Merge commit 'da4441c44f6efccb6f7b7588404d9c6bfb7b6af8' into merge

Conflicts:
	libbb/vfork_daemon_rexec.c
	networking/wget.c
	procps/ps.c

13 files changed, 220 insertions, 47 deletions

diff --git a/shell/Config.src b/shell/Config.src
index c9c2439e7..e96c21620 100644
--- a/shell/Config.src
+++ b/shell/Config.src
@@ -123,9 +123,9 @@ config FEATURE_SH_NOFORK
         default n
         depends on (HUSH || ASH) && FEATURE_PREFER_APPLETS
         help
-          This option causes busybox shells [currently only ash]
-          to not execute typical fork/exec/wait sequence, but call <applet>_main
-          directly, if possible. (Sometimes it is not possible: for example,
+          This option causes busybox shells to not execute typical
+          fork/exec/wait sequence, but call <applet>_main directly,
+          if possible. (Sometimes it is not possible: for example,
           this is not possible in pipes).
 
           This will be done only for some applets (those which are marked
@@ -133,6 +133,7 @@ config FEATURE_SH_NOFORK
 
           This may significantly speed up some shell scripts.
 
-          This feature is relatively new. Use with care.
+          This feature is relatively new. Use with care. Report bugs
+          to project mailing list.
 
 endmenu
diff --git a/shell/ash.c b/shell/ash.c
index 28f988698..fd9141661 100644
--- a/shell/ash.c
+++ b/shell/ash.c
@@ -111,6 +111,13 @@
 //config:       help
 //config:         Enable bash-compatible extensions.
 //config:
+//config:config ASH_IDLE_TIMEOUT
+//config:       bool "Idle timeout variable"
+//config:       default n
+//config:       depends on ASH
+//config:       help
+//config:         Enables bash-like auto-logout after $TMOUT seconds of idle time.
+//config:
 //config:config ASH_JOB_CONTROL
 //config:       bool "Job control"
 //config:       default y
@@ -119,7 +126,7 @@
 //config:         Enable job control in the ash shell.
 //config:
 //config:config ASH_ALIAS
-//config:       bool "alias support"
+//config:       bool "Alias support"
 //config:       default y
 //config:       depends on ASH
 //config:       help
@@ -130,28 +137,28 @@
 //config:       default y
 //config:       depends on ASH
 //config:       help
-//config:         Enable getopts builtin in the ash shell.
+//config:         Enable support for getopts builtin in ash.
 //config:
 //config:config ASH_BUILTIN_ECHO
 //config:       bool "Builtin version of 'echo'"
 //config:       default y
 //config:       depends on ASH
 //config:       help
-//config:         Enable support for echo, builtin to ash.
+//config:         Enable support for echo builtin in ash.
 //config:
 //config:config ASH_BUILTIN_PRINTF
 //config:       bool "Builtin version of 'printf'"
 //config:       default y
 //config:       depends on ASH
 //config:       help
-//config:         Enable support for printf, builtin to ash.
+//config:         Enable support for printf builtin in ash.
 //config:
 //config:config ASH_BUILTIN_TEST
 //config:       bool "Builtin version of 'test'"
 //config:       default y
 //config:       depends on ASH
 //config:       help
-//config:         Enable support for test, builtin to ash.
+//config:         Enable support for test builtin in ash.
 //config:
 //config:config ASH_CMDCMD
 //config:       bool "'command' command to override shell builtins"
@@ -167,7 +174,7 @@
 //config:       default n
 //config:       depends on ASH
 //config:       help
-//config:         Enable "check for new mail" in the ash shell.
+//config:         Enable "check for new mail" function in the ash shell.
 //config:
 //config:config ASH_OPTIMIZE_FOR_SIZE
 //config:       bool "Optimize for size instead of speed"
@@ -449,6 +456,9 @@ static const char *var_end(const char *var)
 
 
 /* ============ Interrupts / exceptions */
+
+static void exitshell(void) NORETURN;
+
 /*
  * These macros allow the user to suspend the handling of interrupt signals
  * over a period of time.  This is similar to SIGHOLD or to sigblock, but
@@ -1929,7 +1939,9 @@ change_lc_ctype(const char *value)
 #endif
 #if ENABLE_ASH_MAIL
 static void chkmail(void);
-static void changemail(const char *) FAST_FUNC;
+static void changemail(const char *var_value) FAST_FUNC;
+#else
+# define chkmail()  ((void)0)
 #endif
 static void changepath(const char *) FAST_FUNC;
 #if ENABLE_ASH_RANDOM_SUPPORT
@@ -3937,18 +3949,51 @@ setjobctl(int on)
 static int FAST_FUNC
 killcmd(int argc, char **argv)
 {
-        int i = 1;
         if (argv[1] && strcmp(argv[1], "-l") != 0) {
+                int i = 1;
                 do {
                         if (argv[i][0] == '%') {
-                                struct job *jp = getjob(argv[i], 0);
-                                unsigned pid = jp->ps[0].ps_pid;
-                                /* Enough space for ' -NNN<nul>' */
-                                argv[i] = alloca(sizeof(int)*3 + 3);
-                                /* kill_main has matching code to expect
-                                 * leading space. Needed to not confuse
-                                 * negative pids with "kill -SIGNAL_NO" syntax */
-                                sprintf(argv[i], " -%u", pid);
+                                /*
+                                 * "kill %N" - job kill
+                                 * Converting to pgrp / pid kill
+                                 */
+                                struct job *jp;
+                                char *dst;
+                                int j, n;
+
+                                jp = getjob(argv[i], 0);
+                                /*
+                                 * In jobs started under job control, we signal
+                                 * entire process group by kill -PGRP_ID.
+                                 * This happens, f.e., in interactive shell.
+                                 *
+                                 * Otherwise, we signal each child via
+                                 * kill PID1 PID2 PID3.
+                                 * Testcases:
+                                 * sh -c 'sleep 1|sleep 1 & kill %1'
+                                 * sh -c 'true|sleep 2 & sleep 1; kill %1'
+                                 * sh -c 'true|sleep 1 & sleep 2; kill %1'
+                                 */
+                                n = jp->nprocs; /* can't be 0 (I hope) */
+                                if (jp->jobctl)
+                                        n = 1;
+                                dst = alloca(n * sizeof(int)*4);
+                                argv[i] = dst;
+                                for (j = 0; j < n; j++) {
+                                        struct procstat *ps = &jp->ps[j];
+                                        /* Skip non-running and not-stopped members
+                                         * (i.e. dead members) of the job
+                                         */
+                                        if (ps->ps_status != -1 && !WIFSTOPPED(ps->ps_status))
+                                                continue;
+                                        /*
+                                         * kill_main has matching code to expect
+                                         * leading space. Needed to not confuse
+                                         * negative pids with "kill -SIGNAL_NO" syntax
+                                         */
+                                        dst += sprintf(dst, jp->jobctl ? " -%u" : " %u", (int)ps->ps_pid);
+                                }
+                                *dst = '\0';
                         }
                 } while (argv[++i]);
         }
@@ -4046,6 +4091,7 @@ sprint_status(char *s, int status, int sigonly)
 #endif
                 }
                 st &= 0x7f;
+//TODO: use bbox's get_signame? strsignal adds ~600 bytes to text+rodata
                 col = fmtstr(s, 32, strsignal(st));
                 if (WCOREDUMP(status)) {
                         col += fmtstr(s + col, 16, " (core dumped)");
@@ -4462,8 +4508,9 @@ waitcmd(int argc UNUSED_PARAM, char **argv)
                                         break;
                                 job = job->prev_job;
                         }
-                } else
+                } else {
                         job = getjob(*argv, 0);
+                }
                 /* loop until process terminated or stopped */
                 while (job->state == JOBRUNNING)
                         blocking_wait_with_raise_on_sig();
@@ -4959,7 +5006,7 @@ forkchild(struct job *jp, union node *n, int mode)
 #if JOBS
         /* do job control only in root shell */
         doing_jobctl = 0;
-        if (mode != FORK_NOJOB && jp->jobctl && !oldlvl) {
+        if (mode != FORK_NOJOB && jp->jobctl && oldlvl == 0) {
                 pid_t pgrp;
 
                 if (jp->nprocs == 0)
@@ -4985,7 +5032,7 @@ forkchild(struct job *jp, union node *n, int mode)
                                 ash_msg_and_raise_error("can't open '%s'", bb_dev_null);
                 }
         }
-        if (!oldlvl) {
+        if (oldlvl == 0) {
                 if (iflag) { /* why if iflag only? */
                         setsignal(SIGINT);
                         setsignal(SIGTERM);
@@ -10065,10 +10112,21 @@ preadfd(void)
         if (!iflag || g_parsefile->pf_fd != STDIN_FILENO)
                 nr = nonblock_safe_read(g_parsefile->pf_fd, buf, IBUFSIZ - 1);
         else {
-#if ENABLE_FEATURE_TAB_COMPLETION
+                int timeout = -1;
+# if ENABLE_ASH_IDLE_TIMEOUT
+                if (iflag) {
+                        const char *tmout_var = lookupvar("TMOUT");
+                        if (tmout_var) {
+                                timeout = atoi(tmout_var) * 1000;
+                                if (timeout <= 0)
+                                        timeout = -1;
+                        }
+                }
+# endif
+# if ENABLE_FEATURE_TAB_COMPLETION
                 line_input_state->path_lookup = pathval();
-#endif
-                nr = read_line_input(cmdedit_prompt, buf, IBUFSIZ, line_input_state);
+# endif
+                nr = read_line_input(line_input_state, cmdedit_prompt, buf, IBUFSIZ, timeout);
                 if (nr == 0) {
                         /* Ctrl+C pressed */
                         if (trap[SIGINT]) {
@@ -10079,17 +10137,24 @@ preadfd(void)
                         }
                         goto retry;
                 }
-                if (nr < 0 && errno == 0) {
-                        /* Ctrl+D pressed */
-                        nr = 0;
+                if (nr < 0) {
+                        if (errno == 0) {
+                                /* Ctrl+D pressed */
+                                nr = 0;
+                        }
+# if ENABLE_ASH_IDLE_TIMEOUT
+                        else if (errno == EAGAIN && timeout > 0) {
+                                printf("\007timed out waiting for input: auto-logout\n");
+                                exitshell();
+                        }
+# endif
                 }
         }
 #else
         nr = nonblock_safe_read(g_parsefile->pf_fd, buf, IBUFSIZ - 1);
 #endif
 
-#if 0
-/* nonblock_safe_read() handles this problem */
+#if 0 /* disabled: nonblock_safe_read() handles this problem */
         if (nr < 0) {
                 if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
                         int flags = fcntl(0, F_GETFL);
@@ -12574,9 +12639,7 @@ cmdloop(int top)
                 inter = 0;
                 if (iflag && top) {
                         inter++;
-#if ENABLE_ASH_MAIL
                         chkmail();
-#endif
                 }
                 n = parsecmd(inter);
 #if DEBUG
@@ -13346,7 +13409,6 @@ ulimitcmd(int argc UNUSED_PARAM, char **argv)
 /*
  * Called to exit the shell.
  */
-static void exitshell(void) NORETURN;
 static void
 exitshell(void)
 {
diff --git a/shell/ash_test/ash-misc/echo_write_error.right b/shell/ash_test/ash-misc/echo_write_error.right
new file mode 100644
index 000000000..3e91a13d3
--- /dev/null
+++ b/shell/ash_test/ash-misc/echo_write_error.right
@@ -0,0 +1,2 @@
+ash: write error: Broken pipe
+Ok: 1
diff --git a/shell/ash_test/ash-misc/echo_write_error.tests b/shell/ash_test/ash-misc/echo_write_error.tests
new file mode 100644
index 000000000..0a40c9ff7
--- /dev/null
+++ b/shell/ash_test/ash-misc/echo_write_error.tests
@@ -0,0 +1,7 @@
+trap "" PIPE
+
+{
+sleep 1
+echo Cant write this - get EPIPE
+echo Ok: $? >&2
+} | { true; }
diff --git a/shell/ash_test/ash-redir/redir.right b/shell/ash_test/ash-redir/redir.right
index 2a02d41ce..c1a6e729a 100644
--- a/shell/ash_test/ash-redir/redir.right
+++ b/shell/ash_test/ash-redir/redir.right
@@ -1 +1,2 @@
+ash: write error: Bad file descriptor
 TEST
diff --git a/shell/ash_test/ash-signals/sigint1.right b/shell/ash_test/ash-signals/sigint1.right
new file mode 100644
index 000000000..a9094b056
--- /dev/null
+++ b/shell/ash_test/ash-signals/sigint1.right
@@ -0,0 +1 @@
+Sending SIGINT to main shell PID
diff --git a/shell/ash_test/ash-signals/sigint1.tests b/shell/ash_test/ash-signals/sigint1.tests
new file mode 100755
index 000000000..3d483d32a
--- /dev/null
+++ b/shell/ash_test/ash-signals/sigint1.tests
@@ -0,0 +1,41 @@
+# What should happen if non-interactive shell gets SIGINT?
+
+(sleep 1; echo Sending SIGINT to main shell PID; exec kill -INT $$) &
+
+# We create a child which exits with 0 even on SIGINT
+# (The complex command is necessary only if SIGINT is generated by ^C,
+# in this testcase even bare "sleep 2" would do because
+# in the testcase we don't send SIGINT *to the child*...)
+$THIS_SH -c 'trap "exit 0" SIGINT; sleep 2'
+
+# In one second, we (main shell) get SIGINT here.
+# The question is whether we should, or should not, exit.
+
+# bash will not stop here. It will execute next command(s).
+
+# The rationale for this is described here:
+# http://www.cons.org/cracauer/sigint.html
+#
+# Basically, bash will not exit on SIGINT immediately if it waits
+# for a child. It will wait for the child to exit.
+# If child exits NOT by dying on SIGINT, then bash will not exit.
+#
+# The idea is that the following script:
+# | emacs file.txt
+# | more cmds
+# User may use ^C to interrupt editor's ops like search. But then
+# emacs exits normally. User expects that script doesn't stop.
+#
+# This is a nice idea, but detecting "did process really exit
+# with SIGINT?" is racy. Consider:
+# | bash -c 'while true; do /bin/true; done'
+# When ^C is pressed while bash waits for /bin/true to exit,
+# it may happen that /bin/true exits with exitcode 0 before
+# ^C is delivered to it as SIGINT. bash will see SIGINT, then
+# it will see that child exited with 0, and bash will NOT EXIT.
+
+# Therefore we do not implement bash behavior.
+# I'd say that emacs need to put itself into a separate pgrp
+# to isolate shell from getting stray SIGINTs from ^C.
+
+echo Next command after SIGINT was executed
diff --git a/shell/hush.c b/shell/hush.c
index 1709fd9d1..4d9e5f8c7 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -1418,6 +1418,7 @@ static void sigexit(int sig)
 static void hush_exit(int exitcode) NORETURN;
 static void hush_exit(int exitcode)
 {
+        fflush_all();
         if (G.exiting <= 0 && G.traps && G.traps[0] && G.traps[0][0]) {
                 /* Prevent recursion:
                  * trap "echo Hi; exit" EXIT; exit
@@ -1901,7 +1902,7 @@ static void get_user_input(struct in_str *i)
                 G.flag_SIGINT = 0;
                 /* buglet: SIGINT will not make new prompt to appear _at once_,
                  * only after <Enter>. (^C will work) */
-                r = read_line_input(prompt_str, G.user_input_buf, CONFIG_FEATURE_EDITING_MAX_LEN-1, G.line_input_state);
+                r = read_line_input(G.line_input_state, prompt_str, G.user_input_buf, CONFIG_FEATURE_EDITING_MAX_LEN-1, /*timeout*/ -1);
                 /* catch *SIGINT* etc (^C is handled by read_line_input) */
                 check_and_run_traps(0);
         } while (r == 0 || G.flag_SIGINT); /* repeat if ^C or SIGINT */
@@ -6105,10 +6106,13 @@ static void exec_builtin(char ***to_free,
                 char **argv)
 {
 #if BB_MMU
-        int rcode = x->b_function(argv);
+        int rcode;
+        fflush_all();
+        rcode = x->b_function(argv);
         fflush_all();
         _exit(rcode);
 #else
+        fflush_all();
         /* On NOMMU, we must never block!
          * Example: { sleep 99 | read line; } & echo Ok
          */
@@ -6500,13 +6504,15 @@ static int checkjobs(struct pipe *fg_pipe)
                                         fg_pipe->alive_cmds--;
                                         ex = WEXITSTATUS(status);
                                         /* bash prints killer signal's name for *last*
-                                         * process in pipe (prints just newline for SIGINT).
+                                         * process in pipe (prints just newline for SIGINT/SIGPIPE).
                                          * Mimic this. Example: "sleep 5" + (^\ or kill -QUIT)
                                          */
                                         if (WIFSIGNALED(status)) {
                                                 int sig = WTERMSIG(status);
                                                 if (i == fg_pipe->num_cmds-1)
-                                                        printf("%s\n", sig == SIGINT ? "" : get_signame(sig));
+                                                        /* TODO: use strsignal() instead for bash compat? but that's bloat... */
+                                                        printf("%s\n", sig == SIGINT || sig == SIGPIPE ? "" : get_signame(sig));
+                                                /* TODO: if (WCOREDUMP(status)) + " (core dumped)"; */
                                                 /* TODO: MIPS has 128 sigs (1..128), what if sig==128 here?
                                                  * Maybe we need to use sig | 128? */
                                                 ex = sig + 128;
@@ -6615,7 +6621,7 @@ static int checkjobs_and_fg_shell(struct pipe *fg_pipe)
  * cmd ; ...   { list } ; ...
  * cmd && ...  { list } && ...
  * cmd || ...  { list } || ...
- * If it is, then we can run cmd as a builtin, NOFORK [do we do this?],
+ * If it is, then we can run cmd as a builtin, NOFORK,
  * or (if SH_STANDALONE) an applet, and we can run the { list }
  * with run_list. If it isn't one of these, we fork and exec cmd.
  *
@@ -6797,13 +6803,12 @@ static NOINLINE int run_pipe(struct pipe *pi)
                 }
 
                 /* Expand the rest into (possibly) many strings each */
-                if (0) {}
 #if ENABLE_HUSH_BASH_COMPAT
-                else if (command->cmd_type == CMD_SINGLEWORD_NOGLOB) {
+                if (command->cmd_type == CMD_SINGLEWORD_NOGLOB) {
                         argv_expanded = expand_strvec_to_strvec_singleword_noglob(argv + command->assignment_cnt);
-                }
+                } else
 #endif
-                else {
+                {
                         argv_expanded = expand_strvec_to_strvec(argv + command->assignment_cnt);
                 }
 
@@ -6833,6 +6838,7 @@ static NOINLINE int run_pipe(struct pipe *pi)
                                 if (!funcp) {
                                         debug_printf_exec(": builtin '%s' '%s'...\n",
                                                 x->b_cmd, argv_expanded[1]);
+                                        fflush_all();
                                         rcode = x->b_function(argv_expanded) & 0xff;
                                         fflush_all();
                                 }
@@ -6865,7 +6871,7 @@ static NOINLINE int run_pipe(struct pipe *pi)
                         return rcode;
                 }
 
-                if (ENABLE_FEATURE_SH_STANDALONE) {
+                if (ENABLE_FEATURE_SH_NOFORK) {
                         int n = find_applet_by_name(argv_expanded[0]);
                         if (n >= 0 && APPLET_IS_NOFORK(n)) {
                                 rcode = redirect_and_varexp_helper(&new_env, &old_vars, command, squirrel, argv_expanded);
@@ -7642,6 +7648,7 @@ int hush_main(int argc, char **argv)
                                         G.global_argc -= builtin_argc; /* skip [BARGV...] "" */
                                         G.global_argv += builtin_argc;
                                         G.global_argv[-1] = NULL; /* replace "" */
+                                        fflush_all();
                                         G.last_exitcode = x->b_function(argv + optind - 1);
                                 }
                                 goto final_return;
diff --git a/shell/hush_test/hush-misc/echo_write_error.right b/shell/hush_test/hush-misc/echo_write_error.right
new file mode 100644
index 000000000..ddcad4363
--- /dev/null
+++ b/shell/hush_test/hush-misc/echo_write_error.right
@@ -0,0 +1,2 @@
+hush: write error: Broken pipe
+Ok: 1
diff --git a/shell/hush_test/hush-misc/echo_write_error.tests b/shell/hush_test/hush-misc/echo_write_error.tests
new file mode 100755
index 000000000..0a40c9ff7
--- /dev/null
+++ b/shell/hush_test/hush-misc/echo_write_error.tests
@@ -0,0 +1,7 @@
+trap "" PIPE
+
+{
+sleep 1
+echo Cant write this - get EPIPE
+echo Ok: $? >&2
+} | { true; }
diff --git a/shell/hush_test/hush-misc/sigint1.right b/shell/hush_test/hush-misc/sigint1.right
new file mode 100644
index 000000000..a9094b056
--- /dev/null
+++ b/shell/hush_test/hush-misc/sigint1.right
@@ -0,0 +1 @@
+Sending SIGINT to main shell PID
diff --git a/shell/hush_test/hush-misc/sigint1.tests b/shell/hush_test/hush-misc/sigint1.tests
new file mode 100755
index 000000000..3d483d32a
--- /dev/null
+++ b/shell/hush_test/hush-misc/sigint1.tests
@@ -0,0 +1,41 @@
+# What should happen if non-interactive shell gets SIGINT?
+
+(sleep 1; echo Sending SIGINT to main shell PID; exec kill -INT $$) &
+
+# We create a child which exits with 0 even on SIGINT
+# (The complex command is necessary only if SIGINT is generated by ^C,
+# in this testcase even bare "sleep 2" would do because
+# in the testcase we don't send SIGINT *to the child*...)
+$THIS_SH -c 'trap "exit 0" SIGINT; sleep 2'
+
+# In one second, we (main shell) get SIGINT here.
+# The question is whether we should, or should not, exit.
+
+# bash will not stop here. It will execute next command(s).
+
+# The rationale for this is described here:
+# http://www.cons.org/cracauer/sigint.html
+#
+# Basically, bash will not exit on SIGINT immediately if it waits
+# for a child. It will wait for the child to exit.
+# If child exits NOT by dying on SIGINT, then bash will not exit.
+#
+# The idea is that the following script:
+# | emacs file.txt
+# | more cmds
+# User may use ^C to interrupt editor's ops like search. But then
+# emacs exits normally. User expects that script doesn't stop.
+#
+# This is a nice idea, but detecting "did process really exit
+# with SIGINT?" is racy. Consider:
+# | bash -c 'while true; do /bin/true; done'
+# When ^C is pressed while bash waits for /bin/true to exit,
+# it may happen that /bin/true exits with exitcode 0 before
+# ^C is delivered to it as SIGINT. bash will see SIGINT, then
+# it will see that child exited with 0, and bash will NOT EXIT.
+
+# Therefore we do not implement bash behavior.
+# I'd say that emacs need to put itself into a separate pgrp
+# to isolate shell from getting stray SIGINTs from ^C.
+
+echo Next command after SIGINT was executed
diff --git a/shell/shell_common.c b/shell/shell_common.c
index 2d5c0db0f..c7b5b6122 100644
--- a/shell/shell_common.c
+++ b/shell/shell_common.c
@@ -375,9 +375,9 @@ shell_builtin_ulimit(char **argv)
 #endif
         /* optarg = NULL; opterr = 0; optopt = 0; - do we need this?? */
 
-        argc = 1;
-        while (argv[argc])
-                argc++;
+        argc = 1;
+        while (argv[argc])
+                argc++;
 
         opts = 0;
         while (1) {