Merge commit '56a3b82e9692a25ef9c9269e88feac0d579ce8e8' into merge

Conflicts:
	coreutils/ls.c
	include/platform.h
	libbb/bb_basename.c

97 files changed, 3706 insertions, 2309 deletions

diff --git a/.gitignore b/.gitignore
index 7d2cca67c..0a0c65bc3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,6 +18,7 @@ Config.in
 # Normal output
 #
 /busybox
+/busybox_old
 /busybox_unstripped*
 
 #
diff --git a/Config.in b/Config.in
index 63d9f5ad7..597ceb02b 100644
--- a/Config.in
+++ b/Config.in
@@ -271,8 +271,9 @@ config UNICODE_PRESERVE_BROKEN
         default n
         depends on UNICODE_SUPPORT
         help
-          With this option on, invalid UTF-8 bytes are not substituted
-          with the selected substitution character.
+          With this option on, on line-editing input (such as used by shells)
+          invalid UTF-8 bytes are not substituted with the selected
+          substitution character.
           For example, this means that entering 'l', 's', ' ', 0xff, [Enter]
           at shell prompt will list file named 0xff (single char name
           with char value 255), not file named '?'.
@@ -365,14 +366,24 @@ config FEATURE_SUID
 
 config FEATURE_SUID_CONFIG
         bool "Runtime SUID/SGID configuration via /etc/busybox.conf"
-        default y if FEATURE_SUID
+        default y
         depends on FEATURE_SUID
         help
           Allow the SUID / SGID state of an applet to be determined at runtime
           by checking /etc/busybox.conf. (This is sort of a poor man's sudo.)
           The format of this file is as follows:
 
-          <applet> = [Ssx-][Ssx-][x-] (<username>|<uid>).(<groupname>|<gid>)
+          APPLET = [Ssx-][Ssx-][x-] [USER.GROUP]
+
+          s: USER or GROUP is allowed to execute APPLET.
+             APPLET will run under USER or GROUP
+             (reagardless of who's running it).
+          S: USER or GROUP is NOT allowed to execute APPLET.
+             APPLET will run under USER or GROUP.
+             This option is not very sensical.
+          x: USER/GROUP/others are allowed to execute APPLET.
+             No UID/GID change will be done when it is run.
+          -: USER/GROUP/others are not allowed to execute APPLET.
 
           An example might help:
 
@@ -382,7 +393,8 @@ config FEATURE_SUID_CONFIG
           su = ssx        # exactly the same
 
           mount = sx- root.disk # applet mount can be run by root and members
-                                # of group disk and runs with euid=0
+                                # of group disk (but not anyone else)
+                                # and runs with euid=0 (egid is not changed)
 
           cp = --- # disable applet cp for everyone
 
diff --git a/Makefile.flags b/Makefile.flags
index c7a805877..513b6ebb2 100644
--- a/Makefile.flags
+++ b/Makefile.flags
@@ -58,14 +58,14 @@ CFLAGS += $(call cc-option,-falign-functions=1 -falign-jumps=1 -falign-labels=1
 #CFLAGS += $(call cc-option,-Wconversion,)
 
 ifneq ($(CONFIG_DEBUG),y)
-CFLAGS += $(call cc-option,-Os,)
+CFLAGS += $(call cc-option,-Os,$(call cc-option,-O2,))
 else
 CFLAGS += $(call cc-option,-g,)
 #CFLAGS += "-D_FORTIFY_SOURCE=2"
 ifeq ($(CONFIG_DEBUG_PESSIMIZE),y)
 CFLAGS += $(call cc-option,-O0,)
 else
-CFLAGS += $(call cc-option,-Os,)
+CFLAGS += $(call cc-option,-Os,$(call cc-option,-O2,))
 endif
 endif
 
diff --git a/archival/dpkg.c b/archival/dpkg.c
index f8e349d09..8899d1719 100644
--- a/archival/dpkg.c
+++ b/archival/dpkg.c
@@ -702,28 +702,21 @@ static unsigned get_status(const unsigned status_node, const int num)
 
 static void set_status(const unsigned status_node_num, const char *new_value, const int position)
 {
-        const unsigned new_value_len = strlen(new_value);
         const unsigned new_value_num = search_name_hashtable(new_value);
         unsigned want = get_status(status_node_num, 1);
         unsigned flag = get_status(status_node_num, 2);
         unsigned status = get_status(status_node_num, 3);
-        int want_len = strlen(name_hashtable[want]);
-        int flag_len = strlen(name_hashtable[flag]);
-        int status_len = strlen(name_hashtable[status]);
         char *new_status;
 
         switch (position) {
                 case 1:
                         want = new_value_num;
-                        want_len = new_value_len;
                         break;
                 case 2:
                         flag = new_value_num;
-                        flag_len = new_value_len;
                         break;
                 case 3:
                         status = new_value_num;
-                        status_len = new_value_len;
                         break;
                 default:
                         bb_error_msg_and_die("DEBUG ONLY: this shouldnt happen");
diff --git a/archival/libarchive/bz/compress.c b/archival/libarchive/bz/compress.c
index 6f1c70a08..f93671742 100644
--- a/archival/libarchive/bz/compress.c
+++ b/archival/libarchive/bz/compress.c
@@ -251,7 +251,7 @@ void sendMTFValues(EState* s)
 {
         int32_t v, t, i, j, gs, ge, totc, bt, bc, iter;
         int32_t nSelectors, alphaSize, minLen, maxLen, selCtr;
-        int32_t nGroups, nBytes;
+        int32_t nGroups;
 
         /*
          * uint8_t len[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
@@ -512,7 +512,6 @@ void sendMTFValues(EState* s)
                         }
                 }
 
-                nBytes = s->numZ;
                 bsW(s, 16, inUse16);
 
                 inUse16 <<= (sizeof(int)*8 - 16); /* move 15th bit into sign bit */
@@ -528,7 +527,6 @@ void sendMTFValues(EState* s)
         }
 
         /*--- Now the selectors. ---*/
-        nBytes = s->numZ;
         bsW(s, 3, nGroups);
         bsW(s, 15, nSelectors);
         for (i = 0; i < nSelectors; i++) {
@@ -538,8 +536,6 @@ void sendMTFValues(EState* s)
         }
 
         /*--- Now the coding tables. ---*/
-        nBytes = s->numZ;
-
         for (t = 0; t < nGroups; t++) {
                 int32_t curr = s->len[t][0];
                 bsW(s, 5, curr);
@@ -551,7 +547,6 @@ void sendMTFValues(EState* s)
         }
 
         /*--- And finally, the block data proper ---*/
-        nBytes = s->numZ;
         selCtr = 0;
         gs = 0;
         while (1) {
diff --git a/archival/tar.c b/archival/tar.c
index 52f3c364c..fca2d068b 100644
--- a/archival/tar.c
+++ b/archival/tar.c
@@ -264,7 +264,8 @@ static int writeTarHeader(struct TarBallInfo *tbInfo,
         PUT_OCTAL(header.uid, statbuf->st_uid);
         PUT_OCTAL(header.gid, statbuf->st_gid);
         memset(header.size, '0', sizeof(header.size)-1); /* Regular file size is handled later */
-        PUT_OCTAL(header.mtime, statbuf->st_mtime);
+        /* users report that files with negative st_mtime cause trouble, so: */
+        PUT_OCTAL(header.mtime, statbuf->st_mtime >= 0 ? statbuf->st_mtime : 0);
 
         /* Enter the user and group names */
         safe_strncpy(header.uname, get_cached_username(statbuf->st_uid), sizeof(header.uname));
@@ -316,15 +317,42 @@ static int writeTarHeader(struct TarBallInfo *tbInfo,
         } else if (S_ISFIFO(statbuf->st_mode)) {
                 header.typeflag = FIFOTYPE;
         } else if (S_ISREG(statbuf->st_mode)) {
-                if (sizeof(statbuf->st_size) > 4
-                 && statbuf->st_size > (off_t)0777777777777LL
+                /* header.size field is 12 bytes long */
+                /* Does octal-encoded size fit? */
+                uoff_t filesize = statbuf->st_size;
+                if (sizeof(filesize) <= 4
+                 || filesize <= (uoff_t)0777777777777LL
                 ) {
+                        PUT_OCTAL(header.size, filesize);
+                }
+                /* Does base256-encoded size fit?
+                 * It always does unless off_t is wider than 64 bits.
+                 */
+                else if (ENABLE_FEATURE_TAR_GNU_EXTENSIONS
+#if ULLONG_MAX > 0xffffffffffffffffLL /* 2^64-1 */
+                 && (filesize <= 0x3fffffffffffffffffffffffLL)
+#endif
+                ) {
+                        /* GNU tar uses "base-256 encoding" for very large numbers.
+                         * Encoding is binary, with highest bit always set as a marker
+                         * and sign in next-highest bit:
+                         * 80 00 .. 00 - zero
+                         * bf ff .. ff - largest positive number
+                         * ff ff .. ff - minus 1
+                         * c0 00 .. 00 - smallest negative number
+                         */
+                        char *p8 = header.size + sizeof(header.size);
+                        do {
+                                *--p8 = (uint8_t)filesize;
+                                filesize >>= 8;
+                        } while (p8 != header.size);
+                        *p8 |= 0x80;
+                } else {
                         bb_error_msg_and_die("can't store file '%s' "
                                 "of size %"OFF_FMT"u, aborting",
                                 fileName, statbuf->st_size);
                 }
                 header.typeflag = REGTYPE;
-                PUT_OCTAL(header.size, statbuf->st_size);
         } else {
                 bb_error_msg("%s: unknown file type", fileName);
                 return FALSE;
diff --git a/console-tools/setconsole.c b/console-tools/setconsole.c
index 59c83361c..771974ae3 100644
--- a/console-tools/setconsole.c
+++ b/console-tools/setconsole.c
@@ -41,6 +41,6 @@ int setconsole_main(int argc UNUSED_PARAM, char **argv)
                         device = DEV_CONSOLE;
         }
 
-        xioctl(xopen(device, O_RDONLY), TIOCCONS, NULL);
+        xioctl(xopen(device, O_WRONLY), TIOCCONS, NULL);
         return EXIT_SUCCESS;
 }
diff --git a/coreutils/ls.c b/coreutils/ls.c
index 09b9f101a..c967fd462 100644
--- a/coreutils/ls.c
+++ b/coreutils/ls.c
@@ -39,7 +39,7 @@
 //usage:        IF_FEATURE_LS_SORTFILES("rSXv")
 //usage:        IF_FEATURE_LS_TIMESTAMPS("ctu")
 //usage:        IF_SELINUX("kKZ") "]"
-//usage:        IF_FEATURE_AUTOWIDTH(" -w WIDTH") " [FILE]..."
+//usage:        IF_FEATURE_AUTOWIDTH(" [-w WIDTH]") " [FILE]..."
 //usage:#define ls_full_usage "\n\n"
 //usage:       "List directory contents\n"
 //usage:     "\nOptions:"
@@ -51,14 +51,14 @@
 //usage:     "\n        -d      List directory entries instead of contents"
 //usage:        IF_FEATURE_LS_FOLLOWLINKS(
 //usage:     "\n        -L      Follow symlinks"
-//usage:     "\n        -H      Follow symlinks on command line only"
+//usage:     "\n        -H      Follow symlinks on command line"
 //usage:        )
 //usage:        IF_FEATURE_LS_RECURSIVE(
 //usage:     "\n        -R      Recurse"
 //usage:        )
 //usage:        IF_FEATURE_LS_FILETYPES(
+//usage:     "\n        -p      Append / to dir entries"
 //usage:     "\n        -F      Append indicator (one of */=@|) to entries"
-//usage:     "\n        -p      Append indicator (one of /=@|) to entries"
 //usage:        )
 //usage:     "\n        -l      Long listing format"
 //usage:     "\n        -i      List inode numbers"
@@ -118,11 +118,11 @@
 enum {
 TERMINAL_WIDTH  = 80,           /* use 79 if terminal has linefold bug */
 
-SPLIT_DIR       = 1,
 SPLIT_FILE      = 0,
+SPLIT_DIR       = 1,
 SPLIT_SUBDIR    = 2,
 
-/* Bits in all_fmt: */
+/* Bits in G.all_fmt: */
 
 /* 51306 lrwxrwxrwx  1 root     root         2 May 11 01:43 /bin/view -> vi* */
 /* what file information will be listed */
@@ -137,9 +137,9 @@ LIST_SIZE       = 1 << 7,
 LIST_DATE_TIME  = 1 << 8,
 LIST_FULLTIME   = 1 << 9,
 LIST_SYMLINK    = 1 << 10,
-LIST_FILETYPE   = 1 << 11,
-LIST_EXEC       = 1 << 12,
-LIST_MASK       = (LIST_EXEC << 1) - 1,
+LIST_FILETYPE   = 1 << 11, /* show / suffix for dirs */
+LIST_CLASSIFY   = 1 << 12, /* requires LIST_FILETYPE, also show *,|,@,= suffixes */
+LIST_MASK       = (LIST_CLASSIFY << 1) - 1,
 
 /* what files will be displayed */
 DISP_DIRNAME    = 1 << 13,      /* 2 or more items? label directories */
@@ -288,7 +288,7 @@ static const uint32_t opt_flags[] = {
         SORT_VERSION,                /* v */
 #endif
 #if ENABLE_FEATURE_LS_FILETYPES
-        LIST_FILETYPE | LIST_EXEC,   /* F */
+        LIST_FILETYPE | LIST_CLASSIFY, /* F */
         LIST_FILETYPE,               /* p */
 #endif
 #if ENABLE_FEATURE_LS_RECURSIVE
@@ -304,25 +304,65 @@ static const uint32_t opt_flags[] = {
 
 
 /*
- * a directory entry and its stat info are stored here
+ * a directory entry and its stat info
  */
 struct dnode {
-        const char *name;       /* the dir entry name */
-        const char *fullname;   /* the dir entry name */
-        struct dnode *next;     /* point at the next node */
-        smallint fname_allocated;
-        struct stat dstat;      /* the file stat info */
+        const char *name;       /* usually basename, but think "ls -l dir/file" */
+        const char *fullname;   /* full name (usable for stat etc) */
+        struct dnode *dn_next;  /* for linked list */
         IF_SELINUX(security_context_t sid;)
+        smallint fname_allocated;
+
+        /* Used to avoid re-doing [l]stat at printout stage
+         * if we already collected needed data in scan stage:
+         */
+        mode_t    dn_mode_lstat;   /* obtained with lstat, or 0 */
+        mode_t    dn_mode_stat;    /* obtained with stat, or 0 */
+
+//      struct stat dstat;
+// struct stat is huge. We don't need it in full.
+// At least we don't need st_dev and st_blksize,
+// but there are invisible fields as well
+// (such as nanosecond-resolution timespamps)
+// and padding, which we also don't want to store.
+// We also can pre-parse dev_t dn_rdev (in glibc, it's huge).
+// On 32-bit uclibc: dnode size went from 112 to 84 bytes.
+//
+        /* Same names as in struct stat, but with dn_ instead of st_ pfx: */
+        mode_t    dn_mode; /* obtained with lstat OR stat, depending on -L etc */
+        off_t     dn_size;
+#if ENABLE_FEATURE_LS_TIMESTAMPS || ENABLE_FEATURE_LS_SORTFILES
+        time_t    dn_atime;
+        time_t    dn_mtime;
+        time_t    dn_ctime;
+#endif
+        ino_t     dn_ino;
+#if !ENABLE_PLATFORM_MINGW32
+        blkcnt_t  dn_blocks;
+#endif
+        nlink_t   dn_nlink;
+        uid_t     dn_uid;
+        gid_t     dn_gid;
+        int       dn_rdev_maj;
+        int       dn_rdev_min;
+//      dev_t     dn_dev;
+//      blksize_t dn_blksize;
 };
 
 struct globals {
 #if ENABLE_FEATURE_LS_COLOR
         smallint show_color;
+# define G_show_color (G.show_color)
+#else
+# define G_show_color 0
 #endif
         smallint exit_code;
         unsigned all_fmt;
 #if ENABLE_FEATURE_AUTOWIDTH
-        unsigned terminal_width; // = TERMINAL_WIDTH;
+        unsigned terminal_width;
+# define G_terminal_width (G.terminal_width)
+#else
+# define G_terminal_width TERMINAL_WIDTH
 #endif
 #if ENABLE_FEATURE_LS_TIMESTAMPS
         /* Do time() just once. Saves one syscall per file for "ls -l" */
@@ -330,74 +370,24 @@ struct globals {
 #endif
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
-#if ENABLE_FEATURE_LS_COLOR
-# define show_color     (G.show_color    )
-#else
-enum { show_color = 0 };
-#endif
-#define exit_code       (G.exit_code     )
-#define all_fmt         (G.all_fmt       )
-#if ENABLE_FEATURE_AUTOWIDTH
-# define terminal_width (G.terminal_width)
-#else
-enum {
-        terminal_width = TERMINAL_WIDTH,
-};
-#endif
-#define current_time_t (G.current_time_t)
 #define INIT_G() do { \
         /* we have to zero it out because of NOEXEC */ \
         memset(&G, 0, sizeof(G)); \
-        IF_FEATURE_AUTOWIDTH(terminal_width = TERMINAL_WIDTH;) \
-        IF_FEATURE_LS_TIMESTAMPS(time(&current_time_t);) \
+        IF_FEATURE_AUTOWIDTH(G_terminal_width = TERMINAL_WIDTH;) \
+        IF_FEATURE_LS_TIMESTAMPS(time(&G.current_time_t);) \
 } while (0)
 
 
-static struct dnode *my_stat(const char *fullname, const char *name, int force_follow)
-{
-        struct stat dstat;
-        struct dnode *cur;
-        IF_SELINUX(security_context_t sid = NULL;)
+/*** Output code ***/
 
-        if ((option_mask32 & OPT_L) || force_follow) {
-#if ENABLE_SELINUX
-                if (is_selinux_enabled())  {
-                         getfilecon(fullname, &sid);
-                }
-#endif
-                if (stat(fullname, &dstat)) {
-                        bb_simple_perror_msg(fullname);
-                        exit_code = EXIT_FAILURE;
-                        return 0;
-                }
-        } else {
-#if ENABLE_SELINUX
-                if (is_selinux_enabled()) {
-                        lgetfilecon(fullname, &sid);
-                }
-#endif
-                if (lstat(fullname, &dstat)) {
-                        bb_simple_perror_msg(fullname);
-                        exit_code = EXIT_FAILURE;
-                        return 0;
-                }
-        }
-
-        cur = xmalloc(sizeof(*cur));
-        cur->fullname = fullname;
-        cur->name = name;
-        cur->dstat = dstat;
-        IF_SELINUX(cur->sid = sid;)
-        return cur;
-}
 
 /* FYI type values: 1:fifo 2:char 4:dir 6:blk 8:file 10:link 12:socket
  * (various wacky OSes: 13:Sun door 14:BSD whiteout 5:XENIX named file
  *  3/7:multiplexed char/block device)
  * and we use 0 for unknown and 15 for executables (see below) */
 #define TYPEINDEX(mode) (((mode) >> 12) & 0x0f)
-#define TYPECHAR(mode)  ("0pcCd?bB-?l?s???" [TYPEINDEX(mode)])
-#define APPCHAR(mode)   ("\0|\0\0/\0\0\0\0\0@\0=\0\0\0" [TYPEINDEX(mode)])
+/*                       un  fi chr -   dir -  blk  -  file -  link - sock -   - exe */
+#define APPCHAR(mode)   ("\0""|""\0""\0""/""\0""\0""\0""\0""\0""@""\0""=""\0""\0""\0" [TYPEINDEX(mode)])
 /* 036 black foreground              050 black background
    037 red foreground                051 red background
    040 green foreground              052 green background
@@ -408,7 +398,7 @@ static struct dnode *my_stat(const char *fullname, const char *name, int force_f
    045 gray foreground               057 white background
 */
 #define COLOR(mode) ( \
-        /*un  fi  chr     dir     blk     file    link    sock        exe */ \
+        /*un  fi  chr  -  dir  -  blk  -  file -  link -  sock -   -  exe */ \
         "\037\043\043\045\042\045\043\043\000\045\044\045\043\045\045\040" \
         [TYPEINDEX(mode)])
 /* Select normal (0) [actually "reset all"] or bold (1)
@@ -417,7 +407,7 @@ static struct dnode *my_stat(const char *fullname, const char *name, int force_f
  * Note: coreutils 6.9 uses inverted red for setuid binaries.
  */
 #define ATTR(mode) ( \
-        /*un fi chr   dir   blk   file  link  sock     exe */ \
+        /*un fi chr - dir - blk - file- link- sock- -  exe */ \
         "\01\00\01\07\01\07\01\07\00\07\01\07\01\07\07\01" \
         [TYPEINDEX(mode)])
 
@@ -437,14 +427,14 @@ static char bold(mode_t mode)
 }
 #endif
 
-#if ENABLE_FEATURE_LS_FILETYPES || ENABLE_FEATURE_LS_COLOR
+#if ENABLE_FEATURE_LS_FILETYPES
 static char append_char(mode_t mode)
 {
-        if (!(all_fmt & LIST_FILETYPE))
+        if (!(G.all_fmt & LIST_FILETYPE))
                 return '\0';
         if (S_ISDIR(mode))
                 return '/';
-        if (!(all_fmt & LIST_EXEC))
+        if (!(G.all_fmt & LIST_CLASSIFY))
                 return '\0';
         if (S_ISREG(mode) && (mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
                 return '*';
@@ -452,149 +442,6 @@ static char append_char(mode_t mode)
 }
 #endif
 
-static unsigned count_dirs(struct dnode **dn, int which)
-{
-        unsigned dirs, all;
-
-        if (!dn)
-                return 0;
-
-        dirs = all = 0;
-        for (; *dn; dn++) {
-                const char *name;
-
-                all++;
-                if (!S_ISDIR((*dn)->dstat.st_mode))
-                        continue;
-                name = (*dn)->name;
-                if (which != SPLIT_SUBDIR /* if not requested to skip . / .. */
-                 /* or if it's not . or .. */
-                 || name[0] != '.' || (name[1] && (name[1] != '.' || name[2]))
-                ) {
-                        dirs++;
-                }
-        }
-        return which != SPLIT_FILE ? dirs : all - dirs;
-}
-
-/* get memory to hold an array of pointers */
-static struct dnode **dnalloc(unsigned num)
-{
-        if (num < 1)
-                return NULL;
-
-        num++; /* so that we have terminating NULL */
-        return xzalloc(num * sizeof(struct dnode *));
-}
-
-#if ENABLE_FEATURE_LS_RECURSIVE
-static void dfree(struct dnode **dnp)
-{
-        unsigned i;
-
-        if (dnp == NULL)
-                return;
-
-        for (i = 0; dnp[i]; i++) {
-                struct dnode *cur = dnp[i];
-                if (cur->fname_allocated)
-                        free((char*)cur->fullname);
-                free(cur);
-        }
-        free(dnp);
-}
-#else
-#define dfree(...) ((void)0)
-#endif
-
-/* Returns NULL-terminated malloced vector of pointers (or NULL) */
-static struct dnode **splitdnarray(struct dnode **dn, int which)
-{
-        unsigned dncnt, d;
-        struct dnode **dnp;
-
-        if (dn == NULL)
-                return NULL;
-
-        /* count how many dirs or files there are */
-        dncnt = count_dirs(dn, which);
-
-        /* allocate a file array and a dir array */
-        dnp = dnalloc(dncnt);
-
-        /* copy the entrys into the file or dir array */
-        for (d = 0; *dn; dn++) {
-                if (S_ISDIR((*dn)->dstat.st_mode)) {
-                        const char *name;
-
-                        if (!(which & (SPLIT_DIR|SPLIT_SUBDIR)))
-                                continue;
-                        name = (*dn)->name;
-                        if ((which & SPLIT_DIR)
-                         || name[0]!='.' || (name[1] && (name[1]!='.' || name[2]))
-                        ) {
-                                dnp[d++] = *dn;
-                        }
-                } else if (!(which & (SPLIT_DIR|SPLIT_SUBDIR))) {
-                        dnp[d++] = *dn;
-                }
-        }
-        return dnp;
-}
-
-#if ENABLE_FEATURE_LS_SORTFILES
-static int sortcmp(const void *a, const void *b)
-{
-        struct dnode *d1 = *(struct dnode **)a;
-        struct dnode *d2 = *(struct dnode **)b;
-        unsigned sort_opts = all_fmt & SORT_MASK;
-        off_t dif;
-
-        dif = 0; /* assume SORT_NAME */
-        // TODO: use pre-initialized function pointer
-        // instead of branch forest
-        if (sort_opts == SORT_SIZE) {
-                dif = (d2->dstat.st_size - d1->dstat.st_size);
-        } else if (sort_opts == SORT_ATIME) {
-                dif = (d2->dstat.st_atime - d1->dstat.st_atime);
-        } else if (sort_opts == SORT_CTIME) {
-                dif = (d2->dstat.st_ctime - d1->dstat.st_ctime);
-        } else if (sort_opts == SORT_MTIME) {
-                dif = (d2->dstat.st_mtime - d1->dstat.st_mtime);
-        } else if (sort_opts == SORT_DIR) {
-                dif = S_ISDIR(d2->dstat.st_mode) - S_ISDIR(d1->dstat.st_mode);
-                /* } else if (sort_opts == SORT_VERSION) { */
-                /* } else if (sort_opts == SORT_EXT) { */
-        }
-        if (dif == 0) {
-                /* sort by name, or tie_breaker for other sorts */
-                if (ENABLE_LOCALE_SUPPORT)
-                        dif = strcoll(d1->name, d2->name);
-                else
-                        dif = strcmp(d1->name, d2->name);
-        }
-
-        /* Make dif fit into an int */
-        if (sizeof(dif) > sizeof(int)) {
-                enum { BITS_TO_SHIFT = 8 * (sizeof(dif) - sizeof(int)) };
-                /* shift leaving only "int" worth of bits */
-                if (dif != 0) {
-                        dif = 1 | (int)((uoff_t)dif >> BITS_TO_SHIFT);
-                }
-        }
-
-        return (all_fmt & SORT_REVERSE) ? -(int)dif : (int)dif;
-}
-
-static void dnsort(struct dnode **dn, int size)
-{
-        qsort(dn, size, sizeof(*dn), sortcmp);
-}
-#else
-#define dnsort(dn, size) ((void)0)
-#endif
-
-
 static unsigned calc_name_len(const char *name)
 {
         unsigned len;
@@ -617,7 +464,6 @@ static unsigned calc_name_len(const char *name)
         return len;
 }
 
-
 /* Return the number of used columns.
  * Note that only STYLE_COLUMNAR uses return value.
  * STYLE_SINGLE and STYLE_LONG don't care.
@@ -656,98 +502,94 @@ static unsigned print_name(const char *name)
  * Note that only STYLE_COLUMNAR uses return value,
  * STYLE_SINGLE and STYLE_LONG don't care.
  */
-static NOINLINE unsigned list_single(const struct dnode *dn)
+static NOINLINE unsigned display_single(const struct dnode *dn)
 {
         unsigned column = 0;
-        char *lpath = lpath; /* for compiler */
+        char *lpath;
 #if ENABLE_FEATURE_LS_FILETYPES || ENABLE_FEATURE_LS_COLOR
-        struct stat info;
+        struct stat statbuf;
         char append;
 #endif
 
-        /* Never happens:
-        if (dn->fullname == NULL)
-                return 0;
-        */
-
 #if ENABLE_FEATURE_LS_FILETYPES
-        append = append_char(dn->dstat.st_mode);
+        append = append_char(dn->dn_mode);
 #endif
 
         /* Do readlink early, so that if it fails, error message
          * does not appear *inside* the "ls -l" line */
-        if (all_fmt & LIST_SYMLINK)
-                if (S_ISLNK(dn->dstat.st_mode))
+        lpath = NULL;
+        if (G.all_fmt & LIST_SYMLINK)
+                if (S_ISLNK(dn->dn_mode))
                         lpath = xmalloc_readlink_or_warn(dn->fullname);
 
-        if (all_fmt & LIST_INO)
-                column += printf("%7llu ", (long long) dn->dstat.st_ino);
+        if (G.all_fmt & LIST_INO)
+                column += printf("%7llu ", (long long) dn->dn_ino);
 //TODO: -h should affect -s too:
-        if (all_fmt & LIST_BLOCKS)
+        if (G.all_fmt & LIST_BLOCKS)
 #if ENABLE_PLATFORM_MINGW32
                 /* MinGW does not have st_blocks */
                 column += printf("%6"OFF_FMT"u ", (off_t)0);
 #else
-                column += printf("%6"OFF_FMT"u ", (off_t) (dn->dstat.st_blocks >> 1));
+                column += printf("%6"OFF_FMT"u ", (off_t) (dn->dn_blocks >> 1));
 #endif
-        if (all_fmt & LIST_MODEBITS)
-                column += printf("%-10s ", (char *) bb_mode_string(dn->dstat.st_mode));
-        if (all_fmt & LIST_NLINKS)
-                column += printf("%4lu ", (long) dn->dstat.st_nlink);
-        if (all_fmt & LIST_ID_NUMERIC) {
+        if (G.all_fmt & LIST_MODEBITS)
+                column += printf("%-10s ", (char *) bb_mode_string(dn->dn_mode));
+        if (G.all_fmt & LIST_NLINKS)
+                column += printf("%4lu ", (long) dn->dn_nlink);
+        if (G.all_fmt & LIST_ID_NUMERIC) {
                 if (option_mask32 & OPT_g)
-                        column += printf("%-8u ", (int) dn->dstat.st_gid);
+                        column += printf("%-8u ", (int) dn->dn_gid);
                 else
                         column += printf("%-8u %-8u ",
-                                        (int) dn->dstat.st_uid,
-                                        (int) dn->dstat.st_gid);
+                                        (int) dn->dn_uid,
+                                        (int) dn->dn_gid);
         }
 #if ENABLE_FEATURE_LS_USERNAME
-        else if (all_fmt & LIST_ID_NAME) {
+        else if (G.all_fmt & LIST_ID_NAME) {
                 if (option_mask32 & OPT_g) {
                         column += printf("%-8.8s ",
-                                get_cached_groupname(dn->dstat.st_gid));
+                                get_cached_groupname(dn->dn_gid));
                 } else {
                         column += printf("%-8.8s %-8.8s ",
-                                get_cached_username(dn->dstat.st_uid),
-                                get_cached_groupname(dn->dstat.st_gid));
+                                get_cached_username(dn->dn_uid),
+                                get_cached_groupname(dn->dn_gid));
                 }
         }
 #endif
-        if (all_fmt & LIST_SIZE) {
-                if (S_ISBLK(dn->dstat.st_mode) || S_ISCHR(dn->dstat.st_mode)) {
+        if (G.all_fmt & LIST_SIZE) {
+                if (S_ISBLK(dn->dn_mode) || S_ISCHR(dn->dn_mode)) {
                         column += printf("%4u, %3u ",
-                                        (int) major(dn->dstat.st_rdev),
-                                        (int) minor(dn->dstat.st_rdev));
+                                        dn->dn_rdev_maj,
+                                        dn->dn_rdev_min);
                 } else {
                         if (option_mask32 & OPT_h) {
                                 column += printf("%"HUMAN_READABLE_MAX_WIDTH_STR"s ",
-                                        /* print st_size, show one fractional, use suffixes */
-                                        make_human_readable_str(dn->dstat.st_size, 1, 0)
+                                        /* print size, show one fractional, use suffixes */
+                                        make_human_readable_str(dn->dn_size, 1, 0)
                                 );
                         } else {
-                                column += printf("%9"OFF_FMT"u ", (off_t) dn->dstat.st_size);
+                                column += printf("%9"OFF_FMT"u ", dn->dn_size);
                         }
                 }
         }
 #if ENABLE_FEATURE_LS_TIMESTAMPS
-        if (all_fmt & (LIST_FULLTIME|LIST_DATE_TIME)) {
+        if (G.all_fmt & (LIST_FULLTIME|LIST_DATE_TIME)) {
                 char *filetime;
-                time_t ttime = dn->dstat.st_mtime;
-                if (all_fmt & TIME_ACCESS)
-                        ttime = dn->dstat.st_atime;
-                if (all_fmt & TIME_CHANGE)
-                        ttime = dn->dstat.st_ctime;
+                time_t ttime = dn->dn_mtime;
+                if (G.all_fmt & TIME_ACCESS)
+                        ttime = dn->dn_atime;
+                if (G.all_fmt & TIME_CHANGE)
+                        ttime = dn->dn_ctime;
                 filetime = ctime(&ttime);
                 /* filetime's format: "Wed Jun 30 21:49:08 1993\n" */
-                if (all_fmt & LIST_FULLTIME) { /* -e */
+                if (G.all_fmt & LIST_FULLTIME) { /* -e */
                         /* Note: coreutils 8.4 ls --full-time prints:
                          * 2009-07-13 17:49:27.000000000 +0200
                          */
                         column += printf("%.24s ", filetime);
                 } else { /* LIST_DATE_TIME */
-                        /* current_time_t ~== time(NULL) */
-                        time_t age = current_time_t - ttime;
+                        /* G.current_time_t ~== time(NULL) */
+                        time_t age = G.current_time_t - ttime;
                         printf("%.6s ", filetime + 4); /* "Jun 30" */
                         if (age < 3600L * 24 * 365 / 2 && age > -15 * 60) {
                                 /* hh:mm if less than 6 months old */
@@ -760,51 +602,52 @@ static NOINLINE unsigned list_single(const struct dnode *dn)
         }
 #endif
 #if ENABLE_SELINUX
-        if (all_fmt & LIST_CONTEXT) {
+        if (G.all_fmt & LIST_CONTEXT) {
                 column += printf("%-32s ", dn->sid ? dn->sid : "unknown");
                 freecon(dn->sid);
         }
 #endif
 
 #if ENABLE_FEATURE_LS_COLOR
-        if (show_color) {
-                info.st_mode = 0; /* for fgcolor() */
-                lstat(dn->fullname, &info);
-                printf("\033[%u;%um", bold(info.st_mode),
-                        fgcolor(info.st_mode));
+        if (G_show_color) {
+                mode_t mode = dn->dn_mode_lstat;
+                if (!mode)
+                        if (lstat(dn->fullname, &statbuf) == 0)
+                                mode = statbuf.st_mode;
+                printf("\033[%u;%um", bold(mode), fgcolor(mode));
         }
 #endif
         column += print_name(dn->name);
-        if (show_color) {
+        if (G_show_color) {
                 printf("\033[0m");
         }
 
-        if (all_fmt & LIST_SYMLINK) {
-                if (S_ISLNK(dn->dstat.st_mode) && lpath) {
-                        printf(" -> ");
+        if (lpath) {
+                printf(" -> ");
 #if ENABLE_FEATURE_LS_FILETYPES || ENABLE_FEATURE_LS_COLOR
-#if ENABLE_FEATURE_LS_COLOR
-                        info.st_mode = 0; /* for fgcolor() */
-#endif
-                        if (stat(dn->fullname, &info) == 0) {
-                                append = append_char(info.st_mode);
-                        }
-#endif
-#if ENABLE_FEATURE_LS_COLOR
-                        if (show_color) {
-                                printf("\033[%u;%um", bold(info.st_mode),
-                                           fgcolor(info.st_mode));
+                if ((G.all_fmt & LIST_FILETYPE) || G_show_color) {
+                        mode_t mode = dn->dn_mode_stat;
+                        if (!mode)
+                                if (stat(dn->fullname, &statbuf) == 0)
+                                        mode = statbuf.st_mode;
+# if ENABLE_FEATURE_LS_FILETYPES
+                        append = append_char(mode);
+# endif
+# if ENABLE_FEATURE_LS_COLOR
+                        if (G_show_color) {
+                                printf("\033[%u;%um", bold(mode), fgcolor(mode));
                         }
+# endif
+                }
 #endif
-                        column += print_name(lpath) + 4;
-                        if (show_color) {
-                                printf("\033[0m");
-                        }
-                        free(lpath);
+                column += print_name(lpath) + 4;
+                free(lpath);
+                if (G_show_color) {
+                        printf("\033[0m");
                 }
         }
 #if ENABLE_FEATURE_LS_FILETYPES
-        if (all_fmt & LIST_FILETYPE) {
+        if (G.all_fmt & LIST_FILETYPE) {
                 if (append) {
                         putchar(append);
                         column++;
@@ -815,14 +658,14 @@ static NOINLINE unsigned list_single(const struct dnode *dn)
         return column;
 }
 
-static void showfiles(struct dnode **dn, unsigned nfiles)
+static void display_files(struct dnode **dn, unsigned nfiles)
 {
         unsigned i, ncols, nrows, row, nc;
         unsigned column;
         unsigned nexttab;
         unsigned column_width = 0; /* used only by STYLE_COLUMNAR */
 
-        if (all_fmt & STYLE_LONG) { /* STYLE_LONG or STYLE_SINGLE */
+        if (G.all_fmt & STYLE_LONG) { /* STYLE_LONG or STYLE_SINGLE */
                 ncols = 1;
         } else {
                 /* find the longest file name, use that as the column width */
@@ -832,10 +675,10 @@ static void showfiles(struct dnode **dn, unsigned nfiles)
                                 column_width = len;
                 }
                 column_width += 1 +
-                        IF_SELINUX( ((all_fmt & LIST_CONTEXT) ? 33 : 0) + )
-                                ((all_fmt & LIST_INO) ? 8 : 0) +
-                                ((all_fmt & LIST_BLOCKS) ? 5 : 0);
-                ncols = (int) (terminal_width / column_width);
+                        IF_SELINUX( ((G.all_fmt & LIST_CONTEXT) ? 33 : 0) + )
+                                ((G.all_fmt & LIST_INO) ? 8 : 0) +
+                                ((G.all_fmt & LIST_BLOCKS) ? 5 : 0);
+                ncols = (unsigned)G_terminal_width / column_width;
         }
 
         if (ncols > 1) {
@@ -852,7 +695,7 @@ static void showfiles(struct dnode **dn, unsigned nfiles)
         for (row = 0; row < nrows; row++) {
                 for (nc = 0; nc < ncols; nc++) {
                         /* reach into the array based on the column and row */
-                        if (all_fmt & DISP_ROWS)
+                        if (G.all_fmt & DISP_ROWS)
                                 i = (row * ncols) + nc; /* display across row */
                         else
                                 i = (nc * nrows) + row; /* display by column */
@@ -863,7 +706,7 @@ static void showfiles(struct dnode **dn, unsigned nfiles)
                                         column += nexttab + 1;
                                 }
                                 nexttab = column + column_width;
-                                column += list_single(dn[i]);
+                                column += display_single(dn[i]);
                         }
                 }
                 putchar('\n');
@@ -872,102 +715,233 @@ static void showfiles(struct dnode **dn, unsigned nfiles)
 }
 
 
-#if !ENABLE_PLATFORM_MINGW32
-#if ENABLE_DESKTOP
-/* http://www.opengroup.org/onlinepubs/9699919799/utilities/ls.html
- * If any of the -l, -n, -s options is specified, each list
- * of files within the directory shall be preceded by a
- * status line indicating the number of file system blocks
- * occupied by files in the directory in 512-byte units if
- * the -k option is not specified, or 1024-byte units if the
- * -k option is specified, rounded up to the next integral
- * number of units.
- */
-/* by Jorgen Overgaard (jorgen AT antistaten.se) */
-static off_t calculate_blocks(struct dnode **dn)
+/*** Dir scanning code ***/
+
+static struct dnode *my_stat(const char *fullname, const char *name, int force_follow)
 {
-        uoff_t blocks = 1;
-        if (dn) {
-                while (*dn) {
-                        /* st_blocks is in 512 byte blocks */
-                        blocks += (*dn)->dstat.st_blocks;
-                        dn++;
+        struct stat statbuf;
+        struct dnode *cur;
+
+        cur = xzalloc(sizeof(*cur));
+        cur->fullname = fullname;
+        cur->name = name;
+
+        if ((option_mask32 & OPT_L) || force_follow) {
+#if ENABLE_SELINUX
+                if (is_selinux_enabled())  {
+                         getfilecon(fullname, &cur->sid);
+                }
+#endif
+                if (stat(fullname, &statbuf)) {
+                        bb_simple_perror_msg(fullname);
+                        G.exit_code = EXIT_FAILURE;
+                        free(cur);
+                        return NULL;
+                }
+                cur->dn_mode_stat = statbuf.st_mode;
+        } else {
+#if ENABLE_SELINUX
+                if (is_selinux_enabled()) {
+                        lgetfilecon(fullname, &cur->sid);
+                }
+#endif
+                if (lstat(fullname, &statbuf)) {
+                        bb_simple_perror_msg(fullname);
+                        G.exit_code = EXIT_FAILURE;
+                        free(cur);
+                        return NULL;
                 }
+                cur->dn_mode_lstat = statbuf.st_mode;
         }
 
-        /* Even though standard says use 512 byte blocks, coreutils use 1k */
-        /* Actually, we round up by calculating (blocks + 1) / 2,
-         * "+ 1" was done when we initialized blocks to 1 */
-        return blocks >> 1;
-}
+        /* cur->dstat = statbuf: */
+        cur->dn_mode   = statbuf.st_mode  ;
+        cur->dn_size   = statbuf.st_size  ;
+#if ENABLE_FEATURE_LS_TIMESTAMPS || ENABLE_FEATURE_LS_SORTFILES
+        cur->dn_atime  = statbuf.st_atime ;
+        cur->dn_mtime  = statbuf.st_mtime ;
+        cur->dn_ctime  = statbuf.st_ctime ;
 #endif
+        cur->dn_ino    = statbuf.st_ino   ;
+#if !ENABLE_PLATFORM_MINGW32
+        cur->dn_blocks = statbuf.st_blocks;
 #endif
+        cur->dn_nlink  = statbuf.st_nlink ;
+        cur->dn_uid    = statbuf.st_uid   ;
+        cur->dn_gid    = statbuf.st_gid   ;
+        cur->dn_rdev_maj = major(statbuf.st_rdev);
+        cur->dn_rdev_min = minor(statbuf.st_rdev);
 
+        return cur;
+}
 
-static struct dnode **list_dir(const char *, unsigned *);
-
-static void showdirs(struct dnode **dn, int first)
+static unsigned count_dirs(struct dnode **dn, int which)
 {
-        unsigned nfiles;
-        unsigned dndirs;
-        struct dnode **subdnp;
-        struct dnode **dnd;
+        unsigned dirs, all;
 
+        if (!dn)
+                return 0;
+
+        dirs = all = 0;
         for (; *dn; dn++) {
-                if (all_fmt & (DISP_DIRNAME | DISP_RECURSIVE)) {
-                        if (!first)
-                                bb_putchar('\n');
-                        first = 0;
-                        printf("%s:\n", (*dn)->fullname);
+                const char *name;
+
+                all++;
+                if (!S_ISDIR((*dn)->dn_mode))
+                        continue;
+
+                name = (*dn)->name;
+                if (which != SPLIT_SUBDIR /* if not requested to skip . / .. */
+                 /* or if it's not . or .. */
+                 || name[0] != '.'
+                 || (name[1] && (name[1] != '.' || name[2]))
+                ) {
+                        dirs++;
                 }
-                subdnp = list_dir((*dn)->fullname, &nfiles);
-#if !ENABLE_PLATFORM_MINGW32
-#if ENABLE_DESKTOP
-                if ((all_fmt & STYLE_MASK) == STYLE_LONG)
-                        printf("total %"OFF_FMT"u\n", calculate_blocks(subdnp));
-#endif
+        }
+        return which != SPLIT_FILE ? dirs : all - dirs;
+}
+
+/* get memory to hold an array of pointers */
+static struct dnode **dnalloc(unsigned num)
+{
+        if (num < 1)
+                return NULL;
+
+        num++; /* so that we have terminating NULL */
+        return xzalloc(num * sizeof(struct dnode *));
+}
+
+#if ENABLE_FEATURE_LS_RECURSIVE
+static void dfree(struct dnode **dnp)
+{
+        unsigned i;
+
+        if (dnp == NULL)
+                return;
+
+        for (i = 0; dnp[i]; i++) {
+                struct dnode *cur = dnp[i];
+                if (cur->fname_allocated)
+                        free((char*)cur->fullname);
+                free(cur);
+        }
+        free(dnp);
+}
+#else
+#define dfree(...) ((void)0)
 #endif
-                if (nfiles > 0) {
-                        /* list all files at this level */
-                        dnsort(subdnp, nfiles);
-                        showfiles(subdnp, nfiles);
-                        if (ENABLE_FEATURE_LS_RECURSIVE
-                         && (all_fmt & DISP_RECURSIVE)
+
+/* Returns NULL-terminated malloced vector of pointers (or NULL) */
+static struct dnode **splitdnarray(struct dnode **dn, int which)
+{
+        unsigned dncnt, d;
+        struct dnode **dnp;
+
+        if (dn == NULL)
+                return NULL;
+
+        /* count how many dirs or files there are */
+        dncnt = count_dirs(dn, which);
+
+        /* allocate a file array and a dir array */
+        dnp = dnalloc(dncnt);
+
+        /* copy the entrys into the file or dir array */
+        for (d = 0; *dn; dn++) {
+                if (S_ISDIR((*dn)->dn_mode)) {
+                        const char *name;
+
+                        if (which == SPLIT_FILE)
+                                continue;
+
+                        name = (*dn)->name;
+                        if ((which & SPLIT_DIR) /* any dir... */
+                        /* ... or not . or .. */
+                         || name[0] != '.'
+                         || (name[1] && (name[1] != '.' || name[2]))
                         ) {
-                                /* recursive - list the sub-dirs */
-                                dnd = splitdnarray(subdnp, SPLIT_SUBDIR);
-                                dndirs = count_dirs(subdnp, SPLIT_SUBDIR);
-                                if (dndirs > 0) {
-                                        dnsort(dnd, dndirs);
-                                        showdirs(dnd, 0);
-                                        /* free the array of dnode pointers to the dirs */
-                                        free(dnd);
-                                }
+                                dnp[d++] = *dn;
                         }
-                        /* free the dnodes and the fullname mem */
-                        dfree(subdnp);
+                } else
+                if (which == SPLIT_FILE) {
+                        dnp[d++] = *dn;
                 }
         }
+        return dnp;
 }
 
+#if ENABLE_FEATURE_LS_SORTFILES
+static int sortcmp(const void *a, const void *b)
+{
+        struct dnode *d1 = *(struct dnode **)a;
+        struct dnode *d2 = *(struct dnode **)b;
+        unsigned sort_opts = G.all_fmt & SORT_MASK;
+        off_t dif;
+
+        dif = 0; /* assume SORT_NAME */
+        // TODO: use pre-initialized function pointer
+        // instead of branch forest
+        if (sort_opts == SORT_SIZE) {
+                dif = (d2->dn_size - d1->dn_size);
+        } else if (sort_opts == SORT_ATIME) {
+                dif = (d2->dn_atime - d1->dn_atime);
+        } else if (sort_opts == SORT_CTIME) {
+                dif = (d2->dn_ctime - d1->dn_ctime);
+        } else if (sort_opts == SORT_MTIME) {
+                dif = (d2->dn_mtime - d1->dn_mtime);
+        } else if (sort_opts == SORT_DIR) {
+                dif = S_ISDIR(d2->dn_mode) - S_ISDIR(d1->dn_mode);
+                /* } else if (sort_opts == SORT_VERSION) { */
+                /* } else if (sort_opts == SORT_EXT) { */
+        }
+        if (dif == 0) {
+                /* sort by name, or tie_breaker for other sorts */
+                if (ENABLE_LOCALE_SUPPORT)
+                        dif = strcoll(d1->name, d2->name);
+                else
+                        dif = strcmp(d1->name, d2->name);
+        }
+
+        /* Make dif fit into an int */
+        if (sizeof(dif) > sizeof(int)) {
+                enum { BITS_TO_SHIFT = 8 * (sizeof(dif) - sizeof(int)) };
+                /* shift leaving only "int" worth of bits */
+                if (dif != 0) {
+                        dif = 1 | (int)((uoff_t)dif >> BITS_TO_SHIFT);
+                }
+        }
+
+        return (G.all_fmt & SORT_REVERSE) ? -(int)dif : (int)dif;
+}
+
+static void dnsort(struct dnode **dn, int size)
+{
+        qsort(dn, size, sizeof(*dn), sortcmp);
+}
+
+static void sort_and_display_files(struct dnode **dn, unsigned nfiles)
+{
+        dnsort(dn, nfiles);
+        display_files(dn, nfiles);
+}
+#else
+# define dnsort(dn, size) ((void)0)
+# define sort_and_display_files(dn, nfiles) display_files(dn, nfiles)
+#endif
 
 /* Returns NULL-terminated malloced vector of pointers (or NULL) */
-static struct dnode **list_dir(const char *path, unsigned *nfiles_p)
+static struct dnode **scan_one_dir(const char *path, unsigned *nfiles_p)
 {
         struct dnode *dn, *cur, **dnp;
         struct dirent *entry;
         DIR *dir;
         unsigned i, nfiles;
 
-        /* Never happens:
-        if (path == NULL)
-                return NULL;
-        */
-
         *nfiles_p = 0;
         dir = warn_opendir(path);
         if (dir == NULL) {
-                exit_code = EXIT_FAILURE;
+                G.exit_code = EXIT_FAILURE;
                 return NULL;    /* could not open the dir */
         }
         dn = NULL;
@@ -978,11 +952,11 @@ static struct dnode **list_dir(const char *path, unsigned *nfiles_p)
                 /* are we going to list the file- it may be . or .. or a hidden file */
                 if (entry->d_name[0] == '.') {
                         if ((!entry->d_name[1] || (entry->d_name[1] == '.' && !entry->d_name[2]))
-                         && !(all_fmt & DISP_DOT)
+                         && !(G.all_fmt & DISP_DOT)
                         ) {
                                 continue;
                         }
-                        if (!(all_fmt & DISP_HIDDEN))
+                        if (!(G.all_fmt & DISP_HIDDEN))
                                 continue;
                 }
                 fullname = concat_path_file(path, entry->d_name);
@@ -992,7 +966,7 @@ static struct dnode **list_dir(const char *path, unsigned *nfiles_p)
                         continue;
                 }
                 cur->fname_allocated = 1;
-                cur->next = dn;
+                cur->dn_next = dn;
                 dn = cur;
                 nfiles++;
         }
@@ -1008,7 +982,7 @@ static struct dnode **list_dir(const char *path, unsigned *nfiles_p)
         dnp = dnalloc(nfiles);
         for (i = 0; /* i < nfiles - detected via !dn below */; i++) {
                 dnp[i] = dn;    /* save pointer to node in array */
-                dn = dn->next;
+                dn = dn->dn_next;
                 if (!dn)
                         break;
         }
@@ -1016,6 +990,77 @@ static struct dnode **list_dir(const char *path, unsigned *nfiles_p)
         return dnp;
 }
 
+#if ENABLE_DESKTOP && !ENABLE_PLATFORM_MINGW32
+/* http://www.opengroup.org/onlinepubs/9699919799/utilities/ls.html
+ * If any of the -l, -n, -s options is specified, each list
+ * of files within the directory shall be preceded by a
+ * status line indicating the number of file system blocks
+ * occupied by files in the directory in 512-byte units if
+ * the -k option is not specified, or 1024-byte units if the
+ * -k option is specified, rounded up to the next integral
+ * number of units.
+ */
+/* by Jorgen Overgaard (jorgen AT antistaten.se) */
+static off_t calculate_blocks(struct dnode **dn)
+{
+        uoff_t blocks = 1;
+        if (dn) {
+                while (*dn) {
+                        /* st_blocks is in 512 byte blocks */
+                        blocks += (*dn)->dn_blocks;
+                        dn++;
+                }
+        }
+
+        /* Even though standard says use 512 byte blocks, coreutils use 1k */
+        /* Actually, we round up by calculating (blocks + 1) / 2,
+         * "+ 1" was done when we initialized blocks to 1 */
+        return blocks >> 1;
+}
+#endif
+
+static void scan_and_display_dirs_recur(struct dnode **dn, int first)
+{
+        unsigned nfiles;
+        struct dnode **subdnp;
+
+        for (; *dn; dn++) {
+                if (G.all_fmt & (DISP_DIRNAME | DISP_RECURSIVE)) {
+                        if (!first)
+                                bb_putchar('\n');
+                        first = 0;
+                        printf("%s:\n", (*dn)->fullname);
+                }
+                subdnp = scan_one_dir((*dn)->fullname, &nfiles);
+#if ENABLE_DESKTOP && !ENABLE_PLATFORM_MINGW32
+                if ((G.all_fmt & STYLE_MASK) == STYLE_LONG)
+                        printf("total %"OFF_FMT"u\n", calculate_blocks(subdnp));
+#endif
+                if (nfiles > 0) {
+                        /* list all files at this level */
+                        sort_and_display_files(subdnp, nfiles);
+
+                        if (ENABLE_FEATURE_LS_RECURSIVE
+                         && (G.all_fmt & DISP_RECURSIVE)
+                        ) {
+                                struct dnode **dnd;
+                                unsigned dndirs;
+                                /* recursive - list the sub-dirs */
+                                dnd = splitdnarray(subdnp, SPLIT_SUBDIR);
+                                dndirs = count_dirs(subdnp, SPLIT_SUBDIR);
+                                if (dndirs > 0) {
+                                        dnsort(dnd, dndirs);
+                                        scan_and_display_dirs_recur(dnd, 0);
+                                        /* free the array of dnode pointers to the dirs */
+                                        free(dnd);
+                                }
+                        }
+                        /* free the dnodes and the fullname mem */
+                        dfree(subdnp);
+                }
+        }
+}
+
 
 int ls_main(int argc UNUSED_PARAM, char **argv)
 {
@@ -1054,13 +1099,13 @@ int ls_main(int argc UNUSED_PARAM, char **argv)
         init_unicode();
 
         if (ENABLE_FEATURE_LS_SORTFILES)
-                all_fmt = SORT_NAME;
+                G.all_fmt = SORT_NAME;
 
 #if ENABLE_FEATURE_AUTOWIDTH
         /* obtain the terminal width */
-        get_terminal_width_height(STDIN_FILENO, &terminal_width, NULL);
+        get_terminal_width_height(STDIN_FILENO, &G_terminal_width, NULL);
         /* go one less... */
-        terminal_width--;
+        G_terminal_width--;
 #endif
 
         /* process options */
@@ -1081,7 +1126,7 @@ int ls_main(int argc UNUSED_PARAM, char **argv)
                 /* -w NUM: */
                 IF_FEATURE_AUTOWIDTH(":w+");
         opt = getopt32(argv, ls_options
-                IF_FEATURE_AUTOWIDTH(, NULL, &terminal_width)
+                IF_FEATURE_AUTOWIDTH(, NULL, &G_terminal_width)
                 IF_FEATURE_LS_COLOR(, &color_opt)
         );
         for (i = 0; opt_flags[i] != (1U << 31); i++) {
@@ -1089,27 +1134,27 @@ int ls_main(int argc UNUSED_PARAM, char **argv)
                         uint32_t flags = opt_flags[i];
 
                         if (flags & STYLE_MASK)
-                                all_fmt &= ~STYLE_MASK;
+                                G.all_fmt &= ~STYLE_MASK;
                         if (flags & SORT_MASK)
-                                all_fmt &= ~SORT_MASK;
+                                G.all_fmt &= ~SORT_MASK;
                         if (flags & TIME_MASK)
-                                all_fmt &= ~TIME_MASK;
+                                G.all_fmt &= ~TIME_MASK;
 
-                        all_fmt |= flags;
+                        G.all_fmt |= flags;
                 }
         }
 
 #if ENABLE_FEATURE_LS_COLOR
-        /* set show_color = 1/0 */
+        /* set G_show_color = 1/0 */
         if (ENABLE_FEATURE_LS_COLOR_IS_DEFAULT && isatty(STDOUT_FILENO)) {
                 char *p = getenv("LS_COLORS");
                 /* LS_COLORS is unset, or (not empty && not "none") ? */
                 if (!p || (p[0] && strcmp(p, "none") != 0))
-                        show_color = 1;
+                        G_show_color = 1;
         }
         if (opt & OPT_color) {
                 if (color_opt[0] == 'n')
-                        show_color = 0;
+                        G_show_color = 0;
                 else switch (index_in_substrings(color_str, color_opt)) {
                 case 3:
                 case 4:
@@ -1118,34 +1163,34 @@ int ls_main(int argc UNUSED_PARAM, char **argv)
                 case 0:
                 case 1:
                 case 2:
-                                show_color = 1;
+                                G_show_color = 1;
                         }
                 }
         }
 #endif
 
         /* sort out which command line options take precedence */
-        if (ENABLE_FEATURE_LS_RECURSIVE && (all_fmt & DISP_NOLIST))
-                all_fmt &= ~DISP_RECURSIVE;     /* no recurse if listing only dir */
+        if (ENABLE_FEATURE_LS_RECURSIVE && (G.all_fmt & DISP_NOLIST))
+                G.all_fmt &= ~DISP_RECURSIVE;   /* no recurse if listing only dir */
         if (ENABLE_FEATURE_LS_TIMESTAMPS && ENABLE_FEATURE_LS_SORTFILES) {
-                if (all_fmt & TIME_CHANGE)
-                        all_fmt = (all_fmt & ~SORT_MASK) | SORT_CTIME;
-                if (all_fmt & TIME_ACCESS)
-                        all_fmt = (all_fmt & ~SORT_MASK) | SORT_ATIME;
+                if (G.all_fmt & TIME_CHANGE)
+                        G.all_fmt = (G.all_fmt & ~SORT_MASK) | SORT_CTIME;
+                if (G.all_fmt & TIME_ACCESS)
+                        G.all_fmt = (G.all_fmt & ~SORT_MASK) | SORT_ATIME;
         }
-        if ((all_fmt & STYLE_MASK) != STYLE_LONG) /* not -l? */
-                all_fmt &= ~(LIST_ID_NUMERIC|LIST_ID_NAME|LIST_FULLTIME);
+        if ((G.all_fmt & STYLE_MASK) != STYLE_LONG) /* not -l? */
+                G.all_fmt &= ~(LIST_ID_NUMERIC|LIST_ID_NAME|LIST_FULLTIME);
 
         /* choose a display format if one was not already specified by an option */
-        if (!(all_fmt & STYLE_MASK))
-                all_fmt |= (isatty(STDOUT_FILENO) ? STYLE_COLUMNAR : STYLE_SINGLE);
+        if (!(G.all_fmt & STYLE_MASK))
+                G.all_fmt |= (isatty(STDOUT_FILENO) ? STYLE_COLUMNAR : STYLE_SINGLE);
 
         argv += optind;
         if (!argv[0])
                 *--argv = (char*)".";
 
         if (argv[1])
-                all_fmt |= DISP_DIRNAME; /* 2 or more items? label directories */
+                G.all_fmt |= DISP_DIRNAME; /* 2 or more items? label directories */
 
         /* stuff the command line file names into a dnode array */
         dn = NULL;
@@ -1153,25 +1198,26 @@ int ls_main(int argc UNUSED_PARAM, char **argv)
         do {
                 cur = my_stat(*argv, *argv,
                         /* follow links on command line unless -l, -s or -F: */
-                        !((all_fmt & STYLE_MASK) == STYLE_LONG
-                          || (all_fmt & LIST_BLOCKS)
+                        !((G.all_fmt & STYLE_MASK) == STYLE_LONG
+                          || (G.all_fmt & LIST_BLOCKS)
                           || (option_mask32 & OPT_F)
                         )
                         /* ... or if -H: */
                         || (option_mask32 & OPT_H)
+                        /* ... or if -L, but my_stat always follows links if -L */
                 );
                 argv++;
                 if (!cur)
                         continue;
-                cur->fname_allocated = 0;
-                cur->next = dn;
+                /*cur->fname_allocated = 0; - already is */
+                cur->dn_next = dn;
                 dn = cur;
                 nfiles++;
         } while (*argv);
 
         /* nfiles _may_ be 0 here - try "ls doesnt_exist" */
         if (nfiles == 0)
-                return exit_code;
+                return G.exit_code;
 
         /* now that we know how many files there are
          * allocate memory for an array to hold dnode pointers
@@ -1179,33 +1225,32 @@ int ls_main(int argc UNUSED_PARAM, char **argv)
         dnp = dnalloc(nfiles);
         for (i = 0; /* i < nfiles - detected via !dn below */; i++) {
                 dnp[i] = dn;    /* save pointer to node in array */
-                dn = dn->next;
+                dn = dn->dn_next;
                 if (!dn)
                         break;
         }
 
-        if (all_fmt & DISP_NOLIST) {
-                dnsort(dnp, nfiles);
-                showfiles(dnp, nfiles);
+        if (G.all_fmt & DISP_NOLIST) {
+                sort_and_display_files(dnp, nfiles);
         } else {
                 dnd = splitdnarray(dnp, SPLIT_DIR);
                 dnf = splitdnarray(dnp, SPLIT_FILE);
                 dndirs = count_dirs(dnp, SPLIT_DIR);
                 dnfiles = nfiles - dndirs;
                 if (dnfiles > 0) {
-                        dnsort(dnf, dnfiles);
-                        showfiles(dnf, dnfiles);
+                        sort_and_display_files(dnf, dnfiles);
                         if (ENABLE_FEATURE_CLEAN_UP)
                                 free(dnf);
                 }
                 if (dndirs > 0) {
                         dnsort(dnd, dndirs);
-                        showdirs(dnd, dnfiles == 0);
+                        scan_and_display_dirs_recur(dnd, dnfiles == 0);
                         if (ENABLE_FEATURE_CLEAN_UP)
                                 free(dnd);
                 }
         }
+
         if (ENABLE_FEATURE_CLEAN_UP)
                 dfree(dnp);
-        return exit_code;
+        return G.exit_code;
 }
diff --git a/coreutils/od.c b/coreutils/od.c
index 31ebde210..fb11fcfe3 100644
--- a/coreutils/od.c
+++ b/coreutils/od.c
@@ -11,11 +11,12 @@
  * Original copyright notice is retained at the end of this file.
  */
 
+//usage:#if !ENABLE_DESKTOP
 //usage:#define od_trivial_usage
-//usage:       "[-aBbcDdeFfHhIiLlOovXx] " IF_DESKTOP("[-t TYPE] ") "[FILE]"
+//usage:       "[-aBbcDdeFfHhIiLlOovXx] [FILE]"
 //usage:#define od_full_usage "\n\n"
-//usage:       "Write an unambiguous representation, octal bytes by default, of FILE\n"
-//usage:       "(or stdin) to stdout"
+//usage:       "Print FILE (or stdin) unambiguously, as octal bytes by default"
+//usage:#endif
 
 #include "libbb.h"
 #if ENABLE_DESKTOP
diff --git a/coreutils/od_bloaty.c b/coreutils/od_bloaty.c
index 4c6b64d5e..8013f483c 100644
--- a/coreutils/od_bloaty.c
+++ b/coreutils/od_bloaty.c
@@ -13,48 +13,64 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software Foundation,
-   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
-
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
 /* Written by Jim Meyering.  */
+/* Busyboxed by Denys Vlasenko, based on od.c from coreutils-5.2.1 */
 
-/* Busyboxed by Denys Vlasenko
-
-Based on od.c from coreutils-5.2.1
-Top bloat sources:
 
-00000073 t parse_old_offset
-0000007b t get_lcm
-00000090 r long_options
-00000092 t print_named_ascii
-000000bf t print_ascii
-00000168 t write_block
-00000366 t decode_format_string
-00000a71 T od_main
-
-Tested for compat with coreutils 6.3
-using this script. Minor differences fixed.
+/* #include "libbb.h" - done in od.c */
+#define assert(a) ((void)0)
 
-#!/bin/sh
-echo STD
-time /path/to/coreutils/od \
-...params... \
->std
-echo Exit code $?
-echo BBOX
-time ./busybox od \
-...params... \
->bbox
-echo Exit code $?
-diff -u -a std bbox >bbox.diff || { echo Different!; sleep 1; }
 
-*/
+//usage:#if ENABLE_DESKTOP
+//usage:#define od_trivial_usage
+//usage:       "[-abcdfhilovxs] [-t TYPE] [-A RADIX] [-N SIZE] [-j SKIP] [-S MINSTR] [-w WIDTH] [FILE...]"
+// We don't support:
+// ... [FILE] [[+]OFFSET[.][b]]
+// Support is buggy for:
+// od --traditional [OPTION]... [FILE] [[+]OFFSET[.][b] [+][LABEL][.][b]]
+
+//usage:#define od_full_usage "\n\n"
+//usage:       "Print FILEs (or stdin) unambiguously, as octal bytes by default"
+//usage:#endif
+
+enum {
+        OPT_A = 1 << 0,
+        OPT_N = 1 << 1,
+        OPT_a = 1 << 2,
+        OPT_b = 1 << 3,
+        OPT_c = 1 << 4,
+        OPT_d = 1 << 5,
+        OPT_f = 1 << 6,
+        OPT_h = 1 << 7,
+        OPT_i = 1 << 8,
+        OPT_j = 1 << 9,
+        OPT_l = 1 << 10,
+        OPT_o = 1 << 11,
+        OPT_t = 1 << 12,
+        /* When zero and two or more consecutive blocks are equal, format
+           only the first block and output an asterisk alone on the following
+           line to indicate that identical blocks have been elided: */
+        OPT_v = 1 << 13,
+        OPT_x = 1 << 14,
+        OPT_s = 1 << 15,
+        OPT_S = 1 << 16,
+        OPT_w = 1 << 17,
+        OPT_traditional = (1 << 18) * ENABLE_LONG_OPTS,
+};
 
-#include "libbb.h"
+#define OD_GETOPT32() getopt32(argv, \
+        "A:N:abcdfhij:lot:vxsS:w::", \
+        /* -w with optional param */ \
+        /* -S was -s and also had optional parameter */ \
+        /* but in coreutils 6.3 it was renamed and now has */ \
+        /* _mandatory_ parameter */ \
+        &str_A, &str_N, &str_j, &lst_t, &str_S, &bytes_per_block)
 
-#define assert(a) ((void)0)
 
 /* Check for 0x7f is a coreutils 6.3 addition */
-#define ISPRINT(c) (((c)>=' ') && (c) != 0x7f)
+#define ISPRINT(c) (((c) >= ' ') && (c) < 0x7f)
 
 typedef long double longdouble_t;
 typedef unsigned long long ulonglong_t;
@@ -165,17 +181,9 @@ struct ERR_width_bytes_has_bad_size {
         char ERR_width_bytes_has_bad_size[ARRAY_SIZE(width_bytes) == N_SIZE_SPECS ? 1 : -1];
 };
 
-static smallint flag_dump_strings;
-/* Non-zero if an old-style 'pseudo-address' was specified.  */
-static smallint flag_pseudo_start;
-static smallint limit_bytes_to_format;
-/* When zero and two or more consecutive blocks are equal, format
-   only the first block and output an asterisk alone on the following
-   line to indicate that identical blocks have been elided.  */
-static smallint verbose;
-static smallint ioerror;
+static smallint exit_code;
 
-static size_t string_min;
+static unsigned string_min;
 
 /* An array of specs describing how to format each input block.  */
 static size_t n_specs;
@@ -186,7 +194,11 @@ static struct tspec *spec;
 static void (*format_address)(off_t, char);
 /* The difference between the old-style pseudo starting address and
    the number of bytes to skip.  */
+#if ENABLE_LONG_OPTS
 static off_t pseudo_offset;
+#else
+enum { pseudo_offset = 0 };
+#endif
 /* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
    input is formatted.  */
 
@@ -221,7 +233,7 @@ static const unsigned char integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1] ALIGN1
 
 #define MAX_FP_TYPE_SIZE sizeof(longdouble_t)
 static const unsigned char fp_type_size[MAX_FP_TYPE_SIZE + 1] ALIGN1 = {
-        /* gcc seems to allow repeated indexes. Last one stays */
+        /* gcc seems to allow repeated indexes. Last one wins */
         [sizeof(longdouble_t)] = FLOAT_LONG_DOUBLE,
         [sizeof(double)] = FLOAT_DOUBLE,
         [sizeof(float)] = FLOAT_SINGLE
@@ -383,7 +395,7 @@ print_named_ascii(size_t n_bytes, const char *block,
         };
         // buf[N] pos:  01234 56789
         char buf[12] = "   x\0 0xx\0";
-        // actually "   x\0 xxx\0", but I want to share the string with below.
+        // actually "   x\0 xxx\0", but want to share string with print_ascii.
         // [12] because we take three 32bit stack slots anyway, and
         // gcc is too dumb to initialize with constant stores,
         // it copies initializer from rodata. Oh well.
@@ -479,10 +491,10 @@ open_next_file(void)
                 if (in_stream) {
                         break;
                 }
-                ioerror = 1;
+                exit_code = 1;
         }
 
-        if (limit_bytes_to_format && !flag_dump_strings)
+        if ((option_mask32 & (OPT_N|OPT_S)) == OPT_N)
                 setbuf(in_stream, NULL);
 }
 
@@ -502,15 +514,14 @@ check_and_close(void)
                                         ? bb_msg_standard_input
                                         : file_list[-1]
                         );
-                        ioerror = 1;
+                        exit_code = 1;
                 }
                 fclose_if_not_stdin(in_stream);
                 in_stream = NULL;
         }
 
         if (ferror(stdout)) {
-                bb_error_msg(bb_msg_write_error);
-                ioerror = 1;
+                bb_error_msg_and_die(bb_msg_write_error);
         }
 }
 
@@ -542,7 +553,6 @@ decode_one_format(const char *s_orig, const char *s, struct tspec *tspec)
         unsigned field_width = 0;
         int pos;
 
-
         switch (*s) {
         case 'd':
         case 'o':
@@ -788,7 +798,7 @@ skip(off_t n_skip)
                                 /* take "check & close / open_next" route */
                         } else {
                                 if (fseeko(in_stream, n_skip, SEEK_CUR) != 0)
-                                        ioerror = 1;
+                                        exit_code = 1;
                                 return;
                         }
                 } else {
@@ -889,7 +899,8 @@ write_block(off_t current_offset, size_t n_bytes,
         static char prev_pair_equal = 0;
         size_t i;
 
-        if (!verbose && !first
+        if (!(option_mask32 & OPT_v)
+         && !first
          && n_bytes == bytes_per_block
          && memcmp(prev_block, curr_block, bytes_per_block) == 0
         ) {
@@ -911,9 +922,9 @@ write_block(off_t current_offset, size_t n_bytes,
                         (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
                         if (spec[i].hexl_mode_trailer) {
                                 /* space-pad out to full line width, then dump the trailer */
-                                int datum_width = width_bytes[spec[i].size];
-                                int blank_fields = (bytes_per_block - n_bytes) / datum_width;
-                                int field_width = spec[i].field_width + 1;
+                                unsigned datum_width = width_bytes[spec[i].size];
+                                unsigned blank_fields = (bytes_per_block - n_bytes) / datum_width;
+                                unsigned field_width = spec[i].field_width + 1;
                                 printf("%*s", blank_fields * field_width, "");
                                 dump_hexl_mode_trailer(n_bytes, curr_block);
                         }
@@ -961,42 +972,6 @@ get_lcm(void)
         return l_c_m;
 }
 
-#if ENABLE_LONG_OPTS
-/* If S is a valid traditional offset specification with an optional
-   leading '+' return nonzero and set *OFFSET to the offset it denotes.  */
-
-static int
-parse_old_offset(const char *s, off_t *offset)
-{
-        static const struct suffix_mult Bb[] = {
-                { "B", 1024 },
-                { "b", 512 },
-                { "", 0 }
-        };
-        char *p;
-        int radix;
-
-        /* Skip over any leading '+'. */
-        if (s[0] == '+') ++s;
-
-        /* Determine the radix we'll use to interpret S.  If there is a '.',
-         * it's decimal, otherwise, if the string begins with '0X'or '0x',
-         * it's hexadecimal, else octal.  */
-        p = strchr(s, '.');
-        radix = 8;
-        if (p) {
-                p[0] = '\0'; /* cheating */
-                radix = 10;
-        } else if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
-                radix = 16;
-
-        *offset = xstrtooff_sfx(s, radix, Bb);
-        if (p) p[0] = '.';
-
-        return (*offset >= 0);
-}
-#endif
-
 /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
    formatted block to standard output, and repeat until the specified
    maximum number of bytes has been read or until all input has been
@@ -1014,27 +989,25 @@ dump(off_t current_offset, off_t end_offset)
         int idx;
         size_t n_bytes_read;
 
-        block[0] = xmalloc(2*bytes_per_block);
+        block[0] = xmalloc(2 * bytes_per_block);
         block[1] = block[0] + bytes_per_block;
 
         idx = 0;
-        if (limit_bytes_to_format) {
+        if (option_mask32 & OPT_N) {
                 while (1) {
                         size_t n_needed;
                         if (current_offset >= end_offset) {
                                 n_bytes_read = 0;
                                 break;
                         }
-                        n_needed = MIN(end_offset - current_offset,
-                                (off_t) bytes_per_block);
+                        n_needed = MIN(end_offset - current_offset, (off_t) bytes_per_block);
                         read_block(n_needed, block[idx], &n_bytes_read);
                         if (n_bytes_read < bytes_per_block)
                                 break;
                         assert(n_bytes_read == bytes_per_block);
-                        write_block(current_offset, n_bytes_read,
-                               block[!idx], block[idx]);
+                        write_block(current_offset, n_bytes_read, block[idx ^ 1], block[idx]);
                         current_offset += n_bytes_read;
-                        idx = !idx;
+                        idx ^= 1;
                 }
         } else {
                 while (1) {
@@ -1042,10 +1015,9 @@ dump(off_t current_offset, off_t end_offset)
                         if (n_bytes_read < bytes_per_block)
                                 break;
                         assert(n_bytes_read == bytes_per_block);
-                        write_block(current_offset, n_bytes_read,
-                               block[!idx], block[idx]);
+                        write_block(current_offset, n_bytes_read, block[idx ^ 1], block[idx]);
                         current_offset += n_bytes_read;
-                        idx = !idx;
+                        idx ^= 1;
                 }
         }
 
@@ -1061,41 +1033,18 @@ dump(off_t current_offset, off_t end_offset)
 
                 memset(block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
                 write_block(current_offset, bytes_to_write,
-                                   block[!idx], block[idx]);
+                                   block[idx ^ 1], block[idx]);
                 current_offset += n_bytes_read;
         }
 
         format_address(current_offset, '\n');
 
-        if (limit_bytes_to_format && current_offset >= end_offset)
+        if ((option_mask32 & OPT_N) && current_offset >= end_offset)
                 check_and_close();
 
         free(block[0]);
 }
 
-/* Read a single byte into *C from the concatenation of the input files
-   named in the global array FILE_LIST.  On the first call to this
-   function, the global variable IN_STREAM is expected to be an open
-   stream associated with the input file INPUT_FILENAME.  If IN_STREAM
-   is at end-of-file, close it and update the global variables IN_STREAM
-   and INPUT_FILENAME so they correspond to the next file in the list.
-   Then try to read a byte from the newly opened file.  Repeat if
-   necessary until EOF is reached for the last file in FILE_LIST, then
-   set *C to EOF and return.  Subsequent calls do likewise.  */
-
-static void
-read_char(int *c)
-{
-        while (in_stream) { /* !EOF */
-                *c = fgetc(in_stream);
-                if (*c != EOF)
-                        return;
-                check_and_close();
-                open_next_file();
-        }
-        *c = EOF;
-}
-
 /* Read N bytes into BLOCK from the concatenation of the input files
    named in the global array FILE_LIST.  On the first call to this
    function, the global variable IN_STREAM is expected to be an open
@@ -1119,8 +1068,8 @@ read_char(int *c)
 static void
 dump_strings(off_t address, off_t end_offset)
 {
-        size_t bufsize = MAX(100, string_min);
-        char *buf = xmalloc(bufsize);
+        unsigned bufsize = MAX(100, string_min);
+        unsigned char *buf = xmalloc(bufsize);
 
         while (1) {
                 size_t i;
@@ -1128,19 +1077,25 @@ dump_strings(off_t address, off_t end_offset)
 
                 /* See if the next 'string_min' chars are all printing chars.  */
  tryline:
-                if (limit_bytes_to_format && (end_offset - string_min <= address))
+                if ((option_mask32 & OPT_N) && (end_offset - string_min <= address))
                         break;
                 i = 0;
-                while (!limit_bytes_to_format || address < end_offset) {
+                while (!(option_mask32 & OPT_N) || address < end_offset) {
                         if (i == bufsize) {
                                 bufsize += bufsize/8;
                                 buf = xrealloc(buf, bufsize);
                         }
-                        read_char(&c);
-                        if (c < 0) { /* EOF */
-                                free(buf);
-                                return;
+
+                        while (in_stream) { /* !EOF */
+                                c = fgetc(in_stream);
+                                if (c != EOF)
+                                        goto got_char;
+                                check_and_close();
+                                open_next_file();
                         }
+                        /* EOF */
+                        goto ret;
+ got_char:
                         address++;
                         if (!c)
                                 break;
@@ -1152,8 +1107,7 @@ dump_strings(off_t address, off_t end_offset)
                 if (i < string_min)             /* Too short! */
                         goto tryline;
 
-                /* If we get here, the string is all printable and NUL-terminated,
-                 * so print it.  It is all in 'buf' and 'i' is its length.  */
+                /* If we get here, the string is all printable and NUL-terminated */
                 buf[i] = 0;
                 format_address(address - i - 1, ' ');
 
@@ -1174,13 +1128,50 @@ dump_strings(off_t address, off_t end_offset)
 
         /* We reach this point only if we search through
            (max_bytes_to_format - string_min) bytes before reaching EOF.  */
+        check_and_close();
+ ret:
         free(buf);
+}
 
-        check_and_close();
+#if ENABLE_LONG_OPTS
+/* If S is a valid traditional offset specification with an optional
+   leading '+' return nonzero and set *OFFSET to the offset it denotes.  */
+
+static int
+parse_old_offset(const char *s, off_t *offset)
+{
+        static const struct suffix_mult Bb[] = {
+                { "B", 1024 },
+                { "b", 512 },
+                { "", 0 }
+        };
+        char *p;
+        int radix;
+
+        /* Skip over any leading '+'. */
+        if (s[0] == '+') ++s;
+        if (!isdigit(s[0])) return 0; /* not a number */
+
+        /* Determine the radix we'll use to interpret S.  If there is a '.',
+         * it's decimal, otherwise, if the string begins with '0X'or '0x',
+         * it's hexadecimal, else octal.  */
+        p = strchr(s, '.');
+        radix = 8;
+        if (p) {
+                p[0] = '\0'; /* cheating */
+                radix = 10;
+        } else if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
+                radix = 16;
+
+        *offset = xstrtooff_sfx(s, radix, Bb);
+        if (p) p[0] = '.';
+
+        return (*offset >= 0);
 }
+#endif
 
 int od_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
-int od_main(int argc, char **argv)
+int od_main(int argc UNUSED_PARAM, char **argv)
 {
         static const struct suffix_mult bkm[] = {
                 { "b", 512 },
@@ -1188,27 +1179,6 @@ int od_main(int argc, char **argv)
                 { "m", 1024*1024 },
                 { "", 0 }
         };
-        enum {
-                OPT_A = 1 << 0,
-                OPT_N = 1 << 1,
-                OPT_a = 1 << 2,
-                OPT_b = 1 << 3,
-                OPT_c = 1 << 4,
-                OPT_d = 1 << 5,
-                OPT_f = 1 << 6,
-                OPT_h = 1 << 7,
-                OPT_i = 1 << 8,
-                OPT_j = 1 << 9,
-                OPT_l = 1 << 10,
-                OPT_o = 1 << 11,
-                OPT_t = 1 << 12,
-                OPT_v = 1 << 13,
-                OPT_x = 1 << 14,
-                OPT_s = 1 << 15,
-                OPT_S = 1 << 16,
-                OPT_w = 1 << 17,
-                OPT_traditional = (1 << 18) * ENABLE_LONG_OPTS,
-        };
 #if ENABLE_LONG_OPTS
         static const char od_longopts[] ALIGN1 =
                 "skip-bytes\0"        Required_argument "j"
@@ -1216,18 +1186,18 @@ int od_main(int argc, char **argv)
                 "read-bytes\0"        Required_argument "N"
                 "format\0"            Required_argument "t"
                 "output-duplicates\0" No_argument       "v"
+                /* Yes, it's true: -S NUM, but --strings[=NUM]!
+                 * that is, NUM is mandatory for -S but optional for --strings!
+                 */
                 "strings\0"           Optional_argument "S"
                 "width\0"             Optional_argument "w"
                 "traditional\0"       No_argument       "\xff"
                 ;
 #endif
-        char *str_A, *str_N, *str_j, *str_S;
+        const char *str_A, *str_N, *str_j, *str_S = "3";
         llist_t *lst_t = NULL;
         unsigned opt;
         int l_c_m;
-        /* The old-style 'pseudo starting address' to be printed in parentheses
-           after any true address.  */
-        off_t pseudo_start = pseudo_start; // for gcc
         /* The number of input bytes to skip before formatting and writing.  */
         off_t n_bytes_to_skip = 0;
         /* The offset of the first byte after the last byte to be formatted.  */
@@ -1239,20 +1209,13 @@ int od_main(int argc, char **argv)
         format_address = format_address_std;
         address_base_char = 'o';
         address_pad_len_char = '7';
-        /* flag_dump_strings = 0; - already is */
 
         /* Parse command line */
         opt_complementary = "w+:t::"; /* -w N, -t is a list */
 #if ENABLE_LONG_OPTS
         applet_long_options = od_longopts;
 #endif
-        opt = getopt32(argv, "A:N:abcdfhij:lot:vxsS:"
-                "w::", // -w with optional param
-                // -S was -s and also had optional parameter
-                // but in coreutils 6.3 it was renamed and now has
-                // _mandatory_ parameter
-                &str_A, &str_N, &str_j, &lst_t, &str_S, &bytes_per_block);
-        argc -= optind;
+        opt = OD_GETOPT32();
         argv += optind;
         if (opt & OPT_A) {
                 static const char doxn[] ALIGN1 = "doxn";
@@ -1274,7 +1237,6 @@ int od_main(int argc, char **argv)
                 address_pad_len_char = doxn_address_pad_len_char[pos];
         }
         if (opt & OPT_N) {
-                limit_bytes_to_format = 1;
                 max_bytes_to_format = xstrtooff_sfx(str_N, 0, bkm);
         }
         if (opt & OPT_a) decode_format_string("a");
@@ -1287,28 +1249,23 @@ int od_main(int argc, char **argv)
         if (opt & OPT_j) n_bytes_to_skip = xstrtooff_sfx(str_j, 0, bkm);
         if (opt & OPT_l) decode_format_string("d4");
         if (opt & OPT_o) decode_format_string("o2");
-        //if (opt & OPT_t)...
         while (lst_t) {
                 decode_format_string(llist_pop(&lst_t));
         }
-        if (opt & OPT_v) verbose = 1;
         if (opt & OPT_x) decode_format_string("x2");
         if (opt & OPT_s) decode_format_string("d2");
         if (opt & OPT_S) {
-                string_min = 3;
                 string_min = xstrtou_sfx(str_S, 0, bkm);
-                flag_dump_strings = 1;
         }
-        //if (opt & OPT_w)...
-        //if (opt & OPT_traditional)...
 
-        if (flag_dump_strings && n_specs > 0)
-                bb_error_msg_and_die("no type may be specified when dumping strings");
+        // Bloat:
+        //if ((option_mask32 & OPT_S) && n_specs > 0)
+        //      bb_error_msg_and_die("no type may be specified when dumping strings");
 
         /* If the --traditional option is used, there may be from
          * 0 to 3 remaining command line arguments;  handle each case
          * separately.
-         * od [file] [[+]offset[.][b] [[+]label[.][b]]]
+         * od [FILE] [[+]OFFSET[.][b] [[+]LABEL[.][b]]]
          * The offset and pseudo_start have the same syntax.
          *
          * FIXME: POSIX 1003.1-2001 with XSI requires support for the
@@ -1316,93 +1273,91 @@ int od_main(int argc, char **argv)
 
 #if ENABLE_LONG_OPTS
         if (opt & OPT_traditional) {
-                off_t o1, o2;
-
-                if (argc == 1) {
-                        if (parse_old_offset(argv[0], &o1)) {
-                                n_bytes_to_skip = o1;
-                                --argc;
-                                ++argv;
-                        }
-                } else if (argc == 2) {
-                        if (parse_old_offset(argv[0], &o1)
-                         && parse_old_offset(argv[1], &o2)
-                        ) {
-                                n_bytes_to_skip = o1;
-                                flag_pseudo_start = 1;
-                                pseudo_start = o2;
-                                argv += 2;
-                                argc -= 2;
-                        } else if (parse_old_offset(argv[1], &o2)) {
-                                n_bytes_to_skip = o2;
-                                --argc;
-                                argv[1] = argv[0];
-                                ++argv;
-                        } else {
-                                bb_error_msg_and_die("invalid second operand "
-                                        "in compatibility mode '%s'", argv[1]);
-                        }
-                } else if (argc == 3) {
-                        if (parse_old_offset(argv[1], &o1)
-                         && parse_old_offset(argv[2], &o2)
-                        ) {
-                                n_bytes_to_skip = o1;
-                                flag_pseudo_start = 1;
-                                pseudo_start = o2;
-                                argv[2] = argv[0];
-                                argv += 2;
-                                argc -= 2;
-                        } else {
-                                bb_error_msg_and_die("in compatibility mode "
-                                        "the last two arguments must be offsets");
+                if (argv[0]) {
+                        off_t pseudo_start = -1;
+                        off_t o1, o2;
+
+                        if (!argv[1]) { /* one arg */
+                                if (parse_old_offset(argv[0], &o1)) {
+                                        /* od --traditional OFFSET */
+                                        n_bytes_to_skip = o1;
+                                        argv++;
+                                }
+                                /* od --traditional FILE */
+                        } else if (!argv[2]) { /* two args */
+                                if (parse_old_offset(argv[0], &o1)
+                                 && parse_old_offset(argv[1], &o2)
+                                ) {
+                                        /* od --traditional OFFSET LABEL */
+                                        n_bytes_to_skip = o1;
+                                        pseudo_start = o2;
+                                        argv += 2;
+                                } else if (parse_old_offset(argv[1], &o2)) {
+                                        /* od --traditional FILE OFFSET */
+                                        n_bytes_to_skip = o2;
+                                        argv[1] = NULL;
+                                } else {
+                                        bb_error_msg_and_die("invalid second argument '%s'", argv[1]);
+                                }
+                        } else if (!argv[3]) { /* three args */
+                                if (parse_old_offset(argv[1], &o1)
+                                 && parse_old_offset(argv[2], &o2)
+                                ) {
+                                        /* od --traditional FILE OFFSET LABEL */
+                                        n_bytes_to_skip = o1;
+                                        pseudo_start = o2;
+                                        argv[1] = NULL;
+                                } else {
+                                        bb_error_msg_and_die("the last two arguments must be offsets");
+                                }
+                        } else { /* >3 args */
+                                bb_error_msg_and_die("too many arguments");
                         }
-                } else if (argc > 3)    {
-                        bb_error_msg_and_die("compatibility mode supports "
-                                "at most three arguments");
-                }
 
-                if (flag_pseudo_start) {
-                        if (format_address == format_address_none) {
-                                address_base_char = 'o';
-                                address_pad_len_char = '7';
-                                format_address = format_address_paren;
-                        } else
-                                format_address = format_address_label;
+                        if (pseudo_start >= 0) {
+                                if (format_address == format_address_none) {
+                                        address_base_char = 'o';
+                                        address_pad_len_char = '7';
+                                        format_address = format_address_paren;
+                                } else {
+                                        format_address = format_address_label;
+                                }
+                                pseudo_offset = pseudo_start - n_bytes_to_skip;
+                        }
                 }
+                /* else: od --traditional (without args) */
         }
 #endif
 
-        if (limit_bytes_to_format) {
+        if (option_mask32 & OPT_N) {
                 end_offset = n_bytes_to_skip + max_bytes_to_format;
                 if (end_offset < n_bytes_to_skip)
-                        bb_error_msg_and_die("skip-bytes + read-bytes is too large");
+                        bb_error_msg_and_die("SKIP + SIZE is too large");
         }
 
         if (n_specs == 0) {
                 decode_format_string("o2");
-                n_specs = 1;
+                /*n_specs = 1; - done by decode_format_string */
         }
 
         /* If no files were listed on the command line,
            set the global pointer FILE_LIST so that it
            references the null-terminated list of one name: "-".  */
         file_list = bb_argv_dash;
-        if (argc > 0) {
+        if (argv[0]) {
                 /* Set the global pointer FILE_LIST so that it
                    references the first file-argument on the command-line.  */
                 file_list = (char const *const *) argv;
         }
 
-        /* open the first input file */
+        /* Open the first input file */
         open_next_file();
-        /* skip over any unwanted header bytes */
+        /* Skip over any unwanted header bytes */
         skip(n_bytes_to_skip);
         if (!in_stream)
                 return EXIT_FAILURE;
 
-        pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
-
-        /* Compute output block length.  */
+        /* Compute output block length */
         l_c_m = get_lcm();
 
         if (opt & OPT_w) { /* -w: width */
@@ -1424,13 +1379,13 @@ int od_main(int argc, char **argv)
         }
 #endif
 
-        if (flag_dump_strings)
+        if (option_mask32 & OPT_S)
                 dump_strings(n_bytes_to_skip, end_offset);
         else
                 dump(n_bytes_to_skip, end_offset);
 
-        if (fclose(stdin) == EOF)
+        if (fclose(stdin))
                 bb_perror_msg_and_die(bb_msg_standard_input);
 
-        return ioerror;
+        return exit_code;
 }
diff --git a/coreutils/tail.c b/coreutils/tail.c
index eac982735..4b42ebc52 100644
--- a/coreutils/tail.c
+++ b/coreutils/tail.c
@@ -59,7 +59,8 @@ static const struct suffix_mult tail_suffixes[] = {
 };
 
 struct globals {
-        bool status;
+        bool from_top;
+        bool exitcode;
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
 
@@ -85,7 +86,7 @@ static ssize_t tail_read(int fd, char *buf, size_t count)
         r = full_read(fd, buf, count);
         if (r < 0) {
                 bb_perror_msg(bb_msg_read_error);
-                G.status = EXIT_FAILURE;
+                G.exitcode = EXIT_FAILURE;
         }
 
         return r;
@@ -99,7 +100,7 @@ static unsigned eat_num(const char *p)
                 p++;
         else if (*p == '+') {
                 p++;
-                G.status = 1; /* mark that we saw "+" */
+                G.from_top = 1;
         }
         return xatou_sfx(p, tail_suffixes);
 }
@@ -109,7 +110,6 @@ int tail_main(int argc, char **argv)
 {
         unsigned count = 10;
         unsigned sleep_period = 1;
-        bool from_top;
         const char *str_c, *str_n;
 
         char *tailbuf;
@@ -152,8 +152,6 @@ int tail_main(int argc, char **argv)
 #endif
         argc -= optind;
         argv += optind;
-        from_top = G.status; /* 1 if there was "-c +N" or "-n +N" */
-        G.status = EXIT_SUCCESS;
 
         /* open all the files */
         fds = xmalloc(sizeof(fds[0]) * (argc + 1));
@@ -171,7 +169,7 @@ int tail_main(int argc, char **argv)
         do {
                 int fd = open_or_warn_stdin(argv[i]);
                 if (fd < 0 && !FOLLOW_RETRY) {
-                        G.status = EXIT_FAILURE;
+                        G.exitcode = EXIT_FAILURE;
                         continue;
                 }
                 fds[nfiles] = fd;
@@ -183,15 +181,19 @@ int tail_main(int argc, char **argv)
 
         /* prepare the buffer */
         tailbufsize = BUFSIZ;
-        if (!from_top && COUNT_BYTES) {
+        if (!G.from_top && COUNT_BYTES) {
                 if (tailbufsize < count + BUFSIZ) {
                         tailbufsize = count + BUFSIZ;
                 }
         }
-        tailbuf = xmalloc(tailbufsize);
+        /* tail -c1024m REGULAR_FILE doesn't really need 1G mem block.
+         * (In fact, it doesn't need ANY memory). So delay allocation.
+         */
+        tailbuf = NULL;
 
         /* tail the files */
-        fmt = header_fmt_str + 1; /* skip header leading newline on first output */
+
+        fmt = header_fmt_str + 1; /* skip leading newline in the header on the first output */
         i = 0;
         do {
                 char *buf;
@@ -209,7 +211,7 @@ int tail_main(int argc, char **argv)
                         fmt = header_fmt_str;
                 }
 
-                if (!from_top) {
+                if (!G.from_top) {
                         off_t current = lseek(fd, 0, SEEK_END);
                         if (current > 0) {
                                 unsigned off;
@@ -242,6 +244,9 @@ int tail_main(int argc, char **argv)
                         }
                 }
 
+                if (!tailbuf)
+                        tailbuf = xmalloc(tailbufsize);
+
                 buf = tailbuf;
                 taillen = 0;
                 /* "We saw 1st line/byte".
@@ -249,7 +254,7 @@ int tail_main(int argc, char **argv)
                 seen = 1;
                 newlines_seen = 0;
                 while ((nread = tail_read(fd, buf, tailbufsize-taillen)) > 0) {
-                        if (from_top) {
+                        if (G.from_top) {
                                 int nwrite = nread;
                                 if (seen < count) {
                                         /* We need to skip a few more bytes/lines */
@@ -313,7 +318,7 @@ int tail_main(int argc, char **argv)
                                 buf = tailbuf + taillen;
                         }
                 } /* while (tail_read() > 0) */
-                if (!from_top) {
+                if (!G.from_top) {
                         xwrite(STDOUT_FILENO, tailbuf, taillen);
                 }
         } while (++i < nfiles);
@@ -368,10 +373,11 @@ int tail_main(int argc, char **argv)
                                 xwrite(STDOUT_FILENO, tailbuf, nread);
                         }
                 } while (++i < nfiles);
-        }
+        } /* while (1) */
+
         if (ENABLE_FEATURE_CLEAN_UP) {
                 free(fds);
                 free(tailbuf);
         }
-        return G.status;
+        return G.exitcode;
 }
diff --git a/docs/style-guide.txt b/docs/style-guide.txt
index fdf6cfe4d..10ed893dc 100644
--- a/docs/style-guide.txt
+++ b/docs/style-guide.txt
@@ -679,11 +679,10 @@ line in the midst of your #includes, if you need to parse long options:
 
 Then have long options defined:
 
-        static const struct option <applet>_long_options[] = {
-                { "list",    0, NULL, 't' },
-                { "extract", 0, NULL, 'x' },
-                { NULL, 0, NULL, 0 }
-        };
+        static const char <applet>_longopts[] ALIGN1 =
+                "list\0"    No_argument "t"
+                "extract\0" No_argument "x"
+        ;
 
 And a code block similar to the following near the top of your applet_main()
 routine:
@@ -691,7 +690,7 @@ routine:
         char *str_b;
 
         opt_complementary = "cryptic_string";
-        applet_long_options = <applet>_long_options; /* if you have them */
+        applet_long_options = <applet>_longopts; /* if you have them */
         opt = getopt32(argc, argv, "ab:c", &str_b);
         if (opt & 1) {
                 handle_option_a();
diff --git a/e2fsprogs/fsck.c b/e2fsprogs/fsck.c
index b4257a2ad..fcbdb5989 100644
--- a/e2fsprogs/fsck.c
+++ b/e2fsprogs/fsck.c
@@ -317,7 +317,6 @@ static void load_fs_info(const char *filename)
 {
         FILE *fstab;
         struct mntent mte;
-        struct fs_info *fs;
 
         fstab = setmntent(filename, "r");
         if (!fstab) {
@@ -330,7 +329,7 @@ static void load_fs_info(const char *filename)
                 //bb_info_msg("CREATE[%s][%s][%s][%s][%d]", mte.mnt_fsname, mte.mnt_dir,
                 //      mte.mnt_type, mte.mnt_opts,
                 //      mte.mnt_passno);
-                fs = create_fs_device(mte.mnt_fsname, mte.mnt_dir,
+                create_fs_device(mte.mnt_fsname, mte.mnt_dir,
                         mte.mnt_type, mte.mnt_opts,
                         mte.mnt_passno);
         }
diff --git a/e2fsprogs/old_e2fsprogs/blkid/blkid_getsize.c b/e2fsprogs/old_e2fsprogs/blkid/blkid_getsize.c
index 941efa42c..e1f6ba6d2 100644
--- a/e2fsprogs/old_e2fsprogs/blkid/blkid_getsize.c
+++ b/e2fsprogs/old_e2fsprogs/blkid/blkid_getsize.c
@@ -96,9 +96,9 @@ blkid_loff_t blkid_get_dev_size(int fd)
 
 #ifdef BLKGETSIZE64
 #ifdef __linux__
-        if ((uname(&ut) == 0) &&
-            ((ut.release[0] == '2') && (ut.release[1] == '.') &&
-             (ut.release[2] < '6') && (ut.release[3] == '.')))
+        uname(&ut);
+        if ((ut.release[0] == '2') && (ut.release[1] == '.') &&
+             (ut.release[2] < '6') && (ut.release[3] == '.'))
                 valid_blkgetsize64 = 0;
 #endif
         if (valid_blkgetsize64 &&
diff --git a/e2fsprogs/old_e2fsprogs/ext2fs/getsize.c b/e2fsprogs/old_e2fsprogs/ext2fs/getsize.c
index ff11fe98c..ee4bbb7b0 100644
--- a/e2fsprogs/old_e2fsprogs/ext2fs/getsize.c
+++ b/e2fsprogs/old_e2fsprogs/ext2fs/getsize.c
@@ -174,9 +174,9 @@ errcode_t ext2fs_get_device_size(const char *file, int blocksize,
 
 #ifdef BLKGETSIZE64
 #ifdef __linux__
-        if ((uname(&ut) == 0) &&
-            ((ut.release[0] == '2') && (ut.release[1] == '.') &&
-             (ut.release[2] < '6') && (ut.release[3] == '.')))
+        uname(&ut);
+        if ((ut.release[0] == '2') && (ut.release[1] == '.') &&
+             (ut.release[2] < '6') && (ut.release[3] == '.'))
                 valid_blkgetsize64 = 0;
 #endif
         if (valid_blkgetsize64 &&
diff --git a/editors/diff.c b/editors/diff.c
index daa58af9b..8b1e92783 100644
--- a/editors/diff.c
+++ b/editors/diff.c
@@ -101,9 +101,9 @@
 #include "libbb.h"
 
 #if 0
-//#define dbg_error_msg(...) bb_error_msg(__VA_ARGS__)
+# define dbg_error_msg(...) bb_error_msg(__VA_ARGS__)
 #else
-#define dbg_error_msg(...) ((void)0)
+# define dbg_error_msg(...) ((void)0)
 #endif
 
 enum {                  /* print_status() and diffreg() return values */
diff --git a/editors/patch.c b/editors/patch.c
index a90252a03..6d3f319b0 100644
--- a/editors/patch.c
+++ b/editors/patch.c
@@ -239,7 +239,7 @@ static int apply_one_hunk(void)
         plist = TT.current_hunk;
         buf = NULL;
         if (reverse ? TT.oldlen : TT.newlen) for (;;) {
-                char *data = xmalloc_reads(TT.filein, NULL, NULL);
+                char *data = xmalloc_reads(TT.filein, NULL);
 
                 TT.linenum++;
 
diff --git a/editors/sed.c b/editors/sed.c
index 9ab758bd7..99e56ff52 100644
--- a/editors/sed.c
+++ b/editors/sed.c
@@ -14,49 +14,47 @@
  */
 
 /* Code overview.
+ *
+ * Files are laid out to avoid unnecessary function declarations.  So for
+ * example, every function add_cmd calls occurs before add_cmd in this file.
+ *
+ * add_cmd() is called on each line of sed command text (from a file or from
+ * the command line).  It calls get_address() and parse_cmd_args().  The
+ * resulting sed_cmd_t structures are appended to a linked list
+ * (G.sed_cmd_head/G.sed_cmd_tail).
+ *
+ * add_input_file() adds a FILE* to the list of input files.  We need to
+ * know all input sources ahead of time to find the last line for the $ match.
+ *
+ * process_files() does actual sedding, reading data lines from each input FILE *
+ * (which could be stdin) and applying the sed command list (sed_cmd_head) to
+ * each of the resulting lines.
+ *
+ * sed_main() is where external code calls into this, with a command line.
+ */
 
-  Files are laid out to avoid unnecessary function declarations.  So for
-  example, every function add_cmd calls occurs before add_cmd in this file.
-
-  add_cmd() is called on each line of sed command text (from a file or from
-  the command line).  It calls get_address() and parse_cmd_args().  The
-  resulting sed_cmd_t structures are appended to a linked list
-  (G.sed_cmd_head/G.sed_cmd_tail).
-
-  add_input_file() adds a FILE* to the list of input files.  We need to
-  know all input sources ahead of time to find the last line for the $ match.
-
-  process_files() does actual sedding, reading data lines from each input FILE *
-  (which could be stdin) and applying the sed command list (sed_cmd_head) to
-  each of the resulting lines.
-
-  sed_main() is where external code calls into this, with a command line.
-*/
-
-
-/*
-        Supported features and commands in this version of sed:
-
-         - comments ('#')
-         - address matching: num|/matchstr/[,num|/matchstr/|$]command
-         - commands: (p)rint, (d)elete, (s)ubstitue (with g & I flags)
-         - edit commands: (a)ppend, (i)nsert, (c)hange
-         - file commands: (r)ead
-         - backreferences in substitution expressions (\0, \1, \2...\9)
-         - grouped commands: {cmd1;cmd2}
-         - transliteration (y/source-chars/dest-chars/)
-         - pattern space hold space storing / swapping (g, h, x)
-         - labels / branching (: label, b, t, T)
-
-         (Note: Specifying an address (range) to match is *optional*; commands
-         default to the whole pattern space if no specific address match was
-         requested.)
-
-        Todo:
-         - Create a wrapper around regex to make libc's regex conform with sed
-
-        Reference http://www.opengroup.org/onlinepubs/007904975/utilities/sed.html
-*/
+/* Supported features and commands in this version of sed:
+ *
+ * - comments ('#')
+ * - address matching: num|/matchstr/[,num|/matchstr/|$]command
+ * - commands: (p)rint, (d)elete, (s)ubstitue (with g & I flags)
+ * - edit commands: (a)ppend, (i)nsert, (c)hange
+ * - file commands: (r)ead
+ * - backreferences in substitution expressions (\0, \1, \2...\9)
+ * - grouped commands: {cmd1;cmd2}
+ * - transliteration (y/source-chars/dest-chars/)
+ * - pattern space hold space storing / swapping (g, h, x)
+ * - labels / branching (: label, b, t, T)
+ *
+ * (Note: Specifying an address (range) to match is *optional*; commands
+ * default to the whole pattern space if no specific address match was
+ * requested.)
+ *
+ * Todo:
+ * - Create a wrapper around regex to make libc's regex conform with sed
+ *
+ * Reference http://www.opengroup.org/onlinepubs/007904975/utilities/sed.html
+ */
 
 //usage:#define sed_trivial_usage
 //usage:       "[-efinr] SED_CMD [FILE]..."
@@ -217,11 +215,16 @@ static void parse_escapes(char *dest, const char *string, int len, char from, ch
 
 static char *copy_parsing_escapes(const char *string, int len)
 {
+        const char *s;
         char *dest = xmalloc(len + 1);
 
-        parse_escapes(dest, string, len, 'n', '\n');
-        /* GNU sed also recognizes \t */
-        parse_escapes(dest, dest, strlen(dest), 't', '\t');
+        /* sed recognizes \n */
+        /* GNU sed also recognizes \t and \r */
+        for (s = "\nn\tt\rr"; *s; s += 2) {
+                parse_escapes(dest, string, len, s[1], s[0]);
+                string = dest;
+                len = strlen(dest);
+        }
         return dest;
 }
 
@@ -244,11 +247,13 @@ static int index_of_next_unescaped_regexp_delim(int delimiter, const char *str)
                 delimiter = -delimiter;
         }
 
-        for (; (ch = str[idx]); idx++) {
+        for (; (ch = str[idx]) != '\0'; idx++) {
                 if (bracket >= 0) {
-                        if (ch == ']' && !(bracket == idx - 1 || (bracket == idx - 2
-                                        && str[idx - 1] == '^')))
+                        if (ch == ']'
+                         && !(bracket == idx - 1 || (bracket == idx - 2 && str[idx - 1] == '^'))
+                        ) {
                                 bracket = -1;
+                        }
                 } else if (escaped)
                         escaped = 0;
                 else if (ch == '\\')
@@ -434,11 +439,47 @@ static int parse_subst_cmd(sed_cmd_t *sed_cmd, const char *substr)
  */
 static const char *parse_cmd_args(sed_cmd_t *sed_cmd, const char *cmdstr)
 {
+        static const char cmd_letters[] = "saicrw:btTydDgGhHlnNpPqx={}";
+        enum {
+                IDX_s = 0,
+                IDX_a,
+                IDX_i,
+                IDX_c,
+                IDX_r,
+                IDX_w,
+                IDX_colon,
+                IDX_b,
+                IDX_t,
+                IDX_T,
+                IDX_y,
+                IDX_d,
+                IDX_D,
+                IDX_g,
+                IDX_G,
+                IDX_h,
+                IDX_H,
+                IDX_l,
+                IDX_n,
+                IDX_N,
+                IDX_p,
+                IDX_P,
+                IDX_q,
+                IDX_x,
+                IDX_equal,
+                IDX_lbrace,
+                IDX_rbrace,
+                IDX_nul
+        };
+        struct chk { char chk[sizeof(cmd_letters)-1 == IDX_nul ? 1 : -1]; };
+
+        unsigned idx = strchrnul(cmd_letters, sed_cmd->cmd) - cmd_letters;
+
         /* handle (s)ubstitution command */
-        if (sed_cmd->cmd == 's')
+        if (idx == IDX_s) {
                 cmdstr += parse_subst_cmd(sed_cmd, cmdstr);
+        }
         /* handle edit cmds: (a)ppend, (i)nsert, and (c)hange */
-        else if (strchr("aic", sed_cmd->cmd)) {
+        else if (idx <= IDX_c) { /* a,i,c */
                 if ((sed_cmd->end_line || sed_cmd->end_match) && sed_cmd->cmd != 'c')
                         bb_error_msg_and_die("only a beginning address can be specified for edit commands");
                 for (;;) {
@@ -454,8 +495,9 @@ static const char *parse_cmd_args(sed_cmd_t *sed_cmd, const char *cmdstr)
                 /* "\anychar" -> "anychar" */
                 parse_escapes(sed_cmd->string, sed_cmd->string, strlen(cmdstr), '\0', '\0');
                 cmdstr += strlen(cmdstr);
+        }
         /* handle file cmds: (r)ead */
-        } else if (strchr("rw", sed_cmd->cmd)) {
+        else if (idx <= IDX_w) { /* r,w */
                 if (sed_cmd->end_line || sed_cmd->end_match)
                         bb_error_msg_and_die("command only uses one address");
                 cmdstr += parse_file_cmd(/*sed_cmd,*/ cmdstr, &sed_cmd->string);
@@ -463,8 +505,9 @@ static const char *parse_cmd_args(sed_cmd_t *sed_cmd, const char *cmdstr)
                         sed_cmd->sw_file = xfopen_for_write(sed_cmd->string);
                         sed_cmd->sw_last_char = '\n';
                 }
+        }
         /* handle branch commands */
-        } else if (strchr(":btT", sed_cmd->cmd)) {
+        else if (idx <= IDX_T) { /* :,b,t,T */
                 int length;
 
                 cmdstr = skip_whitespace(cmdstr);
@@ -475,7 +518,7 @@ static const char *parse_cmd_args(sed_cmd_t *sed_cmd, const char *cmdstr)
                 }
         }
         /* translation command */
-        else if (sed_cmd->cmd == 'y') {
+        else if (idx == IDX_y) {
                 char *match, *replace;
                 int i = cmdstr[0];
 
@@ -495,7 +538,7 @@ static const char *parse_cmd_args(sed_cmd_t *sed_cmd, const char *cmdstr)
         /* if it wasnt a single-letter command that takes no arguments
          * then it must be an invalid command.
          */
-        else if (strchr("dDgGhHlnNpPqx={}", sed_cmd->cmd) == 0) {
+        else if (idx >= IDX_nul) { /* not d,D,g,G,h,H,l,n,N,p,P,q,x,=,{,} */
                 bb_error_msg_and_die("unsupported command %c", sed_cmd->cmd);
         }
 
@@ -966,9 +1009,9 @@ static void process_files(void)
                         }
                         sed_cmd->in_match = !(
                                 /* has the ending line come, or is this a single address command? */
-                                (sed_cmd->end_line ?
-                                        sed_cmd->end_line == -1 ?
-                                                !next_line
+                                (sed_cmd->end_line
+                                        ? sed_cmd->end_line == -1
+                                                ? !next_line
                                                 : (sed_cmd->end_line <= linenum)
                                         : !sed_cmd->end_match
                                 )
diff --git a/editors/vi.c b/editors/vi.c
index 712af0326..9d74acc91 100644
--- a/editors/vi.c
+++ b/editors/vi.c
@@ -536,7 +536,6 @@ static void edit_file(char *fn)
 #define cur_line edit_file__cur_line
 #endif
         int c;
-        int size;
 #if ENABLE_FEATURE_VI_USE_SIGNALS
         int sig;
 #endif
@@ -545,7 +544,6 @@ static void edit_file(char *fn)
         rawmode();
         rows = 24;
         columns = 80;
-        size = 0;
         IF_FEATURE_VI_ASK_TERMINAL(G.get_rowcol_error =) query_screen_dimensions();
 #if ENABLE_FEATURE_VI_ASK_TERMINAL
         if (G.get_rowcol_error /* TODO? && no input on stdin */) {
@@ -1690,12 +1688,16 @@ static char *char_insert(char *p, char c) // insert the char c at 'p'
                         p = text_hole_delete(p, p);     // shrink buffer 1 char
                 }
         } else {
+#if ENABLE_FEATURE_VI_SETOPTS
                 // insert a char into text[]
                 char *sp;               // "save p"
+#endif
 
                 if (c == 13)
                         c = '\n';       // translate \r to \n
+#if ENABLE_FEATURE_VI_SETOPTS
                 sp = p;                 // remember addr of insert
+#endif
                 p += 1 + stupid_insert(p, c);   // insert the char
 #if ENABLE_FEATURE_VI_SETOPTS
                 if (showmatch && strchr(")]}", *sp) != NULL) {
diff --git a/examples/udhcp/udhcpd.conf b/examples/udhcp/udhcpd.conf
index 23fc834b7..cd2957ccc 100644
--- a/examples/udhcp/udhcpd.conf
+++ b/examples/udhcp/udhcpd.conf
@@ -14,11 +14,6 @@ interface	eth0
 # smaller than lease block.
 #max_leases     254
 
-# The time period at which udhcpd will write out a dhcpd.leases
-# file. If this is 0, udhcpd will never automatically write a
-# lease file. Specified in seconds.
-#auto_time      7200
-
 # The amount of time that an IP will be reserved (leased to nobody)
 # if a DHCP decline message is received (seconds)
 #decline_time   3600
@@ -34,11 +29,16 @@ interface	eth0
 # to this value (seconds)
 #min_lease      60
 
+# The location of the pid file
+#pidfile        /var/run/udhcpd.pid
+
 # The location of the leases file
 #lease_file     /var/lib/misc/udhcpd.leases
 
-# The location of the pid file
-#pidfile        /var/run/udhcpd.pid
+# The time period at which udhcpd will write out leases file.
+# If this is 0, udhcpd will never automatically write leases file.
+# Specified in seconds.
+#auto_time      7200
 
 # Every time udhcpd writes a leases file, the below script will be called
 #notify_file                    # default: no script
@@ -90,6 +90,8 @@ option	0x08	01020304	# option 8: "cookie server IP addr: 1.2.3.4"
 #opt wpad       STRING
 #opt serverid   IP              # default: server's IP
 #opt message    STRING          # error message (udhcpd sends it on success too)
+#opt vlanid     NUM             # 802.1P VLAN ID
+#opt vlanpriority NUM           # 802.1Q VLAN priority
 # Options specifying server(s)
 #opt dns        IP_LIST
 #opt wins       IP_LIST
@@ -97,8 +99,15 @@ option	0x08	01020304	# option 8: "cookie server IP addr: 1.2.3.4"
 #opt ntpsrv     IP_LIST
 #opt lprsrv     IP_LIST
 #opt swapsrv    IP
+# Options specifying routes
+#opt routes     IP_PAIR_LIST
 # Obsolete options, no longer supported
 #opt logsrv     IP_LIST # 704/UDP log server (not syslog!)
 #opt namesrv    IP_LIST # IEN 116 name server, obsolete (August 1979!!!)
 #opt cookiesrv  IP_LIST # RFC 865 "quote of the day" server, rarely (never?) used
 #opt timesrv    IP_LIST # RFC 868 time server, rarely (never?) used
+# TODO: in development
+#opt userclass  STRING          # RFC 3004. set of LASCII strings. "I am a printer" etc
+#opt sipserv    STRING LIST     # RFC 3361. flag byte, then: 0: domain names, 1: IP addrs
+#opt staticroutes   STATIC_ROUTES
+#opt msstaticroutes STATIC_ROUTES
diff --git a/findutils/find.c b/findutils/find.c
index 9ae84fa0d..050d6373e 100644
--- a/findutils/find.c
+++ b/findutils/find.c
@@ -264,6 +264,7 @@
 //usage:     "\n        -iname PATTERN  Case insensitive -name"
 //usage:        IF_FEATURE_FIND_PATH(
 //usage:     "\n        -path PATTERN   Match path to PATTERN"
+//usage:     "\n        -ipath PATTERN  Case insensitive -path"
 //usage:        )
 //usage:        IF_FEATURE_FIND_REGEX(
 //usage:     "\n        -regex PATTERN  Match path to regex PATTERN"
@@ -329,7 +330,11 @@
 #include <fnmatch.h>
 #include "libbb.h"
 #if ENABLE_FEATURE_FIND_REGEX
-#include "xregex.h"
+# include "xregex.h"
+#endif
+/* GNUism: */
+#ifndef FNM_CASEFOLD
+# define FNM_CASEFOLD 0
 #endif
 
 /* This is a NOEXEC applet. Be very careful! */
@@ -352,7 +357,7 @@ typedef struct {
 
                         ACTS(print)
                         ACTS(name,  const char *pattern; bool iname;)
-IF_FEATURE_FIND_PATH(   ACTS(path,  const char *pattern;))
+IF_FEATURE_FIND_PATH(   ACTS(path,  const char *pattern; bool ipath;))
 IF_FEATURE_FIND_REGEX(  ACTS(regex, regex_t compiled_pattern;))
 IF_FEATURE_FIND_PRINT0( ACTS(print0))
 IF_FEATURE_FIND_TYPE(   ACTS(type,  int type_mask;))
@@ -473,6 +478,22 @@ static int exec_actions(action ***appp, const char *fileName, const struct stat
 }
 
 
+#if !FNM_CASEFOLD
+static char *strcpy_upcase(char *dst, const char *src)
+{
+        char *d = dst;
+        while (1) {
+                unsigned char ch = *src++;
+                if (ch >= 'a' && ch <= 'z')
+                        ch -= ('a' - 'A');
+                *d++ = ch;
+                if (ch == '\0')
+                        break;
+        }
+        return dst;
+}
+#endif
+
 ACTF(name)
 {
         const char *tmp = bb_basename(fileName);
@@ -488,13 +509,25 @@ ACTF(name)
          * but somewhere between 4.1.20 and 4.4.0 GNU find stopped using it.
          * find -name '*foo' should match .foo too:
          */
+#if FNM_CASEFOLD
         return fnmatch(ap->pattern, tmp, (ap->iname ? FNM_CASEFOLD : 0)) == 0;
+#else
+        if (ap->iname)
+                tmp = strcpy_upcase(alloca(strlen(tmp) + 1), tmp);
+        return fnmatch(ap->pattern, tmp, 0) == 0;
+#endif
 }
 
 #if ENABLE_FEATURE_FIND_PATH
 ACTF(path)
 {
+# if FNM_CASEFOLD
+        return fnmatch(ap->pattern, fileName, (ap->ipath ? FNM_CASEFOLD : 0)) == 0;
+# else
+        if (ap->ipath)
+                fileName = strcpy_upcase(alloca(strlen(fileName) + 1), fileName);
         return fnmatch(ap->pattern, fileName, 0) == 0;
+# endif
 }
 #endif
 #if ENABLE_FEATURE_FIND_REGEX
@@ -794,6 +827,7 @@ static action*** parse_params(char **argv)
                                 PARM_name      ,
                                 PARM_iname     ,
         IF_FEATURE_FIND_PATH(   PARM_path      ,)
+        IF_FEATURE_FIND_PATH(   PARM_ipath     ,)
         IF_FEATURE_FIND_REGEX(  PARM_regex     ,)
         IF_FEATURE_FIND_TYPE(   PARM_type      ,)
         IF_FEATURE_FIND_PERM(   PARM_perm      ,)
@@ -831,6 +865,7 @@ static action*** parse_params(char **argv)
                                  "-name\0"
                                  "-iname\0"
         IF_FEATURE_FIND_PATH(   "-path\0"   )
+        IF_FEATURE_FIND_PATH(   "-ipath\0"  )
         IF_FEATURE_FIND_REGEX(  "-regex\0"  )
         IF_FEATURE_FIND_TYPE(   "-type\0"   )
         IF_FEATURE_FIND_PERM(   "-perm\0"   )
@@ -1018,10 +1053,11 @@ static action*** parse_params(char **argv)
                         ap->iname = (parm == PARM_iname);
                 }
 #if ENABLE_FEATURE_FIND_PATH
-                else if (parm == PARM_path) {
+                else if (parm == PARM_path || parm == PARM_ipath) {
                         action_path *ap;
                         ap = ALLOC_ACTION(path);
                         ap->pattern = arg1;
+                        ap->ipath = (parm == PARM_ipath);
                 }
 #endif
 #if ENABLE_FEATURE_FIND_REGEX
diff --git a/include/archive.h b/include/archive.h
index b139dc5be..9e176d335 100644
--- a/include/archive.h
+++ b/include/archive.h
@@ -125,7 +125,7 @@ typedef struct archive_handle_t {
 #define TAR_BLOCK_SIZE 512
 #define NAME_SIZE      100
 #define NAME_SIZE_STR "100"
-typedef struct tar_header_t {       /* byte offset */
+typedef struct tar_header_t {     /* byte offset */
         char name[NAME_SIZE];     /*   0-99 */
         char mode[8];             /* 100-107 */
         char uid[8];              /* 108-115 */
diff --git a/include/libbb.h b/include/libbb.h
index 4f46cf8c5..ac5722c89 100644
--- a/include/libbb.h
+++ b/include/libbb.h
@@ -20,6 +20,12 @@
 #include <netdb.h>
 #include <setjmp.h>
 #include <signal.h>
+#if defined __UCLIBC__ /* TODO: and glibc? */
+/* use inlined versions of these: */
+# define sigfillset(s)    __sigfillset(s)
+# define sigemptyset(s)   __sigemptyset(s)
+# define sigisemptyset(s) __sigisemptyset(s)
+#endif
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -363,6 +369,7 @@ extern void bb_copyfd_exact_size(int fd1, int fd2, off_t size) FAST_FUNC;
 /* "short" copy can be detected by return value < size */
 /* this helper yells "short read!" if param is not -1 */
 extern void complain_copyfd_and_die(off_t sz) NORETURN FAST_FUNC;
+
 extern char bb_process_escape_sequence(const char **ptr) FAST_FUNC;
 char* strcpy_and_process_escape_sequences(char *dst, const char *src) FAST_FUNC;
 /* xxxx_strip version can modify its parameter:
@@ -371,9 +378,13 @@ char* strcpy_and_process_escape_sequences(char *dst, const char *src) FAST_FUNC;
  * "abc/def"  -> "def"
  * "abc/def/" -> "def" !!
  */
-extern char *bb_get_last_path_component_strip(char *path) FAST_FUNC;
+char *bb_get_last_path_component_strip(char *path) FAST_FUNC;
 /* "abc/def/" -> "" and it never modifies 'path' */
-extern char *bb_get_last_path_component_nostrip(const char *path) FAST_FUNC;
+char *bb_get_last_path_component_nostrip(const char *path) FAST_FUNC;
+/* Simpler version: does not special case "/" string */
+const char *bb_basename(const char *name) FAST_FUNC;
+/* NB: can violate const-ness (similarly to strchr) */
+char *last_char_is(const char *s, int c) FAST_FUNC;
 
 void ndelay_on(int fd) FAST_FUNC;
 void ndelay_off(int fd) FAST_FUNC;
@@ -685,7 +696,7 @@ void* xrealloc_vector_helper(void *vector, unsigned sizeof_and_shift, int idx) F
 
 
 extern ssize_t safe_read(int fd, void *buf, size_t count) FAST_FUNC;
-extern ssize_t nonblock_safe_read(int fd, void *buf, size_t count) FAST_FUNC;
+extern ssize_t nonblock_immune_read(int fd, void *buf, size_t count, int loop_on_EINTR) FAST_FUNC;
 // NB: will return short read on error, not -1,
 // if some data was read before error occurred
 extern ssize_t full_read(int fd, void *buf, size_t count) FAST_FUNC;
@@ -696,7 +707,7 @@ extern ssize_t open_read_close(const char *filename, void *buf, size_t maxsz) FA
 // Reads one line a-la fgets (but doesn't save terminating '\n').
 // Reads byte-by-byte. Useful when it is important to not read ahead.
 // Bytes are appended to pfx (which must be malloced, or NULL).
-extern char *xmalloc_reads(int fd, char *pfx, size_t *maxsz_p) FAST_FUNC;
+extern char *xmalloc_reads(int fd, size_t *maxsz_p) FAST_FUNC;
 /* Reads block up to *maxsz_p (default: INT_MAX - 4095) */
 extern void *xmalloc_read(int fd, size_t *maxsz_p) FAST_FUNC RETURNS_MALLOC;
 /* Returns NULL if file can't be opened (default max size: INT_MAX - 4095) */
@@ -997,9 +1008,13 @@ extern uint32_t option_mask32;
 extern uint32_t getopt32(char **argv, const char *applet_opts, ...) FAST_FUNC;
 
 
+/* Having next pointer as a first member allows easy creation
+ * of "llist-compatible" structs, and using llist_FOO functions
+ * on them.
+ */
 typedef struct llist_t {
-        char *data;
         struct llist_t *link;
+        char *data;
 } llist_t;
 void llist_add_to(llist_t **old_head, void *data) FAST_FUNC;
 void llist_add_to_end(llist_t **list_head, void *data) FAST_FUNC;
@@ -1198,10 +1213,8 @@ void config_close(parser_t *parser) FAST_FUNC;
  * If path is NULL, it is assumed to be "/".
  * filename should not be NULL. */
 char *concat_path_file(const char *path, const char *filename) FAST_FUNC;
+/* Returns NULL on . and .. */
 char *concat_subpath_file(const char *path, const char *filename) FAST_FUNC;
-const char *bb_basename(const char *name) FAST_FUNC;
-/* NB: can violate const-ness (similarly to strchr) */
-char *last_char_is(const char *s, int c) FAST_FUNC;
 
 
 int bb_make_directory(char *path, long mode, int flags) FAST_FUNC;
@@ -1269,14 +1282,19 @@ extern int correct_password(const struct passwd *pw) FAST_FUNC;
 #endif
 extern char *pw_encrypt(const char *clear, const char *salt, int cleanup) FAST_FUNC;
 extern int obscure(const char *old, const char *newval, const struct passwd *pwdp) FAST_FUNC;
-/* rnd is additional random input. New one is returned.
+/*
+ * rnd is additional random input. New one is returned.
  * Useful if you call crypt_make_salt many times in a row:
  * rnd = crypt_make_salt(buf1, 4, 0);
  * rnd = crypt_make_salt(buf2, 4, rnd);
  * rnd = crypt_make_salt(buf3, 4, rnd);
  * (otherwise we risk having same salt generated)
  */
-extern int crypt_make_salt(char *p, int cnt, int rnd) FAST_FUNC;
+extern int crypt_make_salt(char *p, int cnt /*, int rnd*/) FAST_FUNC;
+/* "$N$" + sha_salt_16_bytes + NUL */
+#define MAX_PW_SALT_LEN (3 + 16 + 1)
+extern char* crypt_make_pw_salt(char p[MAX_PW_SALT_LEN], const char *algo) FAST_FUNC;
+
 
 /* Returns number of lines changed, or -1 on error */
 #if !(ENABLE_FEATURE_ADDUSER_TO_GROUP || ENABLE_FEATURE_DEL_USER_FROM_GROUP)
diff --git a/include/mingw.h b/include/mingw.h
index 49de6cb5e..69bf05574 100644
--- a/include/mingw.h
+++ b/include/mingw.h
@@ -209,6 +209,8 @@ NOIMPL(mingw_bind,SOCKET s UNUSED_PARAM,const struct sockaddr* sa UNUSED_PARAM,i
 /*
  * sys/stat.h
  */
+typedef int nlink_t;
+
 #define S_ISUID 04000
 #define S_ISGID 02000
 #define S_ISVTX 01000
diff --git a/include/platform.h b/include/platform.h
index eb9f8032b..48e256aa0 100644
--- a/include/platform.h
+++ b/include/platform.h
@@ -17,24 +17,6 @@
 # endif
 #endif
 
-/* Assume all these functions exist by default.  Platforms where it is not
- * true will #undef them below.
- */
-#define HAVE_CLEARENV 1
-#define HAVE_FDATASYNC 1
-#define HAVE_DPRINTF 1
-#define HAVE_MEMRCHR 1
-#define HAVE_MKDTEMP 1
-#define HAVE_PTSNAME_R 1
-#define HAVE_SETBIT 1
-#define HAVE_SIGHANDLER_T 1
-#define HAVE_STPCPY 1
-#define HAVE_STRCASESTR 1
-#define HAVE_STRCHRNUL 1
-#define HAVE_STRSEP 1
-#define HAVE_STRSIGNAL 1
-#define HAVE_VASPRINTF 1
-
 /* Convenience macros to test the version of gcc. */
 #undef __GNUC_PREREQ
 #if defined __GNUC__ && defined __GNUC_MINOR__
@@ -51,10 +33,6 @@
 # endif
 #endif
 
-/* Define macros for some gcc attributes.  This permits us to use the
-   macros freely, and know that they will come into play for the
-   version of gcc in which they are supported.  */
-
 #if !__GNUC_PREREQ(2,7)
 # ifndef __attribute__
 #  define __attribute__(x)
@@ -108,7 +86,7 @@
 #endif
 
 /* -fwhole-program makes all symbols local. The attribute externally_visible
-   forces a symbol global.  */
+ * forces a symbol global.  */
 #if __GNUC_PREREQ(4,1)
 # define EXTERNALLY_VISIBLE __attribute__(( visibility("default") ))
 //__attribute__ ((__externally_visible__))
@@ -124,22 +102,14 @@
 #endif
 
 /* We use __extension__ in some places to suppress -pedantic warnings
-   about GCC extensions.  This feature didn't work properly before
-   gcc 2.8.  */
+ * about GCC extensions.  This feature didn't work properly before
+ * gcc 2.8.  */
 #if !__GNUC_PREREQ(2,8)
 # ifndef __extension__
 #  define __extension__
 # endif
 #endif
 
-/* gcc-2.95 had no va_copy but only __va_copy. */
-#if !__GNUC_PREREQ(3,0)
-# include <stdarg.h>
-# if !defined va_copy && defined __va_copy
-#  define va_copy(d,s) __va_copy((d),(s))
-# endif
-#endif
-
 /* FAST_FUNC is a qualifier which (possibly) makes function call faster
  * and/or smaller by using modified ABI. It is usually only needed
  * on non-static, busybox internal functions. Recent versions of gcc
@@ -163,6 +133,15 @@
 # define POP_SAVED_FUNCTION_VISIBILITY
 #endif
 
+/* gcc-2.95 had no va_copy but only __va_copy. */
+#if !__GNUC_PREREQ(3,0)
+# include <stdarg.h>
+# if !defined va_copy && defined __va_copy
+#  define va_copy(d,s) __va_copy((d),(s))
+# endif
+#endif
+
+
 /* ---- Endian Detection ------------------------------------ */
 
 #include <limits.h>
@@ -238,6 +217,7 @@
 # define IF_LITTLE_ENDIAN(...) __VA_ARGS__
 #endif
 
+
 /* ---- Unaligned access ------------------------------------ */
 
 #include <stdint.h>
@@ -270,37 +250,9 @@ typedef uint32_t bb__aliased_uint32_t FIX_ALIASING;
 } while (0)
 #endif
 
-/* ---- Compiler dependent settings ------------------------- */
 
-#if (defined __digital__ && defined __unix__) \
- || defined __APPLE__ \
- || defined __FreeBSD__ || defined __OpenBSD__ || defined __NetBSD__
-# undef HAVE_CLEARENV
-# undef HAVE_FDATASYNC
-# undef HAVE_MNTENT_H
-# undef HAVE_PTSNAME_R
-# undef HAVE_SYS_STATFS_H
-# undef HAVE_SIGHANDLER_T
-# undef HAVE_XTABS
-# undef HAVE_DPRINTF
-#else
-# define HAVE_MNTENT_H 1
-# define HAVE_SYS_STATFS_H 1
-# define HAVE_XTABS 1
-#endif
-
-/*----- Kernel versioning ------------------------------------*/
-
-#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
-
-/* ---- Miscellaneous --------------------------------------- */
+/* ---- Size-saving "small" ints (arch-dependent) ----------- */
 
-#if defined __GLIBC__ || defined __UCLIBC__ \
- || defined __dietlibc__ || defined _NEWLIB_VERSION
-# include <features.h>
-#endif
-
-/* Size-saving "small" ints (arch-dependent) */
 #if defined(i386) || defined(__x86_64__) || defined(__mips__) || defined(__cris__)
 /* add other arches which benefit from this... */
 typedef signed char smallint;
@@ -320,7 +272,34 @@ typedef unsigned smalluint;
 # include <stdbool.h>
 #endif
 
-/* Try to defeat gcc's alignment of "char message[]"-like data */
+
+/*----- Kernel versioning ------------------------------------*/
+
+#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
+
+
+/* ---- Miscellaneous --------------------------------------- */
+
+#if defined __GLIBC__ \
+ || defined __UCLIBC__ \
+ || defined __dietlibc__ \
+ || defined _NEWLIB_VERSION
+# include <features.h>
+#endif
+
+/* Define bb_setpgrp */
+#if defined(__digital__) && defined(__unix__)
+/* use legacy setpgrp(pid_t, pid_t) for now.  move to platform.c */
+# define bb_setpgrp() do { pid_t __me = getpid(); setpgrp(__me, __me); } while (0)
+#else
+# define bb_setpgrp() setpgrp()
+#endif
+
+/* fdprintf is more readable, we used it before dprintf was standardized */
+#include <unistd.h>
+#define fdprintf dprintf
+
+/* Useful for defeating gcc's alignment of "char message[]"-like data */
 #if 1 /* if needed: !defined(arch1) && !defined(arch2) */
 # define ALIGN1 __attribute__((aligned(1)))
 # define ALIGN2 __attribute__((aligned(2)))
@@ -332,8 +311,7 @@ typedef unsigned smalluint;
 # define ALIGN4
 #endif
 
-
-/* uclibc does not implement daemon() for no-mmu systems.
+/*
  * For 0.9.29 and svn, __ARCH_USE_MMU__ indicates no-mmu reliably.
  * For earlier versions there is no reliable way to check if we are building
  * for a mmu-less system.
@@ -351,12 +329,9 @@ typedef unsigned smalluint;
 #endif
 
 #if defined(__digital__) && defined(__unix__)
-
 # include <standards.h>
 # include <inttypes.h>
 # define PRIu32 "u"
-/* use legacy setpgrp(pid_t,pid_t) for now.  move to platform.c */
-# define bb_setpgrp() do { pid_t __me = getpid(); setpgrp(__me, __me); } while (0)
 # if !defined ADJ_OFFSET_SINGLESHOT && defined MOD_CLKA && defined MOD_OFFSET
 #  define ADJ_OFFSET_SINGLESHOT (MOD_CLKA | MOD_OFFSET)
 # endif
@@ -369,17 +344,31 @@ typedef unsigned smalluint;
 # if !defined ADJ_TICK && defined MOD_CLKB
 #  define ADJ_TICK MOD_CLKB
 # endif
+#endif
 
-# undef HAVE_STPCPY
-
-#else
-
-# define bb_setpgrp() setpgrp()
 
-#endif
+/* ---- Who misses what? ------------------------------------ */
 
-#include <unistd.h>
-#define fdprintf dprintf
+/* Assume all these functions exist by default.  Platforms where it is not
+ * true will #undef them below.
+ */
+#define HAVE_CLEARENV 1
+#define HAVE_FDATASYNC 1
+#define HAVE_DPRINTF 1
+#define HAVE_MEMRCHR 1
+#define HAVE_MKDTEMP 1
+#define HAVE_PTSNAME_R 1
+#define HAVE_SETBIT 1
+#define HAVE_SIGHANDLER_T 1
+#define HAVE_STPCPY 1
+#define HAVE_STRCASESTR 1
+#define HAVE_STRCHRNUL 1
+#define HAVE_STRSEP 1
+#define HAVE_STRSIGNAL 1
+#define HAVE_VASPRINTF 1
+#define HAVE_MNTENT_H 1
+#define HAVE_SYS_STATFS_H 1
+#define HAVE_XTABS 1
 
 #if defined(__dietlibc__)
 # undef HAVE_STRCHRNUL
@@ -416,6 +405,23 @@ typedef unsigned smalluint;
 # undef HAVE_STRCHRNUL
 #endif
 
+#if (defined __digital__ && defined __unix__) \
+ || defined __APPLE__ \
+ || defined __FreeBSD__ || defined __OpenBSD__ || defined __NetBSD__
+# undef HAVE_CLEARENV
+# undef HAVE_FDATASYNC
+# undef HAVE_MNTENT_H
+# undef HAVE_PTSNAME_R
+# undef HAVE_SYS_STATFS_H
+# undef HAVE_SIGHANDLER_T
+# undef HAVE_XTABS
+# undef HAVE_DPRINTF
+#endif
+
+#if defined(__digital__) && defined(__unix__)
+# undef HAVE_STPCPY
+#endif
+
 /*
  * Now, define prototypes for all the functions defined in platform.c
  * These must come after all the HAVE_* macros are defined (or not)
diff --git a/libbb/Kbuild.src b/libbb/Kbuild.src
index 3c9493f7e..d110a3265 100644
--- a/libbb/Kbuild.src
+++ b/libbb/Kbuild.src
@@ -13,7 +13,6 @@ INSERT
 lib-y += appletlib.o
 lib-y += ask_confirmation.o
 lib-y += bb_askpass.o
-lib-y += bb_basename.o
 lib-y += bb_bswap_64.o
 lib-y += bb_do_delay.o
 lib-y += bb_pwd.o
diff --git a/libbb/appletlib.c b/libbb/appletlib.c
index a934f11bb..d4025b9c7 100644
--- a/libbb/appletlib.c
+++ b/libbb/appletlib.c
@@ -27,12 +27,13 @@
  * FEATURE_INSTALLER or FEATURE_SUID will still link printf routines in. :(
  */
 #include "busybox.h"
-#include <assert.h>
+
 #if !(defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) \
         || defined(__APPLE__) \
     )
 # include <malloc.h> /* for mallopt */
 #endif
+
 /* Try to pull in PAGE_SIZE */
 #ifdef __linux__
 # include <sys/user.h>
@@ -40,6 +41,9 @@
 #ifdef __GNU__ /* Hurd */
 # include <mach/vm_param.h>
 #endif
+#ifndef PAGE_SIZE
+# define PAGE_SIZE (4*1024) /* guess */
+#endif
 
 
 /* Declare <applet>_main() */
@@ -47,7 +51,6 @@
 #include "applets.h"
 #undef PROTOTYPES
 
-
 /* Include generated applet names, pointers to <applet>_main, etc */
 #include "applet_tables.h"
 /* ...and if applet_tables generator says we have only one applet... */
@@ -58,9 +61,9 @@
 # define IF_FEATURE_INDIVIDUAL(...) __VA_ARGS__
 #endif
 
-
 #include "usage_compressed.h"
 
+
 #if ENABLE_SHOW_USAGE && !ENABLE_FEATURE_COMPRESS_USAGE
 static const char usage_messages[] ALIGN1 = UNPACKED_USAGE;
 #else
@@ -233,13 +236,12 @@ IF_FEATURE_SUID(static uid_t ruid;)  /* real uid */
 
 # if ENABLE_FEATURE_SUID_CONFIG
 
-/* applets[] is const, so we have to define this "override" structure */
-static struct BB_suid_config {
+static struct suid_config_t {
+        /* next ptr must be first: this struct needs to be llist-compatible */
+        struct suid_config_t *m_next;
+        struct bb_uidgid_t m_ugid;
         int m_applet;
-        uid_t m_uid;
-        gid_t m_gid;
         mode_t m_mode;
-        struct BB_suid_config *m_next;
 } *suid_config;
 
 static bool suid_cfg_readable;
@@ -248,13 +250,10 @@ static bool suid_cfg_readable;
 static int ingroup(uid_t u, gid_t g)
 {
         struct group *grp = getgrgid(g);
-
         if (grp) {
                 char **mem;
-
                 for (mem = grp->gr_mem; *mem; mem++) {
                         struct passwd *pwd = getpwnam(*mem);
-
                         if (pwd && (pwd->pw_uid == u))
                                 return 1;
                 }
@@ -262,9 +261,7 @@ static int ingroup(uid_t u, gid_t g)
         return 0;
 }
 
-/* This should probably be a libbb routine.  In that case,
- * I'd probably rename it to something like bb_trimmed_slice.
- */
+/* libbb candidate */
 static char *get_trimmed_slice(char *s, char *e)
 {
         /* First, consider the value at e to be nul and back up until we
@@ -282,38 +279,19 @@ static char *get_trimmed_slice(char *s, char *e)
         return skip_whitespace(s);
 }
 
-/* Don't depend on the tools to combine strings. */
-static const char config_file[] ALIGN1 = "/etc/busybox.conf";
-
-/* We don't supply a value for the nul, so an index adjustment is
- * necessary below.  Also, we use unsigned short here to save some
- * space even though these are really mode_t values. */
-static const unsigned short mode_mask[] ALIGN2 = {
-        /*  SST     sst                 xxx         --- */
-        S_ISUID,    S_ISUID|S_IXUSR,    S_IXUSR,    0,  /* user */
-        S_ISGID,    S_ISGID|S_IXGRP,    S_IXGRP,    0,  /* group */
-        0,          S_IXOTH,            S_IXOTH,    0   /* other */
-};
-
-#define parse_error(x)  do { errmsg = x; goto pe_label; } while (0)
-
 static void parse_config_file(void)
 {
-        struct BB_suid_config *sct_head;
-        struct BB_suid_config *sct;
+        /* Don't depend on the tools to combine strings. */
+        static const char config_file[] ALIGN1 = "/etc/busybox.conf";
+
+        struct suid_config_t *sct_head;
         int applet_no;
         FILE *f;
         const char *errmsg;
-        char *s;
-        char *e;
-        int i;
         unsigned lc;
         smallint section;
-        char buffer[256];
         struct stat st;
 
-        assert(!suid_config); /* Should be set to NULL by bss init. */
-
         ruid = getuid();
         if (ruid == 0) /* run by root - don't need to even read config file */
                 return;
@@ -322,7 +300,7 @@ static void parse_config_file(void)
          || !S_ISREG(st.st_mode)                /* Not a regular file? */
          || (st.st_uid != 0)                    /* Not owned by root? */
          || (st.st_mode & (S_IWGRP | S_IWOTH))  /* Writable by non-root? */
-         || !(f = fopen_for_read(config_file))      /* Cannot open? */
+         || !(f = fopen_for_read(config_file))  /* Cannot open? */
         ) {
                 return;
         }
@@ -332,18 +310,21 @@ static void parse_config_file(void)
         section = lc = 0;
 
         while (1) {
-                s = buffer;
-
-                if (!fgets(s, sizeof(buffer), f)) { /* Are we done? */
-// why?
-                        if (ferror(f)) {   /* Make sure it wasn't a read error. */
-                                parse_error("reading");
-                        }
+                char buffer[256];
+                char *s;
+
+                if (!fgets(buffer, sizeof(buffer), f)) { /* Are we done? */
+                        // Looks like bloat
+                        //if (ferror(f)) {   /* Make sure it wasn't a read error. */
+                        //      errmsg = "reading";
+                        //      goto pe_label;
+                        //}
                         fclose(f);
                         suid_config = sct_head; /* Success, so set the pointer. */
                         return;
                 }
 
+                s = buffer;
                 lc++;                                   /* Got a (partial) line. */
 
                 /* If a line is too long for our buffer, we consider it an error.
@@ -355,7 +336,8 @@ static void parse_config_file(void)
                  * we do err on the side of caution.  Besides, the line would be
                  * too long if it did end with a newline. */
                 if (!strchr(s, '\n') && !feof(f)) {
-                        parse_error("line too long");
+                        errmsg = "line too long";
+                        goto pe_label;
                 }
 
                 /* Trim leading and trailing whitespace, ignoring comments, and
@@ -371,12 +353,13 @@ static void parse_config_file(void)
                         /* Unlike the old code, we ignore leading and trailing
                          * whitespace for the section name.  We also require that
                          * there are no stray characters after the closing bracket. */
-                        e = strchr(s, ']');
+                        char *e = strchr(s, ']');
                         if (!e   /* Missing right bracket? */
                          || e[1] /* Trailing characters? */
                          || !*(s = get_trimmed_slice(s+1, e)) /* Missing name? */
                         ) {
-                                parse_error("section header");
+                                errmsg = "section header";
+                                goto pe_label;
                         }
                         /* Right now we only have one section so just check it.
                          * If more sections are added in the future, please don't
@@ -401,12 +384,13 @@ static void parse_config_file(void)
                          * where both key and value could contain inner whitespace. */
 
                         /* First get the key (an applet name in our case). */
-                        e = strchr(s, '=');
+                        char *e = strchr(s, '=');
                         if (e) {
                                 s = get_trimmed_slice(s, e);
                         }
                         if (!e || !*s) {        /* Missing '=' or empty key. */
-                                parse_error("keyword");
+                                errmsg = "keyword";
+                                goto pe_label;
                         }
 
                         /* Ok, we have an applet name.  Process the rhs if this
@@ -415,13 +399,16 @@ static void parse_config_file(void)
                          * up when the busybox configuration is changed. */
                         applet_no = find_applet_by_name(s);
                         if (applet_no >= 0) {
+                                unsigned i;
+                                struct suid_config_t *sct;
+
                                 /* Note: We currently don't check for duplicates!
                                  * The last config line for each applet will be the
                                  * one used since we insert at the head of the list.
                                  * I suppose this could be considered a feature. */
-                                sct = xmalloc(sizeof(struct BB_suid_config));
+                                sct = xzalloc(sizeof(*sct));
                                 sct->m_applet = applet_no;
-                                sct->m_mode = 0;
+                                /*sct->m_mode = 0;*/
                                 sct->m_next = sct_head;
                                 sct_head = sct;
 
@@ -430,48 +417,41 @@ static void parse_config_file(void)
                                 e = skip_whitespace(e+1);
 
                                 for (i = 0; i < 3; i++) {
-                                        /* There are 4 chars + 1 nul for each of user/group/other. */
-                                        static const char mode_chars[] ALIGN1 = "Ssx-\0" "Ssx-\0" "Ttx-";
-
-                                        const char *q;
-                                        q = strchrnul(mode_chars + 5*i, *e++);
-                                        if (!*q) {
-                                                parse_error("mode");
+                                        /* There are 4 chars for each of user/group/other.
+                                         * "x-xx" instead of "x-" are to make
+                                         * "idx > 3" check catch invalid chars.
+                                         */
+                                        static const char mode_chars[] ALIGN1 = "Ssx-" "Ssx-" "x-xx";
+                                        static const unsigned short mode_mask[] ALIGN2 = {
+                                                S_ISUID, S_ISUID|S_IXUSR, S_IXUSR, 0, /* Ssx- */
+                                                S_ISGID, S_ISGID|S_IXGRP, S_IXGRP, 0, /* Ssx- */
+                                                                          S_IXOTH, 0  /*   x- */
+                                        };
+                                        const char *q = strchrnul(mode_chars + 4*i, *e);
+                                        unsigned idx = q - (mode_chars + 4*i);
+                                        if (idx > 3) {
+                                                errmsg = "mode";
+                                                goto pe_label;
                                         }
-                                        /* Adjust by -i to account for nul. */
-                                        sct->m_mode |= mode_mask[(q - mode_chars) - i];
+                                        sct->m_mode |= mode_mask[q - mode_chars];
+                                        e++;
                                 }
 
                                 /* Now get the user/group info. */
 
                                 s = skip_whitespace(e);
-
-                                /* Note: we require whitespace between the mode and the
-                                 * user/group info. */
-                                if ((s == e) || !(e = strchr(s, '.'))) {
-                                        parse_error("<uid>.<gid>");
-                                }
-                                *e++ = '\0';
-
-                                /* We can't use get_ug_id here since it would exit()
-                                 * if a uid or gid was not found.  Oh well... */
-                                sct->m_uid = bb_strtoul(s, NULL, 10);
-                                if (errno) {
-                                        struct passwd *pwd = getpwnam(s);
-                                        if (!pwd) {
-                                                parse_error("user");
+                                /* Default is 0.0, else parse USER.GROUP: */
+                                if (*s) {
+                                        /* We require whitespace between mode and USER.GROUP */
+                                        if ((s == e) || !(e = strchr(s, '.'))) {
+                                                errmsg = "uid.gid";
+                                                goto pe_label;
                                         }
-                                        sct->m_uid = pwd->pw_uid;
-                                }
-
-                                sct->m_gid = bb_strtoul(e, NULL, 10);
-                                if (errno) {
-                                        struct group *grp;
-                                        grp = getgrnam(e);
-                                        if (!grp) {
-                                                parse_error("group");
+                                        *e = ':'; /* get_uidgid needs USER:GROUP syntax */
+                                        if (get_uidgid(&sct->m_ugid, s, /*allow_numeric:*/ 1) == 0) {
+                                                errmsg = "unknown user/group";
+                                                goto pe_label;
                                         }
-                                        sct->m_gid = grp->gr_gid;
                                 }
                         }
                         continue;
@@ -485,22 +465,18 @@ static void parse_config_file(void)
                  * We may want to simply ignore such lines in case they
                  * are used in some future version of busybox. */
                 if (!section) {
-                        parse_error("keyword outside section");
+                        errmsg = "keyword outside section";
+                        goto pe_label;
                 }
 
         } /* while (1) */
 
  pe_label:
-        fprintf(stderr, "Parse error in %s, line %d: %s\n",
-                        config_file, lc, errmsg);
-
         fclose(f);
+        bb_error_msg("parse error in %s, line %u: %s", config_file, lc, errmsg);
+
         /* Release any allocated memory before returning. */
-        while (sct_head) {
-                sct = sct_head->m_next;
-                free(sct_head);
-                sct_head = sct;
-        }
+        llist_free((llist_t*)sct_head, NULL);
 }
 # else
 static inline void parse_config_file(void)
@@ -522,7 +498,7 @@ static void check_suid(int applet_no)
 #  if ENABLE_FEATURE_SUID_CONFIG
         if (suid_cfg_readable) {
                 uid_t uid;
-                struct BB_suid_config *sct;
+                struct suid_config_t *sct;
                 mode_t m;
 
                 for (sct = suid_config; sct; sct = sct->m_next) {
@@ -531,36 +507,40 @@ static void check_suid(int applet_no)
                 }
                 goto check_need_suid;
  found:
+                /* Is this user allowed to run this applet? */
                 m = sct->m_mode;
-                if (sct->m_uid == ruid)
+                if (sct->m_ugid.uid == ruid)
                         /* same uid */
                         m >>= 6;
-                else if ((sct->m_gid == rgid) || ingroup(ruid, sct->m_gid))
+                else if ((sct->m_ugid.gid == rgid) || ingroup(ruid, sct->m_ugid.gid))
                         /* same group / in group */
                         m >>= 3;
-
-                if (!(m & S_IXOTH))           /* is x bit not set ? */
-                        bb_error_msg_and_die("you have no permission to run this applet!");
-
-                /* _both_ sgid and group_exec have to be set for setegid */
-                if ((sct->m_mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP))
-                        rgid = sct->m_gid;
-                /* else (no setegid) we will set egid = rgid */
+                if (!(m & S_IXOTH)) /* is x bit not set? */
+                        bb_error_msg_and_die("you have no permission to run this applet");
 
                 /* We set effective AND saved ids. If saved-id is not set
-                 * like we do below, seteiud(0) can still later succeed! */
+                 * like we do below, seteuid(0) can still later succeed! */
+
+                /* Are we directed to change gid
+                 * (APPLET = *s* USER.GROUP or APPLET = *S* USER.GROUP)?
+                 */
+                if (sct->m_mode & S_ISGID)
+                        rgid = sct->m_ugid.gid;
+                /* else: we will set egid = rgid, thus dropping sgid effect */
                 if (setresgid(-1, rgid, rgid))
                         bb_perror_msg_and_die("setresgid");
 
-                /* do we have to set effective uid? */
+                /* Are we directed to change uid
+                 * (APPLET = s** USER.GROUP or APPLET = S** USER.GROUP)?
+                 */
                 uid = ruid;
                 if (sct->m_mode & S_ISUID)
-                        uid = sct->m_uid;
-                /* else (no seteuid) we will set euid = ruid */
-
+                        uid = sct->m_ugid.uid;
+                /* else: we will set euid = ruid, thus dropping suid effect */
                 if (setresuid(-1, uid, uid))
                         bb_perror_msg_and_die("setresuid");
-                return;
+
+                goto ret;
         }
 #   if !ENABLE_FEATURE_SUID_CONFIG_QUIET
         {
@@ -568,7 +548,7 @@ static void check_suid(int applet_no)
 
                 if (!onetime) {
                         onetime = 1;
-                        fprintf(stderr, "Using fallback suid method\n");
+                        bb_error_msg("using fallback suid method");
                 }
         }
 #   endif
@@ -583,6 +563,10 @@ static void check_suid(int applet_no)
                 xsetgid(rgid);  /* drop all privileges */
                 xsetuid(ruid);
         }
+#  if ENABLE_FEATURE_SUID_CONFIG
+ ret: ;
+        llist_free((llist_t*)suid_config, NULL);
+#  endif
 }
 # else
 #  define check_suid(x) ((void)0)
@@ -799,9 +783,6 @@ int main(int argc UNUSED_PARAM, char **argv)
 #endif
 {
         /* Tweak malloc for reduced memory consumption */
-#ifndef PAGE_SIZE
-# define PAGE_SIZE (4*1024) /* guess */
-#endif
 #ifdef M_TRIM_THRESHOLD
         /* M_TRIM_THRESHOLD is the maximum amount of freed top-most memory
          * to keep before releasing to the OS
diff --git a/libbb/bb_basename.c b/libbb/bb_basename.c
deleted file mode 100644
index 92fdb6545..000000000
--- a/libbb/bb_basename.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/* vi: set sw=4 ts=4: */
-/*
- * Utility routines.
- *
- * Copyright (C) 2007 Denys Vlasenko
- *
- * Licensed under GPLv2, see file LICENSE in this source tree.
- */
-
-#include "libbb.h"
-
-const char* FAST_FUNC bb_basename(const char *name)
-{
-        const char *cp = strrchr(name, '/');
-        if (cp)
-                return cp + 1;
-        if (ENABLE_PLATFORM_MINGW32) {
-                cp = strrchr(name, '\\');
-                if (cp)
-                        return cp + 1;
-        }
-        return name;
-}
diff --git a/libbb/dump.c b/libbb/dump.c
index 1b1d03a66..919fe135c 100644
--- a/libbb/dump.c
+++ b/libbb/dump.c
@@ -99,7 +99,7 @@ static NOINLINE int bb_dump_size(FS *fs)
 static NOINLINE void rewrite(priv_dumper_t *dumper, FS *fs)
 {
         enum { NOTOKAY, USEBCNT, USEPREC } sokay;
-        PR *pr, **nextpr = NULL;
+        PR *pr;
         FU *fu;
         char *p1, *p2, *p3;
         char savech, *fmtp;
@@ -111,15 +111,12 @@ static NOINLINE void rewrite(priv_dumper_t *dumper, FS *fs)
                  * break each format unit into print units; each
                  * conversion character gets its own.
                  */
-                for (nconv = 0, fmtp = fu->fmt; *fmtp; nextpr = &pr->nextpr) {
+                for (nconv = 0, fmtp = fu->fmt; *fmtp; ) {
                         /* NOSTRICT */
                         /* DBU:[dvae@cray.com] zalloc so that forward ptrs start out NULL*/
                         pr = xzalloc(sizeof(PR));
                         if (!fu->nextpr)
                                 fu->nextpr = pr;
-                        /* ignore nextpr -- its unused inside the loop and is
-                         * uninitialized 1st time through.
-                         */
 
                         /* skip preceding text and up to the next % sign */
                         for (p1 = fmtp; *p1 && *p1 != '%'; ++p1)
diff --git a/libbb/get_last_path_component.c b/libbb/get_last_path_component.c
index 72598d22e..db4be68ad 100644
--- a/libbb/get_last_path_component.c
+++ b/libbb/get_last_path_component.c
@@ -6,8 +6,21 @@
  *
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
-
 #include "libbb.h"
+
+const char* FAST_FUNC bb_basename(const char *name)
+{
+        const char *cp = strrchr(name, '/');
+        if (cp)
+                return cp + 1;
+#if ENABLE_PLATFORM_MINGW32
+        cp = strrchr(name, '\\');
+        if (cp)
+                return cp + 1;
+#endif
+        return name;
+}
+
 /*
  * "/"        -> "/"
  * "abc"      -> "abc"
diff --git a/libbb/getopt32.c b/libbb/getopt32.c
index 8087b3ba6..02cbefec9 100644
--- a/libbb/getopt32.c
+++ b/libbb/getopt32.c
@@ -7,7 +7,9 @@
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
-#include <getopt.h>
+#if ENABLE_LONG_OPTS || ENABLE_FEATURE_GETOPT_LONG
+# include <getopt.h>
+#endif
 #include "libbb.h"
 
 /*      Documentation
diff --git a/libbb/lineedit.c b/libbb/lineedit.c
index 67c5e0baa..e443c7a3e 100644
--- a/libbb/lineedit.c
+++ b/libbb/lineedit.c
@@ -41,6 +41,10 @@
  */
 #include "libbb.h"
 #include "unicode.h"
+#ifndef _POSIX_VDISABLE
+# define _POSIX_VDISABLE '\0'
+#endif
+
 
 #ifdef TEST
 # define ENABLE_FEATURE_EDITING 0
@@ -184,6 +188,7 @@ extern struct lineedit_statics *const lineedit_ptr_to_statics;
         IF_FEATURE_EDITING_FANCY_PROMPT(num_ok_lines = 1;) \
         IF_USERNAME_OR_HOMEDIR(home_pwd_buf = (char*)null_str;) \
 } while (0)
+
 static void deinit_S(void)
 {
 #if ENABLE_FEATURE_EDITING_FANCY_PROMPT
@@ -1684,7 +1689,7 @@ static void ask_terminal(void)
          * write(1, "~/srcdevel/bbox/fix/busybox.t4 # ", 33) = 33
          * poll([{fd=0, events=POLLIN}], 1, 0) = 0 (Timeout)  <-- no input exists
          * write(1, "\33[6n", 4) = 4  <-- send the ESC sequence, quick!
-         * poll([{fd=0, events=POLLIN}], 1, 4294967295) = 1 ([{fd=0, revents=POLLIN}])
+         * poll([{fd=0, events=POLLIN}], 1, -1) = 1 ([{fd=0, revents=POLLIN}])
          * read(0, "\n", 1)      = 1  <-- oh crap, user's input got in first
          */
         struct pollfd pfd;
@@ -1842,10 +1847,11 @@ static void win_changed(int nsig)
 {
         int sv_errno = errno;
         unsigned width;
+
         get_terminal_width_height(0, &width, NULL);
-        cmdedit_setwidth(width, nsig /* - just a yes/no flag */);
-        if (nsig == SIGWINCH)
-                signal(SIGWINCH, win_changed); /* rearm ourself */
+//FIXME: cmdedit_setwidth() -> redraw() -> printf() -> KABOOM! (we are in signal handler!)
+        cmdedit_setwidth(width, /*redraw_flg:*/ nsig);
+
         errno = sv_errno;
 }
 
@@ -2031,14 +2037,9 @@ int FAST_FUNC read_line_input(line_input_t *st, const char *prompt, char *comman
         new_settings.c_cc[VMIN] = 1;
         new_settings.c_cc[VTIME] = 0;
         /* Turn off CTRL-C, so we can trap it */
-#ifndef _POSIX_VDISABLE
-# define _POSIX_VDISABLE '\0'
-#endif
         new_settings.c_cc[VINTR] = _POSIX_VDISABLE;
         tcsetattr_stdin_TCSANOW(&new_settings);
 
-        previous_SIGWINCH_handler = signal(SIGWINCH, win_changed);
-        win_changed(0); /* do initial resizing */
 #if ENABLE_USERNAME_OR_HOMEDIR
         {
                 struct passwd *entry;
@@ -2061,6 +2062,11 @@ int FAST_FUNC read_line_input(line_input_t *st, const char *prompt, char *comman
         parse_and_put_prompt(prompt);
         ask_terminal();
 
+        /* Install window resize handler (NB: after *all* init is complete) */
+//FIXME: save entire sigaction!
+        previous_SIGWINCH_handler = signal(SIGWINCH, win_changed);
+        win_changed(0); /* get initial window size */
+
         read_key_buffer[0] = 0;
         while (1) {
                 /*
diff --git a/libbb/llist.c b/libbb/llist.c
index ed84e6472..032e9fac8 100644
--- a/libbb/llist.c
+++ b/libbb/llist.c
@@ -62,7 +62,7 @@ void FAST_FUNC llist_unlink(llist_t **head, llist_t *elm)
 
 /* Recursively free all elements in the linked list.  If freeit != NULL
  * call it on each datum in the list */
-void FAST_FUNC llist_free(llist_t *elm, void (*freeit) (void *data))
+void FAST_FUNC llist_free(llist_t *elm, void (*freeit)(void *data))
 {
         while (elm) {
                 void *data = llist_pop(&elm);
diff --git a/libbb/pw_encrypt.c b/libbb/pw_encrypt.c
index c6c04d44a..39ffa084f 100644
--- a/libbb/pw_encrypt.c
+++ b/libbb/pw_encrypt.c
@@ -27,9 +27,10 @@ static int i64c(int i)
         return ('a' - 38 + i);
 }
 
-int FAST_FUNC crypt_make_salt(char *p, int cnt, int x)
+int FAST_FUNC crypt_make_salt(char *p, int cnt /*, int x */)
 {
-        x += getpid() + time(NULL);
+        /* was: x += ... */
+        int x = getpid() + monotonic_us();
         do {
                 /* x = (x*1664525 + 1013904223) % 2^32 generator is lame
                  * (low-order bit is not "random", etc...),
@@ -47,6 +48,26 @@ int FAST_FUNC crypt_make_salt(char *p, int cnt, int x)
         return x;
 }
 
+char* FAST_FUNC crypt_make_pw_salt(char salt[MAX_PW_SALT_LEN], const char *algo)
+{
+        int len = 2/2;
+        char *salt_ptr = salt;
+        if (algo[0] != 'd') { /* not des */
+                len = 8/2; /* so far assuming md5 */
+                *salt_ptr++ = '$';
+                *salt_ptr++ = '1';
+                *salt_ptr++ = '$';
+#if !ENABLE_USE_BB_CRYPT || ENABLE_USE_BB_CRYPT_SHA
+                if (algo[0] == 's') { /* sha */
+                        salt[1] = '5' + (strcmp(algo, "sha512") == 0);
+                        len = 16/2;
+                }
+#endif
+        }
+        crypt_make_salt(salt_ptr, len);
+        return salt_ptr;
+}
+
 #if ENABLE_USE_BB_CRYPT
 
 static char*
diff --git a/libbb/read_printf.c b/libbb/read_printf.c
index 8664bc625..192f83d6e 100644
--- a/libbb/read_printf.c
+++ b/libbb/read_printf.c
@@ -55,32 +55,35 @@
  * which detects EAGAIN and uses poll() to wait on the fd.
  * Thankfully, poll() doesn't care about O_NONBLOCK flag.
  */
-ssize_t FAST_FUNC nonblock_safe_read(int fd, void *buf, size_t count)
+ssize_t FAST_FUNC nonblock_immune_read(int fd, void *buf, size_t count, int loop_on_EINTR)
 {
         struct pollfd pfd[1];
         ssize_t n;
 
         while (1) {
-                n = safe_read(fd, buf, count);
+                n = loop_on_EINTR ? safe_read(fd, buf, count) : read(fd, buf, count);
                 if (n >= 0 || errno != EAGAIN)
                         return n;
                 /* fd is in O_NONBLOCK mode. Wait using poll and repeat */
                 pfd[0].fd = fd;
                 pfd[0].events = POLLIN;
-                safe_poll(pfd, 1, -1); /* note: this pulls in printf */
+                /* note: safe_poll pulls in printf */
+                loop_on_EINTR ? safe_poll(pfd, 1, -1) : poll(pfd, 1, -1);
         }
 }
 
 // Reads one line a-la fgets (but doesn't save terminating '\n').
 // Reads byte-by-byte. Useful when it is important to not read ahead.
 // Bytes are appended to pfx (which must be malloced, or NULL).
-char* FAST_FUNC xmalloc_reads(int fd, char *buf, size_t *maxsz_p)
+char* FAST_FUNC xmalloc_reads(int fd, size_t *maxsz_p)
 {
         char *p;
-        size_t sz = buf ? strlen(buf) : 0;
+        char *buf = NULL;
+        size_t sz = 0;
         size_t maxsz = maxsz_p ? *maxsz_p : (INT_MAX - 4095);
 
         goto jump_in;
+
         while (sz < maxsz) {
                 if ((size_t)(p - buf) == sz) {
  jump_in:
@@ -88,8 +91,8 @@ char* FAST_FUNC xmalloc_reads(int fd, char *buf, size_t *maxsz_p)
                         p = buf + sz;
                         sz += 128;
                 }
-                /* nonblock_safe_read() because we are used by e.g. shells */
-                if (nonblock_safe_read(fd, p, 1) != 1) { /* EOF/error */
+                if (nonblock_immune_read(fd, p, 1, /*loop_on_EINTR:*/ 1) != 1) {
+                        /* EOF/error */
                         if (p == buf) { /* we read nothing */
                                 free(buf);
                                 return NULL;
diff --git a/libpwdgrp/uidgid_get.c b/libpwdgrp/uidgid_get.c
index 92290bfdb..8388be0da 100644
--- a/libpwdgrp/uidgid_get.c
+++ b/libpwdgrp/uidgid_get.c
@@ -71,7 +71,8 @@ int FAST_FUNC get_uidgid(struct bb_uidgid_t *u, const char *ug, int numeric_ok)
                         }
                 }
                 gr = getgrnam(group);
-                if (!gr) return 0;
+                if (!gr)
+                        return 0;
                 u->gid = gr->gr_gid;
         }
         return 1;
diff --git a/loginutils/adduser.c b/loginutils/adduser.c
index 1944d9d56..47c674bf4 100644
--- a/loginutils/adduser.c
+++ b/loginutils/adduser.c
@@ -67,6 +67,7 @@ static void passwd_study(struct passwd *p)
                 }
                 if (p->pw_uid == max) {
                         bb_error_msg_and_die("no %cids left", 'u');
+                        /* this format string is reused in adduser and addgroup */
                 }
                 p->pw_uid++;
         }
@@ -82,21 +83,32 @@ static void passwd_study(struct passwd *p)
 
 static void addgroup_wrapper(struct passwd *p, const char *group_name)
 {
-        char *argv[5];
+        char *argv[6];
 
         argv[0] = (char*)"addgroup";
         if (group_name) {
                 /* Add user to existing group */
-                argv[1] = p->pw_name;
-                argv[2] = (char*)group_name;
-                argv[3] = NULL;
+                argv[1] = (char*)"--";
+                argv[2] = p->pw_name;
+                argv[3] = (char*)group_name;
+                argv[4] = NULL;
         } else {
-                /* Add user to his own group with the first free gid found in passwd_study */
-//TODO: to be compatible with external addgroup programs we should use --gid instead...
+                /* Add user to his own group with the first free gid
+                 * found in passwd_study.
+                 */
+#if ENABLE_FEATURE_ADDGROUP_LONG_OPTIONS || !ENABLE_ADDGROUP
+                /* We try to use --gid, not -g, because "standard" addgroup
+                 * has no short option -g, it has only long --gid.
+                 */
+                argv[1] = (char*)"--gid";
+#else
+                /* Breaks if system in fact does NOT use busybox addgroup */
                 argv[1] = (char*)"-g";
+#endif
                 argv[2] = utoa(p->pw_gid);
-                argv[3] = p->pw_name;
-                argv[4] = NULL;
+                argv[3] = (char*)"--";
+                argv[4] = p->pw_name;
+                argv[5] = NULL;
         }
 
         spawn_and_wait(argv);
@@ -106,7 +118,7 @@ static void passwd_wrapper(const char *login_name) NORETURN;
 
 static void passwd_wrapper(const char *login_name)
 {
-        BB_EXECLP("passwd", "passwd", login_name, NULL);
+        BB_EXECLP("passwd", "passwd", "--", login_name, NULL);
         bb_error_msg_and_die("can't execute passwd, you must set password manually");
 }
 
@@ -228,9 +240,11 @@ int adduser_main(int argc UNUSED_PARAM, char **argv)
                 if (mkdir_err == 0) {
                         /* New home. Copy /etc/skel to it */
                         const char *args[] = {
-                                "chown", "-R",
+                                "chown",
+                                "-R",
                                 xasprintf("%u:%u", (int)pw.pw_uid, (int)pw.pw_gid),
-                                pw.pw_dir, NULL
+                                pw.pw_dir,
+                                NULL
                         };
                         /* Be silent on any errors (like: no /etc/skel) */
                         logmode = LOGMODE_NONE;
diff --git a/loginutils/chpasswd.c b/loginutils/chpasswd.c
index 6c4296faa..f4718c829 100644
--- a/loginutils/chpasswd.c
+++ b/loginutils/chpasswd.c
@@ -37,9 +37,8 @@ int chpasswd_main(int argc UNUSED_PARAM, char **argv)
         char *name, *pass;
         char salt[sizeof("$N$XXXXXXXX")];
         int opt, rc;
-        int rnd = rnd; /* we *want* it to be non-initialized! */
 
-        if (getuid())
+        if (getuid() != 0)
                 bb_error_msg_and_die(bb_msg_perm_denied_are_you_root);
 
         opt_complementary = "m--e:e--m";
@@ -55,10 +54,12 @@ int chpasswd_main(int argc UNUSED_PARAM, char **argv)
                 xuname2uid(name); /* dies if there is no such user */
 
                 if (!(opt & OPT_ENC)) {
-                        rnd = crypt_make_salt(salt, 1, rnd);
+                        crypt_make_salt(salt, 1);
                         if (opt & OPT_MD5) {
-                                strcpy(salt, "$1$");
-                                rnd = crypt_make_salt(salt + 3, 4, rnd);
+                                salt[0] = '$';
+                                salt[1] = '1';
+                                salt[2] = '$';
+                                crypt_make_salt(salt + 3, 4);
                         }
                         pass = pw_encrypt(pass, salt, 0);
                 }
diff --git a/loginutils/cryptpw.c b/loginutils/cryptpw.c
index 72388c492..b25a39ac9 100644
--- a/loginutils/cryptpw.c
+++ b/loginutils/cryptpw.c
@@ -14,12 +14,12 @@
 //usage:       "[OPTIONS] [PASSWORD] [SALT]"
 /* We do support -s, we just don't mention it */
 //usage:#define cryptpw_full_usage "\n\n"
-//usage:       "Crypt the PASSWORD using crypt(3)\n"
+//usage:       "Crypt PASSWORD using crypt(3)\n"
 //usage:     "\nOptions:"
 //usage:        IF_LONG_OPTS(
 //usage:     "\n        -P,--password-fd=N      Read password from fd N"
 /* //usage:  "\n        -s,--stdin              Use stdin; like -P0" */
-//usage:     "\n        -m,--method=TYPE        Encryption method TYPE"
+//usage:     "\n        -m,--method=TYPE        Encryption method"
 //usage:     "\n        -S,--salt=SALT"
 //usage:        )
 //usage:        IF_NOT_LONG_OPTS(
@@ -34,12 +34,12 @@
 //usage:       "[OPTIONS] [PASSWORD] [SALT]"
 /* We do support -s, we just don't mention it */
 //usage:#define mkpasswd_full_usage "\n\n"
-//usage:       "Crypt the PASSWORD using crypt(3)\n"
+//usage:       "Crypt PASSWORD using crypt(3)\n"
 //usage:     "\nOptions:"
 //usage:        IF_LONG_OPTS(
 //usage:     "\n        -P,--password-fd=N      Read password from fd N"
 /* //usage:  "\n        -s,--stdin              Use stdin; like -P0" */
-//usage:     "\n        -m,--method=TYPE        Encryption method TYPE"
+//usage:     "\n        -m,--method=TYPE        Encryption method"
 //usage:     "\n        -S,--salt=SALT"
 //usage:        )
 //usage:        IF_NOT_LONG_OPTS(
@@ -92,11 +92,9 @@ to cryptpw. -a option (alias for -m) came from cryptpw.
 int cryptpw_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int cryptpw_main(int argc UNUSED_PARAM, char **argv)
 {
-        /* $N$ + sha_salt_16_bytes + NUL */
-        char salt[3 + 16 + 1];
+        char salt[MAX_PW_SALT_LEN];
         char *salt_ptr;
         const char *opt_m, *opt_S;
-        int len;
         int fd;
 
 #if ENABLE_LONG_OPTS
@@ -121,24 +119,9 @@ int cryptpw_main(int argc UNUSED_PARAM, char **argv)
         if (argv[0] && !opt_S)
                 opt_S = argv[1];
 
-        len = 2/2;
-        salt_ptr = salt;
-        if (opt_m[0] != 'd') { /* not des */
-                len = 8/2; /* so far assuming md5 */
-                *salt_ptr++ = '$';
-                *salt_ptr++ = '1';
-                *salt_ptr++ = '$';
-#if !ENABLE_USE_BB_CRYPT || ENABLE_USE_BB_CRYPT_SHA
-                if (opt_m[0] == 's') { /* sha */
-                        salt[1] = '5' + (strcmp(opt_m, "sha512") == 0);
-                        len = 16/2;
-                }
-#endif
-        }
+        salt_ptr = crypt_make_pw_salt(salt, opt_m);
         if (opt_S)
-                safe_strncpy(salt_ptr, opt_S, sizeof(salt) - 3);
-        else
-                crypt_make_salt(salt_ptr, len, 0);
+                safe_strncpy(salt_ptr, opt_S, sizeof(salt) - (sizeof("$N$")-1));
 
         xmove_fd(fd, STDIN_FILENO);
 
diff --git a/loginutils/passwd.c b/loginutils/passwd.c
index 810644e61..b3ce646f1 100644
--- a/loginutils/passwd.c
+++ b/loginutils/passwd.c
@@ -6,13 +6,13 @@
 //usage:#define passwd_trivial_usage
 //usage:       "[OPTIONS] [USER]"
 //usage:#define passwd_full_usage "\n\n"
-//usage:       "Change USER's password. If no USER is specified,\n"
-//usage:       "changes the password for the current user.\n"
+//usage:       "Change USER's password (default: current user)"
+//usage:     "\n"
 //usage:     "\nOptions:"
-//usage:     "\n        -a ALG  Algorithm to use for password (des, md5)" /* ", sha1)" */
-//usage:     "\n        -d      Delete password for the account"
+//usage:     "\n        -a ALG  Encryption method"
+//usage:     "\n        -d      Set password to ''"
 //usage:     "\n        -l      Lock (disable) account"
-//usage:     "\n        -u      Unlock (re-enable) account"
+//usage:     "\n        -u      Unlock (enable) account"
 
 #include "libbb.h"
 #include <syslog.h>
@@ -22,15 +22,15 @@ static void nuke_str(char *str)
         if (str) memset(str, 0, strlen(str));
 }
 
-static char* new_password(const struct passwd *pw, uid_t myuid, int algo)
+static char* new_password(const struct passwd *pw, uid_t myuid, const char *algo)
 {
-        char salt[sizeof("$N$XXXXXXXX")]; /* "$N$XXXXXXXX" or "XX" */
+        char salt[MAX_PW_SALT_LEN];
         char *orig = (char*)"";
         char *newp = NULL;
         char *cp = NULL;
         char *ret = NULL; /* failure so far */
 
-        if (myuid && pw->pw_passwd[0]) {
+        if (myuid != 0 && pw->pw_passwd[0]) {
                 char *encrypted;
 
                 orig = bb_ask_stdin("Old password: "); /* returns ptr to static */
@@ -38,13 +38,13 @@ static char* new_password(const struct passwd *pw, uid_t myuid, int algo)
                         goto err_ret;
                 encrypted = pw_encrypt(orig, pw->pw_passwd, 1); /* returns malloced str */
                 if (strcmp(encrypted, pw->pw_passwd) != 0) {
-                        syslog(LOG_WARNING, "incorrect password for %s",
-                                pw->pw_name);
+                        syslog(LOG_WARNING, "incorrect password for %s", pw->pw_name);
                         bb_do_delay(LOGIN_FAIL_DELAY);
                         puts("Incorrect password");
                         goto err_ret;
                 }
-                if (ENABLE_FEATURE_CLEAN_UP) free(encrypted);
+                if (ENABLE_FEATURE_CLEAN_UP)
+                        free(encrypted);
         }
         orig = xstrdup(orig); /* or else bb_ask_stdin() will destroy it */
         newp = bb_ask_stdin("New password: "); /* returns ptr to static */
@@ -52,22 +52,22 @@ static char* new_password(const struct passwd *pw, uid_t myuid, int algo)
                 goto err_ret;
         newp = xstrdup(newp); /* we are going to bb_ask_stdin() again, so save it */
         if (ENABLE_FEATURE_PASSWD_WEAK_CHECK
-         && obscure(orig, newp, pw) && myuid)
+         && obscure(orig, newp, pw)
+         && myuid != 0
+        ) {
                 goto err_ret; /* non-root is not allowed to have weak passwd */
+        }
 
         cp = bb_ask_stdin("Retype password: ");
         if (!cp)
                 goto err_ret;
-        if (strcmp(cp, newp)) {
+        if (strcmp(cp, newp) != 0) {
                 puts("Passwords don't match");
                 goto err_ret;
         }
 
-        crypt_make_salt(salt, 1, 0); /* des */
-        if (algo) { /* MD5 */
-                strcpy(salt, "$1$");
-                crypt_make_salt(salt + 3, 4, 0);
-        }
+        crypt_make_pw_salt(salt, algo);
+
         /* pw_encrypt returns malloced str */
         ret = pw_encrypt(newp, salt, 1);
         /* whee, success! */
@@ -75,8 +75,10 @@ static char* new_password(const struct passwd *pw, uid_t myuid, int algo)
  err_ret:
         nuke_str(orig);
         if (ENABLE_FEATURE_CLEAN_UP) free(orig);
+
         nuke_str(newp);
         if (ENABLE_FEATURE_CLEAN_UP) free(newp);
+
         nuke_str(cp);
         return ret;
 }
@@ -85,17 +87,15 @@ int passwd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int passwd_main(int argc UNUSED_PARAM, char **argv)
 {
         enum {
-                OPT_algo = 0x1, /* -a - password algorithm */
-                OPT_lock = 0x2, /* -l - lock account */
-                OPT_unlock = 0x4, /* -u - unlock account */
-                OPT_delete = 0x8, /* -d - delete password */
-                OPT_lud = 0xe,
-                STATE_ALGO_md5 = 0x10,
-                //STATE_ALGO_des = 0x20, not needed yet
+                OPT_algo   = (1 << 0), /* -a - password algorithm */
+                OPT_lock   = (1 << 1), /* -l - lock account */
+                OPT_unlock = (1 << 2), /* -u - unlock account */
+                OPT_delete = (1 << 3), /* -d - delete password */
+                OPT_lud    = OPT_lock | OPT_unlock | OPT_delete,
         };
         unsigned opt;
         int rc;
-        const char *opt_a = "";
+        const char *opt_a = "d"; /* des */
         const char *filename;
         char *myname;
         char *name;
@@ -116,13 +116,9 @@ int passwd_main(int argc UNUSED_PARAM, char **argv)
         //argc -= optind;
         argv += optind;
 
-        if (strcasecmp(opt_a, "des") != 0) /* -a */
-                opt |= STATE_ALGO_md5;
-        //else
-        //      opt |= STATE_ALGO_des;
         myuid = getuid();
         /* -l, -u, -d require root priv and username argument */
-        if ((opt & OPT_lud) && (myuid || !argv[0]))
+        if ((opt & OPT_lud) && (myuid != 0 || !argv[0]))
                 bb_show_usage();
 
         /* Will complain and die if username not found */
@@ -130,7 +126,7 @@ int passwd_main(int argc UNUSED_PARAM, char **argv)
         name = argv[0] ? argv[0] : myname;
 
         pw = xgetpwnam(name);
-        if (myuid && pw->pw_uid != myuid) {
+        if (myuid != 0 && pw->pw_uid != myuid) {
                 /* LOGMODE_BOTH */
                 bb_error_msg_and_die("%s can't change password for %s", myname, name);
         }
@@ -164,27 +160,29 @@ int passwd_main(int argc UNUSED_PARAM, char **argv)
         newp = NULL;
         c = pw->pw_passwd[0] - '!';
         if (!(opt & OPT_lud)) {
-                if (myuid && !c) { /* passwd starts with '!' */
+                if (myuid != 0 && !c) { /* passwd starts with '!' */
                         /* LOGMODE_BOTH */
                         bb_error_msg_and_die("can't change "
                                         "locked password for %s", name);
                 }
                 printf("Changing password for %s\n", name);
-                newp = new_password(pw, myuid, opt & STATE_ALGO_md5);
+                newp = new_password(pw, myuid, opt_a);
                 if (!newp) {
                         logmode = LOGMODE_STDIO;
                         bb_error_msg_and_die("password for %s is unchanged", name);
                 }
         } else if (opt & OPT_lock) {
-                if (!c) goto skip; /* passwd starts with '!' */
+                if (!c)
+                        goto skip; /* passwd starts with '!' */
                 newp = xasprintf("!%s", pw->pw_passwd);
         } else if (opt & OPT_unlock) {
-                if (c) goto skip; /* not '!' */
+                if (c)
+                        goto skip; /* not '!' */
                 /* pw->pw_passwd points to static storage,
                  * strdup'ing to avoid nasty surprizes */
                 newp = xstrdup(&pw->pw_passwd[1]);
         } else if (opt & OPT_delete) {
-                newp = (char*)""; //xstrdup("");
+                newp = (char*)"";
         }
 
         rlimit_fsize.rlim_cur = rlimit_fsize.rlim_max = 512L * 30000;
@@ -202,7 +200,7 @@ int passwd_main(int argc UNUSED_PARAM, char **argv)
         rc = update_passwd(bb_path_shadow_file, name, newp, NULL);
         if (rc > 0)
                 /* password in /etc/shadow was updated */
-                newp = (char*) "x"; //xstrdup("x");
+                newp = (char*) "x";
         if (rc >= 0)
                 /* 0 = /etc/shadow missing (not an error), >0 = passwd changed in /etc/shadow */
 #endif
@@ -212,16 +210,17 @@ int passwd_main(int argc UNUSED_PARAM, char **argv)
         }
         /* LOGMODE_BOTH */
         if (rc < 0)
-                bb_error_msg_and_die("can't update password file %s",
-                                filename);
+                bb_error_msg_and_die("can't update password file %s", filename);
         bb_info_msg("Password for %s changed by %s", name, myname);
 
-        //if (ENABLE_FEATURE_CLEAN_UP) free(newp);
+        /*if (ENABLE_FEATURE_CLEAN_UP) free(newp); - can't, it may be non-malloced */
  skip:
         if (!newp) {
                 bb_error_msg_and_die("password for %s is already %slocked",
                         name, (opt & OPT_unlock) ? "un" : "");
         }
-        if (ENABLE_FEATURE_CLEAN_UP) free(myname);
+
+        if (ENABLE_FEATURE_CLEAN_UP)
+                free(myname);
         return 0;
 }
diff --git a/mailutils/Kbuild.src b/mailutils/Kbuild.src
index 20220dac8..6b4fb7470 100644
--- a/mailutils/Kbuild.src
+++ b/mailutils/Kbuild.src
@@ -7,7 +7,3 @@
 lib-y:=
 
 INSERT
-lib-$(CONFIG_MAKEMIME)     += mime.o mail.o
-lib-$(CONFIG_POPMAILDIR)   += popmaildir.o mail.o
-lib-$(CONFIG_REFORMIME)    += mime.o mail.o
-lib-$(CONFIG_SENDMAIL)     += sendmail.o mail.o
diff --git a/mailutils/mail.c b/mailutils/mail.c
index 44957016f..66c79471f 100644
--- a/mailutils/mail.c
+++ b/mailutils/mail.c
@@ -172,8 +172,8 @@ void FAST_FUNC get_cred_or_die(int fd)
                 G.user = xstrdup(bb_ask(fd, /* timeout: */ 0, "User: "));
                 G.pass = xstrdup(bb_ask(fd, /* timeout: */ 0, "Password: "));
         } else {
-                G.user = xmalloc_reads(fd, /* pfx: */ NULL, /* maxsize: */ NULL);
-                G.pass = xmalloc_reads(fd, /* pfx: */ NULL, /* maxsize: */ NULL);
+                G.user = xmalloc_reads(fd, /* maxsize: */ NULL);
+                G.pass = xmalloc_reads(fd, /* maxsize: */ NULL);
         }
         if (!G.user || !*G.user || !G.pass)
                 bb_error_msg_and_die("no username or password");
diff --git a/mailutils/mime.c b/mailutils/makemime.c
index 0aff8b1d7..628619bb8 100644
--- a/mailutils/mime.c
+++ b/mailutils/makemime.c
@@ -8,35 +8,17 @@
  * Licensed under GPLv2, see file LICENSE in this source tree.
  */
 
-//usage:#define makemime_trivial_usage
-//usage:       "[OPTIONS] [FILE]..."
-//usage:#define makemime_full_usage "\n\n"
-//usage:       "Create multipart MIME-encoded message from FILEs\n"
-/* //usage:    "Transfer encoding is base64, disposition is inline (not attachment)\n" */
-//usage:     "\nOptions:"
-//usage:     "\n        -o FILE Output. Default: stdout"
-//usage:     "\n        -a HDR  Add header. Examples:"
-//usage:     "\n                \"From: user@host.org\", \"Date: `date -R`\""
-//usage:     "\n        -c CT   Content type. Default: text/plain"
-//usage:     "\n        -C CS   Charset. Default: " CONFIG_FEATURE_MIME_CHARSET
-/* //usage:  "\n        -e ENC  Transfer encoding. Ignored. base64 is assumed" */
-//usage:     "\n"
-//usage:     "\nOther options are silently ignored"
-
-//usage:#define reformime_trivial_usage
-//usage:       "[OPTIONS] [FILE]..."
-//usage:#define reformime_full_usage "\n\n"
-//usage:       "Parse MIME-encoded message\n"
-//usage:     "\nOptions:"
-//usage:     "\n        -x PREFIX       Extract content of MIME sections to files"
-//usage:     "\n        -X PROG ARGS    Filter content of MIME sections through PROG"
-//usage:     "\n                        Must be the last option"
-//usage:     "\n"
-//usage:     "\nOther options are silently ignored"
+//kbuild:lib-$(CONFIG_MAKEMIME) += makemime.o mail.o
 
 #include "libbb.h"
 #include "mail.h"
 
+#if 0
+# define dbg_error_msg(...) bb_error_msg(__VA_ARGS__)
+#else
+# define dbg_error_msg(...) ((void)0)
+#endif
+
 /*
   makemime -c type [-o file] [-e encoding] [-C charset] [-N name] \
                    [-a "Header: Contents"] file
@@ -50,7 +32,6 @@
           \( opts \)  - read from child process, that generates [ opts ]
 
 Options:
-
   -c type         - create a new MIME section from "file" with this
                     Content-Type: (default is application/octet-stream).
   -C charset      - MIME charset of a new text/plain section.
@@ -70,6 +51,28 @@ Options:
           value on each line.
   {which version of makemime is this? What do we support?}
 */
+/* man makemime:
+
+ * -c TYPE: create a (non-multipart) MIME section with Content-Type: TYPE
+ * makemime -c TYPE [-e ENCODING] [-o OUTFILE] [-C CHARSET] [-N NAME] [-a HEADER...] FILE
+ * The -C option sets the MIME charset attribute for text/plain content.
+ * The -N option sets the name attribute for Content-Type:
+ * Encoding must be one of the following: 7bit, 8bit, quoted-printable, or base64.
+
+ * -m multipart/TYPE: create a multipart MIME collection with Content-Type: multipart/TYPE
+ * makemime -m multipart/TYPE [-e ENCODING] [-o OUTFILE] [-a HEADER...] FILE
+ * Type must be either "multipart/mixed", "multipart/alternative", or some other MIME multipart content type.
+ * Additionally, encoding can only be "7bit" or "8bit", and will default to "8bit" if not specified.
+ * Finally, filename must be a MIME-formatted section, NOT a regular file.
+ * The -m option creates an initial multipart MIME collection, that contains only one MIME section, taken from filename.
+ * The collection is written to standard output, or the pipe or to outputfile.
+
+ * -j FILE1: add a section to a multipart MIME collection
+ * makemime -j FILE1 [-o OUTFILE] FILE2
+ * FILE1 must be a MIME collection that was previously created by the -m option.
+ * FILE2 must be a MIME section that was previously created by the -c option.
+ * The -j options adds the MIME section in FILE2 to the MIME collection in FILE1.
+ */
 
 
 /* In busybox 1.15.0.svn, makemime generates output like this
@@ -92,10 +95,8 @@ Content-Transfer-Encoding: base64
 ...file B contents...
 --24269534-2145583448-1655890676--
 
-*/
-
-
-/* For reference: here is an example email to LKML which has
+ *
+ * For reference: here is an example email to LKML which has
  * 1st unnamed part (so it serves as an email body)
  * and one attached file:
 ...other headers...
@@ -126,28 +127,21 @@ Content-Transfer-Encoding: 7bit
 ...random junk added by mailing list robots and such...
 */
 
-/* man makemime:
-
- * -c TYPE: create a (non-multipart) MIME section with Content-Type: TYPE
- * makemime -c TYPE [-e ENCODING] [-o OUTFILE] [-C CHARSET] [-N NAME] [-a HEADER...] FILE
- * The -C option sets the MIME charset attribute for text/plain content.
- * The -N option sets the name attribute for Content-Type:
- * Encoding must be one of the following: 7bit, 8bit, quoted-printable, or base64.
-
- * -m multipart/TYPE: create a multipart MIME collection with Content-Type: multipart/TYPE
- * makemime -m multipart/TYPE [-e ENCODING] [-o OUTFILE] [-a HEADER...] FILE
- * Type must be either "multipart/mixed", "multipart/alternative", or some other MIME multipart content type.
- * Additionally, encoding can only be "7bit" or "8bit", and will default to "8bit" if not specified.
- * Finally, filename must be a MIME-formatted section, NOT a regular file.
- * The -m option creates an initial multipart MIME collection, that contains only one MIME section, taken from filename.
- * The collection is written to standard output, or the pipe or to outputfile.
+//usage:#define makemime_trivial_usage
+//usage:       "[OPTIONS] [FILE]..."
+//usage:#define makemime_full_usage "\n\n"
+//usage:       "Create multipart MIME-encoded message from FILEs\n"
+/* //usage:    "Transfer encoding is base64, disposition is inline (not attachment)\n" */
+//usage:     "\nOptions:"
+//usage:     "\n        -o FILE Output. Default: stdout"
+//usage:     "\n        -a HDR  Add header. Examples:"
+//usage:     "\n                \"From: user@host.org\", \"Date: `date -R`\""
+//usage:     "\n        -c CT   Content type. Default: text/plain"
+//usage:     "\n        -C CS   Charset. Default: " CONFIG_FEATURE_MIME_CHARSET
+/* //usage:  "\n        -e ENC  Transfer encoding. Ignored. base64 is assumed" */
+//usage:     "\n"
+//usage:     "\nOther options are silently ignored"
 
- * -j FILE1: add a section to a multipart MIME collection
- * makemime -j FILE1 [-o OUTFILE] FILE2
- * FILE1 must be a MIME collection that was previously created by the -m option.
- * FILE2 must be a MIME section that was previously created by the -c option.
- * The -j options adds the MIME section in FILE2 to the MIME collection in FILE1.
- */
 int makemime_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int makemime_main(int argc UNUSED_PARAM, char **argv)
 {
@@ -222,244 +216,3 @@ int makemime_main(int argc UNUSED_PARAM, char **argv)
         return EXIT_SUCCESS;
 #undef boundary
 }
-
-static const char *find_token(const char *const string_array[], const char *key, const char *defvalue)
-{
-        const char *r = NULL;
-        int i;
-        for (i = 0; string_array[i] != NULL; i++) {
-                if (strcasecmp(string_array[i], key) == 0) {
-                        r = (char *)string_array[i+1];
-                        break;
-                }
-        }
-        return (r) ? r : defvalue;
-}
-
-static const char *xfind_token(const char *const string_array[], const char *key)
-{
-        const char *r = find_token(string_array, key, NULL);
-        if (r)
-                return r;
-        bb_error_msg_and_die("header: %s", key);
-}
-
-enum {
-        OPT_x = 1 << 0,
-        OPT_X = 1 << 1,
-#if ENABLE_FEATURE_REFORMIME_COMPAT
-        OPT_d = 1 << 2,
-        OPT_e = 1 << 3,
-        OPT_i = 1 << 4,
-        OPT_s = 1 << 5,
-        OPT_r = 1 << 6,
-        OPT_c = 1 << 7,
-        OPT_m = 1 << 8,
-        OPT_h = 1 << 9,
-        OPT_o = 1 << 10,
-        OPT_O = 1 << 11,
-#endif
-};
-
-static int parse(const char *boundary, char **argv)
-{
-        char *line, *s, *p;
-        const char *type;
-        int boundary_len = strlen(boundary);
-        const char *delims = " ;\"\t\r\n";
-        const char *uniq;
-        int ntokens;
-        const char *tokens[32]; // 32 is enough
-
-        // prepare unique string pattern
-        uniq = xasprintf("%%llu.%u.%s", (unsigned)getpid(), safe_gethostname());
-
-//bb_info_msg("PARSE[%s]", uniq);
-
-        while ((line = xmalloc_fgets_str(stdin, "\r\n\r\n")) != NULL) {
-
-                // seek to start of MIME section
-                // N.B. to avoid false positives let us seek to the _last_ occurance
-                p = NULL;
-                s = line;
-                while ((s = strcasestr(s, "Content-Type:")) != NULL)
-                        p = s++;
-                if (!p)
-                        goto next;
-//bb_info_msg("L[%s]", p);
-
-                // split to tokens
-                // TODO: strip of comments which are of form: (comment-text)
-                ntokens = 0;
-                tokens[ntokens] = NULL;
-                for (s = strtok(p, delims); s; s = strtok(NULL, delims)) {
-                        tokens[ntokens] = s;
-                        if (ntokens < ARRAY_SIZE(tokens) - 1)
-                                ntokens++;
-//bb_info_msg("L[%d][%s]", ntokens, s);
-                }
-                tokens[ntokens] = NULL;
-//bb_info_msg("N[%d]", ntokens);
-
-                // analyse tokens
-                type = find_token(tokens, "Content-Type:", "text/plain");
-//bb_info_msg("T[%s]", type);
-                if (0 == strncasecmp(type, "multipart/", 10)) {
-                        if (0 == strcasecmp(type+10, "mixed")) {
-                                parse(xfind_token(tokens, "boundary="), argv);
-                        } else
-                                bb_error_msg_and_die("no support of content type '%s'", type);
-                } else {
-                        pid_t pid = pid;
-                        int rc;
-                        FILE *fp;
-                        // fetch charset
-                        const char *charset = find_token(tokens, "charset=", CONFIG_FEATURE_MIME_CHARSET);
-                        // fetch encoding
-                        const char *encoding = find_token(tokens, "Content-Transfer-Encoding:", "7bit");
-                        // compose target filename
-                        char *filename = (char *)find_token(tokens, "filename=", NULL);
-                        if (!filename)
-                                filename = xasprintf(uniq, monotonic_us());
-                        else
-                                filename = bb_get_last_path_component_strip(xstrdup(filename));
-
-                        // start external helper, if any
-                        if (opts & OPT_X) {
-                                int fd[2];
-                                xpipe(fd);
-                                pid = vfork();
-                                if (0 == pid) {
-                                        // child reads from fd[0]
-                                        close(fd[1]);
-                                        xmove_fd(fd[0], STDIN_FILENO);
-                                        xsetenv("CONTENT_TYPE", type);
-                                        xsetenv("CHARSET", charset);
-                                        xsetenv("ENCODING", encoding);
-                                        xsetenv("FILENAME", filename);
-                                        BB_EXECVP_or_die(argv);
-                                }
-                                // parent dumps to fd[1]
-                                close(fd[0]);
-                                fp = xfdopen_for_write(fd[1]);
-                                signal(SIGPIPE, SIG_IGN); // ignore EPIPE
-                        // or create a file for dump
-                        } else {
-                                char *fname = xasprintf("%s%s", *argv, filename);
-                                fp = xfopen_for_write(fname);
-                                free(fname);
-                        }
-
-                        // housekeeping
-                        free(filename);
-
-                        // dump to fp
-                        if (0 == strcasecmp(encoding, "base64")) {
-                                read_base64(stdin, fp, '-');
-                        } else if (0 != strcasecmp(encoding, "7bit")
-                                && 0 != strcasecmp(encoding, "8bit")
-                        ) {
-                                // quoted-printable, binary, user-defined are unsupported so far
-                                bb_error_msg_and_die("no support of encoding '%s'", encoding);
-                        } else {
-                                // N.B. we have written redundant \n. so truncate the file
-                                // The following weird 2-tacts reading technique is due to
-                                // we have to not write extra \n at the end of the file
-                                // In case of -x option we could truncate the resulting file as
-                                // fseek(fp, -1, SEEK_END);
-                                // if (ftruncate(fileno(fp), ftell(fp)))
-                                //      bb_perror_msg("ftruncate");
-                                // But in case of -X we have to be much more careful. There is
-                                // no means to truncate what we already have sent to the helper.
-                                p = xmalloc_fgets_str(stdin, "\r\n");
-                                while (p) {
-                                        s = xmalloc_fgets_str(stdin, "\r\n");
-                                        if (s == NULL)
-                                                break;
-                                        if ('-' == s[0]
-                                         && '-' == s[1]
-                                         && 0 == strncmp(s+2, boundary, boundary_len)
-                                        ) {
-                                                break;
-                                        }
-                                        fputs(p, fp);
-                                        p = s;
-                                }
-
-/*
-                                while ((s = xmalloc_fgetline_str(stdin, "\r\n")) != NULL) {
-                                        if ('-' == s[0] && '-' == s[1]
-                                                && 0 == strncmp(s+2, boundary, boundary_len))
-                                                break;
-                                        fprintf(fp, "%s\n", s);
-                                }
-                                // N.B. we have written redundant \n. so truncate the file
-                                fseek(fp, -1, SEEK_END);
-                                if (ftruncate(fileno(fp), ftell(fp)))
-                                        bb_perror_msg("ftruncate");
-*/
-                        }
-                        fclose(fp);
-
-                        // finalize helper
-                        if (opts & OPT_X) {
-                                signal(SIGPIPE, SIG_DFL);
-                                // exit if helper exited >0
-                                rc = (wait4pid(pid) & 0xff);
-                                if (rc)
-                                        return rc+20;
-                        }
-
-                        // check multipart finalized
-                        if (s && '-' == s[2+boundary_len] && '-' == s[2+boundary_len+1]) {
-                                free(line);
-                                break;
-                        }
-                }
- next:
-                free(line);
-        }
-
-//bb_info_msg("ENDPARSE[%s]", boundary);
-
-        return EXIT_SUCCESS;
-}
-
-/*
-Usage: reformime [options]
-    -d - parse a delivery status notification.
-    -e - extract contents of MIME section.
-    -x - extract MIME section to a file.
-    -X - pipe MIME section to a program.
-    -i - show MIME info.
-    -s n.n.n.n - specify MIME section.
-    -r - rewrite message, filling in missing MIME headers.
-    -r7 - also convert 8bit/raw encoding to quoted-printable, if possible.
-    -r8 - also convert quoted-printable encoding to 8bit, if possible.
-    -c charset - default charset for rewriting, -o, and -O.
-    -m [file] [file]... - create a MIME message digest.
-    -h "header" - decode RFC 2047-encoded header.
-    -o "header" - encode unstructured header using RFC 2047.
-    -O "header" - encode address list header using RFC 2047.
-*/
-
-int reformime_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
-int reformime_main(int argc UNUSED_PARAM, char **argv)
-{
-        const char *opt_prefix = "";
-
-        INIT_G();
-
-        // parse options
-        // N.B. only -x and -X are supported so far
-        opt_complementary = "x--X:X--x" IF_FEATURE_REFORMIME_COMPAT(":m::");
-        opts = getopt32(argv,
-                "x:X" IF_FEATURE_REFORMIME_COMPAT("deis:r:c:m:h:o:O:"),
-                &opt_prefix
-                IF_FEATURE_REFORMIME_COMPAT(, NULL, NULL, &G.opt_charset, NULL, NULL, NULL, NULL)
-        );
-        //argc -= optind;
-        argv += optind;
-
-        return parse("", (opts & OPT_X) ? argv : (char **)&opt_prefix);
-}
diff --git a/mailutils/popmaildir.c b/mailutils/popmaildir.c
index 642657919..c9d22aa28 100644
--- a/mailutils/popmaildir.c
+++ b/mailutils/popmaildir.c
@@ -10,6 +10,8 @@
  * Licensed under GPLv2, see file LICENSE in this source tree.
  */
 
+//kbuild:lib-$(CONFIG_POPMAILDIR) += popmaildir.o mail.o
+
 //usage:#define popmaildir_trivial_usage
 //usage:       "[OPTIONS] MAILDIR [CONN_HELPER ARGS]"
 //usage:#define popmaildir_full_usage "\n\n"
diff --git a/mailutils/reformime.c b/mailutils/reformime.c
new file mode 100644
index 000000000..aa5e3b1c0
--- /dev/null
+++ b/mailutils/reformime.c
@@ -0,0 +1,280 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * makemime: create MIME-encoded message
+ * reformime: parse MIME-encoded message
+ *
+ * Copyright (C) 2008 by Vladimir Dronnikov <dronnikov@gmail.com>
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+
+//kbuild:lib-$(CONFIG_REFORMIME) += reformime.o mail.o
+
+#include "libbb.h"
+#include "mail.h"
+
+#if 0
+# define dbg_error_msg(...) bb_error_msg(__VA_ARGS__)
+#else
+# define dbg_error_msg(...) ((void)0)
+#endif
+
+static const char *find_token(const char *const string_array[], const char *key, const char *defvalue)
+{
+        const char *r = NULL;
+        int i;
+        for (i = 0; string_array[i] != NULL; i++) {
+                if (strcasecmp(string_array[i], key) == 0) {
+                        r = (char *)string_array[i+1];
+                        break;
+                }
+        }
+        return (r) ? r : defvalue;
+}
+
+static const char *xfind_token(const char *const string_array[], const char *key)
+{
+        const char *r = find_token(string_array, key, NULL);
+        if (r)
+                return r;
+        bb_error_msg_and_die("not found: '%s'", key);
+}
+
+enum {
+        OPT_x = 1 << 0,
+        OPT_X = 1 << 1,
+#if ENABLE_FEATURE_REFORMIME_COMPAT
+        OPT_d = 1 << 2,
+        OPT_e = 1 << 3,
+        OPT_i = 1 << 4,
+        OPT_s = 1 << 5,
+        OPT_r = 1 << 6,
+        OPT_c = 1 << 7,
+        OPT_m = 1 << 8,
+        OPT_h = 1 << 9,
+        OPT_o = 1 << 10,
+        OPT_O = 1 << 11,
+#endif
+};
+
+static int parse(const char *boundary, char **argv)
+{
+        int boundary_len = strlen(boundary);
+        char uniq[sizeof("%%llu.%u") + sizeof(int)*3];
+
+        dbg_error_msg("BOUNDARY[%s]", boundary);
+
+        // prepare unique string pattern
+        sprintf(uniq, "%%llu.%u", (unsigned)getpid());
+        dbg_error_msg("UNIQ[%s]", uniq);
+
+        while (1) {
+                char *header;
+                const char *tokens[32]; /* 32 is enough */
+                const char *type;
+
+                /* Read the header (everything up to two \n) */
+                {
+                        unsigned header_idx = 0;
+                        int last_ch = 0;
+                        header = NULL;
+                        while (1) {
+                                int ch = fgetc(stdin);
+                                if (ch == '\r') /* Support both line endings */
+                                        continue;
+                                if (ch == EOF)
+                                        break;
+                                if (ch == '\n' && last_ch == ch)
+                                        break;
+                                if (!(header_idx & 0xff))
+                                        header = xrealloc(header, header_idx + 0x101);
+                                header[header_idx++] = last_ch = ch;
+                        }
+                        if (!header) {
+                                dbg_error_msg("EOF");
+                                break;
+                        }
+                        header[header_idx] = '\0';
+                        dbg_error_msg("H:'%s'", p);
+                }
+
+                /* Split to tokens */
+                {
+                        char *s, *p;
+                        unsigned ntokens;
+                        const char *delims = ";=\" \t\n";
+
+                        /* Skip to last Content-Type: */
+                        s = p = header;
+                        while ((p = strchr(p, '\n')) != NULL) {
+                                p++;
+                                if (strncasecmp(p, "Content-Type:", sizeof("Content-Type:")-1) == 0)
+                                        s = p;
+                        }
+                        dbg_error_msg("L:'%s'", p);
+                        ntokens = 0;
+                        s = strtok(s, delims);
+                        while (s) {
+                                tokens[ntokens] = s;
+                                if (ntokens < ARRAY_SIZE(tokens) - 1)
+                                        ntokens++;
+                                dbg_error_msg("L[%d]='%s'", ntokens, s);
+                                s = strtok(NULL, delims);
+                        }
+                        tokens[ntokens] = NULL;
+                        dbg_error_msg("EMPTYLINE, ntokens:%d", ntokens);
+                        if (ntokens == 0)
+                                break;
+                }
+
+                /* Is it multipart? */
+                type = find_token(tokens, "Content-Type:", "text/plain");
+                dbg_error_msg("TYPE:'%s'", type);
+                if (0 == strncasecmp(type, "multipart/", 10)) {
+                        /* Yes, recurse */
+                        if (strcasecmp(type + 10, "mixed") != 0)
+                                bb_error_msg_and_die("no support of content type '%s'", type);
+                        parse(xfind_token(tokens, "boundary"), argv);
+
+                } else {
+                        /* No, process one non-multipart section */
+                        char *end;
+                        pid_t pid = pid;
+                        FILE *fp;
+
+                        const char *charset = find_token(tokens, "charset", CONFIG_FEATURE_MIME_CHARSET);
+                        const char *encoding = find_token(tokens, "Content-Transfer-Encoding:", "7bit");
+
+                        /* Compose target filename */
+                        char *filename = (char *)find_token(tokens, "filename", NULL);
+                        if (!filename)
+                                filename = xasprintf(uniq, monotonic_us());
+                        else
+                                filename = bb_get_last_path_component_strip(xstrdup(filename));
+
+                        if (opts & OPT_X) {
+                                int fd[2];
+
+                                /* start external helper */
+                                xpipe(fd);
+                                pid = vfork();
+                                if (0 == pid) {
+                                        /* child reads from fd[0] */
+                                        close(fd[1]);
+                                        xmove_fd(fd[0], STDIN_FILENO);
+                                        xsetenv("CONTENT_TYPE", type);
+                                        xsetenv("CHARSET", charset);
+                                        xsetenv("ENCODING", encoding);
+                                        xsetenv("FILENAME", filename);
+                                        BB_EXECVP_or_die(argv);
+                                }
+                                /* parent will write to fd[1] */
+                                close(fd[0]);
+                                fp = xfdopen_for_write(fd[1]);
+                                signal(SIGPIPE, SIG_IGN);
+                        } else {
+                                /* write to file */
+                                char *fname = xasprintf("%s%s", *argv, filename);
+                                fp = xfopen_for_write(fname);
+                                free(fname);
+                        }
+                        free(filename);
+
+                        /* write to fp */
+                        end = NULL;
+                        if (0 == strcasecmp(encoding, "base64")) {
+                                read_base64(stdin, fp, '-');
+                        } else
+                        if (0 != strcasecmp(encoding, "7bit")
+                         && 0 != strcasecmp(encoding, "8bit")
+                        ) {
+                                /* quoted-printable, binary, user-defined are unsupported so far */
+                                bb_error_msg_and_die("encoding '%s' not supported", encoding);
+                        } else {
+                                /* plain 7bit or 8bit */
+                                while ((end = xmalloc_fgets(stdin)) != NULL) {
+                                        if ('-' == end[0]
+                                         && '-' == end[1]
+                                         && strncmp(end + 2, boundary, boundary_len) == 0
+                                        ) {
+                                                break;
+                                        }
+                                        fputs(end, fp);
+                                }
+                        }
+                        fclose(fp);
+
+                        /* Wait for child */
+                        if (opts & OPT_X) {
+                                int rc;
+                                signal(SIGPIPE, SIG_DFL);
+                                rc = (wait4pid(pid) & 0xff);
+                                if (rc != 0)
+                                        return rc + 20;
+                        }
+
+                        /* Multipart ended? */
+                        if (end && '-' == end[2 + boundary_len] && '-' == end[2 + boundary_len + 1]) {
+                                dbg_error_msg("FINISHED MPART:'%s'", end);
+                                break;
+                        }
+                        dbg_error_msg("FINISHED:'%s'", end);
+                        free(end);
+                } /* end of "handle one non-multipart block" */
+
+                free(header);
+        } /* while (1) */
+
+        dbg_error_msg("ENDPARSE[%s]", boundary);
+
+        return EXIT_SUCCESS;
+}
+
+//usage:#define reformime_trivial_usage
+//usage:       "[OPTIONS]"
+//usage:#define reformime_full_usage "\n\n"
+//usage:       "Parse MIME-encoded message on stdin\n"
+//usage:     "\nOptions:"
+//usage:     "\n        -x PREFIX       Extract content of MIME sections to files"
+//usage:     "\n        -X PROG ARGS    Filter content of MIME sections through PROG"
+//usage:     "\n                        Must be the last option"
+//usage:     "\n"
+//usage:     "\nOther options are silently ignored"
+
+/*
+Usage: reformime [options]
+    -d - parse a delivery status notification.
+    -e - extract contents of MIME section.
+    -x - extract MIME section to a file.
+    -X - pipe MIME section to a program.
+    -i - show MIME info.
+    -s n.n.n.n - specify MIME section.
+    -r - rewrite message, filling in missing MIME headers.
+    -r7 - also convert 8bit/raw encoding to quoted-printable, if possible.
+    -r8 - also convert quoted-printable encoding to 8bit, if possible.
+    -c charset - default charset for rewriting, -o, and -O.
+    -m [file] [file]... - create a MIME message digest.
+    -h "header" - decode RFC 2047-encoded header.
+    -o "header" - encode unstructured header using RFC 2047.
+    -O "header" - encode address list header using RFC 2047.
+*/
+
+int reformime_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int reformime_main(int argc UNUSED_PARAM, char **argv)
+{
+        const char *opt_prefix = "";
+
+        INIT_G();
+
+        // parse options
+        // N.B. only -x and -X are supported so far
+        opt_complementary = "x--X:X--x" IF_FEATURE_REFORMIME_COMPAT(":m::");
+        opts = getopt32(argv,
+                "x:X" IF_FEATURE_REFORMIME_COMPAT("deis:r:c:m:h:o:O:"),
+                &opt_prefix
+                IF_FEATURE_REFORMIME_COMPAT(, NULL, NULL, &G.opt_charset, NULL, NULL, NULL, NULL)
+        );
+        argv += optind;
+
+        return parse("", (opts & OPT_X) ? argv : (char **)&opt_prefix);
+}
diff --git a/mailutils/sendmail.c b/mailutils/sendmail.c
index 8096288ef..e0aff20fb 100644
--- a/mailutils/sendmail.c
+++ b/mailutils/sendmail.c
@@ -7,6 +7,8 @@
  * Licensed under GPLv2, see file LICENSE in this source tree.
  */
 
+//kbuild:lib-$(CONFIG_SENDMAIL) += sendmail.o mail.o
+
 //usage:#define sendmail_trivial_usage
 //usage:       "[OPTIONS] [RECIPIENT_EMAIL]..."
 //usage:#define sendmail_full_usage "\n\n"
diff --git a/miscutils/dc.c b/miscutils/dc.c
index 777ec1654..b080ba133 100644
--- a/miscutils/dc.c
+++ b/miscutils/dc.c
@@ -11,7 +11,7 @@
 //usage:
 //usage:#define dc_full_usage "\n\n"
 //usage:       "Tiny RPN calculator. Operations:\n"
-//usage:       "+, add, -, sub, *, mul, /, div, %, mod, **, exp, and, or, not, eor,\n"
+//usage:       "+, add, -, sub, *, mul, /, div, %, mod, "IF_FEATURE_DC_LIBM("**, exp, ")"and, or, not, eor,\n"
 //usage:       "p - print top of the stack (without popping),\n"
 //usage:       "f - print entire stack,\n"
 //usage:       "o - pop the value and set output radix (must be 10, 16, 8 or 2).\n"
diff --git a/miscutils/last_fancy.c b/miscutils/last_fancy.c
index 7e61b7691..dc09b65fb 100644
--- a/miscutils/last_fancy.c
+++ b/miscutils/last_fancy.c
@@ -161,11 +161,10 @@ int last_main(int argc UNUSED_PARAM, char **argv)
         time_t boot_time;
         time_t down_time;
         int file;
-        unsigned opt;
         smallint going_down;
         smallint boot_down;
 
-        opt = getopt32(argv, "Wf:" /* "H" */, &filename);
+        /*opt =*/ getopt32(argv, "Wf:" /* "H" */, &filename);
 #ifdef BUT_UTIL_LINUX_LAST_HAS_NO_SUCH_OPT
         if (opt & LAST_OPT_H) {
                 /* Print header line */
diff --git a/miscutils/makedevs.c b/miscutils/makedevs.c
index 8cca83882..c945a1352 100644
--- a/miscutils/makedevs.c
+++ b/miscutils/makedevs.c
@@ -38,7 +38,7 @@
 //usage:#define makedevs_full_usage "\n\n"
 //usage:       "Create a range of special files as specified in a device table.\n"
 //usage:       "Device table entries take the form of:\n"
-//usage:       "<type> <mode> <uid> <gid> <major> <minor> <start> <inc> <count>\n"
+//usage:       "<name> <type> <mode> <uid> <gid> <major> <minor> <start> <inc> <count>\n"
 //usage:       "Where name is the file name, type can be one of:\n"
 //usage:       "        f       Regular file\n"
 //usage:       "        d       Directory\n"
diff --git a/miscutils/setserial.c b/miscutils/setserial.c
new file mode 100644
index 000000000..2951b987d
--- /dev/null
+++ b/miscutils/setserial.c
@@ -0,0 +1,763 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * setserial implementation for busybox
+ *
+ *
+ * Copyright (C) 2011 Marek Bečka <yuen@klacno.sk>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ */
+
+//config:config SETSERIAL
+//config:       bool "setserial"
+//config:       default y
+//config:       depends on PLATFORM_LINUX
+//config:       help
+//config:         Retrieve or set Linux serial port.
+
+//applet:IF_SETSERIAL(APPLET(setserial, BB_DIR_BIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_SETSERIAL) += setserial.o
+
+#include "libbb.h"
+#include <assert.h>
+
+#ifndef PORT_UNKNOWN
+# define PORT_UNKNOWN            0
+#endif
+#ifndef PORT_8250
+# define PORT_8250               1
+#endif
+#ifndef PORT_16450
+# define PORT_16450              2
+#endif
+#ifndef PORT_16550
+# define PORT_16550              3
+#endif
+#ifndef PORT_16550A
+# define PORT_16550A             4
+#endif
+#ifndef PORT_CIRRUS
+# define PORT_CIRRUS             5
+#endif
+#ifndef PORT_16650
+# define PORT_16650              6
+#endif
+#ifndef PORT_16650V2
+# define PORT_16650V2            7
+#endif
+#ifndef PORT_16750
+# define PORT_16750              8
+#endif
+#ifndef PORT_STARTECH
+# define PORT_STARTECH           9
+#endif
+#ifndef PORT_16C950
+# define PORT_16C950            10
+#endif
+#ifndef PORT_16654
+# define PORT_16654             11
+#endif
+#ifndef PORT_16850
+# define PORT_16850             12
+#endif
+#ifndef PORT_RSA
+# define PORT_RSA               13
+#endif
+#ifndef PORT_NS16550A
+# define PORT_NS16550A          14
+#endif
+#ifndef PORT_XSCALE
+# define PORT_XSCALE            15
+#endif
+#ifndef PORT_RM9000
+# define PORT_RM9000            16
+#endif
+#ifndef PORT_OCTEON
+# define PORT_OCTEON            17
+#endif
+#ifndef PORT_AR7
+# define PORT_AR7               18
+#endif
+#ifndef PORT_U6_16550A
+# define PORT_U6_16550A         19
+#endif
+
+#ifndef ASYNCB_HUP_NOTIFY
+# define ASYNCB_HUP_NOTIFY       0
+#endif
+#ifndef ASYNCB_FOURPORT
+# define ASYNCB_FOURPORT         1
+#endif
+#ifndef ASYNCB_SAK
+# define ASYNCB_SAK              2
+#endif
+#ifndef ASYNCB_SPLIT_TERMIOS
+# define ASYNCB_SPLIT_TERMIOS    3
+#endif
+#ifndef ASYNCB_SPD_HI
+# define ASYNCB_SPD_HI           4
+#endif
+#ifndef ASYNCB_SPD_VHI
+# define ASYNCB_SPD_VHI          5
+#endif
+#ifndef ASYNCB_SKIP_TEST
+# define ASYNCB_SKIP_TEST        6
+#endif
+#ifndef ASYNCB_AUTO_IRQ
+# define ASYNCB_AUTO_IRQ         7
+#endif
+#ifndef ASYNCB_SESSION_LOCKOUT
+# define ASYNCB_SESSION_LOCKOUT  8
+#endif
+#ifndef ASYNCB_PGRP_LOCKOUT
+# define ASYNCB_PGRP_LOCKOUT     9
+#endif
+#ifndef ASYNCB_CALLOUT_NOHUP
+# define ASYNCB_CALLOUT_NOHUP   10
+#endif
+#ifndef ASYNCB_SPD_SHI
+# define ASYNCB_SPD_SHI         12
+#endif
+#ifndef ASYNCB_LOW_LATENCY
+# define ASYNCB_LOW_LATENCY     13
+#endif
+#ifndef ASYNCB_BUGGY_UART
+# define ASYNCB_BUGGY_UART      14
+#endif
+
+#ifndef ASYNC_HUP_NOTIFY
+# define ASYNC_HUP_NOTIFY       (1U << ASYNCB_HUP_NOTIFY)
+#endif
+#ifndef ASYNC_FOURPORT
+# define ASYNC_FOURPORT         (1U << ASYNCB_FOURPORT)
+#endif
+#ifndef ASYNC_SAK
+# define ASYNC_SAK              (1U << ASYNCB_SAK)
+#endif
+#ifndef ASYNC_SPLIT_TERMIOS
+# define ASYNC_SPLIT_TERMIOS    (1U << ASYNCB_SPLIT_TERMIOS)
+#endif
+#ifndef ASYNC_SPD_HI
+# define ASYNC_SPD_HI           (1U << ASYNCB_SPD_HI)
+#endif
+#ifndef ASYNC_SPD_VHI
+# define ASYNC_SPD_VHI          (1U << ASYNCB_SPD_VHI)
+#endif
+#ifndef ASYNC_SKIP_TEST
+# define ASYNC_SKIP_TEST        (1U << ASYNCB_SKIP_TEST)
+#endif
+#ifndef ASYNC_AUTO_IRQ
+# define ASYNC_AUTO_IRQ         (1U << ASYNCB_AUTO_IRQ)
+#endif
+#ifndef ASYNC_SESSION_LOCKOUT
+# define ASYNC_SESSION_LOCKOUT  (1U << ASYNCB_SESSION_LOCKOUT)
+#endif
+#ifndef ASYNC_PGRP_LOCKOUT
+# define ASYNC_PGRP_LOCKOUT     (1U << ASYNCB_PGRP_LOCKOUT)
+#endif
+#ifndef ASYNC_CALLOUT_NOHUP
+# define ASYNC_CALLOUT_NOHUP    (1U << ASYNCB_CALLOUT_NOHUP)
+#endif
+#ifndef ASYNC_SPD_SHI
+# define ASYNC_SPD_SHI          (1U << ASYNCB_SPD_SHI)
+#endif
+#ifndef ASYNC_LOW_LATENCY
+# define ASYNC_LOW_LATENCY      (1U << ASYNCB_LOW_LATENCY)
+#endif
+#ifndef ASYNC_BUGGY_UART
+# define ASYNC_BUGGY_UART       (1U << ASYNCB_BUGGY_UART)
+#endif
+
+#ifndef ASYNC_SPD_CUST
+# define ASYNC_SPD_CUST         (ASYNC_SPD_HI|ASYNC_SPD_VHI)
+#endif
+#ifndef ASYNC_SPD_WARP
+# define ASYNC_SPD_WARP         (ASYNC_SPD_HI|ASYNC_SPD_SHI)
+#endif
+#ifndef ASYNC_SPD_MASK
+# define ASYNC_SPD_MASK         (ASYNC_SPD_HI|ASYNC_SPD_VHI|ASYNC_SPD_SHI)
+#endif
+
+#ifndef ASYNC_CLOSING_WAIT_INF
+# define ASYNC_CLOSING_WAIT_INF         0
+#endif
+#ifndef ASYNC_CLOSING_WAIT_NONE
+# define ASYNC_CLOSING_WAIT_NONE        65535
+#endif
+
+#ifndef _LINUX_SERIAL_H
+struct serial_struct {
+        int     type;
+        int     line;
+        unsigned int    port;
+        int     irq;
+        int     flags;
+        int     xmit_fifo_size;
+        int     custom_divisor;
+        int     baud_base;
+        unsigned short  close_delay;
+        char    io_type;
+        char    reserved_char[1];
+        int     hub6;
+        unsigned short  closing_wait; /* time to wait before closing */
+        unsigned short  closing_wait2; /* no longer used... */
+        unsigned char   *iomem_base;
+        unsigned short  iomem_reg_shift;
+        unsigned int    port_high;
+        unsigned long   iomap_base;     /* cookie passed into ioremap */
+};
+#endif
+
+//usage:#define setserial_trivial_usage
+//usage:        "[-gabGvzV] DEVICE [PARAMETER [ARG]]..."
+//usage:#define setserial_full_usage "\n\n"
+//usage:        "Request or set Linux serial port information\n\n"
+//usage:        "Options:\n"
+//usage:        "       -g      Interpret parameters as list of devices for reporting"
+//usage:        "       -a      Print all available information\n"
+//usage:        "       -b      Print summary information\n"
+//usage:        "       -G      Print in form which can be fed back\n"
+//usage:        "               to setserial as command line parameters\n"
+//usage:        "       -z      Zero out serial flags before setting\n"
+//usage:        "       -v      Verbose\n"
+//usage:        "\n"
+//usage:        "Parameters: (* = takes an argument, ^ = can be turned off by preceding ^)\n"
+//usage:        "       *port, *irq, *divisor, *uart, *baund_base, *close_delay, *closing_wait,\n"
+//usage:        "       ^fourport, ^auto_irq, ^skip_test, ^sak, ^session_lockout, ^pgrp_lockout,\n"
+//usage:        "       ^callout_nohup, ^split_termios, ^hup_notify, ^low_latency, autoconfig,\n"
+//usage:        "       spd_normal, spd_hi, spd_vhi, spd_shi, spd_warp, spd_cust\n"
+//usage:        "\n"
+//usage:        "UART types:\n"
+//usage:        "       unknown, 8250, 16450, 16550, 16550A, Cirrus, 16650, 16650V2, 16750,\n"
+//usage:        "       16950, 16954, 16654, 16850, RSA, NS16550A, XSCALE, RM9000, OCTEON, AR7,\n"
+//usage:        "       U6_16550A"
+
+#define OPT_PRINT_SUMMARY       (1 << 0)
+#define OPT_PRINT_FEDBACK       (1 << 1)
+#define OPT_PRINT_ALL           (1 << 2)
+#define OPT_VERBOSE             (1 << 3)
+#define OPT_ZERO                (1 << 4)
+#define OPT_GET                 (1 << 5)
+
+#define OPT_MODE_MASK \
+        (OPT_PRINT_ALL | OPT_PRINT_SUMMARY | OPT_PRINT_FEDBACK)
+
+enum print_mode
+{
+        PRINT_NORMAL  = 0,
+        PRINT_SUMMARY = (1 << 0),
+        PRINT_FEDBACK = (1 << 1),
+        PRINT_ALL     = (1 << 2),
+};
+
+#define CTL_SET                 (1 << 0)
+#define CTL_CONFIG              (1 << 1)
+#define CTL_GET                 (1 << 2)
+#define CTL_CLOSE               (1 << 3)
+#define CTL_NODIE               (1 << 4)
+
+static const char serial_types[] =
+        "unknown\0"             /* 0 */
+        "8250\0"                /* 1 */
+        "16450\0"               /* 2 */
+        "16550\0"               /* 3 */
+        "16550A\0"              /* 4 */
+        "Cirrus\0"              /* 5 */
+        "16650\0"               /* 6 */
+        "16650V2\0"             /* 7 */
+        "16750\0"               /* 8 */
+        "16950\0"               /* 9 UNIMPLEMENTED: also know as "16950/954" */
+        "16954\0"               /* 10 */
+        "16654\0"               /* 11 */
+        "16850\0"               /* 12 */
+        "RSA\0"                 /* 13 */
+#ifndef SETSERIAL_BASE
+        "NS16550A\0"            /* 14 */
+        "XSCALE\0"              /* 15 */
+        "RM9000\0"              /* 16 */
+        "OCTEON\0"              /* 17 */
+        "AR7\0"                 /* 18 */
+        "U6_16550A\0"           /* 19 */
+#endif
+;
+
+#ifndef SETSERIAL_BASE
+# define MAX_SERIAL_TYPE        19
+#else
+# define MAX_SERIAL_TYPE        13
+#endif
+
+static const char commands[] =
+        "spd_normal\0"
+        "spd_hi\0"
+        "spd_vhi\0"
+        "spd_shi\0"
+        "spd_warp\0"
+        "spd_cust\0"
+
+        "sak\0"
+        "fourport\0"
+        "hup_notify\0"
+        "skip_test\0"
+        "auto_irq\0"
+        "split_termios\0"
+        "session_lockout\0"
+        "pgrp_lockout\0"
+        "callout_nohup\0"
+        "low_latency\0"
+
+        "port\0"
+        "irq\0"
+        "divisor\0"
+        "uart\0"
+        "baund_base\0"
+        "close_delay\0"
+        "closing_wait\0"
+
+        "autoconfig\0"
+;
+
+enum
+{
+        CMD_SPD_NORMAL = 0,
+        CMD_SPD_HI,
+        CMD_SPD_VHI,
+        CMD_SPD_SHI,
+        CMD_SPD_WARP,
+        CMD_SPD_CUST,
+
+        CMD_FLAG_SAK,
+        CMD_FLAG_FOURPORT,
+        CMD_FLAG_NUP_NOTIFY,
+        CMD_FLAG_SKIP_TEST,
+        CMD_FLAG_AUTO_IRQ,
+        CMD_FLAG_SPLIT_TERMIOS,
+        CMD_FLAG_SESSION_LOCKOUT,
+        CMD_FLAG_PGRP_LOCKOUT,
+        CMD_FLAG_CALLOUT_NOHUP,
+        CMD_FLAG_LOW_LATENCY,
+
+        CMD_PORT,
+        CMD_IRQ,
+        CMD_DIVISOR,
+        CMD_UART,
+        CMD_BASE,
+        CMD_DELAY,
+        CMD_WAIT,
+
+        CMD_AUTOCONFIG,
+
+        CMD_FLAG_FIRST = CMD_FLAG_SAK,
+        CMD_FLAG_LAST  = CMD_FLAG_LOW_LATENCY,
+};
+
+static bool cmd_noprint(int cmd)
+{
+        return (cmd >= CMD_FLAG_SKIP_TEST && cmd <= CMD_FLAG_CALLOUT_NOHUP);
+}
+
+static bool cmd_is_flag(int cmd)
+{
+        return (cmd >= CMD_FLAG_FIRST && cmd <= CMD_FLAG_LAST);
+}
+
+static bool cmd_need_arg(int cmd)
+{
+        return (cmd >= CMD_PORT && cmd <= CMD_WAIT);
+}
+
+#define ALL_SPD ( \
+        ASYNC_SPD_HI | ASYNC_SPD_VHI | ASYNC_SPD_SHI | \
+        ASYNC_SPD_WARP | ASYNC_SPD_CUST \
+        )
+
+#define ALL_FLAGS ( \
+        ASYNC_SAK | ASYNC_FOURPORT | ASYNC_HUP_NOTIFY | \
+        ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ | ASYNC_SPLIT_TERMIOS | \
+        ASYNC_SESSION_LOCKOUT | ASYNC_PGRP_LOCKOUT | ASYNC_CALLOUT_NOHUP | \
+        ASYNC_LOW_LATENCY \
+        )
+
+#if (ALL_SPD | ALL_FLAGS) > 0xffff
+# error "Unexpected flags size"
+#endif
+
+static const uint16_t setbits[CMD_FLAG_LAST + 1] =
+{
+        0,
+        ASYNC_SPD_HI,
+        ASYNC_SPD_VHI,
+        ASYNC_SPD_SHI,
+        ASYNC_SPD_WARP,
+        ASYNC_SPD_CUST,
+
+        ASYNC_SAK,
+        ASYNC_FOURPORT,
+        ASYNC_HUP_NOTIFY,
+        ASYNC_SKIP_TEST,
+        ASYNC_AUTO_IRQ,
+        ASYNC_SPLIT_TERMIOS,
+        ASYNC_SESSION_LOCKOUT,
+        ASYNC_PGRP_LOCKOUT,
+        ASYNC_CALLOUT_NOHUP,
+        ASYNC_LOW_LATENCY
+};
+
+static const char STR_INFINITE[] = "infinite";
+static const char STR_NONE[] = "none";
+
+static const char *uart_type(int type)
+{
+        if (type > MAX_SERIAL_TYPE)
+                return "undefined";
+
+        return nth_string(serial_types, type);
+}
+
+/* libbb candidate */
+static int index_in_strings_case_insensitive(const char *strings, const char *key)
+{
+        int idx = 0;
+
+        while (*strings) {
+                if (strcasecmp(strings, key) == 0) {
+                        return idx;
+                }
+                strings += strlen(strings) + 1; /* skip NUL */
+                idx++;
+        }
+        return -1;
+}
+
+static int uart_id(const char *name)
+{
+        return index_in_strings_case_insensitive(serial_types, name);
+}
+
+static const char *get_spd(int flags, enum print_mode mode)
+{
+        int idx;
+
+        switch (flags & ASYNC_SPD_MASK) {
+        case ASYNC_SPD_HI:
+                idx = CMD_SPD_HI;
+                break;
+        case ASYNC_SPD_VHI:
+                idx = CMD_SPD_VHI;
+                break;
+        case ASYNC_SPD_SHI:
+                idx = CMD_SPD_SHI;
+                break;
+        case ASYNC_SPD_WARP:
+                idx = CMD_SPD_WARP;
+                break;
+        case ASYNC_SPD_CUST:
+                idx = CMD_SPD_CUST;
+                break;
+        default:
+                if (mode < PRINT_FEDBACK)
+                        return NULL;
+                idx = CMD_SPD_NORMAL;
+        }
+
+        return nth_string(commands, idx);
+}
+
+static int get_numeric(const char *arg)
+{
+        return bb_strtol(arg, NULL, 0);
+}
+
+static int get_wait(const char *arg)
+{
+        if (strcasecmp(arg, STR_NONE) == 0)
+                return ASYNC_CLOSING_WAIT_NONE;
+
+        if (strcasecmp(arg, STR_INFINITE) == 0)
+                return ASYNC_CLOSING_WAIT_INF;
+
+        return get_numeric(arg);
+}
+
+static int get_uart(const char *arg)
+{
+        int uart = uart_id(arg);
+
+        if (uart < 0)
+                bb_error_msg_and_die("illegal UART type: %s", arg);
+
+        return uart;
+}
+
+static int serial_open(const char *dev, bool quiet)
+{
+        int fd;
+
+        fd = device_open(dev, O_RDWR | O_NONBLOCK);
+        if (fd < 0 && !quiet)
+                bb_simple_perror_msg(dev);
+
+        return fd;
+}
+
+static int serial_ctl(int fd, int ops, struct serial_struct *serinfo)
+{
+        int ret = 0;
+        const char *err;
+
+        if (ops & CTL_SET) {
+                ret = ioctl(fd, TIOCSSERIAL, serinfo);
+                if (ret < 0) {
+                        err = "can't set serial info";
+                        goto fail;
+                }
+        }
+
+        if (ops & CTL_CONFIG) {
+                ret = ioctl(fd, TIOCSERCONFIG);
+                if (ret < 0) {
+                        err = "can't autoconfigure port";
+                        goto fail;
+                }
+        }
+
+        if (ops & CTL_GET) {
+                ret = ioctl(fd, TIOCGSERIAL, serinfo);
+                if (ret < 0) {
+                        err = "can't get serial info";
+                        goto fail;
+                }
+        }
+ nodie:
+        if (ops & CTL_CLOSE)
+                close(fd);
+
+        return ret;
+ fail:
+        bb_simple_perror_msg(err);
+        if (ops & CTL_NODIE)
+                goto nodie;
+        exit(EXIT_FAILURE);
+}
+
+static void print_flag(const char **prefix, const char *flag)
+{
+        printf("%s%s", *prefix, flag);
+        *prefix = " ";
+}
+
+static void print_serial_flags(int serial_flags, enum print_mode mode,
+                                const char *prefix, const char *postfix)
+{
+        int i;
+        const char *spd, *pr;
+
+        pr = prefix;
+
+        spd = get_spd(serial_flags, mode);
+        if (spd)
+                print_flag(&pr, spd);
+
+        for (i = CMD_FLAG_FIRST; i <= CMD_FLAG_LAST; i++) {
+                if ((serial_flags & setbits[i])
+                 && (mode > PRINT_SUMMARY || !cmd_noprint(i))
+                ) {
+                        print_flag(&pr, nth_string(commands, i));
+                }
+        }
+
+        puts(pr == prefix ? "" : postfix);
+}
+
+static void print_closing_wait(unsigned int closing_wait)
+{
+        switch (closing_wait) {
+        case ASYNC_CLOSING_WAIT_NONE:
+                puts(STR_NONE);
+                break;
+        case ASYNC_CLOSING_WAIT_INF:
+                puts(STR_INFINITE);
+                break;
+        default:
+                printf("%u\n", closing_wait);
+        }
+}
+
+static void serial_get(const char *device, enum print_mode mode)
+{
+        int fd, ret;
+        const char *uart, *prefix, *postfix;
+        struct serial_struct serinfo;
+
+        fd = serial_open(device, /*quiet:*/ mode == PRINT_SUMMARY);
+        if (fd < 0)
+                return;
+
+        ret = serial_ctl(fd, CTL_GET | CTL_CLOSE | CTL_NODIE, &serinfo);
+        if (ret < 0)
+                return;
+
+        uart = uart_type(serinfo.type);
+        prefix = ", Flags: ";
+        postfix = "";
+
+        switch (mode) {
+        case PRINT_NORMAL:
+                printf("%s, UART: %s, Port: 0x%.4x, IRQ: %d",
+                        device, uart, serinfo.port, serinfo.irq);
+                break;
+        case PRINT_SUMMARY:
+                if (!serinfo.type)
+                        return;
+                printf("%s at 0x%.4x (irq = %d) is a %s",
+                        device, serinfo.port, serinfo.irq, uart);
+                prefix = " (";
+                postfix = ")";
+                break;
+        case PRINT_FEDBACK:
+                printf("%s uart %s port 0x%.4x irq %d baud_base %d", device,
+                        uart, serinfo.port, serinfo.irq, serinfo.baud_base);
+                prefix = " ";
+                break;
+        case PRINT_ALL:
+                printf("%s, Line %d, UART: %s, Port: 0x%.4x, IRQ: %d\n",
+                        device, serinfo.line, uart, serinfo.port, serinfo.irq);
+                printf("\tBaud_base: %d, close_delay: %u, divisor: %d\n",
+                        serinfo.baud_base, serinfo.close_delay,
+                        serinfo.custom_divisor);
+                printf("\tclosing_wait: ");
+                print_closing_wait(serinfo.closing_wait);
+                prefix = "\tFlags: ";
+                postfix = "\n";
+                break;
+        default:
+                assert(0);
+        }
+
+        print_serial_flags(serinfo.flags, mode, prefix, postfix);
+}
+
+static int find_cmd(const char *cmd)
+{
+        int idx;
+
+        idx = index_in_strings_case_insensitive(commands, cmd);
+        if (idx < 0)
+                bb_error_msg_and_die("invalid flag: %s", cmd);
+
+        return idx;
+}
+
+static void serial_set(char **arg, int opts)
+{
+        struct serial_struct serinfo;
+        int cmd;
+        const char *word;
+        int fd;
+
+        fd = serial_open(*arg++, /*quiet:*/ false);
+        if (fd < 0)
+                exit(201);
+
+        serial_ctl(fd, CTL_GET, &serinfo);
+
+        if (opts & OPT_ZERO)
+                serinfo.flags = 0;
+
+        while (*arg) {
+                int invert;
+
+                word = *arg++;
+                invert = (*word == '^');
+                word += invert;
+
+                cmd = find_cmd(word);
+
+                if (*arg == NULL && cmd_need_arg(cmd))
+                        bb_error_msg_and_die(bb_msg_requires_arg, word);
+
+                if (invert && !cmd_is_flag(cmd))
+                        bb_error_msg_and_die("can't invert %s", word);
+
+                switch (cmd) {
+                case CMD_SPD_NORMAL:
+                case CMD_SPD_HI:
+                case CMD_SPD_VHI:
+                case CMD_SPD_SHI:
+                case CMD_SPD_WARP:
+                case CMD_SPD_CUST:
+                        serinfo.flags &= ~ASYNC_SPD_MASK;
+                        /* fallthrough */
+                case CMD_FLAG_SAK:
+                case CMD_FLAG_FOURPORT:
+                case CMD_FLAG_NUP_NOTIFY:
+                case CMD_FLAG_SKIP_TEST:
+                case CMD_FLAG_AUTO_IRQ:
+                case CMD_FLAG_SPLIT_TERMIOS:
+                case CMD_FLAG_SESSION_LOCKOUT:
+                case CMD_FLAG_PGRP_LOCKOUT:
+                case CMD_FLAG_CALLOUT_NOHUP:
+                case CMD_FLAG_LOW_LATENCY:
+                        if (invert)
+                                serinfo.flags &= ~setbits[cmd];
+                        else
+                                serinfo.flags |= setbits[cmd];
+                        break;
+                case CMD_PORT:
+                        serinfo.port = get_numeric(*arg++);
+                        break;
+                case CMD_IRQ:
+                        serinfo.irq = get_numeric(*arg++);
+                        break;
+                case CMD_DIVISOR:
+                        serinfo.custom_divisor = get_numeric(*arg++);
+                        break;
+                case CMD_UART:
+                        serinfo.type = get_uart(*arg++);
+                        break;
+                case CMD_BASE:
+                        serinfo.baud_base = get_numeric(*arg++);
+                        break;
+                case CMD_DELAY:
+                        serinfo.close_delay = get_numeric(*arg++);
+                        break;
+                case CMD_WAIT:
+                        serinfo.closing_wait = get_wait(*arg++);
+                        break;
+                case CMD_AUTOCONFIG:
+                        serial_ctl(fd, CTL_SET | CTL_CONFIG | CTL_GET, &serinfo);
+                        break;
+                default:
+                        assert(0);
+                }
+        }
+
+        serial_ctl(fd, CTL_SET | CTL_CLOSE, &serinfo);
+}
+
+int setserial_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int setserial_main(int argc UNUSED_PARAM, char **argv)
+{
+        int opts;
+
+        opt_complementary = "-1:b-aG:G-ab:a-bG";
+        opts = getopt32(argv, "bGavzg");
+        argv += optind;
+
+        if (!argv[1]) /* one arg only? */
+                opts |= OPT_GET;
+
+        if (!(opts & OPT_GET)) {
+                serial_set(argv, opts);
+                argv[1] = NULL;
+        }
+
+        if (opts & (OPT_VERBOSE | OPT_GET)) {
+                do {
+                        serial_get(*argv++, opts & OPT_MODE_MASK);
+                } while (*argv);
+        }
+
+        return EXIT_SUCCESS;
+}
diff --git a/miscutils/ubi_attach_detach.c b/miscutils/ubi_tools.c
index 9007f8c3f..fc7f38c5d 100644
--- a/miscutils/ubi_attach_detach.c
+++ b/miscutils/ubi_tools.c
@@ -37,18 +37,27 @@
 //config:       select PLATFORM_LINUX
 //config:       help
 //config:         Resize a UBI volume.
+//config:
+//config:config UBIUPDATEVOL
+//config:       bool "ubiupdatevol"
+//config:       default y
+//config:       select PLATFORM_LINUX
+//config:       help
+//config:         Update a UBI volume.
 
 //applet:IF_UBIATTACH(APPLET_ODDNAME(ubiattach, ubi_tools, BB_DIR_USR_SBIN, BB_SUID_DROP, ubiattach))
 //applet:IF_UBIDETACH(APPLET_ODDNAME(ubidetach, ubi_tools, BB_DIR_USR_SBIN, BB_SUID_DROP, ubidetach))
 //applet:IF_UBIMKVOL(APPLET_ODDNAME(ubimkvol, ubi_tools, BB_DIR_USR_SBIN, BB_SUID_DROP, ubimkvol))
 //applet:IF_UBIRMVOL(APPLET_ODDNAME(ubirmvol, ubi_tools, BB_DIR_USR_SBIN, BB_SUID_DROP, ubirmvol))
 //applet:IF_UBIRSVOL(APPLET_ODDNAME(ubirsvol, ubi_tools, BB_DIR_USR_SBIN, BB_SUID_DROP, ubirsvol))
+//applet:IF_UBIUPDATEVOL(APPLET_ODDNAME(ubiupdatevol, ubi_tools, BB_DIR_USR_SBIN, BB_SUID_DROP, ubiupdatevol))
 
-//kbuild:lib-$(CONFIG_UBIATTACH) += ubi_attach_detach.o
-//kbuild:lib-$(CONFIG_UBIDETACH) += ubi_attach_detach.o
-//kbuild:lib-$(CONFIG_UBIMKVOL)  += ubi_attach_detach.o
-//kbuild:lib-$(CONFIG_UBIRMVOL)  += ubi_attach_detach.o
-//kbuild:lib-$(CONFIG_UBIRSVOL)  += ubi_attach_detach.o
+//kbuild:lib-$(CONFIG_UBIATTACH) += ubi_tools.o
+//kbuild:lib-$(CONFIG_UBIDETACH) += ubi_tools.o
+//kbuild:lib-$(CONFIG_UBIMKVOL)  += ubi_tools.o
+//kbuild:lib-$(CONFIG_UBIRMVOL)  += ubi_tools.o
+//kbuild:lib-$(CONFIG_UBIRSVOL)  += ubi_tools.o
+//kbuild:lib-$(CONFIG_UBIUPDATEVOL) += ubi_tools.o
 
 #include "libbb.h"
 #include <mtd/ubi-user.h>
@@ -66,6 +75,7 @@
 #define do_mkvol  (ENABLE_UBIMKVOL  && applet_name[3] == 'm')
 #define do_rmvol  (ENABLE_UBIRMVOL  && applet_name[4] == 'm')
 #define do_rsvol  (ENABLE_UBIRSVOL  && applet_name[4] == 's')
+#define do_update (ENABLE_UBIUPDATEVOL && applet_name[3] == 'u')
 
 //usage:#define ubiattach_trivial_usage
 //usage:       "-m MTD_NUM [-d UBI_NUM] UBI_CTRL_DEV"
@@ -85,7 +95,7 @@
 //usage:#define ubimkvol_trivial_usage
 //usage:       "UBI_DEVICE -N NAME -s SIZE"
 //usage:#define ubimkvol_full_usage "\n\n"
-//usage:       "Create UBI Volume\n"
+//usage:       "Create UBI volume\n"
 //usage:     "\nOptions:"
 //usage:     "\n        -a ALIGNMENT    Volume alignment (default 1)"
 //usage:     "\n        -n VOLID        Volume ID, if not specified, it"
@@ -97,17 +107,26 @@
 //usage:#define ubirmvol_trivial_usage
 //usage:       "UBI_DEVICE -n VOLID"
 //usage:#define ubirmvol_full_usage "\n\n"
-//usage:       "Remove UBI Volume\n"
+//usage:       "Remove UBI volume\n"
 //usage:     "\nOptions:"
 //usage:     "\n        -n VOLID        Volume ID"
 //usage:
 //usage:#define ubirsvol_trivial_usage
-//usage:       "UBI_DEVICE -N NAME -s SIZE"
+//usage:       "UBI_DEVICE -n VOLID -s SIZE"
 //usage:#define ubirsvol_full_usage "\n\n"
-//usage:       "Resize UBI Volume\n"
+//usage:       "Resize UBI volume\n"
 //usage:     "\nOptions:"
-//usage:     "\n        -N NAME         Volume name"
+//usage:     "\n        -n VOLID        Volume ID to resize"
 //usage:     "\n        -s SIZE         Size in bytes"
+//usage:
+//usage:#define ubiupdatevol_trivial_usage
+//usage:       "UBI_DEVICE [IMG_FILE]"
+//usage:#define ubiupdatevol_full_usage "\n\n"
+//usage:       "Update UBI volume\n"
+//usage:     "\nOptions:"
+//usage:     "\n      -t      Truncate UBI volume"
+//usage:     "\n      -s SIZE Bytes in input (if reading stdin)"
+
 
 int ubi_tools_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int ubi_tools_main(int argc UNUSED_PARAM, char **argv)
@@ -124,8 +143,8 @@ int ubi_tools_main(int argc UNUSED_PARAM, char **argv)
         int alignment = 1;
         char *type = NULL;
 
-        opt_complementary = "=1:m+:d+:n+:s+:a+";
-        opts = getopt32(argv, "m:d:n:N:s:a:t:",
+        opt_complementary = "-1:m+:d+:n+:s+:a+";
+        opts = getopt32(argv, "m:d:n:N:s:a:t::",
                         &mtd_num, &dev_num, &vol_id,
                         &vol_name, &size_bytes, &alignment, &type
         );
@@ -166,7 +185,7 @@ int ubi_tools_main(int argc UNUSED_PARAM, char **argv)
 
                 memset(&req, 0, sizeof(req));
                 req.vol_id = vol_id;
-                if (opts & OPTION_t) {
+                if ((opts & OPTION_t) && type) {
                         if (type[0] == 's')
                                 req.vol_type = UBI_STATIC_VOLUME;
                         else
@@ -199,6 +218,57 @@ int ubi_tools_main(int argc UNUSED_PARAM, char **argv)
                 req.vol_id = vol_id;
 
                 xioctl(fd, UBI_IOCRSVOL, &req);
+        } else
+        if (do_update) {
+                long long bytes;
+
+                if (opts & OPTION_t) {
+                        // truncate the volume by starting an update for size 0
+                        bytes = 0;
+                        xioctl(fd, UBI_IOCVOLUP, &bytes);
+                }
+                else {
+                        struct stat st;
+                        char buf[sizeof("/sys/class/ubi/ubi%d_%d/usable_eb_size") + 2 * sizeof(int)*3];
+                        int input_fd;
+                        unsigned ubinum, volnum;
+                        unsigned leb_size;
+                        ssize_t len;
+                        char *input_data;
+
+                        // Make assumption that device not is in normal format.
+                        // Removes need for scanning sysfs tree as full libubi does
+                        if (sscanf(ubi_ctrl, "/dev/ubi%u_%u", &ubinum, &volnum) != 2)
+                                bb_error_msg_and_die("%s volume node not in correct format", "UBI");
+
+                        sprintf(buf, "/sys/class/ubi/ubi%u_%u/usable_eb_size", ubinum, volnum);
+                        if (open_read_close(buf, buf, sizeof(buf)) <= 0)
+                                bb_error_msg_and_die("%s could not get LEB size", "UBI");
+                        if (sscanf(buf, "%u", &leb_size) != 1)
+                                bb_error_msg_and_die("%s could not get LEB size", "UBI");
+
+                        if (opts & OPTION_s) {
+                                input_fd = 0;
+                        } else {
+                                if (!argv[optind+1])
+                                        bb_show_usage();
+                                xstat(argv[optind+1], &st);
+                                size_bytes = st.st_size;
+                                input_fd = xopen(argv[optind+1], O_RDONLY);
+                        }
+
+                        bytes = size_bytes;
+                        xioctl(fd, UBI_IOCVOLUP, &bytes);
+
+                        input_data = xmalloc(leb_size);
+                        while ((len = full_read(input_fd, input_data, leb_size)) > 0) {
+                                xwrite(fd, input_data, len);
+                        }
+                        if (len < 0)
+                                bb_error_msg_and_die("%s volume update failed", "UBI");
+                        if (ENABLE_FEATURE_CLEAN_UP)
+                                close(input_fd);
+                }
         }
 
         if (ENABLE_FEATURE_CLEAN_UP)
diff --git a/networking/ftpgetput.c b/networking/ftpgetput.c
index 66316e21f..f63df55f4 100644
--- a/networking/ftpgetput.c
+++ b/networking/ftpgetput.c
@@ -60,7 +60,7 @@ struct globals {
         FILE *control_stream;
         int verbose_flag;
         int do_continue;
-        char buf[1]; /* actually [BUFSZ] */
+        char buf[4]; /* actually [BUFSZ] */
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
 enum { BUFSZ = COMMON_BUFSIZE - offsetof(struct globals, buf) };
@@ -105,7 +105,7 @@ static int ftpcmd(const char *s1, const char *s2)
         }
 
         do {
-                strcpy(buf, "EOF");
+                strcpy(buf, "EOF"); /* for ftp_die */
                 if (fgets(buf, BUFSZ - 2, control_stream) == NULL) {
                         ftp_die(NULL);
                 }
@@ -316,7 +316,6 @@ static const char ftpgetput_longopts[] ALIGN1 =
 int ftpgetput_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int ftpgetput_main(int argc UNUSED_PARAM, char **argv)
 {
-        unsigned opt;
         const char *port = "ftp";
         /* socket to ftp server */
 
@@ -345,7 +344,7 @@ int ftpgetput_main(int argc UNUSED_PARAM, char **argv)
         applet_long_options = ftpgetput_longopts;
 #endif
         opt_complementary = "-2:vv:cc"; /* must have 2 to 3 params; -v and -c count */
-        opt = getopt32(argv, "cvu:p:P:", &user, &password, &port,
+        getopt32(argv, "cvu:p:P:", &user, &password, &port,
                                         &verbose_flag, &do_continue);
         argv += optind;
 
diff --git a/networking/httpd.c b/networking/httpd.c
index d6157aca2..d77342a2a 100644
--- a/networking/httpd.c
+++ b/networking/httpd.c
@@ -2424,7 +2424,7 @@ int httpd_main(int argc UNUSED_PARAM, char **argv)
                 salt[0] = '$';
                 salt[1] = '1';
                 salt[2] = '$';
-                crypt_make_salt(salt + 3, 4, 0);
+                crypt_make_salt(salt + 3, 4);
                 puts(pw_encrypt(pass, salt, 1));
                 return 0;
         }
diff --git a/networking/inetd.c b/networking/inetd.c
index 226a6491c..58ae089d1 100644
--- a/networking/inetd.c
+++ b/networking/inetd.c
@@ -1164,12 +1164,17 @@ int inetd_main(int argc UNUSED_PARAM, char **argv)
         sigaddset(&sa.sa_mask, SIGALRM);
         sigaddset(&sa.sa_mask, SIGCHLD);
         sigaddset(&sa.sa_mask, SIGHUP);
+//FIXME: explain why no SA_RESTART
+//FIXME: retry_network_setup is unsafe to run in signal handler (many reasons)!
         sa.sa_handler = retry_network_setup;
         sigaction_set(SIGALRM, &sa);
+//FIXME: reread_config_file is unsafe to run in signal handler(many reasons)!
         sa.sa_handler = reread_config_file;
         sigaction_set(SIGHUP, &sa);
+//FIXME: reap_child is unsafe to run in signal handler (uses stdio)!
         sa.sa_handler = reap_child;
         sigaction_set(SIGCHLD, &sa);
+//FIXME: clean_up_and_exit is unsafe to run in signal handler (uses stdio)!
         sa.sa_handler = clean_up_and_exit;
         sigaction_set(SIGTERM, &sa);
         sa.sa_handler = clean_up_and_exit;
diff --git a/networking/ntpd.c b/networking/ntpd.c
index e27dbaa6b..165673a1e 100644
--- a/networking/ntpd.c
+++ b/networking/ntpd.c
@@ -1745,7 +1745,7 @@ static NOINLINE void
 recv_and_process_client_pkt(void /*int fd*/)
 {
         ssize_t          size;
-        uint8_t          version;
+        //uint8_t          version;
         len_and_sockaddr *to;
         struct sockaddr  *from;
         msg_t            msg;
@@ -1793,7 +1793,7 @@ recv_and_process_client_pkt(void /*int fd*/)
         msg.m_rootdelay = d_to_sfp(G.rootdelay);
 //simple code does not do this, fix simple code!
         msg.m_rootdisp = d_to_sfp(G.rootdisp);
-        version = (query_status & VERSION_MASK); /* ... >> VERSION_SHIFT - done below instead */
+        //version = (query_status & VERSION_MASK); /* ... >> VERSION_SHIFT - done below instead */
         msg.m_refid = G.refid; // (version > (3 << VERSION_SHIFT)) ? G.refid : G.refid3;
 
         /* We reply from the local address packet was sent to,
diff --git a/networking/traceroute.c b/networking/traceroute.c
index 96f9d3472..85181ab8d 100644
--- a/networking/traceroute.c
+++ b/networking/traceroute.c
@@ -398,18 +398,23 @@ static len_and_sockaddr* dup_sockaddr(const len_and_sockaddr *lsa)
 
 
 static int
-wait_for_reply(len_and_sockaddr *from_lsa, struct sockaddr *to)
+wait_for_reply(len_and_sockaddr *from_lsa, struct sockaddr *to, unsigned *timestamp_us, int *left_ms)
 {
         struct pollfd pfd[1];
         int read_len = 0;
 
         pfd[0].fd = rcvsock;
         pfd[0].events = POLLIN;
-        if (safe_poll(pfd, 1, waittime * 1000) > 0) {
+        if (*left_ms >= 0 && safe_poll(pfd, 1, *left_ms) > 0) {
+                unsigned t;
+
                 read_len = recv_from_to(rcvsock,
                                 recv_pkt, sizeof(recv_pkt),
-                                /*flags:*/ 0,
+                                /*flags:*/ MSG_DONTWAIT,
                                 &from_lsa->u.sa, to, from_lsa->len);
+                t = monotonic_us();
+                *left_ms -= (t - *timestamp_us) / 1000;
+                *timestamp_us = t;
         }
 
         return read_len;
@@ -730,7 +735,7 @@ packet_ok(int read_len, len_and_sockaddr *from_lsa,
                         type, pr_type(type), icp->icmp6_code);
 
                 read_len -= sizeof(struct icmp6_hdr);
-                for (i = 0; i < read_len ; i++) {
+                for (i = 0; i < read_len; i++) {
                         if (i % 16 == 0)
                                 printf("%04x:", i);
                         if (i % 4 == 0)
@@ -819,7 +824,6 @@ print_delta_ms(unsigned t1p, unsigned t2p)
 static int
 common_traceroute_main(int op, char **argv)
 {
-        int i;
         int minpacket;
         int tos = 0;
         int max_ttl = 30;
@@ -973,6 +977,7 @@ common_traceroute_main(int op, char **argv)
 #if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE && defined IP_OPTIONS
                 if (lsrr > 0) {
                         unsigned char optlist[MAX_IPOPTLEN];
+                        unsigned size;
 
                         /* final hop */
                         gwlist[lsrr] = dest_lsa->u.sin.sin_addr.s_addr;
@@ -982,14 +987,14 @@ common_traceroute_main(int op, char **argv)
                         optlist[0] = IPOPT_NOP;
                         /* loose source route option */
                         optlist[1] = IPOPT_LSRR;
-                        i = lsrr * sizeof(gwlist[0]);
-                        optlist[2] = i + 3;
+                        size = lsrr * sizeof(gwlist[0]);
+                        optlist[2] = size + 3;
                         /* pointer to LSRR addresses */
                         optlist[3] = IPOPT_MINOFF;
-                        memcpy(optlist + 4, gwlist, i);
+                        memcpy(optlist + 4, gwlist, size);
 
                         if (setsockopt(sndsock, IPPROTO_IP, IP_OPTIONS,
-                                        (char *)optlist, i + sizeof(gwlist[0])) < 0) {
+                                        (char *)optlist, size + sizeof(gwlist[0])) < 0) {
                                 bb_perror_msg_and_die("IP_OPTIONS");
                         }
                 }
@@ -1103,28 +1108,34 @@ common_traceroute_main(int op, char **argv)
                 int unreachable = 0; /* counter */
                 int gotlastaddr = 0; /* flags */
                 int got_there = 0;
-                int first = 1;
 
                 printf("%2d", ttl);
                 for (probe = 0; probe < nprobes; ++probe) {
                         int read_len;
                         unsigned t1;
                         unsigned t2;
+                        int left_ms;
                         struct ip *ip;
 
-                        if (!first && pausemsecs > 0)
-                                usleep(pausemsecs * 1000);
                         fflush_all();
+                        if (probe != 0 && pausemsecs > 0)
+                                usleep(pausemsecs * 1000);
 
-                        t1 = monotonic_us();
                         send_probe(++seq, ttl);
+                        t2 = t1 = monotonic_us();
+
+                        left_ms = waittime * 1000;
+                        while ((read_len = wait_for_reply(from_lsa, to, &t2, &left_ms)) != 0) {
+                                int icmp_code;
+
+                                /* Recv'ed a packet, or read error */
+                                /* t2 = monotonic_us() - set by wait_for_reply */
 
-                        first = 0;
-                        while ((read_len = wait_for_reply(from_lsa, to)) != 0) {
-                                t2 = monotonic_us();
-                                i = packet_ok(read_len, from_lsa, to, seq);
+                                if (read_len < 0)
+                                        continue;
+                                icmp_code = packet_ok(read_len, from_lsa, to, seq);
                                 /* Skip short packet */
-                                if (i == 0)
+                                if (icmp_code == 0)
                                         continue;
 
                                 if (!gotlastaddr
@@ -1143,10 +1154,10 @@ common_traceroute_main(int op, char **argv)
                                                 printf(" (%d)", ip->ip_ttl);
 
                                 /* time exceeded in transit */
-                                if (i == -1)
+                                if (icmp_code == -1)
                                         break;
-                                i--;
-                                switch (i) {
+                                icmp_code--;
+                                switch (icmp_code) {
 #if ENABLE_TRACEROUTE6
                                 case ICMP6_DST_UNREACH_NOPORT << 8:
                                         got_there = 1;
@@ -1219,16 +1230,18 @@ common_traceroute_main(int op, char **argv)
                                         ++unreachable;
                                         break;
                                 default:
-                                        printf(" !<%d>", i);
+                                        printf(" !<%d>", icmp_code);
                                         ++unreachable;
                                         break;
                                 }
                                 break;
-                        }
+                        } /* while (wait and read a packet) */
+
                         /* there was no packet at all? */
                         if (read_len == 0)
                                 printf("  *");
-                }
+                } /* for (nprobes) */
+
                 bb_putchar('\n');
                 if (got_there
                  || (unreachable > 0 && unreachable >= nprobes - 1)
diff --git a/networking/udhcp/Config.src b/networking/udhcp/Config.src
index 9cd8cbbae..6bfa398ea 100644
--- a/networking/udhcp/Config.src
+++ b/networking/udhcp/Config.src
@@ -113,6 +113,14 @@ config FEATURE_UDHCP_RFC3397
           search lists via option 119, specified in RFC 3397,
           and SIP servers option 120, specified in RFC 3361.
 
+config FEATURE_UDHCP_8021Q
+        bool "Support for 802.1Q VLAN parameters"
+        default y
+        depends on UDHCPD || UDHCPC
+        help
+          If selected, both client and server will support passing of VLAN
+          ID and priority via options 132 and 133 as per 802.1Q.
+
 config UDHCPC_DEFAULT_SCRIPT
         string "Absolute path to config script"
         default "/usr/share/udhcpc/default.script"
diff --git a/networking/udhcp/common.c b/networking/udhcp/common.c
index 0a60261ab..70e34614c 100644
--- a/networking/udhcp/common.c
+++ b/networking/udhcp/common.c
@@ -55,6 +55,10 @@ const struct dhcp_optflag dhcp_optflags[] = {
         { OPTION_SIP_SERVERS                      , 0x78 }, /* DHCP_SIP_SERVERS   */
 #endif
         { OPTION_STATIC_ROUTES                    , 0x79 }, /* DHCP_STATIC_ROUTES */
+#if ENABLE_FEATURE_UDHCP_8021Q
+        { OPTION_U16                              , 0x84 }, /* DHCP_VLAN_ID       */
+        { OPTION_U8                               , 0x85 }, /* DHCP_VLAN_PRIORITY */
+#endif
         { OPTION_STATIC_ROUTES                    , 0xf9 }, /* DHCP_MS_STATIC_ROUTES */
         { OPTION_STRING                           , 0xfc }, /* DHCP_WPAD          */
 
@@ -118,6 +122,10 @@ const char dhcp_option_strings[] ALIGN1 =
 // doesn't work in udhcpd.conf since OPTION_STATIC_ROUTES
 // is not handled yet by "string->option" conversion code:
         "staticroutes" "\0"/* DHCP_STATIC_ROUTES  */
+#if ENABLE_FEATURE_UDHCP_8021Q
+        "vlanid" "\0"      /* DHCP_VLAN_ID        */
+        "vlanpriority" "\0"/* DHCP_VLAN_PRIORITY  */
+#endif
         "msstaticroutes""\0"/* DHCP_MS_STATIC_ROUTES */
         "wpad" "\0"        /* DHCP_WPAD           */
         ;
diff --git a/networking/udhcp/common.h b/networking/udhcp/common.h
index f8f18ff01..ad6991c94 100644
--- a/networking/udhcp/common.h
+++ b/networking/udhcp/common.h
@@ -145,6 +145,8 @@ enum {
 //#define DHCP_DOMAIN_SEARCH    0x77 /* RFC 3397. set of ASCIZ string, DNS-style compressed */
 //#define DHCP_SIP_SERVERS      0x78 /* RFC 3361. flag byte, then: 0: domain names, 1: IP addrs */
 //#define DHCP_STATIC_ROUTES    0x79 /* RFC 3442. (mask,ip,router) tuples */
+#define DHCP_VLAN_ID            0x84 /* 802.1P VLAN ID */
+#define DHCP_VLAN_PRIORITY      0x85 /* 802.1Q VLAN priority */
 //#define DHCP_MS_STATIC_ROUTES 0xf9 /* Microsoft's pre-RFC 3442 code for 0x79? */
 //#define DHCP_WPAD             0xfc /* MSIE's Web Proxy Autodiscovery Protocol */
 #define DHCP_END                0xff
diff --git a/networking/udhcp/dhcpc.c b/networking/udhcp/dhcpc.c
index ca82d37e6..510c3a1d0 100644
--- a/networking/udhcp/dhcpc.c
+++ b/networking/udhcp/dhcpc.c
@@ -300,6 +300,14 @@ static char **fill_envp(struct dhcp_packet *packet)
         uint8_t *temp;
         uint8_t overload = 0;
 
+#define BITMAP unsigned
+#define BBITS (sizeof(BITMAP) * 8)
+#define BMASK(i) (1 << (i & (sizeof(BITMAP) * 8 - 1)))
+#define FOUND_OPTS(i) (found_opts[(unsigned)i / BBITS])
+        BITMAP found_opts[256 / BBITS];
+
+        memset(found_opts, 0, sizeof(found_opts));
+
         /* We need 6 elements for:
          * "interface=IFACE"
          * "ip=N.N.N.N" from packet->yiaddr
@@ -311,18 +319,21 @@ static char **fill_envp(struct dhcp_packet *packet)
         envc = 6;
         /* +1 element for each option, +2 for subnet option: */
         if (packet) {
-                for (i = 0; dhcp_optflags[i].code; i++) {
-                        if (udhcp_get_option(packet, dhcp_optflags[i].code)) {
-                                if (dhcp_optflags[i].code == DHCP_SUBNET)
+                /* note: do not search for "pad" (0) and "end" (255) options */
+                for (i = 1; i < 255; i++) {
+                        temp = udhcp_get_option(packet, i);
+                        if (temp) {
+                                if (i == DHCP_OPTION_OVERLOAD)
+                                        overload = *temp;
+                                else if (i == DHCP_SUBNET)
                                         envc++; /* for mton */
                                 envc++;
+                                /*if (i != DHCP_MESSAGE_TYPE)*/
+                                FOUND_OPTS(i) |= BMASK(i);
                         }
                 }
-                temp = udhcp_get_option(packet, DHCP_OPTION_OVERLOAD);
-                if (temp)
-                        overload = *temp;
         }
-        curr = envp = xzalloc(sizeof(char *) * envc);
+        curr = envp = xzalloc(sizeof(envp[0]) * envc);
 
         *curr = xasprintf("interface=%s", client_config.interface);
         putenv(*curr++);
@@ -337,12 +348,16 @@ static char **fill_envp(struct dhcp_packet *packet)
         opt_name = dhcp_option_strings;
         i = 0;
         while (*opt_name) {
-                temp = udhcp_get_option(packet, dhcp_optflags[i].code);
-                if (!temp)
+                uint8_t code = dhcp_optflags[i].code;
+                BITMAP *found_ptr = &FOUND_OPTS(code);
+                BITMAP found_mask = BMASK(code);
+                if (!(*found_ptr & found_mask))
                         goto next;
+                *found_ptr &= ~found_mask; /* leave only unknown options */
+                temp = udhcp_get_option(packet, code);
                 *curr = xmalloc_optname_optval(temp, &dhcp_optflags[i], opt_name);
                 putenv(*curr++);
-                if (dhcp_optflags[i].code == DHCP_SUBNET) {
+                if (code == DHCP_SUBNET) {
                         /* Subnet option: make things like "$ip/$mask" possible */
                         uint32_t subnet;
                         move_from_unaligned32(subnet, temp);
@@ -368,6 +383,28 @@ static char **fill_envp(struct dhcp_packet *packet)
                 *curr = xasprintf("sname=%."DHCP_PKT_SNAME_LEN_STR"s", packet->sname);
                 putenv(*curr++);
         }
+        /* Handle unknown options */
+        for (i = 0; i < 256;) {
+                BITMAP bitmap = FOUND_OPTS(i);
+                if (!bitmap) {
+                        i += BBITS;
+                        continue;
+                }
+                if (bitmap & BMASK(i)) {
+                        unsigned len, ofs;
+
+                        temp = udhcp_get_option(packet, i);
+                        /* udhcp_get_option returns ptr to data portion,
+                         * need to go back to get len
+                         */
+                        len = temp[-OPT_DATA + OPT_LEN];
+                        *curr = xmalloc(sizeof("optNNN=") + 1 + len*2);
+                        ofs = sprintf(*curr, "opt%u=", i);
+                        bin2hex(*curr + ofs, (void*) temp, len)[0] = '\0';
+                        putenv(*curr++);
+                }
+                i++;
+        }
         return envp;
 }
 
diff --git a/networking/udhcp/files.c b/networking/udhcp/files.c
index 49bcafb9c..6840f3c25 100644
--- a/networking/udhcp/files.c
+++ b/networking/udhcp/files.c
@@ -80,9 +80,9 @@ static const struct config_keyword keywords[] = {
         /* keywords with no defaults must be last! */
         {"option"       , udhcp_str2optset, &server_config.options      , ""},
         {"opt"          , udhcp_str2optset, &server_config.options      , ""},
-        {"notify_file"  , read_str        , &server_config.notify_file  , ""},
-        {"sname"        , read_str        , &server_config.sname        , ""},
-        {"boot_file"    , read_str        , &server_config.boot_file    , ""},
+        {"notify_file"  , read_str        , &server_config.notify_file  , NULL},
+        {"sname"        , read_str        , &server_config.sname        , NULL},
+        {"boot_file"    , read_str        , &server_config.boot_file    , NULL},
         {"static_lease" , read_staticlease, &server_config.static_leases, ""},
 };
 enum { KWS_WITH_DEFAULTS = ARRAY_SIZE(keywords) - 6 };
diff --git a/printutils/lpd.c b/printutils/lpd.c
index 115552e0b..642e8a89e 100644
--- a/printutils/lpd.c
+++ b/printutils/lpd.c
@@ -102,7 +102,7 @@ static char *xmalloc_read_stdin(void)
 {
         // SECURITY:
         size_t max = 4 * 1024; // more than enough for commands!
-        return xmalloc_reads(STDIN_FILENO, NULL, &max);
+        return xmalloc_reads(STDIN_FILENO, &max);
 }
 
 int lpd_main(int argc, char *argv[]) MAIN_EXTERNALLY_VISIBLE;
diff --git a/procps/fuser.c b/procps/fuser.c
index 7837ff883..8d63a7313 100644
--- a/procps/fuser.c
+++ b/procps/fuser.c
@@ -37,33 +37,18 @@ typedef struct inode_list {
         dev_t dev;
 } inode_list;
 
-typedef struct pid_list {
-        struct pid_list *next;
-        pid_t pid;
-} pid_list;
-
-
 struct globals {
-        pid_list *pid_list_head;
+        int recursion_depth;
+        pid_t mypid;
         inode_list *inode_list_head;
+        smallint kill_failed;
+        int killsig;
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
-#define INIT_G() do { } while (0)
-
-
-static void add_pid(const pid_t pid)
-{
-        pid_list **curr = &G.pid_list_head;
-
-        while (*curr) {
-                if ((*curr)->pid == pid)
-                        return;
-                curr = &(*curr)->next;
-        }
-
-        *curr = xzalloc(sizeof(pid_list));
-        (*curr)->pid = pid;
-}
+#define INIT_G() do { \
+        G.mypid = getpid(); \
+        G.killsig = SIGKILL; \
+} while (0)
 
 static void add_inode(const struct stat *st)
 {
@@ -83,48 +68,7 @@ static void add_inode(const struct stat *st)
         (*curr)->inode = st->st_ino;
 }
 
-static void scan_proc_net(const char *path, unsigned port)
-{
-        char line[MAX_LINE + 1];
-        long long uint64_inode;
-        unsigned tmp_port;
-        FILE *f;
-        struct stat st;
-        int fd;
-
-        /* find socket dev */
-        st.st_dev = 0;
-        fd = socket(AF_INET, SOCK_DGRAM, 0);
-        if (fd >= 0) {
-                fstat(fd, &st);
-                close(fd);
-        }
-
-        f = fopen_for_read(path);
-        if (!f)
-                return;
-
-        while (fgets(line, MAX_LINE, f)) {
-                char addr[68];
-                if (sscanf(line, "%*d: %64[0-9A-Fa-f]:%x %*x:%*x %*x %*x:%*x "
-                                "%*x:%*x %*x %*d %*d %llu",
-                                addr, &tmp_port, &uint64_inode) == 3
-                ) {
-                        int len = strlen(addr);
-                        if (len == 8 && (option_mask32 & OPT_IP6))
-                                continue;
-                        if (len > 8 && (option_mask32 & OPT_IP4))
-                                continue;
-                        if (tmp_port == port) {
-                                st.st_ino = uint64_inode;
-                                add_inode(&st);
-                        }
-                }
-        }
-        fclose(f);
-}
-
-static int search_dev_inode(const struct stat *st)
+static smallint search_dev_inode(const struct stat *st)
 {
         inode_list *ilist = G.inode_list_head;
 
@@ -140,130 +84,202 @@ static int search_dev_inode(const struct stat *st)
         return 0;
 }
 
-static void scan_pid_maps(const char *fname, pid_t pid)
+enum {
+        PROC_NET = 0,
+        PROC_DIR,
+        PROC_DIR_LINKS,
+        PROC_SUBDIR_LINKS,
+};
+
+static smallint scan_proc_net_or_maps(const char *path, unsigned port)
 {
-        FILE *file;
-        char line[MAX_LINE + 1];
-        int major, minor;
+        FILE *f;
+        char line[MAX_LINE + 1], addr[68];
+        int major, minor, r;
         long long uint64_inode;
-        struct stat st;
+        unsigned tmp_port;
+        smallint retval;
+        struct stat statbuf;
+        const char *fmt;
+        void *fag, *sag;
 
-        file = fopen_for_read(fname);
-        if (!file)
-                return;
+        f = fopen_for_read(path);
+        if (!f)
+                return 0;
 
-        while (fgets(line, MAX_LINE, file)) {
-                if (sscanf(line, "%*s %*s %*s %x:%x %llu", &major, &minor, &uint64_inode) != 3)
-                        continue;
-                st.st_ino = uint64_inode;
-                if (major == 0 && minor == 0 && st.st_ino == 0)
-                        continue;
-                st.st_dev = makedev(major, minor);
-                if (search_dev_inode(&st))
-                        add_pid(pid);
-        }
-        fclose(file);
-}
+        if (G.recursion_depth == PROC_NET) {
+                int fd;
 
-static void scan_link(const char *lname, pid_t pid)
-{
-        struct stat st;
+                /* find socket dev */
+                statbuf.st_dev = 0;
+                fd = socket(AF_INET, SOCK_DGRAM, 0);
+                if (fd >= 0) {
+                        fstat(fd, &statbuf);
+                        close(fd);
+                }
 
-        if (stat(lname, &st) >= 0) {
-                if (search_dev_inode(&st))
-                        add_pid(pid);
+                fmt = "%*d: %64[0-9A-Fa-f]:%x %*x:%*x %*x "
+                        "%*x:%*x %*x:%*x %*x %*d %*d %llu";
+                fag = addr;
+                sag = &tmp_port;
+        } else {
+                fmt = "%*s %*s %*s %x:%x %llu";
+                fag = &major;
+                sag = &minor;
         }
-}
-
-static void scan_dir_links(const char *dname, pid_t pid)
-{
-        DIR *d;
-        struct dirent *de;
-        char *lname;
-
-        d = opendir(dname);
-        if (!d)
-                return;
 
-        while ((de = readdir(d)) != NULL) {
-                lname = concat_subpath_file(dname, de->d_name);
-                if (lname == NULL)
+        retval = 0;
+        while (fgets(line, MAX_LINE, f)) {
+                r = sscanf(line, fmt, fag, sag, &uint64_inode);
+                if (r != 3)
                         continue;
-                scan_link(lname, pid);
-                free(lname);
+
+                statbuf.st_ino = uint64_inode;
+                if (G.recursion_depth == PROC_NET) {
+                        r = strlen(addr);
+                        if (r == 8 && (option_mask32 & OPT_IP6))
+                                continue;
+                        if (r > 8 && (option_mask32 & OPT_IP4))
+                                continue;
+                        if (tmp_port == port)
+                                add_inode(&statbuf);
+                } else {
+                        if (major != 0 && minor != 0 && statbuf.st_ino != 0) {
+                                statbuf.st_dev = makedev(major, minor);
+                                retval = search_dev_inode(&statbuf);
+                                if (retval)
+                                        break;
+                        }
+                }
         }
-        closedir(d);
+        fclose(f);
+
+        return retval;
 }
 
-/* NB: does chdir internally */
-static void scan_proc_pids(void)
+static smallint scan_recursive(const char *path)
 {
         DIR *d;
-        struct dirent *de;
-        pid_t pid;
-
-        xchdir("/proc");
-        d = opendir("/proc");
-        if (!d)
-                return;
-
-        while ((de = readdir(d)) != NULL) {
-                pid = (pid_t)bb_strtou(de->d_name, NULL, 10);
-                if (errno)
-                        continue;
-                if (chdir(de->d_name) < 0)
-                        continue;
-                scan_link("cwd", pid);
-                scan_link("exe", pid);
-                scan_link("root", pid);
-
-                scan_dir_links("fd", pid);
-                scan_dir_links("lib", pid);
-                scan_dir_links("mmap", pid);
+        struct dirent *d_ent;
+        smallint stop_scan;
+        smallint retval;
+
+        d = opendir(path);
+        if (d == NULL)
+                return 0;
+
+        G.recursion_depth++;
+        retval = 0;
+        stop_scan = 0;
+        while (!stop_scan && (d_ent = readdir(d)) != NULL) {
+                struct stat statbuf;
+                pid_t pid;
+                char *subpath;
+
+                subpath = concat_subpath_file(path, d_ent->d_name);
+                if (subpath == NULL)
+                        continue; /* . or .. */
+
+                switch (G.recursion_depth) {
+                case PROC_DIR:
+                        pid = (pid_t)bb_strtou(d_ent->d_name, NULL, 10);
+                        if (errno != 0
+                         || pid == G.mypid
+                        /* "this PID doesn't use specified FILEs or PORT/PROTO": */
+                         || scan_recursive(subpath) == 0
+                        ) {
+                                break;
+                        }
+                        if (option_mask32 & OPT_KILL) {
+                                if (kill(pid, G.killsig) != 0) {
+                                        bb_perror_msg("kill pid %s", d_ent->d_name);
+                                        G.kill_failed = 1;
+                                }
+                        }
+                        if (!(option_mask32 & OPT_SILENT))
+                                printf("%s ", d_ent->d_name);
+                        retval = 1;
+                        break;
 
-                scan_pid_maps("maps", pid);
-                xchdir("/proc");
+                case PROC_DIR_LINKS:
+                        switch (
+                                index_in_substrings(
+                                        "cwd"  "\0" "exe"  "\0"
+                                        "root" "\0" "fd"   "\0"
+                                        "lib"  "\0" "mmap" "\0"
+                                        "maps" "\0",
+                                        d_ent->d_name
+                                )
+                        ) {
+                        enum {
+                                CWD_LINK,
+                                EXE_LINK,
+                                ROOT_LINK,
+                                FD_DIR_LINKS,
+                                LIB_DIR_LINKS,
+                                MMAP_DIR_LINKS,
+                                MAPS,
+                        };
+                        case CWD_LINK:
+                        case EXE_LINK:
+                        case ROOT_LINK:
+                                goto scan_link;
+                        case FD_DIR_LINKS:
+                        case LIB_DIR_LINKS:
+                        case MMAP_DIR_LINKS:
+                                stop_scan = scan_recursive(subpath);
+                                if (stop_scan)
+                                        retval = stop_scan;
+                                break;
+                        case MAPS:
+                                stop_scan = scan_proc_net_or_maps(subpath, 0);
+                                if (stop_scan)
+                                        retval = stop_scan;
+                        default:
+                                break;
+                        }
+                        break;
+                case PROC_SUBDIR_LINKS:
+  scan_link:
+                        if (stat(subpath, &statbuf) < 0)
+                                break;
+                        stop_scan = search_dev_inode(&statbuf);
+                        if (stop_scan)
+                                retval = stop_scan;
+                default:
+                        break;
+                }
+                free(subpath);
         }
         closedir(d);
+        G.recursion_depth--;
+        return retval;
 }
 
 int fuser_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int fuser_main(int argc UNUSED_PARAM, char **argv)
 {
-        pid_list *plist;
-        pid_t mypid;
         char **pp;
-        struct stat st;
-        unsigned port;
-        int opt;
-        int exitcode;
-        int killsig;
-/*
-fuser [OPTIONS] FILE or PORT/PROTO
-Find processes which use FILEs or PORTs
-        -m      Find processes which use same fs as FILEs
-        -4      Search only IPv4 space
-        -6      Search only IPv6 space
-        -s      Don't display PIDs
-        -k      Kill found processes
-        -SIGNAL Signal to send (default: KILL)
-*/
+
+        INIT_G();
+
         /* Handle -SIGNAL. Oh my... */
-        killsig = SIGKILL; /* yes, the default is not SIGTERM */
         pp = argv;
         while (*++pp) {
+                int sig;
                 char *arg = *pp;
+
                 if (arg[0] != '-')
                         continue;
                 if (arg[1] == '-' && arg[2] == '\0') /* "--" */
                         break;
                 if ((arg[1] == '4' || arg[1] == '6') && arg[2] == '\0')
                         continue; /* it's "-4" or "-6" */
-                opt = get_signum(&arg[1]);
-                if (opt < 0)
+                sig = get_signum(&arg[1]);
+                if (sig < 0)
                         continue;
                 /* "-SIGNAL" option found. Remove it and bail out */
-                killsig = opt;
+                G.killsig = sig;
                 do {
                         pp[0] = arg = pp[1];
                         pp++;
@@ -272,57 +288,35 @@ Find processes which use FILEs or PORTs
         }
 
         opt_complementary = "-1"; /* at least one param */
-        opt = getopt32(argv, OPTION_STRING);
+        getopt32(argv, OPTION_STRING);
         argv += optind;
 
         pp = argv;
         while (*pp) {
                 /* parse net arg */
-                char path[20], tproto[5];
-                if (sscanf(*pp, "%u/%4s", &port, tproto) != 2)
-                        goto file;
-                sprintf(path, "/proc/net/%s", tproto);
-                if (access(path, R_OK) != 0) { /* PORT/PROTO */
-                        scan_proc_net(path, port);
-                } else { /* FILE */
- file:
-                        xstat(*pp, &st);
-                        add_inode(&st);
+                unsigned port;
+                char path[sizeof("/proc/net/TCP6")];
+
+                strcpy(path, "/proc/net/");
+                if (sscanf(*pp, "%u/%4s", &port, path + sizeof("/proc/net/")-1) == 2
+                 && access(path, R_OK) == 0
+                ) {
+                        /* PORT/PROTO */
+                        scan_proc_net_or_maps(path, port);
+                } else {
+                        /* FILE */
+                        struct stat statbuf;
+                        xstat(*pp, &statbuf);
+                        add_inode(&statbuf);
                 }
                 pp++;
         }
 
-        scan_proc_pids(); /* changes dir to "/proc" */
-
-        mypid = getpid();
-        plist = G.pid_list_head;
-        while (1) {
-                if (!plist)
-                        return EXIT_FAILURE;
-                if (plist->pid != mypid)
-                        break;
-                plist = plist->next;
-        }
-
-        exitcode = EXIT_SUCCESS;
-        do {
-                if (plist->pid != mypid) {
-                        if (opt & OPT_KILL) {
-                                if (kill(plist->pid, killsig) != 0) {
-                                        bb_perror_msg("kill pid %u", (unsigned)plist->pid);
-                                        exitcode = EXIT_FAILURE;
-                                }
-                        }
-                        if (!(opt & OPT_SILENT)) {
-                                printf("%u ", (unsigned)plist->pid);
-                        }
-                }
-                plist = plist->next;
-        } while (plist);
-
-        if (!(opt & (OPT_SILENT))) {
-                bb_putchar('\n');
+        if (scan_recursive("/proc")) {
+                if (!(option_mask32 & OPT_SILENT))
+                        bb_putchar('\n');
+                return G.kill_failed;
         }
 
-        return exitcode;
+        return EXIT_FAILURE;
 }
diff --git a/procps/iostat.c b/procps/iostat.c
index 06a33eb1d..cd233c72f 100644
--- a/procps/iostat.c
+++ b/procps/iostat.c
@@ -24,8 +24,6 @@
 #define debug(fmt, ...) ((void)0)
 
 #define MAX_DEVICE_NAME 12
-#define CURRENT          0
-#define LAST             1
 
 #if 1
 typedef unsigned long long cputime_t;
@@ -39,18 +37,33 @@ typedef long icputime_t;
 # define CPUTIME_MAX (~0UL)
 #endif
 
-struct stats_cpu {
-        cputime_t cpu_user;
-        cputime_t cpu_nice;
-        cputime_t cpu_system;
-        cputime_t cpu_idle;
-        cputime_t cpu_iowait;
-        cputime_t cpu_steal;
-        cputime_t cpu_irq;
-        cputime_t cpu_softirq;
-        cputime_t cpu_guest;
+enum {
+        STATS_CPU_USER,
+        STATS_CPU_NICE,
+        STATS_CPU_SYSTEM,
+        STATS_CPU_IDLE,
+        STATS_CPU_IOWAIT,
+        STATS_CPU_IRQ,
+        STATS_CPU_SOFTIRQ,
+        STATS_CPU_STEAL,
+        STATS_CPU_GUEST,
+
+        GLOBAL_UPTIME,
+        SMP_UPTIME,
+
+        N_STATS_CPU,
 };
 
+typedef struct {
+        cputime_t vector[N_STATS_CPU];
+} stats_cpu_t;
+
+typedef struct {
+        stats_cpu_t *prev;
+        stats_cpu_t *curr;
+        cputime_t itv;
+} stats_cpu_pair_t;
+
 struct stats_dev {
         char dname[MAX_DEVICE_NAME];
         unsigned long long rd_sectors;
@@ -59,24 +72,24 @@ struct stats_dev {
         unsigned long wr_ops;
 };
 
-/* List of devices entered on the command line */
-struct device_list {
-        char dname[MAX_DEVICE_NAME];
-};
-
 /* Globals. Sort by size and access frequency. */
 struct globals {
         smallint show_all;
-        unsigned devlist_i;             /* Index to the list of devices */
         unsigned total_cpus;            /* Number of CPUs */
         unsigned clk_tck;               /* Number of clock ticks per second */
-        struct device_list *dlist;
+        llist_t *dev_list;              /* List of devices entered on the command line */
         struct stats_dev *saved_stats_dev;
         struct tm tmtime;
+        struct {
+                const char *str;
+                unsigned div;
+        } unit;
 };
 #define G (*ptr_to_globals)
 #define INIT_G() do { \
         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
+        G.unit.str = "Blk"; \
+        G.unit.div = 1; \
 } while (0)
 
 /* Must match option string! */
@@ -104,12 +117,12 @@ static void print_header(void)
         char buf[16];
         struct utsname uts;
 
-        if (uname(&uts) < 0)
-                bb_perror_msg_and_die("uname");
+        uname(&uts); /* never fails */
 
+        /* Date representation for the current locale */
         strftime(buf, sizeof(buf), "%x", &G.tmtime);
 
-        printf("%s %s (%s) \t%s \t_%s_\t(%d CPU)\n\n",
+        printf("%s %s (%s) \t%s \t_%s_\t(%u CPU)\n\n",
                         uts.sysname, uts.release, uts.nodename,
                         buf, uts.machine, G.total_cpus);
 }
@@ -124,61 +137,58 @@ static void get_localtime(struct tm *ptm)
 static void print_timestamp(void)
 {
         char buf[20];
+        /* %x: date representation for the current locale */
+        /* %X: time representation for the current locale */
         strftime(buf, sizeof(buf), "%x %X", &G.tmtime);
         printf("%s\n", buf);
 }
 
-/* Fetch CPU statistics from /proc/stat */
-static void get_cpu_statistics(struct stats_cpu *sc)
+static cputime_t get_smp_uptime(void)
 {
         FILE *fp;
-        char buf[1024];
-
-        fp = xfopen_for_read("/proc/stat");
+        unsigned long sec, dec;
 
-        memset(sc, 0, sizeof(*sc));
+        fp = xfopen_for_read("/proc/uptime");
 
-        while (fgets(buf, sizeof(buf), fp)) {
-                /* Does the line starts with "cpu "? */
-                if (starts_with_cpu(buf) && buf[3] == ' ') {
-                        sscanf(buf + 4 + 1,
-                                "%"FMT_DATA"u %"FMT_DATA"u %"FMT_DATA"u %"FMT_DATA"u %"
-                                FMT_DATA"u %"FMT_DATA"u %"FMT_DATA"u %"FMT_DATA"u %"FMT_DATA"u",
-                                &sc->cpu_user, &sc->cpu_nice, &sc->cpu_system,
-                                &sc->cpu_idle, &sc->cpu_iowait, &sc->cpu_irq,
-                                &sc->cpu_softirq, &sc->cpu_steal, &sc->cpu_guest);
-                }
-        }
+        if (fscanf(fp, "%lu.%lu", &sec, &dec) != 2)
+                bb_error_msg_and_die("can't read '%s'", "/proc/uptime");
 
         fclose(fp);
+
+        return (cputime_t)sec * G.clk_tck + dec * G.clk_tck / 100;
 }
 
-static cputime_t get_smp_uptime(void)
+/* Fetch CPU statistics from /proc/stat */
+static void get_cpu_statistics(stats_cpu_t *sc)
 {
         FILE *fp;
-        char buf[sizeof(long)*3 * 2 + 4];
-        unsigned long sec, dec;
+        char buf[1024], *ibuf = buf + 4;
 
-        fp = xfopen_for_read("/proc/uptime");
+        fp = xfopen_for_read("/proc/stat");
 
-        if (fgets(buf, sizeof(buf), fp))
-                if (sscanf(buf, "%lu.%lu", &sec, &dec) != 2)
-                        bb_error_msg_and_die("can't read /proc/uptime");
+        memset(sc, 0, sizeof(*sc));
 
-        fclose(fp);
+        while (fgets(buf, sizeof(buf), fp)) {
+                /* Does the line starts with "cpu "? */
+                if (!starts_with_cpu(buf) || buf[3] != ' ') {
+                        continue;
+                }
+                for (int i = STATS_CPU_USER; i <= STATS_CPU_GUEST; i++) {
+                        ibuf = skip_whitespace(ibuf);
+                        sscanf(ibuf, "%"FMT_DATA"u", &sc->vector[i]);
+                        if (i != STATS_CPU_GUEST) {
+                                sc->vector[GLOBAL_UPTIME] += sc->vector[i];
+                        }
+                        ibuf = skip_non_whitespace(ibuf);
+                }
+                break;
+        }
 
-        return (cputime_t)sec * G.clk_tck + dec * G.clk_tck / 100;
-}
+        if (this_is_smp()) {
+                sc->vector[SMP_UPTIME] = get_smp_uptime();
+        }
 
-/*
- * Obtain current uptime in jiffies.
- * Uptime is sum of individual CPUs' uptimes.
- */
-static cputime_t get_uptime(const struct stats_cpu *sc)
-{
-        /* NB: Don't include cpu_guest, it is already in cpu_user */
-        return sc->cpu_user + sc->cpu_nice + sc->cpu_system + sc->cpu_idle +
-                + sc->cpu_iowait + sc->cpu_irq + sc->cpu_steal + sc->cpu_softirq;
+        fclose(fp);
 }
 
 static ALWAYS_INLINE cputime_t get_interval(cputime_t old, cputime_t new)
@@ -219,65 +229,51 @@ static double percent_value(cputime_t prev, cputime_t curr, cputime_t itv)
         return ((double)overflow_safe_sub(prev, curr)) / itv * 100;
 }
 
-static void print_stats_cpu_struct(const struct stats_cpu *p,
-                const struct stats_cpu *c, cputime_t itv)
+static void print_stats_cpu_struct(stats_cpu_pair_t *stats)
 {
+        cputime_t *p = stats->prev->vector;
+        cputime_t *c = stats->curr->vector;
         printf("         %6.2f  %6.2f  %6.2f  %6.2f  %6.2f  %6.2f\n",
-                percent_value(p->cpu_user   , c->cpu_user   , itv),
-                percent_value(p->cpu_nice   , c->cpu_nice   , itv),
-                percent_value(p->cpu_system + p->cpu_softirq + p->cpu_irq,
-                        c->cpu_system + c->cpu_softirq + c->cpu_irq, itv),
-                percent_value(p->cpu_iowait , c->cpu_iowait , itv),
-                percent_value(p->cpu_steal  , c->cpu_steal  , itv),
-                percent_value(p->cpu_idle   , c->cpu_idle   , itv)
+                percent_value(p[STATS_CPU_USER]  , c[STATS_CPU_USER]  , stats->itv),
+                percent_value(p[STATS_CPU_NICE]  , c[STATS_CPU_NICE]  , stats->itv),
+                percent_value(p[STATS_CPU_SYSTEM] + p[STATS_CPU_SOFTIRQ] + p[STATS_CPU_IRQ],
+                        c[STATS_CPU_SYSTEM] + c[STATS_CPU_SOFTIRQ] + c[STATS_CPU_IRQ], stats->itv),
+                percent_value(p[STATS_CPU_IOWAIT], c[STATS_CPU_IOWAIT], stats->itv),
+                percent_value(p[STATS_CPU_STEAL] , c[STATS_CPU_STEAL] , stats->itv),
+                percent_value(p[STATS_CPU_IDLE]  , c[STATS_CPU_IDLE]  , stats->itv)
         );
 }
 
 static void print_stats_dev_struct(const struct stats_dev *p,
                 const struct stats_dev *c, cputime_t itv)
 {
-        int unit = 1;
-
-        if (option_mask32 & OPT_k)
-                unit = 2;
-        else if (option_mask32 & OPT_m)
-                unit = 2048;
-
         if (option_mask32 & OPT_z)
                 if (p->rd_ops == c->rd_ops && p->wr_ops == c->wr_ops)
                         return;
 
-        printf("%-13s", c->dname);
-        printf(" %8.2f %12.2f %12.2f %10llu %10llu \n",
+        printf("%-13s %8.2f %12.2f %12.2f %10llu %10llu \n", c->dname,
                 percent_value(p->rd_ops + p->wr_ops ,
                 /**/              c->rd_ops + c->wr_ops , itv),
-                percent_value(p->rd_sectors, c->rd_sectors, itv) / unit,
-                percent_value(p->wr_sectors, c->wr_sectors, itv) / unit,
-                (c->rd_sectors - p->rd_sectors) / unit,
-                (c->wr_sectors - p->wr_sectors) / unit);
+                percent_value(p->rd_sectors, c->rd_sectors, itv) / G.unit.div,
+                percent_value(p->wr_sectors, c->wr_sectors, itv) / G.unit.div,
+                (c->rd_sectors - p->rd_sectors) / G.unit.div,
+                (c->wr_sectors - p->wr_sectors) / G.unit.div);
 }
 
-static void cpu_report(const struct stats_cpu *last,
-                const struct stats_cpu *cur,
-                cputime_t itv)
+static void cpu_report(stats_cpu_pair_t *stats)
 {
         /* Always print a header */
         puts("avg-cpu:  %user   %nice %system %iowait  %steal   %idle");
 
         /* Print current statistics */
-        print_stats_cpu_struct(last, cur, itv);
+        print_stats_cpu_struct(stats);
 }
 
 static void print_devstat_header(void)
 {
-        printf("Device:            tps");
-
-        if (option_mask32 & OPT_m)
-                puts("    MB_read/s    MB_wrtn/s    MB_read    MB_wrtn");
-        else if (option_mask32 & OPT_k)
-                puts("    kB_read/s    kB_wrtn/s    kB_read    kB_wrtn");
-        else
-                puts("   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn");
+        printf("Device:%15s%6s%s/s%6s%s/s%6s%s%6s%s\n", "tps",
+                G.unit.str, "_read", G.unit.str, "_wrtn",
+                G.unit.str, "_read", G.unit.str, "_wrtn");
 }
 
 /*
@@ -289,37 +285,6 @@ static int is_partition(const char *dev)
         return ((dev[0] - 's') | (dev[1] - 'd') | (dev[2] - 'a')) == 0 && isdigit(dev[3]);
 }
 
-/*
- * Return number of numbers on cmdline.
- * Reasonable values are only 0 (no interval/count specified),
- * 1 (interval specified) and 2 (both interval and count specified)
- */
-static int numbers_on_cmdline(int argc, char *argv[])
-{
-        int sum = 0;
-
-        if (isdigit(argv[argc-1][0]))
-                sum++;
-        if (argc > 2 && isdigit(argv[argc-2][0]))
-                sum++;
-
-        return sum;
-}
-
-static int is_dev_in_dlist(const char *dev)
-{
-        int i;
-
-        /* Go through the device list */
-        for (i = 0; i < G.devlist_i; i++)
-                if (strcmp(G.dlist[i].dname, dev) == 0)
-                        /* Found a match */
-                        return 1;
-
-        /* No match found */
-        return 0;
-}
-
 static void do_disk_statistics(cputime_t itv)
 {
         FILE *fp;
@@ -356,7 +321,7 @@ static void do_disk_statistics(cputime_t itv)
                         break;
                 }
 
-                if (!G.devlist_i && !is_partition(sd.dname)) {
+                if (!G.dev_list && !is_partition(sd.dname)) {
                         /* User didn't specify device */
                         if (!G.show_all && !sd.rd_ops && !sd.wr_ops) {
                                 /* Don't print unused device */
@@ -367,7 +332,7 @@ static void do_disk_statistics(cputime_t itv)
                         i++;
                 } else {
                         /* Is device in device list? */
-                        if (is_dev_in_dlist(sd.dname)) {
+                        if (llist_find_str(G.dev_list, sd.dname)) {
                                 /* Print current statistics */
                                 print_stats_dev_struct(&G.saved_stats_dev[i], &sd, itv);
                                 G.saved_stats_dev[i] = sd;
@@ -389,28 +354,6 @@ static void dev_report(cputime_t itv)
         do_disk_statistics(itv);
 }
 
-static void save_to_devlist(const char *dname)
-{
-        int i;
-        struct device_list *tmp = G.dlist;
-
-        if (strncmp(dname, "/dev/", 5) == 0)
-                /* We'll ignore prefix '/dev/' */
-                dname += 5;
-
-        /* Go through the list */
-        for (i = 0; i < G.devlist_i; i++, tmp++)
-                if (strcmp(tmp->dname, dname) == 0)
-                        /* Already in the list */
-                        return;
-
-        /* Add device name to the list */
-        strncpy(tmp->dname, dname, MAX_DEVICE_NAME - 1);
-
-        /* Update device list index */
-        G.devlist_i++;
-}
-
 static unsigned get_number_of_devices(void)
 {
         FILE *fp;
@@ -440,18 +383,6 @@ static unsigned get_number_of_devices(void)
         return n;
 }
 
-static int number_of_ALL_on_cmdline(char **argv)
-{
-        int alls = 0;
-
-        /* Iterate over cmd line arguments, count "ALL" */
-        while (*argv)
-                if (strcmp(*argv++, "ALL") == 0)
-                        alls++;
-
-        return alls;
-}
-
 //usage:#define iostat_trivial_usage
 //usage:       "[-c] [-d] [-t] [-z] [-k|-m] [ALL|BLOCKDEV...] [INTERVAL [COUNT]]"
 //usage:#define iostat_full_usage "\n\n"
@@ -465,19 +396,17 @@ static int number_of_ALL_on_cmdline(char **argv)
 //usage:     "\n        -m      Use Mb/s"
 
 int iostat_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
-int iostat_main(int argc, char **argv)
+int iostat_main(int argc UNUSED_PARAM, char **argv)
 {
         int opt, dev_num;
-        unsigned interval = 0;
+        unsigned interval;
         int count;
-        cputime_t global_uptime[2] = { 0 };
-        cputime_t smp_uptime[2] = { 0 };
-        cputime_t itv;
-        struct stats_cpu stats_cur, stats_last;
+        stats_cpu_t stats_data[2];
+        smallint current_stats;
 
         INIT_G();
 
-        memset(&stats_last, 0, sizeof(stats_last));
+        memset(&stats_data, 0, sizeof(stats_data));
 
         /* Get number of clock ticks per sec */
         G.clk_tck = get_user_hz();
@@ -496,25 +425,24 @@ int iostat_main(int argc, char **argv)
                 opt |= OPT_c + OPT_d;
 
         argv += optind;
-        argc -= optind;
-
-        dev_num = argc - numbers_on_cmdline(argc, argv);
-        /* We don't want to allocate space for 'ALL' */
-        dev_num -= number_of_ALL_on_cmdline(argv);
-        if (dev_num > 0)
-                /* Make space for device list */
-                G.dlist = xzalloc(sizeof(G.dlist[0]) * dev_num);
 
         /* Store device names into device list */
+        dev_num = 0;
         while (*argv && !isdigit(*argv[0])) {
-                if (strcmp(*argv, "ALL") != 0)
+                if (strcmp(*argv, "ALL") != 0) {
                         /* If not ALL, save device name */
-                        save_to_devlist(*argv);
-                else
+                        char *dev_name = skip_dev_pfx(*argv);
+                        if (!llist_find_str(G.dev_list, dev_name)) {
+                                llist_add_to(&G.dev_list, dev_name);
+                                dev_num++;
+                        }
+                } else {
                         G.show_all = 1;
+                }
                 argv++;
         }
 
+        interval = 0;
         count = 1;
         if (*argv) {
                 /* Get interval */
@@ -533,28 +461,46 @@ int iostat_main(int argc, char **argv)
                 );
         }
 
+        if (opt & OPT_m) {
+                G.unit.str = " MB";
+                G.unit.div = 2048;
+        }
+
+        if (opt & OPT_k) {
+                G.unit.str = " kB";
+                G.unit.div = 2;
+        }
+
+        get_localtime(&G.tmtime);
+
         /* Display header */
         print_header();
 
+        current_stats = 0;
         /* Main loop */
         for (;;) {
+                stats_cpu_pair_t stats;
+
+                stats.prev = &stats_data[current_stats ^ 1];
+                stats.curr = &stats_data[current_stats];
+
                 /* Fill the time structure */
                 get_localtime(&G.tmtime);
 
                 /* Fetch current CPU statistics */
-                get_cpu_statistics(&stats_cur);
-
-                /* Fetch current uptime */
-                global_uptime[CURRENT] = get_uptime(&stats_cur);
+                get_cpu_statistics(stats.curr);
 
                 /* Get interval */
-                itv = get_interval(global_uptime[LAST], global_uptime[CURRENT]);
+                stats.itv = get_interval(
+                        stats.prev->vector[GLOBAL_UPTIME],
+                        stats.curr->vector[GLOBAL_UPTIME]
+                );
 
                 if (opt & OPT_t)
                         print_timestamp();
 
                 if (opt & OPT_c) {
-                        cpu_report(&stats_last, &stats_cur, itv);
+                        cpu_report(&stats);
                         if (opt & OPT_d)
                                 /* Separate outputs by a newline */
                                 bb_putchar('\n');
@@ -562,32 +508,31 @@ int iostat_main(int argc, char **argv)
 
                 if (opt & OPT_d) {
                         if (this_is_smp()) {
-                                smp_uptime[CURRENT] = get_smp_uptime();
-                                itv = get_interval(smp_uptime[LAST], smp_uptime[CURRENT]);
-                                smp_uptime[LAST] = smp_uptime[CURRENT];
+                                stats.itv = get_interval(
+                                        stats.prev->vector[SMP_UPTIME],
+                                        stats.curr->vector[SMP_UPTIME]
+                                );
                         }
-                        dev_report(itv);
+                        dev_report(stats.itv);
                 }
 
+                bb_putchar('\n');
+
                 if (count > 0) {
                         if (--count == 0)
                                 break;
                 }
 
-                /* Backup current stats */
-                global_uptime[LAST] = global_uptime[CURRENT];
-                stats_last = stats_cur;
+                /* Swap stats */
+                current_stats ^= 1;
 
-                bb_putchar('\n');
                 sleep(interval);
         }
 
-        bb_putchar('\n');
-
         if (ENABLE_FEATURE_CLEAN_UP) {
-                free(&G);
-                free(G.dlist);
+                llist_free(G.dev_list, NULL);
                 free(G.saved_stats_dev);
+                free(&G);
         }
 
         return EXIT_SUCCESS;
diff --git a/procps/mpstat.c b/procps/mpstat.c
index d643c999f..da8f34dab 100644
--- a/procps/mpstat.c
+++ b/procps/mpstat.c
@@ -36,11 +36,10 @@
  * We are printing headers in the " IRQNAME/s" form, experimentally
  * anything smaller than 10 chars looks ugly for /proc/softirqs stats.
  */
-#define INTRATE_SCRWIDTH   10
+#define INTRATE_SCRWIDTH      10
 #define INTRATE_SCRWIDTH_STR "10"
 
 /* System files */
-#define SYSFS_DEVCPU      "/sys/devices/system/cpu"
 #define PROCFS_STAT       "/proc/stat"
 #define PROCFS_INTERRUPTS "/proc/interrupts"
 #define PROCFS_SOFTIRQS   "/proc/softirqs"
diff --git a/procps/nmeter.c b/procps/nmeter.c
index 48b56a399..999955982 100644
--- a/procps/nmeter.c
+++ b/procps/nmeter.c
@@ -24,20 +24,20 @@
 //usage:     "\n -d MSEC        Milliseconds between updates (default:1000)"
 //usage:     "\n"
 //usage:     "\nFormat specifiers:"
-//usage:     "\n %Nc or %[cN]   Monitor CPU. N - bar size (default:10)"
+//usage:     "\n %Nc or %[cN]   CPU. N - bar size (default:10)"
 //usage:     "\n                (displays: S:system U:user N:niced D:iowait I:irq i:softirq)"
-//usage:     "\n %[niface]      Monitor network interface 'iface'"
-//usage:     "\n %m             Monitor allocated memory"
-//usage:     "\n %[mf]          Monitor free memory"
-//usage:     "\n %[mt]          Monitor total memory"
-//usage:     "\n %s             Monitor allocated swap"
-//usage:     "\n %f             Monitor number of used file descriptors"
-//usage:     "\n %Ni            Monitor total/specific IRQ rate"
-//usage:     "\n %x             Monitor context switch rate"
-//usage:     "\n %p             Monitor forks"
-//usage:     "\n %[pn]          Monitor # of processes"
-//usage:     "\n %b             Monitor block io"
-//usage:     "\n %Nt            Show time (with N decimal points)"
+//usage:     "\n %[nINTERFACE]  Network INTERFACE"
+//usage:     "\n %m             Allocated memory"
+//usage:     "\n %[mf]          Free memory"
+//usage:     "\n %[mt]          Total memory"
+//usage:     "\n %s             Allocated swap"
+//usage:     "\n %f             Number of used file descriptors"
+//usage:     "\n %Ni            Total/specific IRQ rate"
+//usage:     "\n %x             Context switch rate"
+//usage:     "\n %p             Forks"
+//usage:     "\n %[pn]          # of processes"
+//usage:     "\n %b             Block io"
+//usage:     "\n %Nt            Time (with N decimal points)"
 //usage:     "\n %r             Print <cr> instead of <lf> at EOL"
 
 //TODO:
diff --git a/procps/powertop.c b/procps/powertop.c
index bfe5a9568..008cdfca4 100644
--- a/procps/powertop.c
+++ b/procps/powertop.c
@@ -393,11 +393,9 @@ static NOINLINE int process_timer_stats(void)
         char buf[128];
         char line[15 + 3 + 128];
         int n;
-        ullong totalticks;
         FILE *fp;
 
         buf[0] = '\0';
-        totalticks = 0;
 
         n = 0;
         fp = NULL;
diff --git a/procps/top.c b/procps/top.c
index ee6555188..011bbf183 100644
--- a/procps/top.c
+++ b/procps/top.c
@@ -92,9 +92,9 @@ enum { SORT_DEPTH = 3 };
 struct globals {
         top_status_t *top;
         int ntop;
+        smallint inverted;
 #if ENABLE_FEATURE_TOPMEM
         smallint sort_field;
-        smallint inverted;
 #endif
 #if ENABLE_FEATURE_TOP_SMP_CPU
         smallint smp_cpu_info; /* one/many cpu info lines? */
@@ -194,9 +194,9 @@ static int mult_lvl_cmp(void* a, void* b)
         for (i = 0; i < SORT_DEPTH; i++) {
                 cmp_val = (*sort_function[i])(a, b);
                 if (cmp_val != 0)
-                        return cmp_val;
+                        break;
         }
-        return 0;
+        return inverted ? -cmp_val : cmp_val;
 }
 
 static NOINLINE int read_cpu_jiffy(FILE *fp, jiffy_counts_t *p_jif)
@@ -797,7 +797,7 @@ static NOINLINE void display_topmem_process_list(int lines_rem, int scr_width)
 
         display_topmem_header(scr_width, &lines_rem);
         strcpy(line_buf, HDR_STR " COMMAND");
-        line_buf[5 + sort_field * 6] = '*';
+        line_buf[11 + sort_field * 6] = "^_"[inverted];
         printf(OPT_BATCH_MODE ? "%.*s" : "\e[7m%.*s\e[0m", scr_width, line_buf);
         lines_rem--;
 
@@ -850,8 +850,114 @@ enum {
                 | PSSCAN_PID
                 | PSSCAN_SMAPS
                 | PSSCAN_COMM,
+        EXIT_MASK = (unsigned)-1,
 };
 
+#if ENABLE_FEATURE_USE_TERMIOS
+static unsigned handle_input(unsigned scan_mask, unsigned interval)
+{
+        unsigned char c;
+        struct pollfd pfd[1];
+
+        pfd[0].fd = 0;
+        pfd[0].events = POLLIN;
+
+        while (1) {
+                if (safe_poll(pfd, 1, interval * 1000) <= 0)
+                        return scan_mask;
+                interval = 0;
+
+                if (safe_read(STDIN_FILENO, &c, 1) != 1) { /* error/EOF? */
+                        option_mask32 |= OPT_EOF;
+                        return scan_mask;
+                }
+
+                if (c == initial_settings.c_cc[VINTR])
+                        return EXIT_MASK;
+                if (c == initial_settings.c_cc[VEOF])
+                        return EXIT_MASK;
+                c |= 0x20; /* lowercase */
+                if (c == 'q')
+                        return EXIT_MASK;
+
+                if (c == 'n') {
+                        IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
+                        sort_function[0] = pid_sort;
+                        continue;
+                }
+                if (c == 'm') {
+                        IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
+                        sort_function[0] = mem_sort;
+# if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+                        sort_function[1] = pcpu_sort;
+                        sort_function[2] = time_sort;
+# endif
+                        continue;
+                }
+# if ENABLE_FEATURE_SHOW_THREADS
+                if (c == 'h'
+                 IF_FEATURE_TOPMEM(&& scan_mask != TOPMEM_MASK)
+                ) {
+                        scan_mask ^= PSSCAN_TASKS;
+                        continue;
+                }
+# endif
+# if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
+                if (c == 'p') {
+                        IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
+                        sort_function[0] = pcpu_sort;
+                        sort_function[1] = mem_sort;
+                        sort_function[2] = time_sort;
+                        continue;
+                }
+                if (c == 't') {
+                        IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
+                        sort_function[0] = time_sort;
+                        sort_function[1] = mem_sort;
+                        sort_function[2] = pcpu_sort;
+                        continue;
+                }
+#  if ENABLE_FEATURE_TOPMEM
+                if (c == 's') {
+                        scan_mask = TOPMEM_MASK;
+                        free(prev_hist);
+                        prev_hist = NULL;
+                        prev_hist_count = 0;
+                        sort_field = (sort_field + 1) % NUM_SORT_FIELD;
+                        continue;
+                }
+#  endif
+                if (c == 'r') {
+                        inverted ^= 1;
+                        continue;
+                }
+#  if ENABLE_FEATURE_TOP_SMP_CPU
+                /* procps-2.0.18 uses 'C', 3.2.7 uses '1' */
+                if (c == 'c' || c == '1') {
+                        /* User wants to toggle per cpu <> aggregate */
+                        if (smp_cpu_info) {
+                                free(cpu_prev_jif);
+                                free(cpu_jif);
+                                cpu_jif = &cur_jif;
+                                cpu_prev_jif = &prev_jif;
+                        } else {
+                                /* Prepare for xrealloc() */
+                                cpu_jif = cpu_prev_jif = NULL;
+                        }
+                        num_cpus = 0;
+                        smp_cpu_info = !smp_cpu_info;
+                        get_jiffy_counts();
+                        continue;
+                }
+#  endif
+# endif
+                break; /* unknown key -> force refresh */
+        }
+
+        return scan_mask;
+}
+#endif
+
 //usage:#if ENABLE_FEATURE_SHOW_THREADS || ENABLE_FEATURE_TOP_SMP_CPU
 //usage:# define IF_SHOW_THREADS_OR_TOP_SMP(...) __VA_ARGS__
 //usage:#else
@@ -871,8 +977,9 @@ enum {
 //usage:                IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE("/cpu")
 //usage:                IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE("/time")
 //usage:        IF_FEATURE_TOPMEM(
-//usage:   "\n""        S: show memory, R: reverse memory sort"
+//usage:   "\n""        S: show memory"
 //usage:        )
+//usage:   "\n""        R: reverse sort"
 //usage:        IF_SHOW_THREADS_OR_TOP_SMP(
 //usage:   "\n""        "
 //usage:                IF_FEATURE_SHOW_THREADS("H: toggle threads")
@@ -880,23 +987,36 @@ enum {
 //usage:                IF_FEATURE_TOP_SMP_CPU("1: toggle SMP")
 //usage:        )
 //usage:   "\n""        Q,^C: exit"
+//usage:   "\n"
+//usage:   "\n""Options:"
+//usage:   "\n""        -b      Batch mode"
+//usage:   "\n""        -n N    Exit after N iterations"
+//usage:   "\n""        -d N    Delay between updates"
+//usage:        IF_FEATURE_TOPMEM(
+//usage:   "\n""        -m      Same as 's' key"
+//usage:        )
+
+/* Interactive testing:
+ * echo sss | ./busybox top
+ * - shows memory screen
+ * echo sss | ./busybox top -bn1 >mem
+ * - saves memory screen - the *whole* list, not first NROWS processes!
+ * echo .m.s.s.s.s.s.s.q | ./busybox top -b >z
+ * - saves several different screens, and exits
+ *
+ * TODO: -i STRING param as a better alternative?
+ */
 
 int top_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int top_main(int argc UNUSED_PARAM, char **argv)
 {
         int iterations;
         unsigned lines, col;
-        int lines_rem;
         unsigned interval;
         char *str_interval, *str_iterations;
         unsigned scan_mask = TOP_MASK;
 #if ENABLE_FEATURE_USE_TERMIOS
         struct termios new_settings;
-        struct pollfd pfd[1];
-        unsigned char c;
-
-        pfd[0].fd = 0;
-        pfd[0].events = POLLIN;
 #endif
 
         INIT_G();
@@ -933,15 +1053,6 @@ int top_main(int argc UNUSED_PARAM, char **argv)
 
         /* change to /proc */
         xchdir("/proc");
-#if ENABLE_FEATURE_USE_TERMIOS
-        tcgetattr(0, (void *) &initial_settings);
-        memcpy(&new_settings, &initial_settings, sizeof(new_settings));
-        /* unbuffered input, turn off echo */
-        new_settings.c_lflag &= ~(ISIG | ICANON | ECHO | ECHONL);
-
-        bb_signals(BB_FATAL_SIGS, sig_catcher);
-        tcsetattr_stdin_TCSANOW(&new_settings);
-#endif
 
 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
         sort_function[0] = pcpu_sort;
@@ -951,21 +1062,41 @@ int top_main(int argc UNUSED_PARAM, char **argv)
         sort_function[0] = mem_sort;
 #endif
 
-        while (1) {
+#if ENABLE_FEATURE_USE_TERMIOS
+        tcgetattr(0, (void *) &initial_settings);
+        memcpy(&new_settings, &initial_settings, sizeof(new_settings));
+        if (!OPT_BATCH_MODE) {
+                /* unbuffered input, turn off echo */
+                new_settings.c_lflag &= ~(ISIG | ICANON | ECHO | ECHONL);
+                tcsetattr_stdin_TCSANOW(&new_settings);
+        }
+
+        bb_signals(BB_FATAL_SIGS, sig_catcher);
+
+        /* Eat initial input, if any */
+        scan_mask = handle_input(scan_mask, 0);
+#endif
+
+        while (scan_mask != EXIT_MASK) {
                 procps_status_t *p = NULL;
 
-                lines = 24; /* default */
-                col = 79;
+                if (OPT_BATCH_MODE) {
+                        lines = INT_MAX;
+                        col = LINE_BUF_SIZE - 2; /* +2 bytes for '\n', NUL */
+                } else {
+                        lines = 24; /* default */
+                        col = 79;
 #if ENABLE_FEATURE_USE_TERMIOS
-                /* We output to stdout, we need size of stdout (not stdin)! */
-                get_terminal_width_height(STDOUT_FILENO, &col, &lines);
-                if (lines < 5 || col < 10) {
-                        sleep(interval);
-                        continue;
-                }
+                        /* We output to stdout, we need size of stdout (not stdin)! */
+                        get_terminal_width_height(STDOUT_FILENO, &col, &lines);
+                        if (lines < 5 || col < 10) {
+                                sleep(interval);
+                                continue;
+                        }
 #endif
-                if (col > LINE_BUF_SIZE-2) /* +2 bytes for '\n', NUL, */
-                        col = LINE_BUF_SIZE-2;
+                        if (col > LINE_BUF_SIZE - 2)
+                                col = LINE_BUF_SIZE - 2;
+                }
 
                 /* read process IDs & status for all the processes */
                 while ((p = procps_scan(p, scan_mask)) != NULL) {
@@ -1033,15 +1164,11 @@ int top_main(int argc UNUSED_PARAM, char **argv)
                         qsort(topmem, ntop, sizeof(topmem_status_t), (void*)topmem_sort);
                 }
 #endif
-                lines_rem = lines;
-                if (OPT_BATCH_MODE) {
-                        lines_rem = INT_MAX;
-                }
                 if (scan_mask != TOPMEM_MASK)
-                        display_process_list(lines_rem, col);
+                        display_process_list(lines, col);
 #if ENABLE_FEATURE_TOPMEM
                 else
-                        display_topmem_process_list(lines_rem, col);
+                        display_topmem_process_list(lines, col);
 #endif
                 clearmems();
                 if (iterations >= 0 && !--iterations)
@@ -1049,84 +1176,13 @@ int top_main(int argc UNUSED_PARAM, char **argv)
 #if !ENABLE_FEATURE_USE_TERMIOS
                 sleep(interval);
 #else
-                if (option_mask32 & (OPT_b|OPT_EOF))
-                         /* batch mode, or EOF on stdin ("top </dev/null") */
+                if (option_mask32 & OPT_EOF)
+                        /* EOF on stdin ("top </dev/null") */
                         sleep(interval);
-                else if (safe_poll(pfd, 1, interval * 1000) > 0) {
-                        if (safe_read(STDIN_FILENO, &c, 1) != 1) { /* error/EOF? */
-                                option_mask32 |= OPT_EOF;
-                                continue;
-                        }
-                        if (c == initial_settings.c_cc[VINTR])
-                                break;
-                        c |= 0x20; /* lowercase */
-                        if (c == 'q')
-                                break;
-                        if (c == 'n') {
-                                IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
-                                sort_function[0] = pid_sort;
-                        }
-                        if (c == 'm') {
-                                IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
-                                sort_function[0] = mem_sort;
-# if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
-                                sort_function[1] = pcpu_sort;
-                                sort_function[2] = time_sort;
-# endif
-                        }
-# if ENABLE_FEATURE_SHOW_THREADS
-                        if (c == 'h'
-                         IF_FEATURE_TOPMEM(&& scan_mask != TOPMEM_MASK)
-                        ) {
-                                scan_mask ^= PSSCAN_TASKS;
-                        }
-# endif
-# if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
-                        if (c == 'p') {
-                                IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
-                                sort_function[0] = pcpu_sort;
-                                sort_function[1] = mem_sort;
-                                sort_function[2] = time_sort;
-                        }
-                        if (c == 't') {
-                                IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
-                                sort_function[0] = time_sort;
-                                sort_function[1] = mem_sort;
-                                sort_function[2] = pcpu_sort;
-                        }
-#  if ENABLE_FEATURE_TOPMEM
-                        if (c == 's') {
-                                scan_mask = TOPMEM_MASK;
-                                free(prev_hist);
-                                prev_hist = NULL;
-                                prev_hist_count = 0;
-                                sort_field = (sort_field + 1) % NUM_SORT_FIELD;
-                        }
-                        if (c == 'r')
-                                inverted ^= 1;
-#  endif
-#  if ENABLE_FEATURE_TOP_SMP_CPU
-                        /* procps-2.0.18 uses 'C', 3.2.7 uses '1' */
-                        if (c == 'c' || c == '1') {
-                                /* User wants to toggle per cpu <> aggregate */
-                                if (smp_cpu_info) {
-                                        free(cpu_prev_jif);
-                                        free(cpu_jif);
-                                        cpu_jif = &cur_jif;
-                                        cpu_prev_jif = &prev_jif;
-                                } else {
-                                        /* Prepare for xrealloc() */
-                                        cpu_jif = cpu_prev_jif = NULL;
-                                }
-                                num_cpus = 0;
-                                smp_cpu_info = !smp_cpu_info;
-                                get_jiffy_counts();
-                        }
-#  endif
-# endif
-                }
+                else
+                        scan_mask = handle_input(scan_mask, interval);
 #endif /* FEATURE_USE_TERMIOS */
-        } /* end of "while (1)" */
+        } /* end of "while (not Q)" */
 
         bb_putchar('\n');
 #if ENABLE_FEATURE_USE_TERMIOS
diff --git a/runit/sv.c b/runit/sv.c
index 322688a36..5b01c875c 100644
--- a/runit/sv.c
+++ b/runit/sv.c
@@ -437,7 +437,6 @@ static int control(const char *a)
 int sv_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int sv_main(int argc UNUSED_PARAM, char **argv)
 {
-        unsigned opt;
         char *x;
         char *action;
         const char *varservice = CONFIG_SV_DEFAULT_SERVICE_DIR;
@@ -458,7 +457,7 @@ int sv_main(int argc UNUSED_PARAM, char **argv)
         if (x) waitsec = xatou(x);
 
         opt_complementary = "w+:vv"; /* -w N, -v is a counter */
-        opt = getopt32(argv, "w:v", &waitsec, &verbose);
+        getopt32(argv, "w:v", &waitsec, &verbose);
         argv += optind;
         action = *argv++;
         if (!action || !*argv) bb_show_usage();
diff --git a/scripts/defconfig.tig b/scripts/defconfig.tig
index ab9dc4728..e19217f08 100644
--- a/scripts/defconfig.tig
+++ b/scripts/defconfig.tig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
 # Busybox version: 1.19.0.git
-# Thu Mar 22 14:00:24 2012
+# Thu Mar 22 15:00:34 2012
 #
 CONFIG_HAVE_DOT_CONFIG=y
 # CONFIG_PLATFORM_POSIX is not set
@@ -615,11 +615,13 @@ CONFIG_HD=y
 # CONFIG_CONSPY is not set
 # CONFIG_NANDWRITE is not set
 # CONFIG_NANDDUMP is not set
+# CONFIG_SETSERIAL is not set
 # CONFIG_UBIATTACH is not set
 # CONFIG_UBIDETACH is not set
 # CONFIG_UBIMKVOL is not set
 # CONFIG_UBIRMVOL is not set
 # CONFIG_UBIRSVOL is not set
+# CONFIG_UBIUPDATEVOL is not set
 # CONFIG_ADJTIMEX is not set
 CONFIG_BBCONFIG=y
 CONFIG_FEATURE_COMPRESS_BBCONFIG=y
@@ -826,6 +828,7 @@ CONFIG_DHCPD_LEASES_FILE=""
 # CONFIG_FEATURE_UDHCP_PORT is not set
 CONFIG_UDHCP_DEBUG=0
 # CONFIG_FEATURE_UDHCP_RFC3397 is not set
+# CONFIG_FEATURE_UDHCP_8021Q is not set
 CONFIG_UDHCPC_DEFAULT_SCRIPT=""
 CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS=0
 CONFIG_IFUPDOWN_UDHCPC_CMD_OPTIONS=""
diff --git a/scripts/kconfig/conf.c b/scripts/kconfig/conf.c
index 6e097889f..ea2446a89 100644
--- a/scripts/kconfig/conf.c
+++ b/scripts/kconfig/conf.c
@@ -173,7 +173,7 @@ static void conf_askvalue(struct symbol *sym, const char *def)
 int conf_string(struct menu *menu)
 {
         struct symbol *sym = menu->sym;
-        const char *def, *help;
+        const char *def;
 
         while (1) {
                 printf("%*s%s ", indent - 1, "", menu->prompt->text);
@@ -188,10 +188,7 @@ int conf_string(struct menu *menu)
                 case '?':
                         /* print help */
                         if (line[1] == '\n') {
-                                help = nohelp_text;
-                                if (menu->sym->help)
-                                        help = menu->sym->help;
-                                printf("\n%s\n", menu->sym->help);
+                                printf("\n%s\n", menu->sym->help ? menu->sym->help : nohelp_text);
                                 def = NULL;
                                 break;
                         }
@@ -207,7 +204,6 @@ int conf_string(struct menu *menu)
 static int conf_sym(struct menu *menu)
 {
         struct symbol *sym = menu->sym;
-        int type;
         tristate oldval, newval;
         const char *help;
 
@@ -215,7 +211,6 @@ static int conf_sym(struct menu *menu)
                 printf("%*s%s ", indent - 1, "", menu->prompt->text);
                 if (sym->name)
                         printf("(%s) ", sym->name);
-                type = sym_get_type(sym);
                 putchar('[');
                 oldval = sym_get_tristate_value(sym);
                 switch (oldval) {
@@ -282,11 +277,9 @@ static int conf_choice(struct menu *menu)
 {
         struct symbol *sym, *def_sym;
         struct menu *child;
-        int type;
         bool is_new;
 
         sym = menu->sym;
-        type = sym_get_type(sym);
         is_new = !sym_has_value(sym);
         if (sym_is_changable(sym)) {
                 conf_sym(menu);
diff --git a/scripts/kconfig/lxdialog/textbox.c b/scripts/kconfig/lxdialog/textbox.c
index 77848bb8e..de4ae41d7 100644
--- a/scripts/kconfig/lxdialog/textbox.c
+++ b/scripts/kconfig/lxdialog/textbox.c
@@ -38,11 +38,8 @@ int dialog_textbox(const char *title, const char *file, int height, int width)
 {
         int i, x, y, cur_x, cur_y, fpos, key = 0;
         int passed_end;
-        char search_term[MAX_LEN + 1];
         WINDOW *dialog, *text;
 
-        search_term[0] = '\0';  /* no search term entered yet */
-
         /* Open input file for reading */
         if ((fd = open(file, O_RDONLY)) == -1) {
                 endwin();
@@ -437,7 +434,6 @@ static void print_page(WINDOW * win, int height, int width)
  */
 static void print_line(WINDOW * win, int row, int width)
 {
-        int y, x;
         char *line;
 
         line = get_line();
@@ -446,11 +442,13 @@ static void print_line(WINDOW * win, int row, int width)
         waddch(win, ' ');
         waddnstr(win, line, MIN(strlen(line), width - 2));
 
-        getyx(win, y, x);
         /* Clear 'residue' of previous line */
 #if OLD_NCURSES
         {
                 int i;
+                int y, x;
+
+                getyx(win, y, x);
                 for (i = 0; i < width - x; i++)
                         waddch(win, ' ');
         }
diff --git a/scripts/trylink b/scripts/trylink
index 5994a757b..a8b0b2e03 100755
--- a/scripts/trylink
+++ b/scripts/trylink
@@ -255,6 +255,7 @@ if test "$CONFIG_FEATURE_SHARED_BUSYBOX" = y; then
             $GC_SECTIONS \
             $START_GROUP $O_FILES $END_GROUP \
             -L"$sharedlib_dir" -lbusybox \
+            $l_list \
             $INFO_OPTS \
     || {
         echo "Linking $EXE failed"
diff --git a/selinux/chcon.c b/selinux/chcon.c
index 8644502b5..88d0cfec6 100644
--- a/selinux/chcon.c
+++ b/selinux/chcon.c
@@ -40,7 +40,6 @@
 //usage:     "\n        -R      Recurse"
 //usage:        )
 
-#include <getopt.h>
 #include <selinux/context.h>
 
 #include "libbb.h"
diff --git a/selinux/runcon.c b/selinux/runcon.c
index f0b21269f..3183a2274 100644
--- a/selinux/runcon.c
+++ b/selinux/runcon.c
@@ -50,7 +50,6 @@
 //usage:     "\n        -l RNG  Levelrange"
 //usage:        )
 
-#include <getopt.h>
 #include <selinux/context.h>
 #include <selinux/flask.h>
 
diff --git a/shell/ash.c b/shell/ash.c
index eaaa71967..a809bf181 100644
--- a/shell/ash.c
+++ b/shell/ash.c
@@ -6276,7 +6276,7 @@ expbackq(union node *cmd, int quoted, int quotes)
  read:
                 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)
                         break;
@@ -10120,7 +10120,7 @@ preadfd(void)
 #if ENABLE_FEATURE_EDITING
  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 {
                 int timeout = -1;
 # if ENABLE_ASH_IDLE_TIMEOUT
@@ -10166,10 +10166,10 @@ preadfd(void)
                 }
         }
 #else
-        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);
 #endif
 
-#if 0 /* disabled: nonblock_safe_read() handles this problem */
+#if 0 /* disabled: nonblock_immune_read() handles this problem */
         if (nr < 0) {
                 if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
                         int flags = fcntl(0, F_GETFL);
diff --git a/shell/hush.c b/shell/hush.c
index d3e957c2f..1082738a2 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -106,6 +106,10 @@
 # define PIPE_BUF 4096  /* amount of buffering in a pipe */
 #endif
 
+/* Not every libc has sighandler_t. Fix it */
+typedef void (*hush_sighandler_t)(int);
+#define sighandler_t hush_sighandler_t
+
 //config:config HUSH
 //config:       bool "hush"
 //config:       default y
@@ -256,7 +260,7 @@
  * therefore we don't show them either.
  */
 //usage:#define hush_trivial_usage
-//usage:        "[-nx] [-c 'SCRIPT' [ARG0 [ARGS]] / FILE [ARGS]]"
+//usage:        "[-nxl] [-c 'SCRIPT' [ARG0 [ARGS]] / FILE [ARGS]]"
 //usage:#define hush_full_usage "\n\n"
 //usage:        "Unix shell interpreter"
 
@@ -445,6 +449,15 @@ enum {
 /* Used for initialization: o_string foo = NULL_O_STRING; */
 #define NULL_O_STRING { NULL }
 
+#ifndef debug_printf_parse
+static const char *const assignment_flag[] = {
+        "MAYBE_ASSIGNMENT",
+        "DEFINITELY_ASSIGNMENT",
+        "NOT_ASSIGNMENT",
+        "WORD_IS_KEYWORD",
+};
+#endif
+
 typedef struct in_str {
         const char *p;
         /* eof_flag=1: last char in ->p is really an EOF */
@@ -764,7 +777,6 @@ struct globals {
         smalluint last_exitcode;
         /* 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;
         char **global_argv;
@@ -792,15 +804,27 @@ struct globals {
         unsigned handled_SIGCHLD;
         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];
 };
 #define G (*ptr_to_globals)
@@ -809,6 +833,9 @@ struct globals {
  * is global, thus "G." prefix is a useful hint */
 #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)
 
 
@@ -1319,12 +1346,14 @@ static void restore_G_args(save_arg_t *sv, char **argv)
  *    "echo $$; sleep 5 & wait; ls -l" + "kill -INT <pid>"
  *    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,
  * i.e. we block all signals which need to have special handling as described
@@ -1332,11 +1361,11 @@ static void restore_G_args(save_arg_t *sv, char **argv)
  * After each pipe execution, we extract any pending signals via sigtimedwait()
  * and act on them.
  *
- * unsigned non_DFL_mask: a mask of such "special" signals
+ * 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 '')
  * after [v]fork, if we plan to be a shell:
@@ -1355,6 +1384,49 @@ static void restore_G_args(save_arg_t *sv, char **argv)
  * 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.
+ *
+ * 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 {
         SPECIAL_INTERACTIVE_SIGS = 0
@@ -1362,21 +1434,43 @@ enum {
                 | (1 << SIGINT)
                 | (1 << SIGHUP)
                 ,
-        SPECIAL_JOB_SIGS = 0
+        SPECIAL_JOBSTOP_SIGS = 0
 #if ENABLE_HUSH_JOB
                 | (1 << SIGTTIN)
                 | (1 << SIGTTOU)
                 | (1 << SIGTSTP)
 #endif
+                ,
 };
 
-#if ENABLE_HUSH_FAST
-static void SIGCHLD_handler(int sig UNUSED_PARAM)
+static void record_pending_signo(int sig)
 {
-        G.count_SIGCHLD++;
+        sigaddset(&G.pending_set, sig);
+#if ENABLE_HUSH_FAST
+        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
+}
+
+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
 
@@ -1393,13 +1487,15 @@ static void SIGCHLD_handler(int sig UNUSED_PARAM)
 static void sigexit(int sig) NORETURN;
 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 */
         if (sig <= 0)
@@ -1414,15 +1510,39 @@ static void sigexit(int sig)
 
 #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)
 {
         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 */
                 argv[1] = G.traps[0];
@@ -1459,28 +1579,30 @@ static void hush_exit(int exitcode)
 }
 
 
-static int check_and_run_traps(int sig)
+//TODO: return a mask of ALL handled sigs?
+static int check_and_run_traps(void)
 {
-        /* 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;
         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 */
                                 argv[1] = G.traps[sig];
@@ -1488,21 +1610,17 @@ static int check_and_run_traps(int sig)
                                 save_rcode = G.last_exitcode;
                                 builtin_eval(argv);
                                 G.last_exitcode = save_rcode;
+                                last_sig = sig;
                         } /* else: "" trap, ignoring signal */
                         continue;
                 }
                 /* 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
                 case SIGHUP: {
@@ -1519,8 +1637,23 @@ static int check_and_run_traps(int sig)
                         sigexit(SIGHUP);
                 }
 #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;
                 }
         }
@@ -1911,7 +2044,7 @@ static void get_user_input(struct in_str *i)
                  * only after <Enter>. (^C will work) */
                 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);
         if (i->eof_flag) { /* EOF/error detected */
@@ -1921,11 +2054,18 @@ static void get_user_input(struct in_str *i)
 # else
         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);
 # endif
@@ -2902,24 +3042,24 @@ static const struct reserved_combo* match_reserved_word(o_string *word)
          */
         static const struct reserved_combo reserved_list[] = {
 # if ENABLE_HUSH_IF
-                { "!",     RES_NONE,  NOT_ASSIGNMENT , 0 },
-                { "if",    RES_IF,    WORD_IS_KEYWORD, FLAG_THEN | FLAG_START },
-                { "then",  RES_THEN,  WORD_IS_KEYWORD, FLAG_ELIF | FLAG_ELSE | FLAG_FI },
-                { "elif",  RES_ELIF,  WORD_IS_KEYWORD, FLAG_THEN },
-                { "else",  RES_ELSE,  WORD_IS_KEYWORD, FLAG_FI   },
-                { "fi",    RES_FI,    NOT_ASSIGNMENT , FLAG_END  },
+                { "!",     RES_NONE,  NOT_ASSIGNMENT  , 0 },
+                { "if",    RES_IF,    MAYBE_ASSIGNMENT, FLAG_THEN | FLAG_START },
+                { "then",  RES_THEN,  MAYBE_ASSIGNMENT, FLAG_ELIF | FLAG_ELSE | FLAG_FI },
+                { "elif",  RES_ELIF,  MAYBE_ASSIGNMENT, FLAG_THEN },
+                { "else",  RES_ELSE,  MAYBE_ASSIGNMENT, FLAG_FI   },
+                { "fi",    RES_FI,    NOT_ASSIGNMENT  , FLAG_END  },
 # endif
 # if ENABLE_HUSH_LOOPS
-                { "for",   RES_FOR,   NOT_ASSIGNMENT , FLAG_IN | FLAG_DO | FLAG_START },
-                { "while", RES_WHILE, WORD_IS_KEYWORD, FLAG_DO | FLAG_START },
-                { "until", RES_UNTIL, WORD_IS_KEYWORD, FLAG_DO | FLAG_START },
-                { "in",    RES_IN,    NOT_ASSIGNMENT , FLAG_DO   },
-                { "do",    RES_DO,    WORD_IS_KEYWORD, FLAG_DONE },
-                { "done",  RES_DONE,  NOT_ASSIGNMENT , FLAG_END  },
+                { "for",   RES_FOR,   NOT_ASSIGNMENT  , FLAG_IN | FLAG_DO | FLAG_START },
+                { "while", RES_WHILE, MAYBE_ASSIGNMENT, FLAG_DO | FLAG_START },
+                { "until", RES_UNTIL, MAYBE_ASSIGNMENT, FLAG_DO | FLAG_START },
+                { "in",    RES_IN,    NOT_ASSIGNMENT  , FLAG_DO   },
+                { "do",    RES_DO,    MAYBE_ASSIGNMENT, FLAG_DONE },
+                { "done",  RES_DONE,  NOT_ASSIGNMENT  , FLAG_END  },
 # endif
 # if ENABLE_HUSH_CASE
-                { "case",  RES_CASE,  NOT_ASSIGNMENT , FLAG_MATCH | FLAG_START },
-                { "esac",  RES_ESAC,  NOT_ASSIGNMENT , FLAG_END  },
+                { "case",  RES_CASE,  NOT_ASSIGNMENT  , FLAG_MATCH | FLAG_START },
+                { "esac",  RES_ESAC,  NOT_ASSIGNMENT  , FLAG_END  },
 # endif
         };
         const struct reserved_combo *r;
@@ -2985,6 +3125,7 @@ static int reserved_word(o_string *word, struct parse_context *ctx)
         ctx->ctx_res_w = r->res;
         ctx->old_flag = r->flag;
         word->o_assignment = r->assignment_flag;
+        debug_printf_parse("word->o_assignment='%s'\n", assignment_flag[word->o_assignment]);
 
         if (ctx->old_flag & FLAG_END) {
                 struct parse_context *old;
@@ -3051,18 +3192,6 @@ static int done_word(o_string *word, struct parse_context *ctx)
                 debug_printf_parse("word stored in rd_filename: '%s'\n", word->data);
                 ctx->pending_redirect = NULL;
         } else {
-                /* If this word wasn't an assignment, next ones definitely
-                 * can't be assignments. Even if they look like ones. */
-                if (word->o_assignment != DEFINITELY_ASSIGNMENT
-                 && word->o_assignment != WORD_IS_KEYWORD
-                ) {
-                        word->o_assignment = NOT_ASSIGNMENT;
-                } else {
-                        if (word->o_assignment == DEFINITELY_ASSIGNMENT)
-                                command->assignment_cnt++;
-                        word->o_assignment = MAYBE_ASSIGNMENT;
-                }
-
 #if HAS_KEYWORDS
 # if ENABLE_HUSH_CASE
                 if (ctx->ctx_dsemicolon
@@ -3082,8 +3211,9 @@ static int done_word(o_string *word, struct parse_context *ctx)
                  && ctx->ctx_res_w != RES_CASE
 # endif
                 ) {
-                        debug_printf_parse("checking '%s' for reserved-ness\n", word->data);
-                        if (reserved_word(word, ctx)) {
+                        int reserved = reserved_word(word, ctx);
+                        debug_printf_parse("checking for reserved-ness: %d\n", reserved);
+                        if (reserved) {
                                 o_reset_to_empty_unquoted(word);
                                 debug_printf_parse("done_word return %d\n",
                                                 (ctx->ctx_res_w == RES_SNTX));
@@ -3104,6 +3234,23 @@ static int done_word(o_string *word, struct parse_context *ctx)
                                         "groups and arglists don't mix\n");
                         return 1;
                 }
+
+                /* If this word wasn't an assignment, next ones definitely
+                 * can't be assignments. Even if they look like ones. */
+                if (word->o_assignment != DEFINITELY_ASSIGNMENT
+                 && word->o_assignment != WORD_IS_KEYWORD
+                ) {
+                        word->o_assignment = NOT_ASSIGNMENT;
+                } else {
+                        if (word->o_assignment == DEFINITELY_ASSIGNMENT) {
+                                command->assignment_cnt++;
+                                debug_printf_parse("++assignment_cnt=%d\n", command->assignment_cnt);
+                        }
+                        debug_printf_parse("word->o_assignment was:'%s'\n", assignment_flag[word->o_assignment]);
+                        word->o_assignment = MAYBE_ASSIGNMENT;
+                }
+                debug_printf_parse("word->o_assignment='%s'\n", assignment_flag[word->o_assignment]);
+
                 if (word->has_quoted_part
                  /* optimization: and if it's ("" or '') or ($v... or `cmd`...): */
                  && (word->data[0] == '\0' || word->data[0] == SPECIAL_VAR_SYMBOL)
@@ -3322,6 +3469,7 @@ static char *fetch_till_str(o_string *as_string,
         int ch;
 
         goto jump_in;
+
         while (1) {
                 ch = i_getch(input);
                 if (ch != EOF)
@@ -4127,6 +4275,7 @@ static struct pipe *parse_stream(char **pstring,
                          && is_well_formed_var_name(dest.data, '=')
                         ) {
                                 dest.o_assignment = DEFINITELY_ASSIGNMENT;
+                                debug_printf_parse("dest.o_assignment='%s'\n", assignment_flag[dest.o_assignment]);
                         }
                         continue;
                 }
@@ -4176,6 +4325,7 @@ static struct pipe *parse_stream(char **pstring,
                                         heredoc_cnt = 0;
                                 }
                                 dest.o_assignment = MAYBE_ASSIGNMENT;
+                                debug_printf_parse("dest.o_assignment='%s'\n", assignment_flag[dest.o_assignment]);
                                 ch = ';';
                                 /* note: if (is_blank) continue;
                                  * will still trigger for us */
@@ -4225,6 +4375,7 @@ static struct pipe *parse_stream(char **pstring,
                         }
                         done_pipe(&ctx, PIPE_SEQ);
                         dest.o_assignment = MAYBE_ASSIGNMENT;
+                        debug_printf_parse("dest.o_assignment='%s'\n", assignment_flag[dest.o_assignment]);
                         /* 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))
@@ -4331,6 +4482,7 @@ static struct pipe *parse_stream(char **pstring,
                         /* ch is a special char and thus this word
                          * cannot be an assignment */
                         dest.o_assignment = NOT_ASSIGNMENT;
+                        debug_printf_parse("dest.o_assignment='%s'\n", assignment_flag[dest.o_assignment]);
                 }
 
                 /* Note: nommu_addchr(&ctx.as_string, ch) is already done */
@@ -4385,11 +4537,11 @@ static struct pipe *parse_stream(char **pstring,
                         break;
 #if ENABLE_HUSH_TICK
                 case '`': {
-                        unsigned pos;
+                        USE_FOR_NOMMU(unsigned pos;)
 
                         o_addchr(&dest, SPECIAL_VAR_SYMBOL);
                         o_addchr(&dest, '`');
-                        pos = dest.length;
+                        USE_FOR_NOMMU(pos = dest.length;)
                         if (!add_till_backquote(&dest, input, /*in_dquote:*/ 0))
                                 goto parse_error;
 # if !BB_MMU
@@ -4429,6 +4581,7 @@ static struct pipe *parse_stream(char **pstring,
                         /* We just finished a cmd. New one may start
                          * with an assignment */
                         dest.o_assignment = MAYBE_ASSIGNMENT;
+                        debug_printf_parse("dest.o_assignment='%s'\n", assignment_flag[dest.o_assignment]);
                         break;
                 case '&':
                         if (done_word(&dest, &ctx)) {
@@ -5323,6 +5476,25 @@ void re_execute_shell(char ***to_free, const char *s,
                 char *g_argv0, char **g_argv,
                 char **builtin_argv) NORETURN;
 
+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);
+        }
+}
+
 static void reset_traps_to_defaults(void)
 {
         /* This function is always called in a child shell
@@ -5336,47 +5508,36 @@ static void reset_traps_to_defaults(void)
          * Testcase: (while :; do :; done) + ^Z should background.
          * 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;
+        mask = (G.special_sig_mask & SPECIAL_INTERACTIVE_SIGS) | G_fatal_sig_mask;
+        if (!G.traps && !mask)
+                return; /* already no traps and no special 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;
+        /* 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);
+                install_sighandler(sig, pick_sighandler(sig));
         }
-        sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
 }
 
 #else /* !BB_MMU */
@@ -5487,9 +5648,6 @@ static void re_execute_shell(char ***to_free, const char *s,
          * _inside_ group (just before echo 1), it works.
          *
          * 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";
         *pp++ = (char *) s;
@@ -5506,7 +5664,9 @@ static void re_execute_shell(char ***to_free, const char *s,
 
  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 */
         if (argv[0][0] == '/')
@@ -6160,7 +6320,9 @@ static void execvp_or_die(char **argv) NORETURN;
 static void execvp_or_die(char **argv)
 {
         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]);
         _exit(127); /* bash compat */
@@ -6292,7 +6454,9 @@ static NOINLINE void pseudo_exec_argv(nommu_save_t *nommu_save,
 # endif
                         /* 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
                          * executable, fall through */
@@ -6991,9 +7155,6 @@ static NOINLINE int run_pipe(struct pipe *pi)
                         if (setup_redirects(command, NULL))
                                 _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) */
                         /* cast away volatility... */
@@ -7271,7 +7432,7 @@ static int run_list(struct pipe *pi)
                                  * and we don't need to wait for anything. */
                                 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"? */
                                 if (G.flag_break_continue) {
@@ -7303,7 +7464,7 @@ static int run_list(struct pipe *pi)
                                 /* even bash 3.2 doesn't do that well with nested bg:
                                  * try "{ { sleep 10; echo DEEP; } & echo HERE; } &".
                                  * I'm NOT treating inner &'s as jobs */
-                                check_and_run_traps(0);
+                                check_and_run_traps();
 #if ENABLE_HUSH_JOB
                                 if (G.run_list_level == 1)
                                         insert_bg_job(pi);
@@ -7318,13 +7479,13 @@ static int run_list(struct pipe *pi)
                                         /* Waits for completion, then fg's main shell */
                                         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
                                 { /* This one just waits for completion */
                                         rcode = checkjobs(pi);
                                         debug_printf_exec(": checkjobs exitcode %d\n", rcode);
-                                        check_and_run_traps(0);
+                                        check_and_run_traps();
                                 }
                                 G.last_exitcode = rcode;
                         }
@@ -7337,7 +7498,10 @@ static int run_list(struct pipe *pi)
 #endif
 #if ENABLE_HUSH_LOOPS
                 /* Beware of "while false; true; do ..."! */
-                if (pi->next && pi->next->res_word == RES_DO) {
+                if (pi->next
+                 && (pi->next->res_word == RES_DO || pi->next->res_word == RES_DONE)
+                 /* check for RES_DONE is needed for "while ...; do \n done" case */
+                ) {
                         if (rword == RES_WHILE) {
                                 if (rcode) {
                                         /* "while false; do...done" - exitcode 0 */
@@ -7395,88 +7559,81 @@ static int run_and_free_list(struct pipe *pi)
 }
 
 
+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)
+static void install_special_sighandlers(void)
 {
-        unsigned sig;
         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;
+                        mask |= SPECIAL_JOBSTOP_SIGS;
         }
-        G.non_DFL_mask = mask;
-
-        sig = 0;
-        while (mask) {
-                if (mask & 1)
-                        sigaddset(&G.blocked_set, sig);
-                mask >>= 1;
-                sig++;
+        /* 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);
         }
-        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;
 }
 
 #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.
-         */
-        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);
+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 */
-        maybe_set_to_sigexit(SIGPIPE);
-        maybe_set_to_sigexit(SIGALRM);
-        /* if we are interactive, SIGHUP, SIGTERM and SIGINT are masked.
+                + (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 */
-        /*maybe_set_to_sigexit(SIGHUP );*/
-        /*maybe_set_to_sigexit(SIGTERM);*/
-        /*maybe_set_to_sigexit(SIGINT );*/
+         * we never want to restore pgrp on exit, and this fn is not called
+         */
+                /*+ (1 << SIGHUP )*/
+                /*+ (1 << SIGTERM)*/
+                /*+ (1 << SIGINT )*/
+        ;
+        G_fatal_sig_mask = mask;
+
+        install_sighandlers(mask);
 }
 #endif
 
@@ -7522,6 +7679,10 @@ static int set_mode(int state, char mode, const char *o_opt)
 int hush_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int hush_main(int argc, char **argv)
 {
+        enum {
+                OPT_login = (1 << 0),
+        };
+        unsigned flags;
         int opt;
         unsigned builtin_argc;
         char **e;
@@ -7529,8 +7690,11 @@ int hush_main(int argc, char **argv)
         struct variable *shell_ver;
 
         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];
 #endif
@@ -7622,8 +7786,6 @@ int hush_main(int argc, char **argv)
 # endif
 #endif
 
-        G.global_argc = argc;
-        G.global_argv = argv;
         /* Initialize some more globals to non-zero values */
         cmdedit_update_prompt();
 
@@ -7635,17 +7797,18 @@ int hush_main(int argc, char **argv)
         }
 
         /* 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.
          */
 
         /* 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:"
 # if ENABLE_HUSH_FUNCTIONS
@@ -7677,7 +7840,7 @@ int hush_main(int argc, char **argv)
                                 /* -c 'builtin' [BARGV...] "" ARG0 [ARG1...] */
                                 const struct built_in_command *x;
 
-                                init_sigmasks();
+                                install_special_sighandlers();
                                 x = find_builtin(optarg);
                                 if (x) { /* paranoia */
                                         G.global_argc -= builtin_argc; /* skip [BARGV...] "" */
@@ -7694,7 +7857,7 @@ int hush_main(int argc, char **argv)
                                 G.global_argv[0] = argv[0];
                                 G.global_argc++;
                         } /* else -c 'script' ARG0 [ARG1...]: $0 is ARG0 */
-                        init_sigmasks();
+                        install_special_sighandlers();
                         parse_and_run_string(optarg);
                         goto final_return;
                 case 'i':
@@ -7706,6 +7869,9 @@ int hush_main(int argc, char **argv)
                         /* "-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
                 case '<': /* "big heredoc" support */
                         full_write1_str(optarg);
@@ -7726,15 +7892,14 @@ int hush_main(int argc, char **argv)
                         empty_trap_mask = bb_strtoull(optarg, &optarg, 16);
                         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
                         optarg++;
@@ -7772,19 +7937,24 @@ int hush_main(int argc, char **argv)
                 }
         } /* 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();
                 G.root_ppid = getppid();
         }
 
         /* If we are login shell... */
-        if (argv[0] && argv[0][0] == '-') {
+        if (flags & OPT_login) {
                 FILE *input;
                 debug_printf("sourcing /etc/profile\n");
                 input = fopen_for_read("/etc/profile");
                 if (input != NULL) {
                         close_on_exec_on(fileno(input));
-                        init_sigmasks();
+                        install_special_sighandlers();
                         parse_and_run_file(input);
                         fclose(input);
                 }
@@ -7797,19 +7967,19 @@ int hush_main(int argc, char **argv)
                  */
         }
 
-        if (argv[optind]) {
+        if (G.global_argv[1]) {
                 FILE *input;
                 /*
                  * "bash <script>" (which is never interactive (unless -i?))
                  * sources $BASH_ENV here (without scanning $PATH).
                  * 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
                 fclose(input);
@@ -7818,7 +7988,7 @@ int hush_main(int argc, char **argv)
         }
 
         /* 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.
          */
 
         /* A shell is interactive if the '-i' flag was given,
@@ -7870,12 +8040,12 @@ int hush_main(int argc, char **argv)
                         }
                 }
 
-                /* 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) */
                         bb_setpgrp(); /* is the same as setpgid(our_pid, our_pid); */
@@ -7886,7 +8056,7 @@ int hush_main(int argc, char **argv)
                  * (we reset die_sleep = 0 whereever we [v]fork) */
                 enable_restore_tty_pgrp_on_exit(); /* sets die_sleep = -1 */
         } else {
-                init_sigmasks();
+                install_special_sighandlers();
         }
 #elif ENABLE_HUSH_INTERACTIVE
         /* No job control compiled in, only prompt/line editing */
@@ -7903,10 +8073,10 @@ int hush_main(int argc, char **argv)
         if (G_interactive_fd) {
                 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:
          * if interactive but not a login shell, sources ~/.bashrc
@@ -8040,7 +8210,7 @@ static int FAST_FUNC builtin_exec(char **argv)
                 tcsetpgrp(G_interactive_fd, G_saved_tty_pgrp);
 
         /* 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.
          */
         execvp_or_die(argv);
@@ -8237,6 +8407,8 @@ static int FAST_FUNC builtin_trap(char **argv)
  process_sig_list:
                 ret = EXIT_SUCCESS;
                 while (*argv) {
+                        sighandler_t handler;
+
                         sig = get_signum(*argv++);
                         if (sig < 0 || sig >= NSIG) {
                                 ret = EXIT_FAILURE;
@@ -8255,18 +8427,13 @@ static int FAST_FUNC builtin_trap(char **argv)
                         if (sig == 0)
                                 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);
-                        }
+                        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);
                 }
-                sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
                 return ret;
         }
 
@@ -8467,6 +8634,27 @@ static int FAST_FUNC builtin_pwd(char **argv UNUSED_PARAM)
         return EXIT_SUCCESS;
 }
 
+/* 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)
 {
         const char *r;
@@ -8474,6 +8662,7 @@ static int FAST_FUNC builtin_read(char **argv)
         char *opt_p = NULL;
         char *opt_t = NULL;
         char *opt_u = NULL;
+        const char *ifs;
         int read_flags;
 
         /* "!": do not abort on errors.
@@ -8483,10 +8672,12 @@ static int FAST_FUNC builtin_read(char **argv)
         if (read_flags == (uint32_t)-1)
                 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,
                 opt_p,
@@ -8494,6 +8685,12 @@ static int FAST_FUNC builtin_read(char **argv)
                 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) {
                 bb_error_msg("%s", r);
                 r = (char*)(uintptr_t)1;
@@ -8726,7 +8923,7 @@ static int FAST_FUNC builtin_unset(char **argv)
 static int FAST_FUNC builtin_wait(char **argv)
 {
         int ret = EXIT_SUCCESS;
-        int status, sig;
+        int status;
 
         argv = skip_dash_dash(argv);
         if (argv[0] == NULL) {
@@ -8746,25 +8943,53 @@ static int FAST_FUNC builtin_wait(char **argv)
                  * ^C <-- after ~4 sec from keyboard
                  * $
                  */
-                sigaddset(&G.blocked_set, SIGCHLD);
-                sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
                 while (1) {
-                        checkjobs(NULL);
-                        if (errno == ECHILD)
+                        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 */
+                        //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;
-                        /* 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;
-                                }
                         }
+                        /* SIGCHLD, or no signal, or ignored one, such as SIGQUIT. Repeat */
                 }
-                sigdelset(&G.blocked_set, SIGCHLD);
-                sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
                 return ret;
         }
 
diff --git a/shell/hush_test/hush-misc/assignment4.right b/shell/hush_test/hush-misc/assignment4.right
new file mode 100644
index 000000000..31c896f62
--- /dev/null
+++ b/shell/hush_test/hush-misc/assignment4.right
@@ -0,0 +1 @@
+Done:0
diff --git a/shell/hush_test/hush-misc/assignment4.tests b/shell/hush_test/hush-misc/assignment4.tests
new file mode 100755
index 000000000..6f46d0a33
--- /dev/null
+++ b/shell/hush_test/hush-misc/assignment4.tests
@@ -0,0 +1,3 @@
+# There was a bug where we misinterpreted assignments after 'do':
+for i in 1; do eval b=; done
+echo Done:$?
diff --git a/shell/hush_test/hush-misc/while3.right b/shell/hush_test/hush-misc/while3.right
new file mode 100644
index 000000000..7c4d7beb0
--- /dev/null
+++ b/shell/hush_test/hush-misc/while3.right
@@ -0,0 +1 @@
+OK:0
diff --git a/shell/hush_test/hush-misc/while3.tests b/shell/hush_test/hush-misc/while3.tests
new file mode 100755
index 000000000..9132b5f4d
--- /dev/null
+++ b/shell/hush_test/hush-misc/while3.tests
@@ -0,0 +1,4 @@
+while false; do
+    # bash will require at least ":" here...
+done
+echo OK:$?
diff --git a/shell/hush_test/hush-trap/signal_read1.right b/shell/hush_test/hush-trap/signal_read1.right
new file mode 100644
index 000000000..2870a8e70
--- /dev/null
+++ b/shell/hush_test/hush-trap/signal_read1.right
@@ -0,0 +1 @@
+Got HUP:0
diff --git a/shell/hush_test/hush-trap/signal_read1.tests b/shell/hush_test/hush-trap/signal_read1.tests
new file mode 100755
index 000000000..1105479a3
--- /dev/null
+++ b/shell/hush_test/hush-trap/signal_read1.tests
@@ -0,0 +1,5 @@
+(sleep 1; kill -HUP $$) &
+trap 'echo "Got HUP:$?"; exit' HUP
+while true; do
+        read ignored
+done
diff --git a/shell/hush_test/hush-trap/signal_read2.right b/shell/hush_test/hush-trap/signal_read2.right
new file mode 100644
index 000000000..71a6bc16d
--- /dev/null
+++ b/shell/hush_test/hush-trap/signal_read2.right
@@ -0,0 +1,2 @@
+HUP
+Done:129
diff --git a/shell/hush_test/hush-trap/signal_read2.tests b/shell/hush_test/hush-trap/signal_read2.tests
new file mode 100755
index 000000000..eab5b9b5b
--- /dev/null
+++ b/shell/hush_test/hush-trap/signal_read2.tests
@@ -0,0 +1,7 @@
+$THIS_SH -c '
+(sleep 1; kill -HUP $$) &
+while true; do
+        read ignored
+done
+'
+echo "Done:$?"
diff --git a/shell/hush_test/run-all b/shell/hush_test/run-all
index 256f152dc..64a7abc47 100755
--- a/shell/hush_test/run-all
+++ b/shell/hush_test/run-all
@@ -48,8 +48,9 @@ do_test()
                         *.orig|*~) ;;
                         #*) 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
         done
@@ -60,6 +61,7 @@ do_test()
         name="${x%%.tests}"
         test -f "$name.right" || continue
 #       echo Running test: "$x"
+        echo -n "$1/$x:"
         (
                 "$THIS_SH" "./$x" >"$name.xx" 2>&1
                 # filter C library differences
@@ -70,9 +72,9 @@ do_test()
                 diff -u "$name.xx" "$name.right" >"../$1-$x.fail" && rm -f "$name.xx" "../$1-$x.fail"
         )
         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
         exit ${tret}
diff --git a/shell/shell_common.c b/shell/shell_common.c
index 75f4b3e54..4329ca05c 100644
--- a/shell/shell_common.c
+++ b/shell/shell_common.c
@@ -36,6 +36,10 @@ int FAST_FUNC is_well_formed_var_name(const char *s, char terminator)
 
 /* 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().
 //Here we can simply store "VAR=" at buffer start and store read data directly
@@ -51,6 +55,7 @@ shell_builtin_read(void FAST_FUNC (*setvar)(const char *name, const char *val),
         const char *opt_u
 )
 {
+        unsigned err;
         unsigned end_ms; /* -t TIMEOUT */
         int fd; /* -u FD */
         int nchars; /* -n NUM */
@@ -62,6 +67,8 @@ shell_builtin_read(void FAST_FUNC (*setvar)(const char *name, const char *val),
         int startword;
         smallint backslash;
 
+        errno = err = 0;
+
         pp = argv;
         while (*pp) {
                 if (!is_well_formed_var_name(*pp, '\0')) {
@@ -152,28 +159,40 @@ shell_builtin_read(void FAST_FUNC (*setvar)(const char *name, const char *val),
         bufpos = 0;
         do {
                 char c;
+                struct pollfd pfd[1];
+                int timeout;
 
-                if (end_ms) {
-                        int timeout;
-                        struct pollfd pfd[1];
+                if ((bufpos & 0xff) == 0)
+                        buffer = xrealloc(buffer, bufpos + 0x100);
 
-                        pfd[0].fd = fd;
-                        pfd[0].events = POLLIN;
+                timeout = -1;
+                if (end_ms) {
                         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;
                         }
                 }
 
-                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' || (ENABLE_PLATFORM_MINGW32 && c == '\r'))
                         continue;
@@ -240,6 +259,8 @@ shell_builtin_read(void FAST_FUNC (*setvar)(const char *name, const char *val),
         free(buffer);
         if (read_flags & BUILTIN_READ_SILENT)
                 tcsetattr(fd, TCSANOW, &old_tty);
+
+        errno = err;
         return retval;
 }
 
diff --git a/sysklogd/klogd.c b/sysklogd/klogd.c
index 3992081ca..27995e570 100644
--- a/sysklogd/klogd.c
+++ b/sysklogd/klogd.c
@@ -22,7 +22,7 @@
 //usage:#define klogd_full_usage "\n\n"
 //usage:       "Kernel logger\n"
 //usage:     "\nOptions:"
-//usage:     "\n        -c N    Only messages with level < N are printed to console"
+//usage:     "\n        -c N    Print to console messages more urgent than prio N (1-8)"
 //usage:     "\n        -n      Run in foreground"
 
 #include "libbb.h"
diff --git a/sysklogd/syslogd.c b/sysklogd/syslogd.c
index b6f409f41..c5c2a2e86 100644
--- a/sysklogd/syslogd.c
+++ b/sysklogd/syslogd.c
@@ -16,26 +16,33 @@
 //usage:#define syslogd_trivial_usage
 //usage:       "[OPTIONS]"
 //usage:#define syslogd_full_usage "\n\n"
-//usage:       "System logging utility.\n"
-//usage:       "This version of syslogd ignores /etc/syslog.conf\n"
+//usage:       "System logging utility\n"
+//usage:        IF_NOT_FEATURE_SYSLOGD_CFG(
+//usage:       "(this version of syslogd ignores /etc/syslog.conf)\n"
+//usage:        )
 //usage:     "\nOptions:"
 //usage:     "\n        -n              Run in foreground"
-//usage:     "\n        -O FILE         Log to given file (default:/var/log/messages)"
-//usage:     "\n        -l N            Set local log level"
-//usage:     "\n        -S              Smaller logging output"
+//usage:     "\n        -O FILE         Log to FILE (default:/var/log/messages)"
+//usage:     "\n        -l N            Log only messages more urgent than prio N (1-8)"
+//usage:     "\n        -S              Smaller output"
 //usage:        IF_FEATURE_ROTATE_LOGFILE(
-//usage:     "\n        -s SIZE         Max size (KB) before rotate (default:200KB, 0=off)"
-//usage:     "\n        -b N            N rotated logs to keep (default:1, max=99, 0=purge)")
+//usage:     "\n        -s SIZE         Max size (KB) before rotation (default:200KB, 0=off)"
+//usage:     "\n        -b N            N rotated logs to keep (default:1, max=99, 0=purge)"
+//usage:        )
 //usage:        IF_FEATURE_REMOTE_LOG(
 //usage:     "\n        -R HOST[:PORT]  Log to IP or hostname on PORT (default PORT=514/UDP)"
-//usage:     "\n        -L              Log locally and via network (default is network only if -R)")
+//usage:     "\n        -L              Log locally and via network (default is network only if -R)"
+//usage:        )
 //usage:        IF_FEATURE_SYSLOGD_DUP(
-//usage:     "\n        -D              Drop duplicates")
+//usage:     "\n        -D              Drop duplicates"
+//usage:        )
 //usage:        IF_FEATURE_IPC_SYSLOG(
-//usage:     "\n        -C[size(KiB)]   Log to shared mem buffer (read it using logread)")
-//usage:        IF_FEATURE_SYSLOGD_CFG(
-//usage:     "\n        -f FILE         Use FILE as config (default is /etc/syslog.conf)")
 /* NB: -Csize shouldn't have space (because size is optional) */
+//usage:     "\n        -C[size_kb]     Log to shared mem buffer (use logread to read it)"
+//usage:        )
+//usage:        IF_FEATURE_SYSLOGD_CFG(
+//usage:     "\n        -f FILE         Use FILE as config (default:/etc/syslog.conf)"
+//usage:        )
 /* //usage:  "\n        -m MIN          Minutes between MARK lines (default:20, 0=off)" */
 //usage:
 //usage:#define syslogd_example_usage
diff --git a/testsuite/od.tests b/testsuite/od.tests
index 138efedea..fa47b4790 100755
--- a/testsuite/od.tests
+++ b/testsuite/od.tests
@@ -4,7 +4,7 @@
 
 . ./testing.sh
 
-# testing "test name" "options" "expected result" "file input" "stdin"
+# testing "test name" "commands" "expected result" "file input" "stdin"
 
 optional DESKTOP
 testing "od -b" \
@@ -16,4 +16,24 @@ testing "od -b" \
         "" "HELLO"
 SKIP=
 
+optional DESKTOP
+testing "od -b --traditional" \
+        "od -b --traditional" \
+"\
+0000000 110 105 114 114 117
+0000005
+" \
+        "" "HELLO"
+SKIP=
+
+optional DESKTOP
+testing "od -b --traditional FILE" \
+        "od -b --traditional input" \
+"\
+0000000 110 105 114 114 117
+0000005
+" \
+        "HELLO" ""
+SKIP=
+
 exit $FAILCOUNT
diff --git a/testsuite/sed.tests b/testsuite/sed.tests
index 395372ae6..e9d0ed601 100755
--- a/testsuite/sed.tests
+++ b/testsuite/sed.tests
@@ -287,6 +287,9 @@ testing "sed -i with address modifies all files, not only first" \
         "cp input input2; sed -i -e '1s/foo/bar/' input input2 && cat input input2; rm input2" \
         "bar\nbar\n" "foo\n" ""
 
+testing "sed understands \r" \
+        "sed 's/r/\r/'" \
+        "\rrr\n" "" "rrr\n"
 
 # testing "description" "arguments" "result" "infile" "stdin"
 
diff --git a/util-linux/acpid.c b/util-linux/acpid.c
index c9eed2a7f..4b7e5cacb 100644
--- a/util-linux/acpid.c
+++ b/util-linux/acpid.c
@@ -283,7 +283,7 @@ int acpid_main(int argc UNUSED_PARAM, char **argv)
                                 char *buf;
                                 int len;
 
-                                buf = xmalloc_reads(pfd[i].fd, NULL, NULL);
+                                buf = xmalloc_reads(pfd[i].fd, NULL);
                                 /* buf = "button/power PWRB 00000080 00000000" */
                                 len = strlen(buf) - 9;
                                 if (len >= 0)
diff --git a/util-linux/fbset.c b/util-linux/fbset.c
index 75d41b882..3be342481 100644
--- a/util-linux/fbset.c
+++ b/util-linux/fbset.c
@@ -402,7 +402,14 @@ int fbset_main(int argc, char **argv)
         argv++;
         argc--;
         for (; argc > 0 && (thisarg = *argv) != NULL; argc--, argv++) {
-                if (thisarg[0] == '-') for (i = 0; i < ARRAY_SIZE(g_cmdoptions); i++) {
+                if (thisarg[0] != '-') {
+                        if (!ENABLE_FEATURE_FBSET_READMODE || argc != 1)
+                                bb_show_usage();
+                        mode = thisarg;
+                        options |= OPT_READMODE;
+                        goto contin;
+                }
+                for (i = 0; i < ARRAY_SIZE(g_cmdoptions); i++) {
                         if (strcmp(thisarg + 1, g_cmdoptions[i].name) != 0)
                                 continue;
                         if (argc <= g_cmdoptions[i].param_count)
@@ -471,10 +478,7 @@ int fbset_main(int argc, char **argv)
                         argv += g_cmdoptions[i].param_count;
                         goto contin;
                 }
-                if (!ENABLE_FEATURE_FBSET_READMODE || argc != 1)
-                        bb_show_usage();
-                mode = *argv;
-                options |= OPT_READMODE;
+                bb_show_usage();
  contin: ;
         }
 
diff --git a/util-linux/fdisk.c b/util-linux/fdisk.c
index da03e683e..f4fd4d31d 100644
--- a/util-linux/fdisk.c
+++ b/util-linux/fdisk.c
@@ -2846,13 +2846,37 @@ open_list_and_close(const char *device, int user_specified)
         close_dev_fd();
 }
 
+/* Is it a whole disk? The digit check is still useful
+   for Xen devices for example. */
+static int is_whole_disk(const char *disk)
+{
+        unsigned len;
+        int fd = open(disk, O_RDONLY);
+
+        if (fd != -1) {
+                struct hd_geometry geometry;
+                int err = ioctl(fd, HDIO_GETGEO, &geometry);
+                close(fd);
+                if (!err)
+                        return (geometry.start == 0);
+        }
+
+        /* Treat "nameN" as a partition name, not whole disk */
+        /* note: mmcblk0 should work from the geometry check above */
+        len = strlen(disk);
+        if (len != 0 && isdigit(disk[len - 1]))
+                return 0;
+
+        return 1;
+}
+
 /* for fdisk -l: try all things in /proc/partitions
    that look like a partition name (do not end in a digit) */
 static void
 list_devs_in_proc_partititons(void)
 {
         FILE *procpt;
-        char line[100], ptname[100], devname[120], *s;
+        char line[100], ptname[100], devname[120];
         int ma, mi, sz;
 
         procpt = fopen_or_warn("/proc/partitions", "r");
@@ -2861,13 +2885,10 @@ list_devs_in_proc_partititons(void)
                 if (sscanf(line, " %u %u %u %[^\n ]",
                                 &ma, &mi, &sz, ptname) != 4)
                         continue;
-                for (s = ptname; *s; s++)
-                        continue;
-                /* note: excluding '0': e.g. mmcblk0 is not a partition name! */
-                if (s[-1] >= '1' && s[-1] <= '9')
-                        continue;
+
                 sprintf(devname, "/dev/%s", ptname);
-                open_list_and_close(devname, 0);
+                if (is_whole_disk(devname))
+                        open_list_and_close(devname, 0);
         }
 #if ENABLE_FEATURE_CLEAN_UP
         fclose(procpt);
diff --git a/util-linux/getopt.c b/util-linux/getopt.c
index 10e1dc49b..85ff76189 100644
--- a/util-linux/getopt.c
+++ b/util-linux/getopt.c
@@ -25,7 +25,7 @@
  *   Added NLS support (partly written by Arkadiusz Mickiewicz
  *     <misiek@misiek.eu.org>)
  * Ported to Busybox - Alfred M. Szmidt <ams@trillian.itslinux.org>
- *  Removed --version/-V and --help/-h in
+ *  Removed --version/-V and --help/-h
  *  Removed parse_error(), using bb_error_msg() from Busybox instead
  *  Replaced our_malloc with xmalloc and our_realloc with xrealloc
  *
@@ -79,7 +79,9 @@
 //usage:       " esac\n"
 //usage:       "done\n"
 
-#include <getopt.h>
+#if ENABLE_FEATURE_GETOPT_LONG
+# include <getopt.h>
+#endif
 #include "libbb.h"
 
 /* NON_OPT is the code that is returned when a non-option is found in '+'
diff --git a/util-linux/mdev.c b/util-linux/mdev.c
index 2f225ac0b..7cabb1df6 100644
--- a/util-linux/mdev.c
+++ b/util-linux/mdev.c
@@ -292,7 +292,7 @@ static void make_device(char *path, int delete)
                          * the rest the line unless keep_matching == 1 */
 
                         /* 2nd field: uid:gid - device ownership */
-                        if (get_uidgid(&ugid, tokens[1], 1) == 0)
+                        if (get_uidgid(&ugid, tokens[1], /*allow_numeric:*/ 1) == 0)
                                 bb_error_msg("unknown user/group %s on line %d", tokens[1], parser->lineno);
 
                         /* 3rd field: mode - device permissions */
diff --git a/util-linux/mount.c b/util-linux/mount.c
index 3e2ba1fab..6a154e2b2 100644
--- a/util-linux/mount.c
+++ b/util-linux/mount.c
@@ -1195,7 +1195,7 @@ static NOINLINE int nfsmount(struct mntent *mp, long vfsflags, char *filteropts)
         noac = 0;
         nordirplus = 0;
         retry = 10000;          /* 10000 minutes ~ 1 week */
-        tcp = 0;
+        tcp = 1;                        /* nfs-utils uses tcp per default */
 
         mountprog = MOUNTPROG;
         mountvers = 0;