contrib/cvs-1.12.11/lib/sighandle.c

   1 /* sighandle.c -- Library routines for manipulating chains of signal handlers
   2    Copyright (C) 1992 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.  */
  13
  14 /* Written by Paul Sander, HaL Computer Systems, Inc. <paul@hal.com>
  15    Brian Berliner <berliner@Sun.COM> added POSIX support */
  16
  17 /*************************************************************************
  18  *
  19  * signal.c -- This file contains code that manipulates chains of signal
  20  *             handlers.
  21  *
  22  *             Facilities are provided to register a signal handler for
  23  *             any specific signal.  When a signal is received, all of the
  24  *             registered signal handlers are invoked in the reverse order
  25  *             in which they are registered.  Note that the signal handlers
  26  *             must not themselves make calls to the signal handling
  27  *             facilities.
  28  *
  29  *************************************************************************/
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include "config.h"
  33 #endif
  34 #include "system.h"
  35
  36 #include <sys/types.h>
  37 #include <stdio.h>
  38 #include <signal.h>
  39
  40 #ifdef STDC_HEADERS
  41 #include <stdlib.h>
  42 #else
  43 #if __STDC__
  44 char *calloc(unsigned nelem, unsigned size);
  45 char *malloc(unsigned size);
  46 #else
  47 char *calloc();
  48 char *malloc();
  49 #endif /* __STDC__ */
  50 #endif /* STDC_HEADERS */
  51
  52 /* Define the highest signal number (usually) */
  53 #ifndef SIGMAX
  54 #define SIGMAX  64
  55 #endif
  56
  57 /* Define linked list of signal handlers structure */
  58 struct SIG_hlist {
  59         RETSIGTYPE              (*handler)();
  60         struct SIG_hlist        *next;
  61 };
  62
  63 /*
  64  * Define array of lists of signal handlers.  Note that this depends on
  65  * the implementation to initialize each element to a null pointer.
  66  */
  67
  68 static  struct SIG_hlist        **SIG_handlers;
  69
  70 /* Define array of default signal vectors */
  71
  72 #ifdef POSIX_SIGNALS
  73 static  struct sigaction        *SIG_defaults;
  74 #else
  75 #ifdef BSD_SIGNALS
  76 static  struct sigvec           *SIG_defaults;
  77 #else
  78 static  RETSIGTYPE              (**SIG_defaults) (int);
  79 #endif
  80 #endif
  81
  82 /* Critical section housekeeping */
  83 static  int             SIG_crSectNest = 0;     /* Nesting level */
  84 #ifdef POSIX_SIGNALS
  85 static  sigset_t        SIG_crSectMask;         /* Signal mask */
  86 #else
  87 static  int             SIG_crSectMask;         /* Signal mask */
  88 #endif
  89 \f
  90 /*
  91  * Initialize the signal handler arrays
  92  */
  93
  94 static int SIG_init()
  95 {
  96         int i;
  97 #ifdef POSIX_SIGNALS
  98         sigset_t sigset_test;
  99 #endif
 100
 101         if (SIG_defaults && SIG_handlers)       /* already allocated */
 102                 return (0);
 103
 104 #ifdef POSIX_SIGNALS
 105         (void) sigfillset(&sigset_test);
 106         for (i = 1; i < SIGMAX && sigismember(&sigset_test, i) == 1; i++)
 107                 ;
 108         if (i < SIGMAX)
 109                 i = SIGMAX;
 110         i++;
 111         if (!SIG_defaults)
 112                 SIG_defaults = (struct sigaction *)
 113                         calloc(i, sizeof(struct sigaction));
 114         (void) sigemptyset(&SIG_crSectMask);
 115 #else
 116         i = SIGMAX+1;
 117 #ifdef BSD_SIGNALS
 118         if (!SIG_defaults)
 119                 SIG_defaults = (struct sigvec *)
 120                         calloc(i, sizeof(struct sigvec));
 121 #else
 122         if (!SIG_defaults)
 123                 SIG_defaults = ( RETSIGTYPE (**) (int) )
 124                         calloc( i, sizeof( RETSIGTYPE (**) (int) ) );
 125 #endif
 126         SIG_crSectMask = 0;
 127 #endif
 128         if (!SIG_handlers)
 129                 SIG_handlers = (struct SIG_hlist **)
 130                         calloc(i, sizeof(struct SIG_hlist *));
 131         return (!SIG_defaults || !SIG_handlers);
 132 }
 133
 134
 135
 136 /*
 137  * The following begins a critical section.
 138  */
 139 void SIG_beginCrSect (void)
 140 {
 141         if (SIG_init() == 0)
 142         {
 143                 if (SIG_crSectNest == 0)
 144                 {
 145 #ifdef POSIX_SIGNALS
 146                         sigset_t sigset_mask;
 147
 148                         (void) sigfillset(&sigset_mask);
 149                         (void) sigprocmask(SIG_SETMASK,
 150                                            &sigset_mask, &SIG_crSectMask);
 151 #else
 152 #ifdef BSD_SIGNALS
 153                         SIG_crSectMask = sigblock(~0);
 154 #else
 155                         /* TBD */
 156 #endif
 157 #endif
 158                 }
 159                 SIG_crSectNest++;
 160         }
 161 }
 162
 163
 164
 165 /*
 166  * The following ends a critical section.
 167  */
 168 void SIG_endCrSect (void)
 169 {
 170         if (SIG_init() == 0)
 171         {
 172                 SIG_crSectNest--;
 173                 if (SIG_crSectNest == 0)
 174                 {
 175 #ifdef POSIX_SIGNALS
 176                         (void) sigprocmask(SIG_SETMASK, &SIG_crSectMask, NULL);
 177 #else
 178 #ifdef BSD_SIGNALS
 179                         (void) sigsetmask(SIG_crSectMask);
 180 #else
 181                         /* TBD */
 182 #endif
 183 #endif
 184                 }
 185         }
 186 }
 187
 188
 189
 190 /*
 191  * The following invokes each signal handler in the reverse order in which
 192  * they were registered.
 193  */
 194 static RETSIGTYPE SIG_handle (int sig)
 195 {
 196         struct SIG_hlist        *this;
 197
 198         /* Dispatch signal handlers */
 199         /* This crit section stuff is a CVSism - we know that our interrupt
 200          * handlers will always end up exiting and we don't want them to be
 201          * interrupted themselves.
 202          */
 203         SIG_beginCrSect();
 204         this = SIG_handlers[sig];
 205         while (this != (struct SIG_hlist *) NULL)
 206         {
 207                 (*this->handler)(sig);
 208                 this = this->next;
 209         }
 210         SIG_endCrSect();
 211
 212         return;
 213 }
 214 \f
 215 /*
 216  * The following registers a signal handler.  If the handler is already
 217  * registered, it is not registered twice, nor is the order in which signal
 218  * handlers are invoked changed.  If this is the first signal handler
 219  * registered for a given signal, the old sigvec structure is saved for
 220  * restoration later.
 221  */
 222
 223 int SIG_register(int sig, RETSIGTYPE (*fn)())
 224 {
 225         int                     val;
 226         struct SIG_hlist        *this;
 227 #ifdef POSIX_SIGNALS
 228         struct sigaction        act;
 229         sigset_t                sigset_mask, sigset_omask;
 230 #else
 231 #ifdef BSD_SIGNALS
 232         struct sigvec           vec;
 233         int                     mask;
 234 #endif
 235 #endif
 236
 237         /* Initialize */
 238         if (SIG_init() != 0)
 239                 return (-1);
 240         val = 0;
 241
 242         /* Block this signal while we look at handler chain */
 243 #ifdef POSIX_SIGNALS
 244         (void) sigemptyset(&sigset_mask);
 245         (void) sigaddset(&sigset_mask, sig);
 246         (void) sigprocmask(SIG_BLOCK, &sigset_mask, &sigset_omask);
 247 #else
 248 #ifdef BSD_SIGNALS
 249         mask = sigblock(sigmask(sig));
 250 #endif
 251 #endif
 252
 253         /* See if this handler was already registered */
 254         this = SIG_handlers[sig];
 255         while (this != (struct SIG_hlist *) NULL)
 256         {
 257                 if (this->handler == fn) break;
 258                 this = this->next;
 259         }
 260
 261         /* Register the new handler only if it is not already registered. */
 262         if (this == (struct SIG_hlist *) NULL)
 263         {
 264
 265                 /*
 266                  * If this is the first handler registered for this signal,
 267                  * set up the signal handler dispatcher
 268                  */
 269
 270                 if (SIG_handlers[sig] == (struct SIG_hlist *) NULL)
 271                 {
 272 #ifdef POSIX_SIGNALS
 273                         act.sa_handler = SIG_handle;
 274                         (void) sigemptyset(&act.sa_mask);
 275                         act.sa_flags = 0;
 276                         val = sigaction(sig, &act, &SIG_defaults[sig]);
 277 #else
 278 #ifdef BSD_SIGNALS
 279                         memset (&vec, 0, sizeof (vec));
 280                         vec.sv_handler = SIG_handle;
 281                         val = sigvec(sig, &vec, &SIG_defaults[sig]);
 282 #else
 283                         if ((SIG_defaults[sig] = signal(sig, SIG_handle)) == SIG_ERR)
 284                                 val = -1;
 285 #endif
 286 #endif
 287                 }
 288
 289                 /* If not, register it */
 290                 if ((val == 0) && (this == (struct SIG_hlist *) NULL))
 291                 {
 292                         this = (struct SIG_hlist *)
 293                                               malloc(sizeof(struct SIG_hlist));
 294                         if (this == NULL)
 295                         {
 296                                 val = -1;
 297                         }
 298                         else
 299                         {
 300                                 this->handler = fn;
 301                                 this->next = SIG_handlers[sig];
 302                                 SIG_handlers[sig] = this;
 303                         }
 304                 }
 305         }
 306
 307         /* Unblock the signal */
 308 #ifdef POSIX_SIGNALS
 309         (void) sigprocmask(SIG_SETMASK, &sigset_omask, NULL);
 310 #else
 311 #ifdef BSD_SIGNALS
 312         (void) sigsetmask(mask);
 313 #endif
 314 #endif
 315
 316         return val;
 317 }
 318
 319
 320
 321 /*
 322  * The following deregisters a signal handler.  If the last signal handler for
 323  * a given signal is deregistered, the default sigvec information is restored.
 324  */
 325
 326 int SIG_deregister(int sig, RETSIGTYPE (*fn)())
 327 {
 328         int                     val;
 329         struct SIG_hlist        *this;
 330         struct SIG_hlist        *last;
 331 #ifdef POSIX_SIGNALS
 332         sigset_t                sigset_mask, sigset_omask;
 333 #else
 334 #ifdef BSD_SIGNALS
 335         int                     mask;
 336 #endif
 337 #endif
 338
 339         /* Initialize */
 340         if (SIG_init() != 0)
 341                 return (-1);
 342         val = 0;
 343         last = (struct SIG_hlist *) NULL;
 344
 345         /* Block this signal while we look at handler chain */
 346 #ifdef POSIX_SIGNALS
 347         (void) sigemptyset(&sigset_mask);
 348         (void) sigaddset(&sigset_mask, sig);
 349         (void) sigprocmask(SIG_BLOCK, &sigset_mask, &sigset_omask);
 350 #else
 351 #ifdef BSD_SIGNALS
 352         mask = sigblock(sigmask(sig));
 353 #endif
 354 #endif
 355
 356         /* Search for the signal handler */
 357         this = SIG_handlers[sig];
 358         while ((this != (struct SIG_hlist *) NULL) && (this->handler != fn))
 359         {
 360                 last = this;
 361                 this = this->next;
 362         }
 363
 364         /* If it was registered, remove it */
 365         if (this != (struct SIG_hlist *) NULL)
 366         {
 367                 if (last == (struct SIG_hlist *) NULL)
 368                 {
 369                         SIG_handlers[sig] = this->next;
 370                 }
 371                 else
 372                 {
 373                         last->next = this->next;
 374                 }
 375                 free((char *) this);
 376         }
 377
 378         /* Restore default behavior if there are no registered handlers */
 379         if (SIG_handlers[sig] == (struct SIG_hlist *) NULL)
 380         {
 381 #ifdef POSIX_SIGNALS
 382                 val = sigaction(sig, &SIG_defaults[sig],
 383                                 (struct sigaction *) NULL);
 384 #else
 385 #ifdef BSD_SIGNALS
 386                 val = sigvec(sig, &SIG_defaults[sig], (struct sigvec *) NULL);
 387 #else
 388                 if (signal(sig, SIG_defaults[sig]) == SIG_ERR)
 389                         val = -1;
 390 #endif
 391 #endif
 392         }
 393
 394         /* Unblock the signal */
 395 #ifdef POSIX_SIGNALS
 396         (void) sigprocmask(SIG_SETMASK, &sigset_omask, NULL);
 397 #else
 398 #ifdef BSD_SIGNALS
 399         (void) sigsetmask(mask);
 400 #endif
 401 #endif
 402
 403         return val;
 404 }
 405
 406
 407
 408 /*
 409  * Return nonzero if currently in a critical section.
 410  * Otherwise return zero.
 411  */
 412
 413 int SIG_inCrSect (void)
 414 {
 415         return SIG_crSectNest > 0;
 416 }