#include "config.h"
#if defined (HAVE_UNISTD_H)
# include <unistd.h>
#endif
#include "bashtypes.h"
#include "bashansi.h"
#include <stdio.h>
#include <errno.h>
#include "trap.h"
#include "shell.h"
#include "input.h"
#include "signames.h"
#include "builtins.h"
#include "builtins/common.h"
#include "builtins/builtext.h"
#ifndef errno
extern int errno;
#endif
#define SIG_INHERITED 0x0
#define SIG_TRAPPED 0x1
#define SIG_HARD_IGNORE 0x2
#define SIG_SPECIAL 0x4
#define SIG_NO_TRAP 0x8
#define SIG_INPROGRESS 0x10
#define SIG_CHANGED 0x20
#define SIG_IGNORED 0x40
#define SPECIAL_TRAP(s) ((s) == EXIT_TRAP || (s) == DEBUG_TRAP || (s) == ERROR_TRAP)
static int sigmodes[BASH_NSIG];
static void free_trap_command __P((int));
static void change_signal __P((int, char *));
static void get_original_signal __P((int));
static void _run_trap_internal __P((int, char *));
static void reset_signal __P((int));
static void restore_signal __P((int));
static void reset_or_restore_signal_handlers __P((sh_resetsig_func_t *));
extern int interrupt_immediately;
extern int last_command_exit_value;
extern int line_number;
extern sh_builtin_func_t *this_shell_builtin;
extern procenv_t wait_intr_buf;
SigHandler *original_signals[NSIG];
char *trap_list[BASH_NSIG];
int pending_traps[NSIG];
int running_trap;
int trap_line_number;
int wait_signal_received;
#define IMPOSSIBLE_TRAP_HANDLER (SigHandler *)initialize_traps
void
initialize_traps ()
{
register int i;
trap_list[EXIT_TRAP] = trap_list[DEBUG_TRAP] = trap_list[ERROR_TRAP] = (char *)NULL;
sigmodes[EXIT_TRAP] = sigmodes[DEBUG_TRAP] = sigmodes[ERROR_TRAP] = SIG_INHERITED;
original_signals[EXIT_TRAP] = IMPOSSIBLE_TRAP_HANDLER;
for (i = 1; i < NSIG; i++)
{
pending_traps[i] = 0;
trap_list[i] = (char *)DEFAULT_SIG;
sigmodes[i] = SIG_INHERITED;
original_signals[i] = IMPOSSIBLE_TRAP_HANDLER;
}
#if defined (SIGCHLD)
original_signals[SIGCHLD] =
(SigHandler *) set_signal_handler (SIGCHLD, SIG_DFL);
set_signal_handler (SIGCHLD, original_signals[SIGCHLD]);
sigmodes[SIGCHLD] |= (SIG_SPECIAL | SIG_NO_TRAP);
#endif
original_signals[SIGINT] =
(SigHandler *) set_signal_handler (SIGINT, SIG_DFL);
set_signal_handler (SIGINT, original_signals[SIGINT]);
sigmodes[SIGINT] |= SIG_SPECIAL;
#if defined (__BEOS__)
original_signals[SIGINT] = SIG_DFL;
#endif
original_signals[SIGQUIT] =
(SigHandler *) set_signal_handler (SIGQUIT, SIG_DFL);
set_signal_handler (SIGQUIT, original_signals[SIGQUIT]);
sigmodes[SIGQUIT] |= SIG_SPECIAL;
if (interactive)
{
original_signals[SIGTERM] =
(SigHandler *)set_signal_handler (SIGTERM, SIG_DFL);
set_signal_handler (SIGTERM, original_signals[SIGTERM]);
sigmodes[SIGTERM] |= SIG_SPECIAL;
}
}
#ifdef INCLUDE_UNUSED
static char *
trap_handler_string (sig)
int sig;
{
if (trap_list[sig] == (char *)DEFAULT_SIG)
return "DEFAULT_SIG";
else if (trap_list[sig] == (char *)IGNORE_SIG)
return "IGNORE_SIG";
else if (trap_list[sig] == (char *)IMPOSSIBLE_TRAP_HANDLER)
return "IMPOSSIBLE_TRAP_HANDLER";
else if (trap_list[sig])
return trap_list[sig];
else
return "NULL";
}
#endif
char *
signal_name (sig)
int sig;
{
char *ret;
ret = (sig >= BASH_NSIG || sig < 0) ? "bad signal number" : signal_names[sig];
if (ret == NULL)
ret = "unrecognized signal number";
return ret;
}
int
decode_signal (string)
char *string;
{
intmax_t sig;
if (legal_number (string, &sig))
return ((sig >= 0 && sig < NSIG) ? (int)sig : NO_SIG);
for (sig = 0; sig < BASH_NSIG; sig++)
{
if (signal_names[sig] == 0 || signal_names[sig][0] == '\0')
continue;
if (strcasecmp (string, signal_names[sig]) == 0 ||
(STREQN (signal_names[sig], "SIG", 3) &&
strcasecmp (string, &(signal_names[sig])[3]) == 0))
return ((int)sig);
}
return (NO_SIG);
}
static int catch_flag;
void
run_pending_traps ()
{
register int sig;
int old_exit_value, *token_state;
if (catch_flag == 0)
return;
catch_flag = 0;
old_exit_value = last_command_exit_value;
for (sig = 1; sig < NSIG; sig++)
{
if (pending_traps[sig])
{
#if defined (HAVE_POSIX_SIGNALS)
sigset_t set, oset;
sigemptyset (&set);
sigemptyset (&oset);
sigaddset (&set, sig);
sigprocmask (SIG_BLOCK, &set, &oset);
#else
# if defined (HAVE_BSD_SIGNALS)
int oldmask = sigblock (sigmask (sig));
# endif
#endif
if (sig == SIGINT)
{
run_interrupt_trap ();
CLRINTERRUPT;
}
else if (trap_list[sig] == (char *)DEFAULT_SIG ||
trap_list[sig] == (char *)IGNORE_SIG ||
trap_list[sig] == (char *)IMPOSSIBLE_TRAP_HANDLER)
{
internal_warning ("run_pending_traps: bad value in trap_list[%d]: %p",
sig, trap_list[sig]);
if (trap_list[sig] == (char *)DEFAULT_SIG)
{
internal_warning ("run_pending_traps: signal handler is SIG_DFL, resending %d (%s) to myself", sig, signal_name (sig));
kill (getpid (), sig);
}
}
else
{
token_state = save_token_state ();
parse_and_execute (savestring (trap_list[sig]), "trap", SEVAL_NONINT|SEVAL_NOHIST);
restore_token_state (token_state);
free (token_state);
}
pending_traps[sig] = 0;
#if defined (HAVE_POSIX_SIGNALS)
sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
#else
# if defined (HAVE_BSD_SIGNALS)
sigsetmask (oldmask);
# endif
#endif
}
}
last_command_exit_value = old_exit_value;
}
sighandler
trap_handler (sig)
int sig;
{
int oerrno;
if ((sig >= NSIG) ||
(trap_list[sig] == (char *)DEFAULT_SIG) ||
(trap_list[sig] == (char *)IGNORE_SIG))
programming_error ("trap_handler: bad signal %d", sig);
else
{
oerrno = errno;
#if defined (MUST_REINSTALL_SIGHANDLERS)
set_signal_handler (sig, trap_handler);
#endif
catch_flag = 1;
pending_traps[sig]++;
if (interrupt_immediately && this_shell_builtin && (this_shell_builtin == wait_builtin))
{
wait_signal_received = sig;
longjmp (wait_intr_buf, 1);
}
if (interrupt_immediately)
run_pending_traps ();
errno = oerrno;
}
SIGRETURN (0);
}
#if defined (JOB_CONTROL) && defined (SIGCHLD)
#ifdef INCLUDE_UNUSED
void
set_sigchld_trap (command_string)
char *command_string;
{
set_signal (SIGCHLD, command_string);
}
#endif
void
maybe_set_sigchld_trap (command_string)
char *command_string;
{
if ((sigmodes[SIGCHLD] & SIG_TRAPPED) == 0)
set_signal (SIGCHLD, command_string);
}
#endif
void
set_debug_trap (command)
char *command;
{
set_signal (DEBUG_TRAP, command);
}
void
set_error_trap (command)
char *command;
{
set_signal (ERROR_TRAP, command);
}
#ifdef INCLUDE_UNUSED
void
set_sigint_trap (command)
char *command;
{
set_signal (SIGINT, command);
}
#endif
SigHandler *
set_sigint_handler ()
{
if (sigmodes[SIGINT] & SIG_HARD_IGNORE)
return ((SigHandler *)SIG_IGN);
else if (sigmodes[SIGINT] & SIG_IGNORED)
return ((SigHandler *)set_signal_handler (SIGINT, SIG_IGN));
else if (sigmodes[SIGINT] & SIG_TRAPPED)
return ((SigHandler *)set_signal_handler (SIGINT, trap_handler));
else if (interactive)
return (set_signal_handler (SIGINT, sigint_sighandler));
else
return (set_signal_handler (SIGINT, termination_unwind_protect));
}
SigHandler *
trap_to_sighandler (sig)
int sig;
{
if (sigmodes[sig] & (SIG_IGNORED|SIG_HARD_IGNORE))
return (SIG_IGN);
else if (sigmodes[sig] & SIG_TRAPPED)
return (trap_handler);
else
return (SIG_DFL);
}
void
set_signal (sig, string)
int sig;
char *string;
{
if (SPECIAL_TRAP (sig))
{
change_signal (sig, savestring (string));
if (sig == EXIT_TRAP && interactive == 0)
initialize_terminating_signals ();
return;
}
if (sigmodes[sig] & SIG_HARD_IGNORE)
return;
if ((sigmodes[sig] & SIG_TRAPPED) == 0)
{
if (original_signals[sig] == IMPOSSIBLE_TRAP_HANDLER)
{
original_signals[sig] = (SigHandler *)set_signal_handler (sig, SIG_DFL);
set_signal_handler (sig, original_signals[sig]);
}
if (original_signals[sig] == SIG_IGN)
{
sigmodes[sig] |= SIG_HARD_IGNORE;
return;
}
}
if ((sigmodes[sig] & SIG_NO_TRAP) == 0)
{
set_signal_handler (sig, SIG_IGN);
change_signal (sig, savestring (string));
set_signal_handler (sig, trap_handler);
}
else
change_signal (sig, savestring (string));
}
static void
free_trap_command (sig)
int sig;
{
if ((sigmodes[sig] & SIG_TRAPPED) && trap_list[sig] &&
(trap_list[sig] != (char *)IGNORE_SIG) &&
(trap_list[sig] != (char *)DEFAULT_SIG) &&
(trap_list[sig] != (char *)IMPOSSIBLE_TRAP_HANDLER))
free (trap_list[sig]);
}
static void
change_signal (sig, value)
int sig;
char *value;
{
if ((sigmodes[sig] & SIG_INPROGRESS) == 0)
free_trap_command (sig);
trap_list[sig] = value;
sigmodes[sig] |= SIG_TRAPPED;
if (value == (char *)IGNORE_SIG)
sigmodes[sig] |= SIG_IGNORED;
else
sigmodes[sig] &= ~SIG_IGNORED;
if (sigmodes[sig] & SIG_INPROGRESS)
sigmodes[sig] |= SIG_CHANGED;
}
#define GET_ORIGINAL_SIGNAL(sig) \
if (sig && sig < NSIG && original_signals[sig] == IMPOSSIBLE_TRAP_HANDLER) \
get_original_signal (sig)
static void
get_original_signal (sig)
int sig;
{
if (original_signals[sig] == (SigHandler *)IMPOSSIBLE_TRAP_HANDLER)
{
original_signals[sig] =
(SigHandler *) set_signal_handler (sig, SIG_DFL);
set_signal_handler (sig, original_signals[sig]);
if (original_signals[sig] == SIG_IGN)
sigmodes[sig] |= SIG_HARD_IGNORE;
}
}
void
restore_default_signal (sig)
int sig;
{
if (SPECIAL_TRAP (sig))
{
if ((sig != DEBUG_TRAP && sig != ERROR_TRAP) || (sigmodes[sig] & SIG_INPROGRESS) == 0)
free_trap_command (sig);
trap_list[sig] = (char *)NULL;
sigmodes[sig] &= ~SIG_TRAPPED;
if (sigmodes[sig] & SIG_INPROGRESS)
sigmodes[sig] |= SIG_CHANGED;
return;
}
GET_ORIGINAL_SIGNAL (sig);
if (sigmodes[sig] & SIG_HARD_IGNORE)
return;
if ((sigmodes[sig] & SIG_TRAPPED) == 0)
return;
if ((sigmodes[sig] & SIG_NO_TRAP) == 0)
set_signal_handler (sig, original_signals[sig]);
change_signal (sig, (char *)DEFAULT_SIG);
sigmodes[sig] &= ~SIG_TRAPPED;
}
void
ignore_signal (sig)
int sig;
{
if (SPECIAL_TRAP (sig) && ((sigmodes[sig] & SIG_IGNORED) == 0))
{
change_signal (sig, (char *)IGNORE_SIG);
return;
}
GET_ORIGINAL_SIGNAL (sig);
if (sigmodes[sig] & SIG_HARD_IGNORE)
return;
if (sigmodes[sig] & SIG_IGNORED)
return;
if ((sigmodes[sig] & SIG_NO_TRAP) == 0)
set_signal_handler (sig, SIG_IGN);
change_signal (sig, (char *)IGNORE_SIG);
}
int
run_exit_trap ()
{
char *trap_command;
int code, old_exit_value;
old_exit_value = last_command_exit_value;
if ((sigmodes[EXIT_TRAP] & SIG_TRAPPED) &&
(sigmodes[EXIT_TRAP] & (SIG_IGNORED|SIG_INPROGRESS)) == 0)
{
trap_command = savestring (trap_list[EXIT_TRAP]);
sigmodes[EXIT_TRAP] &= ~SIG_TRAPPED;
sigmodes[EXIT_TRAP] |= SIG_INPROGRESS;
code = setjmp (top_level);
if (code == 0)
{
reset_parser ();
parse_and_execute (trap_command, "exit trap", SEVAL_NONINT|SEVAL_NOHIST);
}
else if (code == EXITPROG)
return (last_command_exit_value);
else
return (old_exit_value);
}
return (old_exit_value);
}
void
run_trap_cleanup (sig)
int sig;
{
sigmodes[sig] &= ~(SIG_INPROGRESS|SIG_CHANGED);
}
static void
_run_trap_internal (sig, tag)
int sig;
char *tag;
{
char *trap_command, *old_trap;
int old_exit_value, *token_state;
if ((sigmodes[sig] & SIG_TRAPPED) && ((sigmodes[sig] & SIG_IGNORED) == 0) &&
(trap_list[sig] != (char *)IMPOSSIBLE_TRAP_HANDLER) &&
((sigmodes[sig] & SIG_INPROGRESS) == 0))
{
old_trap = trap_list[sig];
sigmodes[sig] |= SIG_INPROGRESS;
sigmodes[sig] &= ~SIG_CHANGED;
trap_command = savestring (old_trap);
running_trap = sig + 1;
old_exit_value = last_command_exit_value;
trap_line_number = line_number;
token_state = save_token_state ();
parse_and_execute (trap_command, tag, SEVAL_NONINT|SEVAL_NOHIST);
restore_token_state (token_state);
free (token_state);
last_command_exit_value = old_exit_value;
running_trap = 0;
sigmodes[sig] &= ~SIG_INPROGRESS;
if (sigmodes[sig] & SIG_CHANGED)
{
free (old_trap);
sigmodes[sig] &= ~SIG_CHANGED;
}
}
}
void
run_debug_trap ()
{
if ((sigmodes[DEBUG_TRAP] & SIG_TRAPPED) && ((sigmodes[DEBUG_TRAP] & SIG_INPROGRESS) == 0))
_run_trap_internal (DEBUG_TRAP, "debug trap");
}
void
run_error_trap ()
{
if ((sigmodes[ERROR_TRAP] & SIG_TRAPPED) && (sigmodes[ERROR_TRAP] & SIG_INPROGRESS) == 0)
_run_trap_internal (ERROR_TRAP, "error trap");
}
void
run_interrupt_trap ()
{
_run_trap_internal (SIGINT, "interrupt trap");
}
#ifdef INCLUDE_UNUSED
void
free_trap_strings ()
{
register int i;
for (i = 0; i < BASH_NSIG; i++)
{
free_trap_command (i);
trap_list[i] = (char *)DEFAULT_SIG;
sigmodes[i] &= ~SIG_TRAPPED;
}
trap_list[DEBUG_TRAP] = trap_list[EXIT_TRAP] = trap_list[ERROR_TRAP] = (char *)NULL;
}
#endif
static void
reset_signal (sig)
int sig;
{
set_signal_handler (sig, original_signals[sig]);
sigmodes[sig] &= ~SIG_TRAPPED;
}
static void
restore_signal (sig)
int sig;
{
set_signal_handler (sig, original_signals[sig]);
change_signal (sig, (char *)DEFAULT_SIG);
sigmodes[sig] &= ~SIG_TRAPPED;
}
static void
reset_or_restore_signal_handlers (reset)
sh_resetsig_func_t *reset;
{
register int i;
if (sigmodes[EXIT_TRAP] & SIG_TRAPPED)
{
free_trap_command (EXIT_TRAP);
trap_list[EXIT_TRAP] = (char *)NULL;
sigmodes[EXIT_TRAP] &= ~SIG_TRAPPED;
}
for (i = 1; i < NSIG; i++)
{
if (sigmodes[i] & SIG_TRAPPED)
{
if (trap_list[i] == (char *)IGNORE_SIG)
set_signal_handler (i, SIG_IGN);
else
(*reset) (i);
}
else if (sigmodes[i] & SIG_SPECIAL)
(*reset) (i);
}
sigmodes[DEBUG_TRAP] &= ~SIG_TRAPPED;
sigmodes[ERROR_TRAP] &= ~SIG_TRAPPED;
}
void
reset_signal_handlers ()
{
reset_or_restore_signal_handlers (reset_signal);
}
void
restore_original_signals ()
{
reset_or_restore_signal_handlers (restore_signal);
}
int
maybe_call_trap_handler (sig)
int sig;
{
if ((sigmodes[sig] & SIG_TRAPPED) && ((sigmodes[sig] & SIG_IGNORED) == 0))
{
switch (sig)
{
case SIGINT:
run_interrupt_trap ();
break;
case EXIT_TRAP:
run_exit_trap ();
break;
case DEBUG_TRAP:
run_debug_trap ();
break;
case ERROR_TRAP:
run_error_trap ();
break;
default:
trap_handler (sig);
break;
}
return (1);
}
else
return (0);
}
int
signal_is_trapped (sig)
int sig;
{
return (sigmodes[sig] & SIG_TRAPPED);
}
int
signal_is_special (sig)
int sig;
{
return (sigmodes[sig] & SIG_SPECIAL);
}
int
signal_is_ignored (sig)
int sig;
{
return (sigmodes[sig] & SIG_IGNORED);
}
void
set_signal_ignored (sig)
int sig;
{
sigmodes[sig] |= SIG_HARD_IGNORE;
original_signals[sig] = SIG_IGN;
}