Commit 51e6d6b2 authored by Paul Eggert's avatar Paul Eggert

* lib/sigprocmask.c, m4/signalblocking.m4: Remove.

These files have been unused since the 2012-06-22 patch that
introduced high-resolution time stamps.
parent a999ce26
2012-08-18 Paul Eggert <eggert@cs.ucla.edu>
* lib/sigprocmask.c, m4/signalblocking.m4: Remove.
These files have been unused since the 2012-06-22 patch that
introduced high-resolution time stamps.
2012-08-17 Jan Beich <jbeich@tormail.org> (tiny change)
* configure.ac (PTY_OPEN): Try posix_openpt on gnu-linux,
......
......@@ -508,9 +508,6 @@ dup2
lib/signal.h:
signal
lib/sigprocmask.c:
signal
lib/stdio.h:
fdopen
fopen
......
/* POSIX compatible signal blocking.
Copyright (C) 2006-2012 Free Software Foundation, Inc.
Written by Bruno Haible <bruno@clisp.org>, 2006.
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 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
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
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, see <http://www.gnu.org/licenses/>. */
#include <config.h>
/* Specification. */
#include <signal.h>
#include <errno.h>
#include <stdint.h>
#include <stdlib.h>
#if HAVE_MSVC_INVALID_PARAMETER_HANDLER
# include "msvc-inval.h"
#endif
/* 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 native Windows platforms. */
/* 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
/* On native Windows, as of 2008, the signal SIGABRT_COMPAT is an alias
for the signal SIGABRT. Only one signal handler is stored for both
SIGABRT and SIGABRT_COMPAT. SIGABRT_COMPAT is not a signal of its own. */
#if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
# undef SIGABRT_COMPAT
# define SIGABRT_COMPAT 6
#endif
#ifdef SIGABRT_COMPAT
# define SIGABRT_COMPAT_MASK (1U << SIGABRT_COMPAT)
#else
# define SIGABRT_COMPAT_MASK 0
#endif
typedef void (*handler_t) (int);
#if HAVE_MSVC_INVALID_PARAMETER_HANDLER
static inline handler_t
signal_nothrow (int sig, handler_t handler)
{
handler_t result;
TRY_MSVC_INVAL
{
result = signal (sig, handler);
}
CATCH_MSVC_INVAL
{
result = SIG_ERR;
errno = EINVAL;
}
DONE_MSVC_INVAL;
return result;
}
# define signal signal_nothrow
#endif
/* Handling of gnulib defined signals. */
#if GNULIB_defined_SIGPIPE
static handler_t SIGPIPE_handler = SIG_DFL;
#endif
#if GNULIB_defined_SIGPIPE
static handler_t
ext_signal (int sig, handler_t handler)
{
switch (sig)
{
case SIGPIPE:
{
handler_t old_handler = SIGPIPE_handler;
SIGPIPE_handler = handler;
return old_handler;
}
default: /* System defined signal */
return signal (sig, handler);
}
}
# undef signal
# define signal ext_signal
#endif
int
sigismember (const sigset_t *set, int sig)
{
if (sig >= 0 && sig < NSIG)
{
#ifdef SIGABRT_COMPAT
if (sig == SIGABRT_COMPAT)
sig = SIGABRT;
#endif
return (*set >> sig) & 1;
}
else
return 0;
}
int
sigemptyset (sigset_t *set)
{
*set = 0;
return 0;
}
int
sigaddset (sigset_t *set, int sig)
{
if (sig >= 0 && sig < NSIG)
{
#ifdef SIGABRT_COMPAT
if (sig == SIGABRT_COMPAT)
sig = SIGABRT;
#endif
*set |= 1U << sig;
return 0;
}
else
{
errno = EINVAL;
return -1;
}
}
int
sigdelset (sigset_t *set, int sig)
{
if (sig >= 0 && sig < NSIG)
{
#ifdef SIGABRT_COMPAT
if (sig == SIGABRT_COMPAT)
sig = SIGABRT;
#endif
*set &= ~(1U << sig);
return 0;
}
else
{
errno = EINVAL;
return -1;
}
}
int
sigfillset (sigset_t *set)
{
*set = ((2U << (NSIG - 1)) - 1) & ~ SIGABRT_COMPAT_MASK;
return 0;
}
/* Set of currently blocked signals. */
static volatile sigset_t blocked_set /* = 0 */;
/* Set of currently blocked and pending signals. */
static volatile sig_atomic_t pending_array[NSIG] /* = { 0 } */;
/* Signal handler that is installed for blocked signals. */
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;
}
int
sigpending (sigset_t *set)
{
sigset_t pending = 0;
int sig;
for (sig = 0; sig < NSIG; sig++)
if (pending_array[sig])
pending |= 1U << sig;
*set = pending;
return 0;
}
/* The previous signal handlers.
Only the array elements corresponding to blocked signals are relevant. */
static volatile handler_t old_handlers[NSIG];
int
sigprocmask (int operation, const sigset_t *set, sigset_t *old_set)
{
if (old_set != NULL)
*old_set = blocked_set;
if (set != NULL)
{
sigset_t new_blocked_set;
sigset_t to_unblock;
sigset_t to_block;
switch (operation)
{
case SIG_BLOCK:
new_blocked_set = blocked_set | *set;
break;
case SIG_SETMASK:
new_blocked_set = *set;
break;
case SIG_UNBLOCK:
new_blocked_set = blocked_set & ~*set;
break;
default:
errno = EINVAL;
return -1;
}
to_unblock = blocked_set & ~new_blocked_set;
to_block = new_blocked_set & ~blocked_set;
if (to_block != 0)
{
int sig;
for (sig = 0; sig < NSIG; sig++)
if ((to_block >> sig) & 1)
{
pending_array[sig] = 0;
if ((old_handlers[sig] = signal (sig, blocked_handler)) != SIG_ERR)
blocked_set |= 1U << sig;
}
}
if (to_unblock != 0)
{
sig_atomic_t received[NSIG];
int sig;
for (sig = 0; sig < NSIG; sig++)
if ((to_unblock >> sig) & 1)
{
if (signal (sig, old_handlers[sig]) != blocked_handler)
/* The application changed a signal handler while the signal
was blocked, bypassing our rpl_signal replacement.
We don't support this. */
abort ();
received[sig] = pending_array[sig];
blocked_set &= ~(1U << sig);
pending_array[sig] = 0;
}
else
received[sig] = 0;
for (sig = 0; sig < NSIG; sig++)
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)
{
#ifdef SIGABRT_COMPAT
if (sig == SIGABRT_COMPAT)
sig = SIGABRT;
#endif
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;
}
}
#if GNULIB_defined_SIGPIPE
/* Raise the signal SIGPIPE. */
int
_gl_raise_SIGPIPE (void)
{
if (blocked_set & (1U << SIGPIPE))
pending_array[SIGPIPE] = 1;
else
{
handler_t handler = SIGPIPE_handler;
if (handler == SIG_DFL)
exit (128 + SIGPIPE);
else if (handler != SIG_IGN)
(*handler) (SIGPIPE);
}
return 0;
}
#endif
# signalblocking.m4 serial 13
dnl Copyright (C) 2001-2002, 2006-2012 Free Software Foundation, Inc.
dnl This file is free software; the Free Software Foundation
dnl gives unlimited permission to copy and/or distribute it,
dnl with or without modifications, as long as this notice is preserved.
# Determine available signal blocking primitives. Three different APIs exist:
# 1) POSIX: sigemptyset, sigaddset, sigprocmask
# 2) SYSV: sighold, sigrelse
# 3) BSD: sigblock, sigsetmask
# For simplicity, here we check only for the POSIX signal blocking.
AC_DEFUN([gl_SIGNALBLOCKING],
[
AC_REQUIRE([gl_SIGNAL_H_DEFAULTS])
AC_REQUIRE([gl_CHECK_TYPE_SIGSET_T])
if test $gl_cv_type_sigset_t = yes; then
AC_CHECK_FUNC([sigprocmask], [gl_cv_func_sigprocmask=1])
fi
if test -z "$gl_cv_func_sigprocmask"; then
HAVE_POSIX_SIGNALBLOCKING=0
fi
])
# Prerequisites of lib/sigprocmask.c.
AC_DEFUN([gl_PREREQ_SIGPROCMASK], [
AC_REQUIRE([AC_C_INLINE])
])
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment