alarm.cpp

Go to the documentation of this file.

 
// expand _TEST_EXPORT macros
#define _RWSTD_TEST_SRC
 
// including <time.h> first works around a SunPro/SunOS bug (PR #26255)
#include <time.h>     // for time_t
 
#include <assert.h>   // for assert()
#include <stdio.h>    // for sprintf()
 
#include <rw_alarm.h>    // for rw_alarm()
#include <rw_printf.h>   // for rw_fprintf()
 
 
// avoid re-declaring the constants below extern exported to prevent
// MSVC error: object must have external linkage in order to be
// exported/imported
 
/* extern _TEST_EXPORT */ rw_signal_handler_t* const
rw_sig_dfl = (rw_signal_handler_t*)0;
 
/* extern _TEST_EXPORT */ rw_signal_handler_t* const
rw_sig_ign = (rw_signal_handler_t*)1;
 
/* extern _TEST_EXPORT */ rw_signal_handler_t* const
rw_sig_hold = (rw_signal_handler_t*)2;
 
/* extern _TEST_EXPORT */ rw_signal_handler_t* const
rw_sig_restore = (rw_signal_handler_t*)3;
 
 
// may point to a user-defined handler for the alarm
static rw_signal_handler_t*
_rw_alarm_handler;
 
 
#ifdef _WIN32
 
#include <windows.h>
 
// CygWin doesn't seem to define alarm()...
 
// thread procedure
static DWORD WINAPI
_rw_alarm_proc (LPVOID arg /* seconds */)
{
    Sleep (1000U * (ULONG)arg);
 
    rw_fprintf (rw_stderr, "%s:%d alarm expired\n", __FILE__, __LINE__);
 
    if (_rw_alarm_handler)
        _rw_alarm_handler (0);
    else
        abort ();   // no SIGALRM on Win32
 
    return 0;
}
 
 
// rough equivalent of POSIX alarm
_TEST_EXPORT
unsigned int
rw_alarm (unsigned int nsec, rw_signal_handler_t* handler /* = 0 */)
{
    static HANDLE thread    = 0;   // thread handle (one alarm per process)
    static unsigned pending = 0;   // previous alarm() argument
    static time_t t0        = 0;   // start of previous alarm()
    time_t unslept          = 0;   // seconds until previous alarm expires
 
    if (thread) {
        // previous alarm is still pending, cancel it
        unslept = pending - (time (0) - t0);
        TerminateThread (thread, 0);
        CloseHandle (thread);
        thread = 0;
    }
 
    pending = nsec;
 
    if (nsec) {
        time (&t0);   // keep track of when countdown started
 
        if (handler) {
            // take care not to overwrite any previously set handler
            _rw_alarm_handler = handler;
        }
 
        DWORD tid;    // dummy (not used, required on Win95)
        thread = CreateThread (0, 0, _rw_alarm_proc, (LPVOID)nsec, 0, &tid);
        // thread handle will leak unless alarm (0) is called
    }
 
    return unsigned (unslept);
}
 
 
#else   // ifndef _WIN32
 
#  include <signal.h>   // for SIGALRM, signal()
#  include <unistd.h>   // for alarm(), write()
 
   // define macros in case they aren't #defined by
   // the system headers e.g., when using pure libc headers
#  ifndef SIGALRM
#    define SIGALRM   14   /* e.g., Solaris */
#  endif
 
#  ifndef SIG_DFL
#    define SIG_DFL (rw_signal_handler_t*)0
#  endif   // SIG_DFL
 
#  ifndef SIG_IGN
#    define SIG_IGN (rw_signal_handler_t*)1
#  endif   // SIG_IGN
 
#  ifndef SIG_HOLD
#    define SIG_HOLD (rw_signal_handler_t*)2
#  endif   // SIG_HOLD
 
 
extern "C" {
 
static void
_rw_handle_sigalrm (int signo)
{
    assert (SIGALRM == signo);
 
    char buffer [1024];
 
    // fprintf() is not async-signal safe...
    const int len =
        sprintf (buffer, "%s:%d: alarm expired\n", __FILE__, __LINE__);
 
    // ...use write() instead
    write (STDERR_FILENO, buffer, size_t (len));
 
    if (_rw_alarm_handler)
        _rw_alarm_handler (signo);
}
 
}   // extern "C"
 
 
_TEST_EXPORT
unsigned
rw_alarm (unsigned int nsec, rw_signal_handler_t* handler /* = 0 */)
{
    static rw_signal_handler_t* saved_handler = 0;
    static unsigned             saved_nsec    = 0;
 
    if (rw_sig_hold == handler) {
        // hold and save the current SIGALRM handler
        // and just retrieve the current alarm
        saved_handler = signal (SIGALRM, (rw_signal_handler_t*)SIG_HOLD);
        saved_nsec    = alarm (0);
 
        alarm (saved_nsec);
 
        return saved_nsec;
    }
 
    if (rw_sig_restore == handler) {
        // restore the previously saved SIGALRM handler
        // and set a new alarm to go off approximately
        // after (saved_nsec - nsec) seconds
 
        if (saved_handler) {
            signal (SIGALRM, saved_handler);
 
            if (nsec < saved_nsec)
                nsec = saved_nsec - nsec;
            else
                nsec = 1;
 
            alarm (nsec);
 
            // return the new timeout
            return nsec;
        }
 
        // return 0 to indicate that no alarm was set
        return 0;
    }
 
    if (rw_sig_dfl == handler) {
        signal (SIGALRM, (rw_signal_handler_t*)SIG_DFL);
    }
    else if (rw_sig_ign == handler) {
        signal (SIGALRM, (rw_signal_handler_t*)SIG_IGN);
    }
    else if (handler) {
        // take care not to overwrite any previously set handler
        _rw_alarm_handler = handler;
        signal (SIGALRM, _rw_handle_sigalrm);
    }
 
    return alarm (nsec);
}
 
 
#endif   // _WIN32