Merge branch 'busybox' into merge

20 files changed, 625 insertions, 37 deletions

diff --git a/Makefile b/Makefile
index 783f55f87..a65cd61a4 100644
--- a/Makefile
+++ b/Makefile
@@ -1315,14 +1315,6 @@ quiet_cmd_rmdirs = $(if $(wildcard $(rm-dirs)),CLEAN   $(wildcard $(rm-dirs)))
 quiet_cmd_rmfiles = $(if $(wildcard $(rm-files)),CLEAN   $(wildcard $(rm-files)))
       cmd_rmfiles = rm -f $(rm-files)
 
-
-a_flags = -Wp,-MD,$(depfile) $(AFLAGS) $(AFLAGS_KERNEL) \
-          $(NOSTDINC_FLAGS) $(CPPFLAGS) \
-          $(modkern_aflags) $(EXTRA_AFLAGS) $(AFLAGS_$(*F).o)
-
-quiet_cmd_as_o_S = AS      $@
-cmd_as_o_S       = $(CC) $(a_flags) -c -o $@ $<
-
 # read all saved command lines
 
 targets := $(wildcard $(sort $(targets)))
diff --git a/Makefile.flags b/Makefile.flags
index f202a5f54..bf77c2492 100644
--- a/Makefile.flags
+++ b/Makefile.flags
@@ -88,14 +88,14 @@ endif
 #CFLAGS += $(call cc-option,-Wconversion,)
 
 ifneq ($(CONFIG_DEBUG),y)
-CFLAGS += $(call cc-option,-Os,$(call cc-option,-O2,))
+CFLAGS += $(call cc-option,-Oz,$(call cc-option,-Os,$(call cc-option,-O2,)))
 else
 CFLAGS += $(call cc-option,-g,)
 #CFLAGS += "-D_FORTIFY_SOURCE=2"
 ifeq ($(CONFIG_DEBUG_PESSIMIZE),y)
 CFLAGS += $(call cc-option,-O0,)
 else
-CFLAGS += $(call cc-option,-Os,$(call cc-option,-O2,))
+CFLAGS += $(call cc-option,-Oz,$(call cc-option,-Os,$(call cc-option,-O2,)))
 endif
 endif
 ifeq ($(CONFIG_DEBUG_SANITIZE),y)
diff --git a/coreutils/tsort.c b/coreutils/tsort.c
new file mode 100644
index 000000000..dedb65b15
--- /dev/null
+++ b/coreutils/tsort.c
@@ -0,0 +1,188 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * tsort implementation for busybox
+ *
+ * public domain -- David Leonard, 2022
+ */
+//config:config TSORT
+//config:       bool "tsort (0.7 kb)"
+//config:       default y
+//config:       help
+//config:       tsort performs a topological sort.
+
+//applet:IF_TSORT(APPLET(tsort, BB_DIR_USR_BIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_TSORT) += tsort.o
+
+/* BB_AUDIT SUSv3 compliant */
+/* http://www.opengroup.org/onlinepubs/007904975/utilities/tsort.html */
+
+//usage:#define tsort_trivial_usage
+//usage:       "[FILE]"
+//usage:#define tsort_full_usage "\n\n"
+//usage:       "Topological sort"
+//usage:#define tsort_example_usage
+//usage:       "$ echo -e \"a b\\nb c\" | tsort\n"
+//usage:       "a\n"
+//usage:       "b\n"
+//usage:       "c\n"
+
+#include "libbb.h"
+#include "common_bufsiz.h"
+
+struct node {
+        unsigned in_count;
+        unsigned out_count;
+        struct node **out;
+        char name[1];
+};
+
+struct globals {
+        struct node **nodes;
+        unsigned nodes_len;
+};
+#define G (*(struct globals*)bb_common_bufsiz1)
+#define INIT_G() do { \
+        setup_common_bufsiz(); \
+        BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
+        G.nodes = NULL; \
+        G.nodes_len = 0; \
+} while (0)
+
+static struct node *
+get_node(const char *name)
+{
+        struct node *n;
+        unsigned a = 0;
+        unsigned b = G.nodes_len;
+
+        /* Binary search for name */
+        while (a != b) {
+                unsigned m = (a + b) / 2;
+                int cmp = strcmp(name, G.nodes[m]->name);
+                if (cmp == 0)
+                        return G.nodes[m]; /* found */
+                if (cmp < 0) {
+                        b = m;
+                } else {
+                        a = m + 1;
+                }
+        }
+
+        /* Allocate new node */
+        n = xzalloc(sizeof(*n) + strlen(name));
+        //n->in_count = 0;
+        //n->out_count = 0;
+        //n->out = NULL;
+        strcpy(n->name, name);
+
+        /* Insert to maintain sort */
+        G.nodes = xrealloc(G.nodes, (G.nodes_len + 1) * sizeof(*G.nodes));
+        memmove(&G.nodes[a + 1], &G.nodes[a],
+                (G.nodes_len - a) * sizeof(*G.nodes));
+        G.nodes[a] = n;
+        G.nodes_len++;
+        return n;
+}
+
+static void
+add_edge(struct node *a, struct node *b)
+{
+        a->out = xrealloc_vector(a->out, 6, a->out_count);
+        a->out[a->out_count++] = b;
+        b->in_count++;
+}
+
+int tsort_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int tsort_main(int argc UNUSED_PARAM, char **argv)
+{
+        char *line;
+        size_t linesz;
+        ssize_t len;
+        struct node *a;
+        int cycles;
+
+        INIT_G();
+
+        if (argv[1]) {
+                if (argv[2])
+                        bb_show_usage();
+                if (NOT_LONE_DASH(argv[1])) {
+                        close(STDIN_FILENO); /* == 0 */
+                        xopen(argv[1], O_RDONLY); /* fd will be 0 */
+                }
+        }
+
+        /* Read in words separated by <blank>s */
+        a = NULL;
+        line = NULL;
+        linesz = 0;
+        while ((len = getline(&line, &linesz, stdin)) != -1) {
+                char *s = line;
+                while (*(s = skip_whitespace(s)) != '\0') {
+                        struct node *b;
+                        char *word;
+
+                        word = s;
+                        s = skip_non_whitespace(s);
+                        if (*s)
+                                *s++ = '\0';
+
+                        /* Create nodes and edges for each word pair */
+                        b = get_node(word);
+                        if (!a) {
+                                a = b;
+                        } else {
+                                if (a != b)
+                                        add_edge(a, b);
+                                a = NULL;
+                        }
+                }
+        }
+// Most other tools do not check for input read error (treat them as EOF)
+//      die_if_ferror(in, input_filename);
+        if (a)
+                bb_simple_error_msg_and_die("odd input");
+        free(line);
+
+        /*
+         * Kahn's algorithm:
+         *   - find a node that has no incoming edges, print and remove it
+         *   - repeat until the graph is empty
+         *   - if any nodes are left, they form cycles.
+         */
+        cycles = 0;
+        while (G.nodes_len) {
+                struct node *n;
+                unsigned i;
+
+                /* Search for first node with no incoming edges */
+                for (i = 0; i < G.nodes_len; i++) {
+                        if (!G.nodes[i]->in_count)
+                                break;
+                }
+                if (i == G.nodes_len) {
+                        /* Must be a cycle; arbitraily break it at node 0 */
+                        cycles++;
+                        i = 0;
+#ifndef TINY
+                        bb_error_msg("cycle at %s", G.nodes[i]->name);
+#endif
+                }
+
+                /* Remove the node (need no longer maintain sort) */
+                n = G.nodes[i];
+                G.nodes[i] = G.nodes[--G.nodes_len];
+
+                /* And remove its outgoing edges */
+                for (i = 0; i < n->out_count; i++)
+                        n->out[i]->in_count--;
+                free(n->out);
+
+                puts(n->name);
+                free(n);
+        }
+        free(G.nodes);
+
+        fflush_stdout_and_exit(cycles ? 1 : 0);
+}
diff --git a/docs/posix_conformance.txt b/docs/posix_conformance.txt
index 5e107d74d..8edbe3e15 100644
--- a/docs/posix_conformance.txt
+++ b/docs/posix_conformance.txt
@@ -24,7 +24,7 @@ POSIX Tools not supported:
   gencat, getconf, iconv, join, link, locale, localedef, lp, m4,
   mailx, newgrp, nl, pathchk, pax, pr, qalter, qdel, qhold, qmove,
   qmsg, qrerun, qrls, qselect, qsig, qstat, qsub, tabs, talk, tput,
-  tsort, unlink, uucp, uustat, uux
+  unlink, uucp, uustat, uux
 
 POSIX Tools not supported (DEVELOPMENT):
   admin, cflow, ctags, cxref, delta, fort77, get, lex, make, nm, prs, rmdel,
diff --git a/editors/vi.c b/editors/vi.c
index dd8dd488a..e28db3ab6 100644
--- a/editors/vi.c
+++ b/editors/vi.c
@@ -1281,10 +1281,11 @@ static char *get_input_line(const char *prompt)
                         break;          // this is end of input
                 if (isbackspace(c)) {
                         // user wants to erase prev char
-                        write1("\b \b"); // erase char on screen
                         buf[--i] = '\0';
+                        go_bottom_and_clear_to_eol();
                         if (i <= 0) // user backs up before b-o-l, exit
                                 break;
+                        write1(buf);
                 } else if (c > 0 && c < 256) { // exclude Unicode
                         // (TODO: need to handle Unicode)
                         buf[i] = c;
diff --git a/examples/shutdown-1.0/script/hardshutdown.c b/examples/shutdown-1.0/script/hardshutdown.c
index c21ddad58..b4af26f0f 100644
--- a/examples/shutdown-1.0/script/hardshutdown.c
+++ b/examples/shutdown-1.0/script/hardshutdown.c
@@ -102,7 +102,7 @@ enum action_t {
         REBOOT
 };
 
-int main(int argc, char *argv[])
+int main(int argc, char **argv)
 {
         struct timespec t = {0,0};
         enum action_t action = SHUTDOWN;
diff --git a/init/init.c b/init/init.c
index 785a3b460..1e1ce833d 100644
--- a/init/init.c
+++ b/init/init.c
@@ -1105,10 +1105,14 @@ int init_main(int argc UNUSED_PARAM, char **argv)
         setsid();
 
         /* Make sure environs is set to something sane */
-        putenv((char *) "HOME=/");
         putenv((char *) bb_PATH_root_path);
         putenv((char *) "SHELL=/bin/sh");
         putenv((char *) "USER=root"); /* needed? why? */
+        /* Linux kernel sets HOME="/" when execing init,
+         * and it can be overridden (but not unset?) on kernel's command line.
+         * We used to set it to "/" here, but now we do not:
+         */
+        //putenv((char *) "HOME=/");
 
         if (argv[1])
                 xsetenv("RUNLEVEL", argv[1]);
diff --git a/libbb/appletlib.c b/libbb/appletlib.c
index 9e415610d..99f0cb89c 100644
--- a/libbb/appletlib.c
+++ b/libbb/appletlib.c
@@ -849,7 +849,7 @@ get_script_content(unsigned n)
 //usage:#define busybox_trivial_usage NOUSAGE_STR
 //usage:#define busybox_full_usage ""
 //applet:IF_BUSYBOX(IF_FEATURE_SH_STANDALONE(IF_FEATURE_TAB_COMPLETION(APPLET(busybox, BB_DIR_BIN, BB_SUID_MAYBE))))
-int busybox_main(int argc, char *argv[]) MAIN_EXTERNALLY_VISIBLE;
+int busybox_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 #  else
 #   define busybox_main(argc,argv) busybox_main(argv)
 static
diff --git a/libpwdgrp/pwd_grp.c b/libpwdgrp/pwd_grp.c
index b44ada432..10debbcdb 100644
--- a/libpwdgrp/pwd_grp.c
+++ b/libpwdgrp/pwd_grp.c
@@ -191,6 +191,9 @@ static char *parse_common(FILE *fp, struct passdb *db,
         char *buf;
 
         while ((buf = xmalloc_fgetline(fp)) != NULL) {
+                int n;
+                char *field;
+
                 /* Skip empty lines, comment lines */
                 if (buf[0] == '\0' || buf[0] == '#')
                         goto free_and_next;
@@ -204,7 +207,16 @@ static char *parse_common(FILE *fp, struct passdb *db,
                         /* no key specified: sequential read, return a record */
                         break;
                 }
-                if (strcmp(key, nth_string(buf, field_pos)) == 0) {
+                /* Can't use nth_string() here, it does not allow empty strings
+                 * ("\0\0" terminates the list), and a valid passwd entry
+                 * "user::UID:GID..." would be mishandled */
+                n = field_pos;
+                field = buf;
+                while (n) {
+                        n--;
+                        field += strlen(field) + 1;
+                }
+                if (strcmp(key, field) == 0) {
                         /* record found */
                         break;
                 }
diff --git a/miscutils/crond.c b/miscutils/crond.c
index 1965af656..bd43c6b68 100644
--- a/miscutils/crond.c
+++ b/miscutils/crond.c
@@ -125,6 +125,7 @@ typedef struct CronLine {
         char *cl_mailto;                /* whom to mail results, may be NULL */
 #endif
         char *cl_shell;
+        char *cl_path;
         /* ordered by size, not in natural order. makes code smaller: */
         char cl_Dow[7];                 /* 0-6, beginning sunday */
         char cl_Mons[12];               /* 0-11 */
@@ -421,6 +422,7 @@ static void load_crontab(const char *fileName)
         char *mailTo = NULL;
 #endif
         char *shell = NULL;
+        char *path = NULL;
 
         delete_cronfile(fileName);
 
@@ -470,7 +472,12 @@ static void load_crontab(const char *fileName)
                                 shell = xstrdup(&tokens[0][6]);
                                 continue;
                         }
-//TODO: handle HOME= too? "man crontab" says:
+                        if (is_prefixed_with(tokens[0], "PATH=")) {
+                                free(path);
+                                path = xstrdup(&tokens[0][5]);
+                                continue;
+                        }
+//TODO: handle HOME= too? Better yet, handle arbitrary ENVVARs? "man crontab" says:
 //name = value
 //
 //where the spaces around the equal-sign (=) are optional, and any subsequent
@@ -480,8 +487,8 @@ static void load_crontab(const char *fileName)
 //
 //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.
+//line of the crontab's owner.  HOME, SHELL, and PATH may be overridden by
+//settings in the crontab; LOGNAME may not.
 
 #if ENABLE_FEATURE_CROND_SPECIAL_TIMES
                         if (tokens[0][0] == '@') {
@@ -567,6 +574,7 @@ static void load_crontab(const char *fileName)
                         line->cl_mailto = xstrdup(mailTo);
 #endif
                         line->cl_shell = xstrdup(shell);
+                        line->cl_path = xstrdup(path);
                         /* copy command */
                         line->cl_cmd = xstrdup(tokens[5]);
                         pline = &line->cl_next;
@@ -653,21 +661,22 @@ static void safe_setenv(char **pvar_val, const char *var, const char *val)
 }
 #endif
 
-static void set_env_vars(struct passwd *pas, const char *shell)
+static void set_env_vars(struct passwd *pas, const char *shell, const char *path)
 {
         /* 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);
         safe_setenv(&G.env_var_shell, "SHELL", shell);
+        if (path) safe_setenv(&G.env_var_shell, "PATH", path);
 #else
         xsetenv("LOGNAME", pas->pw_name);
         xsetenv("USER", pas->pw_name);
         xsetenv("HOME", pas->pw_dir);
         xsetenv("SHELL", shell);
+        if (path) xsetenv("PATH", path);
 #endif
 }
 
@@ -701,7 +710,7 @@ fork_job(const char *user, int mailFd, CronLine *line, bool run_sendmail)
         shell = line->cl_shell ? line->cl_shell : G.default_shell;
         prog = run_sendmail ? SENDMAIL : shell;
 
-        set_env_vars(pas, shell);
+        set_env_vars(pas, shell, NULL); /* don't use crontab's PATH for sendmail */
 
         sv_logmode = logmode;
         pid = vfork();
@@ -845,7 +854,7 @@ static pid_t start_one_job(const char *user, CronLine *line)
 
         /* Prepare things before vfork */
         shell = line->cl_shell ? line->cl_shell : G.default_shell;
-        set_env_vars(pas, shell);
+        set_env_vars(pas, shell, line->cl_path);
 
         /* Fork as the user in question and run program */
         pid = vfork();
diff --git a/miscutils/seedrng.c b/miscutils/seedrng.c
new file mode 100644
index 000000000..967741dc7
--- /dev/null
+++ b/miscutils/seedrng.c
@@ -0,0 +1,242 @@
+// SPDX-License-Identifier: GPL-2.0 OR MIT
+/*
+ * Copyright (C) 2022 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
+ *
+ * SeedRNG is a simple program made for seeding the Linux kernel random number
+ * generator from seed files. It is is useful in light of the fact that the
+ * Linux kernel RNG cannot be initialized from shell scripts, and new seeds
+ * cannot be safely generated from boot time shell scripts either. It should
+ * be run once at init time and once at shutdown time. It can be run at other
+ * times on a timer as well. Whenever it is run, it writes existing seed files
+ * into the RNG pool, and then creates a new seed file. If the RNG is
+ * initialized at the time of creating a new seed file, then that new seed file
+ * is marked as "creditable", which means it can be used to initialize the RNG.
+ * Otherwise, it is marked as "non-creditable", in which case it is still used
+ * to seed the RNG's pool, but will not initialize the RNG. In order to ensure
+ * that entropy only ever stays the same or increases from one seed file to the
+ * next, old seed values are hashed together with new seed values when writing
+ * new seed files.
+ *
+ * This is based on code from <https://git.zx2c4.com/seedrng/about/>.
+ */
+//config:config SEEDRNG
+//config:       bool "seedrng (1.3 kb)"
+//config:       default y
+//config:       help
+//config:       Seed the kernel RNG from seed files, meant to be called
+//config:       once during startup, once during shutdown, and optionally
+//config:       at some periodic interval in between.
+
+//applet:IF_SEEDRNG(APPLET(seedrng, BB_DIR_USR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_SEEDRNG) += seedrng.o
+
+//usage:#define seedrng_trivial_usage
+//usage:        "[-d DIR] [-n]"
+//usage:#define seedrng_full_usage "\n\n"
+//usage:        "Seed the kernel RNG from seed files"
+//usage:        "\n"
+//usage:        "\n     -d DIR  Use seed files in DIR (default: /var/lib/seedrng)"
+//usage:        "\n     -n      Do not credit randomness, even if creditable"
+
+#include "libbb.h"
+
+#include <linux/random.h>
+#include <sys/random.h>
+#include <sys/file.h>
+
+#ifndef GRND_INSECURE
+#define GRND_INSECURE 0x0004 /* Apparently some headers don't ship with this yet. */
+#endif
+
+#define DEFAULT_SEED_DIR         "/var/lib/seedrng"
+#define CREDITABLE_SEED_NAME     "seed.credit"
+#define NON_CREDITABLE_SEED_NAME "seed.no-credit"
+
+enum {
+        MIN_SEED_LEN = SHA256_OUTSIZE,
+        /* kernels < 5.18 could return short reads from getrandom()
+         * if signal is pending and length is > 256.
+         * Let's limit our reads to 256 bytes.
+         */
+        MAX_SEED_LEN = 256,
+};
+
+static size_t determine_optimal_seed_len(void)
+{
+        char poolsize_str[12];
+        unsigned poolsize;
+        int n;
+
+        n = open_read_close("/proc/sys/kernel/random/poolsize", poolsize_str, sizeof(poolsize_str) - 1);
+        if (n < 0) {
+                bb_perror_msg("can't determine pool size, assuming %u bits", MIN_SEED_LEN * 8);
+                return MIN_SEED_LEN;
+        }
+        poolsize_str[n] = '\0';
+        poolsize = (bb_strtou(poolsize_str, NULL, 10) + 7) / 8;
+        return MAX(MIN(poolsize, MAX_SEED_LEN), MIN_SEED_LEN);
+}
+
+static bool read_new_seed(uint8_t *seed, size_t len)
+{
+        bool is_creditable;
+        ssize_t ret;
+
+        ret = getrandom(seed, len, GRND_NONBLOCK);
+        if (ret == (ssize_t)len) {
+                return true;
+        }
+        if (ret < 0 && errno == ENOSYS) {
+                int fd = xopen("/dev/random", O_RDONLY);
+                struct pollfd random_fd;
+                random_fd.fd = fd;
+                random_fd.events = POLLIN;
+                is_creditable = poll(&random_fd, 1, 0) == 1;
+//This is racy. is_creditable can be set to true here, but other process
+//can consume "good" random data from /dev/urandom before we do it below.
+                close(fd);
+        } else {
+                if (getrandom(seed, len, GRND_INSECURE) == (ssize_t)len)
+                        return false;
+                is_creditable = false;
+        }
+
+        /* Either getrandom() is not implemented, or
+         * getrandom(GRND_INSECURE) did not give us LEN bytes.
+         * Fallback to reading /dev/urandom.
+         */
+        errno = 0;
+        if (open_read_close("/dev/urandom", seed, len) != (ssize_t)len)
+                bb_perror_msg_and_die("can't read '%s'", "/dev/urandom");
+        return is_creditable;
+}
+
+static void seed_from_file_if_exists(const char *filename, int dfd, bool credit, sha256_ctx_t *hash)
+{
+        struct {
+                int entropy_count;
+                int buf_size;
+                uint8_t buf[MAX_SEED_LEN];
+        } req;
+        ssize_t seed_len;
+
+        seed_len = open_read_close(filename, req.buf, sizeof(req.buf));
+        if (seed_len < 0) {
+                if (errno != ENOENT)
+                        bb_perror_msg_and_die("can't read '%s'", filename);
+                return;
+        }
+        xunlink(filename);
+        if (seed_len != 0) {
+                int fd;
+
+                /* We are going to use this data to seed the RNG:
+                 * we believe it to genuinely containing entropy.
+                 * If this just-unlinked file survives
+                 * (if machine crashes before deletion is recorded on disk)
+                 * and we reuse it after reboot, this assumption
+                 * would be violated, and RNG may end up generating
+                 * the same data. fsync the directory
+                 * to make sure file is gone:
+                 */
+                if (fsync(dfd) != 0)
+                        bb_simple_perror_msg_and_die("I/O error");
+
+//Length is not random, and taking its address spills variable to stack
+//              sha256_hash(hash, &seed_len, sizeof(seed_len));
+                sha256_hash(hash, req.buf, seed_len);
+
+                req.buf_size = seed_len;
+                seed_len *= 8;
+                req.entropy_count = credit ? seed_len : 0;
+                printf("Seeding %u bits %s crediting\n",
+                                (unsigned)seed_len, credit ? "and" : "without");
+                fd = xopen("/dev/urandom", O_RDONLY);
+                xioctl(fd, RNDADDENTROPY, &req);
+                if (ENABLE_FEATURE_CLEAN_UP)
+                        close(fd);
+        }
+}
+
+int seedrng_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int seedrng_main(int argc UNUSED_PARAM, char **argv)
+{
+        const char *seed_dir;
+        int fd, dfd;
+        int i;
+        unsigned opts;
+        uint8_t new_seed[MAX_SEED_LEN];
+        size_t new_seed_len;
+        bool new_seed_creditable;
+        struct timespec timestamp[2];
+        sha256_ctx_t hash;
+
+        enum {
+                OPT_n = (1 << 0), /* must be 1 */
+                OPT_d = (1 << 1),
+        };
+#if ENABLE_LONG_OPTS
+        static const char longopts[] ALIGN1 =
+                "skip-credit\0" No_argument       "n"
+                "seed-dir\0"    Required_argument "d"
+                ;
+#endif
+
+        seed_dir = DEFAULT_SEED_DIR;
+        opts = getopt32long(argv, "nd:", longopts, &seed_dir);
+        umask(0077);
+        if (getuid() != 0)
+                bb_simple_error_msg_and_die(bb_msg_you_must_be_root);
+
+        if (mkdir(seed_dir, 0700) < 0 && errno != EEXIST)
+                bb_perror_msg_and_die("can't create directory '%s'", seed_dir);
+        dfd = xopen(seed_dir, O_DIRECTORY | O_RDONLY);
+        xfchdir(dfd);
+        /* Concurrent runs of this tool might feed the same data to RNG twice.
+         * Avoid concurrent runs by taking a blocking lock on the directory.
+         * Not checking for errors. Looking at manpage,
+         * ENOLCK "The kernel ran out of memory for allocating lock records"
+         * seems to be the only one which is possible - and if that happens,
+         * machine is OOMing (much worse problem than inability to lock...).
+         * Also, typically configured Linux machines do not fail GFP_KERNEL
+         * allocations (they trigger memory reclaim instead).
+         */
+        flock(dfd, LOCK_EX); /* blocks while another instance runs */
+
+        sha256_begin(&hash);
+//Hashing in a constant string doesn't add any entropy
+//      sha256_hash(&hash, "SeedRNG v1 Old+New Prefix", 25);
+        clock_gettime(CLOCK_REALTIME, &timestamp[0]);
+        clock_gettime(CLOCK_BOOTTIME, &timestamp[1]);
+        sha256_hash(&hash, timestamp, sizeof(timestamp));
+
+        for (i = 0; i <= 1; i++) {
+                seed_from_file_if_exists(
+                        i == 0 ? NON_CREDITABLE_SEED_NAME : CREDITABLE_SEED_NAME,
+                        dfd,
+                        /*credit?*/ (opts ^ OPT_n) & i, /* 0, then 1 unless -n */
+                        &hash);
+        }
+
+        new_seed_len = determine_optimal_seed_len();
+        new_seed_creditable = read_new_seed(new_seed, new_seed_len);
+//Length is not random, and taking its address spills variable to stack
+//      sha256_hash(&hash, &new_seed_len, sizeof(new_seed_len));
+        sha256_hash(&hash, new_seed, new_seed_len);
+        sha256_end(&hash, new_seed + new_seed_len - SHA256_OUTSIZE);
+
+        printf("Saving %u bits of %screditable seed for next boot\n",
+                (unsigned)new_seed_len * 8, new_seed_creditable ? "" : "non-");
+        fd = xopen3(NON_CREDITABLE_SEED_NAME, O_WRONLY | O_CREAT | O_TRUNC, 0400);
+        xwrite(fd, new_seed, new_seed_len);
+        if (new_seed_creditable) {
+                /* More paranoia when we create a file which we believe contains
+                 * genuine entropy: make sure disk is not full, quota isn't exceeded, etc:
+                 */
+                if (fsync(fd) < 0)
+                        bb_perror_msg_and_die("can't write '%s'", NON_CREDITABLE_SEED_NAME);
+                xrename(NON_CREDITABLE_SEED_NAME, CREDITABLE_SEED_NAME);
+        }
+        return EXIT_SUCCESS;
+}
diff --git a/networking/httpd_indexcgi.c b/networking/httpd_indexcgi.c
index 47b1159f4..edaaad566 100644
--- a/networking/httpd_indexcgi.c
+++ b/networking/httpd_indexcgi.c
@@ -211,7 +211,7 @@ static void fmt_04u(/*char *dst,*/ unsigned n)
         fmt_02u(n % 100);
 }
 
-int main(int argc, char *argv[])
+int main(int argc, char **argv)
 {
         dir_list_t *dir_list;
         dir_list_t *cdir;
diff --git a/networking/httpd_ssi.c b/networking/httpd_ssi.c
index 4bd9a6d97..620b96332 100644
--- a/networking/httpd_ssi.c
+++ b/networking/httpd_ssi.c
@@ -143,7 +143,7 @@ static void process_includes(const char *filename)
         fclose(fp);
 }
 
-int main(int argc, char *argv[])
+int main(int argc, char **argv)
 {
         if (!argv[1])
                 return 1;
diff --git a/networking/ifplugd.c b/networking/ifplugd.c
index c4b6b9584..0b55bf4e5 100644
--- a/networking/ifplugd.c
+++ b/networking/ifplugd.c
@@ -28,6 +28,7 @@
 //usage:     "\n        -a              Don't up interface at each link probe"
 //usage:     "\n        -M              Monitor creation/destruction of interface"
 //usage:     "\n                        (otherwise it must exist)"
+//usage:     "\n        -A              Don't up newly appeared interface"
 //usage:     "\n        -r PROG         Script to run"
 //usage:     "\n        -x ARG          Extra argument for script"
 //usage:     "\n        -I              Don't exit on nonzero exit code from script"
@@ -94,7 +95,7 @@ Netlink code then can be just dropped (1k or more?)
 #define IFPLUGD_ENV_CURRENT "IFPLUGD_CURRENT"
 
 enum {
-        FLAG_NO_AUTO                    = 1 <<  0, // -a, Do not enable interface automatically
+        FLAG_NO_AUTO                    = 1 <<  0, // -a, Don't up interface at each link probe
         FLAG_NO_DAEMON                  = 1 <<  1, // -n, Do not daemonize
         FLAG_NO_SYSLOG                  = 1 <<  2, // -s, Do not use syslog, use stderr instead
         FLAG_IGNORE_FAIL                = 1 <<  3, // -f, Ignore detection failure, retry instead (failure is treated as DOWN)
@@ -111,14 +112,15 @@ enum {
         FLAG_INITIAL_DOWN               = 1 << 14, // -l, Run "down" script on startup if no cable is detected
         FLAG_EXTRA_ARG                  = 1 << 15, // -x, Specify an extra argument for action script
         FLAG_MONITOR                    = 1 << 16, // -M, Use interface monitoring
+        FLAG_NO_UP_NEW_IFACE            = 1 << 17, // -A, Don't up newly appeared interface
 #if ENABLE_FEATURE_PIDFILE
-        FLAG_KILL                       = 1 << 17, // -k, Kill a running daemon
+        FLAG_KILL                       = 1 << 18, // -k, Kill a running daemon
 #endif
 };
 #if ENABLE_FEATURE_PIDFILE
-# define OPTION_STR "+ansfFi:r:It:+u:+d:+m:pqlx:Mk"
+# define OPTION_STR "+ansfFi:r:It:+u:+d:+m:pqlx:MAk"
 #else
-# define OPTION_STR "+ansfFi:r:It:+u:+d:+m:pqlx:M"
+# define OPTION_STR "+ansfFi:r:It:+u:+d:+m:pqlx:MA"
 #endif
 
 enum { // interface status
@@ -387,7 +389,7 @@ static void up_iface(void)
 
 static void maybe_up_new_iface(void)
 {
-        if (!(option_mask32 & FLAG_NO_AUTO))
+        if (!(option_mask32 & FLAG_NO_UP_NEW_IFACE))
                 up_iface();
 
 #if 0 /* bloat */
diff --git a/printutils/lpd.c b/printutils/lpd.c
index e48feef90..34e5ea209 100644
--- a/printutils/lpd.c
+++ b/printutils/lpd.c
@@ -114,8 +114,8 @@ static char *xmalloc_read_stdin(void)
         return xmalloc_reads(STDIN_FILENO, &max);
 }
 
-int lpd_main(int argc, char *argv[]) MAIN_EXTERNALLY_VISIBLE;
-int lpd_main(int argc UNUSED_PARAM, char *argv[])
+int lpd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int lpd_main(int argc UNUSED_PARAM, char **argv)
 {
         int spooling = spooling; // for compiler
         char *s, *queue;
diff --git a/printutils/lpr.c b/printutils/lpr.c
index 77d1a79a4..d40d0a67c 100644
--- a/printutils/lpr.c
+++ b/printutils/lpr.c
@@ -78,8 +78,8 @@ static void get_response_or_say_and_die(int fd, const char *errmsg)
         }
 }
 
-int lpqr_main(int argc, char *argv[]) MAIN_EXTERNALLY_VISIBLE;
-int lpqr_main(int argc UNUSED_PARAM, char *argv[])
+int lpqr_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int lpqr_main(int argc UNUSED_PARAM, char **argv)
 {
         enum {
                 OPT_P           = 1 << 0, // -P queue[@host[:port]]. If no -P is given use $PRINTER, then "lp@localhost:515"
diff --git a/procps/top.c b/procps/top.c
index 804d6f258..744f20e9b 100644
--- a/procps/top.c
+++ b/procps/top.c
@@ -689,6 +689,9 @@ static NOINLINE void display_process_list(int lines_rem, int scr_width)
                 lines_rem = ntop - G_scroll_ofs;
         s = top + G_scroll_ofs;
         while (--lines_rem >= 0) {
+                int n;
+                char *ppu;
+                char ppubuf[sizeof(int)*3 * 2 + 12];
                 char vsz_str_buf[8];
                 unsigned col;
 
@@ -699,12 +702,36 @@ static NOINLINE void display_process_list(int lines_rem, int scr_width)
 
                 smart_ulltoa5(s->vsz, vsz_str_buf, " mgtpezy");
                 /* PID PPID USER STAT VSZ %VSZ [%CPU] COMMAND */
+                n = sprintf(ppubuf, "%5u %5u %-8.8s", s->pid, s->ppid, get_cached_username(s->uid));
+                ppu = ppubuf;
+                if (n != 6+6+8) {
+                        /* Format PID PPID USER part into 6+6+8 chars:
+                         * shrink PID/PPID if possible, then truncate USER
+                         */
+                        char *p, *pp;
+                        if (*ppu == ' ') {
+                                do {
+                                        ppu++, n--;
+                                        if (n == 6+6+8)
+                                                goto shortened;
+                                } while (*ppu == ' ');
+                        }
+                        pp = p = skip_non_whitespace(ppu) + 1;
+                        if (*p == ' ') {
+                                do
+                                        p++, n--;
+                                while (n != 6+6+8 && *p == ' ');
+                                overlapping_strcpy(pp, p); /* shrink PPID */
+                        }
+                        ppu[6+6+8] = '\0'; /* truncate USER */
+                }
+ shortened:
                 col = snprintf(line_buf, scr_width,
-                                "\n" "%5u%6u %-8.8s %s  %.5s" FMT
+                                "\n" "%s %s  %.5s" FMT
                                 IF_FEATURE_TOP_SMP_PROCESS(" %3d")
                                 IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE(FMT)
                                 " ",
-                                s->pid, s->ppid, get_cached_username(s->uid),
+                                ppu,
                                 s->state, vsz_str_buf,
                                 SHOW_STAT(pmem)
                                 IF_FEATURE_TOP_SMP_PROCESS(, s->last_seen_on_cpu)
diff --git a/scripts/Makefile.lib b/scripts/Makefile.lib
index d8d768a28..ac1ac9735 100644
--- a/scripts/Makefile.lib
+++ b/scripts/Makefile.lib
@@ -113,6 +113,7 @@ c_flags        = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(CPPFLAGS) \
                  $(basename_flags) $(modname_flags)
 
 a_flags        = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(CPPFLAGS) \
+                 $(__c_flags) \
                  $(__a_flags) $(modkern_aflags)
 
 cpp_flags      = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(__cpp_flags)
diff --git a/shell/match.c b/shell/match.c
index 90f77546d..8024f2747 100644
--- a/shell/match.c
+++ b/shell/match.c
@@ -95,7 +95,7 @@ char* FAST_FUNC scan_and_match(char *string, const char *pattern, unsigned flags
 }
 
 #ifdef STANDALONE
-int main(int argc, char *argv[])
+int main(int argc, char **argv)
 {
         char *string;
         char *op;
diff --git a/testsuite/tsort.tests b/testsuite/tsort.tests
new file mode 100755
index 000000000..c6fe78272
--- /dev/null
+++ b/testsuite/tsort.tests
@@ -0,0 +1,110 @@
+#!/bin/sh
+
+# SUSv3 compliant sort tests.
+# Public Domain, David Leonard 2022
+
+. ./testing.sh
+
+#       name cmd expected ./input stdin
+testing "" "tsort"       "a\n" "" "a a\n"
+testing "" "tsort -"     "a\n" "" "a a\n"
+testing "" "tsort input" "a\n" "a a\n" ""
+testing "tsort input (w/o eol)" "tsort input" "a\n" "a a" ""
+testing "" "tsort /dev/null" "" "" ""
+
+testing "tsort empty" tsort "" "" ""
+testing "tsort blank" tsort "" "" "\n"
+testing "tsort blanks" tsort "" "" "\n\n \t\n "
+
+# simple inputs having exactly one solution
+testing "tsort 1-edge" tsort "a\nb\n" "" "a b\n"
+testing "tsort 2-edge" tsort "a\nb\nc\n" "" "a b b c\n"
+
+
+# The following test helper accommodates future variable output because, as
+# tsort is allowed to emit any total ordering that satisfies its input,
+# should the implementation changes, these tests will remain valid.
+#
+# The idea is to verify that:
+# - each input word is present EXACTLY ONCE in tsort's output
+# - for each input pair 'a b', the occurrence of 'a' APPEARS BEFORE 'b'
+# - the exit code is 0
+
+tsort_test () {
+        fail=
+        name="$1"; shift
+        args="$*"
+        if [ $VERBOSE ]; then
+                echo "============"
+                echo "echo \"$args\" | tsort >actual"
+        fi
+        echo "$args" | tsort >actual
+        ec=$?
+        if [ $ec -ne 0 ]; then
+                fail "tsort exit $ec, expected 0"
+        fi
+        while [ $# -ne 0 ]; do
+                a=$1; shift
+                b=$1; shift
+                aline=$(grep -nxF "$a" <actual | cut -d: -f1)
+                bline=$(grep -nxF "$b" <actual | cut -d: -f1)
+                case $aline in
+                        "") fail "word $a missing from output ($args)";;
+                        *" "*) fail "word $a duplicated ($args)";;
+                esac
+                case $bline in
+                        "") fail "word $b missing from output ($args)";;
+                        *" "*) fail "word $b duplicated ($args)";;
+                esac
+                if [ $aline -gt $bline ]; then
+                        fail "$a appears after $b ($args)"
+                fi
+        done
+        if [ $fail ] && [ $VERBOSE ]; then
+                echo "exit $ec, actual:"
+                cat actual
+        fi
+        rm actual
+        report "$name"
+}
+
+# Test that erroneous input causes an unsuccessful exit code
+# we don't test the output error message
+tsort_test_err () {
+        fail=
+        name="$1"; shift
+        echo "$*" | tsort >/dev/null 2>/dev/null
+        ec=$?
+        if [ $ec -eq 0 ]; then
+                fail "$name: unexpected exit 0 ($*)"
+        fi
+        report "$name"
+}
+
+fail () {
+        [ $VERBOSE ] && echo "ERROR: $*"
+        fail=1
+}
+
+report () {
+        if [ $fail ]; then
+                FAILCOUNT=$(($FAILCOUNT + 1))
+                echo "FAIL: $*"
+        else
+                echo "PASS: $*"
+        fi
+}
+
+tsort_test "tsort empty2"
+tsort_test "tsort singleton"    a a
+tsort_test "tsort simple"       a b b c
+tsort_test "tsort 2singleton"   a a b b
+tsort_test "tsort medium"       a b a b b c
+tsort_test "tsort std.example"  a b c c d e g g f g e f h h
+tsort_test "tsort prefixes"     a aa aa aaa aaaa aaaaa a aaaaa
+
+tsort_test_err "tsort odd"      a
+tsort_test_err "tsort odd2"     a b c
+tsort_test_err "tsort cycle"    a b b a
+
+exit $FAILCOUNT