hush: fix wait builtin

function                                             old     new   delta
builtin_wait                                         174     275    +101
sigwaitinfo                                            -      48     +48
__GI_sigwaitinfo                                       -      48     +48
check_and_run_traps                                  133     169     +36
checkjobs                                            349     380     +31
hush_main                                            971     991     +20
static.zero_timespec                                   -       8      +8
run_list                                            2010    2016      +6
file_get                                             254     260      +6
static.zero_ts                                         8       -      -8
------------------------------------------------------------------------------
(add/remove: 3/1 grow/shrink: 6/0 up/down: 304/-8)            Total: 296 bytes

1 files changed, 99 insertions, 31 deletions

diff --git a/shell/hush.c b/shell/hush.c
index de3b56d21..af6763517 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -491,13 +491,14 @@ struct globals {
 	unsigned char charmap[256];
 	char user_input_buf[ENABLE_FEATURE_EDITING ? BUFSIZ : 2];
 	/* Signal and trap handling */
-	char **traps; /* char *traps[NSIG] */
+//	unsigned count_SIGCHLD;
+//	unsigned handled_SIGCHLD;
 	/* which signals have non-DFL handler (even with no traps set)? */
 	unsigned non_DFL_mask;
+	char **traps; /* char *traps[NSIG] */
 	sigset_t blocked_set;
 	sigset_t inherited_set;
 };
-
 #define G (*ptr_to_globals)
 /* Not #defining name to G.name - this quickly gets unwieldy
  * (too many defines). Also, I actually prefer to see when a variable
@@ -829,12 +830,18 @@ static void free_strings(char **strings)
  *    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.
+ * Note: as a result, we do not use signal handlers much. The only uses
+ * are to count SIGCHLDs [disabled - bug somewhere, + bloat]
+ * and to restore tty pgrp on signal-induced exit.
  *
  * TODO: check/fix wait builtin to be interruptible.
  */
 
+//static void SIGCHLD_handler(int sig UNUSED_PARAM)
+//{
+//	G.count_SIGCHLD++;
+//}
+
 /* called once at shell init */
 static void init_signal_mask(void)
 {
@@ -863,20 +870,24 @@ static void init_signal_mask(void)
 		mask >>= 1;
 		sig++;
 	}
+	sigdelset(&G.blocked_set, SIGCHLD);
 	sigprocmask(SIG_SETMASK, &G.blocked_set, &G.inherited_set);
 }
 
-static void check_and_run_traps(void)
+static int check_and_run_traps(int sig)
 {
-	static const struct timespec zero_ts = { 0, 0 };
+	static const struct timespec zero_timespec = { 0, 0 };
 	smalluint save_rcode;
-	int sig;
+	int last_sig = 0;
 
+	if (sig)
+		goto jump_in;
 	while (1) {
-		sig = sigtimedwait(&G.blocked_set, NULL, &zero_ts);
+		sig = sigtimedwait(&G.blocked_set, NULL, &zero_timespec);
 		if (sig <= 0)
 			break;
-
+ jump_in:
+		last_sig = sig;
 		if (G.traps && G.traps[sig]) {
 			if (G.traps[sig][0]) {
 				/* We have user-defined handler */
@@ -890,7 +901,11 @@ static void check_and_run_traps(void)
 		}
 		/* not a trap: special action */
 		switch (sig) {
+//		case SIGCHLD:
+//			G.count_SIGCHLD++;
+//			break;
 		case SIGINT:
+			bb_putchar('\n');
 			G.flag_SIGINT = 1;
 			break;
 //TODO
@@ -900,6 +915,7 @@ static void check_and_run_traps(void)
 			break;
 		}
 	}
+	return last_sig;
 }
 
 #if ENABLE_HUSH_JOB
@@ -1209,7 +1225,7 @@ static void get_user_input(struct in_str *i)
 		 * only after <Enter>. (^C will work) */
 		r = read_line_input(prompt_str, G.user_input_buf, BUFSIZ-1, G.line_input_state);
 		/* catch *SIGINT* etc (^C is handled by read_line_input) */
-		check_and_run_traps();
+		check_and_run_traps(0);
 	} while (r == 0 || G.flag_SIGINT); /* repeat if ^C or SIGINT */
 	i->eof_flag = (r < 0);
 	if (i->eof_flag) { /* EOF/error detected */
@@ -1223,7 +1239,7 @@ static void get_user_input(struct in_str *i)
 		fflush(stdout);
 		G.user_input_buf[0] = r = fgetc(i->file);
 		/*G.user_input_buf[1] = '\0'; - already is and never changed */
-//do we need check_and_run_traps()? (maybe only if stdin)
+//do we need check_and_run_traps(0)? (maybe only if stdin)
 	} while (G.flag_SIGINT);
 	i->eof_flag = (r == EOF);
 #endif
@@ -2329,6 +2345,11 @@ static int checkjobs(struct pipe* fg_pipe)
 
 	debug_printf_jobs("checkjobs %p\n", fg_pipe);
 
+	errno = 0;
+//	if (G.handled_SIGCHLD == G.count_SIGCHLD)
+//		/* avoid doing syscall, nothing there anyway */
+//		return rcode;
+
 	attributes = WUNTRACED;
 	if (fg_pipe == NULL)
 		attributes |= WNOHANG;
@@ -2346,10 +2367,21 @@ static int checkjobs(struct pipe* fg_pipe)
 // + killall -STOP cat
 
  wait_more:
-// TODO: safe_waitpid?
-	while ((childpid = waitpid(-1, &status, attributes)) > 0) {
+	while (1) {
 		int i;
-		const int dead = WIFEXITED(status) || WIFSIGNALED(status);
+		int dead;
+
+//		i = G.count_SIGCHLD;
+		childpid = waitpid(-1, &status, attributes);
+		if (childpid <= 0) {
+			if (childpid && errno != ECHILD)
+				bb_perror_msg("waitpid");
+//			else /* Until next SIGCHLD, waitpid's are useless */
+//				G.handled_SIGCHLD = i;
+			break;
+		}
+		dead = WIFEXITED(status) || WIFSIGNALED(status);
+
 #if DEBUG_JOBS
 		if (WIFSTOPPED(status))
 			debug_printf_jobs("pid %d stopped by sig %d (exitcode %d)\n",
@@ -2428,10 +2460,6 @@ static int checkjobs(struct pipe* fg_pipe)
 #endif
 	} /* while (waitpid succeeds)... */
 
-	/* wait found no children or failed */
-
-	if (childpid && errno != ECHILD)
-		bb_perror_msg("waitpid");
 	return rcode;
 }
 
@@ -3004,7 +3032,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();
+				check_and_run_traps(0);
 #if ENABLE_HUSH_LOOPS
 				/* was it "break" or "continue"? */
 				if (G.flag_break_continue) {
@@ -3029,7 +3057,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();
+				check_and_run_traps(0);
 #if ENABLE_HUSH_JOB
 				if (G.run_list_level == 1)
 					insert_bg_job(pi);
@@ -3040,13 +3068,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();
+					check_and_run_traps(0);
 					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();
+					check_and_run_traps(0);
 					debug_printf_exec(": checkjobs returned %d\n", rcode);
 				}
 			}
@@ -3668,9 +3696,9 @@ static int process_command_subs(o_string *dest,
 	}
 
 	debug_printf("done reading from pipe, pclose()ing\n");
-	/* This is the step that wait()s for the child.  Should be pretty
+	/* This is the step that waits for the child.  Should be pretty
 	 * safe, since we just read an EOF from its stdout.  We could try
-	 * to do better, by using wait(), and keeping track of background jobs
+	 * to do better, by using waitpid, and keeping track of background jobs
 	 * at the same time.  That would be a lot of work, and contrary
 	 * to the KISS philosophy of this program. */
 	retcode = fclose(p);
@@ -4586,7 +4614,7 @@ int hush_main(int argc, char **argv)
 			// to (inadvertently) close/redirect it
 		}
 	}
-	init_signal_mask();
+	init_signal_mask(); /* note: ensures SIGCHLD is not masked */
 	debug_printf("G.interactive_fd=%d\n", G.interactive_fd);
 	if (G.interactive_fd) {
 		fcntl(G.interactive_fd, F_SETFD, FD_CLOEXEC);
@@ -4617,8 +4645,12 @@ int hush_main(int argc, char **argv)
 			fcntl(G.interactive_fd, F_SETFD, FD_CLOEXEC);
 		}
 	}
-	init_signal_mask();
+	init_signal_mask(); /* note: ensures SIGCHLD is not masked */
 #endif
+	/* POSIX allows shell to re-enable SIGCHLD
+	 * even if it was SIG_IGN on entry */
+//	G.count_SIGCHLD++; /* ensure it is != G.handled_SIGCHLD */
+	signal(SIGCHLD, SIG_DFL); // SIGCHLD_handler);
 
 #if ENABLE_HUSH_INTERACTIVE && !ENABLE_FEATURE_SH_EXTRA_QUIET
 	if (G.interactive_fd) {
@@ -5164,12 +5196,48 @@ static int builtin_unset(char **argv)
 static int builtin_wait(char **argv)
 {
 	int ret = EXIT_SUCCESS;
-	int status;
-
-	if (*++argv == NULL)
-		/* don't care about exit status */
-		wait(NULL);
+	int status, sig;
+
+	if (*++argv == NULL) {
+		/* Don't care about wait results */
+		/* Note 1: must wait until there are no more children */
+		/* Note 2: must be interruptible */
+		/* Examples:
+		 * $ sleep 3 & sleep 6 & wait
+		 * [1] 30934 sleep 3
+		 * [2] 30935 sleep 6
+		 * [1] Done                   sleep 3
+		 * [2] Done                   sleep 6
+		 * $ sleep 3 & sleep 6 & wait
+		 * [1] 30936 sleep 3
+		 * [2] 30937 sleep 6
+		 * [1] Done                   sleep 3
+		 * ^C <-- after ~4 sec from keyboard
+		 * $
+		 */
+		sigaddset(&G.blocked_set, SIGCHLD);
+		sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
+		while (1) {
+			checkjobs(NULL);
+			if (errno == ECHILD)
+				break;
+			/* Wait for SIGCHLD or any other signal of interest */
+			/* sigtimedwait with infinite timeout: */
+			sig = sigwaitinfo(&G.blocked_set, NULL);
+			if (sig > 0) {
+				sig = check_and_run_traps(sig);
+				if (sig && sig != SIGCHLD) { /* see note 2 */
+					ret = 128 + sig;
+					break;
+				}
+			}
+		}
+		sigdelset(&G.blocked_set, SIGCHLD);
+		sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
+		return ret;
+	}
 
+	/* This is probably buggy wrt interruptible-ness */
 	while (*argv) {
 		pid_t pid = bb_strtou(*argv, NULL, 10);
 		if (errno) {