mirror of
https://github.com/sheumann/hush.git
synced 2024-06-26 02:29:31 +00:00
hush: rework signal and trap handling. Some smaller bits are TODO,
expect minor breakage function old new delta set_fatal_sighandler 12 186 +174 check_and_run_traps - 122 +122 maybe_set_sighandler - 76 +76 hush_main 831 887 +56 sigtimedwait - 50 +50 __GI_sigtimedwait - 50 +50 hush_exit 49 93 +44 set_mode 749 777 +28 pseudo_exec_argv 131 151 +20 static.zero_ts - 8 +8 expand_variables 1962 1970 +8 builtin_wait 172 174 +2 set_misc_sighandler 12 - -12 set_jobctrl_sighandler 12 - -12 handler_ctrl_c 16 - -16 builtin_set_mode 28 - -28 handle_trap 97 - -97 handler_ctrl_z 107 - -107 builtin_trap 545 438 -107 run_list 2149 2006 -143 ------------------------------------------------------------------------------ (add/remove: 5/6 grow/shrink: 7/2 up/down: 638/-522) Total: 116 bytes
This commit is contained in:
Denis Vlasenko
parent
d690f68554
commit
d5762932fb
580
shell/hush.c
580
shell/hush.c
|
|
@ -460,13 +460,13 @@ struct globals {
|
|||
int last_jobid;
|
||||
struct pipe *job_list;
|
||||
struct pipe *toplevel_list;
|
||||
smallint ctrl_z_flag;
|
||||
//// smallint ctrl_z_flag;
|
||||
#endif
|
||||
#if ENABLE_HUSH_LOOPS
|
||||
smallint flag_break_continue;
|
||||
#endif
|
||||
smallint fake_mode;
|
||||
/* these three support $?, $#, and $1 */
|
||||
/* These four support $?, $#, and $1 */
|
||||
smalluint last_return_code;
|
||||
/* is global_argv and global_argv[1..n] malloced? (note: not [0]) */
|
||||
smalluint global_args_malloced;
|
||||
|
|
@ -489,10 +489,14 @@ struct globals {
|
|||
#endif
|
||||
unsigned char charmap[256];
|
||||
char user_input_buf[ENABLE_FEATURE_EDITING ? BUFSIZ : 2];
|
||||
struct {
|
||||
char *cmd;
|
||||
struct sigaction oact;
|
||||
} *traps;
|
||||
/* Signal and trap handling */
|
||||
char **traps; /* char *traps[NSIG] */
|
||||
/* which signals have non-DFL handler (even with no traps set)? */
|
||||
unsigned non_DFL_mask;
|
||||
/* which signals are known to be IGNed on entry to shell? */
|
||||
unsigned IGN_mask;
|
||||
sigset_t blocked_set;
|
||||
sigset_t inherited_set;
|
||||
};
|
||||
|
||||
#define G (*ptr_to_globals)
|
||||
|
|
@ -521,11 +525,9 @@ static int builtin_help(char **argv);
|
|||
static int builtin_pwd(char **argv);
|
||||
static int builtin_read(char **argv);
|
||||
static int builtin_test(char **argv);
|
||||
static void handle_trap(int sig);
|
||||
static int builtin_trap(char **argv);
|
||||
static int builtin_true(char **argv);
|
||||
static int builtin_set(char **argv);
|
||||
static int builtin_set_mode(const char, const char);
|
||||
static int builtin_shift(char **argv);
|
||||
static int builtin_source(char **argv);
|
||||
static int builtin_umask(char **argv);
|
||||
|
|
@ -750,95 +752,270 @@ static void free_strings(char **strings)
|
|||
}
|
||||
|
||||
|
||||
/* Signals are grouped, we handle them in batches */
|
||||
static void set_misc_sighandler(void (*handler)(int))
|
||||
/* Basic theory of signal handling in shell
|
||||
* ========================================
|
||||
* This does not describe what hush does, rahter, it is current understanding
|
||||
* what it _should_ do.
|
||||
* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#trap
|
||||
*
|
||||
* Signals are handled only after each pipe ("cmd | cmd | cmd" thing)
|
||||
* is finished or backgrounded. It is the same in interactive and
|
||||
* non-interactive shells, and is the same regardless of whether
|
||||
* a user trap handler is installed or a default one is in effect.
|
||||
* ^C or ^Z from keyboard seem to execute "at once" because it usually
|
||||
* backgrounds (i.e. stops) or kills all members of currently running
|
||||
* pipe.
|
||||
*
|
||||
* Wait builtin in interruptible by signals for which user trap is set
|
||||
* or by SIGINT in interactive shell.
|
||||
*
|
||||
* Trap handlers will execute even within trap handlers. (right?)
|
||||
*
|
||||
* User trap handlers are forgotten when subshell is entered.
|
||||
*
|
||||
* If job control is off, backgrounded commands ("cmd &")
|
||||
* have SIGINT, SIGQUIT set to SIG_IGN.
|
||||
*
|
||||
* Commands run in command substitution ("`cmd`")
|
||||
* have SIGTTIN, SIGTTOU, SIGTSTP set to SIG_IGN.
|
||||
*
|
||||
* Ordinary commands have IGN/DFL set as inherited by the shell
|
||||
* from its parent.
|
||||
*
|
||||
* Default handlers which differ from DFL action
|
||||
* (note: subshell is not an interactive shell):
|
||||
*
|
||||
* SIGQUIT: ignore
|
||||
* SIGTERM (interactive): ignore
|
||||
* SUGHUP (interactive): send SIGCONT to stopped jobs,
|
||||
* send SIGHUP to all jobs and exit
|
||||
* SIGTTIN, SIGTTOU, SIGTSTP (if job control is on): ignore
|
||||
* (note that ^Z is handled not by trapping SIGTSTP, but by seeing
|
||||
* that all pipe members are stopped) (right?)
|
||||
* SIGINT (interactive): wait for last pipe, ignore the rest
|
||||
* of the command line, show prompt. (check/expand this)
|
||||
* Example 1: this waits 5 sec, but does not execute ls:
|
||||
* "echo $$; sleep 5; ls -l" + "kill -INT <pid>"
|
||||
* Example 2: this does not wait and does not execute ls:
|
||||
* "echo $$; sleep 5 & wait; ls -l" + "kill -INT <pid>"
|
||||
*
|
||||
* (What happens to signals which are IGN on shell start?)
|
||||
* (What happens with signal mask on shell start?)
|
||||
*
|
||||
* Implementation in hush
|
||||
* ======================
|
||||
* We use in-kernel pending signal mask to determine which signals were sent.
|
||||
* We block all signals which we don't want to take action immediately,
|
||||
* i.e. we block all signals which need to have special handling as described
|
||||
* above, and all signals which have traps set.
|
||||
* After each pipe execution, we extract any pending signals via sigtimedwait()
|
||||
* and act on them.
|
||||
*
|
||||
* unsigned non_DFL_mask: a mask of such "special" signals
|
||||
* sigset_t blocked_set: current blocked signal set
|
||||
*
|
||||
* "trap - SIGxxx": clear bit in blocked_set unless it is also in non_DFL
|
||||
* "trap 'cmd' SIGxxx": set bit in blocked_set (even if 'cmd' is '')
|
||||
* after [v]fork, if we plan to be a shell:
|
||||
* nothing for {} subshell (say, "true | { true; true; } | true")
|
||||
* unset all traps if () shell. [TODO]
|
||||
* after [v]fork, if we plan to exec:
|
||||
* POSIX says pending signal mask is cleared in child - no need to clear it.
|
||||
* restore blocked signal set to one inherited by shell just prior to exec.
|
||||
*
|
||||
* Note: as a result, we do not use signal handlers much. The only use
|
||||
* is to restore terminal pgrp on exit.
|
||||
*
|
||||
* TODO: check/fix wait builtin to be interruptible.
|
||||
*/
|
||||
|
||||
/* called once at shell init */
|
||||
static void init_signal_mask(void)
|
||||
{
|
||||
bb_signals(0
|
||||
+ (1 << SIGINT)
|
||||
+ (1 << SIGQUIT)
|
||||
+ (1 << SIGTERM)
|
||||
, handler);
|
||||
unsigned sig;
|
||||
unsigned mask = (1 << SIGQUIT);
|
||||
#if ENABLE_HUSH_INTERACTIVE
|
||||
if (G.interactive_fd) {
|
||||
mask = 0
|
||||
| (1 << SIGQUIT)
|
||||
| (1 << SIGTERM)
|
||||
| (1 << SIGHUP)
|
||||
#if ENABLE_HUSH_JOB
|
||||
| (1 << SIGTTIN) | (1 << SIGTTOU) | (1 << SIGTSTP)
|
||||
#endif
|
||||
| (1 << SIGINT)
|
||||
;
|
||||
}
|
||||
#endif
|
||||
G.non_DFL_mask = mask;
|
||||
|
||||
/*sigemptyset(&G.blocked_set); - already is */
|
||||
sigprocmask(SIG_SETMASK, NULL, &G.blocked_set);
|
||||
sig = 0;
|
||||
while (mask) {
|
||||
if (mask & 1)
|
||||
sigaddset(&G.blocked_set, sig);
|
||||
mask >>= 1;
|
||||
sig++;
|
||||
}
|
||||
sigprocmask(SIG_SETMASK, &G.blocked_set, &G.inherited_set);
|
||||
}
|
||||
static void check_and_run_traps(void)
|
||||
{
|
||||
static const struct timespec zero_ts = { 0, 0 };
|
||||
smalluint save_rcode;
|
||||
int sig;
|
||||
|
||||
while (1) {
|
||||
sig = sigtimedwait(&G.blocked_set, NULL, &zero_ts);
|
||||
if (sig <= 0)
|
||||
break;
|
||||
|
||||
if (G.traps && G.traps[sig]) {
|
||||
if (G.traps[sig][0]) {
|
||||
/* We have user-defined handler */
|
||||
char *argv[] = { NULL, xstrdup(G.traps[sig]), NULL };
|
||||
save_rcode = G.last_return_code;
|
||||
builtin_eval(argv);
|
||||
free(argv[1]);
|
||||
G.last_return_code = save_rcode;
|
||||
} /* else: "" trap, ignoring signal */
|
||||
continue;
|
||||
}
|
||||
/* not a trap: special action */
|
||||
#if 0 //TODO
|
||||
switch (sig) {
|
||||
case SIGHUP: ...
|
||||
break;
|
||||
case SIGINT: ...
|
||||
break;
|
||||
default: /* SIGTERM, SIGQUIT, SIGTTIN, SIGTTOU, SIGTSTP */
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
/* The stuff below needs to be migrated to "Special action" above */
|
||||
|
||||
/////* Signals are grouped, we handle them in batches */
|
||||
////static void set_misc_sighandler(void (*handler)(int))
|
||||
////{
|
||||
//// bb_signals(0
|
||||
//// + (1 << SIGINT)
|
||||
//// + (1 << SIGQUIT)
|
||||
//// + (1 << SIGTERM)
|
||||
//// , handler);
|
||||
////}
|
||||
|
||||
#if ENABLE_HUSH_JOB
|
||||
|
||||
/* helper */
|
||||
static unsigned maybe_set_sighandler(int sig, void (*handler)(int))
|
||||
{
|
||||
/* non_DFL_mask'ed signals are, well, masked,
|
||||
* no need to set handler for them.
|
||||
* IGN_mask'ed signals were found to be IGN on entry,
|
||||
* do not change that -> no need to set handler for them either
|
||||
*/
|
||||
unsigned ign = ((G.IGN_mask|G.non_DFL_mask) >> sig) & 1;
|
||||
if (!ign) {
|
||||
handler = signal(sig, handler);
|
||||
ign = (handler == SIG_IGN);
|
||||
if (ign) /* restore back to IGN! */
|
||||
signal(sig, handler);
|
||||
}
|
||||
return ign << sig; /* pass back knowledge about SIG_IGN */
|
||||
}
|
||||
/* Used only to set handler to restore pgrp on exit, and to reset it to DFL */
|
||||
static void set_fatal_sighandler(void (*handler)(int))
|
||||
{
|
||||
bb_signals(0
|
||||
+ (1 << SIGILL)
|
||||
+ (1 << SIGTRAP)
|
||||
+ (1 << SIGABRT)
|
||||
+ (1 << SIGFPE)
|
||||
+ (1 << SIGBUS)
|
||||
+ (1 << SIGSEGV)
|
||||
unsigned mask = 0;
|
||||
|
||||
if (HUSH_DEBUG) {
|
||||
mask |= maybe_set_sighandler(SIGILL , handler);
|
||||
mask |= maybe_set_sighandler(SIGFPE , handler);
|
||||
mask |= maybe_set_sighandler(SIGBUS , handler);
|
||||
mask |= maybe_set_sighandler(SIGSEGV, handler);
|
||||
mask |= maybe_set_sighandler(SIGTRAP, handler);
|
||||
} /* else: hush is perfect. what SEGV? */
|
||||
|
||||
mask |= maybe_set_sighandler(SIGABRT, handler);
|
||||
|
||||
/* bash 3.2 seems to handle these just like 'fatal' ones */
|
||||
+ (1 << SIGHUP)
|
||||
+ (1 << SIGPIPE)
|
||||
+ (1 << SIGALRM)
|
||||
, handler);
|
||||
mask |= maybe_set_sighandler(SIGPIPE, handler);
|
||||
mask |= maybe_set_sighandler(SIGALRM, handler);
|
||||
mask |= maybe_set_sighandler(SIGHUP , handler);
|
||||
|
||||
/* if we aren't interactive... but in this case
|
||||
* we never want to restore pgrp on exit, and this fn is not called */
|
||||
/*mask |= maybe_set_sighandler(SIGTERM, handler); */
|
||||
/*mask |= maybe_set_sighandler(SIGINT , handler); */
|
||||
|
||||
G.IGN_mask = mask;
|
||||
}
|
||||
static void set_jobctrl_sighandler(void (*handler)(int))
|
||||
/* Used only to suppress ^Z in `cmd` */
|
||||
static void IGN_jobctrl_signals(void)
|
||||
{
|
||||
bb_signals(0
|
||||
+ (1 << SIGTSTP)
|
||||
+ (1 << SIGTTIN)
|
||||
+ (1 << SIGTTOU)
|
||||
, handler);
|
||||
, SIG_IGN);
|
||||
}
|
||||
/* SIGCHLD is special and handled separately */
|
||||
|
||||
static void set_every_sighandler(void (*handler)(int))
|
||||
{
|
||||
set_fatal_sighandler(handler);
|
||||
set_jobctrl_sighandler(handler);
|
||||
set_misc_sighandler(handler);
|
||||
signal(SIGCHLD, handler);
|
||||
}
|
||||
////static void set_every_sighandler(void (*handler)(int))
|
||||
////{
|
||||
//// set_fatal_sighandler(handler);
|
||||
//// set_jobctrl_sighandler(handler);
|
||||
//// set_misc_sighandler(handler);
|
||||
//// signal(SIGCHLD, handler);
|
||||
////}
|
||||
|
||||
static void handler_ctrl_c(int sig UNUSED_PARAM)
|
||||
{
|
||||
debug_printf_jobs("got sig %d\n", sig);
|
||||
// as usual we can have all kinds of nasty problems with leaked malloc data here
|
||||
siglongjmp(G.toplevel_jb, 1);
|
||||
}
|
||||
////static void handler_ctrl_c(int sig UNUSED_PARAM)
|
||||
////{
|
||||
//// debug_printf_jobs("got sig %d\n", sig);
|
||||
////// as usual we can have all kinds of nasty problems with leaked malloc data here
|
||||
//// siglongjmp(G.toplevel_jb, 1);
|
||||
////}
|
||||
|
||||
static void handler_ctrl_z(int sig UNUSED_PARAM)
|
||||
{
|
||||
pid_t pid;
|
||||
|
||||
debug_printf_jobs("got tty sig %d in pid %d\n", sig, getpid());
|
||||
|
||||
if (!BB_MMU) {
|
||||
fputs("Sorry, backgrounding (CTRL+Z) of foreground scripts not supported on nommu\n", stderr);
|
||||
return;
|
||||
}
|
||||
|
||||
pid = fork();
|
||||
if (pid < 0) /* can't fork. Pretend there was no ctrl-Z */
|
||||
return;
|
||||
G.ctrl_z_flag = 1;
|
||||
if (!pid) { /* child */
|
||||
if (ENABLE_HUSH_JOB)
|
||||
die_sleep = 0; /* let nofork's xfuncs die */
|
||||
bb_setpgrp();
|
||||
debug_printf_jobs("set pgrp for child %d ok\n", getpid());
|
||||
set_every_sighandler(SIG_DFL);
|
||||
raise(SIGTSTP); /* resend TSTP so that child will be stopped */
|
||||
debug_printf_jobs("returning in child\n");
|
||||
/* return to nofork, it will eventually exit now,
|
||||
* not return back to shell */
|
||||
return;
|
||||
}
|
||||
/* parent */
|
||||
/* finish filling up pipe info */
|
||||
G.toplevel_list->pgrp = pid; /* child is in its own pgrp */
|
||||
G.toplevel_list->cmds[0].pid = pid;
|
||||
/* parent needs to longjmp out of running nofork.
|
||||
* we will "return" exitcode 0, with child put in background */
|
||||
// as usual we can have all kinds of nasty problems with leaked malloc data here
|
||||
debug_printf_jobs("siglongjmp in parent\n");
|
||||
siglongjmp(G.toplevel_jb, 1);
|
||||
}
|
||||
////static void handler_ctrl_z(int sig UNUSED_PARAM)
|
||||
////{
|
||||
//// pid_t pid;
|
||||
////
|
||||
//// debug_printf_jobs("got tty sig %d in pid %d\n", sig, getpid());
|
||||
////
|
||||
//// if (!BB_MMU) {
|
||||
//// fputs("Sorry, backgrounding (CTRL+Z) of foreground scripts not supported on nommu\n", stderr);
|
||||
//// return;
|
||||
//// }
|
||||
////
|
||||
//// pid = fork();
|
||||
//// if (pid < 0) /* can't fork. Pretend there was no ctrl-Z */
|
||||
//// return;
|
||||
//// G.ctrl_z_flag = 1;
|
||||
//// if (!pid) { /* child */
|
||||
//// if (ENABLE_HUSH_JOB)
|
||||
//// die_sleep = 0; /* let nofork's xfuncs die */
|
||||
//// bb_setpgrp();
|
||||
//// debug_printf_jobs("set pgrp for child %d ok\n", getpid());
|
||||
//////// set_every_sighandler(SIG_DFL);
|
||||
//// raise(SIGTSTP); /* resend TSTP so that child will be stopped */
|
||||
//// debug_printf_jobs("returning in child\n");
|
||||
//// /* return to nofork, it will eventually exit now,
|
||||
//// * not return back to shell */
|
||||
//// return;
|
||||
//// }
|
||||
//// /* parent */
|
||||
//// /* finish filling up pipe info */
|
||||
//// G.toplevel_list->pgrp = pid; /* child is in its own pgrp */
|
||||
//// G.toplevel_list->cmds[0].pid = pid;
|
||||
//// /* parent needs to longjmp out of running nofork.
|
||||
//// * we will "return" exitcode 0, with child put in background */
|
||||
////// as usual we can have all kinds of nasty problems with leaked malloc data here
|
||||
//// debug_printf_jobs("siglongjmp in parent\n");
|
||||
//// siglongjmp(G.toplevel_jb, 1);
|
||||
////}
|
||||
|
||||
/* Restores tty foreground process group, and exits.
|
||||
* May be called as signal handler for fatal signal
|
||||
|
|
@ -865,8 +1042,8 @@ static void sigexit(int sig)
|
|||
|
||||
#else /* !JOB */
|
||||
|
||||
#define set_fatal_sighandler(handler) ((void)0)
|
||||
#define set_jobctrl_sighandler(handler) ((void)0)
|
||||
#define set_fatal_sighandler(handler) ((void)0)
|
||||
#define IGN_jobctrl_signals(handler) ((void)0)
|
||||
|
||||
#endif /* JOB */
|
||||
|
||||
|
|
@ -874,8 +1051,11 @@ static void sigexit(int sig)
|
|||
static void hush_exit(int exitcode) NORETURN;
|
||||
static void hush_exit(int exitcode)
|
||||
{
|
||||
if (G.traps && G.traps[0].cmd)
|
||||
handle_trap(0);
|
||||
if (G.traps && G.traps[0] && G.traps[0][0]) {
|
||||
char *argv[] = { NULL, xstrdup(G.traps[0]), NULL };
|
||||
builtin_eval(argv);
|
||||
free(argv[1]);
|
||||
}
|
||||
|
||||
if (ENABLE_HUSH_JOB) {
|
||||
fflush(NULL); /* flush all streams */
|
||||
|
|
@ -2052,6 +2232,8 @@ static void pseudo_exec_argv(nommu_save_t *nommu_save, char **argv, int assignme
|
|||
}
|
||||
#endif
|
||||
|
||||
sigprocmask(SIG_SETMASK, &G.inherited_set, NULL);
|
||||
|
||||
debug_printf_exec("execing '%s'\n", argv[0]);
|
||||
execvp(argv[0], argv);
|
||||
bb_perror_msg("can't exec '%s'", argv[0]);
|
||||
|
|
@ -2200,6 +2382,8 @@ static int checkjobs(struct pipe* fg_pipe)
|
|||
pid_t childpid;
|
||||
int rcode = 0;
|
||||
|
||||
debug_printf_jobs("checkjobs %p\n", fg_pipe);
|
||||
|
||||
attributes = WUNTRACED;
|
||||
if (fg_pipe == NULL)
|
||||
attributes |= WNOHANG;
|
||||
|
|
@ -2459,7 +2643,7 @@ static int run_pipe(struct pipe *pi)
|
|||
|
||||
/* Disable job control signals for shell (parent) and
|
||||
* for initial child code after fork */
|
||||
set_jobctrl_sighandler(SIG_IGN);
|
||||
//// set_jobctrl_sighandler(SIG_IGN);
|
||||
|
||||
/* Going to fork a child per each pipe member */
|
||||
pi->alive_cmds = 0;
|
||||
|
|
@ -2486,9 +2670,9 @@ static int run_pipe(struct pipe *pi)
|
|||
|
||||
command->pid = BB_MMU ? fork() : vfork();
|
||||
if (!command->pid) { /* child */
|
||||
if (ENABLE_HUSH_JOB)
|
||||
die_sleep = 0; /* let nofork's xfuncs die */
|
||||
#if ENABLE_HUSH_JOB
|
||||
die_sleep = 0; /* let nofork's xfuncs die */
|
||||
|
||||
/* Every child adds itself to new process group
|
||||
* with pgid == pid_of_first_child_in_pipe */
|
||||
if (G.run_list_level == 1 && G.interactive_fd) {
|
||||
|
|
@ -2514,9 +2698,9 @@ static int run_pipe(struct pipe *pi)
|
|||
setup_redirects(command, NULL);
|
||||
|
||||
/* Restore default handlers just prior to exec */
|
||||
set_jobctrl_sighandler(SIG_DFL);
|
||||
set_misc_sighandler(SIG_DFL);
|
||||
signal(SIGCHLD, SIG_DFL);
|
||||
//// set_jobctrl_sighandler(SIG_DFL);
|
||||
//// set_misc_sighandler(SIG_DFL);
|
||||
//// signal(SIGCHLD, SIG_DFL);
|
||||
/* Stores to nommu_save list of env vars putenv'ed
|
||||
* (NOMMU, on MMU we don't need that) */
|
||||
/* cast away volatility... */
|
||||
|
|
@ -2693,6 +2877,8 @@ static int run_list(struct pipe *pi)
|
|||
* in order to return, no direct "return" statements please.
|
||||
* This helps to ensure that no memory is leaked. */
|
||||
|
||||
//TODO: needs re-thinking
|
||||
|
||||
#if ENABLE_HUSH_JOB
|
||||
/* Example of nested list: "while true; do { sleep 1 | exit 2; } done".
|
||||
* We are saving state before entering outermost list ("while...done")
|
||||
|
|
@ -2713,27 +2899,27 @@ static int run_list(struct pipe *pi)
|
|||
restore_nofork_data(&G.nofork_save);
|
||||
}
|
||||
#endif
|
||||
if (G.ctrl_z_flag) {
|
||||
/* ctrl-Z has forked and stored pid of the child in pi->pid.
|
||||
* Remember this child as background job */
|
||||
insert_bg_job(pi);
|
||||
} else {
|
||||
//// if (G.ctrl_z_flag) {
|
||||
//// /* ctrl-Z has forked and stored pid of the child in pi->pid.
|
||||
//// * Remember this child as background job */
|
||||
//// insert_bg_job(pi);
|
||||
//// } else {
|
||||
/* ctrl-C. We just stop doing whatever we were doing */
|
||||
bb_putchar('\n');
|
||||
}
|
||||
//// }
|
||||
USE_HUSH_LOOPS(loop_top = NULL;)
|
||||
USE_HUSH_LOOPS(G.depth_of_loop = 0;)
|
||||
rcode = 0;
|
||||
goto ret;
|
||||
}
|
||||
/* ctrl-Z handler will store pid etc in pi */
|
||||
G.toplevel_list = pi;
|
||||
G.ctrl_z_flag = 0;
|
||||
#if ENABLE_FEATURE_SH_STANDALONE
|
||||
G.nofork_save.saved = 0; /* in case we will run a nofork later */
|
||||
#endif
|
||||
signal_SA_RESTART_empty_mask(SIGTSTP, handler_ctrl_z);
|
||||
signal(SIGINT, handler_ctrl_c);
|
||||
//// /* ctrl-Z handler will store pid etc in pi */
|
||||
//// G.toplevel_list = pi;
|
||||
//// G.ctrl_z_flag = 0;
|
||||
////#if ENABLE_FEATURE_SH_STANDALONE
|
||||
//// G.nofork_save.saved = 0; /* in case we will run a nofork later */
|
||||
////#endif
|
||||
//// signal_SA_RESTART_empty_mask(SIGTSTP, handler_ctrl_z);
|
||||
//// signal(SIGINT, handler_ctrl_c);
|
||||
}
|
||||
#endif /* JOB */
|
||||
|
||||
|
|
@ -2854,11 +3040,17 @@ static int run_list(struct pipe *pi)
|
|||
continue; /* not matched yet, skip this pipe */
|
||||
}
|
||||
#endif
|
||||
if (pi->num_cmds == 0)
|
||||
goto check_jobs_and_continue;
|
||||
/* Just pressing <enter> in shell should check for jobs.
|
||||
* OTOH, in non-interactive shell this is useless
|
||||
* and only leads to extra job checks */
|
||||
if (pi->num_cmds == 0) {
|
||||
if (G.interactive_fd)
|
||||
goto check_jobs_and_continue;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* After analyzing all keywords and conditions, we decided
|
||||
* to execute this pipe. NB: has to do checkjobs(NULL)
|
||||
* to execute this pipe. NB: have to do checkjobs(NULL)
|
||||
* after run_pipe() to collect any background children,
|
||||
* even if list execution is to be stopped. */
|
||||
debug_printf_exec(": run_pipe with %d members\n", pi->num_cmds);
|
||||
|
|
@ -2871,6 +3063,7 @@ static int run_list(struct pipe *pi)
|
|||
if (r != -1) {
|
||||
/* we only ran a builtin: rcode is already known
|
||||
* and we don't need to wait for anything. */
|
||||
check_and_run_traps();
|
||||
#if ENABLE_HUSH_LOOPS
|
||||
/* was it "break" or "continue"? */
|
||||
if (G.flag_break_continue) {
|
||||
|
|
@ -2895,6 +3088,7 @@ static int run_list(struct pipe *pi)
|
|||
/* even bash 3.2 doesn't do that well with nested bg:
|
||||
* try "{ { sleep 10; echo DEEP; } & echo HERE; } &".
|
||||
* I'm NOT treating inner &'s as jobs */
|
||||
check_and_run_traps();
|
||||
#if ENABLE_HUSH_JOB
|
||||
if (G.run_list_level == 1)
|
||||
insert_bg_job(pi);
|
||||
|
|
@ -2905,11 +3099,13 @@ static int run_list(struct pipe *pi)
|
|||
if (G.run_list_level == 1 && G.interactive_fd) {
|
||||
/* waits for completion, then fg's main shell */
|
||||
rcode = checkjobs_and_fg_shell(pi);
|
||||
check_and_run_traps();
|
||||
debug_printf_exec(": checkjobs_and_fg_shell returned %d\n", rcode);
|
||||
} else
|
||||
#endif
|
||||
{ /* this one just waits for completion */
|
||||
rcode = checkjobs(pi);
|
||||
check_and_run_traps();
|
||||
debug_printf_exec(": checkjobs returned %d\n", rcode);
|
||||
}
|
||||
}
|
||||
|
|
@ -2948,17 +3144,18 @@ static int run_list(struct pipe *pi)
|
|||
} /* for (pi) */
|
||||
|
||||
#if ENABLE_HUSH_JOB
|
||||
if (G.ctrl_z_flag) {
|
||||
/* ctrl-Z forked somewhere in the past, we are the child,
|
||||
* and now we completed running the list. Exit. */
|
||||
//TODO: _exit?
|
||||
exit(rcode);
|
||||
}
|
||||
//// if (G.ctrl_z_flag) {
|
||||
//// /* ctrl-Z forked somewhere in the past, we are the child,
|
||||
//// * and now we completed running the list. Exit. */
|
||||
//////TODO: _exit?
|
||||
//// exit(rcode);
|
||||
//// }
|
||||
ret:
|
||||
if (!--G.run_list_level && G.interactive_fd) {
|
||||
signal(SIGTSTP, SIG_IGN);
|
||||
signal(SIGINT, SIG_IGN);
|
||||
}
|
||||
G.run_list_level--;
|
||||
//// if (!G.run_list_level && G.interactive_fd) {
|
||||
//// signal(SIGTSTP, SIG_IGN);
|
||||
//// signal(SIGINT, SIG_IGN);
|
||||
//// }
|
||||
#endif
|
||||
debug_printf_exec("run_list lvl %d return %d\n", G.run_list_level + 1, rcode);
|
||||
#if ENABLE_HUSH_LOOPS
|
||||
|
|
@ -3478,10 +3675,10 @@ static FILE *generate_stream_from_list(struct pipe *head)
|
|||
/* Process substitution is not considered to be usual
|
||||
* 'command execution'.
|
||||
* SUSv3 says ctrl-Z should be ignored, ctrl-C should not. */
|
||||
/* Not needed, we are relying on it being disabled
|
||||
* everywhere outside actual command execution. */
|
||||
/*set_jobctrl_sighandler(SIG_IGN);*/
|
||||
set_misc_sighandler(SIG_DFL);
|
||||
//// /* Not needed, we are relying on it being disabled
|
||||
//// * everywhere outside actual command execution. */
|
||||
IGN_jobctrl_signals();
|
||||
//// set_misc_sighandler(SIG_DFL);
|
||||
/* Freeing 'head' here would break NOMMU. */
|
||||
_exit(run_list(head));
|
||||
}
|
||||
|
|
@ -4287,7 +4484,6 @@ static void setup_job_control(void)
|
|||
pid_t shell_pgrp;
|
||||
|
||||
shell_pgrp = getpgrp();
|
||||
close_on_exec_on(G.interactive_fd);
|
||||
|
||||
/* If we were ran as 'hush &',
|
||||
* sleep until we are in the foreground. */
|
||||
|
|
@ -4298,8 +4494,8 @@ static void setup_job_control(void)
|
|||
}
|
||||
|
||||
/* Ignore job-control and misc signals. */
|
||||
set_jobctrl_sighandler(SIG_IGN);
|
||||
set_misc_sighandler(SIG_IGN);
|
||||
//// set_jobctrl_sighandler(SIG_IGN);
|
||||
//// set_misc_sighandler(SIG_IGN);
|
||||
//huh? signal(SIGCHLD, SIG_IGN);
|
||||
|
||||
/* We _must_ restore tty pgrp on fatal signals */
|
||||
|
|
@ -4312,6 +4508,16 @@ static void setup_job_control(void)
|
|||
}
|
||||
#endif
|
||||
|
||||
static int set_mode(const char cstate, const char mode)
|
||||
{
|
||||
int state = (cstate == '-' ? 1 : 0);
|
||||
switch (mode) {
|
||||
case 'n': G.fake_mode = state; break;
|
||||
case 'x': /*G.debug_mode = state;*/ break;
|
||||
default: return EXIT_FAILURE;
|
||||
}
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
int hush_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int hush_main(int argc, char **argv)
|
||||
|
|
@ -4408,7 +4614,7 @@ int hush_main(int argc, char **argv)
|
|||
break;
|
||||
case 'n':
|
||||
case 'x':
|
||||
if (!builtin_set_mode('-', opt))
|
||||
if (!set_mode('-', opt))
|
||||
break;
|
||||
default:
|
||||
#ifndef BB_VER
|
||||
|
|
@ -4447,6 +4653,7 @@ int hush_main(int argc, char **argv)
|
|||
// to (inadvertently) close/redirect it
|
||||
}
|
||||
}
|
||||
init_signal_mask();
|
||||
debug_printf("G.interactive_fd=%d\n", G.interactive_fd);
|
||||
if (G.interactive_fd) {
|
||||
fcntl(G.interactive_fd, F_SETFD, FD_CLOEXEC);
|
||||
|
|
@ -4475,9 +4682,10 @@ int hush_main(int argc, char **argv)
|
|||
}
|
||||
if (G.interactive_fd) {
|
||||
fcntl(G.interactive_fd, F_SETFD, FD_CLOEXEC);
|
||||
set_misc_sighandler(SIG_IGN);
|
||||
//// set_misc_sighandler(SIG_IGN);
|
||||
}
|
||||
}
|
||||
init_signal_mask();
|
||||
#endif
|
||||
|
||||
#if ENABLE_HUSH_INTERACTIVE && !ENABLE_FEATURE_SH_EXTRA_QUIET
|
||||
|
|
@ -4530,93 +4738,63 @@ int lash_main(int argc, char **argv)
|
|||
/*
|
||||
* Built-ins
|
||||
*/
|
||||
/* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#trap
|
||||
*
|
||||
* Traps are also evaluated immediately instead of being delayed properly:
|
||||
* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_11
|
||||
* Example: hush -c 'trap "echo hi" 31; sleep 10; echo moo' & sleep 1; kill -31 $!
|
||||
* "hi" should not be displayed until the sleep finishes
|
||||
* This will have to get fixed ...
|
||||
*/
|
||||
static void handle_trap(int sig)
|
||||
{
|
||||
int save_errno, save_rcode;
|
||||
char *argv[] = { NULL, G.traps[sig].cmd, NULL };
|
||||
/* Race! We transitioned from handled to ignore/default, but
|
||||
* the signal came in after updating .cmd but before we could
|
||||
* register the new signal handler.
|
||||
*/
|
||||
if (!argv[1] || argv[1][0] == '\0')
|
||||
return;
|
||||
/* need to save/restore errno/$? across traps */
|
||||
save_errno = errno;
|
||||
save_rcode = G.last_return_code;
|
||||
builtin_eval(argv);
|
||||
errno = save_errno;
|
||||
G.last_return_code = save_rcode;
|
||||
}
|
||||
static int builtin_trap(char **argv)
|
||||
{
|
||||
size_t i;
|
||||
int i;
|
||||
int sig;
|
||||
bool ign = false;
|
||||
char *new_cmd = NULL;
|
||||
char *new_cmd;
|
||||
|
||||
if (!G.traps)
|
||||
G.traps = xzalloc(sizeof(*G.traps) * NSIG);
|
||||
G.traps = xzalloc(sizeof(G.traps[0]) * NSIG);
|
||||
|
||||
if (!argv[1]) {
|
||||
/* No args: print all trapped. This isn't 100% correct as we should
|
||||
* be escaping the cmd so that it can be pasted back in ...
|
||||
*/
|
||||
for (i = 0; i < NSIG; ++i)
|
||||
if (G.traps[i].cmd)
|
||||
printf("trap -- '%s' %s\n", G.traps[i].cmd, get_signame(i));
|
||||
if (G.traps[i])
|
||||
printf("trap -- '%s' %s\n", G.traps[i], get_signame(i));
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
/* first arg is decimal: reset all specified */
|
||||
sig = bb_strtou(argv[1], NULL, 10);
|
||||
new_cmd = NULL;
|
||||
i = 0;
|
||||
/* if first arg is decimal: reset all specified */
|
||||
sig = bb_strtou(*++argv, NULL, 10);
|
||||
if (errno == 0) {
|
||||
int ret;
|
||||
i = 0;
|
||||
set_all:
|
||||
ret = EXIT_SUCCESS;
|
||||
while (argv[++i]) {
|
||||
char *old_cmd;
|
||||
|
||||
sig = get_signum(argv[i]);
|
||||
while (*argv) {
|
||||
sig = get_signum(*argv++);
|
||||
if (sig < 0 || sig >= NSIG) {
|
||||
ret = EXIT_FAILURE;
|
||||
/* mimic bash message exactly */
|
||||
bb_perror_msg("trap: %s: invalid signal specification", argv[i]);
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Make sure .cmd is always a valid command list since
|
||||
* signals can occur at any time ...
|
||||
*/
|
||||
old_cmd = G.traps[sig].cmd;
|
||||
G.traps[sig].cmd = xstrdup(new_cmd);
|
||||
free(old_cmd);
|
||||
free(G.traps[sig]);
|
||||
G.traps[sig] = xstrdup(new_cmd);
|
||||
|
||||
debug_printf("trap: setting SIG%s (%i) to: %s",
|
||||
get_signame(sig), sig, G.traps[sig].cmd);
|
||||
debug_printf("trap: setting SIG%s (%i) to '%s'",
|
||||
get_signame(sig), sig, G.traps[sig]);
|
||||
|
||||
/* There is no signal for 0 (EXIT) */
|
||||
if (sig == 0)
|
||||
continue;
|
||||
|
||||
if (new_cmd) {
|
||||
/* add/update a handler */
|
||||
struct sigaction act = {
|
||||
.sa_handler = ign ? SIG_IGN : handle_trap,
|
||||
.sa_flags = SA_RESTART,
|
||||
};
|
||||
sigemptyset(&act.sa_mask);
|
||||
sigaction(sig, &act, old_cmd ? NULL : &G.traps[sig].oact);
|
||||
} else if (old_cmd && !new_cmd)
|
||||
/* there was a handler, and we are removing it */
|
||||
sigaction_set(sig, &G.traps[sig].oact);
|
||||
sigaddset(&G.blocked_set, sig);
|
||||
} else {
|
||||
/* there was a trap handler, we are removing it
|
||||
* (if sig has non-DFL handling,
|
||||
* we don't need to do anything) */
|
||||
if (sig < 32 && (G.non_DFL_mask & (1 << sig)))
|
||||
continue;
|
||||
sigdelset(&G.blocked_set, sig);
|
||||
}
|
||||
sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -4624,17 +4802,15 @@ static int builtin_trap(char **argv)
|
|||
/* first arg is "-": reset all specified to default */
|
||||
/* first arg is "": ignore all specified */
|
||||
/* everything else: execute first arg upon signal */
|
||||
if (!argv[2]) {
|
||||
if (!argv[1]) {
|
||||
bb_error_msg("trap: invalid arguments");
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
if (LONE_DASH(argv[1]))
|
||||
if (LONE_DASH(*argv))
|
||||
/* nothing! */;
|
||||
else
|
||||
new_cmd = argv[1];
|
||||
if (argv[1][0] == '\0')
|
||||
ign = true;
|
||||
i = 1;
|
||||
new_cmd = *argv;
|
||||
argv++;
|
||||
goto set_all;
|
||||
}
|
||||
|
||||
|
|
@ -4891,16 +5067,6 @@ static int builtin_read(char **argv)
|
|||
*
|
||||
* So far, we only support "set -- [argument...]" and some of the short names.
|
||||
*/
|
||||
static int builtin_set_mode(const char cstate, const char mode)
|
||||
{
|
||||
int state = (cstate == '-' ? 1 : 0);
|
||||
switch (mode) {
|
||||
case 'n': G.fake_mode = state; break;
|
||||
case 'x': /*G.debug_mode = state;*/ break;
|
||||
default: return EXIT_FAILURE;
|
||||
}
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
static int builtin_set(char **argv)
|
||||
{
|
||||
int n;
|
||||
|
|
@ -4922,7 +5088,7 @@ static int builtin_set(char **argv)
|
|||
|
||||
if (arg[0] == '+' || arg[0] == '-') {
|
||||
for (n = 1; arg[n]; ++n)
|
||||
if (builtin_set_mode(arg[0], arg[n]))
|
||||
if (set_mode(arg[0], arg[n]))
|
||||
goto error;
|
||||
continue;
|
||||
}
|
||||
|
|
@ -5068,27 +5234,29 @@ static int builtin_wait(char **argv)
|
|||
int ret = EXIT_SUCCESS;
|
||||
int status;
|
||||
|
||||
if (argv[1] == NULL)
|
||||
if (*++argv == NULL)
|
||||
/* don't care about exit status */
|
||||
wait(&status);
|
||||
wait(NULL);
|
||||
|
||||
while (argv[1]) {
|
||||
pid_t pid = bb_strtou(argv[1], NULL, 10);
|
||||
while (*argv) {
|
||||
pid_t pid = bb_strtou(*argv, NULL, 10);
|
||||
if (errno) {
|
||||
bb_perror_msg("wait %s", argv[1]);
|
||||
/* mimic bash message */
|
||||
bb_error_msg("wait: '%s': not a pid or valid job spec", *argv);
|
||||
return EXIT_FAILURE;
|
||||
} else if (waitpid(pid, &status, 0) == pid) {
|
||||
}
|
||||
if (waitpid(pid, &status, 0) == pid) {
|
||||
if (WIFSIGNALED(status))
|
||||
ret = 128 + WTERMSIG(status);
|
||||
else if (WIFEXITED(status))
|
||||
ret = WEXITSTATUS(status);
|
||||
else
|
||||
else /* wtf? */
|
||||
ret = EXIT_FAILURE;
|
||||
} else {
|
||||
bb_perror_msg("wait %s", argv[1]);
|
||||
bb_perror_msg("wait %s", *argv);
|
||||
ret = 127;
|
||||
}
|
||||
++argv;
|
||||
argv++;
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user