code.delx.au - gnu-emacs/blob - lib-src/timer.c

   1 /* timer.c --- daemon to provide a tagged interval timer service
   2
   3    This little daemon runs forever waiting for commands to schedule events.
   4    SIGALRM causes
   5    it to check its queue for events attached to the current second; if
   6    one is found, its label is written to stdout.  SIGTERM causes it to
   7    terminate, printing a list of pending events.
   8
   9    This program is intended to be used with the lisp package called
  10    timer.el.  The first such program was written anonymously in 1990.
  11    This version was documented and rewritten for portability by
  12    esr@snark.thyrsus.com, Aug 7 1992.  */
  13
  14 #include <stdio.h>
  15 #include <signal.h>
  16 #include <errno.h>
  17 #include <sys/types.h>  /* time_t */
  18
  19 #include <../src/config.h>
  20 #undef read
  21
  22 #ifdef LINUX
  23 /* Perhaps this is correct unconditionally.  */
  24 #undef signal
  25 #endif
  26 #ifdef _CX_UX
  27 /* I agree with the comment above, this probably should be unconditional (it
  28  * is already unconditional in a couple of other files in this directory),
  29  * but in the spirit of minimizing the effects of my port, I am making it
  30  * conditional on _CX_UX.
  31  */
  32 #undef signal
  33 #endif
  34
  35
  36 extern int errno;
  37 extern char *strerror ();
  38 extern time_t time ();
  39
  40 /*
  41  * The field separator for input.  This character shouldn't occur in dates,
  42  * and should be printable so event strings are readable by people.
  43  */
  44 #define FS '@'
  45
  46 struct event
  47   {
  48     char *token;
  49     time_t reply_at;
  50   };
  51 int events_size;                /* How many slots have we allocated?  */
  52 int num_events;                 /* How many are actually scheduled?  */
  53 struct event *events;           /* events[0 .. num_events-1] are the
  54                                    valid events.  */
  55
  56 char *pname;      /* program name for error messages */
  57
  58 /* This buffer is used for reading commands.
  59    We make it longer when necessary, but we never free it.  */
  60 char *buf;
  61 /* This is the allocated size of buf.  */
  62 int buf_size;
  63
  64 /* Non-zero means don't handle an alarm now;
  65    instead, just set alarm_deferred if an alarm happens.
  66    We set this around parts of the program that call malloc and free.  */
  67 int defer_alarms;
  68
  69 /* Non-zero if an alarm came in during the reading of a command.  */
  70 int alarm_deferred;
  71 \f
  72 /* Schedule one event, and arrange an alarm for it.
  73    STR is a string of two fields separated by FS.
  74    First field is string for get_date, saying when to wake-up.
  75    Second field is a token to identify the request.  */
  76
  77 void
  78 schedule (str)
  79      char *str;
  80 {
  81   extern time_t get_date ();
  82   extern char *strcpy ();
  83   time_t now;
  84   register char *p;
  85   static struct event *ep;
  86
  87   /* check entry format */
  88   for (p = str; *p && *p != FS; p++)
  89     continue;
  90   if (!*p)
  91     {
  92       fprintf (stderr, "%s: bad input format: %s\n", pname, str);
  93       return;
  94     }
  95   *p++ = 0;
  96
  97   /* allocate an event slot */
  98   ep = events + num_events;
  99
 100   /* If the event array is full, stretch it.  After stretching, we know
 101      that ep will be pointing to an available event spot.  */
 102   if (ep == events + events_size)
 103     {
 104       int old_size = events_size;
 105
 106       events_size *= 2;
 107       events = ((struct event *)
 108                 realloc (events, events_size * sizeof (struct event)));
 109       if (! events)
 110         {
 111           fprintf (stderr, "%s: virtual memory exhausted.\n", pname);
 112           /* Since there is so much virtual memory, and running out
 113              almost surely means something is very very wrong,
 114              it is best to exit rather than continue.  */
 115           exit (1);
 116         }
 117
 118       while (old_size < events_size)
 119         events[old_size++].token = NULL;
 120     }
 121
 122   /* Don't allow users to schedule events in past time.  */
 123   ep->reply_at = get_date (str, NULL);
 124   if (ep->reply_at - time (&now) < 0)
 125     {
 126       fprintf (stderr, "%s: bad time spec: %s%c%s\n", pname, str, FS, p);
 127       return;
 128     }
 129
 130   /* save the event description */
 131   ep->token = (char *) malloc ((unsigned) strlen (p) + 1);
 132   if (! ep->token)
 133     {
 134       fprintf (stderr, "%s: malloc %s: %s%c%s\n",
 135                pname, strerror (errno), str, FS, p);
 136       return;
 137     }
 138
 139   strcpy (ep->token, p);
 140   num_events++;
 141 }
 142 \f
 143 /* Print the notification for the alarmed event just arrived if any,
 144    and schedule an alarm for the next event if any.  */
 145
 146 void
 147 notify ()
 148 {
 149   time_t now, tdiff, waitfor = -1;
 150   register struct event *ep;
 151
 152   /* Inhibit interference with alarms while changing global vars.  */
 153   defer_alarms = 1;
 154   alarm_deferred = 0;
 155
 156   now = time ((time_t *) NULL);
 157
 158   for (ep = events; ep < events + num_events; ep++)
 159     /* Are any events ready to fire?  */
 160     if (ep->reply_at <= now)
 161       {
 162         fputs (ep->token, stdout);
 163         putc ('\n', stdout);
 164         fflush (stdout);
 165         free (ep->token);
 166
 167         /* We now have a hole in the event array; fill it with the last
 168            event.  */
 169         ep->token = events[num_events - 1].token;
 170         ep->reply_at = events[num_events - 1].reply_at;
 171         num_events--;
 172
 173         /* We ought to scan this event again.  */
 174         ep--;
 175       }
 176     else
 177       {
 178         /* next timeout should be the soonest of any remaining */
 179         if ((tdiff = ep->reply_at - now) < waitfor || waitfor < 0)
 180           waitfor = (long)tdiff;
 181       }
 182
 183   /* If there are no more events, we needn't bother setting an alarm.  */
 184   if (num_events > 0)
 185     alarm (waitfor);
 186
 187   /* Now check if there was another alarm
 188      while we were handling an explicit request.  */
 189   defer_alarms = 0;
 190   if (alarm_deferred)
 191     notify ();
 192   alarm_deferred = 0;
 193 }
 194 \f
 195 /* Read one command from command from standard input
 196    and schedule the event for it.  */
 197
 198 void
 199 getevent ()
 200 {
 201   int i;
 202   int n_events;
 203
 204   /* In principle the itimer should be disabled on entry to this
 205      function, but it really doesn't make any important difference
 206      if it isn't.  */
 207
 208   if (buf == 0)
 209     {
 210       buf_size = 80;
 211       buf = (char *) malloc (buf_size);
 212     }
 213
 214   /* Read a line from standard input, expanding buf if it is too short
 215      to hold the line.  */
 216   for (i = 0; ; i++)
 217     {
 218       char c;
 219       int nread;
 220
 221       if (i >= buf_size)
 222         {
 223           buf_size *= 2;
 224           alarm_deferred = 0;
 225           defer_alarms = 1;
 226           buf = (char *) realloc (buf, buf_size);
 227           defer_alarms = 0;
 228           if (alarm_deferred)
 229             notify ();
 230           alarm_deferred = 0;
 231         }
 232
 233       /* Read one character into c.  */
 234       while (1)
 235         {
 236           nread = read (fileno (stdin), &c, 1);
 237
 238           /* Retry after transient error.  */
 239           if (nread < 0
 240               && (1
 241 #ifdef EINTR
 242                   || errno == EINTR
 243 #endif
 244 #ifdef EAGAIN
 245                   || errno == EAGAIN
 246 #endif
 247                   ))
 248             continue;
 249
 250           /* Report serious errors.  */
 251           if (nread < 0)
 252             {
 253               perror ("read");
 254               exit (1);
 255             }
 256
 257           /* On eof, exit.  */
 258           if (nread == 0)
 259             exit (0);
 260
 261           break;
 262         }
 263
 264       if (c == '\n')
 265         {
 266           buf[i] = '\0';
 267           break;
 268         }
 269
 270       buf[i] = c;
 271     }
 272
 273   /* Register the event.  */
 274   alarm_deferred = 0;
 275   defer_alarms = 1;
 276   schedule (buf);
 277   defer_alarms = 0;
 278   notify ();
 279   alarm_deferred = 0;
 280 }
 281
 282 /* Handle incoming signal SIG.  */
 283
 284 SIGTYPE
 285 sigcatch (sig)
 286      int sig;
 287 {
 288   struct event *ep;
 289
 290   /* required on older UNIXes; harmless on newer ones */
 291   signal (sig, sigcatch);
 292
 293   switch (sig)
 294     {
 295     case SIGALRM:
 296       if (defer_alarms)
 297         alarm_deferred = 1;
 298       else
 299         notify ();
 300       break;
 301     case SIGTERM:
 302       fprintf (stderr, "Events still queued:\n");
 303       for (ep = events; ep < events + num_events; ep++)
 304         fprintf (stderr, "%d = %ld @ %s\n",
 305                  ep - events, ep->reply_at, ep->token);
 306       exit (0);
 307       break;
 308     }
 309 }
 310
 311 /*ARGSUSED*/
 312 int
 313 main (argc, argv)
 314      int argc;
 315      char **argv;
 316 {
 317   for (pname = argv[0] + strlen (argv[0]);
 318        *pname != '/' && pname != argv[0];
 319        pname--);
 320   if (*pname == '/')
 321     pname++;
 322
 323   events_size = 16;
 324   events = ((struct event *) malloc (events_size * sizeof (*events)));
 325   num_events = 0;
 326
 327   signal (SIGALRM, sigcatch);
 328   signal (SIGTERM, sigcatch);
 329
 330   /* Loop reading commands from standard input
 331      and scheduling alarms accordingly.
 332      The alarms are handled asynchronously, while we wait for commands.  */
 333   while (1)
 334     getevent ();
 335 }
 336 \f
 337 #ifndef HAVE_STRERROR
 338 char *
 339 strerror (errnum)
 340      int errnum;
 341 {
 342   extern char *sys_errlist[];
 343   extern int sys_nerr;
 344
 345   if (errnum >= 0 && errnum < sys_nerr)
 346     return sys_errlist[errnum];
 347   return (char *) "Unknown error";
 348 }
 349
 350 #endif /* ! HAVE_STRERROR */
 351
 352 long *
 353 xmalloc (size)
 354      int size;
 355 {
 356   register long *val;
 357
 358   val = (long *) malloc (size);
 359
 360   if (!val && size)
 361     {
 362       fprintf (stderr, "timer: virtual memory exceeded\n");
 363       exit (1);
 364     }
 365
 366   return val;
 367 }
 368
 369 /* timer.c ends here */