#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 "bashintl.h"
#include "trap.h"
#include "shell.h"
#include "flags.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 || (s) == RETURN_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 int _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 last_command_exit_value;
extern int line_number;
extern char *this_command_name;
extern sh_builtin_func_t *this_shell_builtin;
extern procenv_t wait_intr_buf;
extern int return_catch_flag, return_catch_value;
extern int subshell_level;
SigHandler *original_signals[NSIG];
char *trap_list[BASH_NSIG];
int pending_traps[NSIG];
int running_trap;
int trap_saved_exit_value;
int wait_signal_received;
#define IMPOSSIBLE_TRAP_HANDLER (SigHandler *)initialize_traps
#define GETORIGSIG(sig) \
do { \
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; \
} while (0)
#define GET_ORIGINAL_SIGNAL(sig) \
if (sig && sig < NSIG && original_signals[sig] == IMPOSSIBLE_TRAP_HANDLER) \
GETORIGSIG(sig)
void
initialize_traps ()
{
register int i;
initialize_signames();
trap_list[EXIT_TRAP] = trap_list[DEBUG_TRAP] = trap_list[ERROR_TRAP] = trap_list[RETURN_TRAP] = (char *)NULL;
sigmodes[EXIT_TRAP] = sigmodes[DEBUG_TRAP] = sigmodes[ERROR_TRAP] = sigmodes[RETURN_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)
GETORIGSIG (SIGCHLD);
sigmodes[SIGCHLD] |= (SIG_SPECIAL | SIG_NO_TRAP);
#endif
GETORIGSIG (SIGINT);
sigmodes[SIGINT] |= SIG_SPECIAL;
#if defined (__BEOS__)
original_signals[SIGINT] = SIG_DFL;
sigmodes[SIGINT] &= ~SIG_HARD_IGNORE;
#endif
GETORIGSIG (SIGQUIT);
sigmodes[SIGQUIT] |= SIG_SPECIAL;
if (interactive)
{
GETORIGSIG (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 || signal_names[sig] == NULL)
? _("invalid signal number")
: signal_names[sig];
return ret;
}
int
decode_signal (string, flags)
char *string;
int flags;
{
intmax_t sig;
char *name;
if (legal_number (string, &sig))
return ((sig >= 0 && sig < NSIG) ? (int)sig : NO_SIG);
for (sig = 0; sig < BASH_NSIG; sig++)
{
name = signal_names[sig];
if (name == 0 || name[0] == '\0')
continue;
if (STREQN (name, "SIG", 3))
{
name += 3;
if ((flags & DSIG_NOCASE) && strcasecmp (string, name) == 0)
return ((int)sig);
else if ((flags & DSIG_NOCASE) == 0 && strcmp (string, name) == 0)
return ((int)sig);
else if ((flags & DSIG_SIGPREFIX) == 0)
continue;
}
name = signal_names[sig];
if ((flags & DSIG_NOCASE) && strcasecmp (string, name) == 0)
return ((int)sig);
else if ((flags & DSIG_NOCASE) == 0 && strcmp (string, name) == 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);
}
void
set_return_trap (command)
char *command;
{
set_signal (RETURN_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, termsig_sighandler));
}
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)
GETORIGSIG (sig);
if (original_signals[sig] == SIG_IGN)
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;
}
static void
get_original_signal (sig)
int sig;
{
if (original_signals[sig] == (SigHandler *)IMPOSSIBLE_TRAP_HANDLER)
GETORIGSIG (sig);
}
void
restore_default_signal (sig)
int sig;
{
if (SPECIAL_TRAP (sig))
{
if ((sig != DEBUG_TRAP && sig != ERROR_TRAP && sig != RETURN_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, function_code, retval;
trap_saved_exit_value = last_command_exit_value;
function_code = 0;
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;
retval = trap_saved_exit_value;
running_trap = 1;
code = setjmp (top_level);
if (return_catch_flag)
function_code = setjmp (return_catch);
if (code == 0 && function_code == 0)
{
reset_parser ();
parse_and_execute (trap_command, "exit trap", SEVAL_NONINT|SEVAL_NOHIST);
}
else if (code == ERREXIT)
retval = last_command_exit_value;
else if (code == EXITPROG)
retval = last_command_exit_value;
else if (function_code != 0)
retval = return_catch_value;
else
retval = trap_saved_exit_value;
running_trap = 0;
return retval;
}
return (trap_saved_exit_value);
}
void
run_trap_cleanup (sig)
int sig;
{
sigmodes[sig] &= ~(SIG_INPROGRESS|SIG_CHANGED);
}
static int
_run_trap_internal (sig, tag)
int sig;
char *tag;
{
char *trap_command, *old_trap;
int trap_exit_value, *token_state;
int save_return_catch_flag, function_code;
procenv_t save_return_catch;
trap_exit_value = function_code = 0;
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;
trap_saved_exit_value = last_command_exit_value;
token_state = save_token_state ();
save_return_catch_flag = return_catch_flag;
if (return_catch_flag)
{
COPY_PROCENV (return_catch, save_return_catch);
function_code = setjmp (return_catch);
}
if (function_code == 0)
parse_and_execute (trap_command, tag, SEVAL_NONINT|SEVAL_NOHIST);
restore_token_state (token_state);
free (token_state);
trap_exit_value = last_command_exit_value;
last_command_exit_value = trap_saved_exit_value;
running_trap = 0;
sigmodes[sig] &= ~SIG_INPROGRESS;
if (sigmodes[sig] & SIG_CHANGED)
{
#if 0
if (SPECIAL_TRAP (sig) == 0)
#endif
free (old_trap);
sigmodes[sig] &= ~SIG_CHANGED;
}
if (save_return_catch_flag)
{
return_catch_flag = save_return_catch_flag;
return_catch_value = trap_exit_value;
COPY_PROCENV (save_return_catch, return_catch);
if (function_code)
longjmp (return_catch, 1);
}
}
return trap_exit_value;
}
int
run_debug_trap ()
{
int trap_exit_value;
trap_exit_value = 0;
if ((sigmodes[DEBUG_TRAP] & SIG_TRAPPED) && ((sigmodes[DEBUG_TRAP] & SIG_IGNORED) == 0) && ((sigmodes[DEBUG_TRAP] & SIG_INPROGRESS) == 0))
{
trap_exit_value = _run_trap_internal (DEBUG_TRAP, "debug trap");
#if defined (DEBUGGER)
if (debugging_mode && trap_exit_value == 2 && return_catch_flag)
{
return_catch_value = trap_exit_value;
longjmp (return_catch, 1);
}
#endif
}
return trap_exit_value;
}
void
run_error_trap ()
{
if ((sigmodes[ERROR_TRAP] & SIG_TRAPPED) && ((sigmodes[ERROR_TRAP] & SIG_IGNORED) == 0) && (sigmodes[ERROR_TRAP] & SIG_INPROGRESS) == 0)
_run_trap_internal (ERROR_TRAP, "error trap");
}
void
run_return_trap ()
{
int old_exit_value;
#if 0
if ((sigmodes[DEBUG_TRAP] & SIG_TRAPPED) && (sigmodes[DEBUG_TRAP] & SIG_INPROGRESS))
return;
#endif
if ((sigmodes[RETURN_TRAP] & SIG_TRAPPED) && ((sigmodes[RETURN_TRAP] & SIG_IGNORED) == 0) && (sigmodes[RETURN_TRAP] & SIG_INPROGRESS) == 0)
{
old_exit_value = last_command_exit_value;
_run_trap_internal (RETURN_TRAP, "return trap");
last_command_exit_value = old_exit_value;
}
}
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] = trap_list[RETURN_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)
{
sigmodes[EXIT_TRAP] &= ~SIG_TRAPPED;
if (reset != reset_signal)
{
free_trap_command (EXIT_TRAP);
trap_list[EXIT_TRAP] = (char *)NULL;
}
}
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);
}
if (function_trace_mode == 0)
{
sigmodes[DEBUG_TRAP] &= ~SIG_TRAPPED;
sigmodes[RETURN_TRAP] &= ~SIG_TRAPPED;
}
if (error_trace_mode == 0)
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;
}
int
signal_in_progress (sig)
int sig;
{
return (sigmodes[sig] & SIG_INPROGRESS);
}