fetchmail - [fork] set imap idle timeout to 600s, some servers don't follow rfc recommendations

	Commit message (Expand)	Author	Age	Files	Lines
*	Add .mailmap file.	Matthias Andree	2011-05-04	1	-0/+1

/***************************************************************************** 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 */