Changeset 3232 in MondoRescue for branches/3.2/mindi-busybox/shell

Timestamp:

Jan 1, 2014, 12:47:38 AM (10 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.21.1

Location:

branches/3.2/mindi-busybox/shell

Files:

• Config.src (modified) (2 diffs)
• ash.c (modified) (66 diffs)
• ash_test/ash-redir/redir.right (modified) (1 diff)
• cttyhack.c (modified) (4 diffs)
• hush.c (modified) (129 diffs)
• hush_test/hush-parsing/starquoted2.right (modified) (1 diff)
• hush_test/hush-parsing/starquoted2.tests (modified) (1 diff)
• hush_test/run-all (modified) (3 diffs)
• math.c (modified) (1 diff)
• shell_common.c (modified) (11 diffs)
• shell_common.h (modified) (1 diff)

branches/3.2/mindi-busybox/shell/Config.src

@@ -124 +124 @@
     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).
 
@@ -134 +134 @@
       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.
+
+config FEATURE_SH_HISTFILESIZE
+    bool "Use $HISTFILESIZE"
+    default y
+    depends on HUSH || ASH
+    help
+      This option makes busybox shells to use $HISTFILESIZE variable
+      to set shell history size. Note that its max value is capped
+      by "History size" setting in library tuning section.
+
 
 endmenu

branches/3.2/mindi-busybox/shell/ash.c

@@ -24 +24 @@
  *      define DEBUG=2 to compile in and turn on debugging.
  *
- * When debugging is on, debugging info will be written to ./trace and
- * a quit signal will generate a core dump.
+ * When debugging is on (DEBUG is 1 and "set -o debug" was executed),
+ * debugging info will be written to ./trace and a quit signal
+ * will generate a core dump.
  */
 #define DEBUG 0
@@ -37 +38 @@
 #define JOBS ENABLE_ASH_JOB_CONTROL
 
-#include "busybox.h" /* for applet_names */
 #include <paths.h>
 #include <setjmp.h>
 #include <fnmatch.h>
 #include <sys/times.h>
+
+#include "busybox.h" /* for applet_names */
+#include "unicode.h"
 
 #include "shell_common.h"
@@ -72 +75 @@
 # error "Do not even bother, ash will not run on NOMMU machine"
 #endif
-
-//applet:IF_ASH(APPLET(ash, _BB_DIR_BIN, _BB_SUID_DROP))
-//applet:IF_FEATURE_SH_IS_ASH(APPLET_ODDNAME(sh, ash, _BB_DIR_BIN, _BB_SUID_DROP, sh))
-//applet:IF_FEATURE_BASH_IS_ASH(APPLET_ODDNAME(bash, ash, _BB_DIR_BIN, _BB_SUID_DROP, bash))
-
-//kbuild:lib-$(CONFIG_ASH) += ash.o ash_ptr_hack.o shell_common.o
-//kbuild:lib-$(CONFIG_ASH_RANDOM_SUPPORT) += random.o
 
 //config:config ASH
@@ -98 +94 @@
 //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"
@@ -106 +109 @@
 //config:
 //config:config ASH_ALIAS
-//config:   bool "alias support"
+//config:   bool "Alias support"
 //config:   default y
 //config:   depends on ASH
@@ -117 +120 @@
 //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
@@ -124 +127 @@
 //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
@@ -131 +134 @@
 //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
@@ -138 +141 @@
 //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
@@ -154 +157 @@
 //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
@@ -184 +187 @@
 //config:
 
-//usage:#define ash_trivial_usage NOUSAGE_STR
-//usage:#define ash_full_usage ""
-//usage:#define sh_trivial_usage NOUSAGE_STR
-//usage:#define sh_full_usage ""
-//usage:#define bash_trivial_usage NOUSAGE_STR
-//usage:#define bash_full_usage ""
+//applet:IF_ASH(APPLET(ash, BB_DIR_BIN, BB_SUID_DROP))
+//applet:IF_FEATURE_SH_IS_ASH(APPLET_ODDNAME(sh, ash, BB_DIR_BIN, BB_SUID_DROP, sh))
+//applet:IF_FEATURE_BASH_IS_ASH(APPLET_ODDNAME(bash, ash, BB_DIR_BIN, BB_SUID_DROP, bash))
+
+//kbuild:lib-$(CONFIG_ASH) += ash.o ash_ptr_hack.o shell_common.o
+//kbuild:lib-$(CONFIG_ASH_RANDOM_SUPPORT) += random.o
 
 
@@ -401 +404 @@
 
 /* ============ Interrupts / exceptions */
+
+static void exitshell(void) NORETURN;
+
 /*
  * These macros allow the user to suspend the handling of interrupt signals
@@ -1881 +1887 @@
 #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;
@@ -1893 +1901 @@
     void (*var_func)(const char *) FAST_FUNC;
 } varinit_data[] = {
+    /*
+     * Note: VEXPORT would not work correctly here for NOFORK applets:
+     * some environment strings may be constant.
+     */
     { VSTRFIXED|VTEXTFIXED       , defifsvar   , NULL            },
 #if ENABLE_ASH_MAIL
@@ -3485 +3497 @@
     case S_CATCH:
         act.sa_handler = signal_handler;
-        act.sa_flags = 0; /* matters only if !DFL and !IGN */
-        sigfillset(&act.sa_mask); /* ditto */
         break;
     case S_IGN:
@@ -3492 +3502 @@
         break;
     }
+
+    /* flags and mask matter only if !DFL and !IGN, but we do it
+     * for all cases for more deterministic behavior:
+     */
+    act.sa_flags = 0;
+    sigfillset(&act.sa_mask);
+
     sigaction_set(signo, &act);
 
@@ -3528 +3545 @@
     /* first remove from list */
     jpp = curp = &curjob;
-    do {
+    while (1) {
         jp1 = *jpp;
         if (jp1 == jp)
             break;
         jpp = &jp1->prev_job;
-    } while (1);
+    }
     *jpp = jp1->prev_job;
 
@@ -3548 +3565 @@
     case CUR_RUNNING:
         /* newly created job or backgrounded job,
-           put after all stopped jobs. */
-        do {
+         * put after all stopped jobs.
+         */
+        while (1) {
             jp1 = *jpp;
 #if JOBS
@@ -3556 +3574 @@
                 break;
             jpp = &jp1->prev_job;
-        } while (1);
+        }
         /* FALLTHROUGH */
 #if JOBS
@@ -3729 +3747 @@
         /* fd is a tty at this point */
         close_on_exec_on(fd);
-        do { /* while we are in the background */
+        while (1) { /* while we are in the background */
             pgrp = tcgetpgrp(fd);
             if (pgrp < 0) {
@@ -3740 +3758 @@
                 break;
             killpg(0, SIGTTIN);
-        } while (1);
+        }
         initialpgrp = pgrp;
 
@@ -3772 +3790 @@
 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]);
@@ -3881 +3932 @@
         }
         st &= 0x7f;
+//TODO: use bbox's get_signame? strsignal adds ~600 bytes to text+rodata
         col = fmtstr(s, 32, strsignal(st));
         if (WCOREDUMP(status)) {
@@ -4215 +4267 @@
                 job = job->prev_job;
             }
-        } else
+        } else {
             job = getjob(*argv, 0);
+        }
         /* loop until process terminated or stopped */
         while (job->state == JOBRUNNING)
@@ -4712 +4765 @@
     /* 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;
 
@@ -4738 +4791 @@
         }
     }
-    if (!oldlvl) {
+    if (oldlvl == 0) {
         if (iflag) { /* why if iflag only? */
             setsignal(SIGINT);
@@ -4945 +4998 @@
  */
 
+#undef EMPTY
+#undef CLOSED
 #define EMPTY -2                /* marks an unused slot in redirtab */
 #define CLOSED -3               /* marks a slot of previously-closed fd */
@@ -5057 +5112 @@
     int f;
 
+    fname = redir->nfile.expfname;
     switch (redir->nfile.type) {
     case NFROM:
-        fname = redir->nfile.expfname;
         f = open(fname, O_RDONLY);
         if (f < 0)
@@ -5065 +5120 @@
         break;
     case NFROMTO:
-        fname = redir->nfile.expfname;
         f = open(fname, O_RDWR|O_CREAT, 0666);
         if (f < 0)
@@ -5076 +5130 @@
         /* Take care of noclobber mode. */
         if (Cflag) {
-            fname = redir->nfile.expfname;
             f = noclobberopen(fname);
             if (f < 0)
@@ -5084 +5137 @@
         /* FALLTHROUGH */
     case NCLOBBER:
-        fname = redir->nfile.expfname;
         f = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666);
         if (f < 0)
@@ -5090 +5142 @@
         break;
     case NAPPEND:
-        fname = redir->nfile.expfname;
         f = open(fname, O_WRONLY|O_CREAT|O_APPEND, 0666);
         if (f < 0)
@@ -5870 +5921 @@
         if (in.fd < 0)
             break;
-        i = nonblock_safe_read(in.fd, buf, sizeof(buf));
+        i = nonblock_immune_read(in.fd, buf, sizeof(buf), /*loop_on_EINTR:*/ 1);
         TRACE(("expbackq: read returns %d\n", i));
         if (i <= 0)
@@ -5922 +5973 @@
     *p = '\0';
     p--;
-    do {
+    while (1) {
         int esc;
 
@@ -5940 +5991 @@
 
         p -= esc + 1;
-    } while (1);
+    }
 
     begoff = p - start;
@@ -6090 +6141 @@
             goto addquote;
         case CTLVAR:
+            TRACE(("argstr: evalvar('%s')\n", p));
             p = evalvar(p, flags, var_str_list);
+            TRACE(("argstr: evalvar:'%s'\n", (char *)stackblock()));
             goto start;
         case CTLBACKQ:
@@ -6287 +6340 @@
     IF_ASH_BASH_COMPAT(int pos, len, orig_len;)
     int saveherefd = herefd;
-    int amount, workloc, resetloc;
+    int amount, resetloc;
+    IF_ASH_BASH_COMPAT(int workloc;)
     int zero;
     char *(*scan)(char*, char*, char*, char*, int, int);
@@ -6400 +6454 @@
     str = (char *)stackblock() + strloc;
     preglob(str, varflags & VSQUOTE, 0);
+
+#if ENABLE_ASH_BASH_COMPAT
     workloc = expdest - (char *)stackblock();
-
-#if ENABLE_ASH_BASH_COMPAT
     if (subtype == VSREPLACE || subtype == VSREPLACEALL) {
         char *idx, *end;
@@ -6798 +6852 @@
         if (NULL == subevalvar(p, /* varname: */ NULL, patloc, subtype,
                 startloc, varflags,
-//TODO: | EXP_REDIR too? All other such places do it too
-                /* quotes: */ flags & (EXP_FULL | EXP_CASE),
+                /* quotes: */ flags & (EXP_FULL | EXP_CASE | EXP_REDIR),
                 var_str_list)
         ) {
@@ -7201 +7254 @@
     ifsfirst.next = NULL;
     ifslastp = NULL;
+    TRACE(("expandarg: argstr('%s',flags:%x)\n", arg->narg.text, flag));
     argstr(arg->narg.text, flag,
             /* var_str_list: */ arglist ? arglist->list : NULL);
@@ -7209 +7263 @@
     }
     p = grabstackstr(p);
+    TRACE(("expandarg: p:'%s'\n", p));
     exparg.lastp = &exparg.list;
     /*
@@ -7219 +7274 @@
         expandmeta(exparg.list /*, flag*/);
     } else {
-        if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
+        if (flag & EXP_REDIR) { /*XXX - for now, just remove escapes */
             rmescapes(p, 0);
+            TRACE(("expandarg: rmescapes:'%s'\n", p));
+        }
         sp = stzalloc(sizeof(*sp));
         sp->text = p;
@@ -7348 +7405 @@
 tryexec(IF_FEATURE_SH_STANDALONE(int applet_no,) char *cmd, char **argv, char **envp)
 {
-    int repeated = 0;
-
 #if ENABLE_FEATURE_SH_STANDALONE
     if (applet_no >= 0) {
@@ -7373 +7428 @@
     execve(cmd, argv, envp);
 #endif
-    if (repeated) {
+    if (cmd == (char*) bb_busybox_exec_path) {
+        /* We already visited ENOEXEC branch below, don't do it again */
+//TODO: try execve(initial_argv0_of_shell, argv, envp) before giving up?
         free(argv);
         return;
     }
     if (errno == ENOEXEC) {
+        /* Run "cmd" as a shell script:
+         * http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html
+         * "If the execve() function fails with ENOEXEC, the shell
+         * shall execute a command equivalent to having a shell invoked
+         * with the command name as its first operand,
+         * with any remaining arguments passed to the new shell"
+         *
+         * That is, do not use $SHELL, user's shell, or /bin/sh;
+         * just call ourselves.
+         *
+         * Note that bash reads ~80 chars of the file, and if it sees
+         * a zero byte before it sees newline, it doesn't try to
+         * interpret it, but fails with "cannot execute binary file"
+         * message and exit code 126. For one, this prevents attempts
+         * to interpret foreign ELF binaries as shell scripts.
+         */
         char **ap;
         char **new;
@@ -7383 +7456 @@
         for (ap = argv; *ap; ap++)
             continue;
-        ap = new = ckmalloc((ap - argv + 2) * sizeof(ap[0]));
-        ap[1] = cmd;
-        ap[0] = cmd = (char *)DEFAULT_SHELL;
-        ap += 2;
-        argv++;
-        while ((*ap++ = *argv++) != NULL)
+        new = ckmalloc((ap - argv + 2) * sizeof(new[0]));
+        new[0] = (char*) "ash";
+        new[1] = cmd;
+        ap = new + 2;
+        while ((*ap++ = *++argv) != NULL)
             continue;
+        cmd = (char*) bb_busybox_exec_path;
         argv = new;
-        repeated++;
         goto repeat;
     }
@@ -7408 +7480 @@
     char **envp;
     int exerrno;
-#if ENABLE_FEATURE_SH_STANDALONE
-    int applet_no = -1;
-#endif
+    int applet_no = -1; /* used only by FEATURE_SH_STANDALONE */
 
     clearredir(/*drop:*/ 1);
@@ -7420 +7490 @@
     ) {
         tryexec(IF_FEATURE_SH_STANDALONE(applet_no,) argv[0], argv, envp);
+        if (applet_no >= 0) {
+            /* We tried execing ourself, but it didn't work.
+             * Maybe /proc/self/exe doesn't exist?
+             * Try $PATH search.
+             */
+            goto try_PATH;
+        }
         e = errno;
     } else {
+ try_PATH:
         e = ENOENT;
         while ((cmdname = path_advance(&path, argv[0])) != NULL) {
@@ -8596 +8674 @@
         case NAPPEND:
             expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR);
+            TRACE(("expredir expanded to '%s'\n", fn.list->text));
 #if ENABLE_ASH_BASH_COMPAT
  store_expfname:
+#endif
+#if 0
+// By the design of stack allocator, the loop of this kind:
+//  while true; do while true; do break; done </dev/null; done
+// will look like a memory leak: ash plans to free expfname's
+// of "/dev/null" as soon as it finishes running the loop
+// (in this case, never).
+// This "fix" is wrong:
+            if (redir->nfile.expfname)
+                stunalloc(redir->nfile.expfname);
+// It results in corrupted state of stacked allocations.
 #endif
             redir->nfile.expfname = fn.list->text;
@@ -9234 +9324 @@
     /* Now locate the command. */
     if (argc) {
-        const char *oldpath;
         int cmd_flag = DO_ERR;
-
+#if ENABLE_ASH_CMDCMD
+        const char *oldpath = path + 5;
+#endif
         path += 5;
-        oldpath = path;
         for (;;) {
             find_command(argv[0], &cmdentry, cmd_flag, path);
@@ -9560 +9650 @@
  retry:
     if (!iflag || g_parsefile->pf_fd != STDIN_FILENO)
-        nr = nonblock_safe_read(g_parsefile->pf_fd, buf, IBUFSIZ - 1);
+        nr = nonblock_immune_read(g_parsefile->pf_fd, buf, IBUFSIZ - 1, /*loop_on_EINTR:*/ 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
+        /* Unicode support should be activated even if LANG is set
+         * _during_ shell execution, not only if it was set when
+         * shell was started. Therefore, re-check LANG every time:
+         */
+        reinit_unicode(lookupvar("LANG"));
+        nr = read_line_input(line_input_state, cmdedit_prompt, buf, IBUFSIZ, timeout);
         if (nr == 0) {
             /* Ctrl+C pressed */
@@ -9576 +9682 @@
             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 */
+    nr = nonblock_immune_read(g_parsefile->pf_fd, buf, IBUFSIZ - 1, /*loop_on_EINTR:*/ 1);
+#endif
+
+#if 0 /* disabled: nonblock_immune_read() handles this problem */
     if (nr < 0) {
         if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
@@ -10105 +10218 @@
                         setparam(argptr);
                 }
-                break;    /* "-" or  "--" terminates options */
+                break;    /* "-" or "--" terminates options */
             }
         }
@@ -10207 +10320 @@
     if (!argv[1])
         return showvars(nullstr, 0, VUNSET);
+
     INT_OFF;
-    retval = 1;
-    if (!options(0)) { /* if no parse error... */
-        retval = 0;
+    retval = options(/*cmdline:*/ 0);
+    if (retval == 0) { /* if no parse error... */
         optschanged();
         if (*argptr != NULL) {
@@ -11538 +11651 @@
     if (oldstyle) {
         /* We must read until the closing backquote, giving special
-           treatment to some slashes, and then push the string and
-           reread it as input, interpreting it normally.  */
+         * treatment to some slashes, and then push the string and
+         * reread it as input, interpreting it normally.
+         */
         char *pout;
         size_t psavelen;
@@ -12071 +12185 @@
         if (iflag && top) {
             inter++;
-#if ENABLE_ASH_MAIL
             chkmail();
-#endif
         }
         n = parsecmd(inter);
@@ -12532 +12644 @@
     const char *p;
     char **aptr;
-    int flag = argv[0][0] == 'r' ? VREADONLY : VEXPORT;
-
-    if (nextopt("p") != 'p') {
+    char opt;
+    int flag;
+    int flag_off;
+
+    /* "readonly" in bash accepts, but ignores -n.
+     * We do the same: it saves a conditional in nextopt's param.
+     */
+    flag_off = 0;
+    while ((opt = nextopt("np")) != '\0') {
+        if (opt == 'n')
+            flag_off = VEXPORT;
+    }
+    flag = VEXPORT;
+    if (argv[0][0] == 'r') {
+        flag = VREADONLY;
+        flag_off = 0; /* readonly ignores -n */
+    }
+    flag_off = ~flag_off;
+
+    /*if (opt_p_not_specified) - bash doesnt check this. Try "export -p NAME" */
+    {
         aptr = argptr;
         name = *aptr;
@@ -12545 +12675 @@
                     vp = *findvar(hashvar(name), name);
                     if (vp) {
-                        vp->flags |= flag;
+                        vp->flags = ((vp->flags | flag) & flag_off);
                         continue;
                     }
                 }
-                setvar(name, p, flag);
+                setvar(name, p, (flag & flag_off));
             } while ((name = *++aptr) != NULL);
             return 0;
         }
     }
+
+    /* No arguments. Show the list of exported or readonly vars.
+     * -n is ignored.
+     */
     showvars(argv[0], flag, 0);
     return 0;
@@ -12706 +12840 @@
     }
 
+    /* "read -s" needs to save/restore termios, can't allow ^C
+     * to jump out of it.
+     */
+    INT_OFF;
     r = shell_builtin_read(setvar2,
         argptr,
@@ -12715 +12853 @@
         opt_u
     );
+    INT_ON;
 
     if ((uintptr_t)r > 1)
@@ -12803 +12942 @@
  * Called to exit the shell.
  */
-static void exitshell(void) NORETURN;
 static void
 exitshell(void)
@@ -12810 +12948 @@
     char *p;
     int status;
+
+#if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
+    save_history(line_input_state);
+#endif
 
     status = exitstatus;
@@ -12866 +13008 @@
 
         p = lookupvar("PWD");
-        if (p)
+        if (p) {
             if (*p != '/' || stat(p, &st1) || stat(".", &st2)
-             || st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino)
+             || st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino
+            ) {
                 p = '\0';
+            }
+        }
         setpwd(p, 0);
     }
 }
+
+
+//usage:#define ash_trivial_usage
+//usage:    "[-/+OPTIONS] [-/+o OPT]... [-c 'SCRIPT' [ARG0 [ARGS]] / FILE [ARGS]]"
+//usage:#define ash_full_usage "\n\n"
+//usage:    "Unix shell interpreter"
+
+//usage:#if ENABLE_FEATURE_SH_IS_ASH
+//usage:# define sh_trivial_usage ash_trivial_usage
+//usage:# define sh_full_usage    ash_full_usage
+//usage:#endif
+//usage:#if ENABLE_FEATURE_BASH_IS_ASH
+//usage:# define bash_trivial_usage ash_trivial_usage
+//usage:# define bash_full_usage    ash_full_usage
+//usage:#endif
 
 /*
@@ -12891 +13051 @@
         optlist[i] = 2;
     argptr = xargv;
-    if (options(1)) {
+    if (options(/*cmdline:*/ 1)) {
         /* it already printed err message */
         raise_exception(EXERROR);
@@ -13053 +13213 @@
     if (iflag) {
         const char *hp = lookupvar("HISTFILE");
-
-        if (hp == NULL) {
+        if (!hp) {
             hp = lookupvar("HOME");
-            if (hp != NULL) {
+            if (hp) {
                 char *defhp = concat_path_file(hp, ".ash_history");
                 setvar("HISTFILE", defhp, 0);
@@ -13064 +13223 @@
     }
 #endif
-    if (/* argv[0] && */ argv[0][0] == '-')
+    if (argv[0] && argv[0][0] == '-')
         isloginsh = 1;
     if (isloginsh) {
@@ -13100 +13259 @@
 
     if (sflag || minusc == NULL) {
-#if defined MAX_HISTORY && MAX_HISTORY > 0 && ENABLE_FEATURE_EDITING_SAVEHISTORY
+#if MAX_HISTORY > 0 && ENABLE_FEATURE_EDITING_SAVEHISTORY
         if (iflag) {
             const char *hp = lookupvar("HISTFILE");
             if (hp)
                 line_input_state->hist_file = hp;
+# if ENABLE_FEATURE_SH_HISTFILESIZE
+            hp = lookupvar("HISTFILESIZE");
+            line_input_state->max_history = size_from_HISTFILESIZE(hp);
+# endif
         }
 #endif

branches/3.2/mindi-busybox/shell/ash_test/ash-redir/redir.right

@@ +1 @@
+ash: write error: Bad file descriptor
 TEST

branches/3.2/mindi-busybox/shell/cttyhack.c

@@ -7 +7 @@
 #include "libbb.h"
 
-//applet:IF_CTTYHACK(APPLET(cttyhack, _BB_DIR_BIN, _BB_SUID_DROP))
+//applet:IF_CTTYHACK(APPLET(cttyhack, BB_DIR_BIN, BB_SUID_DROP))
 
 //kbuild:lib-$(CONFIG_CTTYHACK) += cttyhack.o
@@ -15 +15 @@
 //config:   default y
 //config:   help
-//config:     One common problem reported on the mailing list is "can't access tty;
-//config:     job control turned off" error message which typically appears when
-//config:     one tries to use shell with stdin/stdout opened to /dev/console.
+//config:     One common problem reported on the mailing list is the "can't
+//config:     access tty; job control turned off" error message, which typically
+//config:     appears when one tries to use a shell with stdin/stdout on
+//config:     /dev/console.
 //config:     This device is special - it cannot be a controlling tty.
 //config:
-//config:     Proper solution is to use correct device instead of /dev/console.
+//config:     The proper solution is to use the correct device instead of
+//config:     /dev/console.
 //config:
-//config:     cttyhack provides "quick and dirty" solution to this problem.
+//config:     cttyhack provides a "quick and dirty" solution to this problem.
 //config:     It analyzes stdin with various ioctls, trying to determine whether
 //config:     it is a /dev/ttyN or /dev/ttySN (virtual terminal or serial line).
-//config:     If it detects one, it closes stdin/out/err and reopens that device.
-//config:     Then it executes given program. Opening the device will make
+//config:     On Linux it also checks sysfs for a pointer to the active console.
+//config:     If cttyhack is able to find the real console device, it closes
+//config:     stdin/out/err and reopens that device.
+//config:     Then it executes the given program. Opening the device will make
 //config:     that device a controlling tty. This may require cttyhack
 //config:     to be a session leader.
@@ -47 +51 @@
 //config:     # exec setsid sh -c 'exec sh </dev/tty1 >/dev/tty1 2>&1'
 //config:
+//config:     Starting getty on a controlling tty from a shell script:
+//config:
+//config:     # getty 115200 $(cttyhack)
 
 //usage:#define cttyhack_trivial_usage
-//usage:       "PROG ARGS"
+//usage:       "[PROG ARGS]"
 //usage:#define cttyhack_full_usage "\n\n"
 //usage:       "Give PROG a controlling tty if possible."
@@ -105 +112 @@
     } u;
 
-    if (!*++argv) {
-        bb_show_usage();
+    strcpy(console, "/dev/tty");
+    fd = open(console, O_RDWR);
+    if (fd < 0) {
+        /* We don't have ctty (or don't have "/dev/tty" node...) */
+        do {
+#ifdef __linux__
+            /* Note that this method does not use _stdin_.
+             * Thus, "cttyhack </dev/something" can't be used.
+             * However, this method is more reliable than
+             * TIOCGSERIAL check, which assumes that all
+             * serial lines follow /dev/ttySn convention -
+             * which is not always the case.
+             * Therefore, we use this method first:
+             */
+            int s = open_read_close("/sys/class/tty/console/active",
+                console + 5, sizeof(console) - 5);
+            if (s > 0) {
+                char *last;
+                /* Found active console via sysfs (Linux 2.6.38+).
+                 * It looks like "[tty0 ]ttyS0\n" so zap the newline:
+                 */
+                console[4 + s] = '\0';
+                /* If there are multiple consoles,
+                 * take the last one:
+                 */
+                last = strrchr(console + 5, ' ');
+                if (last)
+                    overlapping_strcpy(console + 5, last + 1);
+                break;
+            }
+
+            if (ioctl(0, VT_GETSTATE, &u.vt) == 0) {
+                /* this is linux virtual tty */
+                sprintf(console + 8, "S%u" + 1, (int)u.vt.v_active);
+                break;
+            }
+#endif
+#ifdef TIOCGSERIAL
+            if (ioctl(0, TIOCGSERIAL, &u.sr) == 0) {
+                /* this is a serial console; assuming it is named /dev/ttySn */
+                sprintf(console + 8, "S%u", (int)u.sr.line);
+                break;
+            }
+#endif
+            /* nope, could not find it */
+            console[0] = '\0';
+        } while (0);
     }
 
-    strcpy(console, "/dev/tty");
-    fd = open(console, O_RDWR);
-    if (fd >= 0) {
-        /* We already have ctty, nothing to do */
-        close(fd);
-    } else {
-        /* We don't have ctty (or don't have "/dev/tty" node...) */
-        if (0) {}
-#ifdef TIOCGSERIAL
-        else if (ioctl(0, TIOCGSERIAL, &u.sr) == 0) {
-            /* this is a serial console */
-            sprintf(console + 8, "S%d", u.sr.line);
-        }
-#endif
-#ifdef __linux__
-        else if (ioctl(0, VT_GETSTATE, &u.vt) == 0) {
-            /* this is linux virtual tty */
-            sprintf(console + 8, "S%d" + 1, u.vt.v_active);
-        }
-#endif
-        if (console[8]) {
-            fd = xopen(console, O_RDWR);
-            //bb_error_msg("switching to '%s'", console);
-            dup2(fd, 0);
-            dup2(fd, 1);
-            dup2(fd, 2);
-            while (fd > 2)
-                close(fd--);
-            /* Some other session may have it as ctty,
-             * steal it from them:
-             */
-            ioctl(0, TIOCSCTTY, 1);
-        }
+    argv++;
+    if (!argv[0]) {
+        if (!console[0])
+            return EXIT_FAILURE;
+        puts(console);
+        return EXIT_SUCCESS;
     }
 
+    if (fd < 0) {
+        fd = open_or_warn(console, O_RDWR);
+        if (fd < 0)
+            goto ret;
+    }
+    //bb_error_msg("switching to '%s'", console);
+    dup2(fd, 0);
+    dup2(fd, 1);
+    dup2(fd, 2);
+    while (fd > 2)
+        close(fd--);
+    /* Some other session may have it as ctty,
+     * try to steal it from them:
+     */
+    ioctl(0, TIOCSCTTY, 1);
+ ret:
     BB_EXECVP_or_die(argv);
 }

branches/3.2/mindi-busybox/shell/hush.c

@@ -82 +82 @@
  *              aaa
  */
-#include "busybox.h"  /* for APPLET_IS_NOFORK/NOEXEC */
-#include <malloc.h>   /* for malloc_trim */
+#if !(defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) \
+    || defined(__APPLE__) \
+    )
+# include <malloc.h>   /* for malloc_trim */
+#endif
 #include <glob.h>
 /* #include <dmalloc.h> */
@@ -90 +93 @@
 #endif
 
+#include "busybox.h"  /* for APPLET_IS_NOFORK/NOEXEC */
+#include "unicode.h"
 #include "shell_common.h"
 #include "math.h"
@@ -101 +106 @@
 # define PIPE_BUF 4096  /* amount of buffering in a pipe */
 #endif
-
-//applet:IF_HUSH(APPLET(hush, _BB_DIR_BIN, _BB_SUID_DROP))
-//applet:IF_MSH(APPLET(msh, _BB_DIR_BIN, _BB_SUID_DROP))
-//applet:IF_FEATURE_SH_IS_HUSH(APPLET_ODDNAME(sh, hush, _BB_DIR_BIN, _BB_SUID_DROP, sh))
-//applet:IF_FEATURE_BASH_IS_HUSH(APPLET_ODDNAME(bash, hush, _BB_DIR_BIN, _BB_SUID_DROP, bash))
-
-//kbuild:lib-$(CONFIG_HUSH) += hush.o match.o shell_common.o
-//kbuild:lib-$(CONFIG_HUSH_RANDOM_SUPPORT) += random.o
 
 //config:config HUSH
@@ -246 +243 @@
 //config:
 
-//usage:#define hush_trivial_usage NOUSAGE_STR
-//usage:#define hush_full_usage ""
-//usage:#define msh_trivial_usage NOUSAGE_STR
-//usage:#define msh_full_usage ""
-//usage:#define sh_trivial_usage NOUSAGE_STR
-//usage:#define sh_full_usage ""
-//usage:#define bash_trivial_usage NOUSAGE_STR
-//usage:#define bash_full_usage ""
+//applet:IF_HUSH(APPLET(hush, BB_DIR_BIN, BB_SUID_DROP))
+//applet:IF_MSH(APPLET(msh, BB_DIR_BIN, BB_SUID_DROP))
+//applet:IF_FEATURE_SH_IS_HUSH(APPLET_ODDNAME(sh, hush, BB_DIR_BIN, BB_SUID_DROP, sh))
+//applet:IF_FEATURE_BASH_IS_HUSH(APPLET_ODDNAME(bash, hush, BB_DIR_BIN, BB_SUID_DROP, bash))
+
+//kbuild:lib-$(CONFIG_HUSH) += hush.o match.o shell_common.o
+//kbuild:lib-$(CONFIG_HUSH_RANDOM_SUPPORT) += random.o
+
+/* -i (interactive) and -s (read stdin) are also accepted,
+ * but currently do nothing, therefore aren't shown in help.
+ * NOMMU-specific options are not meant to be used by users,
+ * therefore we don't show them either.
+ */
+//usage:#define hush_trivial_usage
+//usage:    "[-nxl] [-c 'SCRIPT' [ARG0 [ARGS]] / FILE [ARGS]]"
+//usage:#define hush_full_usage "\n\n"
+//usage:    "Unix shell interpreter"
+
+//usage:#define msh_trivial_usage hush_trivial_usage
+//usage:#define msh_full_usage hush_full_usage
+
+//usage:#if ENABLE_FEATURE_SH_IS_HUSH
+//usage:# define sh_trivial_usage hush_trivial_usage
+//usage:# define sh_full_usage    hush_full_usage
+//usage:#endif
+//usage:#if ENABLE_FEATURE_BASH_IS_HUSH
+//usage:# define bash_trivial_usage hush_trivial_usage
+//usage:# define bash_full_usage    hush_full_usage
+//usage:#endif
 
 
@@ -303 +321 @@
 # undef ENABLE_FEATURE_EDITING_FANCY_PROMPT
 # define ENABLE_FEATURE_EDITING_FANCY_PROMPT 0
+# undef ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
+# define ENABLE_FEATURE_EDITING_SAVE_ON_EXIT 0
 #endif
 
@@ -437 +457 @@
 #endif
 
-/* I can almost use ordinary FILE*.  Is open_memstream() universally
- * available?  Where is it documented? */
 typedef struct in_str {
     const char *p;
@@ -445 +463 @@
     char peek_buf[2];
 #if ENABLE_HUSH_INTERACTIVE
-    smallint promptme;
     smallint promptmode; /* 0: PS1, 1: PS2 */
 #endif
+    int last_char;
     FILE *file;
     int (*get) (struct in_str *) FAST_FUNC;
@@ -505 +523 @@
     pid_t pid;                  /* 0 if exited */
     int assignment_cnt;         /* how many argv[i] are assignments? */
-    smallint is_stopped;        /* is the command currently running? */
     smallint cmd_type;          /* CMD_xxx */
 #define CMD_NORMAL   0
@@ -677 +694 @@
  * xtrace          off
  */
-static const char o_opt_strings[] ALIGN1 = "pipefail\0";
+static const char o_opt_strings[] ALIGN1 =
+    "pipefail\0"
+    "noexec\0"
+#if ENABLE_HUSH_MODE_X
+    "xtrace\0"
+#endif
+    ;
 enum {
     OPT_O_PIPEFAIL,
+    OPT_O_NOEXEC,
+#if ENABLE_HUSH_MODE_X
+    OPT_O_XTRACE,
+#endif
     NUM_OPT_O
 };
@@ -727 +754 @@
 #endif
     char o_opt[NUM_OPT_O];
+#if ENABLE_HUSH_MODE_X
+# define G_x_mode (G.o_opt[OPT_O_XTRACE])
+#else
+# define G_x_mode 0
+#endif
     smallint flag_SIGINT;
 #if ENABLE_HUSH_LOOPS
@@ -738 +770 @@
     smallint flag_return_in_progress;
 #endif
-    smallint n_mode;
-#if ENABLE_HUSH_MODE_X
-    smallint x_mode;
-# define G_x_mode (G.x_mode)
-#else
-# define G_x_mode 0
-#endif
     smallint exiting; /* used to prevent EXIT trap recursion */
     /* These four support $?, $#, and $1 */
@@ -750 +775 @@
     /* are global_argv and global_argv[1..n] malloced? (note: not [0]) */
     smalluint global_args_malloced;
-    smalluint inherited_set_is_saved;
     /* how many non-NULL argv's we have. NB: $# + 1 */
     int global_argc;
@@ -778 +802 @@
     smallint we_have_children;
 #endif
-    /* which signals have non-DFL handler (even with no traps set)? */
-    unsigned non_DFL_mask;
+    /* Which signals have non-DFL handler (even with no traps set)?
+     * Set at the start to:
+     * (SIGQUIT + maybe SPECIAL_INTERACTIVE_SIGS + maybe SPECIAL_JOBSTOP_SIGS)
+     * SPECIAL_INTERACTIVE_SIGS are cleared after fork.
+     * The rest is cleared right before execv syscalls.
+     * Other than these two times, never modified.
+     */
+    unsigned special_sig_mask;
+#if ENABLE_HUSH_JOB
+    unsigned fatal_sig_mask;
+# define G_fatal_sig_mask G.fatal_sig_mask
+#else
+# define G_fatal_sig_mask 0
+#endif
     char **traps; /* char *traps[NSIG] */
-    sigset_t blocked_set;
-    sigset_t inherited_set;
+    sigset_t pending_set;
 #if HUSH_DEBUG
     unsigned long memleak_value;
     int debug_indent;
 #endif
+    struct sigaction sa;
     char user_input_buf[ENABLE_FEATURE_EDITING ? CONFIG_FEATURE_EDITING_MAX_LEN : 2];
 };
@@ -795 +831 @@
 #define INIT_G() do { \
     SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
+    /* memset(&G.sa, 0, sizeof(G.sa)); */  \
+    sigfillset(&G.sa.sa_mask); \
+    G.sa.sa_flags = SA_RESTART; \
 } while (0)
 
@@ -1062 +1101 @@
 }
 
-static void syntax_error(unsigned lineno, const char *msg)
+static void syntax_error(unsigned lineno UNUSED_PARAM, const char *msg)
 {
     if (msg)
-        die_if_script(lineno, "syntax error: %s", msg);
+        bb_error_msg("syntax error: %s", msg);
     else
-        die_if_script(lineno, "syntax error", NULL);
-}
-
-static void syntax_error_at(unsigned lineno, const char *msg)
-{
-    die_if_script(lineno, "syntax error at '%s'", msg);
-}
-
-static void syntax_error_unterm_str(unsigned lineno, const char *s)
-{
-    die_if_script(lineno, "syntax error: unterminated %s", s);
-}
-
-/* It so happens that all such cases are totally fatal
- * even if shell is interactive: EOF while looking for closing
- * delimiter. There is nowhere to read stuff from after that,
- * it's EOF! The only choice is to terminate.
- */
-static void syntax_error_unterm_ch(unsigned lineno, char ch) NORETURN;
+        bb_error_msg("syntax error");
+}
+
+static void syntax_error_at(unsigned lineno UNUSED_PARAM, const char *msg)
+{
+    bb_error_msg("syntax error at '%s'", msg);
+}
+
+static void syntax_error_unterm_str(unsigned lineno UNUSED_PARAM, const char *s)
+{
+    bb_error_msg("syntax error: unterminated %s", s);
+}
+
 static void syntax_error_unterm_ch(unsigned lineno, char ch)
 {
     char msg[2] = { ch, '\0' };
     syntax_error_unterm_str(lineno, msg);
-    xfunc_die();
-}
-
-static void syntax_error_unexpected_ch(unsigned lineno, int ch)
+}
+
+static void syntax_error_unexpected_ch(unsigned lineno UNUSED_PARAM, int ch)
 {
     char msg[2];
     msg[0] = ch;
     msg[1] = '\0';
-    die_if_script(lineno, "syntax error: unexpected %s", ch == EOF ? "EOF" : msg);
+    bb_error_msg("syntax error: unexpected %s", ch == EOF ? "EOF" : msg);
 }
 
@@ -1312 +1344 @@
  *    Example 3: this does not wait 5 sec, but executes ls:
  *    "sleep 5; ls -l" + press ^C
+ *    Example 4: this does not wait and does not execute ls:
+ *    "sleep 5 & wait; ls -l" + press ^C
  *
  * (What happens to signals which are IGN on shell start?)
  * (What happens with signal mask on shell start?)
  *
- * Implementation in hush
- * ======================
+ * Old implementation
+ * ==================
  * 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,
@@ -1325 +1359 @@
  * and act on them.
  *
- * unsigned non_DFL_mask: a mask of such "special" signals
+ * unsigned special_sig_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_mask
+ *    clear bit in blocked_set unless it is also in special_sig_mask
  * "trap 'cmd' SIGxxx":
  *    set bit in blocked_set (even if 'cmd' is '')
@@ -1348 +1382 @@
  * are set to the default actions". bash interprets it so that traps which
  * are set to '' (ignore) are NOT reset to defaults. We do the same.
+ *
+ * Problem: the above approach makes it unwieldy to catch signals while
+ * we are in read builtin, of while we read commands from stdin:
+ * masked signals are not visible!
+ *
+ * New implementation
+ * ==================
+ * We record each signal we are interested in by installing signal handler
+ * for them - a bit like emulating kernel pending signal mask in userspace.
+ * We are interested in: signals which need to have special handling
+ * as described above, and all signals which have traps set.
+ * Signals are rocorded in pending_set.
+ * After each pipe execution, we extract any pending signals
+ * and act on them.
+ *
+ * unsigned special_sig_mask: a mask of shell-special signals.
+ * unsigned fatal_sig_mask: a mask of signals on which we restore tty pgrp.
+ * char *traps[sig] if trap for sig is set (even if it's '').
+ * sigset_t pending_set: set of sigs we received.
+ *
+ * "trap - SIGxxx":
+ *    if sig is in special_sig_mask, set handler back to:
+ *        record_pending_signo, or to IGN if it's a tty stop signal
+ *    if sig is in fatal_sig_mask, set handler back to sigexit.
+ *    else: set handler back to SIG_DFL
+ * "trap 'cmd' SIGxxx":
+ *    set handler to record_pending_signo.
+ * "trap '' SIGxxx":
+ *    set handler to SIG_IGN.
+ * after [v]fork, if we plan to be a shell:
+ *    set signals with special interactive handling to SIG_DFL
+ *    (because child shell is not interactive),
+ *    unset all traps except '' (note: regardless of child shell's type - {}, (), etc)
+ * after [v]fork, if we plan to exec:
+ *    POSIX says fork clears pending signal mask in child - no need to clear it.
+ *
+ * To make wait builtin interruptible, we handle SIGCHLD as special signal,
+ * otherwise (if we leave it SIG_DFL) sigsuspend in wait builtin will not wake up on it.
+ *
+ * Note (compat):
+ * Standard says "When a subshell is entered, traps that are not being ignored
+ * are set to the default actions". bash interprets it so that traps which
+ * are set to '' (ignore) are NOT reset to defaults. We do the same.
  */
 enum {
@@ -1355 +1432 @@
         | (1 << SIGHUP)
         ,
-    SPECIAL_JOB_SIGS = 0
+    SPECIAL_JOBSTOP_SIGS = 0
 #if ENABLE_HUSH_JOB
         | (1 << SIGTTIN)
@@ -1361 +1438 @@
         | (1 << SIGTSTP)
 #endif
+        ,
 };
 
+static void record_pending_signo(int sig)
+{
+    sigaddset(&G.pending_set, sig);
 #if ENABLE_HUSH_FAST
-static void SIGCHLD_handler(int sig UNUSED_PARAM)
-{
-    G.count_SIGCHLD++;
+    if (sig == SIGCHLD) {
+        G.count_SIGCHLD++;
 //bb_error_msg("[%d] SIGCHLD_handler: G.count_SIGCHLD:%d G.handled_SIGCHLD:%d", getpid(), G.count_SIGCHLD, G.handled_SIGCHLD);
-}
-#endif
+    }
+#endif
+}
+
+static sighandler_t install_sighandler(int sig, sighandler_t handler)
+{
+    struct sigaction old_sa;
+
+    /* We could use signal() to install handlers... almost:
+     * except that we need to mask ALL signals while handlers run.
+     * I saw signal nesting in strace, race window isn't small.
+     * SA_RESTART is also needed, but in Linux, signal()
+     * sets SA_RESTART too.
+     */
+    /* memset(&G.sa, 0, sizeof(G.sa)); - already done */
+    /* sigfillset(&G.sa.sa_mask);      - already done */
+    /* G.sa.sa_flags = SA_RESTART;     - already done */
+    G.sa.sa_handler = handler;
+    sigaction(sig, &G.sa, &old_sa);
+    return old_sa.sa_handler;
+}
 
 #if ENABLE_HUSH_JOB
@@ -1386 +1485 @@
 static void sigexit(int sig)
 {
-    /* Disable all signals: job control, SIGPIPE, etc. */
-    sigprocmask_allsigs(SIG_BLOCK);
-
     /* Careful: we can end up here after [v]fork. Do not restore
      * tty pgrp then, only top-level shell process does that */
-    if (G_saved_tty_pgrp && getpid() == G.root_pid)
+    if (G_saved_tty_pgrp && getpid() == G.root_pid) {
+        /* Disable all signals: job control, SIGPIPE, etc.
+         * Mostly paranoid measure, to prevent infinite SIGTTOU.
+         */
+        sigprocmask_allsigs(SIG_BLOCK);
         tcsetpgrp(G_interactive_fd, G_saved_tty_pgrp);
+    }
 
     /* Not a signal, just exit */
@@ -1407 +1508 @@
 #endif
 
+static sighandler_t pick_sighandler(unsigned sig)
+{
+    sighandler_t handler = SIG_DFL;
+    if (sig < sizeof(unsigned)*8) {
+        unsigned sigmask = (1 << sig);
+
+#if ENABLE_HUSH_JOB
+        /* is sig fatal? */
+        if (G_fatal_sig_mask & sigmask)
+            handler = sigexit;
+        else
+#endif
+        /* sig has special handling? */
+        if (G.special_sig_mask & sigmask) {
+            handler = record_pending_signo;
+            /* TTIN/TTOU/TSTP can't be set to record_pending_signo
+             * in order to ignore them: they will be raised
+             * in an endless loop when we try to do some
+             * terminal ioctls! We do have to _ignore_ these.
+             */
+            if (SPECIAL_JOBSTOP_SIGS & sigmask)
+                handler = SIG_IGN;
+        }
+    }
+    return handler;
+}
+
 /* Restores tty foreground process group, and exits. */
 static void hush_exit(int exitcode) NORETURN;
 static void hush_exit(int exitcode)
 {
+#if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
+    save_history(G.line_input_state);
+#endif
+
+    fflush_all();
     if (G.exiting <= 0 && G.traps && G.traps[0] && G.traps[0][0]) {
-        /* Prevent recursion:
-         * trap "echo Hi; exit" EXIT; exit
-         */
         char *argv[3];
         /* argv[0] is unused */
@@ -1451 +1581 @@
 
 
-static int check_and_run_traps(int sig)
-{
-    /* I want it in rodata, not in bss.
-     * gcc 4.2.1 puts it in rodata only if it has { 0, 0 }
-     * initializer. But other compilers may still use bss.
-     * TODO: find more portable solution.
-     */
-    static const struct timespec zero_timespec = { 0, 0 };
-    smalluint save_rcode;
+//TODO: return a mask of ALL handled sigs?
+static int check_and_run_traps(void)
+{
     int last_sig = 0;
 
-    if (sig)
-        goto jump_in;
     while (1) {
-        sig = sigtimedwait(&G.blocked_set, NULL, &zero_timespec);
-        if (sig <= 0)
+        int sig;
+
+        if (sigisemptyset(&G.pending_set))
             break;
- jump_in:
-        last_sig = sig;
+        sig = 0;
+        do {
+            sig++;
+            if (sigismember(&G.pending_set, sig)) {
+                sigdelset(&G.pending_set, sig);
+                goto got_sig;
+            }
+        } while (sig < NSIG);
+        break;
+ got_sig:
         if (G.traps && G.traps[sig]) {
             if (G.traps[sig][0]) {
                 /* We have user-defined handler */
+                smalluint save_rcode;
                 char *argv[3];
                 /* argv[0] is unused */
@@ -1480 +1612 @@
                 builtin_eval(argv);
                 G.last_exitcode = save_rcode;
+                last_sig = sig;
             } /* else: "" trap, ignoring signal */
             continue;
@@ -1485 +1618 @@
         /* not a trap: special action */
         switch (sig) {
-#if ENABLE_HUSH_FAST
-        case SIGCHLD:
-            G.count_SIGCHLD++;
-//bb_error_msg("[%d] check_and_run_traps: G.count_SIGCHLD:%d G.handled_SIGCHLD:%d", getpid(), G.count_SIGCHLD, G.handled_SIGCHLD);
-            break;
-#endif
         case SIGINT:
             /* Builtin was ^C'ed, make it look prettier: */
             bb_putchar('\n');
             G.flag_SIGINT = 1;
+            last_sig = sig;
             break;
 #if ENABLE_HUSH_JOB
@@ -1511 +1639 @@
         }
 #endif
+#if ENABLE_HUSH_FAST
+        case SIGCHLD:
+            G.count_SIGCHLD++;
+//bb_error_msg("[%d] check_and_run_traps: G.count_SIGCHLD:%d G.handled_SIGCHLD:%d", getpid(), G.count_SIGCHLD, G.handled_SIGCHLD);
+            /* Note:
+             * We dont do 'last_sig = sig' here -> NOT returning this sig.
+             * This simplifies wait builtin a bit.
+             */
+            break;
+#endif
         default: /* ignored: */
             /* SIGTERM, SIGQUIT, SIGTTIN, SIGTTOU, SIGTSTP */
+            /* Note:
+             * We dont do 'last_sig = sig' here -> NOT returning this sig.
+             * Example: wait is not interrupted by TERM
+             * in interactive shell, because TERM is ignored.
+             */
             break;
         }
@@ -1834 +1977 @@
     if (ch != '\0') {
         i->p++;
+        i->last_char = ch;
         return ch;
     }
@@ -1891 +2035 @@
      * is actually being read */
     do {
+        /* Unicode support should be activated even if LANG is set
+         * _during_ shell execution, not only if it was set when
+         * shell was started. Therefore, re-check LANG every time:
+         */
+        reinit_unicode(get_local_var_value("LANG"));
+
         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);
+        check_and_run_traps();
     } while (r == 0 || G.flag_SIGINT); /* repeat if ^C or SIGINT */
     i->eof_flag = (r < 0);
@@ -1906 +2056 @@
     do {
         G.flag_SIGINT = 0;
-        fputs(prompt_str, stdout);
+        if (i->last_char == '\0' || i->last_char == '\n') {
+            /* Why check_and_run_traps here? Try this interactively:
+             * $ trap 'echo INT' INT; (sleep 2; kill -INT $$) &
+             * $ <[enter], repeatedly...>
+             * Without check_and_run_traps, handler never runs.
+             */
+            check_and_run_traps();
+            fputs(prompt_str, stdout);
+        }
         fflush_all();
         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(0)? (maybe only if stdin)
     } while (G.flag_SIGINT);
     i->eof_flag = (r == EOF);
@@ -1938 +2095 @@
          * more complicated by now, like sourcing or substituting. */
 #if ENABLE_HUSH_INTERACTIVE
-        if (G_interactive_fd && i->promptme && i->file == stdin) {
+        if (G_interactive_fd && i->file == stdin) {
             do {
                 get_user_input(i);
             } while (!*i->p); /* need non-empty line */
             i->promptmode = 1; /* PS2 */
-            i->promptme = 0;
             goto take_cached;
         }
@@ -1950 +2106 @@
     }
     debug_printf("file_get: got '%c' %d\n", ch, ch);
-#if ENABLE_HUSH_INTERACTIVE
-    if (ch == '\n')
-        i->promptme = 1;
-#endif
+    i->last_char = ch;
     return ch;
 }
@@ -1980 +2133 @@
 static void setup_file_in_str(struct in_str *i, FILE *f)
 {
+    memset(i, 0, sizeof(*i));
     i->peek = file_peek;
     i->get = file_get;
-#if ENABLE_HUSH_INTERACTIVE
-    i->promptme = 1;
-    i->promptmode = 0; /* PS1 */
-#endif
+    /* i->promptmode = 0; - PS1 (memset did it) */
     i->file = f;
-    i->p = NULL;
+    /* i->p = NULL; */
 }
 
 static void setup_string_in_str(struct in_str *i, const char *s)
 {
+    memset(i, 0, sizeof(*i));
     i->peek = static_peek;
     i->get = static_get;
-#if ENABLE_HUSH_INTERACTIVE
-    i->promptme = 1;
-    i->promptmode = 0; /* PS1 */
-#endif
+    /* i->promptmode = 0; - PS1 (memset did it) */
     i->p = s;
-    i->eof_flag = 0;
+    /* i->eof_flag = 0; */
 }
 
@@ -2134 +2283 @@
         o_addblock(o, str, ordinary_cnt);
         if (ordinary_cnt == len)
-            return;
+            return; /* NUL is already added by o_addblock */
         str += ordinary_cnt;
         len -= ordinary_cnt + 1; /* we are processing + 1 char below */
@@ -2148 +2297 @@
         o->data[o->length] = ch;
         o->length++;
-        o->data[o->length] = '\0';
-    }
+    }
+    o->data[o->length] = '\0';
 }
 
@@ -2238 +2387 @@
         o->has_empty_slot = 0;
     }
+    o->has_quoted_part = 0;
     list[n] = (char*)(uintptr_t)string_len;
     return n + 1;
@@ -3117 +3267 @@
                 p += 3;
             }
-            if (p == word->data || p[0] != '\0') {
-                /* saw no "$@", or not only "$@" but some
-                 * real text is there too */
-                /* insert "empty variable" reference, this makes
-                 * e.g. "", $empty"" etc to not disappear */
-                o_addchr(word, SPECIAL_VAR_SYMBOL);
-                o_addchr(word, SPECIAL_VAR_SYMBOL);
-            }
         }
         command->argv = add_string_to_strings(command->argv, xstrdup(word->data));
@@ -3322 +3464 @@
 
     goto jump_in;
+
     while (1) {
         ch = i_getch(input);
@@ -3533 +3676 @@
 #if ENABLE_HUSH_TICK || ENABLE_SH_MATH_SUPPORT || ENABLE_HUSH_DOLLAR_OPS
 /* Subroutines for copying $(...) and `...` things */
-static void add_till_backquote(o_string *dest, struct in_str *input, int in_dquote);
+static int add_till_backquote(o_string *dest, struct in_str *input, int in_dquote);
 /* '...' */
-static void add_till_single_quote(o_string *dest, struct in_str *input)
+static int add_till_single_quote(o_string *dest, struct in_str *input)
 {
     while (1) {
@@ -3541 +3684 @@
         if (ch == EOF) {
             syntax_error_unterm_ch('\'');
-            /*xfunc_die(); - redundant */
+            return 0;
         }
         if (ch == '\'')
-            return;
+            return 1;
         o_addchr(dest, ch);
     }
 }
 /* "...\"...`..`...." - do we need to handle "...$(..)..." too? */
-static void add_till_double_quote(o_string *dest, struct in_str *input)
+static int add_till_double_quote(o_string *dest, struct in_str *input)
 {
     while (1) {
@@ -3555 +3698 @@
         if (ch == EOF) {
             syntax_error_unterm_ch('"');
-            /*xfunc_die(); - redundant */
+            return 0;
         }
         if (ch == '"')
-            return;
+            return 1;
         if (ch == '\\') {  /* \x. Copy both chars. */
             o_addchr(dest, ch);
@@ -3565 +3708 @@
         o_addchr(dest, ch);
         if (ch == '`') {
-            add_till_backquote(dest, input, /*in_dquote:*/ 1);
+            if (!add_till_backquote(dest, input, /*in_dquote:*/ 1))
+                return 0;
             o_addchr(dest, ch);
             continue;
@@ -3586 +3730 @@
  * echo `echo '\'TEST\`echo ZZ\`BEST`    \TESTZZBEST
  */
-static void add_till_backquote(o_string *dest, struct in_str *input, int in_dquote)
+static int add_till_backquote(o_string *dest, struct in_str *input, int in_dquote)
 {
     while (1) {
         int ch = i_getch(input);
         if (ch == '`')
-            return;
+            return 1;
         if (ch == '\\') {
             /* \x. Copy both unless it is \`, \$, \\ and maybe \" */
@@ -3605 +3749 @@
         if (ch == EOF) {
             syntax_error_unterm_ch('`');
-            /*xfunc_die(); - redundant */
+            return 0;
         }
         o_addchr(dest, ch);
@@ -3641 +3785 @@
         if (ch == EOF) {
             syntax_error_unterm_ch(end_ch);
-            /*xfunc_die(); - redundant */
+            return 0;
         }
         if (ch == end_ch  IF_HUSH_BASH_COMPAT( || ch == end_char2)) {
@@ -3655 +3799 @@
         if (ch == '(' || ch == '{') {
             ch = (ch == '(' ? ')' : '}');
-            add_till_closing_bracket(dest, input, ch);
+            if (!add_till_closing_bracket(dest, input, ch))
+                return 0;
             o_addchr(dest, ch);
             continue;
         }
         if (ch == '\'') {
-            add_till_single_quote(dest, input);
+            if (!add_till_single_quote(dest, input))
+                return 0;
             o_addchr(dest, ch);
             continue;
         }
         if (ch == '"') {
-            add_till_double_quote(dest, input);
+            if (!add_till_double_quote(dest, input))
+                return 0;
             o_addchr(dest, ch);
             continue;
         }
         if (ch == '`') {
-            add_till_backquote(dest, input, /*in_dquote:*/ 0);
+            if (!add_till_backquote(dest, input, /*in_dquote:*/ 0))
+                return 0;
             o_addchr(dest, ch);
             continue;
@@ -3679 +3827 @@
             if (ch == EOF) {
                 syntax_error_unterm_ch(')');
-                /*xfunc_die(); - redundant */
+                return 0;
             }
             o_addchr(dest, ch);
@@ -3750 +3898 @@
  bad_dollar_syntax:
             syntax_error_unterm_str("${name}");
-            debug_printf_parse("parse_dollar return 1: unterminated ${name}\n");
-            return 1;
+            debug_printf_parse("parse_dollar return 0: unterminated ${name}\n");
+            return 0;
         }
         nommu_addchr(as_string, ch);
@@ -3807 +3955 @@
 #if ENABLE_HUSH_DOLLAR_OPS
                 last_ch = add_till_closing_bracket(dest, input, end_ch);
+                if (last_ch == 0) /* error? */
+                    return 0;
 #else
 #error Simple code to only allow ${var} is not implemented
@@ -3851 +4001 @@
             if (!BB_MMU)
                 pos = dest->length;
-            add_till_closing_bracket(dest, input, ')' | DOUBLE_CLOSE_CHAR_FLAG);
+            if (!add_till_closing_bracket(dest, input, ')' | DOUBLE_CLOSE_CHAR_FLAG))
+                return 0; /* error */
             if (as_string) {
                 o_addstr(as_string, dest->data + pos);
@@ -3866 +4017 @@
         if (!BB_MMU)
             pos = dest->length;
-        add_till_closing_bracket(dest, input, ')');
+        if (!add_till_closing_bracket(dest, input, ')'))
+            return 0; /* error */
         if (as_string) {
             o_addstr(as_string, dest->data + pos);
@@ -3893 +4045 @@
         o_addQchr(dest, '$');
     }
-    debug_printf_parse("parse_dollar return 0\n");
-    return 0;
+    debug_printf_parse("parse_dollar return 1 (ok)\n");
+    return 1;
 #undef as_string
 }
@@ -3935 +4087 @@
         nommu_addchr(as_string, ch);
     if (ch == dquote_end) { /* may be only '"' or EOF */
-        debug_printf_parse("encode_string return 0\n");
-        return 0;
+        debug_printf_parse("encode_string return 1 (ok)\n");
+        return 1;
     }
     /* note: can't move it above ch == dquote_end check! */
     if (ch == EOF) {
         syntax_error_unterm_ch('"');
-        /*xfunc_die(); - redundant */
+        return 0; /* error */
     }
     next = '\0';
@@ -3972 +4124 @@
     }
     if (ch == '$') {
-        if (parse_dollar(as_string, dest, input, /*quote_mask:*/ 0x80) != 0) {
-            debug_printf_parse("encode_string return 1: "
-                    "parse_dollar returned non-0\n");
-            return 1;
+        if (!parse_dollar(as_string, dest, input, /*quote_mask:*/ 0x80)) {
+            debug_printf_parse("encode_string return 0: "
+                    "parse_dollar returned 0 (error)\n");
+            return 0;
         }
         goto again;
@@ -3984 +4136 @@
         o_addchr(dest, SPECIAL_VAR_SYMBOL);
         o_addchr(dest, 0x80 | '`');
-        add_till_backquote(dest, input, /*in_dquote:*/ dquote_end == '"');
+        if (!add_till_backquote(dest, input, /*in_dquote:*/ dquote_end == '"'))
+            return 0; /* error */
         o_addchr(dest, SPECIAL_VAR_SYMBOL);
         //debug_printf_subst("SUBST RES3 '%s'\n", dest->data + pos);
@@ -3999 +4152 @@
  * Return a list of pipes to execute, or NULL on EOF
  * or if end_trigger character is met.
- * On syntax error, exit is shell is not interactive,
+ * On syntax error, exit if shell is not interactive,
  * reset parsing machinery and start parsing anew,
  * or return ERR_PTR.
@@ -4028 +4181 @@
      */
 
- reset: /* we come back here only on syntax errors in interactive shell */
-
-#if ENABLE_HUSH_INTERACTIVE
-    input->promptmode = 0; /* PS1 */
-#endif
     if (MAYBE_ASSIGNMENT != 0)
         dest.o_assignment = MAYBE_ASSIGNMENT;
@@ -4058 +4206 @@
              * checking only ')' */
             if (end_trigger == ')') {
-                syntax_error_unterm_ch('('); /* exits */
-                /* goto parse_error; */
+                syntax_error_unterm_ch('(');
+                goto parse_error;
             }
 
@@ -4072 +4220 @@
              * bash says: "syntax error near unexpected token '&'") */
             if (pi->num_cmds == 0
-                IF_HAS_KEYWORDS( && pi->res_word == RES_NONE)
+            IF_HAS_KEYWORDS(&& pi->res_word == RES_NONE)
             ) {
                 free_pipe_list(pi);
@@ -4225 +4373 @@
             /* Do we sit outside of any if's, loops or case's? */
             if (!HAS_KEYWORDS
-             IF_HAS_KEYWORDS(|| (ctx.ctx_res_w == RES_NONE && ctx.old_flag == 0))
+            IF_HAS_KEYWORDS(|| (ctx.ctx_res_w == RES_NONE && ctx.old_flag == 0))
             ) {
                 o_free(&dest);
@@ -4354 +4502 @@
             break;
         case '$':
-            if (parse_dollar(&ctx.as_string, &dest, input, /*quote_mask:*/ 0) != 0) {
+            if (!parse_dollar(&ctx.as_string, &dest, input, /*quote_mask:*/ 0)) {
                 debug_printf_parse("parse_stream parse error: "
-                    "parse_dollar returned non-0\n");
+                    "parse_dollar returned 0 (error)\n");
                 goto parse_error;
             }
@@ -4362 +4510 @@
         case '\'':
             dest.has_quoted_part = 1;
-            while (1) {
-                ch = i_getch(input);
-                if (ch == EOF) {
-                    syntax_error_unterm_ch('\'');
-                    /*xfunc_die(); - redundant */
+            if (next == '\'' && !ctx.pending_redirect) {
+ insert_empty_quoted_str_marker:
+                nommu_addchr(&ctx.as_string, next);
+                i_getch(input); /* eat second ' */
+                o_addchr(&dest, SPECIAL_VAR_SYMBOL);
+                o_addchr(&dest, SPECIAL_VAR_SYMBOL);
+            } else {
+                while (1) {
+                    ch = i_getch(input);
+                    if (ch == EOF) {
+                        syntax_error_unterm_ch('\'');
+                        goto parse_error;
+                    }
+                    nommu_addchr(&ctx.as_string, ch);
+                    if (ch == '\'')
+                        break;
+                    o_addqchr(&dest, ch);
                 }
-                nommu_addchr(&ctx.as_string, ch);
-                if (ch == '\'')
-                    break;
-                o_addqchr(&dest, ch);
             }
             break;
         case '"':
             dest.has_quoted_part = 1;
+            if (next == '"' && !ctx.pending_redirect)
+                goto insert_empty_quoted_str_marker;
             if (dest.o_assignment == NOT_ASSIGNMENT)
                 dest.o_expflags |= EXP_FLAG_ESC_GLOB_CHARS;
-            if (encode_string(&ctx.as_string, &dest, input, '"', /*process_bkslash:*/ 1))
+            if (!encode_string(&ctx.as_string, &dest, input, '"', /*process_bkslash:*/ 1))
                 goto parse_error;
             dest.o_expflags &= ~EXP_FLAG_ESC_GLOB_CHARS;
@@ -4384 +4542 @@
 #if ENABLE_HUSH_TICK
         case '`': {
-            unsigned pos;
+            USE_FOR_NOMMU(unsigned pos;)
 
             o_addchr(&dest, SPECIAL_VAR_SYMBOL);
             o_addchr(&dest, '`');
-            pos = dest.length;
-            add_till_backquote(&dest, input, /*in_dquote:*/ 0);
+            USE_FOR_NOMMU(pos = dest.length;)
+            if (!add_till_backquote(&dest, input, /*in_dquote:*/ 0))
+                goto parse_error;
 # if !BB_MMU
             o_addstr(&ctx.as_string, dest.data + pos);
@@ -4528 +4687 @@
             IF_HAS_KEYWORDS(pctx = p2;)
         } while (HAS_KEYWORDS && pctx);
-        /* Free text, clear all dest fields */
+
         o_free(&dest);
-        /* If we are not in top-level parse, we return,
-         * our caller will propagate error.
-         */
-        if (end_trigger != ';') {
+        G.last_exitcode = 1;
 #if !BB_MMU
-            if (pstring)
-                *pstring = NULL;
-#endif
-            debug_leave();
-            return ERR_PTR;
-        }
-        /* Discard cached input, force prompt */
-        input->p = NULL;
-        IF_HUSH_INTERACTIVE(input->promptme = 1;)
-        goto reset;
+        if (pstring)
+            *pstring = NULL;
+#endif
+        debug_leave();
+        return ERR_PTR;
     }
 }
@@ -4604 +4755 @@
 /* Store given string, finalizing the word and starting new one whenever
  * we encounter IFS char(s). This is used for expanding variable values.
- * End-of-string does NOT finalize word: think about 'echo -$VAR-' */
-static int expand_on_ifs(o_string *output, int n, const char *str)
-{
+ * End-of-string does NOT finalize word: think about 'echo -$VAR-'.
+ * Return in *ended_with_ifs:
+ * 1 - ended with IFS char, else 0 (this includes case of empty str).
+ */
+static int expand_on_ifs(int *ended_with_ifs, o_string *output, int n, const char *str)
+{
+    int last_is_ifs = 0;
+
     while (1) {
-        int word_len = strcspn(str, G.ifs);
+        int word_len;
+
+        if (!*str)  /* EOL - do not finalize word */
+            break;
+        word_len = strcspn(str, G.ifs);
         if (word_len) {
+            /* We have WORD_LEN leading non-IFS chars */
             if (!(output->o_expflags & EXP_FLAG_GLOB)) {
                 o_addblock(output, str, word_len);
@@ -4622 +4783 @@
                 /*o_addqblock(output, str, word_len); - WRONG: "v='*'; echo Z$v" prints "Z*" instead of Z* files */
             }
+            last_is_ifs = 0;
             str += word_len;
-        }
+            if (!*str)  /* EOL - do not finalize word */
+                break;
+        }
+
+        /* We know str here points to at least one IFS char */
+        last_is_ifs = 1;
+        str += strspn(str, G.ifs); /* skip IFS chars */
         if (!*str)  /* EOL - do not finalize word */
             break;
-        o_addchr(output, '\0');
-        debug_print_list("expand_on_ifs", output, n);
-        n = o_save_ptr(output, n);
-        str += strspn(str, G.ifs); /* skip ifs chars */
-    }
+
+        /* Start new word... but not always! */
+        /* Case "v=' a'; echo ''$v": we do need to finalize empty word: */
+        if (output->has_quoted_part
+        /* Case "v=' a'; echo $v":
+         * here nothing precedes the space in $v expansion,
+         * therefore we should not finish the word
+         * (IOW: if there *is* word to finalize, only then do it):
+         */
+         || (n > 0 && output->data[output->length - 1])
+        ) {
+            o_addchr(output, '\0');
+            debug_print_list("expand_on_ifs", output, n);
+            n = o_save_ptr(output, n);
+        }
+    }
+
+    if (ended_with_ifs)
+        *ended_with_ifs = last_is_ifs;
     debug_print_list("expand_on_ifs[1]", output, n);
     return n;
@@ -4667 +4849 @@
     setup_string_in_str(&input, str);
     encode_string(NULL, &dest, &input, EOF, process_bkslash);
+//TODO: error check (encode_string returns 0 on error)?
     //bb_error_msg("'%s' -> '%s'", str, dest.data);
     exp_str = expand_string_to_string(dest.data, /*unbackslash:*/ do_unbackslash);
@@ -5044 +5227 @@
      */
     char cant_be_null = 0; /* only bit 0x80 matters */
+    int ended_in_ifs = 0;  /* did last unquoted expansion end with IFS chars? */
     char *p;
 
@@ -5062 +5246 @@
         char arith_buf[sizeof(arith_t)*3 + 2];
 #endif
+
+        if (ended_in_ifs) {
+            o_addchr(output, '\0');
+            n = o_save_ptr(output, n);
+            ended_in_ifs = 0;
+        }
+
         o_addblock(output, arg, p - arg);
         debug_print_list("expand_vars_to_list[1]", output, n);
@@ -5090 +5281 @@
             if (!(first_ch & 0x80)) { /* unquoted $* or $@ */
                 while (G.global_argv[i]) {
-                    n = expand_on_ifs(output, n, G.global_argv[i]);
+                    n = expand_on_ifs(NULL, output, n, G.global_argv[i]);
                     debug_printf_expand("expand_vars_to_list: argv %d (last %d)\n", i, G.global_argc - 1);
                     if (G.global_argv[i++][0] && G.global_argv[i]) {
@@ -5123 +5314 @@
                         o_addchr(output, G.ifs[0]);
                 }
+                output->has_quoted_part = 1;
             }
             break;
@@ -5128 +5320 @@
         case SPECIAL_VAR_SYMBOL: /* <SPECIAL_VAR_SYMBOL><SPECIAL_VAR_SYMBOL> */
             /* "Empty variable", used to make "" etc to not disappear */
+            output->has_quoted_part = 1;
             arg++;
             cant_be_null = 0x80;
@@ -5165 +5358 @@
                         !!(output->o_expflags & EXP_FLAG_ESC_GLOB_CHARS));
                 if (val && val[0]) {
-                    n = expand_on_ifs(output, n, val);
+                    n = expand_on_ifs(&ended_in_ifs, output, n, val);
                     val = NULL;
                 }
             } else { /* quoted $VAR, val will be appended below */
+                output->has_quoted_part = 1;
                 debug_printf_expand("quoted '%s', output->o_escape:%d\n", val,
                         !!(output->o_expflags & EXP_FLAG_ESC_GLOB_CHARS));
@@ -5193 +5387 @@
 
     if (arg[0]) {
+        if (ended_in_ifs) {
+            o_addchr(output, '\0');
+            n = o_save_ptr(output, n);
+        }
         debug_print_list("expand_vars_to_list[a]", output, n);
         /* this part is literal, and it was already pre-quoted
@@ -5323 +5521 @@
 
 
+static void switch_off_special_sigs(unsigned mask)
+{
+    unsigned sig = 0;
+    while ((mask >>= 1) != 0) {
+        sig++;
+        if (!(mask & 1))
+            continue;
+        if (G.traps) {
+            if (G.traps[sig] && !G.traps[sig][0])
+                /* trap is '', has to remain SIG_IGN */
+                continue;
+            free(G.traps[sig]);
+            G.traps[sig] = NULL;
+        }
+        /* We are here only if no trap or trap was not '' */
+        install_sighandler(sig, SIG_DFL);
+    }
+}
+
 #if BB_MMU
 /* never called */
@@ -5342 +5559 @@
      * Same goes for SIGTERM, SIGHUP, SIGINT.
      */
-    if (!G.traps && !(G.non_DFL_mask & SPECIAL_INTERACTIVE_SIGS))
-        return; /* already no traps and no SPECIAL_INTERACTIVE_SIGS */
-
-    /* Switching off SPECIAL_INTERACTIVE_SIGS.
-     * Stupid. It can be done with *single* &= op, but we can't use
-     * the fact that G.blocked_set is implemented as a bitmask
-     * in libc... */
-    mask = (SPECIAL_INTERACTIVE_SIGS >> 1);
-    sig = 1;
-    while (1) {
-        if (mask & 1) {
-            /* Careful. Only if no trap or trap is not "" */
-            if (!G.traps || !G.traps[sig] || G.traps[sig][0])
-                sigdelset(&G.blocked_set, sig);
-        }
-        mask >>= 1;
-        if (!mask)
-            break;
-        sig++;
-    }
-    /* Our homegrown sig mask is saner to work with :) */
-    G.non_DFL_mask &= ~SPECIAL_INTERACTIVE_SIGS;
-
-    /* Resetting all traps to default except empty ones */
-    mask = G.non_DFL_mask;
-    if (G.traps) for (sig = 0; sig < NSIG; sig++, mask >>= 1) {
-        if (!G.traps[sig] || !G.traps[sig][0])
-            continue;
+    mask = (G.special_sig_mask & SPECIAL_INTERACTIVE_SIGS) | G_fatal_sig_mask;
+    if (!G.traps && !mask)
+        return; /* already no traps and no special sigs */
+
+    /* Switch off special sigs */
+    switch_off_special_sigs(mask);
+#if ENABLE_HUSH_JOB
+    G_fatal_sig_mask = 0;
+#endif
+    G.special_sig_mask &= ~SPECIAL_INTERACTIVE_SIGS;
+    /* SIGQUIT,SIGCHLD and maybe SPECIAL_JOBSTOP_SIGS
+     * remain set in G.special_sig_mask */
+
+    if (!G.traps)
+        return;
+
+    /* Reset all sigs to default except ones with empty traps */
+    for (sig = 0; sig < NSIG; sig++) {
+        if (!G.traps[sig])
+            continue; /* no trap: nothing to do */
+        if (!G.traps[sig][0])
+            continue; /* empty trap: has to remain SIG_IGN */
+        /* sig has non-empty trap, reset it: */
         free(G.traps[sig]);
         G.traps[sig] = NULL;
-        /* There is no signal for 0 (EXIT) */
+        /* There is no signal for trap 0 (EXIT) */
         if (sig == 0)
             continue;
-        /* There was a trap handler, we just removed it.
-         * But if sig still has non-DFL handling,
-         * we should not unblock the sig. */
-        if (mask & 1)
-            continue;
-        sigdelset(&G.blocked_set, sig);
-    }
-    sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
+        install_sighandler(sig, pick_sighandler(sig));
+    }
 }
 
@@ -5493 +5699 @@
      *
      * I conclude it means we don't need to pass active traps here.
-     * Even if we would use signal handlers instead of signal masking
-     * in order to implement trap handling,
-     * exec syscall below resets signals to SIG_DFL for us.
      */
     *pp++ = (char *) "-c";
@@ -5512 +5715 @@
  do_exec:
     debug_printf_exec("re_execute_shell pid:%d cmd:'%s'\n", getpid(), s);
-    sigprocmask(SIG_SETMASK, &G.inherited_set, NULL);
+    /* Don't propagate SIG_IGN to the child */
+    if (SPECIAL_JOBSTOP_SIGS != 0)
+        switch_off_special_sigs(G.special_sig_mask & SPECIAL_JOBSTOP_SIGS);
     execve(bb_busybox_exec_path, argv, pp);
     /* Fallback. Useful for init=/bin/hush usage etc */
@@ -5543 +5748 @@
         struct pipe *pipe_list;
 
+#if ENABLE_HUSH_INTERACTIVE
+        if (end_trigger == ';')
+            inp->promptmode = 0; /* PS1 */
+#endif
         pipe_list = parse_stream(NULL, inp, end_trigger);
-        if (!pipe_list) { /* EOF */
-            if (empty)
+        if (!pipe_list || pipe_list == ERR_PTR) { /* EOF/error */
+            /* If we are in "big" script
+             * (not in `cmd` or something similar)...
+             */
+            if (pipe_list == ERR_PTR && end_trigger == ';') {
+                /* Discard cached input (rest of line) */
+                int ch = inp->last_char;
+                while (ch != EOF && ch != '\n') {
+                    //bb_error_msg("Discarded:'%c'", ch);
+                    ch = i_getch(inp);
+                }
+                /* Force prompt */
+                inp->p = NULL;
+                /* This stream isn't empty */
+                empty = 0;
+                continue;
+            }
+            if (!pipe_list && empty)
                 G.last_exitcode = 0;
             break;
@@ -5553 +5778 @@
         run_and_free_list(pipe_list);
         empty = 0;
+#if ENABLE_HUSH_FUNCTIONS
+        if (G.flag_return_in_progress == 1)
+            break;
+#endif
     }
 }
@@ -6119 +6348 @@
 {
 #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
@@ -6139 +6371 @@
 {
     debug_printf_exec("execing '%s'\n", argv[0]);
-    sigprocmask(SIG_SETMASK, &G.inherited_set, NULL);
+    /* Don't propagate SIG_IGN to the child */
+    if (SPECIAL_JOBSTOP_SIGS != 0)
+        switch_off_special_sigs(G.special_sig_mask & SPECIAL_JOBSTOP_SIGS);
     execvp(argv[0], argv);
     bb_perror_msg("can't execute '%s'", argv[0]);
@@ -6271 +6505 @@
             /* Re-exec ourselves */
             debug_printf_exec("re-execing applet '%s'\n", argv[0]);
-            sigprocmask(SIG_SETMASK, &G.inherited_set, NULL);
+            /* Don't propagate SIG_IGN to the child */
+            if (SPECIAL_JOBSTOP_SIGS != 0)
+                switch_off_special_sigs(G.special_sig_mask & SPECIAL_JOBSTOP_SIGS);
             execv(bb_busybox_exec_path, argv);
             /* If they called chroot or otherwise made the binary no longer
@@ -6514 +6750 @@
                     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)
                      */
@@ -6520 +6756 @@
                         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? */
@@ -6527 +6765 @@
                     fg_pipe->cmds[i].cmd_exitcode = ex;
                 } else {
-                    fg_pipe->cmds[i].is_stopped = 1;
                     fg_pipe->stopped_cmds++;
                 }
@@ -6588 +6825 @@
         } else {
             /* child stopped */
-            pi->cmds[i].is_stopped = 1;
             pi->stopped_cmds++;
         }
@@ -6629 +6865 @@
  * 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.
@@ -6811 +7047 @@
 
         /* 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);
-        }
-#endif
-        else {
+        } else
+#endif
+        {
             argv_expanded = expand_strvec_to_strvec(argv + command->assignment_cnt);
         }
@@ -6847 +7082 @@
                     debug_printf_exec(": builtin '%s' '%s'...\n",
                         x->b_cmd, argv_expanded[1]);
+                    fflush_all();
                     rcode = x->b_function(argv_expanded) & 0xff;
                     fflush_all();
@@ -6879 +7115 @@
         }
 
-        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)) {
@@ -6968 +7204 @@
                 _exit(1);
 
-            /* Restore default handlers just prior to exec */
-            /*signal(SIGCHLD, SIG_DFL); - so far we don't have any handlers */
-
             /* Stores to nommu_save list of env vars putenv'ed
              * (NOMMU, on MMU we don't need that) */
@@ -7248 +7481 @@
                 G.last_exitcode = rcode;
                 debug_printf_exec(": builtin/func exitcode %d\n", rcode);
-                check_and_run_traps(0);
+                check_and_run_traps();
 #if ENABLE_HUSH_LOOPS
                 /* Was it "break" or "continue"? */
@@ -7280 +7513 @@
                  * try "{ { sleep 10; echo DEEP; } & echo HERE; } &".
                  * I'm NOT treating inner &'s as jobs */
-                check_and_run_traps(0);
+                check_and_run_traps();
 #if ENABLE_HUSH_JOB
                 if (G.run_list_level == 1)
@@ -7295 +7528 @@
                     rcode = checkjobs_and_fg_shell(pi);
                     debug_printf_exec(": checkjobs_and_fg_shell exitcode %d\n", rcode);
-                    check_and_run_traps(0);
+                    check_and_run_traps();
                 } else
 #endif
@@ -7301 +7534 @@
                     rcode = checkjobs(pi);
                     debug_printf_exec(": checkjobs exitcode %d\n", rcode);
-                    check_and_run_traps(0);
+                    check_and_run_traps();
                 }
                 G.last_exitcode = rcode;
@@ -7316 +7549 @@
         if (pi->next
          && (pi->next->res_word == RES_DO || pi->next->res_word == RES_DONE)
-        /* (the second check above is needed for "while ...; do \n done" case) */
+         /* check for RES_DONE is needed for "while ...; do \n done" case */
         ) {
             if (rword == RES_WHILE) {
@@ -7362 +7595 @@
     int rcode = 0;
     debug_printf_exec("run_and_free_list entered\n");
-    if (!G.n_mode) {
+    if (!G.o_opt[OPT_O_NOEXEC]) {
         debug_printf_exec(": run_list: 1st pipe with %d cmds\n", pi->num_cmds);
         rcode = run_list(pi);
@@ -7375 +7608 @@
 
 
+static void install_sighandlers(unsigned mask)
+{
+    sighandler_t old_handler;
+    unsigned sig = 0;
+    while ((mask >>= 1) != 0) {
+        sig++;
+        if (!(mask & 1))
+            continue;
+        old_handler = install_sighandler(sig, pick_sighandler(sig));
+        /* POSIX allows shell to re-enable SIGCHLD
+         * even if it was SIG_IGN on entry.
+         * Therefore we skip IGN check for it:
+         */
+        if (sig == SIGCHLD)
+            continue;
+        if (old_handler == SIG_IGN) {
+            /* oops... restore back to IGN, and record this fact */
+            install_sighandler(sig, old_handler);
+            if (!G.traps)
+                G.traps = xzalloc(sizeof(G.traps[0]) * NSIG);
+            free(G.traps[sig]);
+            G.traps[sig] = xzalloc(1); /* == xstrdup(""); */
+        }
+    }
+}
+
 /* Called a few times only (or even once if "sh -c") */
-static void init_sigmasks(void)
-{
-    unsigned sig;
+static void install_special_sighandlers(void)
+{
     unsigned mask;
-    sigset_t old_blocked_set;
-
-    if (!G.inherited_set_is_saved) {
-        sigprocmask(SIG_SETMASK, NULL, &G.blocked_set);
-        G.inherited_set = G.blocked_set;
-    }
-    old_blocked_set = G.blocked_set;
-
-    mask = (1 << SIGQUIT);
+
+    /* Which signals are shell-special? */
+    mask = (1 << SIGQUIT) | (1 << SIGCHLD);
     if (G_interactive_fd) {
-        mask = (1 << SIGQUIT) | SPECIAL_INTERACTIVE_SIGS;
+        mask |= SPECIAL_INTERACTIVE_SIGS;
         if (G_saved_tty_pgrp) /* we have ctty, job control sigs work */
-            mask |= SPECIAL_JOB_SIGS;
-    }
-    G.non_DFL_mask = mask;
-
-    sig = 0;
-    while (mask) {
-        if (mask & 1)
-            sigaddset(&G.blocked_set, sig);
-        mask >>= 1;
-        sig++;
-    }
-    sigdelset(&G.blocked_set, SIGCHLD);
-
-    if (memcmp(&old_blocked_set, &G.blocked_set, sizeof(old_blocked_set)) != 0)
-        sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
-
-    /* POSIX allows shell to re-enable SIGCHLD
-     * even if it was SIG_IGN on entry */
-#if ENABLE_HUSH_FAST
-    G.count_SIGCHLD++; /* ensure it is != G.handled_SIGCHLD */
-    if (!G.inherited_set_is_saved)
-        signal(SIGCHLD, SIGCHLD_handler);
-#else
-    if (!G.inherited_set_is_saved)
-        signal(SIGCHLD, SIG_DFL);
-#endif
-
-    G.inherited_set_is_saved = 1;
+            mask |= SPECIAL_JOBSTOP_SIGS;
+    }
+    /* Careful, do not re-install handlers we already installed */
+    if (G.special_sig_mask != mask) {
+        unsigned diff = mask & ~G.special_sig_mask;
+        G.special_sig_mask = mask;
+        install_sighandlers(diff);
+    }
 }
 
 #if ENABLE_HUSH_JOB
 /* helper */
-static void maybe_set_to_sigexit(int sig)
-{
-    void (*handler)(int);
-    /* non_DFL_mask'ed signals are, well, masked,
-     * no need to set handler for them.
+/* Set handlers to restore tty pgrp and exit */
+static void install_fatal_sighandlers(void)
+{
+    unsigned mask;
+
+    /* We will restore tty pgrp on these signals */
+    mask = 0
+        + (1 << SIGILL ) * HUSH_DEBUG
+        + (1 << SIGFPE ) * HUSH_DEBUG
+        + (1 << SIGBUS ) * HUSH_DEBUG
+        + (1 << SIGSEGV) * HUSH_DEBUG
+        + (1 << SIGTRAP) * HUSH_DEBUG
+        + (1 << SIGABRT)
+    /* bash 3.2 seems to handle these just like 'fatal' ones */
+        + (1 << SIGPIPE)
+        + (1 << SIGALRM)
+    /* if we are interactive, SIGHUP, SIGTERM and SIGINT are special sigs.
+     * if we aren't interactive... but in this case
+     * we never want to restore pgrp on exit, and this fn is not called
      */
-    if (!((G.non_DFL_mask >> sig) & 1)) {
-        handler = signal(sig, sigexit);
-        if (handler == SIG_IGN) /* oops... restore back to IGN! */
-            signal(sig, handler);
-    }
-}
-/* Set handlers to restore tty pgrp and exit */
-static void set_fatal_handlers(void)
-{
-    /* We _must_ restore tty pgrp on fatal signals */
-    if (HUSH_DEBUG) {
-        maybe_set_to_sigexit(SIGILL );
-        maybe_set_to_sigexit(SIGFPE );
-        maybe_set_to_sigexit(SIGBUS );
-        maybe_set_to_sigexit(SIGSEGV);
-        maybe_set_to_sigexit(SIGTRAP);
-    } /* else: hush is perfect. what SEGV? */
-    maybe_set_to_sigexit(SIGABRT);
-    /* bash 3.2 seems to handle these just like 'fatal' ones */
-    maybe_set_to_sigexit(SIGPIPE);
-    maybe_set_to_sigexit(SIGALRM);
-    /* if we are interactive, SIGHUP, SIGTERM and SIGINT are masked.
-     * if we aren't interactive... but in this case
-     * we never want to restore pgrp on exit, and this fn is not called */
-    /*maybe_set_to_sigexit(SIGHUP );*/
-    /*maybe_set_to_sigexit(SIGTERM);*/
-    /*maybe_set_to_sigexit(SIGINT );*/
+        /*+ (1 << SIGHUP )*/
+        /*+ (1 << SIGTERM)*/
+        /*+ (1 << SIGINT )*/
+    ;
+    G_fatal_sig_mask = mask;
+
+    install_sighandlers(mask);
 }
 #endif
@@ -7465 +7691 @@
     switch (mode) {
     case 'n':
-        G.n_mode = state;
+        G.o_opt[OPT_O_NOEXEC] = state;
         break;
     case 'x':
@@ -7502 +7728 @@
 int hush_main(int argc, char **argv)
 {
+    enum {
+        OPT_login = (1 << 0),
+    };
+    unsigned flags;
     int opt;
     unsigned builtin_argc;
@@ -7509 +7739 @@
 
     INIT_G();
-    if (EXIT_SUCCESS) /* if EXIT_SUCCESS == 0, it is already done */
+    if (EXIT_SUCCESS != 0) /* if EXIT_SUCCESS == 0, it is already done */
         G.last_exitcode = EXIT_SUCCESS;
+#if ENABLE_HUSH_FAST
+    G.count_SIGCHLD++; /* ensure it is != G.handled_SIGCHLD */
+#endif
 #if !BB_MMU
     G.argv0_for_re_execing = argv[0];
@@ -7584 +7817 @@
 #if ENABLE_FEATURE_EDITING
     G.line_input_state = new_line_input_t(FOR_SHELL);
-# if defined MAX_HISTORY && MAX_HISTORY > 0 && ENABLE_HUSH_SAVEHISTORY
-    {
-        const char *hp = get_local_var_value("HISTFILE");
-        if (!hp) {
-            hp = get_local_var_value("HOME");
-            if (hp) {
-                G.line_input_state->hist_file = concat_path_file(hp, ".hush_history");
-                //set_local_var(xasprintf("HISTFILE=%s", ...));
-            }
-        }
-    }
-# endif
-#endif
-
-    G.global_argc = argc;
-    G.global_argv = argv;
+#endif
+
     /* Initialize some more globals to non-zero values */
     cmdedit_update_prompt();
@@ -7611 +7830 @@
 
     /* Shell is non-interactive at first. We need to call
-     * init_sigmasks() if we are going to execute "sh <script>",
+     * install_special_sighandlers() if we are going to execute "sh <script>",
      * "sh -c <cmds>" or login shell's /etc/profile and friends.
-     * If we later decide that we are interactive, we run init_sigmasks()
+     * If we later decide that we are interactive, we run install_special_sighandlers()
      * in order to intercept (more) signals.
      */
@@ -7619 +7838 @@
     /* Parse options */
     /* http://www.opengroup.org/onlinepubs/9699919799/utilities/sh.html */
+    flags = (argv[0] && argv[0][0] == '-') ? OPT_login : 0;
     builtin_argc = 0;
     while (1) {
-        opt = getopt(argc, argv, "+c:xins"
+        opt = getopt(argc, argv, "+c:xinsl"
 #if !BB_MMU
                 "<:$:R:V:"
@@ -7653 +7873 @@
                 const struct built_in_command *x;
 
-                init_sigmasks();
+                install_special_sighandlers();
                 x = find_builtin(optarg);
                 if (x) { /* paranoia */
@@ -7659 +7879 @@
                     G.global_argv += builtin_argc;
                     G.global_argv[-1] = NULL; /* replace "" */
+                    fflush_all();
                     G.last_exitcode = x->b_function(argv + optind - 1);
                 }
@@ -7669 +7890 @@
                 G.global_argc++;
             } /* else -c 'script' ARG0 [ARG1...]: $0 is ARG0 */
-            init_sigmasks();
+            install_special_sighandlers();
             parse_and_run_string(optarg);
             goto final_return;
@@ -7680 +7901 @@
             /* "-s" means "read from stdin", but this is how we always
              * operate, so simply do nothing here. */
+            break;
+        case 'l':
+            flags |= OPT_login;
             break;
 #if !BB_MMU
@@ -7701 +7925 @@
             if (empty_trap_mask != 0) {
                 int sig;
-                init_sigmasks();
+                install_special_sighandlers();
                 G.traps = xzalloc(sizeof(G.traps[0]) * NSIG);
                 for (sig = 1; sig < NSIG; sig++) {
                     if (empty_trap_mask & (1LL << sig)) {
                         G.traps[sig] = xzalloc(1); /* == xstrdup(""); */
-                        sigaddset(&G.blocked_set, sig);
+                        install_sighandler(sig, SIG_IGN);
                     }
                 }
-                sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
             }
 # if ENABLE_HUSH_LOOPS
@@ -7747 +7970 @@
     } /* option parsing loop */
 
+    /* Skip options. Try "hush -l": $1 should not be "-l"! */
+    G.global_argc = argc - (optind - 1);
+    G.global_argv = argv + (optind - 1);
+    G.global_argv[0] = argv[0];
+
     if (!G.root_pid) {
         G.root_pid = getpid();
@@ -7753 +7981 @@
 
     /* If we are login shell... */
-    if (argv[0] && argv[0][0] == '-') {
+    if (flags & OPT_login) {
         FILE *input;
         debug_printf("sourcing /etc/profile\n");
@@ -7759 +7987 @@
         if (input != NULL) {
             close_on_exec_on(fileno(input));
-            init_sigmasks();
+            install_special_sighandlers();
             parse_and_run_file(input);
             fclose(input);
@@ -7772 +8000 @@
     }
 
-    if (argv[optind]) {
+    if (G.global_argv[1]) {
         FILE *input;
         /*
@@ -7779 +8007 @@
          * If called as sh, does the same but with $ENV.
          */
-        debug_printf("running script '%s'\n", argv[optind]);
-        G.global_argv = argv + optind;
-        G.global_argc = argc - optind;
-        input = xfopen_for_read(argv[optind]);
+        G.global_argc--;
+        G.global_argv++;
+        debug_printf("running script '%s'\n", G.global_argv[0]);
+        input = xfopen_for_read(G.global_argv[0]);
         close_on_exec_on(fileno(input));
-        init_sigmasks();
+        install_special_sighandlers();
         parse_and_run_file(input);
 #if ENABLE_FEATURE_CLEAN_UP
@@ -7793 +8021 @@
 
     /* Up to here, shell was non-interactive. Now it may become one.
-     * NB: don't forget to (re)run init_sigmasks() as needed.
+     * NB: don't forget to (re)run install_special_sighandlers() as needed.
      */
 
@@ -7845 +8073 @@
         }
 
-        /* Block some signals */
-        init_sigmasks();
+        /* Install more signal handlers */
+        install_special_sighandlers();
 
         if (G_saved_tty_pgrp) {
             /* Set other signals to restore saved_tty_pgrp */
-            set_fatal_handlers();
+            install_fatal_sighandlers();
             /* Put ourselves in our own process group
              * (bash, too, does this only if ctty is available) */
@@ -7860 +8088 @@
          * (we reset die_sleep = 0 whereever we [v]fork) */
         enable_restore_tty_pgrp_on_exit(); /* sets die_sleep = -1 */
+
+# if ENABLE_HUSH_SAVEHISTORY && MAX_HISTORY > 0
+        {
+            const char *hp = get_local_var_value("HISTFILE");
+            if (!hp) {
+                hp = get_local_var_value("HOME");
+                if (hp)
+                    hp = concat_path_file(hp, ".hush_history");
+            } else {
+                hp = xstrdup(hp);
+            }
+            if (hp) {
+                G.line_input_state->hist_file = hp;
+                //set_local_var(xasprintf("HISTFILE=%s", ...));
+            }
+#  if ENABLE_FEATURE_SH_HISTFILESIZE
+            hp = get_local_var_value("HISTFILESIZE");
+            G.line_input_state->max_history = size_from_HISTFILESIZE(hp);
+#  endif
+        }
+# endif
     } else {
-        init_sigmasks();
+        install_special_sighandlers();
     }
 #elif ENABLE_HUSH_INTERACTIVE
@@ -7878 +8127 @@
         close_on_exec_on(G_interactive_fd);
     }
-    init_sigmasks();
+    install_special_sighandlers();
 #else
     /* We have interactiveness code disabled */
-    init_sigmasks();
+    install_special_sighandlers();
 #endif
     /* bash:
@@ -8015 +8264 @@
 
     /* TODO: if exec fails, bash does NOT exit! We do.
-     * We'll need to undo sigprocmask (it's inside execvp_or_die)
+     * We'll need to undo trap cleanup (it's inside execvp_or_die)
      * and tcsetpgrp, and this is inherently racy.
      */
@@ -8033 +8282 @@
      * # exit
      * exit
-     # EEE (then bash exits)
+     * EEE (then bash exits)
      *
      * TODO: we can use G.exiting = -1 as indicator "last cmd was exit"
@@ -8212 +8461 @@
         ret = EXIT_SUCCESS;
         while (*argv) {
+            sighandler_t handler;
+
             sig = get_signum(*argv++);
             if (sig < 0 || sig >= NSIG) {
@@ -8230 +8481 @@
                 continue;
 
-            if (new_cmd) {
-                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);
+            if (new_cmd)
+                handler = (new_cmd[0] ? record_pending_signo : SIG_IGN);
+            else
+                /* We are removing trap handler */
+                handler = pick_sighandler(sig);
+            install_sighandler(sig, handler);
+        }
         return ret;
     }
@@ -8346 +8592 @@
     for (i = 0; i < pi->num_cmds; i++) {
         debug_printf_jobs("reviving pid %d\n", pi->cmds[i].pid);
-        pi->cmds[i].is_stopped = 0;
     }
     pi->stopped_cmds = 0;
@@ -8442 +8687 @@
 }
 
+/* Interruptibility of read builtin in bash
+ * (tested on bash-4.2.8 by sending signals (not by ^C)):
+ *
+ * Empty trap makes read ignore corresponding signal, for any signal.
+ *
+ * SIGINT:
+ * - terminates non-interactive shell;
+ * - interrupts read in interactive shell;
+ * if it has non-empty trap:
+ * - executes trap and returns to command prompt in interactive shell;
+ * - executes trap and returns to read in non-interactive shell;
+ * SIGTERM:
+ * - is ignored (does not interrupt) read in interactive shell;
+ * - terminates non-interactive shell;
+ * if it has non-empty trap:
+ * - executes trap and returns to read;
+ * SIGHUP:
+ * - terminates shell (regardless of interactivity);
+ * if it has non-empty trap:
+ * - executes trap and returns to read;
+ */
 static int FAST_FUNC builtin_read(char **argv)
 {
@@ -8449 +8715 @@
     char *opt_t = NULL;
     char *opt_u = NULL;
+    const char *ifs;
     int read_flags;
 
@@ -8458 +8725 @@
         return EXIT_FAILURE;
     argv += optind;
-
+    ifs = get_local_var_value("IFS"); /* can be NULL */
+
+ again:
     r = shell_builtin_read(set_local_var_from_halves,
         argv,
-        get_local_var_value("IFS"), /* can be NULL */
+        ifs,
         read_flags,
         opt_n,
@@ -8468 +8737 @@
         opt_u
     );
+
+    if ((uintptr_t)r == 1 && errno == EINTR) {
+        unsigned sig = check_and_run_traps();
+        if (sig && sig != SIGINT)
+            goto again;
+    }
 
     if ((uintptr_t)r > 1) {
@@ -8701 +8976 @@
 {
     int ret = EXIT_SUCCESS;
-    int status, sig;
+    int status;
 
     argv = skip_dash_dash(argv);
@@ -8721 +8996 @@
          * $
          */
-        sigaddset(&G.blocked_set, SIGCHLD);
-        sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
         while (1) {
-            checkjobs(NULL);
-            if (errno == ECHILD)
+            int sig;
+            sigset_t oldset, allsigs;
+
+            /* waitpid is not interruptible by SA_RESTARTed
+             * signals which we use. Thus, this ugly dance:
+             */
+
+            /* Make sure possible SIGCHLD is stored in kernel's
+             * pending signal mask before we call waitpid.
+             * Or else we may race with SIGCHLD, lose it,
+             * and get stuck in sigwaitinfo...
+             */
+            sigfillset(&allsigs);
+            sigprocmask(SIG_SETMASK, &allsigs, &oldset);
+
+            if (!sigisemptyset(&G.pending_set)) {
+                /* Crap! we raced with some signal! */
+            //  sig = 0;
+                goto restore;
+            }
+
+            checkjobs(NULL); /* waitpid(WNOHANG) inside */
+            if (errno == ECHILD) {
+                sigprocmask(SIG_SETMASK, &oldset, NULL);
                 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);
+            }
+
+            /* Wait for SIGCHLD or any other signal */
+            //sig = sigwaitinfo(&allsigs, NULL);
+            /* It is vitally important for sigsuspend that SIGCHLD has non-DFL handler! */
+            /* Note: sigsuspend invokes signal handler */
+            sigsuspend(&oldset);
+ restore:
+            sigprocmask(SIG_SETMASK, &oldset, NULL);
+
+            /* So, did we get a signal? */
+            //if (sig > 0)
+            //  raise(sig); /* run handler */
+            sig = check_and_run_traps();
+            if (sig /*&& sig != SIGCHLD - always true */) {
+                /* see note 2 */
+                ret = 128 + sig;
+                break;
+            }
+            /* SIGCHLD, or no signal, or ignored one, such as SIGQUIT. Repeat */
+        }
         return ret;
     }

branches/3.2/mindi-busybox/shell/hush_test/hush-parsing/starquoted2.right

@@ -1 +1 @@
 Should be printed
+Would not be printed by bash
+Would not be printed by bash
+Would not be printed by bash
 Should be printed
 Empty:

branches/3.2/mindi-busybox/shell/hush_test/hush-parsing/starquoted2.tests

@@ -9 +9 @@
 # treating "" as "this word cannot be expanded to nothing,
 # but must be at least null string". Now it can be expanded to nothing.
-for a in "$@"""; do echo Should not be printed; done
-for a in """$@"; do echo Should not be printed; done
-for a in """$@"''"$@"''; do echo Should not be printed; done
+for a in "$@"""; do echo Would not be printed by bash; done
+for a in """$@"; do echo Would not be printed by bash; done
+for a in """$@"''"$@"''; do echo Would not be printed by bash; done
 for a in ""; do echo Should be printed; done
 

branches/3.2/mindi-busybox/shell/hush_test/run-all

@@ -49 +49 @@
             #*) echo $x ; sh $x ;;
             *)
+            echo -n "$1/$x:"
             sh "$x" >"../$1-$x.fail" 2>&1 && \
-            { echo "$1/$x: ok"; rm "../$1-$x.fail"; } || echo "$1/$x: fail";
+            { { echo " ok"; rm "../$1-$x.fail"; } || echo " fail"; }
             ;;
         esac
@@ -61 +62 @@
     test -f "$name.right" || continue
 #   echo Running test: "$x"
+    echo -n "$1/$x:"
     (
         "$THIS_SH" "./$x" >"$name.xx" 2>&1
@@ -71 +73 @@
     )
     case $? in
-        0)  echo "$1/$x: ok";;
-        77) echo "$1/$x: skip (feature disabled)";;
-        *)  echo "$1/$x: fail"; tret=1;;
+        0)  echo " ok";;
+        77) echo " skip (feature disabled)";;
+        *)  echo " fail"; tret=1;;
     esac
     done

branches/3.2/mindi-busybox/shell/math.c

@@ -411 +411 @@
             c = 1;
             while (--right_side_val >= 0)
-                c *= rez;
+                c *= rez;
             rez = c;
         }

branches/3.2/mindi-busybox/shell/shell_common.c

@@ -19 +19 @@
 #include "libbb.h"
 #include "shell_common.h"
+#include <sys/resource.h> /* getrlimit */
 
 const char defifsvar[] ALIGN1 = "IFS= \t\n";
@@ -37 +38 @@
 /* read builtin */
 
+/* Needs to be interruptible: shell mush handle traps and shell-special signals
+ * while inside read. To implement this, be sure to not loop on EINTR
+ * and return errno == EINTR reliably.
+ */
 //TODO: use more efficient setvar() which takes a pointer to malloced "VAR=VAL"
 //string. hush naturally has it, and ash has setvareq().
@@ -52 +57 @@
 )
 {
+    unsigned err;
     unsigned end_ms; /* -t TIMEOUT */
     int fd; /* -u FD */
@@ -62 +68 @@
     int startword;
     smallint backslash;
+
+    errno = err = 0;
 
     pp = argv;
@@ -132 +140 @@
         if (nchars) {
             tty.c_lflag &= ~ICANON;
-            tty.c_cc[VMIN] = nchars < 256 ? nchars : 255;
+            // Setting it to more than 1 breaks poll():
+            // it blocks even if there's data. !??
+            //tty.c_cc[VMIN] = nchars < 256 ? nchars : 255;
+            /* reads would block only if < 1 char is available */
+            tty.c_cc[VMIN] = 1;
+            /* no timeout (reads block forever) */
+            tty.c_cc[VTIME] = 0;
         }
         if (read_flags & BUILTIN_READ_SILENT) {
@@ -153 +167 @@
     do {
         char c;
-
+        struct pollfd pfd[1];
+        int timeout;
+
+        if ((bufpos & 0xff) == 0)
+            buffer = xrealloc(buffer, bufpos + 0x101);
+
+        timeout = -1;
         if (end_ms) {
-            int timeout;
-            struct pollfd pfd[1];
-
-            pfd[0].fd = fd;
-            pfd[0].events = POLLIN;
             timeout = end_ms - (unsigned)monotonic_ms();
-            if (timeout <= 0 /* already late? */
-             || safe_poll(pfd, 1, timeout) != 1 /* no? wait... */
-            ) { /* timed out! */
+            if (timeout <= 0) { /* already late? */
                 retval = (const char *)(uintptr_t)1;
                 goto ret;
@@ -169 +182 @@
         }
 
-        if ((bufpos & 0xff) == 0)
-            buffer = xrealloc(buffer, bufpos + 0x100);
-        if (nonblock_safe_read(fd, &buffer[bufpos], 1) != 1) {
+        /* We must poll even if timeout is -1:
+         * we want to be interrupted if signal arrives,
+         * regardless of SA_RESTART-ness of that signal!
+         */
+        errno = 0;
+        pfd[0].fd = fd;
+        pfd[0].events = POLLIN;
+        if (poll(pfd, 1, timeout) != 1) {
+            /* timed out, or EINTR */
+            err = errno;
+            retval = (const char *)(uintptr_t)1;
+            goto ret;
+        }
+        if (read(fd, &buffer[bufpos], 1) != 1) {
+            err = errno;
             retval = (const char *)(uintptr_t)1;
             break;
         }
+
         c = buffer[bufpos];
         if (c == '\0')
@@ -241 +267 @@
     if (read_flags & BUILTIN_READ_SILENT)
         tcsetattr(fd, TCSANOW, &old_tty);
+
+    errno = err;
     return retval;
 }
@@ -287 +315 @@
     { RLIMIT_LOCKS,     0,  'w',    "locks" },
 #endif
+#ifdef RLIMIT_NICE
+    { RLIMIT_NICE,      0,  'e',    "scheduling priority" },
+#endif
+#ifdef RLIMIT_RTPRIO
+    { RLIMIT_RTPRIO,    0,  'r',    "real-time priority" },
+#endif
 };
 
@@ -328 +362 @@
 #ifdef RLIMIT_LOCKS
             "w::"
+#endif
+#ifdef RLIMIT_NICE
+            "e::"
+#endif
+#ifdef RLIMIT_RTPRIO
+            "r::"
 #endif
             ;
@@ -369 +409 @@
     /* optarg = NULL; opterr = 0; optopt = 0; - do we need this?? */
 
-        argc = 1;
-        while (argv[argc])
-                argc++;
+    argc = 1;
+    while (argv[argc])
+        argc++;
 
     opts = 0;

branches/3.2/mindi-busybox/shell/shell_common.h

@@ -19 +19 @@
 #ifndef SHELL_COMMON_H
 #define SHELL_COMMON_H 1
-/*  BCO: From http://paste.pound-python.org/show/23796/ - Fix #632 */
-#include <sys/resource.h>
-/*  End BCO */
 
 PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
 
-extern const char defifsvar[]; /* "IFS= \t\n" */
+extern const char defifsvar[] ALIGN1; /* "IFS= \t\n" */
 #define defifs (defifsvar + 4)