Merge branch 'busybox' into merge

Conflicts:
	debianutils/which.c
	editors/vi.c
	libbb/executable.c

44 files changed, 1697 insertions, 783 deletions

diff --git a/coreutils/test.c b/coreutils/test.c
index d8af4dcf3..139f1db75 100644
--- a/coreutils/test.c
+++ b/coreutils/test.c
@@ -650,7 +650,7 @@ static int filstat(char *nm, enum token mode)
         if (mode == FILEX) {
                 char *p;
 
-                if (execable_file(nm)) {
+                if (file_is_executable(nm)) {
                         return 1;
                 }
                 else if ((p=win32_execable_file(nm))) {
diff --git a/debianutils/which.c b/debianutils/which.c
index bcca95331..fe6cf2f78 100644
--- a/debianutils/which.c
+++ b/debianutils/which.c
@@ -1,13 +1,9 @@
 /* vi: set sw=4 ts=4: */
 /*
- * Which implementation for busybox
- *
  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
  * Copyright (C) 2006 Gabriel Somlo <somlo at cmu.edu>
  *
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
- *
- * Based on which from debianutils
  */
 
 //usage:#define which_trivial_usage
@@ -24,98 +20,59 @@
 int which_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int which_main(int argc UNUSED_PARAM, char **argv)
 {
-        IF_DESKTOP(int opt;)
-        int status = EXIT_SUCCESS;
-        char *path;
-        char *p;
+        const char *env_path;
+        int status = 0;
+
+        env_path = getenv("PATH");
+        if (!env_path)
+                env_path = bb_default_root_path;
 
         opt_complementary = "-1"; /* at least one argument */
-        IF_DESKTOP(opt =) getopt32(argv, "a");
+        getopt32(argv, "a");
         argv += optind;
 
-        /* This matches what is seen on e.g. ubuntu.
-         * "which" there is a shell script. */
-        path = getenv("PATH");
-        if (!path) {
-                path = (char*)bb_PATH_root_path;
-                putenv(path);
-                path += 5; /* skip "PATH=" */
-        }
-
         do {
+                int missing = 1;
+                char *p;
+
 #if ENABLE_FEATURE_PREFER_APPLETS
                 if ( find_applet_by_name(*argv) >= 0 ) {
+                        missing = 0;
                         puts(*argv);
-                        IF_DESKTOP(if ( !opt ))
-                                continue;
+                        if (!option_mask32) /* -a not set */
+                                break;
                 }
 #endif
 
-#if ENABLE_DESKTOP
-/* Much bloat just to support -a */
+                /* If file contains a slash don't use PATH */
                 if (strchr(*argv, '/') || (ENABLE_PLATFORM_MINGW32 && strchr(*argv, '\\'))) {
-                        if (execable_file(*argv)) {
+                        if (file_is_executable(*argv)) {
+                                missing = 0;
                                 puts(*argv);
-                                continue;
                         }
 #if ENABLE_PLATFORM_MINGW32
                         else if ((p=win32_execable_file(*argv)) != NULL) {
+                                missing = 0;
                                 puts(p);
                                 free(p);
-                                continue;
                         }
 #endif
-                        status = EXIT_FAILURE;
                 } else {
-                        char *path2 = xstrdup(path);
-                        char *tmp = path2;
+                        char *path;
+                        char *tmp;
 
-                        p = find_execable(*argv, &tmp);
-                        if (!p)
-                                status = EXIT_FAILURE;
-                        else {
- print:
-                                puts(p);
-                                free(p);
-                                if (opt) {
-                                        /* -a: show matches in all PATH components */
-                                        if (tmp) {
-                                                p = find_execable(*argv, &tmp);
-                                                if (p)
-                                                        goto print;
-                                        }
-                                }
-                        }
-                        free(path2);
-                }
-#else
-/* Just ignoring -a */
-                if (strchr(*argv, '/') || (ENABLE_PLATFORM_MINGW32 && strchr(*argv, '\\'))) {
-                        if (execable_file(*argv)) {
-                                puts(*argv);
-                                continue;
-                        }
-#if ENABLE_PLATFORM_MINGW32
-                        else if ((p=win32_execable_file(*argv)) != NULL) {
-                                puts(p);
-                                free(p);
-                                continue;
-                        }
-#endif
-                } else {
-                        char *path2 = xstrdup(path);
-                        char *tmp = path2;
-                        p = find_execable(*argv, &tmp);
-                        free(path2);
-                        if (p) {
+                        path = tmp = xstrdup(env_path);
+                        while ((p = find_executable(*argv, &tmp)) != NULL) {
+                                missing = 0;
                                 puts(p);
                                 free(p);
-                                continue;
+                                if (!option_mask32) /* -a not set */
+                                        break;
                         }
+                        free(path);
                 }
-                status = EXIT_FAILURE;
-#endif
-        } while (*(++argv) != NULL);
+                status |= missing;
+        } while (*++argv);
 
-        fflush_stdout_and_exit(status);
+        return status;
 }
diff --git a/docs/ifupdown_design.txt b/docs/ifupdown_design.txt
index 8ab4e51ad..39e28a9f4 100644
--- a/docs/ifupdown_design.txt
+++ b/docs/ifupdown_design.txt
@@ -21,7 +21,7 @@ static int dhcp_down(struct interface_defn_t *ifd, execfn *exec)
 #if ENABLE_FEATURE_IFUPDOWN_EXTERNAL_DHCP
         int i ;
         for (i = 0; i < ARRAY_SIZE(ext_dhcp_clients); i++) {
-                if (exists_execable(ext_dhcp_clients[i].name))
+                if (executable_exists(ext_dhcp_clients[i].name))
                         return execute(ext_dhcp_clients[i].stopcmd, ifd, exec);
         }
         bb_error_msg("no dhcp clients found, using static interface shutdown");
diff --git a/docs/new-applet-HOWTO.txt b/docs/new-applet-HOWTO.txt
index 6a8054d0e..078e77bce 100644
--- a/docs/new-applet-HOWTO.txt
+++ b/docs/new-applet-HOWTO.txt
@@ -6,7 +6,7 @@ This document details the steps you must take to add a new applet to BusyBox.
 Credits:
 Matt Kraai - initial writeup
 Mark Whitley - the remix
-Thomas Lundquist - Trying to keep it updated.
+Thomas Lundquist - trying to keep it updated
 
 When doing this you should consider using the latest git HEAD.
 This is a good thing if you plan to getting it committed into mainline.
@@ -16,14 +16,14 @@ Initial Write
 
 First, write your applet.  Be sure to include copyright information at the top,
 such as who you stole the code from and so forth. Also include the mini-GPL
-boilerplate. Be sure to name the main function <applet>_main instead of main.
-And be sure to put it in <applet>.c. Usage does not have to be taken care of by
-your applet.
-Make sure to #include "libbb.h" as the first include file in your applet.
+boilerplate and Config.in/Kbuild/usage/applet.h snippets (more on that below
+in this document). Be sure to name the main function <applet>_main instead
+of main. And be sure to put it in <applet>.c. Make sure to #include "libbb.h"
+as the first include file in your applet.
 
 For a new applet mu, here is the code that would go in mu.c:
 
-(busybox.h already includes most usual header files. You do not need
+(libbb.h already includes most usual header files. You do not need
 #include <stdio.h> etc...)
 
 
@@ -41,6 +41,22 @@ For a new applet mu, here is the code that would go in mu.c:
 #include "libbb.h"
 #include "other.h"
 
+//config:config MU
+//config:       bool "MU"
+//config:       default y
+//config:       help
+//config:         Returns an indeterminate value.
+
+//kbuild:lib-$(CONFIG_MU) += mu.o
+//applet:IF_MU(APPLET(mu, BB_DIR_USR_BIN, BB_SUID_DROP))
+
+//usage:#define mu_trivial_usage
+//usage:        "[-abcde] FILE..."
+//usage:#define mu_full_usage
+//usage:        "Returns an indeterminate value\n"
+//usage:     "\n        -a      First function"
+//usage:     "\n        -b      Second function"
+
 int mu_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int mu_main(int argc, char **argv)
 {
@@ -90,6 +106,8 @@ Make a new file named <function_name>.c
 #include "libbb.h"
 #include "other.h"
 
+//kbuild:lib-y += function.o
+
 int function(char *a)
 {
         return *a;
@@ -97,9 +115,7 @@ int function(char *a)
 
 ----end example code------
 
-Add <function_name>.o in the right alphabetically sorted place
-in libbb/Kbuild.src. You should look at the conditional part of
-libbb/Kbuild.src as well.
+Remember about the kbuild snippet.
 
 You should also try to find a suitable place in include/libbb.h for
 the function declaration. If not, add it somewhere anyway, with or without
@@ -109,60 +125,68 @@ You can look at libbb/Config.src and try to find out if the function is
 tunable and add it there if it is.
 
 
+Kbuild/Config.in/usage/applets.h snippets in .c files
+-----------------------------------------------------
+
+The old way of adding new applets was to put all the information needed by the
+configuration and build system into appropriate files (namely: Kbuild.src and
+Config.src in new applet's directory) and to add the applet declaration and
+usage info text to include/applets.src.h and include/usage.src.h respectively.
+
+Since the scripts/gen_build_files.sh script had been introduced, the preferred
+way is to have all these declarations contained within the applet .c files.
+
+Every line intended to be processed by gen_build_files.sh should start as a
+comment without any preceding whitespaces and be followed by an appropriate
+keyword - kbuild, config, usage or applet - and a colon, just like shown in the
+first example above.
+
+
 Placement / Directory
 ---------------------
 
 Find the appropriate directory for your new applet.
 
-Make sure you find the appropriate places in the files, the applets are
-sorted alphabetically.
+Add the kbuild snippet to the .c file:
 
-Add the applet to Kbuild.src in the chosen directory:
+//kbuild:lib-$(CONFIG_MU) += mu.o
 
-lib-$(CONFIG_MU)               += mu.o
+Add the config snippet to the .c file:
 
-Add the applet to Config.src in the chosen directory:
-
-config MU
-        bool "MU"
-        default n
-        help
-          Returns an indeterminate value.
+//config:config MU
+//config:       bool "MU"
+//config:       default y
+//config:       help
+//config:         Returns an indeterminate value.
 
 
 Usage String(s)
 ---------------
 
-Next, add usage information for you applet to include/usage.src.h.
+Next, add usage information for your applet to the .c file.
 This should look like the following:
 
-        #define mu_trivial_usage \
-                "-[abcde] FILES"
-        #define mu_full_usage \
-                "Returns an indeterminate value.\n\n" \
-                "Options:\n" \
-                "\t-a\t\tfirst function\n" \
-                "\t-b\t\tsecond function\n" \
-                ...
+//usage:#define mu_trivial_usage
+//usage:        "[-abcde] FILE..."
+//usage:#define mu_full_usage
+//usage:        "Returns an indeterminate value\n"
+//usage:     "\n        -a      First function"
+//usage:     "\n        -b      Second function"
+//usage:        ...
 
 If your program supports flags, the flags should be mentioned on the first
-line (-[abcde]) and a detailed description of each flag should go in the
-mu_full_usage section, one flag per line. (Numerous examples of this
-currently exist in usage.src.h.)
+line ([-abcde]) and a detailed description of each flag should go in the
+mu_full_usage section, one flag per line.
 
 
 Header Files
 ------------
 
-Next, add an entry to include/applets.src.h.  Be *sure* to keep the list
-in alphabetical order, or else it will break the binary-search lookup
-algorithm in busybox.c and the Gods of BusyBox smite you. Yea, verily:
-
-Be sure to read the top of applets.src.h before adding your applet.
+Finally add the applet declaration snippet. Be sure to read the top of
+applets.src.h before adding your applet - it contains important info
+on applet macros and conventions.
 
-        /* all programs above here are alphabetically "less than" 'mu' */
-        IF_MU(APPLET(mu, BB_DIR_USR_BIN, BB_SUID_DROP))
-        /* all programs below here are alphabetically "greater than" 'mu' */
+//applet:IF_MU(APPLET(mu, BB_DIR_USR_BIN, BB_SUID_DROP))
 
 
 The Grand Announcement
diff --git a/editors/vi.c b/editors/vi.c
index ab49b3f7d..a6505e0bf 100644
--- a/editors/vi.c
+++ b/editors/vi.c
@@ -17,7 +17,6 @@
  *      it would be easier to change the mark when add/delete lines
  *      More intelligence in refresh()
  *      ":r !cmd"  and  "!cmd"  to filter text through an external command
- *      A true "undo" facility
  *      An "ex" line oriented mode- maybe using "cmdedit"
  */
 
@@ -136,6 +135,36 @@
 //config:         cursor position using "ESC [ 6 n" escape sequence, then read stdin.
 //config:
 //config:         This is not clean but helps a lot on serial lines and such.
+//config:config FEATURE_VI_UNDO
+//config:       bool "Support undo command 'u'"
+//config:       default y
+//config:       depends on VI
+//config:       help
+//config:         Support the 'u' command to undo insertion, deletion, and replacement
+//config:         of text.
+//config:config FEATURE_VI_UNDO_QUEUE
+//config:       bool "Enable undo operation queuing"
+//config:       default y
+//config:       depends on FEATURE_VI_UNDO
+//config:       help
+//config:         The vi undo functions can use an intermediate queue to greatly lower
+//config:         malloc() calls and overhead. When the maximum size of this queue is
+//config:         reached, the contents of the queue are committed to the undo stack.
+//config:         This increases the size of the undo code and allows some undo
+//config:         operations (especially un-typing/backspacing) to be far more useful.
+//config:config FEATURE_VI_UNDO_QUEUE_MAX
+//config:       int "Maximum undo character queue size"
+//config:       default 256
+//config:       range 32 65536
+//config:       depends on FEATURE_VI_UNDO_QUEUE
+//config:       help
+//config:         This option sets the number of bytes used at runtime for the queue.
+//config:         Smaller values will create more undo objects and reduce the amount
+//config:         of typed or backspaced characters that are grouped into one undo
+//config:         operation; larger values increase the potential size of each undo
+//config:         and will generally malloc() larger objects and less frequently.
+//config:         Unless you want more (or less) frequent "undo points" while typing,
+//config:         you should probably leave this unchanged.
 
 //applet:IF_VI(APPLET(vi, BB_DIR_BIN, BB_SUID_DROP))
 
@@ -277,8 +306,8 @@ struct globals {
         smallint editing;        // >0 while we are editing a file
                                  // [code audit says "can be 0, 1 or 2 only"]
         smallint cmd_mode;       // 0=command  1=insert 2=replace
-        int file_modified;       // buffer contents changed (counter, not flag!)
-        int last_file_modified;  // = -1;
+        int modified_count;      // buffer contents changed if !0
+        int last_modified_count; // = -1;
         int save_argc;           // how many file names on cmd line
         int cmdcnt;              // repetition count
         unsigned rows, columns;  // the terminal screen is this size
@@ -347,6 +376,42 @@ struct globals {
         char get_input_line__buf[MAX_INPUT_LEN]; /* former static */
 
         char scr_out_buf[MAX_SCR_COLS + MAX_TABSTOP * 2];
+#if ENABLE_FEATURE_VI_UNDO
+// undo_push() operations
+#define UNDO_INS         0
+#define UNDO_DEL         1
+#define UNDO_INS_CHAIN   2
+#define UNDO_DEL_CHAIN   3
+// UNDO_*_QUEUED must be equal to UNDO_xxx ORed with UNDO_QUEUED_FLAG
+#define UNDO_QUEUED_FLAG 4
+#define UNDO_INS_QUEUED  4
+#define UNDO_DEL_QUEUED  5
+#define UNDO_USE_SPOS   32
+#define UNDO_EMPTY      64
+// Pass-through flags for functions that can be undone
+#define NO_UNDO          0
+#define ALLOW_UNDO       1
+#define ALLOW_UNDO_CHAIN 2
+# if ENABLE_FEATURE_VI_UNDO_QUEUE
+#define ALLOW_UNDO_QUEUED 3
+        char undo_queue_state;
+        int undo_q;
+        char *undo_queue_spos;  // Start position of queued operation
+        char undo_queue[CONFIG_FEATURE_VI_UNDO_QUEUE_MAX];
+# else
+// If undo queuing disabled, don't invoke the missing queue logic
+#define ALLOW_UNDO_QUEUED 1
+# endif
+
+        struct undo_object {
+                struct undo_object *prev;       // Linking back avoids list traversal (LIFO)
+                int start;              // Offset where the data should be restored/deleted
+                int length;             // total data size
+                uint8_t u_type;         // 0=deleted, 1=inserted, 2=swapped
+                char undo_text[1];      // text that was deleted (if deletion)
+        } *undo_stack_tail;
+#endif /* ENABLE_FEATURE_VI_UNDO */
+
 };
 #define G (*ptr_to_globals)
 #define text           (G.text          )
@@ -358,8 +423,8 @@ struct globals {
 #define vi_setops               (G.vi_setops          )
 #define editing                 (G.editing            )
 #define cmd_mode                (G.cmd_mode           )
-#define file_modified           (G.file_modified      )
-#define last_file_modified      (G.last_file_modified )
+#define modified_count          (G.modified_count     )
+#define last_modified_count     (G.last_modified_count)
 #define save_argc               (G.save_argc          )
 #define cmdcnt                  (G.cmdcnt             )
 #define rows                    (G.rows               )
@@ -408,15 +473,24 @@ struct globals {
 #define last_modifying_cmd  (G.last_modifying_cmd )
 #define get_input_line__buf (G.get_input_line__buf)
 
+#if ENABLE_FEATURE_VI_UNDO
+#define undo_stack_tail  (G.undo_stack_tail )
+# if ENABLE_FEATURE_VI_UNDO_QUEUE
+#define undo_queue_state (G.undo_queue_state)
+#define undo_q           (G.undo_q          )
+#define undo_queue       (G.undo_queue      )
+#define undo_queue_spos  (G.undo_queue_spos )
+# endif
+#endif
+
 #define INIT_G() do { \
         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
-        last_file_modified = -1; \
+        last_modified_count = -1; \
         /* "" but has space for 2 chars: */ \
         IF_FEATURE_VI_SEARCH(last_search_pattern = xzalloc(2);) \
 } while (0)
 
 
-static int init_text_buffer(char *); // init from file or create new
 static void edit_file(char *);  // edit one file
 static void do_cmd(int);        // execute a command
 static int next_tabstop(int);
@@ -437,10 +511,12 @@ static void dot_next(void);	// move dot to next line B-o-l
 static void dot_prev(void);     // move dot to prev line B-o-l
 static void dot_scroll(int, int);       // move the screen up or down
 static void dot_skip_over_ws(void);     // move dot pat WS
-static void dot_delete(void);   // delete the char at 'dot'
 static char *bound_dot(char *); // make sure  text[0] <= P < "end"
 static char *new_screen(int, int);      // malloc virtual screen memory
-static char *char_insert(char *, char); // insert the char c at 'p'
+#if !ENABLE_FEATURE_VI_UNDO
+#define char_insert(a,b,c) char_insert(a,b)
+#endif
+static char *char_insert(char *, char, int);    // insert the char c at 'p'
 // might reallocate text[]! use p += stupid_insert(p, ...),
 // and be careful to not use pointers into potentially freed text[]!
 static uintptr_t stupid_insert(char *, char);   // stupidly insert the char c at 'p'
@@ -448,11 +524,17 @@ static int find_range(char **, char **, char);	// return pointers for an object
 static int st_test(char *, int, int, char *);   // helper for skip_thing()
 static char *skip_thing(char *, int, int, int); // skip some object
 static char *find_pair(char *, char);   // find matching pair ()  []  {}
-static char *text_hole_delete(char *, char *);  // at "p", delete a 'size' byte hole
+#if !ENABLE_FEATURE_VI_UNDO
+#define text_hole_delete(a,b,c) text_hole_delete(a,b)
+#endif
+static char *text_hole_delete(char *, char *, int);     // at "p", delete a 'size' byte hole
 // might reallocate text[]! use p += text_hole_make(p, ...),
 // and be careful to not use pointers into potentially freed text[]!
 static uintptr_t text_hole_make(char *, int);   // at "p", make a 'size' byte hole
-static char *yank_delete(char *, char *, int, int);     // yank text[] into register then delete
+#if !ENABLE_FEATURE_VI_UNDO
+#define yank_delete(a,b,c,d,e) yank_delete(a,b,c,d)
+#endif
+static char *yank_delete(char *, char *, int, int, int);        // yank text[] into register then delete
 static void show_help(void);    // display some help info
 static void rawmode(void);      // set "raw" mode on tty
 static void cookmode(void);     // return to "cooked" mode on tty
@@ -460,7 +542,6 @@ static void cookmode(void);	// return to "cooked" mode on tty
 static int mysleep(int);
 static int readit(void);        // read (maybe cursor) key from stdin
 static int get_one_char(void);  // read 1 char from stdin
-static int file_size(const char *);   // what is the byte size of "fn"
 #if !ENABLE_FEATURE_VI_READONLY
 #define file_insert(fn, p, update_ro_status) file_insert(fn, p)
 #endif
@@ -495,8 +576,8 @@ static char *char_search(char *, const char *, int, int);	// search for pattern
 #if ENABLE_FEATURE_VI_COLON
 static char *get_one_address(char *, int *);    // get colon addr, if present
 static char *get_address(char *, int *, int *); // get two colon addrs, if present
-static void colon(char *);      // execute the "colon" mode cmds
 #endif
+static void colon(char *);      // execute the "colon" mode cmds
 #if ENABLE_FEATURE_VI_USE_SIGNALS
 static void winch_sig(int);     // catch window size changes
 static void suspend_sig(int);   // catch ctrl-Z
@@ -514,20 +595,36 @@ static void showmatching(char *);	// show the matching pair ()  []  {}
 #if ENABLE_FEATURE_VI_YANKMARK || (ENABLE_FEATURE_VI_COLON && ENABLE_FEATURE_VI_SEARCH) || ENABLE_FEATURE_VI_CRASHME
 // might reallocate text[]! use p += string_insert(p, ...),
 // and be careful to not use pointers into potentially freed text[]!
-static uintptr_t string_insert(char *, const char *);   // insert the string at 'p'
+# if !ENABLE_FEATURE_VI_UNDO
+#define string_insert(a,b,c) string_insert(a,b)
+# endif
+static uintptr_t string_insert(char *, const char *, int);      // insert the string at 'p'
 #endif
 #if ENABLE_FEATURE_VI_YANKMARK
 static char *text_yank(char *, char *, int);    // save copy of "p" into a register
 static char what_reg(void);             // what is letter of current YDreg
 static void check_context(char);        // remember context for '' command
 #endif
+#if ENABLE_FEATURE_VI_UNDO
+static void flush_undo_data(void);
+static void undo_push(char *, unsigned int, unsigned char);     // Push an operation on the undo stack
+static void undo_pop(void);     // Undo the last operation
+# if ENABLE_FEATURE_VI_UNDO_QUEUE
+static void undo_queue_commit(void);    // Flush any queued objects to the undo stack
+# else
+# define undo_queue_commit() ((void)0)
+# endif
+#else
+#define flush_undo_data()   ((void)0)
+#define undo_queue_commit() ((void)0)
+#endif
+
 #if ENABLE_FEATURE_VI_CRASHME
 static void crash_dummy();
 static void crash_test();
 static int crashme = 0;
 #endif
 
-
 static void write1(const char *out)
 {
         fputs(out, stdout);
@@ -540,6 +637,14 @@ int vi_main(int argc, char **argv)
 
         INIT_G();
 
+#if ENABLE_FEATURE_VI_UNDO
+        /* undo_stack_tail = NULL; - already is */
+#if ENABLE_FEATURE_VI_UNDO_QUEUE
+        undo_queue_state = UNDO_EMPTY;
+        /* undo_q = 0; - already is  */
+#endif
+#endif
+
 #if ENABLE_FEATURE_VI_USE_SIGNALS || ENABLE_FEATURE_VI_CRASHME
         my_pid = getpid();
 #endif
@@ -618,30 +723,29 @@ int vi_main(int argc, char **argv)
 static int init_text_buffer(char *fn)
 {
         int rc;
-        int size = file_size(fn);       // file size. -1 means does not exist.
+
+        flush_undo_data();
+        modified_count = 0;
+        last_modified_count = -1;
+#if ENABLE_FEATURE_VI_YANKMARK
+        /* init the marks */
+        memset(mark, 0, sizeof(mark));
+#endif
 
         /* allocate/reallocate text buffer */
         free(text);
-        text_size = size + 10240;
+        text_size = 10240;
         screenbegin = dot = end = text = xzalloc(text_size);
 
         if (fn != current_filename) {
                 free(current_filename);
                 current_filename = xstrdup(fn);
         }
-        if (size < 0) {
-                // file dont exist. Start empty buf with dummy line
-                char_insert(text, '\n');
-                rc = 0;
-        } else {
-                rc = file_insert(fn, text, 1);
+        rc = file_insert(fn, text, 1);
+        if (rc < 0) {
+                // file doesnt exist. Start empty buf with dummy line
+                char_insert(text, '\n', NO_UNDO);
         }
-        file_modified = 0;
-        last_file_modified = -1;
-#if ENABLE_FEATURE_VI_YANKMARK
-        /* init the marks. */
-        memset(mark, 0, sizeof(mark));
-#endif
         return rc;
 }
 
@@ -756,7 +860,7 @@ static void edit_file(char *fn)
                                 crash_dummy();  // generate a random command
                         } else {
                                 crashme = 0;
-                                string_insert(text, "\n\n#####  Ran out of text to work on.  #####\n\n"); // insert the string
+                                string_insert(text, "\n\n#####  Ran out of text to work on.  #####\n\n", NO_UNDO); // insert the string
                                 dot = text;
                                 refresh(FALSE);
                         }
@@ -909,13 +1013,71 @@ static void setops(const char *args, const char *opname, int flg_no,
 }
 #endif
 
+#endif /* FEATURE_VI_COLON */
+
 // buf must be no longer than MAX_INPUT_LEN!
 static void colon(char *buf)
 {
+#if !ENABLE_FEATURE_VI_COLON
+        /* Simple ":cmd" handler with minimal set of commands */
+        char *p = buf;
+        int cnt;
+
+        if (*p == ':')
+                p++;
+        cnt = strlen(p);
+        if (cnt == 0)
+                return;
+        if (strncmp(p, "quit", cnt) == 0
+         || strncmp(p, "q!", cnt) == 0
+        ) {
+                if (modified_count && p[1] != '!') {
+                        status_line_bold("No write since last change (:%s! overrides)", p);
+                } else {
+                        editing = 0;
+                }
+                return;
+        }
+        if (strncmp(p, "write", cnt) == 0
+         || strncmp(p, "wq", cnt) == 0
+         || strncmp(p, "wn", cnt) == 0
+         || (p[0] == 'x' && !p[1])
+        ) {
+                cnt = file_write(current_filename, text, end - 1);
+                if (cnt < 0) {
+                        if (cnt == -1)
+                                status_line_bold("Write error: %s", strerror(errno));
+                } else {
+                        modified_count = 0;
+                        last_modified_count = -1;
+                        status_line("'%s' %dL, %dC",
+                                current_filename,
+                                count_lines(text, end - 1), cnt
+                        );
+                        if (p[0] == 'x' || p[1] == 'q' || p[1] == 'n'
+                         || p[0] == 'X' || p[1] == 'Q' || p[1] == 'N'
+                        ) {
+                                editing = 0;
+                        }
+                }
+                return;
+        }
+        if (strncmp(p, "file", cnt) == 0) {
+                last_status_cksum = 0;  // force status update
+                return;
+        }
+        if (sscanf(p, "%d", &cnt) > 0) {
+                dot = find_line(cnt);
+                dot_skip_over_ws();
+                return;
+        }
+        not_implemented(p);
+#else
+
         char c, *orig_buf, *buf1, *q, *r;
         char *fn, cmd[MAX_INPUT_LEN], args[MAX_INPUT_LEN];
-        int i, l, li, ch, b, e;
-        int useforce, forced = FALSE;
+        int i, l, li, b, e;
+        int useforce;
 
         // :3154        // if (-e line 3154) goto it  else stay put
         // :4,33w! foo  // write a portion of buffer to file "foo"
@@ -937,7 +1099,7 @@ static void colon(char *buf)
         if (*buf == ':')
                 buf++;                  // move past the ':'
 
-        li = ch = i = 0;
+        li = i = 0;
         b = e = -1;
         q = text;                       // assume 1,$ for the range
         r = end - 1;
@@ -1015,11 +1177,13 @@ static void colon(char *buf)
                         q = begin_line(dot);    // assume .,. for the range
                         r = end_line(dot);
                 }
-                dot = yank_delete(q, r, 1, YANKDEL);    // save, then delete lines
+                dot = yank_delete(q, r, 1, YANKDEL, ALLOW_UNDO);        // save, then delete lines
                 dot_skip_over_ws();
         } else if (strncmp(cmd, "edit", i) == 0) {      // Edit a file
+                int size;
+
                 // don't edit, if the current file has been modified
-                if (file_modified && !useforce) {
+                if (modified_count && !useforce) {
                         status_line_bold("No write since last change (:%s! overrides)", cmd);
                         goto ret;
                 }
@@ -1035,8 +1199,7 @@ static void colon(char *buf)
                         goto ret;
                 }
 
-                if (init_text_buffer(fn) < 0)
-                        goto ret;
+                size = init_text_buffer(fn);
 
 #if ENABLE_FEATURE_VI_YANKMARK
                 if (Ureg >= 0 && Ureg < 28) {
@@ -1052,12 +1215,14 @@ static void colon(char *buf)
                 li = count_lines(text, end - 1);
                 status_line("'%s'%s"
                         IF_FEATURE_VI_READONLY("%s")
-                        " %dL, %dC", current_filename,
-                        (file_size(fn) < 0 ? " [New file]" : ""),
+                        " %dL, %dC",
+                        current_filename,
+                        (size < 0 ? " [New file]" : ""),
                         IF_FEATURE_VI_READONLY(
                                 ((readonly_mode) ? " [Readonly]" : ""),
                         )
-                        li, ch);
+                        li, (int)(end - text)
+                );
         } else if (strncmp(cmd, "file", i) == 0) {      // what File is this
                 if (b != -1 || e != -1) {
                         status_line_bold("No address allowed on this command");
@@ -1122,7 +1287,7 @@ static void colon(char *buf)
                         goto ret;
                 }
                 // don't exit if the file been modified
-                if (file_modified) {
+                if (modified_count) {
                         status_line_bold("No write since last change (:%s! overrides)", cmd);
                         goto ret;
                 }
@@ -1146,6 +1311,8 @@ static void colon(char *buf)
                 }
                 editing = 0;
         } else if (strncmp(cmd, "read", i) == 0) {      // read file into text[]
+                int size;
+
                 fn = args;
                 if (!fn[0]) {
                         status_line_bold("No filename given");
@@ -1159,26 +1326,27 @@ static void colon(char *buf)
                         q = next_line(q);
                 { // dance around potentially-reallocated text[]
                         uintptr_t ofs = q - text;
-                        ch = file_insert(fn, q, 0);
+                        size = file_insert(fn, q, /*update_ro:*/ 0);
                         q = text + ofs;
                 }
-                if (ch < 0)
+                if (size < 0)
                         goto ret;       // nothing was inserted
                 // how many lines in text[]?
-                li = count_lines(q, q + ch - 1);
+                li = count_lines(q, q + size - 1);
                 status_line("'%s'"
                         IF_FEATURE_VI_READONLY("%s")
-                        " %dL, %dC", fn,
+                        " %dL, %dC",
+                        fn,
                         IF_FEATURE_VI_READONLY((readonly_mode ? " [Readonly]" : ""),)
-                        li, ch);
-                if (ch > 0) {
+                        li, size
+                );
+                if (size > 0) {
                         // if the insert is before "dot" then we need to update
                         if (q <= dot)
-                                dot += ch;
-                        /*file_modified++; - done by file_insert */
+                                dot += size;
                 }
         } else if (strncmp(cmd, "rewind", i) == 0) {    // rewind cmd line args
-                if (file_modified && !useforce) {
+                if (modified_count && !useforce) {
                         status_line_bold("No write since last change (:%s! overrides)", cmd);
                 } else {
                         // reset the filenames to edit
@@ -1235,6 +1403,9 @@ static void colon(char *buf)
                 char *F, *R, *flags;
                 size_t len_F, len_R;
                 int gflag;              // global replace flag
+#if ENABLE_FEATURE_VI_UNDO
+                int dont_chain_first_item = ALLOW_UNDO;
+#endif
 
                 // F points to the "find" pattern
                 // R points to the "replace" pattern
@@ -1269,9 +1440,13 @@ static void colon(char *buf)
                         if (found) {
                                 uintptr_t bias;
                                 // we found the "find" pattern - delete it
-                                text_hole_delete(found, found + len_F - 1);
-                                // inset the "replace" patern
-                                bias = string_insert(found, R); // insert the string
+                                // For undo support, the first item should not be chained
+                                text_hole_delete(found, found + len_F - 1, dont_chain_first_item);
+#if ENABLE_FEATURE_VI_UNDO
+                                dont_chain_first_item = ALLOW_UNDO_CHAIN;
+#endif
+                                // insert the "replace" patern
+                                bias = string_insert(found, R, ALLOW_UNDO_CHAIN);
                                 found += bias;
                                 ls += bias;
                                 /*q += bias; - recalculated anyway */
@@ -1293,6 +1468,9 @@ static void colon(char *buf)
                 || strncmp(cmd, "wn", i) == 0
                 || (cmd[0] == 'x' && !cmd[1])
         ) {
+                int size;
+                //int forced = FALSE;
+
                 // is there a file name to write to?
                 if (args[0]) {
                         fn = args;
@@ -1305,34 +1483,33 @@ static void colon(char *buf)
 #endif
                 // how many lines in text[]?
                 li = count_lines(q, r);
-                ch = r - q + 1;
-                // see if file exists- if not, its just a new file request
-                if (useforce) {
+                size = r - q + 1;
+                //if (useforce) {
                         // if "fn" is not write-able, chmod u+w
                         // sprintf(syscmd, "chmod u+w %s", fn);
                         // system(syscmd);
-                        forced = TRUE;
-                }
+                        // forced = TRUE;
+                //}
                 l = file_write(fn, q, r);
-                if (useforce && forced) {
+                //if (useforce && forced) {
                         // chmod u-w
                         // sprintf(syscmd, "chmod u-w %s", fn);
                         // system(syscmd);
-                        forced = FALSE;
-                }
+                        // forced = FALSE;
+                //}
                 if (l < 0) {
                         if (l == -1)
                                 status_line_bold_errno(fn);
                 } else {
                         status_line("'%s' %dL, %dC", fn, li, l);
-                        if (q == text && r == end - 1 && l == ch) {
-                                file_modified = 0;
-                                last_file_modified = -1;
+                        if (q == text && r == end - 1 && l == size) {
+                                modified_count = 0;
+                                last_modified_count = -1;
                         }
                         if ((cmd[0] == 'x' || cmd[1] == 'q' || cmd[1] == 'n'
                             || cmd[0] == 'X' || cmd[1] == 'Q' || cmd[1] == 'N'
                             )
-                         && l == ch
+                         && l == size
                         ) {
                                 editing = 0;
                         }
@@ -1359,9 +1536,8 @@ static void colon(char *buf)
  colon_s_fail:
         status_line(":s expression missing delimiters");
 #endif
-}
-
 #endif /* FEATURE_VI_COLON */
+}
 
 static void Hit_Return(void)
 {
@@ -1572,23 +1748,27 @@ static char *find_line(int li)	// find begining of line #li
 //----- Dot Movement Routines ----------------------------------
 static void dot_left(void)
 {
+        undo_queue_commit();
         if (dot > text && dot[-1] != '\n')
                 dot--;
 }
 
 static void dot_right(void)
 {
+        undo_queue_commit();
         if (dot < end - 1 && *dot != '\n')
                 dot++;
 }
 
 static void dot_begin(void)
 {
+        undo_queue_commit();
         dot = begin_line(dot);  // return pointer to first char cur line
 }
 
 static void dot_end(void)
 {
+        undo_queue_commit();
         dot = end_line(dot);    // return pointer to last char cur line
 }
 
@@ -1614,11 +1794,13 @@ static char *move_to_col(char *p, int l)
 
 static void dot_next(void)
 {
+        undo_queue_commit();
         dot = next_line(dot);
 }
 
 static void dot_prev(void)
 {
+        undo_queue_commit();
         dot = prev_line(dot);
 }
 
@@ -1626,6 +1808,7 @@ static void dot_scroll(int cnt, int dir)
 {
         char *q;
 
+        undo_queue_commit();
         for (; cnt > 0; cnt--) {
                 if (dir < 0) {
                         // scroll Backwards
@@ -1653,11 +1836,6 @@ static void dot_skip_over_ws(void)
                 dot++;
 }
 
-static void dot_delete(void)    // delete the char at 'dot'
-{
-        text_hole_delete(dot, dot);
-}
-
 static char *bound_dot(char *p) // make sure  text[0] <= P < "end"
 {
         if (p >= end && end > text) {
@@ -1804,17 +1982,34 @@ static char *char_search(char *p, const char *pat, int dir, int range)
 
 #endif /* FEATURE_VI_SEARCH */
 
-static char *char_insert(char *p, char c) // insert the char c at 'p'
+static char *char_insert(char *p, char c, int undo) // insert the char c at 'p'
 {
         if (c == 22) {          // Is this an ctrl-V?
                 p += stupid_insert(p, '^');     // use ^ to indicate literal next
                 refresh(FALSE); // show the ^
                 c = get_one_char();
                 *p = c;
+#if ENABLE_FEATURE_VI_UNDO
+                switch (undo) {
+                        case ALLOW_UNDO:
+                                undo_push(p, 1, UNDO_INS);
+                                break;
+                        case ALLOW_UNDO_CHAIN:
+                                undo_push(p, 1, UNDO_INS_CHAIN);
+                                break;
+# if ENABLE_FEATURE_VI_UNDO_QUEUE
+                        case ALLOW_UNDO_QUEUED:
+                                undo_push(p, 1, UNDO_INS_QUEUED);
+                                break;
+# endif
+                }
+#else
+                modified_count++;
+#endif /* ENABLE_FEATURE_VI_UNDO */
                 p++;
-                file_modified++;
         } else if (c == 27) {   // Is this an ESC?
                 cmd_mode = 0;
+                undo_queue_commit();
                 cmdcnt = 0;
                 end_cmd_q();    // stop adding to q
                 last_status_cksum = 0;  // force status update
@@ -1825,7 +2020,7 @@ static char *char_insert(char *p, char c) // insert the char c at 'p'
                 //     123456789
                 if ((p[-1] != '\n') && (dot>text)) {
                         p--;
-                        p = text_hole_delete(p, p);     // shrink buffer 1 char
+                        p = text_hole_delete(p, p, ALLOW_UNDO_QUEUED);  // shrink buffer 1 char
                 }
         } else {
 #if ENABLE_FEATURE_VI_SETOPTS
@@ -1838,6 +2033,27 @@ static char *char_insert(char *p, char c) // insert the char c at 'p'
 #if ENABLE_FEATURE_VI_SETOPTS
                 sp = p;                 // remember addr of insert
 #endif
+#if ENABLE_FEATURE_VI_UNDO
+# if ENABLE_FEATURE_VI_UNDO_QUEUE
+                if (c == '\n')
+                        undo_queue_commit();
+# endif
+                switch (undo) {
+                        case ALLOW_UNDO:
+                                undo_push(p, 1, UNDO_INS);
+                                break;
+                        case ALLOW_UNDO_CHAIN:
+                                undo_push(p, 1, UNDO_INS_CHAIN);
+                                break;
+# if ENABLE_FEATURE_VI_UNDO_QUEUE
+                        case ALLOW_UNDO_QUEUED:
+                                undo_push(p, 1, UNDO_INS_QUEUED);
+                                break;
+# endif
+                }
+#else
+                modified_count++;
+#endif /* ENABLE_FEATURE_VI_UNDO */
                 p += 1 + stupid_insert(p, c);   // insert the char
 #if ENABLE_FEATURE_VI_SETOPTS
                 if (showmatch && strchr(")]}", *sp) != NULL) {
@@ -1853,6 +2069,9 @@ static char *char_insert(char *p, char c) // insert the char c at 'p'
                                 bias = text_hole_make(p, len);
                                 p += bias;
                                 q += bias;
+#if ENABLE_FEATURE_VI_UNDO
+                                undo_push(p, len, UNDO_INS);
+#endif
                                 memcpy(p, q, len);
                                 p += len;
                         }
@@ -1870,7 +2089,6 @@ static uintptr_t stupid_insert(char *p, char c) // stupidly insert the char c at
         bias = text_hole_make(p, 1);
         p += bias;
         *p = c;
-        //file_modified++; - done by text_hole_make()
         return bias;
 }
 
@@ -2051,6 +2269,199 @@ static void showmatching(char *p)
 }
 #endif /* FEATURE_VI_SETOPTS */
 
+#if ENABLE_FEATURE_VI_UNDO
+static void flush_undo_data(void)
+{
+        struct undo_object *undo_entry;
+
+        while (undo_stack_tail) {
+                undo_entry = undo_stack_tail;
+                undo_stack_tail = undo_entry->prev;
+                free(undo_entry);
+        }
+}
+
+// Undo functions and hooks added by Jody Bruchon (jody@jodybruchon.com)
+static void undo_push(char *src, unsigned int length, uint8_t u_type)   // Add to the undo stack
+{
+        struct undo_object *undo_entry;
+
+        // "u_type" values
+        // UNDO_INS: insertion, undo will remove from buffer
+        // UNDO_DEL: deleted text, undo will restore to buffer
+        // UNDO_{INS,DEL}_CHAIN: Same as above but also calls undo_pop() when complete
+        // The CHAIN operations are for handling multiple operations that the user
+        // performs with a single action, i.e. REPLACE mode or find-and-replace commands
+        // UNDO_{INS,DEL}_QUEUED: If queuing feature is enabled, allow use of the queue
+        // for the INS/DEL operation. The raw values should be equal to the values of
+        // UNDO_{INS,DEL} ORed with UNDO_QUEUED_FLAG
+
+#if ENABLE_FEATURE_VI_UNDO_QUEUE
+        // This undo queuing functionality groups multiple character typing or backspaces
+        // into a single large undo object. This greatly reduces calls to malloc() for
+        // single-character operations while typing and has the side benefit of letting
+        // an undo operation remove chunks of text rather than a single character.
+        switch (u_type) {
+        case UNDO_EMPTY:        // Just in case this ever happens...
+                return;
+        case UNDO_DEL_QUEUED:
+                if (length != 1)
+                        return; // Only queue single characters
+                switch (undo_queue_state) {
+                case UNDO_EMPTY:
+                        undo_queue_state = UNDO_DEL;
+                case UNDO_DEL:
+                        undo_queue_spos = src;
+                        undo_q++;
+                        undo_queue[CONFIG_FEATURE_VI_UNDO_QUEUE_MAX - undo_q] = *src;
+                        // If queue is full, dump it into an object
+                        if (undo_q == CONFIG_FEATURE_VI_UNDO_QUEUE_MAX)
+                                undo_queue_commit();
+                        return;
+                case UNDO_INS:
+                        // Switch from storing inserted text to deleted text
+                        undo_queue_commit();
+                        undo_push(src, length, UNDO_DEL_QUEUED);
+                        return;
+                }
+                break;
+        case UNDO_INS_QUEUED:
+                if (length != 1)
+                        return;
+                switch (undo_queue_state) {
+                case UNDO_EMPTY:
+                        undo_queue_state = UNDO_INS;
+                        undo_queue_spos = src;
+                case UNDO_INS:
+                        undo_q++;       // Don't need to save any data for insertions
+                        if (undo_q == CONFIG_FEATURE_VI_UNDO_QUEUE_MAX)
+                                undo_queue_commit();
+                        return;
+                case UNDO_DEL:
+                        // Switch from storing deleted text to inserted text
+                        undo_queue_commit();
+                        undo_push(src, length, UNDO_INS_QUEUED);
+                        return;
+                }
+                break;
+        }
+#else
+        // If undo queuing is disabled, ignore the queuing flag entirely
+        u_type = u_type & ~UNDO_QUEUED_FLAG;
+#endif
+
+        // Allocate a new undo object
+        if (u_type == UNDO_DEL || u_type == UNDO_DEL_CHAIN) {
+                // For UNDO_DEL objects, save deleted text
+                if ((src + length) == end)
+                        length--;
+                // If this deletion empties text[], strip the newline. When the buffer becomes
+                // zero-length, a newline is added back, which requires this to compensate.
+                undo_entry = xzalloc(offsetof(struct undo_object, undo_text) + length);
+                memcpy(undo_entry->undo_text, src, length);
+        } else {
+                undo_entry = xzalloc(sizeof(*undo_entry));
+        }
+        undo_entry->length = length;
+#if ENABLE_FEATURE_VI_UNDO_QUEUE
+        if ((u_type & UNDO_USE_SPOS) != 0) {
+                undo_entry->start = undo_queue_spos - text;     // use start position from queue
+        } else {
+                undo_entry->start = src - text; // use offset from start of text buffer
+        }
+        u_type = (u_type & ~UNDO_USE_SPOS);
+#else
+        undo_entry->start = src - text;
+#endif
+        undo_entry->u_type = u_type;
+
+        // Push it on undo stack
+        undo_entry->prev = undo_stack_tail;
+        undo_stack_tail = undo_entry;
+        modified_count++;
+}
+
+static void undo_pop(void)      // Undo the last operation
+{
+        int repeat;
+        char *u_start, *u_end;
+        struct undo_object *undo_entry;
+
+        // Commit pending undo queue before popping (should be unnecessary)
+        undo_queue_commit();
+
+        undo_entry = undo_stack_tail;
+        // Check for an empty undo stack
+        if (!undo_entry) {
+                status_line("Already at oldest change");
+                return;
+        }
+
+        switch (undo_entry->u_type) {
+        case UNDO_DEL:
+        case UNDO_DEL_CHAIN:
+                // make hole and put in text that was deleted; deallocate text
+                u_start = text + undo_entry->start;
+                text_hole_make(u_start, undo_entry->length);
+                memcpy(u_start, undo_entry->undo_text, undo_entry->length);
+                status_line("Undo [%d] %s %d chars at position %d",
+                        modified_count, "restored",
+                        undo_entry->length, undo_entry->start
+                );
+                break;
+        case UNDO_INS:
+        case UNDO_INS_CHAIN:
+                // delete what was inserted
+                u_start = undo_entry->start + text;
+                u_end = u_start - 1 + undo_entry->length;
+                text_hole_delete(u_start, u_end, NO_UNDO);
+                status_line("Undo [%d] %s %d chars at position %d",
+                        modified_count, "deleted",
+                        undo_entry->length, undo_entry->start
+                );
+                break;
+        }
+        repeat = 0;
+        switch (undo_entry->u_type) {
+        // If this is the end of a chain, lower modification count and refresh display
+        case UNDO_DEL:
+        case UNDO_INS:
+                dot = (text + undo_entry->start);
+                refresh(FALSE);
+                break;
+        case UNDO_DEL_CHAIN:
+        case UNDO_INS_CHAIN:
+                repeat = 1;
+                break;
+        }
+        // Deallocate the undo object we just processed
+        undo_stack_tail = undo_entry->prev;
+        free(undo_entry);
+        modified_count--;
+        // For chained operations, continue popping all the way down the chain.
+        if (repeat) {
+                undo_pop();     // Follow the undo chain if one exists
+        }
+}
+
+#if ENABLE_FEATURE_VI_UNDO_QUEUE
+static void undo_queue_commit(void)     // Flush any queued objects to the undo stack
+{
+        // Pushes the queue object onto the undo stack
+        if (undo_q > 0) {
+                // Deleted character undo events grow from the end
+                undo_push(undo_queue + CONFIG_FEATURE_VI_UNDO_QUEUE_MAX - undo_q,
+                        undo_q,
+                        (undo_queue_state | UNDO_USE_SPOS)
+                );
+                undo_queue_state = UNDO_EMPTY;
+                undo_q = 0;
+        }
+}
+#endif
+
+#endif /* ENABLE_FEATURE_VI_UNDO */
+
 // open a hole in text[]
 // might reallocate text[]! use p += text_hole_make(p, ...),
 // and be careful to not use pointers into potentially freed text[]!
@@ -2082,12 +2493,12 @@ static uintptr_t text_hole_make(char *p, int size)	// at "p", make a 'size' byte
         }
         memmove(p + size, p, end - size - p);
         memset(p, ' ', size);   // clear new hole
-        file_modified++;
         return bias;
 }
 
 //  close a hole in text[]
-static char *text_hole_delete(char *p, char *q) // delete "p" through "q", inclusive
+//  "undo" value indicates if this operation should be undo-able
+static char *text_hole_delete(char *p, char *q, int undo) // delete "p" through "q", inclusive
 {
         char *src, *dest;
         int cnt, hole_size;
@@ -2102,10 +2513,29 @@ static char *text_hole_delete(char *p, char *q) // delete "p" through "q", inclu
         }
         hole_size = q - p + 1;
         cnt = end - src;
+#if ENABLE_FEATURE_VI_UNDO
+        switch (undo) {
+                case NO_UNDO:
+                        break;
+                case ALLOW_UNDO:
+                        undo_push(p, hole_size, UNDO_DEL);
+                        break;
+                case ALLOW_UNDO_CHAIN:
+                        undo_push(p, hole_size, UNDO_DEL_CHAIN);
+                        break;
+# if ENABLE_FEATURE_VI_UNDO_QUEUE
+                case ALLOW_UNDO_QUEUED:
+                        undo_push(p, hole_size, UNDO_DEL_QUEUED);
+                        break;
+# endif
+        }
+        modified_count--;
+#endif
         if (src < text || src > end)
                 goto thd0;
         if (dest < text || dest >= end)
                 goto thd0;
+        modified_count++;
         if (src >= end)
                 goto thd_atend; // just delete the end of the buffer
         memmove(dest, src, cnt);
@@ -2115,7 +2545,6 @@ static char *text_hole_delete(char *p, char *q) // delete "p" through "q", inclu
                 dest = end - 1; // make sure dest in below end-1
         if (end <= text)
                 dest = end = text;      // keep pointers valid
-        file_modified++;
  thd0:
         return dest;
 }
@@ -2123,7 +2552,7 @@ static char *text_hole_delete(char *p, char *q) // delete "p" through "q", inclu
 // copy text into register, then delete text.
 // if dist <= 0, do not include, or go past, a NewLine
 //
-static char *yank_delete(char *start, char *stop, int dist, int yf)
+static char *yank_delete(char *start, char *stop, int dist, int yf, int undo)
 {
         char *p;
 
@@ -2152,7 +2581,7 @@ static char *yank_delete(char *start, char *stop, int dist, int yf)
         text_yank(start, stop, YDreg);
 #endif
         if (yf == YANKDEL) {
-                p = text_hole_delete(start, stop);
+                p = text_hole_delete(start, stop, undo);
         }                                       // delete lines
         return p;
 }
@@ -2218,12 +2647,22 @@ static void end_cmd_q(void)
  || ENABLE_FEATURE_VI_CRASHME
 // might reallocate text[]! use p += string_insert(p, ...),
 // and be careful to not use pointers into potentially freed text[]!
-static uintptr_t string_insert(char *p, const char *s) // insert the string at 'p'
+static uintptr_t string_insert(char *p, const char *s, int undo) // insert the string at 'p'
 {
         uintptr_t bias;
         int i;
 
         i = strlen(s);
+#if ENABLE_FEATURE_VI_UNDO
+        switch (undo) {
+                case ALLOW_UNDO:
+                        undo_push(p, i, UNDO_INS);
+                        break;
+                case ALLOW_UNDO_CHAIN:
+                        undo_push(p, i, UNDO_INS_CHAIN);
+                        break;
+        }
+#endif
         bias = text_hole_make(p, i);
         p += bias;
         memcpy(p, s, i);
@@ -2481,17 +2920,6 @@ static char *get_input_line(const char *prompt)
 #undef buf
 }
 
-static int file_size(const char *fn) // what is the byte size of "fn"
-{
-        struct stat st_buf;
-        int cnt;
-
-        cnt = -1;
-        if (fn && stat(fn, &st_buf) == 0)       // see if file exists
-                cnt = (int) st_buf.st_size;
-        return cnt;
-}
-
 // might reallocate text[]!
 static int file_insert(const char *fn, char *p, int update_ro_status)
 {
@@ -2499,38 +2927,37 @@ static int file_insert(const char *fn, char *p, int update_ro_status)
         int fd, size;
         struct stat statbuf;
 
-        /* Validate file */
-        if (stat(fn, &statbuf) < 0) {
-                status_line_bold_errno(fn);
-                goto fi0;
-        }
-        if (!S_ISREG(statbuf.st_mode)) {
-                // This is not a regular file
-                status_line_bold("'%s' is not a regular file", fn);
-                goto fi0;
-        }
         if (p < text || p > end) {
                 status_line_bold("Trying to insert file outside of memory");
-                goto fi0;
+                return cnt;
         }
 
-        // read file to buffer
         fd = open(fn, O_RDONLY);
         if (fd < 0) {
                 status_line_bold_errno(fn);
-                goto fi0;
+                return cnt;
+        }
+
+        /* Validate file */
+        if (fstat(fd, &statbuf) < 0) {
+                status_line_bold_errno(fn);
+                goto fi;
+        }
+        if (!S_ISREG(statbuf.st_mode)) {
+                status_line_bold("'%s' is not a regular file", fn);
+                goto fi;
         }
 #if ENABLE_PLATFORM_MINGW32
         _setmode(fd, _O_TEXT);
 #endif
         size = (statbuf.st_size < INT_MAX ? (int)statbuf.st_size : INT_MAX);
         p += text_hole_make(p, size);
-        cnt = safe_read(fd, p, size);
+        cnt = full_read(fd, p, size);
         if (cnt < 0) {
                 status_line_bold_errno(fn);
-                p = text_hole_delete(p, p + size - 1);  // un-do buffer insert
+                p = text_hole_delete(p, p + size - 1, NO_UNDO); // un-do buffer insert
         } else if (cnt < size) {
-                // There was a partial read, shrink unused space text[]
+                // There was a partial read, shrink unused space
 #if ENABLE_PLATFORM_MINGW32
                 int i, newline;
 
@@ -2541,7 +2968,7 @@ static int file_insert(const char *fn, char *p, int update_ro_status)
                         }
                 }
 #endif
-                p = text_hole_delete(p + cnt, p + size - 1);    // un-do buffer insert
+                p = text_hole_delete(p + cnt, p + size - 1, NO_UNDO);
 #if ENABLE_PLATFORM_MINGW32
                 // on WIN32 a partial read might just mean CRs have been removed
                 if ( cnt+newline != size ) {
@@ -2551,10 +2978,9 @@ static int file_insert(const char *fn, char *p, int update_ro_status)
                 status_line_bold("can't read '%s'", fn);
 #endif
         }
-        if (cnt >= size)
-                file_modified++;
+ fi:
         close(fd);
- fi0:
+
 #if ENABLE_FEATURE_VI_READONLY
         if (update_ro_status
          && ((access(fn, W_OK) < 0) ||
@@ -2607,7 +3033,7 @@ static int file_write(char *fn, char *first, char *last)
 #endif
         if (charcnt == cnt) {
                 // good write
-                //file_modified = FALSE;
+                //modified_count = FALSE;
         } else {
                 charcnt = 0;
         }
@@ -2829,7 +3255,7 @@ static int format_edit_status(void)
 
         int cur, percent, ret, trunc_at;
 
-        // file_modified is now a counter rather than a flag.  this
+        // modified_count is now a counter rather than a flag.  this
         // helps reduce the amount of line counting we need to do.
         // (this will cause a mis-reporting of modified status
         // once every MAXINT editing operations.)
@@ -2839,11 +3265,12 @@ static int format_edit_status(void)
         // we're on, then we shouldn't have to do this count_lines()
         cur = count_lines(text, dot);
 
-        // reduce counting -- the total lines can't have
-        // changed if we haven't done any edits.
-        if (file_modified != last_file_modified) {
+        // count_lines() is expensive.
+        // Call it only if something was changed since last time
+        // we were here:
+        if (modified_count != last_modified_count) {
                 tot = cur + count_lines(dot, end - 1) - 1;
-                last_file_modified = file_modified;
+                last_modified_count = modified_count;
         }
 
         //    current line         percent
@@ -2870,7 +3297,7 @@ static int format_edit_status(void)
 #if ENABLE_FEATURE_VI_READONLY
                 (readonly_mode ? " [Readonly]" : ""),
 #endif
-                (file_modified ? " [Modified]" : ""),
+                (modified_count ? " [Modified]" : ""),
                 cur, tot, percent);
 
         if (ret >= 0 && ret < trunc_at)
@@ -3095,11 +3522,12 @@ static void do_cmd(int c)
                 if (*dot == '\n') {
                         // don't Replace past E-o-l
                         cmd_mode = 1;   // convert to insert
+                        undo_queue_commit();
                 } else {
                         if (1 <= c || Isprint(c)) {
                                 if (c != 27)
-                                        dot = yank_delete(dot, dot, 0, YANKDEL);        // delete char
-                                dot = char_insert(dot, c);      // insert new char
+                                        dot = yank_delete(dot, dot, 0, YANKDEL, ALLOW_UNDO);    // delete char
+                                dot = char_insert(dot, c, ALLOW_UNDO_CHAIN);    // insert new char
                         }
                         goto dc1;
                 }
@@ -3109,7 +3537,7 @@ static void do_cmd(int c)
                 if (c == KEYCODE_INSERT) goto dc5;
                 // insert the char c at "dot"
                 if (1 <= c || Isprint(c)) {
-                        dot = char_insert(dot, c);
+                        dot = char_insert(dot, c, ALLOW_UNDO_QUEUED);
                 }
                 goto dc1;
         }
@@ -3155,7 +3583,6 @@ static void do_cmd(int c)
                 //case ']':     // ]-
                 //case '_':     // _-
                 //case '`':     // `-
-                //case 'u':     // u- FIXME- there is no undo
                 //case 'v':     // v-
         default:                        // unrecognized command
                 buf[0] = c;
@@ -3224,6 +3651,7 @@ static void do_cmd(int c)
                 if (cmd_mode == 0)
                         indicate_error(c);
                 cmd_mode = 0;   // stop insrting
+                undo_queue_commit();
                 end_cmd_q();
                 last_status_cksum = 0;  // force status update
                 break;
@@ -3298,15 +3726,20 @@ static void do_cmd(int c)
                         if (c == 'p')
                                 dot_right();    // move to right, can move to NL
                 }
-                string_insert(dot, p);  // insert the string
+                string_insert(dot, p, ALLOW_UNDO);      // insert the string
                 end_cmd_q();    // stop adding to q
                 break;
+#if ENABLE_FEATURE_VI_UNDO
+        case 'u':       // u- undo last operation
+                undo_pop();
+                break;
+#endif
         case 'U':                       // U- Undo; replace current line with original version
                 if (reg[Ureg] != NULL) {
                         p = begin_line(dot);
                         q = end_line(dot);
-                        p = text_hole_delete(p, q);     // delete cur line
-                        p += string_insert(p, reg[Ureg]);       // insert orig line
+                        p = text_hole_delete(p, q, ALLOW_UNDO); // delete cur line
+                        p += string_insert(p, reg[Ureg], ALLOW_UNDO_CHAIN);     // insert orig line
                         dot = p;
                         dot_skip_over_ws();
                 }
@@ -3482,57 +3915,14 @@ static void do_cmd(int c)
                 break;
         case ':':                       // :- the colon mode commands
                 p = get_input_line(":");        // get input line- use "status line"
-#if ENABLE_FEATURE_VI_COLON
                 colon(p);               // execute the command
-#else
-                if (*p == ':')
-                        p++;                            // move past the ':'
-                cnt = strlen(p);
-                if (cnt <= 0)
-                        break;
-                if (strncmp(p, "quit", cnt) == 0
-                 || strncmp(p, "q!", cnt) == 0   // delete lines
-                ) {
-                        if (file_modified && p[1] != '!') {
-                                status_line_bold("No write since last change (:%s! overrides)", p);
-                        } else {
-                                editing = 0;
-                        }
-                } else if (strncmp(p, "write", cnt) == 0
-                        || strncmp(p, "wq", cnt) == 0
-                        || strncmp(p, "wn", cnt) == 0
-                        || (p[0] == 'x' && !p[1])
-                ) {
-                        cnt = file_write(current_filename, text, end - 1);
-                        if (cnt < 0) {
-                                if (cnt == -1)
-                                        status_line_bold("Write error: %s", strerror(errno));
-                        } else {
-                                file_modified = 0;
-                                last_file_modified = -1;
-                                status_line("'%s' %dL, %dC", current_filename, count_lines(text, end - 1), cnt);
-                                if (p[0] == 'x' || p[1] == 'q' || p[1] == 'n'
-                                 || p[0] == 'X' || p[1] == 'Q' || p[1] == 'N'
-                                ) {
-                                        editing = 0;
-                                }
-                        }
-                } else if (strncmp(p, "file", cnt) == 0) {
-                        last_status_cksum = 0;  // force status update
-                } else if (sscanf(p, "%d", &j) > 0) {
-                        dot = find_line(j);             // go to line # j
-                        dot_skip_over_ws();
-                } else {                // unrecognized cmd
-                        not_implemented(p);
-                }
-#endif /* !FEATURE_VI_COLON */
                 break;
         case '<':                       // <- Left  shift something
         case '>':                       // >- Right shift something
                 cnt = count_lines(text, dot);   // remember what line we are on
                 c1 = get_one_char();    // get the type of thing to delete
                 find_range(&p, &q, c1);
-                yank_delete(p, q, 1, YANKONLY); // save copy before change
+                yank_delete(p, q, 1, YANKONLY, NO_UNDO);        // save copy before change
                 p = begin_line(p);
                 q = end_line(q);
                 i = count_lines(p, q);  // # of lines we are shifting
@@ -3541,16 +3931,16 @@ static void do_cmd(int c)
                                 // shift left- remove tab or 8 spaces
                                 if (*p == '\t') {
                                         // shrink buffer 1 char
-                                        text_hole_delete(p, p);
+                                        text_hole_delete(p, p, NO_UNDO);
                                 } else if (*p == ' ') {
                                         // we should be calculating columns, not just SPACE
                                         for (j = 0; *p == ' ' && j < tabstop; j++) {
-                                                text_hole_delete(p, p);
+                                                text_hole_delete(p, p, NO_UNDO);
                                         }
                                 }
                         } else if (c == '>') {
                                 // shift right -- add tab or 8 spaces
-                                char_insert(p, '\t');
+                                char_insert(p, '\t', ALLOW_UNDO);
                         }
                 }
                 dot = find_line(cnt);   // what line were we on
@@ -3585,7 +3975,7 @@ static void do_cmd(int c)
                 save_dot = dot;
                 dot = dollar_line(dot); // move to before NL
                 // copy text into a register and delete
-                dot = yank_delete(save_dot, dot, 0, YANKDEL);   // delete to e-o-l
+                dot = yank_delete(save_dot, dot, 0, YANKDEL, ALLOW_UNDO);       // delete to e-o-l
                 if (c == 'C')
                         goto dc_i;      // start inserting
 #if ENABLE_FEATURE_VI_DOT_CMD
@@ -3630,15 +4020,22 @@ static void do_cmd(int c)
         case KEYCODE_INSERT:    // Cursor Key Insert
  dc_i:
                 cmd_mode = 1;   // start inserting
+                undo_queue_commit();    // commit queue when cmd_mode changes
                 break;
         case 'J':                       // J- join current and next lines together
                 do {
                         dot_end();              // move to NL
                         if (dot < end - 1) {    // make sure not last char in text[]
+#if ENABLE_FEATURE_VI_UNDO
+                                undo_push(dot, 1, UNDO_DEL);
                                 *dot++ = ' ';   // replace NL with space
-                                file_modified++;
+                                undo_push((dot - 1), 1, UNDO_INS_CHAIN);
+#else
+                                *dot++ = ' ';
+                                modified_count++;
+#endif
                                 while (isblank(*dot)) { // delete leading WS
-                                        dot_delete();
+                                        text_hole_delete(dot, dot, ALLOW_UNDO_CHAIN);
                                 }
                         }
                 } while (--cmdcnt > 0);
@@ -3667,10 +4064,10 @@ static void do_cmd(int c)
                         dot_prev();
         case 'o':                       // o- open a empty line below; Yes, I know it is in the middle of the "if (..."
                         dot_end();
-                        dot = char_insert(dot, '\n');
+                        dot = char_insert(dot, '\n', ALLOW_UNDO);
                 } else {
                         dot_begin();    // 0
-                        dot = char_insert(dot, '\n');   // i\n ESC
+                        dot = char_insert(dot, '\n', ALLOW_UNDO);       // i\n ESC
                         dot_prev();     // -
                 }
                 goto dc_i;
@@ -3678,6 +4075,7 @@ static void do_cmd(int c)
         case 'R':                       // R- continuous Replace char
  dc5:
                 cmd_mode = 2;
+                undo_queue_commit();
                 break;
         case KEYCODE_DELETE:
                 c = 'x';
@@ -3692,7 +4090,7 @@ static void do_cmd(int c)
                         if (dot[dir] != '\n') {
                                 if (c == 'X')
                                         dot--;  // delete prev char
-                                dot = yank_delete(dot, dot, 0, YANKDEL);        // delete char
+                                dot = yank_delete(dot, dot, 0, YANKDEL, ALLOW_UNDO);    // delete char
                         }
                 } while (--cmdcnt > 0);
                 end_cmd_q();    // stop adding to q
@@ -3706,7 +4104,7 @@ static void do_cmd(int c)
                         indicate_error(c);
                         break;
                 }
-                if (file_modified) {
+                if (modified_count) {
                         if (ENABLE_FEATURE_VI_READONLY && readonly_mode) {
                                 status_line_bold("'%s' is read only", current_filename);
                                 break;
@@ -3763,6 +4161,7 @@ static void do_cmd(int c)
                         c1 = get_one_char();    // get the type of thing to delete
                 // determine range, and whether it spans lines
                 ml = find_range(&p, &q, c1);
+                place_cursor(0, 0);
                 if (c1 == 27) { // ESC- user changed mind and wants out
                         c = c1 = 27;    // Escape- do nothing
                 } else if (strchr("wW", c1)) {
@@ -3774,13 +4173,13 @@ static void do_cmd(int c)
                                         q--;
                                 }
                         }
-                        dot = yank_delete(p, q, ml, yf);        // delete word
+                        dot = yank_delete(p, q, ml, yf, ALLOW_UNDO);    // delete word
                 } else if (strchr("^0bBeEft%$ lh\b\177", c1)) {
                         // partial line copy text into a register and delete
-                        dot = yank_delete(p, q, ml, yf);        // delete word
+                        dot = yank_delete(p, q, ml, yf, ALLOW_UNDO);    // delete word
                 } else if (strchr("cdykjHL+-{}\r\n", c1)) {
                         // whole line copy text into a register and delete
-                        dot = yank_delete(p, q, ml, yf);        // delete lines
+                        dot = yank_delete(p, q, ml, yf, ALLOW_UNDO);    // delete lines
                         whole = 1;
                 } else {
                         // could not recognize object
@@ -3790,7 +4189,7 @@ static void do_cmd(int c)
                 }
                 if (ml && whole) {
                         if (c == 'c') {
-                                dot = char_insert(dot, '\n');
+                                dot = char_insert(dot, '\n', ALLOW_UNDO_CHAIN);
                                 // on the last line of file don't move to prev line
                                 if (whole && dot != (end-1)) {
                                         dot_prev();
@@ -3836,8 +4235,14 @@ static void do_cmd(int c)
         case 'r':                       // r- replace the current char with user input
                 c1 = get_one_char();    // get the replacement char
                 if (*dot != '\n') {
+#if ENABLE_FEATURE_VI_UNDO
+                        undo_push(dot, 1, UNDO_DEL);
+                        *dot = c1;
+                        undo_push(dot, 1, UNDO_INS_CHAIN);
+#else
                         *dot = c1;
-                        file_modified++;
+                        modified_count++;
+#endif
                 }
                 end_cmd_q();    // stop adding to q
                 break;
@@ -3877,13 +4282,25 @@ static void do_cmd(int c)
                 break;
         case '~':                       // ~- flip the case of letters   a-z -> A-Z
                 do {
+#if ENABLE_FEATURE_VI_UNDO
+                        if (islower(*dot)) {
+                                undo_push(dot, 1, UNDO_DEL);
+                                *dot = toupper(*dot);
+                                undo_push(dot, 1, UNDO_INS_CHAIN);
+                        } else if (isupper(*dot)) {
+                                undo_push(dot, 1, UNDO_DEL);
+                                *dot = tolower(*dot);
+                                undo_push(dot, 1, UNDO_INS_CHAIN);
+                        }
+#else
                         if (islower(*dot)) {
                                 *dot = toupper(*dot);
-                                file_modified++;
+                                modified_count++;
                         } else if (isupper(*dot)) {
                                 *dot = tolower(*dot);
-                                file_modified++;
+                                modified_count++;
                         }
+#endif
                         dot_right();
                 } while (--cmdcnt > 0);
                 end_cmd_q();    // stop adding to q
@@ -3913,7 +4330,7 @@ static void do_cmd(int c)
  dc1:
         // if text[] just became empty, add back an empty line
         if (end == text) {
-                char_insert(text, '\n');        // start empty buf with dummy line
+                char_insert(text, '\n', NO_UNDO);       // start empty buf with dummy line
                 dot = text;
         }
         // it is OK for dot to exactly equal to end, otherwise check dot validity
diff --git a/include/applets.src.h b/include/applets.src.h
index 7dbd4c7f3..cb36628b5 100644
--- a/include/applets.src.h
+++ b/include/applets.src.h
@@ -8,7 +8,7 @@
 
 /*
 name  - applet name as it is typed on command line
-name2 - applet name, converted to C (ether-wake: name2 = ether_wake)
+help  - applet name, converted to C (ether-wake: help = ether_wake)
 main  - corresponding <applet>_main to call (bzcat: main = bunzip2)
 l     - location to install link to: [/usr]/[s]bin
 s     - suid type:
@@ -24,46 +24,46 @@ s     - suid type:
 
 #if defined(PROTOTYPES)
 # define APPLET(name,l,s)                    int name##_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
-# define APPLET_ODDNAME(name,main,l,s,name2) int main##_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
-# define APPLET_NOEXEC(name,main,l,s,name2)  int main##_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
-# define APPLET_NOFORK(name,main,l,s,name2)  int main##_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+# define APPLET_ODDNAME(name,main,l,s,help)  int main##_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+# define APPLET_NOEXEC(name,main,l,s,help)   int main##_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+# define APPLET_NOFORK(name,main,l,s,help)   int main##_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 
-#elif defined(NAME_MAIN_CNAME)
-# define APPLET(name,l,s)                    name name##_main name
-# define APPLET_ODDNAME(name,main,l,s,name2) name main##_main name2
-# define APPLET_NOEXEC(name,main,l,s,name2)  name main##_main name2
-# define APPLET_NOFORK(name,main,l,s,name2)  name main##_main name2
+#elif defined(NAME_MAIN)
+# define APPLET(name,l,s)                    name name##_main
+# define APPLET_ODDNAME(name,main,l,s,help)  name main##_main
+# define APPLET_NOEXEC(name,main,l,s,help)   name main##_main
+# define APPLET_NOFORK(name,main,l,s,help)   name main##_main
 
 #elif defined(MAKE_USAGE) && ENABLE_FEATURE_VERBOSE_USAGE
 # define APPLET(name,l,s)                    MAKE_USAGE(#name, name##_trivial_usage name##_full_usage)
-# define APPLET_ODDNAME(name,main,l,s,name2) MAKE_USAGE(#name, name2##_trivial_usage name2##_full_usage)
-# define APPLET_NOEXEC(name,main,l,s,name2)  MAKE_USAGE(#name, name2##_trivial_usage name2##_full_usage)
-# define APPLET_NOFORK(name,main,l,s,name2)  MAKE_USAGE(#name, name2##_trivial_usage name2##_full_usage)
+# define APPLET_ODDNAME(name,main,l,s,help)  MAKE_USAGE(#name, help##_trivial_usage help##_full_usage)
+# define APPLET_NOEXEC(name,main,l,s,help)   MAKE_USAGE(#name, help##_trivial_usage help##_full_usage)
+# define APPLET_NOFORK(name,main,l,s,help)   MAKE_USAGE(#name, help##_trivial_usage help##_full_usage)
 
 #elif defined(MAKE_USAGE) && !ENABLE_FEATURE_VERBOSE_USAGE
 # define APPLET(name,l,s)                    MAKE_USAGE(#name, name##_trivial_usage)
-# define APPLET_ODDNAME(name,main,l,s,name2) MAKE_USAGE(#name, name2##_trivial_usage)
-# define APPLET_NOEXEC(name,main,l,s,name2)  MAKE_USAGE(#name, name2##_trivial_usage)
-# define APPLET_NOFORK(name,main,l,s,name2)  MAKE_USAGE(#name, name2##_trivial_usage)
+# define APPLET_ODDNAME(name,main,l,s,help)  MAKE_USAGE(#name, help##_trivial_usage)
+# define APPLET_NOEXEC(name,main,l,s,help)   MAKE_USAGE(#name, help##_trivial_usage)
+# define APPLET_NOFORK(name,main,l,s,help)   MAKE_USAGE(#name, help##_trivial_usage)
 
 #elif defined(MAKE_LINKS)
 # define APPLET(name,l,c)                    LINK l name
-# define APPLET_ODDNAME(name,main,l,s,name2) LINK l name
-# define APPLET_NOEXEC(name,main,l,s,name2)  LINK l name
-# define APPLET_NOFORK(name,main,l,s,name2)  LINK l name
+# define APPLET_ODDNAME(name,main,l,s,help)  LINK l name
+# define APPLET_NOEXEC(name,main,l,s,help)   LINK l name
+# define APPLET_NOFORK(name,main,l,s,help)   LINK l name
 
 #elif defined(MAKE_SUID)
 # define APPLET(name,l,s)                    SUID s l name
-# define APPLET_ODDNAME(name,main,l,s,name2) SUID s l name
-# define APPLET_NOEXEC(name,main,l,s,name2)  SUID s l name
-# define APPLET_NOFORK(name,main,l,s,name2)  SUID s l name
+# define APPLET_ODDNAME(name,main,l,s,help)  SUID s l name
+# define APPLET_NOEXEC(name,main,l,s,help)   SUID s l name
+# define APPLET_NOFORK(name,main,l,s,help)   SUID s l name
 
 #else
   static struct bb_applet applets[] = { /*    name, main, location, need_suid */
 # define APPLET(name,l,s)                    { #name, #name, l, s },
-# define APPLET_ODDNAME(name,main,l,s,name2) { #name, #main, l, s },
-# define APPLET_NOEXEC(name,main,l,s,name2)  { #name, #main, l, s, 1 },
-# define APPLET_NOFORK(name,main,l,s,name2)  { #name, #main, l, s, 1, 1 },
+# define APPLET_ODDNAME(name,main,l,s,help)  { #name, #main, l, s },
+# define APPLET_NOEXEC(name,main,l,s,help)   { #name, #main, l, s, 1 },
+# define APPLET_NOFORK(name,main,l,s,help)   { #name, #main, l, s, 1, 1 },
 #endif
 
 #if ENABLE_INSTALL_NO_USR
@@ -104,7 +104,6 @@ IF_CKSUM(APPLET_NOEXEC(cksum, cksum, BB_DIR_USR_BIN, BB_SUID_DROP, cksum))
 IF_CLEAR(APPLET(clear, BB_DIR_USR_BIN, BB_SUID_DROP))
 IF_COMM(APPLET(comm, BB_DIR_USR_BIN, BB_SUID_DROP))
 IF_CP(APPLET_NOEXEC(cp, cp, BB_DIR_BIN, BB_SUID_DROP, cp))
-IF_CROND(APPLET(crond, BB_DIR_USR_SBIN, BB_SUID_DROP))
 /* Needs to be run by root or be suid root - needs to change /var/spool/cron* files: */
 IF_CRONTAB(APPLET(crontab, BB_DIR_USR_BIN, BB_SUID_REQUIRE))
 IF_CRYPTPW(APPLET(cryptpw, BB_DIR_USR_BIN, BB_SUID_DROP))
@@ -391,7 +390,7 @@ IF_WHOAMI(APPLET_NOFORK(whoami, whoami, BB_DIR_USR_BIN, BB_SUID_DROP, whoami))
 IF_YES(APPLET_NOFORK(yes, yes, BB_DIR_USR_BIN, BB_SUID_DROP, yes))
 IF_ZCIP(APPLET(zcip, BB_DIR_SBIN, BB_SUID_DROP))
 
-#if !defined(PROTOTYPES) && !defined(NAME_MAIN_CNAME) && !defined(MAKE_USAGE) \
+#if !defined(PROTOTYPES) && !defined(NAME_MAIN) && !defined(MAKE_USAGE) \
         && !defined(MAKE_LINKS) && !defined(MAKE_SUID)
 };
 #endif
diff --git a/include/libbb.h b/include/libbb.h
index 3b2bf0a0a..c80cd80d7 100644
--- a/include/libbb.h
+++ b/include/libbb.h
@@ -928,9 +928,9 @@ void FAST_FUNC update_utmp(pid_t pid, int new_type, const char *tty_name, const
 #endif
 
 
-int execable_file(const char *name) FAST_FUNC;
-char *find_execable(const char *filename, char **PATHp) FAST_FUNC;
-int exists_execable(const char *filename) FAST_FUNC;
+int file_is_executable(const char *name) FAST_FUNC;
+char *find_executable(const char *filename, char **PATHp) FAST_FUNC;
+int executable_exists(const char *filename) FAST_FUNC;
 
 /* BB_EXECxx always execs (it's not doing NOFORK/NOEXEC stuff),
  * but it may exec busybox and call applet instead of searching PATH.
@@ -1090,6 +1090,7 @@ enum {
         LOGMODE_BOTH = LOGMODE_SYSLOG + LOGMODE_STDIO,
 };
 extern const char *msg_eol;
+extern smallint syslog_level;
 extern smallint logmode;
 extern int die_sleep;
 extern uint8_t xfunc_error_retval;
diff --git a/include/platform.h b/include/platform.h
index 515ef031f..884c6e95f 100644
--- a/include/platform.h
+++ b/include/platform.h
@@ -390,6 +390,7 @@ typedef unsigned smalluint;
 #define HAVE_STRSIGNAL 1
 #define HAVE_STRVERSCMP 1
 #define HAVE_VASPRINTF 1
+#define HAVE_USLEEP 1
 #define HAVE_UNLOCKED_STDIO 1
 #define HAVE_UNLOCKED_LINE_OPS 1
 #define HAVE_GETLINE 1
@@ -398,8 +399,15 @@ typedef unsigned smalluint;
 #define HAVE_NET_ETHERNET_H 1
 #define HAVE_SYS_STATFS_H 1
 
-#if defined(__UCLIBC__) && UCLIBC_VERSION < KERNEL_VERSION(0, 9, 32)
-# undef HAVE_STRVERSCMP
+#if defined(__UCLIBC__)
+# if UCLIBC_VERSION < KERNEL_VERSION(0, 9, 32)
+#  undef HAVE_STRVERSCMP
+# endif
+# if UCLIBC_VERSION >= KERNEL_VERSION(0, 9, 30)
+#  ifndef __UCLIBC_SUSV3_LEGACY__
+#   undef HAVE_USLEEP
+#  endif
+# endif
 #endif
 
 #if ENABLE_PLATFORM_MINGW32
@@ -554,6 +562,10 @@ extern char *strsep(char **stringp, const char *delim) FAST_FUNC;
 # define strsignal(sig) get_signame(sig)
 #endif
 
+#ifndef HAVE_USLEEP
+extern int usleep(unsigned) FAST_FUNC;
+#endif
+
 #ifndef HAVE_VASPRINTF
 # include <stdarg.h>
 extern int vasprintf(char **string_ptr, const char *format, va_list p) FAST_FUNC;
diff --git a/libbb/Kbuild.src b/libbb/Kbuild.src
index d81ae8468..107c80689 100644
--- a/libbb/Kbuild.src
+++ b/libbb/Kbuild.src
@@ -30,7 +30,7 @@ lib-y += crc32.o
 lib-y += default_error_retval.o
 lib-y += device_open.o
 lib-y += dump.o
-lib-y += execable.o
+lib-y += executable.o
 lib-y += fclose_nonstdin.o
 lib-y += fflush_stdout_and_exit.o
 lib-y += fgets_str.o
diff --git a/libbb/execable.c b/libbb/executable.c
index ae61a8800..2e5f6a1b7 100644
--- a/libbb/execable.c
+++ b/libbb/executable.c
@@ -13,7 +13,7 @@
  * return 1 if found;
  * return 0 otherwise;
  */
-int FAST_FUNC execable_file(const char *name)
+int FAST_FUNC file_is_executable(const char *name)
 {
         struct stat s;
         return (!access(name, X_OK) && !stat(name, &s) && S_ISREG(s.st_mode));
@@ -23,7 +23,7 @@ int FAST_FUNC execable_file(const char *name)
  * return allocated string containing full path if found;
  *  PATHp points to the component after the one where it was found
  *  (or NULL),
- *  you may call find_execable again with this PATHp to continue
+ *  you may call find_executable again with this PATHp to continue
  *  (if it's not NULL).
  * return NULL otherwise; (PATHp is undefined)
  * in all cases (*PATHp) contents will be trashed (s/:/NUL/).
@@ -32,8 +32,16 @@ int FAST_FUNC execable_file(const char *name)
 #define next_path_sep(s) strchr(s, ':')
 #endif
 
-char* FAST_FUNC find_execable(const char *filename, char **PATHp)
+char* FAST_FUNC find_executable(const char *filename, char **PATHp)
 {
+        /* About empty components in $PATH:
+         * http://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap08.html
+         * 8.3 Other Environment Variables - PATH
+         * A zero-length prefix is a legacy feature that indicates the current
+         * working directory. It appears as two adjacent colons ( "::" ), as an
+         * initial colon preceding the rest of the list, or as a trailing colon
+         * following the rest of the list.
+         */
         char *p, *n;
 #if ENABLE_PLATFORM_MINGW32
         char *w;
@@ -44,21 +52,22 @@ char* FAST_FUNC find_execable(const char *filename, char **PATHp)
                 n = (char*)next_path_sep(p);
                 if (n)
                         *n++ = '\0';
-                if (*p != '\0') { /* it's not a PATH="foo::bar" situation */
-                        p = concat_path_file(p, filename);
-                        if (execable_file(p)) {
-                                *PATHp = n;
-                                return p;
-                        }
+                p = concat_path_file(
+                        p[0] ? p : ".", /* handle "::" case */
+                        filename
+                );
+                if (file_is_executable(p)) {
+                        *PATHp = n;
+                        return p;
+                }
 #if ENABLE_PLATFORM_MINGW32
-                        else if ((w=win32_execable_file(p))) {
-                                *PATHp = n;
-                                free(p);
-                                return w;
-                        }
-#endif
+                else if ((w=win32_execable_file(p))) {
+                        *PATHp = n;
                         free(p);
+                        return w;
                 }
+#endif
+                free(p);
                 p = n;
         } /* on loop exit p == NULL */
         return p;
@@ -68,17 +77,14 @@ char* FAST_FUNC find_execable(const char *filename, char **PATHp)
  * return 1 if found;
  * return 0 otherwise;
  */
-int FAST_FUNC exists_execable(const char *filename)
+int FAST_FUNC executable_exists(const char *filename)
 {
         char *path = xstrdup(getenv("PATH"));
         char *tmp = path;
-        char *ret = find_execable(filename, &tmp);
+        char *ret = find_executable(filename, &tmp);
         free(path);
-        if (ret) {
-                free(ret);
-                return 1;
-        }
-        return 0;
+        free(ret);
+        return ret != NULL;
 }
 
 #if ENABLE_FEATURE_PREFER_APPLETS
diff --git a/libbb/getpty.c b/libbb/getpty.c
index 435e4d09f..391d729f2 100644
--- a/libbb/getpty.c
+++ b/libbb/getpty.c
@@ -16,7 +16,7 @@ int FAST_FUNC xgetpty(char *line)
 
 #if ENABLE_FEATURE_DEVPTS
         p = open("/dev/ptmx", O_RDWR);
-        if (p > 0) {
+        if (p >= 0) {
                 grantpt(p); /* chmod+chown corresponding slave pty */
                 unlockpt(p); /* (what does this do?) */
 # ifndef HAVE_PTSNAME_R
diff --git a/libbb/obscure.c b/libbb/obscure.c
index 9ecc1f672..24c4ac917 100644
--- a/libbb/obscure.c
+++ b/libbb/obscure.c
@@ -76,7 +76,7 @@ static int string_checker(const char *p1, const char *p2)
         ret |= string_checker_helper(p, p2);
 
         /* clean up */
-        memset(p, 0, size);
+        nuke_str(p);
         free(p);
 
         return ret;
diff --git a/libbb/platform.c b/libbb/platform.c
index 19734517b..8d90ca4e9 100644
--- a/libbb/platform.c
+++ b/libbb/platform.c
@@ -17,6 +17,24 @@ char* FAST_FUNC strchrnul(const char *s, int c)
 }
 #endif
 
+#ifndef HAVE_USLEEP
+int FAST_FUNC usleep(unsigned usec)
+{
+        struct timespec ts;
+        ts.tv_sec = usec / 1000000u;
+        ts.tv_nsec = (usec % 1000000u) * 1000u;
+        /*
+         * If a signal has non-default handler, nanosleep returns early.
+         * Our version of usleep doesn't return early
+         * if interrupted by such signals:
+         *
+         */
+        while (nanosleep(&ts, &ts) != 0)
+                continue;
+        return 0;
+}
+#endif
+
 #ifndef HAVE_VASPRINTF
 int FAST_FUNC vasprintf(char **string_ptr, const char *format, va_list p)
 {
diff --git a/libbb/rtc.c b/libbb/rtc.c
index 97455e86a..6d06d57f9 100644
--- a/libbb/rtc.c
+++ b/libbb/rtc.c
@@ -33,23 +33,55 @@ int FAST_FUNC rtc_adjtime_is_utc(void)
         return utc;
 }
 
+/* rtc opens are exclusive.
+ * Try to run two "hwclock -w" at the same time to see it.
+ * Users wouldn't expect that to fail merely because /dev/rtc
+ * was momentarily busy, let's try a bit harder on errno == EBUSY.
+ */
+static int open_loop_on_busy(const char *name, int flags)
+{
+        int rtc;
+        /*
+         * Tested with two parallel "hwclock -w" loops.
+         * With try = 10, no failures with 2x1000000 loop iterations.
+         */
+        int try = 1000 / 20;
+ again:
+        errno = 0;
+        rtc = open(name, flags);
+        if (errno == EBUSY) {
+                usleep(20 * 1000);
+                if (--try != 0)
+                        goto again;
+                /* EBUSY. Last try, exit on error instead of returning -1 */
+                return xopen(name, flags);
+        }
+        return rtc;
+}
+
+/* Never fails */
 int FAST_FUNC rtc_xopen(const char **default_rtc, int flags)
 {
         int rtc;
+        const char *name =
+                "/dev/rtc""\0"
+                "/dev/rtc0""\0"
+                "/dev/misc/rtc""\0";
 
-        if (!*default_rtc) {
-                *default_rtc = "/dev/rtc";
-                rtc = open(*default_rtc, flags);
-                if (rtc >= 0)
-                        return rtc;
-                *default_rtc = "/dev/rtc0";
-                rtc = open(*default_rtc, flags);
+        if (!*default_rtc)
+                goto try_name;
+        name = ""; /*else: we have rtc name, don't try other names */
+
+        for (;;) {
+                rtc = open_loop_on_busy(*default_rtc, flags);
                 if (rtc >= 0)
                         return rtc;
-                *default_rtc = "/dev/misc/rtc";
+                if (!name[0])
+                        return xopen(*default_rtc, flags);
+ try_name:
+                *default_rtc = name;
+                name += strlen(name) + 1;
         }
-
-        return xopen(*default_rtc, flags);
 }
 
 void FAST_FUNC rtc_read_tm(struct tm *ptm, int fd)
diff --git a/libbb/verror_msg.c b/libbb/verror_msg.c
index ee95be3e3..0ef2a311f 100644
--- a/libbb/verror_msg.c
+++ b/libbb/verror_msg.c
@@ -11,6 +11,9 @@
 # include <syslog.h>
 #endif
 
+#if ENABLE_FEATURE_SYSLOG
+smallint syslog_level = LOG_ERR;
+#endif
 smallint logmode = LOGMODE_STDIO;
 const char *msg_eol = "\n";
 
@@ -70,7 +73,7 @@ void FAST_FUNC bb_verror_msg(const char *s, va_list p, const char* strerr)
         }
 #if ENABLE_FEATURE_SYSLOG
         if (logmode & LOGMODE_SYSLOG) {
-                syslog(LOG_ERR, "%s", msg + applet_len);
+                syslog(syslog_level, "%s", msg + applet_len);
         }
 #endif
         free(msg);
diff --git a/libbb/xreadlink.c b/libbb/xreadlink.c
index ea09f20b8..2c5a9ef39 100644
--- a/libbb/xreadlink.c
+++ b/libbb/xreadlink.c
@@ -1,14 +1,14 @@
 /* vi: set sw=4 ts=4: */
 /*
  * xreadlink.c - safe implementation of readlink.
- * Returns a NULL on failure...
+ * Returns a NULL on failure.
  *
  * Licensed under GPLv2, see file LICENSE in this source tree.
  */
 
 #include "libbb.h"
 
-/* some systems (eg Hurd) does not have MAXSYMLINKS definition,
+/* Some systems (eg Hurd) do not have MAXSYMLINKS definition,
  * set it to some reasonable value if it isn't defined */
 #ifndef MAXSYMLINKS
 # define MAXSYMLINKS 20
@@ -108,8 +108,11 @@ char* FAST_FUNC xmalloc_readlink_or_warn(const char *path)
 
 char* FAST_FUNC xmalloc_realpath(const char *path)
 {
-#if defined(__GLIBC__) || \
-    (defined(__UCLIBC__) && UCLIBC_VERSION >= KERNEL_VERSION(0, 9, 31))
+/* NB: uclibc also defines __GLIBC__
+ * Therefore the test "if glibc, or uclibc >= 0.9.31" looks a bit weird:
+ */
+#if defined(__GLIBC__) && \
+    (!defined(__UCLIBC__) || UCLIBC_VERSION >= KERNEL_VERSION(0, 9, 31))
         /* glibc provides a non-standard extension */
         /* new: POSIX.1-2008 specifies this behavior as well */
         return realpath(path, NULL);
diff --git a/loginutils/su.c b/loginutils/su.c
index c51f26f70..f8125054a 100644
--- a/loginutils/su.c
+++ b/loginutils/su.c
@@ -101,6 +101,7 @@ int su_main(int argc UNUSED_PARAM, char **argv)
                 if (ENABLE_FEATURE_SU_SYSLOG)
                         syslog(LOG_NOTICE, "%c %s %s:%s",
                                 '-', tty, old_user, opt_username);
+                bb_do_delay(LOGIN_FAIL_DELAY);
                 bb_error_msg_and_die("incorrect password");
         }
 
diff --git a/miscutils/Config.src b/miscutils/Config.src
index 1da9800bd..1b2a3ae9a 100644
--- a/miscutils/Config.src
+++ b/miscutils/Config.src
@@ -133,40 +133,6 @@ config CHRT
           manipulate real-time attributes of a process.
           This requires sched_{g,s}etparam support in your libc.
 
-config CROND
-        bool "crond"
-        default y
-        select FEATURE_SYSLOG
-        help
-          Crond is a background daemon that parses individual crontab
-          files and executes commands on behalf of the users in question.
-          This is a port of dcron from slackware. It uses files of the
-          format /var/spool/cron/crontabs/<username> files, for example:
-              $ cat /var/spool/cron/crontabs/root
-              # Run daily cron jobs at 4:40 every day:
-              40 4 * * * /etc/cron/daily > /dev/null 2>&1
-
-config FEATURE_CROND_D
-        bool "Support option -d to redirect output to stderr"
-        depends on CROND
-        default y
-        help
-          -d sets loglevel to 0 (most verbose) and directs all output to stderr.
-
-config FEATURE_CROND_CALL_SENDMAIL
-        bool "Report command output via email (using sendmail)"
-        default y
-        depends on CROND
-        help
-          Command output will be sent to corresponding user via email.
-
-config FEATURE_CROND_DIR
-        string "crond spool directory"
-        default "/var/spool/cron"
-        depends on CROND || CRONTAB
-        help
-          Location of crond spool.
-
 config CRONTAB
         bool "crontab"
         default y
diff --git a/miscutils/Kbuild.src b/miscutils/Kbuild.src
index 9e164f16e..8eaa82de9 100644
--- a/miscutils/Kbuild.src
+++ b/miscutils/Kbuild.src
@@ -12,7 +12,6 @@ lib-$(CONFIG_BBCONFIG)    += bbconfig.o
 lib-$(CONFIG_BEEP)        += beep.o
 lib-$(CONFIG_CHAT)        += chat.o
 lib-$(CONFIG_CHRT)        += chrt.o
-lib-$(CONFIG_CROND)       += crond.o
 lib-$(CONFIG_CRONTAB)     += crontab.o
 lib-$(CONFIG_DC)          += dc.o
 lib-$(CONFIG_DEVFSD)      += devfsd.o
diff --git a/miscutils/adjtimex.c b/miscutils/adjtimex.c
index c8816e9e7..534364a69 100644
--- a/miscutils/adjtimex.c
+++ b/miscutils/adjtimex.c
@@ -14,12 +14,12 @@
 //usage:#define adjtimex_trivial_usage
 //usage:       "[-q] [-o OFF] [-f FREQ] [-p TCONST] [-t TICK]"
 //usage:#define adjtimex_full_usage "\n\n"
-//usage:       "Read and optionally set system timebase parameters. See adjtimex(2)\n"
+//usage:       "Read or set kernel time variables. See adjtimex(2)\n"
 //usage:     "\n        -q      Quiet"
 //usage:     "\n        -o OFF  Time offset, microseconds"
 //usage:     "\n        -f FREQ Frequency adjust, integer kernel units (65536 is 1ppm)"
-//usage:     "\n                (positive values make clock run faster)"
 //usage:     "\n        -t TICK Microseconds per tick, usually 10000"
+//usage:     "\n                (positive -t or -f values make clock run faster)"
 //usage:     "\n        -p TCONST"
 
 #include "libbb.h"
@@ -111,13 +111,13 @@ int adjtimex_main(int argc UNUSED_PARAM, char **argv)
         }
 
         if (!(opt & OPT_quiet)) {
-                int sep;
+                const char *sep;
                 const char *name;
 
                 printf(
                         "    mode:         %d\n"
-                        "-o  offset:       %ld\n"
-                        "-f  frequency:    %ld\n"
+                        "-o  offset:       %ld us\n"
+                        "-f  freq.adjust:  %ld (65536 = 1ppm)\n"
                         "    maxerror:     %ld\n"
                         "    esterror:     %ld\n"
                         "    status:       %d (",
@@ -125,15 +125,14 @@ int adjtimex_main(int argc UNUSED_PARAM, char **argv)
                 txc.esterror, txc.status);
 
                 /* representative output of next code fragment:
-                   "PLL | PPSTIME" */
+                 * "PLL | PPSTIME"
+                 */
                 name = statlist_name;
-                sep = 0;
+                sep = "";
                 for (i = 0; statlist_bit[i]; i++) {
                         if (txc.status & statlist_bit[i]) {
-                                if (sep)
-                                        fputs(" | ", stdout);
-                                fputs(name, stdout);
-                                sep = 1;
+                                printf("%s%s", sep, name);
+                                sep = " | ";
                         }
                         name += strlen(name) + 1;
                 }
@@ -143,9 +142,9 @@ int adjtimex_main(int argc UNUSED_PARAM, char **argv)
                         descript = nth_string(ret_code_descript, ret);
                 printf(")\n"
                         "-p  timeconstant: %ld\n"
-                        "    precision:    %ld\n"
+                        "    precision:    %ld us\n"
                         "    tolerance:    %ld\n"
-                        "-t  tick:         %ld\n"
+                        "-t  tick:         %ld us\n"
                         "    time.tv_sec:  %ld\n"
                         "    time.tv_usec: %ld\n"
                         "    return value: %d (%s)\n",
diff --git a/miscutils/crond.c b/miscutils/crond.c
index 582dc991a..3659b9a6f 100644
--- a/miscutils/crond.c
+++ b/miscutils/crond.c
@@ -1,7 +1,5 @@
 /* vi: set sw=4 ts=4: */
 /*
- * crond -d[#] -c <crondir> -f -b
- *
  * run as root, but NOT setuid root
  *
  * Copyright 1994 Matthew Dillon (dillon@apollo.west.oic.com)
@@ -10,6 +8,43 @@
  *
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
+//config:config CROND
+//config:       bool "crond"
+//config:       default y
+//config:       select FEATURE_SYSLOG
+//config:       help
+//config:         Crond is a background daemon that parses individual crontab
+//config:         files and executes commands on behalf of the users in question.
+//config:         This is a port of dcron from slackware. It uses files of the
+//config:         format /var/spool/cron/crontabs/<username> files, for example:
+//config:             $ cat /var/spool/cron/crontabs/root
+//config:             # Run daily cron jobs at 4:40 every day:
+//config:             40 4 * * * /etc/cron/daily > /dev/null 2>&1
+//config:
+//config:config FEATURE_CROND_D
+//config:       bool "Support option -d to redirect output to stderr"
+//config:       depends on CROND
+//config:       default y
+//config:       help
+//config:         -d N sets loglevel (0:most verbose) and directs all output to stderr.
+//config:
+//config:config FEATURE_CROND_CALL_SENDMAIL
+//config:       bool "Report command output via email (using sendmail)"
+//config:       default y
+//config:       depends on CROND
+//config:       help
+//config:         Command output will be sent to corresponding user via email.
+//config:
+//config:config FEATURE_CROND_DIR
+//config:       string "crond spool directory"
+//config:       default "/var/spool/cron"
+//config:       depends on CROND || CRONTAB
+//config:       help
+//config:         Location of crond spool.
+
+//applet:IF_CROND(APPLET(crond, BB_DIR_USR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_CROND) += crond.o
 
 //usage:#define crond_trivial_usage
 //usage:       "-fbS -l N " IF_FEATURE_CROND_D("-d N ") "-L LOGFILE -c DIR"
@@ -17,12 +52,12 @@
 //usage:       "        -f      Foreground"
 //usage:     "\n        -b      Background (default)"
 //usage:     "\n        -S      Log to syslog (default)"
-//usage:     "\n        -l      Set log level. 0 is the most verbose, default 8"
+//usage:     "\n        -l N    Set log level. Most verbose:0, default:8"
 //usage:        IF_FEATURE_CROND_D(
-//usage:     "\n        -d      Set log level, log to stderr"
+//usage:     "\n        -d N    Set log level, log to stderr"
 //usage:        )
-//usage:     "\n        -L      Log to file"
-//usage:     "\n        -c      Working dir"
+//usage:     "\n        -L FILE Log to FILE"
+//usage:     "\n        -c DIR  Cron dir. Default:"CONFIG_FEATURE_CROND_DIR"/crontabs"
 
 #include "libbb.h"
 #include <syslog.h>
@@ -36,7 +71,7 @@
 #endif
 
 
-#define TMPDIR          CONFIG_FEATURE_CROND_DIR
+#define CRON_DIR        CONFIG_FEATURE_CROND_DIR
 #define CRONTABS        CONFIG_FEATURE_CROND_DIR "/crontabs"
 #ifndef SENDMAIL
 # define SENDMAIL       "sendmail"
@@ -69,6 +104,7 @@ typedef struct CronLine {
         int cl_empty_mail_size;         /* size of mail header only, 0 if no mailfile */
         char *cl_mailto;                /* whom to mail results, may be NULL */
 #endif
+        char *cl_shell;
         /* ordered by size, not in natural order. makes code smaller: */
         char cl_Dow[7];                 /* 0-6, beginning sunday */
         char cl_Mons[12];               /* 0-11 */
@@ -90,12 +126,6 @@ enum {
         OPT_c = (1 << 5),
         OPT_d = (1 << 6) * ENABLE_FEATURE_CROND_D,
 };
-#if ENABLE_FEATURE_CROND_D
-# define DebugOpt (option_mask32 & OPT_d)
-#else
-# define DebugOpt 0
-#endif
-
 
 struct globals {
         unsigned log_level; /* = 8; */
@@ -106,6 +136,8 @@ struct globals {
 #if SETENV_LEAKS
         char *env_var_user;
         char *env_var_home;
+        char *env_var_shell;
+        char *env_var_logname;
 #endif
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
@@ -114,56 +146,56 @@ struct globals {
         G.crontab_dir_name = CRONTABS; \
 } while (0)
 
+/* Log levels:
+ * 0 is the most verbose, default 8.
+ * For some reason, in fact only 5, 7 and 8 are used.
+ */
+static void crondlog(unsigned level, const char *msg, va_list va)
+{
+        if (level >= G.log_level) {
+                /*
+                 * We are called only for info meesages.
+                 * Warnings/errors use plain bb_[p]error_msg's, which
+                 * need not touch syslog_level
+                 * (they are ok with LOG_ERR default).
+                 */
+                syslog_level = LOG_INFO;
+                bb_verror_msg(msg, va, /* strerr: */ NULL);
+                syslog_level = LOG_ERR;
+        }
+}
 
-/* 0 is the most verbose, default 8 */
-#define LVL5  "\x05"
-#define LVL7  "\x07"
-#define LVL8  "\x08"
-#define WARN9 "\x49"
-#define DIE9  "\xc9"
-/* level >= 20 is "error" */
-#define ERR20 "\x14"
+static void log5(const char *msg, ...)
+{
+        va_list va;
+        va_start(va, msg);
+        crondlog(4, msg, va);
+        va_end(va);
+}
 
-static void crondlog(const char *ctl, ...) __attribute__ ((format (printf, 1, 2)));
-static void crondlog(const char *ctl, ...)
+static void log7(const char *msg, ...)
 {
         va_list va;
-        int level = (ctl[0] & 0x1f);
-
-        va_start(va, ctl);
-        if (level >= (int)G.log_level) {
-                /* Debug mode: all to (non-redirected) stderr, */
-                /* Syslog mode: all to syslog (logmode = LOGMODE_SYSLOG), */
-                if (!DebugOpt && G.log_filename) {
-                        /* Otherwise (log to file): we reopen log file at every write: */
-                        int logfd = open_or_warn(G.log_filename, O_WRONLY | O_CREAT | O_APPEND);
-                        if (logfd >= 0)
-                                xmove_fd(logfd, STDERR_FILENO);
-                }
-                /* When we log to syslog, level > 8 is logged at LOG_ERR
-                 * syslog level, level <= 8 is logged at LOG_INFO. */
-                if (level > 8) {
-                        bb_verror_msg(ctl + 1, va, /* strerr: */ NULL);
-                } else {
-                        char *msg = NULL;
-                        vasprintf(&msg, ctl + 1, va);
-                        bb_info_msg("%s: %s", applet_name, msg);
-                        free(msg);
-                }
-        }
+        va_start(va, msg);
+        crondlog(7, msg, va);
+        va_end(va);
+}
+
+static void log8(const char *msg, ...)
+{
+        va_list va;
+        va_start(va, msg);
+        crondlog(8, msg, va);
         va_end(va);
-        if (ctl[0] & 0x80)
-                exit(20);
 }
 
+
 static const char DowAry[] ALIGN1 =
         "sun""mon""tue""wed""thu""fri""sat"
-        /* "Sun""Mon""Tue""Wed""Thu""Fri""Sat" */
 ;
 
 static const char MonAry[] ALIGN1 =
         "jan""feb""mar""apr""may""jun""jul""aug""sep""oct""nov""dec"
-        /* "Jan""Feb""Mar""Apr""May""Jun""Jul""Aug""Sep""Oct""Nov""Dec" */
 ;
 
 static void ParseField(char *user, char *ary, int modvalue, int off,
@@ -267,12 +299,12 @@ static void ParseField(char *user, char *ary, int modvalue, int off,
 
         if (*ptr) {
  err:
-                crondlog(WARN9 "user %s: parse error at %s", user, base);
+                bb_error_msg("user %s: parse error at %s", user, base);
                 return;
         }
 
-        if (DebugOpt && (G.log_level <= 5)) { /* like LVL5 */
-                /* can't use crondlog, it inserts '\n' */
+        /* can't use log5 (it inserts newlines), open-coding it */
+        if (G.log_level <= 5 && logmode != LOGMODE_SYSLOG) {
                 int i;
                 for (i = 0; i < modvalue; ++i)
                         fprintf(stderr, "%d", (unsigned char)ary[i]);
@@ -368,11 +400,12 @@ static void load_crontab(const char *fileName)
 #if ENABLE_FEATURE_CROND_CALL_SENDMAIL
         char *mailTo = NULL;
 #endif
+        char *shell = NULL;
 
         delete_cronfile(fileName);
 
         if (!getpwnam(fileName)) {
-                crondlog(LVL7 "ignoring file '%s' (no such user)", fileName);
+                log7("ignoring file '%s' (no such user)", fileName);
                 return;
         }
 
@@ -393,14 +426,16 @@ static void load_crontab(const char *fileName)
                 while (1) {
                         CronLine *line;
 
-                        if (!--maxLines)
+                        if (!--maxLines) {
+                                bb_error_msg("user %s: too many lines", fileName);
                                 break;
+                        }
+
                         n = config_read(parser, tokens, 6, 1, "# \t", PARSE_NORMAL | PARSE_KEEP_COPY);
                         if (!n)
                                 break;
 
-                        if (DebugOpt)
-                                crondlog(LVL5 "user:%s entry:%s", fileName, parser->data);
+                        log5("user:%s entry:%s", fileName, parser->data);
 
                         /* check if line is setting MAILTO= */
                         if (0 == strncmp(tokens[0], "MAILTO=", 7)) {
@@ -410,6 +445,24 @@ static void load_crontab(const char *fileName)
 #endif /* otherwise just ignore such lines */
                                 continue;
                         }
+                        if (0 == strncmp(tokens[0], "SHELL=", 6)) {
+                                free(shell);
+                                shell = xstrdup(&tokens[0][6]);
+                                continue;
+                        }
+//TODO: handle HOME= too? "man crontab" says:
+//name = value
+//
+//where the spaces around the equal-sign (=) are optional, and any subsequent
+//non-leading spaces in value will be part of the value assigned to name.
+//The value string may be placed in quotes (single or double, but matching)
+//to preserve leading or trailing blanks.
+//
+//Several environment variables are set up automatically by the cron(8) daemon.
+//SHELL is set to /bin/sh, and LOGNAME and HOME are set from the /etc/passwd
+//line of the crontab's owner. HOME and SHELL may be overridden by settings
+//in the crontab; LOGNAME may not.
+
                         /* check if a minimum of tokens is specified */
                         if (n < 6)
                                 continue;
@@ -429,11 +482,9 @@ static void load_crontab(const char *fileName)
                         /* copy mailto (can be NULL) */
                         line->cl_mailto = xstrdup(mailTo);
 #endif
+                        line->cl_shell = xstrdup(shell);
                         /* copy command */
                         line->cl_cmd = xstrdup(tokens[5]);
-                        if (DebugOpt) {
-                                crondlog(LVL5 " command:%s", tokens[5]);
-                        }
                         pline = &line->cl_next;
 //bb_error_msg("M[%s]F[%s][%s][%s][%s][%s][%s]", mailTo, tokens[0], tokens[1], tokens[2], tokens[3], tokens[4], tokens[5]);
                 }
@@ -441,12 +492,12 @@ static void load_crontab(const char *fileName)
 
                 file->cf_next = G.cron_files;
                 G.cron_files = file;
-
-                if (maxLines == 0) {
-                        crondlog(WARN9 "user %s: too many lines", fileName);
-                }
         }
         config_close(parser);
+#if ENABLE_FEATURE_CROND_CALL_SENDMAIL
+        free(mailTo);
+#endif
+        free(shell);
 }
 
 static void process_cron_update_file(void)
@@ -482,17 +533,16 @@ static void rescan_crontab_dir(void)
         /* Remove cron update file */
         unlink(CRONUPDATE);
         /* Re-chdir, in case directory was renamed & deleted */
-        if (chdir(G.crontab_dir_name) < 0) {
-                crondlog(DIE9 "chdir(%s)", G.crontab_dir_name);
-        }
+        xchdir(G.crontab_dir_name);
 
         /* Scan directory and add associated users */
         {
                 DIR *dir = opendir(".");
                 struct dirent *den;
 
+                /* xopendir exists, but "can't open '.'" is not informative */
                 if (!dir)
-                        crondlog(DIE9 "chdir(%s)", "."); /* exits */
+                        bb_error_msg_and_die("can't open '%s'", G.crontab_dir_name);
                 while ((den = readdir(dir)) != NULL) {
                         if (strchr(den->d_name, '.') != NULL) {
                                 continue;
@@ -519,19 +569,22 @@ static void safe_setenv(char **pvar_val, const char *var, const char *val)
 }
 #endif
 
-static void set_env_vars(struct passwd *pas)
+static void set_env_vars(struct passwd *pas, const char *shell)
 {
+        /* POSIX requires crond to set up at least HOME, LOGNAME, PATH, SHELL.
+         * We assume crond inherited suitable PATH.
+         */
 #if SETENV_LEAKS
+        safe_setenv(&G.env_var_logname, "LOGNAME", pas->pw_name);
         safe_setenv(&G.env_var_user, "USER", pas->pw_name);
         safe_setenv(&G.env_var_home, "HOME", pas->pw_dir);
-        /* if we want to set user's shell instead: */
-        /*safe_setenv(G.env_var_shell, "SHELL", pas->pw_shell);*/
+        safe_setenv(&G.env_var_shell, "SHELL", shell);
 #else
+        xsetenv("LOGNAME", pas->pw_name);
         xsetenv("USER", pas->pw_name);
         xsetenv("HOME", pas->pw_dir);
+        xsetenv("SHELL", shell);
 #endif
-        /* currently, we use constant one: */
-        /*setenv("SHELL", DEFAULT_SHELL, 1); - done earlier */
 }
 
 static void change_user(struct passwd *pas)
@@ -539,10 +592,8 @@ static void change_user(struct passwd *pas)
         /* careful: we're after vfork! */
         change_identity(pas); /* - initgroups, setgid, setuid */
         if (chdir(pas->pw_dir) < 0) {
-                crondlog(WARN9 "chdir(%s)", pas->pw_dir);
-                if (chdir(TMPDIR) < 0) {
-                        crondlog(DIE9 "chdir(%s)", TMPDIR); /* exits */
-                }
+                bb_error_msg("can't change directory to '%s'", pas->pw_dir);
+                xchdir(CRON_DIR);
         }
 }
 
@@ -550,46 +601,53 @@ static void change_user(struct passwd *pas)
 #if ENABLE_FEATURE_CROND_CALL_SENDMAIL
 
 static pid_t
-fork_job(const char *user, int mailFd,
-                const char *prog,
-                const char *shell_cmd /* if NULL, we run sendmail */
-) {
+fork_job(const char *user, int mailFd, CronLine *line, bool run_sendmail)
+{
         struct passwd *pas;
+        const char *shell, *prog;
+        smallint sv_logmode;
         pid_t pid;
 
         /* prepare things before vfork */
         pas = getpwnam(user);
         if (!pas) {
-                crondlog(WARN9 "can't get uid for %s", user);
+                bb_error_msg("can't get uid for %s", user);
                 goto err;
         }
-        set_env_vars(pas);
 
+        shell = line->cl_shell ? line->cl_shell : DEFAULT_SHELL;
+        prog = run_sendmail ? SENDMAIL : shell;
+
+        set_env_vars(pas, shell);
+
+        sv_logmode = logmode;
         pid = vfork();
         if (pid == 0) {
                 /* CHILD */
-                /* initgroups, setgid, setuid, and chdir to home or TMPDIR */
+                /* initgroups, setgid, setuid, and chdir to home or CRON_DIR */
                 change_user(pas);
-                if (DebugOpt) {
-                        crondlog(LVL5 "child running %s", prog);
-                }
+                log5("child running %s", prog);
                 if (mailFd >= 0) {
-                        xmove_fd(mailFd, shell_cmd ? 1 : 0);
+                        xmove_fd(mailFd, run_sendmail ? 0 : 1);
                         dup2(1, 2);
                 }
                 /* crond 3.0pl1-100 puts tasks in separate process groups */
                 bb_setpgrp();
-                execlp(prog, prog, (shell_cmd ? "-c" : SENDMAIL_ARGS), shell_cmd, (char *) NULL);
-                crondlog(ERR20 "can't execute '%s' for user %s", prog, user);
-                if (shell_cmd) {
-                        fdprintf(1, "Exec failed: %s -c %s\n", prog, shell_cmd);
-                }
-                _exit(EXIT_SUCCESS);
+                if (!run_sendmail)
+                        execlp(prog, prog, "-c", line->cl_cmd, (char *) NULL);
+                else
+                        execlp(prog, prog, SENDMAIL_ARGS, (char *) NULL);
+                /*
+                 * I want this error message on stderr too,
+                 * even if other messages go only to syslog:
+                 */
+                logmode |= LOGMODE_STDIO;
+                bb_error_msg_and_die("can't execute '%s' for user %s", prog, user);
         }
+        logmode = sv_logmode;
 
         if (pid < 0) {
-                /* FORK FAILED */
-                crondlog(ERR20 "can't vfork");
+                bb_perror_msg("vfork");
  err:
                 pid = 0;
         } /* else: PARENT, FORK SUCCESS */
@@ -614,7 +672,7 @@ static void start_one_job(const char *user, CronLine *line)
 
         if (line->cl_mailto) {
                 /* Open mail file (owner is root so nobody can screw with it) */
-                snprintf(mailFile, sizeof(mailFile), "%s/cron.%s.%d", TMPDIR, user, getpid());
+                snprintf(mailFile, sizeof(mailFile), "%s/cron.%s.%d", CRON_DIR, user, getpid());
                 mailFd = open(mailFile, O_CREAT | O_TRUNC | O_WRONLY | O_EXCL | O_APPEND, 0600);
 
                 if (mailFd >= 0) {
@@ -622,18 +680,18 @@ static void start_one_job(const char *user, CronLine *line)
                                 line->cl_cmd);
                         line->cl_empty_mail_size = lseek(mailFd, 0, SEEK_CUR);
                 } else {
-                        crondlog(ERR20 "can't create mail file %s for user %s, "
+                        bb_error_msg("can't create mail file %s for user %s, "
                                         "discarding output", mailFile, user);
                 }
         }
 
-        line->cl_pid = fork_job(user, mailFd, DEFAULT_SHELL, line->cl_cmd);
+        line->cl_pid = fork_job(user, mailFd, line, /*sendmail?*/ 0);
         if (mailFd >= 0) {
                 if (line->cl_pid <= 0) {
                         unlink(mailFile);
                 } else {
                         /* rename mail-file based on pid of process */
-                        char *mailFile2 = xasprintf("%s/cron.%s.%d", TMPDIR, user, (int)line->cl_pid);
+                        char *mailFile2 = xasprintf("%s/cron.%s.%d", CRON_DIR, user, (int)line->cl_pid);
                         rename(mailFile, mailFile2); // TODO: xrename?
                         free(mailFile2);
                 }
@@ -665,7 +723,7 @@ static void process_finished_job(const char *user, CronLine *line)
          * End of primary job - check for mail file.
          * If size has changed and the file is still valid, we send it.
          */
-        snprintf(mailFile, sizeof(mailFile), "%s/cron.%s.%d", TMPDIR, user, (int)pid);
+        snprintf(mailFile, sizeof(mailFile), "%s/cron.%s.%d", CRON_DIR, user, (int)pid);
         mailFd = open(mailFile, O_RDONLY);
         unlink(mailFile);
         if (mailFd < 0) {
@@ -683,43 +741,41 @@ static void process_finished_job(const char *user, CronLine *line)
         }
         line->cl_empty_mail_size = 0;
         /* if (line->cl_mailto) - always true if cl_empty_mail_size was nonzero */
-                line->cl_pid = fork_job(user, mailFd, SENDMAIL, NULL);
+                line->cl_pid = fork_job(user, mailFd, line, /*sendmail?*/ 1);
 }
 
 #else /* !ENABLE_FEATURE_CROND_CALL_SENDMAIL */
 
 static void start_one_job(const char *user, CronLine *line)
 {
+        const char *shell;
         struct passwd *pas;
         pid_t pid;
 
         pas = getpwnam(user);
         if (!pas) {
-                crondlog(WARN9 "can't get uid for %s", user);
+                bb_error_msg("can't get uid for %s", user);
                 goto err;
         }
 
         /* Prepare things before vfork */
-        set_env_vars(pas);
+        shell = line->cl_shell ? line->cl_shell : DEFAULT_SHELL;
+        set_env_vars(pas, shell);
 
         /* Fork as the user in question and run program */
         pid = vfork();
         if (pid == 0) {
                 /* CHILD */
-                /* initgroups, setgid, setuid, and chdir to home or TMPDIR */
+                /* initgroups, setgid, setuid, and chdir to home or CRON_DIR */
                 change_user(pas);
-                if (DebugOpt) {
-                        crondlog(LVL5 "child running %s", DEFAULT_SHELL);
-                }
+                log5("child running %s", shell);
                 /* crond 3.0pl1-100 puts tasks in separate process groups */
                 bb_setpgrp();
-                execl(DEFAULT_SHELL, DEFAULT_SHELL, "-c", line->cl_cmd, (char *) NULL);
-                crondlog(ERR20 "can't execute '%s' for user %s", DEFAULT_SHELL, user);
-                _exit(EXIT_SUCCESS);
+                execl(shell, shell, "-c", line->cl_cmd, (char *) NULL);
+                bb_error_msg_and_die("can't execute '%s' for user %s", shell, user);
         }
         if (pid < 0) {
-                /* FORK FAILED */
-                crondlog(ERR20 "can't vfork");
+                bb_perror_msg("vfork");
  err:
                 pid = 0;
         }
@@ -751,24 +807,20 @@ static void flag_starting_jobs(time_t t1, time_t t2)
 
                 ptm = localtime(&t);
                 for (file = G.cron_files; file; file = file->cf_next) {
-                        if (DebugOpt)
-                                crondlog(LVL5 "file %s:", file->cf_username);
+                        log5("file %s:", file->cf_username);
                         if (file->cf_deleted)
                                 continue;
                         for (line = file->cf_lines; line; line = line->cl_next) {
-                                if (DebugOpt)
-                                        crondlog(LVL5 " line %s", line->cl_cmd);
+                                log5(" line %s", line->cl_cmd);
                                 if (line->cl_Mins[ptm->tm_min]
                                  && line->cl_Hrs[ptm->tm_hour]
                                  && (line->cl_Days[ptm->tm_mday] || line->cl_Dow[ptm->tm_wday])
                                  && line->cl_Mons[ptm->tm_mon]
                                 ) {
-                                        if (DebugOpt) {
-                                                crondlog(LVL5 " job: %d %s",
+                                        log5(" job: %d %s",
                                                         (int)line->cl_pid, line->cl_cmd);
-                                        }
                                         if (line->cl_pid > 0) {
-                                                crondlog(LVL8 "user %s: process already running: %s",
+                                                log8("user %s: process already running: %s",
                                                         file->cf_username, line->cl_cmd);
                                         } else if (line->cl_pid == 0) {
                                                 line->cl_pid = -1;
@@ -797,7 +849,7 @@ static void start_jobs(void)
 
                         start_one_job(file->cf_username, line);
                         pid = line->cl_pid;
-                        crondlog(LVL8 "USER %s pid %3d cmd %s",
+                        log8("USER %s pid %3d cmd %s",
                                 file->cf_username, (int)pid, line->cl_cmd);
                         if (pid < 0) {
                                 file->cf_wants_starting = 1;
@@ -849,12 +901,21 @@ static int check_completions(void)
         return num_still_running;
 }
 
+static void reopen_logfile_to_stderr(void)
+{
+        if (G.log_filename) {
+                int logfd = open_or_warn(G.log_filename, O_WRONLY | O_CREAT | O_APPEND);
+                if (logfd >= 0)
+                        xmove_fd(logfd, STDERR_FILENO);
+        }
+}
+
 int crond_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int crond_main(int argc UNUSED_PARAM, char **argv)
 {
         time_t t2;
-        int rescan;
-        int sleep_time;
+        unsigned rescan;
+        unsigned sleep_time;
         unsigned opts;
 
         INIT_G();
@@ -880,10 +941,11 @@ int crond_main(int argc UNUSED_PARAM, char **argv)
                 logmode = LOGMODE_SYSLOG;
         }
 
-        xchdir(G.crontab_dir_name);
         //signal(SIGHUP, SIG_IGN); /* ? original crond dies on HUP... */
-        xsetenv("SHELL", DEFAULT_SHELL); /* once, for all future children */
-        crondlog(LVL8 "crond (busybox "BB_VER") started, log level %d", G.log_level);
+
+        reopen_logfile_to_stderr();
+        xchdir(G.crontab_dir_name);
+        log8("crond (busybox "BB_VER") started, log level %d", G.log_level);
         rescan_crontab_dir();
         write_pidfile(CONFIG_PID_FILE_PATH "/crond.pid");
 
@@ -896,14 +958,14 @@ int crond_main(int argc UNUSED_PARAM, char **argv)
                 time_t t1;
                 long dt;
 
-                t1 = t2;
-
                 /* Synchronize to 1 minute, minimum 1 second */
-                sleep(sleep_time - (time(NULL) % sleep_time) + 1);
-
+                t1 = t2;
+                sleep(sleep_time - (time(NULL) % sleep_time));
                 t2 = time(NULL);
                 dt = (long)t2 - (long)t1;
 
+                reopen_logfile_to_stderr();
+
                 /*
                  * The file 'cron.update' is checked to determine new cron
                  * jobs.  The directory is rescanned once an hour to deal
@@ -931,20 +993,18 @@ int crond_main(int argc UNUSED_PARAM, char **argv)
                         rescan_crontab_dir();
                 }
                 process_cron_update_file();
-                if (DebugOpt)
-                        crondlog(LVL5 "wakeup dt=%ld", dt);
+                log5("wakeup dt=%ld", dt);
                 if (dt < -60 * 60 || dt > 60 * 60) {
-                        crondlog(WARN9 "time disparity of %ld minutes detected", dt / 60);
+                        bb_error_msg("time disparity of %ld minutes detected", dt / 60);
                         /* and we do not run any jobs in this case */
                 } else if (dt > 0) {
                         /* Usual case: time advances forward, as expected */
                         flag_starting_jobs(t1, t2);
                         start_jobs();
+                        sleep_time = 60;
                         if (check_completions() > 0) {
                                 /* some jobs are still running */
                                 sleep_time = 10;
-                        } else {
-                                sleep_time = 60;
                         }
                 }
                 /* else: time jumped back, do not run any jobs */
diff --git a/miscutils/less.c b/miscutils/less.c
index 574f222e0..d84df469c 100644
--- a/miscutils/less.c
+++ b/miscutils/less.c
@@ -404,6 +404,9 @@ static void fill_match_lines(unsigned pos);
  * last_line_pos - screen line position of next char to be read
  *      (takes into account tabs and backspaces)
  * eof_error - < 0 error, == 0 EOF, > 0 not EOF/error
+ *
+ * "git log -p | less -m" on the kernel git tree is a good test for EAGAINs,
+ * "/search on very long input" and "reaching max line count" corner cases.
  */
 static void read_lines(void)
 {
@@ -414,9 +417,13 @@ static void read_lines(void)
 #if ENABLE_FEATURE_LESS_REGEXP
         unsigned old_max_fline = max_fline;
         time_t last_time = 0;
-        unsigned seconds_p1 = 3; /* seconds_to_loop + 1 */
+        int had_progress = 2;
 #endif
 
+        /* (careful: max_fline can be -1) */
+        if (max_fline + 1 > MAXLINES)
+                return;
+
         if (option_mask32 & FLAG_N)
                 w -= 8;
 
@@ -441,6 +448,7 @@ static void read_lines(void)
                         char c;
                         /* if no unprocessed chars left, eat more */
                         if (readpos >= readeof) {
+                                errno = 0;
                                 ndelay_on(0);
                                 eof_error = safe_read(STDIN_FILENO, readbuf, sizeof(readbuf));
                                 ndelay_off(0);
@@ -448,6 +456,7 @@ static void read_lines(void)
                                 readeof = eof_error;
                                 if (eof_error <= 0)
                                         goto reached_eof;
+                                IF_FEATURE_LESS_REGEXP(had_progress = 1;)
                         }
                         c = readbuf[readpos];
                         /* backspace? [needed for manpages] */
@@ -519,31 +528,23 @@ static void read_lines(void)
 #endif
                 }
                 if (eof_error <= 0) {
-                        if (eof_error < 0) {
-                                if (errno == EAGAIN) {
-                                        /* not yet eof or error, reset flag (or else
-                                         * we will hog CPU - select() will return
-                                         * immediately */
-                                        eof_error = 1;
-                                } else {
-                                        print_statusline(bb_msg_read_error);
-                                }
-                        }
 #if !ENABLE_FEATURE_LESS_REGEXP
                         break;
 #else
                         if (wanted_match < num_matches) {
                                 break;
-                        } else { /* goto_match called us */
+                        } /* else: goto_match() called us */
+                        if (errno == EAGAIN) {
                                 time_t t = time(NULL);
                                 if (t != last_time) {
                                         last_time = t;
-                                        if (--seconds_p1 == 0)
+                                        if (--had_progress < 0)
                                                 break;
                                 }
                                 sched_yield();
-                                goto again0; /* go loop again (max 2 seconds) */
+                                goto again0;
                         }
+                        break;
 #endif
                 }
                 max_fline++;
@@ -551,6 +552,15 @@ static void read_lines(void)
                 p = current_line;
                 last_line_pos = 0;
         } /* end of "read lines until we reach cur_fline" loop */
+
+        if (eof_error < 0) {
+                if (errno == EAGAIN) {
+                        eof_error = 1;
+                } else {
+                        print_statusline(bb_msg_read_error);
+                }
+        }
+
         fill_match_lines(old_max_fline);
 #if ENABLE_FEATURE_LESS_REGEXP
         /* prevent us from being stuck in search for a match */
diff --git a/modutils/insmod.c b/modutils/insmod.c
index 887d9f2a3..9c3c992a5 100644
--- a/modutils/insmod.c
+++ b/modutils/insmod.c
@@ -21,7 +21,7 @@
 //usage:        IF_NOT_FEATURE_2_4_MODULES("FILE ")
 //usage:        "[SYMBOL=VALUE]..."
 //usage:#define insmod_full_usage "\n\n"
-//usage:       "Load the specified kernel modules into the kernel"
+//usage:       "Load kernel module"
 //usage:        IF_FEATURE_2_4_MODULES( "\n"
 //usage:     "\n        -f      Force module to load into the wrong kernel version"
 //usage:     "\n        -k      Make module autoclean-able"
diff --git a/modutils/modprobe-small.c b/modutils/modprobe-small.c
index 5b7836344..91e0c1380 100644
--- a/modutils/modprobe-small.c
+++ b/modutils/modprobe-small.c
@@ -9,10 +9,10 @@
  */
 
 //applet:IF_MODPROBE_SMALL(APPLET(modprobe, BB_DIR_SBIN, BB_SUID_DROP))
-//applet:IF_MODPROBE_SMALL(APPLET_ODDNAME(depmod, modprobe, BB_DIR_SBIN, BB_SUID_DROP, modprobe))
-//applet:IF_MODPROBE_SMALL(APPLET_ODDNAME(insmod, modprobe, BB_DIR_SBIN, BB_SUID_DROP, modprobe))
-//applet:IF_MODPROBE_SMALL(APPLET_ODDNAME(lsmod, modprobe, BB_DIR_SBIN, BB_SUID_DROP, modprobe))
-//applet:IF_MODPROBE_SMALL(APPLET_ODDNAME(rmmod, modprobe, BB_DIR_SBIN, BB_SUID_DROP, modprobe))
+//applet:IF_MODPROBE_SMALL(APPLET_ODDNAME(depmod, modprobe, BB_DIR_SBIN, BB_SUID_DROP, depmod))
+//applet:IF_MODPROBE_SMALL(APPLET_ODDNAME(insmod, modprobe, BB_DIR_SBIN, BB_SUID_DROP, insmod))
+//applet:IF_MODPROBE_SMALL(APPLET_ODDNAME(lsmod, modprobe, BB_DIR_SBIN, BB_SUID_DROP, lsmod))
+//applet:IF_MODPROBE_SMALL(APPLET_ODDNAME(rmmod, modprobe, BB_DIR_SBIN, BB_SUID_DROP, rmmod))
 
 #include "libbb.h"
 /* After libbb.h, since it needs sys/types.h on some systems */
@@ -22,6 +22,9 @@
 extern int init_module(void *module, unsigned long len, const char *options);
 extern int delete_module(const char *module, unsigned flags);
 extern int query_module(const char *name, int which, void *buf, size_t bufsize, size_t *ret);
+/* linux/include/linux/module.h has limit of 64 chars on module names */
+#undef MODULE_NAME_LEN
+#define MODULE_NAME_LEN 64
 
 
 #if 1
@@ -143,6 +146,19 @@ static void replace(char *s, char what, char with)
         }
 }
 
+static char *filename2modname(const char *filename, char *modname)
+{
+        int i;
+        char *from;
+
+        from = bb_get_last_path_component_nostrip(filename);
+        for (i = 0; i < (MODULE_NAME_LEN-1) && from[i] != '\0' && from[i] != '.'; i++)
+                modname[i] = (from[i] == '-') ? '_' : from[i];
+        modname[i] = '\0';
+
+        return modname;
+}
+
 /* Take "word word", return malloced "word",NUL,"word",NUL,NUL */
 static char* str_2_list(const char *str)
 {
@@ -212,6 +228,7 @@ static void parse_module(module_info *info, const char *pathname)
         reset_stringbuf();
         pos = 0;
         while (1) {
+                unsigned start = stringbuf_idx;
                 ptr = find_keyword(module_image + pos, len - pos, "alias=");
                 if (!ptr) {
                         ptr = find_keyword(module_image + pos, len - pos, "__ksymtab_");
@@ -228,6 +245,31 @@ static void parse_module(module_info *info, const char *pathname)
                 }
                 append(ptr);
                 appendc(' ');
+                /*
+                 * Don't add redundant aliases, such as:
+                 * libcrc32c.ko symbol:crc32c symbol:crc32c
+                 */
+                if (start) { /* "if we aren't the first alias" */
+                        char *found, *last;
+                        stringbuf[stringbuf_idx] = '\0';
+                        last = stringbuf + start;
+                        /*
+                         * String at last-1 is " symbol:crc32c "
+                         * (with both leading and trailing spaces).
+                         */
+                        if (strncmp(stringbuf, last, stringbuf_idx - start) == 0)
+                                /* First alias matches us */
+                                found = stringbuf;
+                        else
+                                /* Does any other alias match? */
+                                found = strstr(stringbuf, last-1);
+                        if (found < last-1) {
+                                /* There is absolutely the same string before us */
+                                dbg2_error_msg("redundant:'%s'", last);
+                                stringbuf_idx = start;
+                                goto skip;
+                        }
+                }
  skip:
                 pos = (ptr - module_image);
         }
@@ -251,14 +293,13 @@ static void parse_module(module_info *info, const char *pathname)
 
 static int pathname_matches_modname(const char *pathname, const char *modname)
 {
+        int r;
+        char name[MODULE_NAME_LEN];
         const char *fname = bb_get_last_path_component_nostrip(pathname);
         const char *suffix = strrstr(fname, ".ko");
-//TODO: can do without malloc?
-        char *name = xstrndup(fname, suffix - fname);
-        int r;
+        safe_strncpy(name, fname, suffix - fname);
         replace(name, '-', '_');
         r = (strcmp(name, modname) == 0);
-        free(name);
         return r;
 }
 
@@ -421,11 +462,12 @@ static void write_out_dep_bb(int fd)
         }
 }
 
-static module_info* find_alias(const char *alias)
+static module_info** find_alias(const char *alias)
 {
         int i;
         int dep_bb_fd;
-        module_info *result;
+        int infoidx;
+        module_info **infovec;
         dbg1_error_msg("find_alias('%s')", alias);
 
  try_again:
@@ -438,7 +480,9 @@ static module_info* find_alias(const char *alias)
                         if (!modinfo[i].aliases) {
                                 parse_module(&modinfo[i], modinfo[i].pathname);
                         }
-                        return &modinfo[i];
+                        infovec = xzalloc(2 * sizeof(infovec[0]));
+                        infovec[0] = &modinfo[i];
+                        return infovec;
                 }
                 i++;
         }
@@ -451,16 +495,13 @@ static module_info* find_alias(const char *alias)
 
         /* Scan all module bodies, extract modinfo (it contains aliases) */
         i = 0;
-        result = NULL;
+        infoidx = 0;
+        infovec = NULL;
         while (modinfo[i].pathname) {
                 char *desc, *s;
                 if (!modinfo[i].aliases) {
                         parse_module(&modinfo[i], modinfo[i].pathname);
                 }
-                if (result) {
-                        i++;
-                        continue;
-                }
                 /* "alias1 symbol:sym1 alias2 symbol:sym2" */
                 desc = str_2_list(modinfo[i].aliases);
                 /* Does matching substring exist? */
@@ -472,13 +513,12 @@ static module_info* find_alias(const char *alias)
                         if (fnmatch(s, alias, 0) == 0) {
                                 dbg1_error_msg("found alias '%s' in module '%s'",
                                                 alias, modinfo[i].pathname);
-                                result = &modinfo[i];
+                                infovec = xrealloc_vector(infovec, 1, infoidx);
+                                infovec[infoidx++] = &modinfo[i];
                                 break;
                         }
                 }
                 free(desc);
-                if (result && dep_bb_fd < 0)
-                        return result;
                 i++;
         }
 
@@ -487,8 +527,8 @@ static module_info* find_alias(const char *alias)
                 write_out_dep_bb(dep_bb_fd);
         }
 
-        dbg1_error_msg("find_alias '%s' returns %p", alias, result);
-        return result;
+        dbg1_error_msg("find_alias '%s' returns %d results", alias, infoidx);
+        return infovec;
 }
 
 #if ENABLE_FEATURE_MODPROBE_SMALL_CHECK_ALREADY_LOADED
@@ -524,14 +564,23 @@ static int already_loaded(const char *name)
 static void process_module(char *name, const char *cmdline_options)
 {
         char *s, *deps, *options;
+        module_info **infovec;
         module_info *info;
+        int infoidx;
         int is_rmmod = (option_mask32 & OPT_r) != 0;
+
         dbg1_error_msg("process_module('%s','%s')", name, cmdline_options);
 
         replace(name, '-', '_');
 
         dbg1_error_msg("already_loaded:%d is_rmmod:%d", already_loaded(name), is_rmmod);
-        if (already_loaded(name) != is_rmmod) {
+        /*
+         * We used to have "is_rmmod != already_loaded(name)" check here, but
+         *  modprobe -r pci:v00008086d00007010sv00000000sd00000000bc01sc01i80
+         * won't unload modules (there are more than one)
+         * which have this alias.
+         */
+        if (!is_rmmod && already_loaded(name)) {
                 dbg1_error_msg("nothing to do for '%s'", name);
                 return;
         }
@@ -560,39 +609,51 @@ static void process_module(char *name, const char *cmdline_options)
         if (!module_count) {
                 /* Scan module directory. This is done only once.
                  * It will attempt module load, and will exit(EXIT_SUCCESS)
-                 * on success. */
+                 * on success.
+                 */
                 module_found_idx = -1;
                 recursive_action(".",
                         ACTION_RECURSE, /* flags */
                         fileAction, /* file action */
                         NULL, /* dir action */
                         name, /* user data */
-                        0); /* depth */
+                        0 /* depth */
+                );
                 dbg1_error_msg("dirscan complete");
                 /* Module was not found, or load failed, or is_rmmod */
                 if (module_found_idx >= 0) { /* module was found */
-                        info = &modinfo[module_found_idx];
+                        infovec = xzalloc(2 * sizeof(infovec[0]));
+                        infovec[0] = &modinfo[module_found_idx];
                 } else { /* search for alias, not a plain module name */
-                        info = find_alias(name);
+                        infovec = find_alias(name);
                 }
         } else {
-                info = find_alias(name);
+                infovec = find_alias(name);
         }
 
-// Problem here: there can be more than one module
-// for the given alias. For example,
-// "pci:v00008086d00007010sv00000000sd00000000bc01sc01i80" matches
-// ata_piix because it has an alias "pci:v00008086d00007010sv*sd*bc*sc*i*"
-// and ata_generic, it has an alias "alias=pci:v*d*sv*sd*bc01sc01i*"
-// Standard modprobe would load them both.
-// In this code, find_alias() returns only the first matching module.
+        /* There can be more than one module for the given alias. For example,
+         * "pci:v00008086d00007010sv00000000sd00000000bc01sc01i80" matches
+         * ata_piix because it has alias "pci:v00008086d00007010sv*sd*bc*sc*i*"
+         * and ata_generic, it has alias "pci:v*d*sv*sd*bc01sc01i*"
+         * Standard modprobe loads them both. We achieve it by returning
+         * a *list* of modinfo pointers from find_alias().
+         */
 
-        /* rmmod? unload it by name */
+        /* rmmod or modprobe -r? unload module(s) */
         if (is_rmmod) {
-                if (delete_module(name, O_NONBLOCK | O_EXCL) != 0) {
-                        if (!(option_mask32 & OPT_q))
-                                bb_perror_msg("remove '%s'", name);
-                        goto ret;
+                infoidx = 0;
+                while ((info = infovec[infoidx++]) != NULL) {
+                        int r;
+                        char modname[MODULE_NAME_LEN];
+
+                        filename2modname(info->pathname, modname);
+                        r = delete_module(modname, O_NONBLOCK | O_EXCL);
+                        dbg1_error_msg("delete_module('%s', O_NONBLOCK | O_EXCL):%d", modname, r);
+                        if (r != 0) {
+                                if (!(option_mask32 & OPT_q))
+                                        bb_perror_msg("remove '%s'", modname);
+                                goto ret;
+                        }
                 }
 
                 if (applet_name[0] == 'r') {
@@ -608,7 +669,7 @@ static void process_module(char *name, const char *cmdline_options)
                  */
         }
 
-        if (!info) {
+        if (!infovec) {
                 /* both dirscan and find_alias found nothing */
                 if (!is_rmmod && applet_name[0] != 'd') /* it wasn't rmmod or depmod */
                         bb_error_msg("module '%s' not found", name);
@@ -616,36 +677,41 @@ static void process_module(char *name, const char *cmdline_options)
                 goto ret;
         }
 
-        /* Iterate thru dependencies, trying to (un)load them */
-        deps = str_2_list(info->deps);
-        for (s = deps; *s; s += strlen(s) + 1) {
-                //if (strcmp(name, s) != 0) // N.B. do loops exist?
-                dbg1_error_msg("recurse on dep '%s'", s);
-                process_module(s, NULL);
-                dbg1_error_msg("recurse on dep '%s' done", s);
-        }
-        free(deps);
+        infoidx = 0;
+        while ((info = infovec[infoidx++]) != NULL) {
+                /* Iterate thru dependencies, trying to (un)load them */
+                deps = str_2_list(info->deps);
+                for (s = deps; *s; s += strlen(s) + 1) {
+                        //if (strcmp(name, s) != 0) // N.B. do loops exist?
+                        dbg1_error_msg("recurse on dep '%s'", s);
+                        process_module(s, NULL);
+                        dbg1_error_msg("recurse on dep '%s' done", s);
+                }
+                free(deps);
 
-        /* modprobe -> load it */
-        if (!is_rmmod) {
-                if (!options || strstr(options, "blacklist") == NULL) {
-                        errno = 0;
-                        if (load_module(info->pathname, options) != 0) {
-                                if (EEXIST != errno) {
-                                        bb_error_msg("'%s': %s",
-                                                info->pathname,
-                                                moderror(errno));
-                                } else {
-                                        dbg1_error_msg("'%s': %s",
-                                                info->pathname,
-                                                moderror(errno));
-                                }
-                        }
-                } else {
+                if (is_rmmod)
+                        continue;
+
+                /* We are modprobe: load it */
+                if (options && strstr(options, "blacklist")) {
                         dbg1_error_msg("'%s': blacklisted", info->pathname);
+                        continue;
+                }
+                errno = 0;
+                if (load_module(info->pathname, options) != 0) {
+                        if (EEXIST != errno) {
+                                bb_error_msg("'%s': %s",
+                                        info->pathname,
+                                        moderror(errno));
+                        } else {
+                                dbg1_error_msg("'%s': %s",
+                                        info->pathname,
+                                        moderror(errno));
+                        }
                 }
         }
  ret:
+        free(infovec);
         free(options);
 //TODO: return load attempt result from process_module.
 //If dep didn't load ok, continuing makes little sense.
@@ -703,10 +769,6 @@ The following options are useful for people managing distributions:
 
 //usage:#if ENABLE_MODPROBE_SMALL
 
-//// Note: currently, help system shows modprobe --help text for all aliased cmds
-//// (see APPLET_ODDNAME macro definition).
-//// All other help texts defined below are not used. FIXME?
-
 //usage:#define depmod_trivial_usage NOUSAGE_STR
 //usage:#define depmod_full_usage ""
 
@@ -720,7 +782,7 @@ The following options are useful for people managing distributions:
 //usage:        IF_NOT_FEATURE_2_4_MODULES("FILE ")
 //usage:        "[SYMBOL=VALUE]..."
 //usage:#define insmod_full_usage "\n\n"
-//usage:       "Load the specified kernel modules into the kernel"
+//usage:       "Load kernel module"
 //usage:        IF_FEATURE_2_4_MODULES( "\n"
 //usage:     "\n        -f      Force module to load into the wrong kernel version"
 //usage:     "\n        -k      Make module autoclean-able"
@@ -745,7 +807,7 @@ The following options are useful for people managing distributions:
 //usage:       "$ rmmod tulip\n"
 
 //usage:#define modprobe_trivial_usage
-//usage:        "[-qfwrsv] MODULE [symbol=value]..."
+//usage:        "[-qfwrsv] MODULE [SYMBOL=VALUE]..."
 //usage:#define modprobe_full_usage "\n\n"
 //usage:       "        -r      Remove MODULE (stacks) or do autoclean"
 //usage:     "\n        -q      Quiet"
diff --git a/modutils/modprobe.c b/modutils/modprobe.c
index 7f7446d8e..f08f0850d 100644
--- a/modutils/modprobe.c
+++ b/modutils/modprobe.c
@@ -87,7 +87,7 @@
 //usage:
 //usage:#define modprobe_trivial_usage
 //usage:        "[-alrqvsD" IF_FEATURE_MODPROBE_BLACKLIST("b") "]"
-//usage:        " MODULE [symbol=value]..."
+//usage:        " MODULE [SYMBOL=VALUE]..."
 //usage:#define modprobe_full_usage "\n\n"
 //usage:       "        -a      Load multiple MODULEs"
 //usage:     "\n        -l      List (MODULE is a pattern)"
diff --git a/networking/Config.src b/networking/Config.src
index ca0ddcdd9..fbad7ecb2 100644
--- a/networking/Config.src
+++ b/networking/Config.src
@@ -664,6 +664,14 @@ config FEATURE_NTPD_SERVER
           Make ntpd usable as a NTP server. If you disable this option
           ntpd will be usable only as a NTP client.
 
+config FEATURE_NTPD_CONF
+        bool "Make ntpd understand /etc/ntp.conf"
+        default y
+        depends on NTPD
+        help
+          Make ntpd look in /etc/ntp.conf for peers. Only "server address"
+          is supported.
+
 config PSCAN
         bool "pscan"
         default y
diff --git a/networking/ifupdown.c b/networking/ifupdown.c
index e1ea351a4..c35d97a1a 100644
--- a/networking/ifupdown.c
+++ b/networking/ifupdown.c
@@ -555,7 +555,7 @@ static int FAST_FUNC dhcp_up(struct interface_defn_t *ifd, execfn *exec)
                 return 0;
 #  endif
         for (i = 0; i < ARRAY_SIZE(ext_dhcp_clients); i++) {
-                if (exists_execable(ext_dhcp_clients[i].name))
+                if (executable_exists(ext_dhcp_clients[i].name))
                         return execute(ext_dhcp_clients[i].startcmd, ifd, exec);
         }
         bb_error_msg("no dhcp clients found");
@@ -592,7 +592,7 @@ static int FAST_FUNC dhcp_down(struct interface_defn_t *ifd, execfn *exec)
         unsigned i;
 
         for (i = 0; i < ARRAY_SIZE(ext_dhcp_clients); i++) {
-                if (exists_execable(ext_dhcp_clients[i].name)) {
+                if (executable_exists(ext_dhcp_clients[i].name)) {
                         result = execute(ext_dhcp_clients[i].stopcmd, ifd, exec);
                         if (result)
                                 break;
diff --git a/networking/ntpd.c b/networking/ntpd.c
index 44592ce54..59607ed23 100644
--- a/networking/ntpd.c
+++ b/networking/ntpd.c
@@ -42,6 +42,13 @@
 //usage:        )
 //usage:     "\n        -S PROG Run PROG after stepping time, stratum change, and every 11 mins"
 //usage:     "\n        -p PEER Obtain time from PEER (may be repeated)"
+//usage:        IF_FEATURE_NTPD_CONF(
+//usage:     "\n                If -p is not given, read /etc/ntp.conf"
+//usage:        )
+
+// -l and -p options are not compatible with "standard" ntpd:
+// it has them as "-l logfile" and "-p pidfile".
+// -S and -w are not compat either, "standard" ntpd has no such opts.
 
 #include "libbb.h"
 #include <math.h>
@@ -245,6 +252,9 @@ typedef struct {
          * or when receive times out (if p_fd >= 0): */
         double           next_action_time;
         double           p_xmttime;
+        double           p_raw_delay;
+        /* p_raw_delay is set even by "high delay" packets */
+        /* lastpkt_delay isn't */
         double           lastpkt_recv_time;
         double           lastpkt_delay;
         double           lastpkt_rootdelay;
@@ -730,7 +740,7 @@ reset_peer_stats(peer_t *p, double offset)
 }
 
 static void
-add_peers(char *s)
+add_peers(const char *s)
 {
         peer_t *p;
 
@@ -1678,7 +1688,8 @@ recv_and_process_peer_pkt(peer_t *p)
         ssize_t     size;
         msg_t       msg;
         double      T1, T2, T3, T4;
-        double      dv, offset;
+        double      offset;
+        double      prev_delay, delay;
         unsigned    interval;
         datapoint_t *datapoint;
         peer_t      *q;
@@ -1738,12 +1749,6 @@ recv_and_process_peer_pkt(peer_t *p)
 //      if (msg.m_rootdelay / 2 + msg.m_rootdisp >= MAXDISP || p->lastpkt_reftime > msg.m_xmt)
 //              return;                 /* invalid header values */
 
-        p->lastpkt_status = msg.m_status;
-        p->lastpkt_stratum = msg.m_stratum;
-        p->lastpkt_rootdelay = sfp_to_d(msg.m_rootdelay);
-        p->lastpkt_rootdisp = sfp_to_d(msg.m_rootdisp);
-        p->lastpkt_refid = msg.m_refid;
-
         /*
          * From RFC 2030 (with a correction to the delay math):
          *
@@ -1763,28 +1768,35 @@ recv_and_process_peer_pkt(peer_t *p)
         T3 = lfp_to_d(msg.m_xmttime);
         T4 = G.cur_time;
 
-        p->lastpkt_recv_time = T4;
-        VERB6 bb_error_msg("%s->lastpkt_recv_time=%f", p->p_dotted, p->lastpkt_recv_time);
-
         /* The delay calculation is a special case. In cases where the
          * server and client clocks are running at different rates and
          * with very fast networks, the delay can appear negative. In
          * order to avoid violating the Principle of Least Astonishment,
          * the delay is clamped not less than the system precision.
          */
-        dv = p->lastpkt_delay;
-        p->lastpkt_delay = (T4 - T1) - (T3 - T2);
-        if (p->lastpkt_delay < G_precision_sec)
-                p->lastpkt_delay = G_precision_sec;
+        delay = (T4 - T1) - (T3 - T2);
+        if (delay < G_precision_sec)
+                delay = G_precision_sec;
         /*
          * If this packet's delay is much bigger than the last one,
          * it's better to just ignore it than use its much less precise value.
          */
-        if (p->reachable_bits && p->lastpkt_delay > dv * BAD_DELAY_GROWTH) {
-                bb_error_msg("reply from %s: delay %f is too high, ignoring", p->p_dotted, p->lastpkt_delay);
+        prev_delay = p->p_raw_delay;
+        p->p_raw_delay = delay;
+        if (p->reachable_bits && delay > prev_delay * BAD_DELAY_GROWTH) {
+                bb_error_msg("reply from %s: delay %f is too high, ignoring", p->p_dotted, delay);
                 goto pick_normal_interval;
         }
 
+        p->lastpkt_delay = delay;
+        p->lastpkt_recv_time = T4;
+        VERB6 bb_error_msg("%s->lastpkt_recv_time=%f", p->p_dotted, p->lastpkt_recv_time);
+        p->lastpkt_status = msg.m_status;
+        p->lastpkt_stratum = msg.m_stratum;
+        p->lastpkt_rootdelay = sfp_to_d(msg.m_rootdelay);
+        p->lastpkt_rootdisp = sfp_to_d(msg.m_rootdisp);
+        p->lastpkt_refid = msg.m_refid;
+
         p->datapoint_idx = p->reachable_bits ? (p->datapoint_idx + 1) % NUM_DATAPOINTS : 0;
         datapoint = &p->filter_datapoint[p->datapoint_idx];
         datapoint->d_recv_time = T4;
@@ -2087,14 +2099,34 @@ static NOINLINE void ntp_init(char **argv)
                         "d" /* compat */
                         "46aAbgL", /* compat, ignored */
                         &peers, &G.script_name, &G.verbose);
-        if (!(opts & (OPT_p|OPT_l)))
-                bb_show_usage();
+
 //      if (opts & OPT_x) /* disable stepping, only slew is allowed */
 //              G.time_was_stepped = 1;
         if (peers) {
                 while (peers)
                         add_peers(llist_pop(&peers));
-        } else {
+        }
+#if ENABLE_FEATURE_NTPD_CONF
+        else {
+                parser_t *parser;
+                char *token[3];
+
+                parser = config_open("/etc/ntp.conf");
+                while (config_read(parser, token, 3, 1, "# \t", PARSE_NORMAL)) {
+                        if (strcmp(token[0], "server") == 0 && token[1]) {
+                                add_peers(token[1]);
+                                continue;
+                        }
+                        bb_error_msg("skipping %s:%u: unimplemented command '%s'",
+                                "/etc/ntp.conf", parser->lineno, token[0]
+                        );
+                }
+                config_close(parser);
+        }
+#endif
+        if (G.peer_cnt == 0) {
+                if (!(opts & OPT_l))
+                        bb_show_usage();
                 /* -l but no peers: "stratum 1 server" mode */
                 G.stratum = 1;
         }
diff --git a/networking/wget.c b/networking/wget.c
index f13ca1c74..774accf7a 100644
--- a/networking/wget.c
+++ b/networking/wget.c
@@ -650,7 +650,7 @@ static void NOINLINE retrieve_file_data(FILE *dfp)
 #if ENABLE_FEATURE_WGET_TIMEOUT
                                 second_cnt = G.timeout_seconds;
 #endif
-                                continue;
+                                goto bump;
                         }
 
                         /* n <= 0.
@@ -683,11 +683,12 @@ static void NOINLINE retrieve_file_data(FILE *dfp)
                                  * to try reading anyway.
                                  */
                         }
+#endif
+ bump:
                         /* Need to do it _every_ second for "stalled" indicator
                          * to be shown properly.
                          */
                         progress_meter(PROGRESS_BUMP);
-#endif
                 } /* while (reading data) */
 
 #if ENABLE_FEATURE_WGET_STATUSBAR || ENABLE_FEATURE_WGET_TIMEOUT
diff --git a/scripts/Makefile.build b/scripts/Makefile.build
index 5685b5bcc..5eac45f91 100644
--- a/scripts/Makefile.build
+++ b/scripts/Makefile.build
@@ -255,8 +255,9 @@ $(sort $(subdir-obj-y)): $(subdir-ym) ;
 ifdef builtin-target
 quiet_cmd_link_o_target = LD      $@
 # If the list of objects to link is empty, just create an empty built-in.o
+# -nostdlib is added to make "make LD=gcc ..." work (some people use that)
 cmd_link_o_target = $(if $(strip $(obj-y)),\
-                $(LD) $(ld_flags) -r -o $@ $(filter $(obj-y), $^),\
+                $(LD) -nostdlib $(ld_flags) -r -o $@ $(filter $(obj-y), $^),\
                 rm -f $@; $(AR) rcs $@)
 
 $(builtin-target): $(obj-y) FORCE
diff --git a/scripts/gen_build_files.sh b/scripts/gen_build_files.sh
index e8fa831be..ebee17c64 100755
--- a/scripts/gen_build_files.sh
+++ b/scripts/gen_build_files.sh
@@ -71,7 +71,7 @@ sed -n -e 's@^//usage:\([ '"$TAB"'].*\)$@\1 \\@p' \
 
 # (Re)generate */Kbuild and */Config.in
 # We skip .dotdirs - makes git/svn/etc users happier
-{ cd -- "$srctree" && find . -type d -not '(' -name '.?*' -prune ')'; } \
+{ cd -- "$srctree" && find . -type d ! '(' -name '.?*' -prune ')'; } \
 | while read -r d; do
         d="${d#./}"
 
diff --git a/scripts/trylink b/scripts/trylink
index e47169917..5da494fbb 100755
--- a/scripts/trylink
+++ b/scripts/trylink
@@ -268,7 +268,7 @@ fi
 
 if test "$CONFIG_FEATURE_INDIVIDUAL" = y; then
     echo "Linking individual applets against libbusybox (see $sharedlib_dir/*)"
-    gcc -DNAME_MAIN_CNAME -E -include include/autoconf.h include/applets.h \
+    gcc -DNAME_MAIN -E -include include/autoconf.h include/applets.h \
     | grep -v "^#" \
     | grep -v "^$" \
     > applet_lst.tmp
@@ -300,6 +300,8 @@ int main(int argc, char **argv)
         }
         rm -- "$sharedlib_dir/applet.c" $EXE.out
         $STRIP -s --remove-section=.note --remove-section=.comment $EXE
+        # Let user see that we do something - list the names of created binaries:
+        echo "$EXE"
 
     done <applet_lst.tmp
 fi
diff --git a/shell/ash.c b/shell/ash.c
index 19565d185..ce6e355eb 100644
--- a/shell/ash.c
+++ b/shell/ash.c
@@ -55,6 +55,7 @@
 #include <setjmp.h>
 #include <fnmatch.h>
 #include <sys/times.h>
+#include <sys/utsname.h> /* for setting $HOSTNAME */
 
 #include "busybox.h" /* for applet_names */
 #include "unicode.h"
@@ -9353,6 +9354,9 @@ mklocal(char *name)
                         vp->flags |= VSTRFIXED|VTEXTFIXED;
                         if (eq)
                                 setvareq(name, 0);
+                        else
+                                /* "local VAR" unsets VAR: */
+                                setvar(name, NULL, 0);
                 }
         }
         lvp->vp = vp;
@@ -12899,7 +12903,7 @@ find_command(char *name, struct cmdentry *entry, int act, const char *path)
                                                         e = errno;
                                                 goto loop;
                                         }
-                                        if (!execable_file(fullname)) {
+                                        if (!file_is_executable(fullname)) {
                                                 e = ENOEXEC;
                                                 goto loop;
                                         }
@@ -13522,6 +13526,11 @@ init(void)
 #if ENABLE_ASH_BASH_COMPAT
                 p = lookupvar("SHLVL");
                 setvar("SHLVL", utoa((p ? atoi(p) : 0) + 1), VEXPORT);
+                if (!lookupvar("HOSTNAME")) {
+                        struct utsname uts;
+                        uname(&uts);
+                        setvar2("HOSTNAME", uts.nodename);
+                }
 #endif
                 p = lookupvar("PWD");
                 if (p) {
diff --git a/shell/ash_test/ash-misc/local1.right b/shell/ash_test/ash-misc/local1.right
new file mode 100644
index 000000000..a2d121df6
--- /dev/null
+++ b/shell/ash_test/ash-misc/local1.right
@@ -0,0 +1,4 @@
+A1:'A'
+A2:''
+A3:''
+A4:'A'
diff --git a/shell/ash_test/ash-misc/local1.tests b/shell/ash_test/ash-misc/local1.tests
new file mode 100755
index 000000000..b1e675059
--- /dev/null
+++ b/shell/ash_test/ash-misc/local1.tests
@@ -0,0 +1,11 @@
+a=A
+f() {
+        local a
+        # the above line unsets $a
+        echo "A2:'$a'"
+        unset a
+        echo "A3:'$a'"
+}
+echo "A1:'$a'"
+f
+echo "A4:'$a'"
diff --git a/shell/hush.c b/shell/hush.c
index 927193450..e1d0ece29 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -91,6 +91,7 @@
 #if ENABLE_HUSH_CASE
 # include <fnmatch.h>
 #endif
+#include <sys/utsname.h> /* for setting $HOSTNAME */
 
 #include "busybox.h"  /* for APPLET_IS_NOFORK/NOEXEC */
 #include "unicode.h"
@@ -944,6 +945,7 @@ static const struct built_in_command bltins1[] = {
         BLTIN("source"   , builtin_source  , "Run commands in a file"),
 #endif
         BLTIN("trap"     , builtin_trap    , "Trap signals"),
+        BLTIN("true"     , builtin_true    , NULL),
         BLTIN("type"     , builtin_type    , "Show command type"),
         BLTIN("ulimit"   , shell_builtin_ulimit  , "Control resource limits"),
         BLTIN("umask"    , builtin_umask   , "Set file creation mask"),
@@ -7785,6 +7787,14 @@ int hush_main(int argc, char **argv)
 
         /* Export PWD */
         set_pwd_var(/*exp:*/ 1);
+
+#if ENABLE_HUSH_BASH_COMPAT
+        /* Set (but not export) HOSTNAME unless already set */
+        if (!get_local_var_value("HOSTNAME")) {
+                struct utsname uts;
+                uname(&uts);
+                set_local_var_from_halves("HOSTNAME", uts.nodename);
+        }
         /* bash also exports SHLVL and _,
          * and sets (but doesn't export) the following variables:
          * BASH=/bin/bash
@@ -7793,7 +7803,6 @@ int hush_main(int argc, char **argv)
          * HOSTTYPE=i386
          * MACHTYPE=i386-pc-linux-gnu
          * OSTYPE=linux-gnu
-         * HOSTNAME=<xxxxxxxxxx>
          * PPID=<NNNNN> - we also do it elsewhere
          * EUID=<NNNNN>
          * UID=<NNNNN>
@@ -7821,6 +7830,7 @@ int hush_main(int argc, char **argv)
          * PS2='> '
          * PS4='+ '
          */
+#endif
 
 #if ENABLE_FEATURE_EDITING
         G.line_input_state = new_line_input_t(FOR_SHELL);
diff --git a/shell/random.c b/shell/random.c
index 853ab085a..5d3620516 100644
--- a/shell/random.c
+++ b/shell/random.c
@@ -6,17 +6,51 @@
  *
  * Licensed under GPLv2, see file LICENSE in this source tree.
  */
-#include "libbb.h"
-#include "random.h"
+
+/* For testing against dieharder, you need only random.{c,h}
+ * Howto:
+ * gcc -O2 -Wall -DRANDTEST random.c -o random
+ * ./random | dieharder -g 200 -a
+ */
+
+#if !defined RANDTEST
+
+# include "libbb.h"
+# include "random.h"
+# define RAND_BASH_MASK 0x7fff
+
+#else
+# include <stdint.h>
+# include <unistd.h>
+# include <stdio.h>
+# include <time.h>
+# define FAST_FUNC /* nothing */
+# define PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN /* nothing */
+# define POP_SAVED_FUNCTION_VISIBILITY /* nothing */
+# define monotonic_us() time(NULL)
+# include "random.h"
+# define RAND_BASH_MASK 0xffffffff /* off */
+#endif
 
 uint32_t FAST_FUNC
 next_random(random_t *rnd)
 {
-        /* Galois LFSR parameter */
-        /* Taps at 32 31 29 1: */
+        /* Galois LFSR parameter:
+         * Taps at 32 31 29 1:
+         */
         enum { MASK = 0x8000000b };
         /* Another example - taps at 32 31 30 10: */
-        /* MASK = 0x00400007 */
+        /* enum { MASK = 0x00400007 }; */
+
+        /* Xorshift parameters:
+         * Choices for a,b,c: 10,13,10; 8,9,22; 2,7,3; 23,3,24
+         * (given by algorithm author)
+         */
+        enum {
+                a = 2,
+                b = 7,
+                c = 3,
+        };
 
         uint32_t t;
 
@@ -27,18 +61,100 @@ next_random(random_t *rnd)
                 INIT_RANDOM_T(rnd, getpid(), monotonic_us());
         }
 
-        /* LCG has period of 2^32 and alternating lowest bit */
+        /* LCG: period of 2^32, but quite weak:
+         * bit 0 alternates beetween 0 and 1 (pattern of length 2)
+         * bit 1 has a repeating pattern of length 4
+         * bit 2 has a repeating pattern of length 8
+         * etc...
+         */
         rnd->LCG = 1664525 * rnd->LCG + 1013904223;
-        /* Galois LFSR has period of 2^32-1 = 3 * 5 * 17 * 257 * 65537 */
+
+        /* Galois LFSR:
+         * period of 2^32-1 = 3 * 5 * 17 * 257 * 65537.
+         * Successive values are right-shifted one bit
+         * and possibly xored with a sparse constant.
+         */
         t = (rnd->galois_LFSR << 1);
         if (rnd->galois_LFSR < 0) /* if we just shifted 1 out of msb... */
                 t ^= MASK;
         rnd->galois_LFSR = t;
-        /* Both are weak, combining them gives better randomness
-         * and ~2^64 period. & 0x7fff is probably bash compat
-         * for $RANDOM range. Combining with subtraction is
-         * just for fun. + and ^ would work equally well. */
-        t = (t - rnd->LCG) & 0x7fff;
 
-        return t;
+        /* http://en.wikipedia.org/wiki/Xorshift
+         * Moderately good statistical properties:
+         * fails the following "dieharder -g 200 -a" tests:
+         *       diehard_operm5|   0
+         *         diehard_oqso|   0
+         * diehard_count_1s_byt|   0
+         *     diehard_3dsphere|   3
+         *      diehard_squeeze|   0
+         *         diehard_runs|   0
+         *         diehard_runs|   0
+         *        diehard_craps|   0
+         *        diehard_craps|   0
+         * rgb_minimum_distance|   3
+         * rgb_minimum_distance|   4
+         * rgb_minimum_distance|   5
+         *     rgb_permutations|   3
+         *     rgb_permutations|   4
+         *     rgb_permutations|   5
+         *         dab_filltree|  32
+         *         dab_filltree|  32
+         *         dab_monobit2|  12
+         */
+ again:
+        t = rnd->xs64_x ^ (rnd->xs64_x << a);
+        rnd->xs64_x = rnd->xs64_y;
+        rnd->xs64_y = rnd->xs64_y ^ (rnd->xs64_y >> c) ^ t ^ (t >> b);
+        /*
+         * Period 2^64-1 = 2^32+1 * 2^32-1 has a common divisor with Galois LFSR.
+         * By skipping two possible states (0x1 and 0x2) we reduce period to
+         * 2^64-3 = 13 * 3889 * 364870227143809 which has no common divisors:
+         */
+        if (rnd->xs64_y == 0 && rnd->xs64_x <= 2)
+                goto again;
+
+        /* Combined LCG + Galois LFSR rng has 2^32 * 2^32-1 period.
+         * Strength:
+         * individually, both are extremely weak cryptographycally;
+         * when combined, they fail the following "dieharder -g 200 -a" tests:
+         *     diehard_rank_6x8|   0
+         *         diehard_oqso|   0
+         *          diehard_dna|   0
+         * diehard_count_1s_byt|   0
+         *          rgb_bitdist|   2
+         *         dab_monobit2|  12
+         *
+         * Combining them with xorshift-64 increases period to
+         * 2^32 * 2^32-1 * 2^64-3
+         * which is about 2^128, or in base 10 ~3.40*10^38.
+         * Strength of the combination:
+         * passes all "dieharder -g 200 -a" tests.
+         *
+         * Combining with subtraction and addition is just for fun.
+         * It does not add meaningful strength, could use xor operation instead.
+         */
+        t = rnd->galois_LFSR - rnd->LCG + rnd->xs64_y;
+
+        /* bash compat $RANDOM range: */
+        return t & RAND_BASH_MASK;
 }
+
+#ifdef RANDTEST
+static random_t rnd;
+
+int main(int argc, char **argv)
+{
+        int i;
+        uint32_t buf[4096];
+
+        for (;;) {
+                for (i = 0; i < sizeof(buf) / sizeof(buf[0]); i++) {
+                        buf[i] = next_random(&rnd);
+                }
+                write(1, buf, sizeof(buf));
+        }
+
+        return 0;
+}
+
+#endif
diff --git a/shell/random.h b/shell/random.h
index 180c48abb..c4eb44c13 100644
--- a/shell/random.h
+++ b/shell/random.h
@@ -12,16 +12,24 @@
 PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
 
 typedef struct random_t {
-        /* Random number generators */
-        int32_t galois_LFSR; /* Galois LFSR (fast but weak). signed! */
-        uint32_t LCG;        /* LCG (fast but weak) */
+        /* State of random number generators: */
+
+        /* Galois LFSR (fast but weak) */
+        int32_t galois_LFSR; /* must be signed! */
+
+        /* LCG (fast but weak) */
+        uint32_t LCG;
+
+        /* 64-bit xorshift (fast, moderate strength) */
+        uint32_t xs64_x;
+        uint32_t xs64_y;
 } random_t;
 
 #define UNINITED_RANDOM_T(rnd) \
         ((rnd)->galois_LFSR == 0)
 
 #define INIT_RANDOM_T(rnd, nonzero, v) \
-        ((rnd)->galois_LFSR = (nonzero), (rnd)->LCG = (v))
+        ((rnd)->galois_LFSR = (rnd)->xs64_x = (nonzero), (rnd)->LCG = (rnd)->xs64_y = (v))
 
 #define CLEAR_RANDOM_T(rnd) \
         ((rnd)->galois_LFSR = 0)
diff --git a/util-linux/Config.src b/util-linux/Config.src
index 5a8b0063b..c1cd6daa4 100644
--- a/util-linux/Config.src
+++ b/util-linux/Config.src
@@ -599,6 +599,15 @@ config SWAPONOFF
           space. If you are not using any swap space, you can leave this
           option disabled.
 
+config FEATURE_SWAPON_DISCARD
+        bool "Support discard option -d"
+        default y
+        depends on SWAPONOFF
+        help
+          Enable support for discarding swap area blocks at swapon and/or as
+          the kernel frees them. This option enables both the -d option on
+          'swapon' and the 'discard' option for swap entries in /etc/fstab.
+
 config FEATURE_SWAPON_PRI
         bool "Support priority option -p"
         default y
diff --git a/util-linux/rtcwake.c b/util-linux/rtcwake.c
index 735a29822..33cdbfad4 100644
--- a/util-linux/rtcwake.c
+++ b/util-linux/rtcwake.c
@@ -51,7 +51,6 @@
 
 #define SYS_RTC_PATH   "/sys/class/rtc/%s/device/power/wakeup"
 #define SYS_POWER_PATH "/sys/power/state"
-#define DEFAULT_MODE   "standby"
 
 static NOINLINE bool may_wakeup(const char *rtcname)
 {
@@ -122,17 +121,16 @@ static NOINLINE void setup_alarm(int fd, time_t *wakeup, time_t rtc_time)
 int rtcwake_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int rtcwake_main(int argc UNUSED_PARAM, char **argv)
 {
-        time_t rtc_time;
-
         unsigned opt;
         const char *rtcname = NULL;
-        const char *suspend;
+        const char *suspend = "standby";
         const char *opt_seconds;
         const char *opt_time;
 
+        time_t rtc_time;
         time_t sys_time;
-        time_t alarm_time = 0;
-        unsigned seconds = 0;
+        time_t alarm_time = alarm_time;
+        unsigned seconds = seconds; /* for compiler */
         int utc = -1;
         int fd;
 
@@ -148,6 +146,8 @@ int rtcwake_main(int argc UNUSED_PARAM, char **argv)
                 ;
         applet_long_options = rtcwake_longopts;
 #endif
+        /* Must have -s or -t, exclusive */
+        opt_complementary = "s:t:s--t:t--s";
         opt = getopt32(argv, "alud:m:s:t:", &rtcname, &suspend, &opt_seconds, &opt_time);
 
         /* this is the default
@@ -156,17 +156,17 @@ int rtcwake_main(int argc UNUSED_PARAM, char **argv)
         */
         if (opt & (RTCWAKE_OPT_UTC | RTCWAKE_OPT_LOCAL))
                 utc = opt & RTCWAKE_OPT_UTC;
-        if (!(opt & RTCWAKE_OPT_SUSPEND_MODE))
-                suspend = DEFAULT_MODE;
-        if (opt & RTCWAKE_OPT_SECONDS)
+        if (opt & RTCWAKE_OPT_SECONDS) {
                 /* alarm time, seconds-to-sleep (relative) */
-                seconds = xatoi(opt_seconds);
-        if (opt & RTCWAKE_OPT_TIME)
+                seconds = xatou(opt_seconds);
+        } else {
+                /* RTCWAKE_OPT_TIME */
                 /* alarm time, time_t (absolute, seconds since 1/1 1970 UTC) */
-                alarm_time = xatol(opt_time);
-
-        if (!alarm_time && !seconds)
-                bb_error_msg_and_die("must provide wake time");
+                if (sizeof(alarm_time) <= sizeof(long))
+                        alarm_time = xatol(opt_time);
+                else
+                        alarm_time = xatoll(opt_time);
+        }
 
         if (utc == -1)
                 utc = rtc_adjtime_is_utc();
@@ -177,8 +177,9 @@ int rtcwake_main(int argc UNUSED_PARAM, char **argv)
         /* this RTC must exist and (if we'll sleep) be wakeup-enabled */
         fd = rtc_xopen(&rtcname, O_RDONLY);
 
-        if (strcmp(suspend, "on") && !may_wakeup(rtcname))
-                bb_error_msg_and_die("%s not enabled for wakeup events", rtcname);
+        if (strcmp(suspend, "on") != 0)
+                if (!may_wakeup(rtcname))
+                        bb_error_msg_and_die("%s not enabled for wakeup events", rtcname);
 
         /* relative or absolute alarm time, normalized to time_t */
         sys_time = time(NULL);
@@ -188,21 +189,29 @@ int rtcwake_main(int argc UNUSED_PARAM, char **argv)
                 rtc_time = rtc_tm2time(&tm_time, utc);
         }
 
-
-        if (alarm_time) {
-                if (alarm_time < sys_time)
+        if (opt & RTCWAKE_OPT_TIME) {
+                /* Correct for RTC<->system clock difference */
+                alarm_time += rtc_time - sys_time;
+                if (alarm_time < rtc_time)
+                        /*
+                         * Compat message text.
+                         * I'd say "RTC time is already ahead of ..." instead.
+                         */
                         bb_error_msg_and_die("time doesn't go backward to %s", ctime(&alarm_time));
-                alarm_time += sys_time - rtc_time;
         } else
                 alarm_time = rtc_time + seconds + 1;
-        setup_alarm(fd, &alarm_time, rtc_time);
 
+        setup_alarm(fd, &alarm_time, rtc_time);
         sync();
+#if 0 /*debug*/
+        printf("sys_time: %s", ctime(&sys_time));
+        printf("rtc_time: %s", ctime(&rtc_time));
+#endif
         printf("wakeup from \"%s\" at %s", suspend, ctime(&alarm_time));
         fflush_all();
         usleep(10 * 1000);
 
-        if (strcmp(suspend, "on"))
+        if (strcmp(suspend, "on") != 0)
                 xopen_xwrite_close(SYS_POWER_PATH, suspend);
         else {
                 /* "fake" suspend ... we'll do the delay ourselves */
diff --git a/util-linux/script.c b/util-linux/script.c
index 8fb991d15..abcd73bff 100644
--- a/util-linux/script.c
+++ b/util-linux/script.c
@@ -77,8 +77,15 @@ int script_main(int argc UNUSED_PARAM, char **argv)
         if (!(opt & OPT_q)) {
                 printf("Script started, file is %s\n", fname);
         }
+
         shell = get_shell_name();
 
+        /* Some people run "script ... 0>&-".
+         * Our code assumes that STDIN_FILENO != pty.
+         * Ensure STDIN_FILENO is not closed:
+         */
+        bb_sanitize_stdio();
+
         pty = xgetpty(pty_line);
 
         /* get current stdin's tty params */
diff --git a/util-linux/swaponoff.c b/util-linux/swaponoff.c
index 3f223343e..75487267b 100644
--- a/util-linux/swaponoff.c
+++ b/util-linux/swaponoff.c
@@ -8,10 +8,14 @@
  */
 
 //usage:#define swapon_trivial_usage
-//usage:       "[-a]" IF_FEATURE_SWAPON_PRI(" [-p PRI]") " [DEVICE]"
+//usage:       "[-a]" IF_FEATURE_SWAPON_DISCARD(" [-d[POL]]") IF_FEATURE_SWAPON_PRI(" [-p PRI]") " [DEVICE]"
 //usage:#define swapon_full_usage "\n\n"
 //usage:       "Start swapping on DEVICE\n"
 //usage:     "\n        -a      Start swapping on all swap devices"
+//usage:        IF_FEATURE_SWAPON_DISCARD(
+//usage:     "\n        -d[POL] Discard blocks at swapon (POL=once),"
+//usage:     "\n                as freed (POL=pages), or both (POL omitted)"
+//usage:        )
 //usage:        IF_FEATURE_SWAPON_PRI(
 //usage:     "\n        -p PRI  Set swap device priority"
 //usage:        )
@@ -38,78 +42,162 @@
 # define MNTTYPE_SWAP "swap"
 #endif
 
-#if ENABLE_FEATURE_SWAPON_PRI
+#if ENABLE_FEATURE_SWAPON_DISCARD
+#ifndef SWAP_FLAG_DISCARD
+#define SWAP_FLAG_DISCARD 0x10000
+#endif
+#ifndef SWAP_FLAG_DISCARD_ONCE
+#define SWAP_FLAG_DISCARD_ONCE 0x20000
+#endif
+#ifndef SWAP_FLAG_DISCARD_PAGES
+#define SWAP_FLAG_DISCARD_PAGES 0x40000
+#endif
+#define SWAP_FLAG_DISCARD_MASK \
+        (SWAP_FLAG_DISCARD | SWAP_FLAG_DISCARD_ONCE | SWAP_FLAG_DISCARD_PAGES)
+#endif
+
+
+#if ENABLE_FEATURE_SWAPON_DISCARD || ENABLE_FEATURE_SWAPON_PRI
 struct globals {
         int flags;
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
 #define g_flags (G.flags)
+#define save_g_flags()    int save_g_flags = g_flags
+#define restore_g_flags() g_flags = save_g_flags
 #else
 #define g_flags 0
+#define save_g_flags()    ((void)0)
+#define restore_g_flags() ((void)0)
 #endif
 #define INIT_G() do { } while (0)
 
+#define do_swapoff   (applet_name[5] == 'f')
+
+/* Command line options */
+enum {
+        OPTBIT_a,                              /* -a all      */
+        IF_FEATURE_SWAPON_DISCARD( OPTBIT_d ,) /* -d discard  */
+        IF_FEATURE_SWAPON_PRI    ( OPTBIT_p ,) /* -p priority */
+        OPT_a = 1 << OPTBIT_a,
+        OPT_d = IF_FEATURE_SWAPON_DISCARD((1 << OPTBIT_d)) + 0,
+        OPT_p = IF_FEATURE_SWAPON_PRI    ((1 << OPTBIT_p)) + 0,
+};
+
+#define OPT_ALL      (option_mask32 & OPT_a)
+#define OPT_DISCARD  (option_mask32 & OPT_d)
+#define OPT_PRIO     (option_mask32 & OPT_p)
+
 static int swap_enable_disable(char *device)
 {
-        int status;
+        int err = 0;
+        int quiet = 0;
         struct stat st;
 
         resolve_mount_spec(&device);
-        xstat(device, &st);
 
-#if ENABLE_DESKTOP
-        /* test for holes */
-        if (S_ISREG(st.st_mode))
-                if (st.st_blocks * (off_t)512 < st.st_size)
-                        bb_error_msg("warning: swap file has holes");
-#endif
-
-        if (applet_name[5] == 'n')
-                status = swapon(device, g_flags);
-        else
-                status = swapoff(device);
+        if (do_swapoff) {
+                err = swapoff(device);
+                /* Don't complain on OPT_ALL if not a swap device or if it doesn't exist */
+                quiet = (OPT_ALL && (errno == EINVAL || errno == ENOENT));
+        } else {
+                /* swapon */
+                err = stat(device, &st);
+                if (!err) {
+                        if (ENABLE_DESKTOP && S_ISREG(st.st_mode)) {
+                                if (st.st_blocks * (off_t)512 < st.st_size) {
+                                        bb_error_msg("%s: file has holes", device);
+                                        return 1;
+                                }
+                        }
+                        err = swapon(device, g_flags);
+                        /* Don't complain on swapon -a if device is already in use */
+                        quiet = (OPT_ALL && errno == EBUSY);
+                }
+        }
 
-        if (status != 0) {
+        if (err && !quiet) {
                 bb_simple_perror_msg(device);
                 return 1;
         }
-
         return 0;
 }
 
-static int do_em_all(void)
+#if ENABLE_FEATURE_SWAPON_DISCARD
+static void set_discard_flag(char *s)
 {
-        struct mntent *m;
-        FILE *f;
-        int err;
+        /* Unset the flag first to allow fstab options to override */
+        /* options set on the command line */
+        g_flags = (g_flags & ~SWAP_FLAG_DISCARD_MASK) | SWAP_FLAG_DISCARD;
+
+        if (!s) /* No optional policy value on the commandline */
+                return;
+        /* Skip prepended '=' */
+        if (*s == '=')
+                s++;
+        /* For fstab parsing: remove other appended options */
+        *strchrnul(s, ',') = '\0';
+
+        if (strcmp(s, "once") == 0)
+                g_flags |= SWAP_FLAG_DISCARD_ONCE;
+        if  (strcmp(s, "pages") == 0)
+                g_flags |= SWAP_FLAG_DISCARD_PAGES;
+}
+#else
+#define set_discard_flag(s) ((void)0)
+#endif
 
-        f = setmntent("/etc/fstab", "r");
-        if (f == NULL)
-                bb_perror_msg_and_die("/etc/fstab");
+#if ENABLE_FEATURE_SWAPON_PRI
+static void set_priority_flag(char *s)
+{
+        unsigned prio;
+
+        /* For fstab parsing: remove other appended options */
+        *strchrnul(s, ',') = '\0';
+        /* Max allowed 32767 (== SWAP_FLAG_PRIO_MASK) */
+        prio = bb_strtou(s, NULL, 10);
+        if (!errno) {
+                /* Unset the flag first to allow fstab options to override */
+                /* options set on the command line */
+                g_flags = (g_flags & ~SWAP_FLAG_PRIO_MASK) | SWAP_FLAG_PREFER |
+                                        MIN(prio, SWAP_FLAG_PRIO_MASK);
+        }
+}
+#else
+#define set_priority_flag(s) ((void)0)
+#endif
+
+static int do_em_all_in_fstab(void)
+{
+        struct mntent *m;
+        int err = 0;
+        FILE *f = xfopen_for_read("/etc/fstab");
 
-        err = 0;
         while ((m = getmntent(f)) != NULL) {
                 if (strcmp(m->mnt_type, MNTTYPE_SWAP) == 0) {
                         /* swapon -a should ignore entries with noauto,
-                         * but swapoff -a should process them */
-                        if (applet_name[5] != 'n'
-                         || hasmntopt(m, MNTOPT_NOAUTO) == NULL
-                        ) {
-#if ENABLE_FEATURE_SWAPON_PRI
-                                char *p;
-                                g_flags = 0; /* each swap space might have different flags */
-                                p = hasmntopt(m, "pri");
-                                if (p) {
-                                        /* Max allowed 32767 (==SWAP_FLAG_PRIO_MASK) */
-                                        unsigned int swap_prio = MIN(bb_strtou(p + 4 , NULL, 10), SWAP_FLAG_PRIO_MASK);
-                                        /* We want to allow "NNNN,foo", thus errno == EINVAL is allowed too */
-                                        if (errno != ERANGE) {
-                                                g_flags = SWAP_FLAG_PREFER |
-                                                        (swap_prio << SWAP_FLAG_PRIO_SHIFT);
+                         * but swapoff -a should process them
+                         */
+                        if (do_swapoff || hasmntopt(m, MNTOPT_NOAUTO) == NULL) {
+                                /* each swap space might have different flags */
+                                /* save global flags for the next round */
+                                save_g_flags();
+                                if (ENABLE_FEATURE_SWAPON_DISCARD) {
+                                        char *p = hasmntopt(m, "discard");
+                                        if (p) {
+                                                /* move to '=' or to end of string */
+                                                p += 7;
+                                                set_discard_flag(p);
                                         }
                                 }
-#endif
-                                err += swap_enable_disable(m->mnt_fsname);
+                                if (ENABLE_FEATURE_SWAPON_PRI) {
+                                        char *p = hasmntopt(m, "pri");
+                                        if (p) {
+                                                set_priority_flag(p + 4);
+                                        }
+                                }
+                                err |= swap_enable_disable(m->mnt_fsname);
+                                restore_g_flags();
                         }
                 }
         }
@@ -120,38 +208,68 @@ static int do_em_all(void)
         return err;
 }
 
+static int do_all_in_proc_swaps(void)
+{
+        char *line;
+        int err = 0;
+        FILE *f = fopen_for_read("/proc/swaps");
+        /* Don't complain if missing */
+        if (f) {
+                while ((line = xmalloc_fgetline(f)) != NULL) {
+                        if (line[0] == '/') {
+                                *strchrnul(line, ' ') = '\0';
+                                err |= swap_enable_disable(line);
+                        }
+                        free(line);
+                }
+                if (ENABLE_FEATURE_CLEAN_UP)
+                        fclose(f);
+        }
+
+        return err;
+}
+
+#define OPTSTR_SWAPON "a" \
+        IF_FEATURE_SWAPON_DISCARD("d::") \
+        IF_FEATURE_SWAPON_PRI("p:")
+
 int swap_on_off_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int swap_on_off_main(int argc UNUSED_PARAM, char **argv)
 {
-        int ret;
+        IF_FEATURE_SWAPON_PRI(char *prio;)
+        IF_FEATURE_SWAPON_DISCARD(char *discard = NULL;)
+        int ret = 0;
 
         INIT_G();
 
-#if !ENABLE_FEATURE_SWAPON_PRI
-        ret = getopt32(argv, "a");
-#else
-        if (applet_name[5] == 'n')
-                opt_complementary = "p+";
-        ret = getopt32(argv, (applet_name[5] == 'n') ? "ap:" : "a", &g_flags);
-
-        if (ret & 2) { // -p
-                g_flags = SWAP_FLAG_PREFER |
-                        ((g_flags & SWAP_FLAG_PRIO_MASK) << SWAP_FLAG_PRIO_SHIFT);
-                ret &= 1;
-        }
-#endif
-
-        if (ret /* & 1: not needed */) // -a
-                return do_em_all();
+        getopt32(argv, do_swapoff ? "a" : OPTSTR_SWAPON
+                        IF_FEATURE_SWAPON_DISCARD(, &discard)
+                        IF_FEATURE_SWAPON_PRI(, &prio)
+        );
 
         argv += optind;
-        if (!*argv)
-                bb_show_usage();
 
-        /* ret = 0; redundant */
-        do {
-                ret += swap_enable_disable(*argv);
-        } while (*++argv);
+        if (OPT_DISCARD) {
+                set_discard_flag(discard);
+        }
+        if (OPT_PRIO) {
+                set_priority_flag(prio);
+        }
 
+        if (OPT_ALL) {
+                /* swapoff -a does also /proc/swaps */
+                if (do_swapoff)
+                        ret = do_all_in_proc_swaps();
+                ret |= do_em_all_in_fstab();
+        } else if (!*argv) {
+                /* if not -a we need at least one arg */
+                bb_show_usage();
+        }
+        /* Unset -a now to allow for more messages in swap_enable_disable */
+        option_mask32 = option_mask32 & ~OPT_a;
+        /* Now process devices on the commandline if any */
+        while (*argv) {
+                ret |= swap_enable_disable(*argv++);
+        }
         return ret;
 }
diff --git a/win32/mingw.c b/win32/mingw.c
index 501c886e0..044d5c50f 100644
--- a/win32/mingw.c
+++ b/win32/mingw.c
@@ -943,11 +943,11 @@ char *win32_execable_file(const char *p)
         if ( (path=malloc(len+5)) != NULL ) {
                 memcpy(path, p, len);
                 memcpy(path+len, ".exe", 5);
-                if (execable_file(path)) {
+                if (file_is_executable(path)) {
                         return path;
                 }
                 memcpy(path+len, ".com", 5);
-                if (execable_file(path)) {
+                if (file_is_executable(path)) {
                         return path;
                 }
                 free(path);
diff --git a/win32/process.c b/win32/process.c
index e2e81c793..462731a2d 100644
--- a/win32/process.c
+++ b/win32/process.c
@@ -238,7 +238,7 @@ mingw_spawn_interpreter(int mode, const char *prog, const char *const *argv, con
         else {
                 char *path = xstrdup(getenv("PATH"));
                 char *tmp = path;
-                char *iprog = find_execable(interpr, &tmp);
+                char *iprog = find_executable(interpr, &tmp);
                 free(path);
                 if (!iprog) {
                         free(new_argv);
@@ -273,9 +273,9 @@ mingw_spawn_1(int mode, const char *cmd, const char *const *argv, const char *co
                         return -1;
                 }
 
-                /* exists_execable() does not return new file name */
+                /* executable_exists() does not return new file name */
                 tmp = path = xstrdup(path);
-                prog = find_execable(cmd, &tmp);
+                prog = find_executable(cmd, &tmp);
                 free(path);
                 if (!prog) {
                         errno = ENOENT;