Home | History | Annotate | Download | only in lib
      1 /* POSIX compatible signal blocking.
      2    Copyright (C) 2006-2012 Free Software Foundation, Inc.
      3    Written by Bruno Haible <bruno (at) clisp.org>, 2006.
      4 
      5    This program is free software: you can redistribute it and/or modify
      6    it under the terms of the GNU General Public License as published by
      7    the Free Software Foundation; either version 3 of the License, or
      8    (at your option) any later version.
      9 
     10    This program is distributed in the hope that it will be useful,
     11    but WITHOUT ANY WARRANTY; without even the implied warranty of
     12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     13    GNU General Public License for more details.
     14 
     15    You should have received a copy of the GNU General Public License
     16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
     17 
     18 #include <config.h>
     19 
     20 /* Specification.  */
     21 #include <signal.h>
     22 
     23 #include <errno.h>
     24 #include <stdint.h>
     25 #include <stdlib.h>
     26 
     27 #if HAVE_MSVC_INVALID_PARAMETER_HANDLER
     28 # include "msvc-inval.h"
     29 #endif
     30 
     31 /* We assume that a platform without POSIX signal blocking functions
     32    also does not have the POSIX sigaction() function, only the
     33    signal() function.  We also assume signal() has SysV semantics,
     34    where any handler is uninstalled prior to being invoked.  This is
     35    true for native Windows platforms.  */
     36 
     37 /* We use raw signal(), but also provide a wrapper rpl_signal() so
     38    that applications can query or change a blocked signal.  */
     39 #undef signal
     40 
     41 /* Provide invalid signal numbers as fallbacks if the uncatchable
     42    signals are not defined.  */
     43 #ifndef SIGKILL
     44 # define SIGKILL (-1)
     45 #endif
     46 #ifndef SIGSTOP
     47 # define SIGSTOP (-1)
     48 #endif
     49 
     50 /* On native Windows, as of 2008, the signal SIGABRT_COMPAT is an alias
     51    for the signal SIGABRT.  Only one signal handler is stored for both
     52    SIGABRT and SIGABRT_COMPAT.  SIGABRT_COMPAT is not a signal of its own.  */
     53 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
     54 # undef SIGABRT_COMPAT
     55 # define SIGABRT_COMPAT 6
     56 #endif
     57 #ifdef SIGABRT_COMPAT
     58 # define SIGABRT_COMPAT_MASK (1U << SIGABRT_COMPAT)
     59 #else
     60 # define SIGABRT_COMPAT_MASK 0
     61 #endif
     62 
     63 typedef void (*handler_t) (int);
     64 
     65 #if HAVE_MSVC_INVALID_PARAMETER_HANDLER
     66 static handler_t
     67 signal_nothrow (int sig, handler_t handler)
     68 {
     69   handler_t result;
     70 
     71   TRY_MSVC_INVAL
     72     {
     73       result = signal (sig, handler);
     74     }
     75   CATCH_MSVC_INVAL
     76     {
     77       result = SIG_ERR;
     78       errno = EINVAL;
     79     }
     80   DONE_MSVC_INVAL;
     81 
     82   return result;
     83 }
     84 # define signal signal_nothrow
     85 #endif
     86 
     87 /* Handling of gnulib defined signals.  */
     88 
     89 #if GNULIB_defined_SIGPIPE
     90 static handler_t SIGPIPE_handler = SIG_DFL;
     91 #endif
     92 
     93 #if GNULIB_defined_SIGPIPE
     94 static handler_t
     95 ext_signal (int sig, handler_t handler)
     96 {
     97   switch (sig)
     98     {
     99     case SIGPIPE:
    100       {
    101         handler_t old_handler = SIGPIPE_handler;
    102         SIGPIPE_handler = handler;
    103         return old_handler;
    104       }
    105     default: /* System defined signal */
    106       return signal (sig, handler);
    107     }
    108 }
    109 # undef signal
    110 # define signal ext_signal
    111 #endif
    112 
    113 int
    114 sigismember (const sigset_t *set, int sig)
    115 {
    116   if (sig >= 0 && sig < NSIG)
    117     {
    118       #ifdef SIGABRT_COMPAT
    119       if (sig == SIGABRT_COMPAT)
    120         sig = SIGABRT;
    121       #endif
    122 
    123       return (*set >> sig) & 1;
    124     }
    125   else
    126     return 0;
    127 }
    128 
    129 int
    130 sigemptyset (sigset_t *set)
    131 {
    132   *set = 0;
    133   return 0;
    134 }
    135 
    136 int
    137 sigaddset (sigset_t *set, int sig)
    138 {
    139   if (sig >= 0 && sig < NSIG)
    140     {
    141       #ifdef SIGABRT_COMPAT
    142       if (sig == SIGABRT_COMPAT)
    143         sig = SIGABRT;
    144       #endif
    145 
    146       *set |= 1U << sig;
    147       return 0;
    148     }
    149   else
    150     {
    151       errno = EINVAL;
    152       return -1;
    153     }
    154 }
    155 
    156 int
    157 sigdelset (sigset_t *set, int sig)
    158 {
    159   if (sig >= 0 && sig < NSIG)
    160     {
    161       #ifdef SIGABRT_COMPAT
    162       if (sig == SIGABRT_COMPAT)
    163         sig = SIGABRT;
    164       #endif
    165 
    166       *set &= ~(1U << sig);
    167       return 0;
    168     }
    169   else
    170     {
    171       errno = EINVAL;
    172       return -1;
    173     }
    174 }
    175 
    176 
    177 int
    178 sigfillset (sigset_t *set)
    179 {
    180   *set = ((2U << (NSIG - 1)) - 1) & ~ SIGABRT_COMPAT_MASK;
    181   return 0;
    182 }
    183 
    184 /* Set of currently blocked signals.  */
    185 static volatile sigset_t blocked_set /* = 0 */;
    186 
    187 /* Set of currently blocked and pending signals.  */
    188 static volatile sig_atomic_t pending_array[NSIG] /* = { 0 } */;
    189 
    190 /* Signal handler that is installed for blocked signals.  */
    191 static void
    192 blocked_handler (int sig)
    193 {
    194   /* Reinstall the handler, in case the signal occurs multiple times
    195      while blocked.  There is an inherent race where an asynchronous
    196      signal in between when the kernel uninstalled the handler and
    197      when we reinstall it will trigger the default handler; oh
    198      well.  */
    199   signal (sig, blocked_handler);
    200   if (sig >= 0 && sig < NSIG)
    201     pending_array[sig] = 1;
    202 }
    203 
    204 int
    205 sigpending (sigset_t *set)
    206 {
    207   sigset_t pending = 0;
    208   int sig;
    209 
    210   for (sig = 0; sig < NSIG; sig++)
    211     if (pending_array[sig])
    212       pending |= 1U << sig;
    213   *set = pending;
    214   return 0;
    215 }
    216 
    217 /* The previous signal handlers.
    218    Only the array elements corresponding to blocked signals are relevant.  */
    219 static volatile handler_t old_handlers[NSIG];
    220 
    221 int
    222 sigprocmask (int operation, const sigset_t *set, sigset_t *old_set)
    223 {
    224   if (old_set != NULL)
    225     *old_set = blocked_set;
    226 
    227   if (set != NULL)
    228     {
    229       sigset_t new_blocked_set;
    230       sigset_t to_unblock;
    231       sigset_t to_block;
    232 
    233       switch (operation)
    234         {
    235         case SIG_BLOCK:
    236           new_blocked_set = blocked_set | *set;
    237           break;
    238         case SIG_SETMASK:
    239           new_blocked_set = *set;
    240           break;
    241         case SIG_UNBLOCK:
    242           new_blocked_set = blocked_set & ~*set;
    243           break;
    244         default:
    245           errno = EINVAL;
    246           return -1;
    247         }
    248       to_unblock = blocked_set & ~new_blocked_set;
    249       to_block = new_blocked_set & ~blocked_set;
    250 
    251       if (to_block != 0)
    252         {
    253           int sig;
    254 
    255           for (sig = 0; sig < NSIG; sig++)
    256             if ((to_block >> sig) & 1)
    257               {
    258                 pending_array[sig] = 0;
    259                 if ((old_handlers[sig] = signal (sig, blocked_handler)) != SIG_ERR)
    260                   blocked_set |= 1U << sig;
    261               }
    262         }
    263 
    264       if (to_unblock != 0)
    265         {
    266           sig_atomic_t received[NSIG];
    267           int sig;
    268 
    269           for (sig = 0; sig < NSIG; sig++)
    270             if ((to_unblock >> sig) & 1)
    271               {
    272                 if (signal (sig, old_handlers[sig]) != blocked_handler)
    273                   /* The application changed a signal handler while the signal
    274                      was blocked, bypassing our rpl_signal replacement.
    275                      We don't support this.  */
    276                   abort ();
    277                 received[sig] = pending_array[sig];
    278                 blocked_set &= ~(1U << sig);
    279                 pending_array[sig] = 0;
    280               }
    281             else
    282               received[sig] = 0;
    283 
    284           for (sig = 0; sig < NSIG; sig++)
    285             if (received[sig])
    286               raise (sig);
    287         }
    288     }
    289   return 0;
    290 }
    291 
    292 /* Install the handler FUNC for signal SIG, and return the previous
    293    handler.  */
    294 handler_t
    295 rpl_signal (int sig, handler_t handler)
    296 {
    297   /* We must provide a wrapper, so that a user can query what handler
    298      they installed even if that signal is currently blocked.  */
    299   if (sig >= 0 && sig < NSIG && sig != SIGKILL && sig != SIGSTOP
    300       && handler != SIG_ERR)
    301     {
    302       #ifdef SIGABRT_COMPAT
    303       if (sig == SIGABRT_COMPAT)
    304         sig = SIGABRT;
    305       #endif
    306 
    307       if (blocked_set & (1U << sig))
    308         {
    309           /* POSIX states that sigprocmask and signal are both
    310              async-signal-safe.  This is not true of our
    311              implementation - there is a slight data race where an
    312              asynchronous interrupt on signal A can occur after we
    313              install blocked_handler but before we have updated
    314              old_handlers for signal B, such that handler A can see
    315              stale information if it calls signal(B).  Oh well -
    316              signal handlers really shouldn't try to manipulate the
    317              installed handlers of unrelated signals.  */
    318           handler_t result = old_handlers[sig];
    319           old_handlers[sig] = handler;
    320           return result;
    321         }
    322       else
    323         return signal (sig, handler);
    324     }
    325   else
    326     {
    327       errno = EINVAL;
    328       return SIG_ERR;
    329     }
    330 }
    331 
    332 #if GNULIB_defined_SIGPIPE
    333 /* Raise the signal SIGPIPE.  */
    334 int
    335 _gl_raise_SIGPIPE (void)
    336 {
    337   if (blocked_set & (1U << SIGPIPE))
    338     pending_array[SIGPIPE] = 1;
    339   else
    340     {
    341       handler_t handler = SIGPIPE_handler;
    342       if (handler == SIG_DFL)
    343         exit (128 + SIGPIPE);
    344       else if (handler != SIG_IGN)
    345         (*handler) (SIGPIPE);
    346     }
    347   return 0;
    348 }
    349 #endif
    350