/*****************************************************************************

NAME:

   idle.c -- code for interruptible delays without sleep(3).

ENTRY POINTS:

   interruptible_idle() -- delay for some time, interruptible by signal.

THEORY:

   Sometimes you need more than one time delay per program, so alarm(3)

won't cut it.  This code illustrates time delays with select(2).

AUTHOR:

   Eric S. Raymond <esr@thyrsus.com>, 1997.  This source code example

is part of fetchmail and the Unix Cookbook, and are released under the

MIT license.  Compile with -DMAIN to build the demonstrator.

******************************************************************************/

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <signal.h>

#include <errno.h>

#include <fetchmail.h>	/* for ROOT_UID */

#ifndef TRUE

#define TRUE 1

#define FALSE 0

#endif

volatile int lastsig;		/* last signal received */

#ifdef SLEEP_WITH_ALARM

/*

 * The function of this variable is to remove the window during which a

 * SIGALRM can hose the code (ALARM is triggered *before* pause() is called).

 * This is a bit of a kluge; the real right thing would use sigprocmask(),

 * sigsuspend().  This workaround lets the interval timer trigger the first

 * alarm after the required interval and will then generate alarms

 * seconds until it is certain that the critical section (ie., the window)

 * is exited.

 */

static sig_atomic_t	alarm_latch = FALSE;

RETSIGTYPE gotsigalrm(int sig)

{

    set_signal_handler(sig, gotsigalrm);

    lastsig = sig;

    alarm_latch = TRUE;

}

#endif /* SLEEP_WITH_ALARM */

#ifdef __EMX__

/* Various EMX-specific definitions */

static int itimerflag;

void itimerthread(void* dummy)

{

    if (outlevel >= O_VERBOSE)

	report(stderr, 

	       GT_("fetchmail: thread sleeping for %d sec.\n"), poll_interval);

    while(1)

    {

	_sleep2(poll_interval*1000);

	kill((getpid()), SIGALRM);

    }

}

#endif

int interruptible_idle(int seconds)

/* time for a pause in the action; return TRUE if awakened by signal */

{

    int awoken = FALSE;

#ifndef __EMX__

#ifdef SLEEP_WITH_ALARM		/* not normally on */

    /*

     * We can't use sleep(3) here because we need an alarm(3)

     * equivalent in order to implement server nonresponse timeout.

     * We'll just assume setitimer(2) is available since fetchmail

     * has to have a BSDoid socket layer to work at all.

     */

    /* 

     * This code stopped working under glibc-2, apparently due

     * to the change in signal(2) semantics.  (The siginterrupt

     * line, added later, should fix this problem.) John Stracke

     * <francis@netscape.com> wrote:

     *

     * The problem seems to be that, after hitting the interval

     * timer while talking to the server, the process no longer

     * responds to SIGALRM.  I put in printf()s to see when it

     * reached the pause() for the poll interval, and I checked

     * the return from setitimer(), and everything seemed to be

     * working fine, except that the pause() just ignored SIGALRM.

     * I thought maybe the itimer wasn't being fired, so I hit

     * it with a SIGALRM from the command line, and it ignored

     * that, too.  SIGUSR1 woke it up just fine, and it proceeded

     * to repoll--but, when the dummy server didn't respond, it

     * never timed out, and SIGALRM wouldn't make it.

     *

     * (continued below...)

     */

    {

    struct itimerval ntimeout;

    ntimeout.it_interval.tv_sec = 5; /* repeat alarm every 5 secs */

    ntimeout.it_interval.tv_usec = 0;

    ntimeout.it_value.tv_sec  = seconds;

    ntimeout.it_value.tv_usec = 0;

    alarm_latch = FALSE;

    set_signal_handler(SIGALRM, gotsigalrm);	/* first trap signals */

    setitimer(ITIMER_REAL,&ntimeout,NULL);	/* then start timer */

    /* there is a very small window between the next two lines */

    /* which could result in a deadlock.  But this will now be  */

    /* caught by periodic alarms (see it_interval) */

    if (!alarm_latch)

	pause();

    /* stop timer */

    ntimeout.it_interval.tv_sec = ntimeout.it_interval.tv_usec = 0;

    ntimeout.it_value.tv_sec  = ntimeout.it_value.tv_usec = 0;

    setitimer(ITIMER_REAL,&ntimeout,NULL);	/* now stop timer */

    set_signal_handler(SIGALRM, SIG_IGN);

    }

#else

    /* 

     * So the workaround I used is to make it sleep by using

     * select() instead of setitimer()/pause().  select() is

     * perfectly happy being called with a timeout and

     * no file descriptors; it just sleeps until it hits the

     * timeout.  The only concern I had was that it might

     * implement its timeout with SIGALRM--there are some

     * Unices where this is done, because select() is a library

     * function--but apparently not.

     */

    {

    struct timeval timeout;

    timeout.tv_sec = seconds;

    timeout.tv_usec = 0;

    do {

	lastsig = 0;

	select(0,0,0,0, &timeout);

    } while (lastsig == SIGCHLD);

    }

#endif

#else /* EMX */

    alarm_latch = FALSE;

    set_signal_handler(SIGALRM, gotsigalrm);

    _beginthread(itimerthread, NULL, 32768, NULL);

    /* see similar code above */

    if (!alarm_latch)

	pause();

    set_signal_handler(SIGALRM, SIG_IGN);

#endif /* ! EMX */

    if (lastsig == SIGUSR1 || ((seconds && getuid() == ROOT_UID)

	&& lastsig == SIGHUP))

       awoken = TRUE;

    /* now lock out interrupts again */

    set_signal_handler(SIGUSR1, SIG_IGN);

    if (getuid() == ROOT_UID)

	set_signal_handler(SIGHUP, SIG_IGN);

    return(awoken ? lastsig : 0);

}

#ifdef MAIN

int main(int argc, char **argv)

{

    for (;;)

    {

	printf("How may I serve you, master?\n");

	interruptible_idle(5);

    }

}

#endif /* MAIN */

/* idle.c ends here */