new = old_termios;
new.c_cflag |= (CLOCAL | CREAD);
new.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
- signal(SIGINT, onintr);
- signal(SIGQUIT, onintr);
- signal(SIGTERM, onintr);
- signal(SIGALRM, onintr);
+ bb_signals(0
+ + (1 << SIGINT)
+ + (1 << SIGQUIT)
+ + (1 << SIGTERM)
+ + (1 << SIGALRM)
+ , onintr);
tcsetattr(STDERR_FILENO, TCSANOW, &new);
/* save_cursor_pos 7
mode += (retval & 2); /* Since 'a' is the 2nd option... */
if (retval & 1) {
- signal(SIGINT, SIG_IGN); /* TODO - switch to sigaction. */
+ signal(SIGINT, SIG_IGN); /* TODO - switch to sigaction. (why?) */
}
retval = EXIT_SUCCESS;
/* gnu tee ignores SIGPIPE in case one of the output files is a pipe
* that doesn't consume all its input. Good idea... */
- signal(SIGPIPE, SIG_IGN); /* TODO - switch to sigaction. */
+ signal(SIGPIPE, SIG_IGN);
/* Allocate an array of FILE *'s, with one extra for a sentinal. */
fp = files = xzalloc(sizeof(FILE *) * (argc + 2));
char *xmalloc_follow_symlinks(const char *path);
-//TODO: signal(sid, f) is the same? then why?
-extern void sig_catch(int,void (*)(int));
-//#define sig_ignore(s) (sig_catch((s), SIG_IGN))
-//#define sig_uncatch(s) (sig_catch((s), SIG_DFL))
-extern void sig_block(int);
-extern void sig_unblock(int);
-/* UNUSED: extern void sig_blocknone(void); */
-extern void sig_pause(void);
+//enum {
+// BB_SIGS_FATAL = ,
+//};
+void bb_signals(int sigs, void (*f)(int));
+/* Unlike signal() and bb_signals, sets handler with sigaction()
+ * and in a way that while signal handler is run, no other signals
+ * will be blocked: */
+void bb_signals_recursive(int sigs, void (*f)(int));
+void sig_block(int);
+void sig_unblock(int);
+/* UNUSED: void sig_blocknone(void); */
+void sig_pause(void);
void xsetgid(gid_t gid);
/* Child */
/* Reset signal handlers that were set by the parent process */
- signal(SIGUSR1, SIG_DFL);
- signal(SIGUSR2, SIG_DFL);
- signal(SIGINT, SIG_DFL);
- signal(SIGTERM, SIG_DFL);
- signal(SIGHUP, SIG_DFL);
- signal(SIGQUIT, SIG_DFL);
- signal(SIGCONT, SIG_DFL);
- signal(SIGSTOP, SIG_DFL);
- signal(SIGTSTP, SIG_DFL);
+ bb_signals(0
+ + (1 << SIGUSR1)
+ + (1 << SIGUSR2)
+ + (1 << SIGINT)
+ + (1 << SIGTERM)
+ + (1 << SIGHUP)
+ + (1 << SIGQUIT)
+ + (1 << SIGCONT)
+ + (1 << SIGSTOP)
+ + (1 << SIGTSTP)
+ , SIG_DFL);
/* Create a new session and make ourself the process
* group leader */
if (pid > 0) {
/* Parent - wait till the child is done */
- signal(SIGINT, SIG_IGN);
- signal(SIGTSTP, SIG_IGN);
- signal(SIGQUIT, SIG_IGN);
+ bb_signals(0
+ + (1 << SIGINT)
+ + (1 << SIGTSTP)
+ + (1 << SIGQUIT)
+ , SIG_IGN);
signal(SIGCHLD, SIG_DFL);
waitfor(pid);
}
/* Set up sig handlers -- be sure to
* clear all of these in run() */
- signal(SIGHUP, exec_restart_action);
- signal(SIGQUIT, exec_restart_action);
- signal(SIGUSR1, halt_reboot_pwoff); /* halt */
- signal(SIGUSR2, halt_reboot_pwoff); /* poweroff */
- signal(SIGTERM, halt_reboot_pwoff); /* reboot */
+ bb_signals(0
+ + (1 << SIGHUP)
+ + (1 << SIGQUIT)
+ , exec_restart_action);
+ bb_signals(0
+ + (1 << SIGUSR1) /* halt */
+ + (1 << SIGUSR2) /* poweroff */
+ + (1 << SIGTERM) /* reboot */
+ , halt_reboot_pwoff);
signal(SIGINT, ctrlaltdel_signal);
signal(SIGCONT, cont_handler);
- signal(SIGSTOP, stop_handler);
- signal(SIGTSTP, stop_handler);
+ bb_signals(0
+ + (1 << SIGSTOP)
+ + (1 << SIGTSTP)
+ , stop_handler);
/* Turn off rebooting via CTL-ALT-DEL -- we get a
* SIGINT on CAD so we can shut things down gracefully... */
lib-y += safe_write.o
lib-y += setup_environment.o
lib-y += sha1.o
+lib-y += signals.o
lib-y += simplify_path.o
lib-y += skip_whitespace.o
lib-y += speed_table.o
--- /dev/null
+/* vi: set sw=4 ts=4: */
+/*
+ * Utility routines.
+ *
+ * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
+ * Copyright (C) 2006 Rob Landley
+ * Copyright (C) 2006 Denis Vlasenko
+ *
+ * Licensed under GPL version 2, see file LICENSE in this tarball for details.
+ */
+
+#include "libbb.h"
+
+void bb_signals(int sigs, void (*f)(int))
+{
+ int sig_no = 0;
+ int bit = 1;
+
+ while (sigs) {
+ if (sigs & bit) {
+ sigs &= ~bit;
+ signal(sig_no, f);
+ }
+ sig_no++;
+ bit <<= 1;
+ }
+}
+
+void bb_signals_recursive(int sigs, void (*f)(int))
+{
+ int sig_no = 0;
+ int bit = 1;
+ struct sigaction sa;
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_handler = f;
+ /*sa.sa_flags = 0;*/
+ /*sigemptyset(&sa.sa_mask); - hope memset did it*/
+
+ while (sigs) {
+ if (sigs & bit) {
+ sigs &= ~bit;
+ sigaction(sig_no, &sa, NULL);
+ }
+ sig_no++;
+ bit <<= 1;
+ }
+}
+
+void sig_block(int sig)
+{
+ sigset_t ss;
+ sigemptyset(&ss);
+ sigaddset(&ss, sig);
+ sigprocmask(SIG_BLOCK, &ss, NULL);
+}
+
+void sig_unblock(int sig)
+{
+ sigset_t ss;
+ sigemptyset(&ss);
+ sigaddset(&ss, sig);
+ sigprocmask(SIG_UNBLOCK, &ss, NULL);
+}
+
+#if 0
+void sig_blocknone(void)
+{
+ sigset_t ss;
+ sigemptyset(&ss);
+ sigprocmask(SIG_SETMASK, &ss, NULL);
+}
+#endif
+
+void sig_pause(void)
+{
+ sigset_t ss;
+ sigemptyset(&ss);
+ sigsuspend(&ss);
+}
}
}
-void sig_block(int sig)
-{
- sigset_t ss;
- sigemptyset(&ss);
- sigaddset(&ss, sig);
- sigprocmask(SIG_BLOCK, &ss, NULL);
-}
-
-void sig_unblock(int sig)
-{
- sigset_t ss;
- sigemptyset(&ss);
- sigaddset(&ss, sig);
- sigprocmask(SIG_UNBLOCK, &ss, NULL);
-}
-
-#if 0
-void sig_blocknone(void)
-{
- sigset_t ss;
- sigemptyset(&ss);
- sigprocmask(SIG_SETMASK, &ss, NULL);
-}
-#endif
-
-void sig_catch(int sig, void (*f)(int))
-{
- struct sigaction sa;
- sa.sa_handler = f;
- sa.sa_flags = 0;
- sigemptyset(&sa.sa_mask);
- sigaction(sig, &sa, NULL);
-}
-
-void sig_pause(void)
-{
- sigset_t ss;
- sigemptyset(&ss);
- sigsuspend(&ss);
-}
-
-
void xsetenv(const char *key, const char *value)
{
if (setenv(key, value, 1))
rlimit_fsize.rlim_cur = rlimit_fsize.rlim_max = 512L * 30000;
setrlimit(RLIMIT_FSIZE, &rlimit_fsize);
- signal(SIGHUP, SIG_IGN);
- signal(SIGINT, SIG_IGN);
- signal(SIGQUIT, SIG_IGN);
+ bb_signals(0
+ + (1 << SIGHUP)
+ + (1 << SIGINT)
+ + (1 << SIGQUIT)
+ , SIG_IGN);
umask(077);
xsetuid(0);
empty_line_marker = "";
tcgetattr(kbd_fd, &term_orig);
- signal(SIGTERM, sig_catcher);
- signal(SIGINT, sig_catcher);
+ bb_signals(0
+ + (1 << SIGTERM)
+ + (1 << SIGINT)
+ , sig_catcher);
term_less = term_orig;
term_less.c_lflag &= ~(ICANON | ECHO);
term_less.c_iflag &= ~(IXON | ICRNL);
}
// setup signals
- sig_catch(SIGHUP, signal_handler);
- sig_catch(SIGINT, signal_handler);
- sig_catch(SIGTERM, signal_handler);
- sig_catch(SIGPIPE, signal_handler);
+ bb_signals_recursive(0
+ + (1 << SIGHUP)
+ + (1 << SIGINT)
+ + (1 << SIGTERM)
+ + (1 << SIGPIPE)
+ , signal_handler);
// error exit code if we fail to open the device
signalled = 1;
Return 0 on error, 1 if ok. */
/* pid_t is short on BSDI, so don't try to promote it. */
-static int resuse_end(pid_t pid, resource_t * resp)
+static int resuse_end(pid_t pid, resource_t *resp)
{
int status;
pid_t caught;
/* Ignore signals, but don't ignore the children. When wait3
returns the child process, set the time the command finished. */
while ((caught = wait3(&status, 0, &resp->ru)) != pid) {
- if (caught == -1)
+ if (caught == -1 && errno != EINTR)
return 0;
}
resp->elapsed_ms = (monotonic_us() / 1000) - resp->elapsed_ms;
/* Run command CMD and return statistics on it.
Put the statistics in *RESP. */
-static void run_command(char *const *cmd, resource_t * resp)
+static void run_command(char *const *cmd, resource_t *resp)
{
pid_t pid; /* Pid of child. */
- __sighandler_t interrupt_signal, quit_signal;
+ void (*interrupt_signal)(int);
+ void (*quit_signal)(int);
resp->elapsed_ms = monotonic_us() / 1000;
pid = vfork(); /* Run CMD as child process. */
if (pid < 0)
bb_error_msg_and_die("cannot fork");
- else if (pid == 0) { /* If child. */
+ if (pid == 0) { /* If child. */
/* Don't cast execvp arguments; that causes errors on some systems,
versus merely warnings if the cast is left off. */
BB_EXECVP(cmd[0], cmd);
- bb_error_msg("cannot run %s", cmd[0]);
- _exit(errno == ENOENT ? 127 : 126);
+ xfunc_error_retval = (errno == ENOENT ? 127 : 126);
+ bb_error_msg_and_die("cannot run %s", cmd[0]);
}
/* Have signals kill the child but not self (if possible). */
+//TODO: just block all sigs? and reenable them in the very end in main?
interrupt_signal = signal(SIGINT, SIG_IGN);
quit_signal = signal(SIGQUIT, SIG_IGN);
bb_daemonize_or_rexec(DAEMON_CHDIR_ROOT, argv);
}
- signal(SIGHUP, watchdog_shutdown);
- signal(SIGINT, watchdog_shutdown);
+ bb_signals(0
+ + (1 << SIGHUP)
+ + (1 << SIGINT)
+ , watchdog_shutdown);
/* Use known fd # - avoid needing global 'int fd' */
xmove_fd(xopen(argv[argc - 1], O_WRONLY), 3);
dnsentryinit();
signal(SIGINT, interrupt);
- /* why? signal(SIGPIPE, SIG_IGN); */
- signal(SIGHUP, SIG_IGN);
+ bb_signals(0
+ /* why? + (1 << SIGPIPE) */
+ + (1 << SIGHUP)
#ifdef SIGTSTP
- signal(SIGTSTP, SIG_IGN);
+ + (1 << SIGTSTP)
#endif
#ifdef SIGURG
- signal(SIGURG, SIG_IGN);
+ + (1 << SIGURG)
#endif
+ , SIG_IGN);
lsa = xdotted2sockaddr(listen_interface, port);
udps = xsocket(lsa->u.sa.sa_family, SOCK_DGRAM, 0);
PTR_TO_GLOBALS = xzalloc(sizeof(G));
/* catch a signal or two for cleanup */
- signal(SIGINT, catch);
- signal(SIGQUIT, catch);
- signal(SIGTERM, catch);
+ bb_signals(0
+ + (1 << SIGINT)
+ + (1 << SIGQUIT)
+ + (1 << SIGTERM)
+ , catch);
/* and suppress others... */
+ bb_signals(0
#ifdef SIGURG
- signal(SIGURG, SIG_IGN);
+ + (1 << SIGURG)
#endif
- signal(SIGPIPE, SIG_IGN); /* important! */
+ + (1 << SIGPIPE) /* important! */
+ , SIG_IGN);
proggie = argv;
while (*++proggie) {
_exit(127);
}
// parent - check whether child is alive
- sig_catch(SIGCHLD, signal_handler);
- sig_catch(SIGALRM, signal_handler);
+ bb_signals_recursive(0
+ + (1 << SIGCHLD)
+ + (1 << SIGALRM)
+ , signal_handler);
signal_handler(SIGCHLD);
// child seems OK -> parent goes on
}
/* Trap signals in order to restore tty states upon exit */
if (!(opt & OPT_e_quit)) {
- signal(SIGHUP, sig_handler);
- signal(SIGINT, sig_handler);
- signal(SIGQUIT, sig_handler);
- signal(SIGTERM, sig_handler);
+ bb_signals(0
+ + (1 << SIGHUP)
+ + (1 << SIGINT)
+ + (1 << SIGQUIT)
+ + (1 << SIGTERM)
+ , sig_handler);
}
/* Open tty */
setsid();
/* Restore default signal handling */
- signal(SIGCHLD, SIG_DFL);
- signal(SIGPIPE, SIG_DFL);
+ bb_signals((1 << SIGCHLD) + (1 << SIGPIPE), SIG_DFL);
/* open the child's side of the tty. */
/* NB: setsid() disconnects from any previous ctty's. Therefore
close_on_exec_on(signal_pipe.rd);
close_on_exec_on(signal_pipe.wr);
ndelay_on(signal_pipe.wr);
- signal(SIGUSR1, signal_handler);
- signal(SIGUSR2, signal_handler);
- signal(SIGTERM, signal_handler);
+ bb_signals(0
+ + (1 << SIGUSR1)
+ + (1 << SIGUSR2)
+ + (1 << SIGTERM)
+ , signal_handler);
}
/* unbuffered input, turn off echo */
new_settings.c_lflag &= ~(ISIG | ICANON | ECHO | ECHONL);
- signal(SIGTERM, sig_catcher);
- signal(SIGINT, sig_catcher);
+ bb_signals(0
+ + (1 << SIGTERM)
+ + (1 << SIGINT)
+ , sig_catcher);
tcsetattr(0, TCSANOW, (void *) &new_settings);
atexit(reset_term);
#endif /* FEATURE_USE_TERMIOS */
xdup2(logpipe.wr, 1);
}
}
- signal(SIGCHLD, SIG_DFL);
- signal(SIGTERM, SIG_DFL);
+ bb_signals(0
+ + (1 << SIGCHLD)
+ + (1 << SIGTERM)
+ , SIG_DFL);
sig_unblock(SIGCHLD);
sig_unblock(SIGTERM);
execvp(*run, run);
ndelay_on(selfpipe.wr);
sig_block(SIGCHLD);
- sig_catch(SIGCHLD, s_child);
+ bb_signals_recursive(1 << SIGCHLD, s_child);
sig_block(SIGTERM);
- sig_catch(SIGTERM, s_term);
+ bb_signals_recursive(1 << SIGTERM, s_term);
xchdir(dir);
/* bss: svd[0].pid = 0; */
/* child */
if (set_pgrp)
setsid();
- signal(SIGHUP, SIG_DFL);
- signal(SIGTERM, SIG_DFL);
+ bb_signals(0
+ + (1 << SIGHUP)
+ + (1 << SIGTERM)
+ , SIG_DFL);
execvp(prog[0], prog);
fatal2_cannot("start runsv ", name);
}
bb_show_usage();
}
- sig_catch(SIGTERM, s_term);
- sig_catch(SIGHUP, s_hangup);
+ bb_signals_recursive(1 << SIGTERM, s_term);
+ bb_signals_recursive(1 << SIGHUP, s_hangup);
svdir = *argv++;
if (argv && *argv) {
rplog = *argv;
int fd;
/* child */
- signal(SIGTERM, SIG_DFL);
- signal(SIGALRM, SIG_DFL);
- signal(SIGHUP, SIG_DFL);
+ bb_signals(0
+ + (1 << SIGTERM)
+ + (1 << SIGALRM)
+ + (1 << SIGHUP)
+ , SIG_DFL);
sig_unblock(SIGTERM);
sig_unblock(SIGALRM);
sig_unblock(SIGHUP);
sigaddset(&blocked_sigset, SIGALRM);
sigaddset(&blocked_sigset, SIGHUP);
sigprocmask(SIG_BLOCK, &blocked_sigset, NULL);
- sig_catch(SIGTERM, sig_term_handler);
- sig_catch(SIGCHLD, sig_child_handler);
- sig_catch(SIGALRM, sig_alarm_handler);
- sig_catch(SIGHUP, sig_hangup_handler);
+ bb_signals_recursive(1 << SIGTERM, sig_term_handler);
+ bb_signals_recursive(1 << SIGCHLD, sig_child_handler);
+ bb_signals_recursive(1 << SIGALRM, sig_alarm_handler);
+ bb_signals_recursive(1 << SIGHUP, sig_hangup_handler);
logdirs_reopen();
/* Signals are grouped, we handle them in batches */
static void set_fatal_sighandler(void (*handler)(int))
{
- signal(SIGILL , handler);
- signal(SIGTRAP, handler);
- signal(SIGABRT, handler);
- signal(SIGFPE , handler);
- signal(SIGBUS , handler);
- signal(SIGSEGV, handler);
+ bb_signals(0
+ + (1 << SIGILL)
+ + (1 << SIGTRAP)
+ + (1 << SIGABRT)
+ + (1 << SIGFPE)
+ + (1 << SIGBUS)
+ + (1 << SIGSEGV)
/* bash 3.2 seems to handle these just like 'fatal' ones */
- signal(SIGHUP , handler);
- signal(SIGPIPE, handler);
- signal(SIGALRM, handler);
+ + (1 << SIGHUP)
+ + (1 << SIGPIPE)
+ + (1 << SIGALRM)
+ , handler);
}
static void set_jobctrl_sighandler(void (*handler)(int))
{
- signal(SIGTSTP, handler);
- signal(SIGTTIN, handler);
- signal(SIGTTOU, handler);
+ bb_signals(0
+ + (1 << SIGTSTP)
+ + (1 << SIGTTIN)
+ + (1 << SIGTTOU)
+ , handler);
}
static void set_misc_sighandler(void (*handler)(int))
{
- signal(SIGINT , handler);
- signal(SIGQUIT, handler);
- signal(SIGTERM, handler);
+ bb_signals(0
+ + (1 << SIGINT)
+ + (1 << SIGQUIT)
+ + (1 << SIGTERM)
+ , handler);
}
/* SIGCHLD is special and handled separately */
openlog("kernel", 0, LOG_KERN);
/* Set up sig handlers */
- signal(SIGINT, klogd_signal);
- signal(SIGKILL, klogd_signal);
- signal(SIGTERM, klogd_signal);
+ bb_signals(0
+ + (1 << SIGINT)
+ + (1 << SIGTERM)
+ , klogd_signal);
signal(SIGHUP, SIG_IGN);
/* "Open the log. Currently a NOP." */
int sock_fd;
/* Set up signal handlers */
- signal(SIGINT, quit_signal);
- signal(SIGTERM, quit_signal);
- signal(SIGQUIT, quit_signal);
+ bb_signals(0
+ + (1 << SIGINT)
+ + (1 << SIGTERM)
+ + (1 << SIGQUIT)
+ , quit_signal);
signal(SIGHUP, SIG_IGN);
/* signal(SIGCHLD, SIG_IGN); - why? */
#ifdef SYSLOGD_MARK
new_settings.c_cc[VMIN] = 1;
new_settings.c_cc[VTIME] = 0;
setTermSettings(cin_fileno, &new_settings);
- signal(SIGINT, gotsig);
- signal(SIGQUIT, gotsig);
- signal(SIGTERM, gotsig);
+ bb_signals(0
+ + (1 << SIGINT)
+ + (1 << SIGQUIT)
+ + (1 << SIGTERM)
+ , gotsig);
#endif
do {
projects / platform / upstream / busybox.git / commitdiff