X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;f=lib%2Fsigprocmask.c;h=d6daca6ae2157b713efed0e0ea4f5b75d8a8a498;hb=6fe332a17fb940b8f7d988ec48968c6316c73ec6;hp=149d27003afa4fb97fc033dd36d50ba642fad66c;hpb=fa9f85a436cb8239695046be4feb68211fe71af1;p=gnulib.git

diff --git a/lib/sigprocmask.c b/lib/sigprocmask.c
index 149d27003..d6daca6ae 100644
--- a/lib/sigprocmask.c
+++ b/lib/sigprocmask.c
@@ -1,11 +1,11 @@
 /* POSIX compatible signal blocking.
-   Copyright (C) 2006 Free Software Foundation, Inc.
+   Copyright (C) 2006-2008 Free Software Foundation, Inc.
    Written by Bruno Haible <bruno@clisp.org>, 2006.
 
-   This program is free software; you can redistribute it and/or modify
+   This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -13,24 +13,37 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software Foundation,
-   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>
 
 /* Specification.  */
-#include "sigprocmask.h"
+#include <signal.h>
 
 #include <errno.h>
 #include <stdint.h>
 #include <stdlib.h>
 
-/* We assume that a platform without POSIX signal blocking functions also
-   does not have the POSIX sigaction() function, only the signal() function.
-   This is true for Woe32 platforms.  */
+/* We assume that a platform without POSIX signal blocking functions
+   also does not have the POSIX sigaction() function, only the
+   signal() function.  We also assume signal() has SysV semantics,
+   where any handler is uninstalled prior to being invoked.  This is
+   true for Woe32 platforms.  */
 
-/* A signal handler.  */
-typedef void (*handler_t) (int signal);
+/* We use raw signal(), but also provide a wrapper rpl_signal() so
+   that applications can query or change a blocked signal.  */
+#undef signal
+
+/* Provide invalid signal numbers as fallbacks if the uncatchable
+   signals are not defined.  */
+#ifndef SIGKILL
+# define SIGKILL (-1)
+#endif
+#ifndef SIGSTOP
+# define SIGSTOP (-1)
+#endif
+
+typedef void (*handler_t) (int);
 
 int
 sigismember (const sigset_t *set, int sig)
@@ -86,7 +99,7 @@ sigfillset (sigset_t *set)
 }
 
 /* Set of currently blocked signals.  */
-static sigset_t blocked_set /* = 0 */;
+static volatile sigset_t blocked_set /* = 0 */;
 
 /* Set of currently blocked and pending signals.  */
 static volatile sig_atomic_t pending_array[NSIG] /* = { 0 } */;
@@ -95,6 +108,12 @@ static volatile sig_atomic_t pending_array[NSIG] /* = { 0 } */;
 static void
 blocked_handler (int sig)
 {
+  /* Reinstall the handler, in case the signal occurs multiple times
+     while blocked.  There is an inherent race where an asynchronous
+     signal in between when the kernel uninstalled the handler and
+     when we reinstall it will trigger the default handler; oh
+     well.  */
+  signal (sig, blocked_handler);
   if (sig >= 0 && sig < NSIG)
     pending_array[sig] = 1;
 }
@@ -108,12 +127,13 @@ sigpending (sigset_t *set)
   for (sig = 0; sig < NSIG; sig++)
     if (pending_array[sig])
       pending |= 1U << sig;
-  return pending;
+  *set = pending;
+  return 0;
 }
 
 /* The previous signal handlers.
    Only the array elements corresponding to blocked signals are relevant.  */
-static handler_t old_handlers[NSIG];
+static volatile handler_t old_handlers[NSIG];
 
 int
 sigprocmask (int operation, const sigset_t *set, sigset_t *old_set)
@@ -168,7 +188,8 @@ sigprocmask (int operation, const sigset_t *set, sigset_t *old_set)
 	      {
 		if (signal (sig, old_handlers[sig]) != blocked_handler)
 		  /* The application changed a signal handler while the signal
-		     was blocked.  We don't support this.  */
+		     was blocked, bypassing our rpl_signal replacement.
+		     We don't support this.  */
 		  abort ();
 		received[sig] = pending_array[sig];
 		blocked_set &= ~(1U << sig);
@@ -178,15 +199,44 @@ sigprocmask (int operation, const sigset_t *set, sigset_t *old_set)
 	      received[sig] = 0;
 
 	  for (sig = 0; sig < NSIG; sig++)
-	    if (received[NSIG])
-	      {
-		#if HAVE_RAISE
-		raise (sig);
-		#else
-		kill (getpid (), sig);
-		#endif
-	      }
+	    if (received[sig])
+	      raise (sig);
 	}
     }
   return 0;
 }
+
+/* Install the handler FUNC for signal SIG, and return the previous
+   handler.  */
+handler_t
+rpl_signal (int sig, handler_t handler)
+{
+  /* We must provide a wrapper, so that a user can query what handler
+     they installed even if that signal is currently blocked.  */
+  if (sig >= 0 && sig < NSIG && sig != SIGKILL && sig != SIGSTOP
+      && handler != SIG_ERR)
+    {
+      if (blocked_set & (1U << sig))
+	{
+	  /* POSIX states that sigprocmask and signal are both
+	     async-signal-safe.  This is not true of our
+	     implementation - there is a slight data race where an
+	     asynchronous interrupt on signal A can occur after we
+	     install blocked_handler but before we have updated
+	     old_handlers for signal B, such that handler A can see
+	     stale information if it calls signal(B).  Oh well -
+	     signal handlers really shouldn't try to manipulate the
+	     installed handlers of unrelated signals.  */
+	  handler_t result = old_handlers[sig];
+	  old_handlers[sig] = handler;
+	  return result;
+	}
+      else
+	return signal (sig, handler);
+    }
+  else
+    {
+      errno = EINVAL;
+      return SIG_ERR;
+    }
+}