Changeset 3621 for branches/3.3/mindi-busybox/libbb – MondoRescue

branches/3.3/mindi-busybox/libbb/Config.src

-              r3232
+              r3621
 config MD5_SMALL
     int "MD5: Trade bytes for speed (0:fast, 3:slow)"
     default 1
+    default 1  # all "fast or small" options default to small
     range 0 3
     help
 …
 config SHA3_SMALL
     int "SHA3: Trade bytes for speed (0:fast, 1:slow)"
     default 1
+    default 1  # all "fast or small" options default to small
     range 0 1
     help
 …
 config FEATURE_FAST_TOP
     bool "Faster /proc scanning code (+100 bytes)"
     default y
+    default n  # all "fast or small" options default to small
     help
       This option makes top (and ps) ~20% faster (or 20% less CPU hungry),
 …
     bool "Reverse history search"
     default y
     depends on FEATURE_EDITING_SAVEHISTORY
+    depends on FEATURE_EDITING
     help
       Enable readline-like Ctrl-R combination for reverse history search.
 …
 config MONOTONIC_SYSCALL
     bool "Use clock_gettime(CLOCK_MONOTONIC) syscall"
     default n
+    default y
     select PLATFORM_LINUX
     help

branches/3.3/mindi-busybox/libbb/Kbuild.src

-              r3232
+              r3621
 lib-y += copyfd.o
 lib-y += crc32.o
-lib-y += create_icmp6_socket.o
-lib-y += create_icmp_socket.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 += human_readable.o
 lib-y += inet_common.o
-lib-y += info_msg.o
 lib-y += inode_hash.o
 lib-y += isdirectory.o
 …
 lib-y += str_tolower.o
 lib-y += strrstr.o
+lib-y += sysconf.o
 lib-y += time.o
 lib-y += trim.o
 …
 lib-$(CONFIG_DELUSER) += update_passwd.o
+lib-$(CONFIG_FTPD) += correct_password.o
 lib-$(CONFIG_PASSWD) += pw_encrypt.o update_passwd.o obscure.o
 lib-$(CONFIG_CHPASSWD) += pw_encrypt.o update_passwd.o
 lib-$(CONFIG_CRYPTPW) += pw_encrypt.o
+lib-$(CONFIG_SULOGIN) += pw_encrypt.o
+lib-$(CONFIG_MKPASSWD) += pw_encrypt.o
+lib-$(CONFIG_SULOGIN) += pw_encrypt.o correct_password.o
 lib-$(CONFIG_VLOCK) += pw_encrypt.o correct_password.o
 lib-$(CONFIG_SU) += pw_encrypt.o correct_password.o
 lib-$(CONFIG_LOGIN) += pw_encrypt.o correct_password.o
 lib-$(CONFIG_FEATURE_HTTPD_AUTH_MD5) += pw_encrypt.o
+lib-$(CONFIG_FEATURE_FTP_AUTHENTICATION) += pw_encrypt.o
 lib-$(CONFIG_DF) += find_mount_point.o
 …
 lib-$(CONFIG_DEVFSD) += xregcomp.o
 lib-$(CONFIG_FEATURE_FIND_REGEX) += xregcomp.o
+# Add the experimental logging functionality, only used by zcip
+lib-$(CONFIG_ZCIP) += logenv.o

branches/3.3/mindi-busybox/libbb/appletlib.c

-              r3232
+              r3621
 #if !(defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) \
         || defined(__APPLE__) \
+    || defined(__APPLE__) \
+    )
 # include <malloc.h> /* for mallopt */
 …
 #include "usage_compressed.h"
+static void run_applet_and_exit(const char *name, char **argv) NORETURN;
 #if ENABLE_SHOW_USAGE && !ENABLE_FEATURE_COMPRESS_USAGE
 …
             full_write2_str(" ");
             full_write2_str(p);
             full_write2_str("\n\n");
+            full_write2_str("\n");
+        }
         if (ENABLE_FEATURE_CLEAN_UP)
 …
+}
-#if NUM_APPLETS > 8
-static int applet_name_compare(const void *name, const void *idx)
+{
-    int i = (int)(ptrdiff_t)idx - 1;
-    return strcmp(name, APPLET_NAME(i));
+}
-#endif
 int FAST_FUNC find_applet_by_name(const char *name)
+{
+#if NUM_APPLETS > 8
     /* Do a binary search to find the applet entry given the name. */
+    unsigned i, max;
+    int j;
     const char *p;
+    p = bsearch(name, (void*)(ptrdiff_t)1, ARRAY_SIZE(applet_main), 1, applet_name_compare);
+    /*
+     * if (!p) return -1;
+     * ^^^^^^^^^^^^^^^^^^ the code below will do this if p == NULL :)
+     */
+    return (int)(ptrdiff_t)p - 1;
+/* The commented-out word-at-a-time code is ~40% faster, but +160 bytes.
+ * "Faster" here saves ~0.5 microsecond of real time - not worth it.
+ */
+#if 0 /*BB_UNALIGNED_MEMACCESS_OK && BB_LITTLE_ENDIAN*/
+    uint32_t n32;
+    /* Handle all names < 2 chars long early */
+    if (name[0] == '\0')
+        return -1; /* "" is not a valid applet name */
+    if (name[1] == '\0') {
+        if (!ENABLE_TEST)
+            return -1; /* 1-char name is not valid */
+        if (name[0] != ']')
+            return -1; /* 1-char name which isn't "[" is not valid */
+        /* applet "[" is always applet #0: */
+        return 0;
+    }
+#endif
+    p = applet_names;
+    i = 0;
+#if KNOWN_APPNAME_OFFSETS <= 0
+    max = NUM_APPLETS;
 #else
+    /* A version which does not pull in bsearch */
+    int i = 0;
+    const char *p = applet_names;
+    while (i < NUM_APPLETS) {
+        if (strcmp(name, p) == 0)
+    max = NUM_APPLETS * KNOWN_APPNAME_OFFSETS;
+    for (j = ARRAY_SIZE(applet_nameofs)-1; j >= 0; j--) {
+        const char *pp = applet_names + applet_nameofs[j];
+        if (strcmp(name, pp) >= 0) {
+            //bb_error_msg("name:'%s' >= pp:'%s'", name, pp);
+            p = pp;
+            i = max - NUM_APPLETS;
+            break;
+        }
+        max -= NUM_APPLETS;
+    }
+    max /= (unsigned)KNOWN_APPNAME_OFFSETS;
+    i /= (unsigned)KNOWN_APPNAME_OFFSETS;
+    //bb_error_msg("name:'%s' starting from:'%s' i:%u max:%u", name, p, i, max);
+#endif
+    /* Open-coded linear search without strcmp/strlen calls for speed */
+#if 0 /*BB_UNALIGNED_MEMACCESS_OK && BB_LITTLE_ENDIAN*/
+    /* skip "[\0" name, it's surely not it */
+    if (ENABLE_TEST && LONE_CHAR(p, '['))
+        i++, p += 2;
+    /* All remaining applet names in p[] are at least 2 chars long */
+    /* name[] is also at least 2 chars long */
+    n32 = (name[0] << 0) | (name[1] << 8) | (name[2] << 16);
+    while (i < max) {
+        uint32_t p32;
+        char ch;
+        /* Quickly check match of the first 3 bytes */
+        move_from_unaligned32(p32, p);
+        p += 3;
+        if ((p32 & 0x00ffffff) != n32) {
+            /* Most likely case: 3 first bytes do not match */
+            i++;
+            if ((p32 & 0x00ff0000) == '\0')
+                continue; // p[2] was NUL
+            p++;
+            if ((p32 & 0xff000000) == '\0')
+                continue; // p[3] was NUL
+            /* p[0..3] aren't matching and none is NUL, check the rest */
+            while (*p++ != '\0')
+                continue;
+            continue;
+        }
+        /* Unlikely branch: first 3 bytes ([0..2]) match */
+        if ((p32 & 0x00ff0000) == '\0') {
+            /* name is 2-byte long, it is full match */
+            //bb_error_msg("found:'%s' i:%u", name, i);
             return i;
+        p += strlen(p) + 1;
+        }
+        /* Check remaining bytes [3..NUL] */
+        ch = (p32 >> 24);
+        j = 3;
+        while (ch == name[j]) {
+            if (ch == '\0') {
+                //bb_error_msg("found:'%s' i:%u", name, i);
+                return i;
+            }
+            ch = *++p;
+            j++;
+        }
+        /* Not a match. Skip it, including NUL */
+        while (ch != '\0')
+            ch = *++p;
+        p++;
+        i++;
+    }
+    return -1;
+#else
+    while (i < max) {
+        char ch;
+        j = 0;
+        /* Do we see "name\0" in applet_names[p] position? */
+        while ((ch = *p) == name[j]) {
+            if (ch == '\0') {
+                //bb_error_msg("found:'%s' i:%u", name, i);
+                return i; /* yes */
+            }
+            p++;
+            j++;
+        }
+        /* No.
+         * p => 1st non-matching char in applet_names[],
+         * skip to and including NUL.
+         */
+        while (ch != '\0')
+            ch = *++p;
+        p++;
         i++;
+    }
 …
     applet_name = applet;
+    /* Set locale for everybody except 'init' */
+    if (ENABLE_LOCALE_SUPPORT && getpid() != 1)
+    if (ENABLE_LOCALE_SUPPORT)
         setlocale(LC_ALL, "");
 …
      && !argv[2]
      && strcmp(argv[1], "--help") == 0
      && strncmp(applet, "busybox", 7) != 0
+     && !is_prefixed_with(applet, "busybox")
     ) {
         /* Special case. POSIX says "test --help"
 …
+                    }
                     *e = ':'; /* get_uidgid needs USER:GROUP syntax */
                     if (get_uidgid(&sct->m_ugid, s, /*allow_numeric:*/ 1) == 0) {
+                    if (get_uidgid(&sct->m_ugid, s) == 0) {
                         errmsg = "unknown user/group";
                         goto pe_label;
 …
             goto pe_label;
+        }
     } /* while (1) */
 …
     int (*lf)(const char *, const char *);
     char *fpc;
+        const char *appname = applet_names;
     unsigned i;
     int rc;
 …
         fpc = concat_path_file(
                 custom_install_dir ? custom_install_dir : install_dir[APPLET_INSTALL_LOC(i)],
                 APPLET_NAME(i));
+                appname);
         // debug: bb_error_msg("%slinking %s to busybox",
         //      use_symbolic_links ? "sym" : "", fpc);
 …
+        }
         free(fpc);
+    }
+}
+# else
+#  define install_links(x,y,z) ((void)0)
+        while (*appname++ != '\0')
+            continue;
+    }
+}
+# elif ENABLE_BUSYBOX
+static void install_links(const char *busybox UNUSED_PARAM,
+        int use_symbolic_links UNUSED_PARAM,
+        char *custom_install_dir UNUSED_PARAM)
+{
+}
 # endif
+# if ENABLE_BUSYBOX
 /* If we were called as "busybox..." */
 static int busybox_main(char **argv)
 …
         if (ENABLE_FEATURE_AUTOWIDTH) {
             /* Obtain the terminal width */
             get_terminal_width_height(0, &output_width, NULL);
+            output_width = get_terminal_width(2);
+        }
 …
         full_write2_str(" multi-call binary.\n"); /* reuse */
         full_write2_str(
             "BusyBox is copyrighted by many authors between 1998-2012.\n"
+            "BusyBox is copyrighted by many authors between 1998-2015.\n"
             "Licensed under GPLv2. See source distribution for detailed\n"
             "copyright notices.\n"
 …
             "   or: function [arguments]...\n"
             "\n"
+            IF_NOT_FEATURE_SH_STANDALONE(
             "\tBusyBox is a multi-call binary that combines many common Unix\n"
             "\tutilities into a single executable.  Most people will create a\n"
             "\tlink to busybox for each function they wish to use and BusyBox\n"
             "\twill act like whatever it was invoked as.\n"
+            )
+            IF_FEATURE_SH_STANDALONE(
+            "\tBusyBox is a multi-call binary that combines many common Unix\n"
+            "\tutilities into a single executable.  The shell in this build\n"
+            "\tis configured to run built-in utilities without $PATH search.\n"
+            "\tYou don't need to install a link to busybox for each utility.\n"
+            "\tTo run external program, use full path (/sbin/ip instead of ip).\n"
+            )
             "\n"
             "Currently defined functions:\n"
 …
+    }
     if (strncmp(argv[1], "--list", 6) == 0) {
+    if (is_prefixed_with(argv[1], "--list")) {
         unsigned i = 0;
         const char *a = applet_names;
         dup2(1, 2);
         while (*a) {
 # if ENABLE_FEATURE_INSTALLER
+#  if ENABLE_FEATURE_INSTALLER
             if (argv[1][6]) /* --list-full? */
                 full_write2_str(install_dir[APPLET_INSTALL_LOC(i)] + 1);
 # endif
+#  endif
             full_write2_str(a);
             full_write2_str("\n");
             i++;
+            a += strlen(a) + 1;
+            while (*a++ != '\0')
+                continue;
+        }
         return 0;
 …
     applet_name = bb_get_last_path_component_nostrip(argv[0]);
     run_applet_and_exit(applet_name, argv);
+    /*bb_error_msg_and_die("applet not found"); - sucks in printf */
+    full_write2_str(applet_name);
+    full_write2_str(": applet not found\n");
+    xfunc_die();
+}
+}
+# endif
 void FAST_FUNC run_applet_no_and_exit(int applet_no, char **argv)
 …
     /* Reinit some shared global data */
     xfunc_error_retval = EXIT_FAILURE;
+    applet_name = APPLET_NAME(applet_no);
+    if (argc == 2 && strcmp(argv[1], "--help") == 0) {
+        /* Special case. POSIX says "test --help"
+         * should be no different from e.g. "test --foo".  */
+//TODO: just compare applet_no with APPLET_NO_test
+        if (!ENABLE_TEST || strcmp(applet_name, "test") != 0) {
+            /* If you want "foo --help" to return 0: */
+            /*xfunc_error_retval = 0;*/
+    applet_name = bb_get_last_path_component_nostrip(argv[0]);
+    /* Special case. POSIX says "test --help"
+     * should be no different from e.g. "test --foo".
+     * Thus for "test", we skip --help check.
+     * "true" and "false" are also special.
+     */
+    if (1
+#if defined APPLET_NO_test
+     && applet_no != APPLET_NO_test
+#endif
+#if defined APPLET_NO_true
+     && applet_no != APPLET_NO_true
+#endif
+#if defined APPLET_NO_false
+     && applet_no != APPLET_NO_false
+#endif
+    ) {
+        if (argc == 2 && strcmp(argv[1], "--help") == 0) {
+            /* Make "foo --help" exit with 0: */
+            xfunc_error_retval = 0;
             bb_show_usage();
+        }
 …
+}
+void FAST_FUNC run_applet_and_exit(const char *name, char **argv)
+{
+    int applet = find_applet_by_name(name);
+static NORETURN void run_applet_and_exit(const char *name, char **argv)
+{
+    int applet;
+# if ENABLE_BUSYBOX
+    if (is_prefixed_with(name, "busybox"))
+        exit(busybox_main(argv));
+# endif
+    /* find_applet_by_name() search is more expensive, so goes second */
+    applet = find_applet_by_name(name);
     if (applet >= 0)
         run_applet_no_and_exit(applet, argv);
+    if (strncmp(name, "busybox", 7) == 0)
+        exit(busybox_main(argv));
+    /*bb_error_msg_and_die("applet not found"); - links in printf */
+    full_write2_str(applet_name);
+    full_write2_str(": applet not found\n");
+    /* POSIX: "If a command is not found, the exit status shall be 127" */
+    exit(127);
+}
 …
 #endif
+{
+#if 0
+    /* TODO: find a use for a block of memory between end of .bss
+     * and end of page. For example, I'm getting "_end:0x812e698 2408 bytes"
+     * - more than 2k of wasted memory (in this particular build)
+     * *per each running process*!
+     * (If your linker does not generate "_end" name, weak attribute
+     * makes &_end == NULL, end_len == 0 here.)
+     */
+    extern char _end[] __attribute__((weak));
+    unsigned end_len = (-(int)_end) & 0xfff;
+    printf("_end:%p %u bytes\n", &_end, end_len);
+#endif
     /* Tweak malloc for reduced memory consumption */
 #ifdef M_TRIM_THRESHOLD
 …
 #if defined(SINGLE_APPLET_MAIN)
     /* Only one applet is selected in .config */
     if (argv[1] && strncmp(argv[0], "busybox", 7) == 0) {
+    if (argv[1] && is_prefixed_with(argv[0], "busybox")) {
         /* "busybox <applet> <params>" should still work as expected */
         argv++;
 …
     lbb_prepare("busybox" IF_FEATURE_INDIVIDUAL(, argv));
+#if !ENABLE_BUSYBOX
+    if (argv[1] && is_prefixed_with(bb_basename(argv[0]), "busybox"))
+        argv++;
+#endif
     applet_name = argv[0];
     if (applet_name[0] == '-')
 …
     run_applet_and_exit(applet_name, argv);
+    /*bb_error_msg_and_die("applet not found"); - sucks in printf */
+    full_write2_str(applet_name);
+    full_write2_str(": applet not found\n");
+    xfunc_die();
+#endif
+}
+#endif
+}

branches/3.3/mindi-busybox/libbb/bb_askpass.c

-              r3232
+              r3621
 /*
  * Ask for a password
- * I use a static buffer in this function.  Plan accordingly.
+ *
  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
 …
     /* Was static char[BIGNUM] */
     enum { sizeof_passwd = 128 };
-    static char *passwd;
+    char *passwd;
     char *ret;
     int i;
 …
     struct termios tio, oldtio;
+    tcflush(fd, TCIFLUSH);
+    /* Was buggy: was printing prompt *before* flushing input,
+     * which was upsetting "expect" based scripts of some users.
+     */
     fputs(prompt, stdout);
     fflush_all();
-    tcflush(fd, TCIFLUSH);
     tcgetattr(fd, &oldtio);
 …
+    }
+    if (!passwd)
+        passwd = xmalloc(sizeof_passwd);
+    passwd = auto_string(xmalloc(sizeof_passwd));
     ret = passwd;
     i = 0;
     while (1) {
         int r = read(fd, &ret[i], 1);
+        if (r < 0) {
+        if ((i == 0 && r == 0) /* EOF (^D) with no password */
+         || r < 0
+        ) {
             /* read is interrupted by timeout or ^C */
             ret = NULL;

branches/3.3/mindi-busybox/libbb/change_identity.c

-              r2725
+              r3621
 void FAST_FUNC change_identity(const struct passwd *pw)
+{
+    if (initgroups(pw->pw_name, pw->pw_gid) == -1)
+    int res;
+    res = initgroups(pw->pw_name, pw->pw_gid);
+    endgrent(); /* helps to close a fd used internally by libc */
+    if (res != 0) {
+        /*
+         * If initgroups() fails because a system call is unimplemented
+         * then we are running on a Linux kernel compiled without multiuser
+         * support (CONFIG_MULTIUSER is not defined).
+         *
+         * If we are running without multiuser support *and* the target uid
+         * already matches the current uid then we can skip the change of
+         * identity.
+         */
+        if (errno == ENOSYS && pw->pw_uid == getuid()) {
+            return;
+        }
         bb_perror_msg_and_die("can't set groups");
+    endgrent(); /* helps to close a fd used internally by libc */
+    }
     xsetgid(pw->pw_gid);
     xsetuid(pw->pw_uid);

branches/3.3/mindi-busybox/libbb/compare_string_array.c

-              r2725
+              r3621
 #include "libbb.h"
+/*
+ * Return NULL if string is not prefixed with key. Return pointer to the
+ * first character in string after the prefix key. If key is an empty string,
+ * return pointer to the beginning of string.
+ */
+char* FAST_FUNC is_prefixed_with(const char *string, const char *key)
+{
+#if 0   /* Two passes over key - probably slower */
+    int len = strlen(key);
+    if (strncmp(string, key, len) == 0)
+        return string + len;
+    return NULL;
+#else   /* Open-coded */
+    while (*key != '\0') {
+        if (*key != *string)
+            return NULL;
+        key++;
+        string++;
+    }
+    return (char*)string;
+#endif
+}
+/*
+ * Return NULL if string is not suffixed with key. Return pointer to the
+ * beginning of prefix key in string. If key is an empty string return pointer
+ * to the end of string.
+ */
+char* FAST_FUNC is_suffixed_with(const char *string, const char *key)
+{
+    size_t key_len = strlen(key);
+    ssize_t len_diff = strlen(string) - key_len;
+    if (len_diff >= 0) {
+        string += len_diff;
+        if (strcmp(string, key) == 0) {
+            return (char*)string;
+        }
+    }
+    return NULL;
+}
 /* returns the array index of the string */
 …
+{
     int i;
+    int len = strlen(key);
+    if (len) {
+    if (key[0]) {
         for (i = 0; string_array[i] != 0; i++) {
             if (strncmp(string_array[i], key, len) == 0) {
+            if (is_prefixed_with(string_array[i], key)) {
                 return i;
+            }
 …
+}
 #endif
+#if ENABLE_UNIT_TEST
+BBUNIT_DEFINE_TEST(is_prefixed_with)
+{
+    BBUNIT_ASSERT_STREQ(" bar", is_prefixed_with("foo bar", "foo"));
+    BBUNIT_ASSERT_STREQ("bar", is_prefixed_with("foo bar", "foo "));
+    BBUNIT_ASSERT_STREQ("", is_prefixed_with("foo", "foo"));
+    BBUNIT_ASSERT_STREQ("foo", is_prefixed_with("foo", ""));
+    BBUNIT_ASSERT_STREQ("", is_prefixed_with("", ""));
+    BBUNIT_ASSERT_NULL(is_prefixed_with("foo", "bar foo"));
+    BBUNIT_ASSERT_NULL(is_prefixed_with("foo foo", "bar"));
+    BBUNIT_ASSERT_NULL(is_prefixed_with("", "foo"));
+    BBUNIT_ENDTEST;
+}
+BBUNIT_DEFINE_TEST(is_suffixed_with)
+{
+    BBUNIT_ASSERT_STREQ("bar", is_suffixed_with("foo bar", "bar"));
+    BBUNIT_ASSERT_STREQ("foo", is_suffixed_with("foo", "foo"));
+    BBUNIT_ASSERT_STREQ("", is_suffixed_with("foo", ""));
+    BBUNIT_ASSERT_STREQ("", is_suffixed_with("", ""));
+    BBUNIT_ASSERT_STREQ("foo", is_suffixed_with("barfoofoo", "foo"));
+    BBUNIT_ASSERT_NULL(is_suffixed_with("foo", "bar foo"));
+    BBUNIT_ASSERT_NULL(is_suffixed_with("foo foo", "bar"));
+    BBUNIT_ASSERT_NULL(is_suffixed_with("", "foo"));
+    BBUNIT_ENDTEST;
+}
+#endif /* ENABLE_UNIT_TEST */

branches/3.3/mindi-busybox/libbb/copy_file.c

-              r3232
+              r3621
         return -1; /* error */
+    }
+#if ENABLE_FEATURE_CP_LONG_OPTIONS
+    if (flags & FILEUTILS_RMDEST)
+        if (flags & FILEUTILS_VERBOSE)
+            printf("removed '%s'\n", dest);
+#endif
     return 1; /* ok (to try again) */
+}
 …
+    }
+    if (dest_exists) {
+        if (flags & FILEUTILS_UPDATE) {
+            if (source_stat.st_mtime <= dest_stat.st_mtime) {
+                return 0; /* source file must be newer */
+            }
+        }
+#if ENABLE_FEATURE_CP_LONG_OPTIONS
+        if (flags & FILEUTILS_RMDEST) {
+            ovr = ask_and_unlink(dest, flags);
+            if (ovr <= 0)
+                return ovr;
+            dest_exists = 0;
+        }
+#endif
+    }
     if (flags & (FILEUTILS_MAKE_SOFTLINK|FILEUTILS_MAKE_HARDLINK)) {
         int (*lf)(const char *oldpath, const char *newpath);
 …
+    }
+    if (flags & FILEUTILS_VERBOSE) {
+        printf("'%s' -> '%s'\n", source, dest);
+    }
     return retval;
+}

branches/3.3/mindi-busybox/libbb/copyfd.c

-              r2725
+              r3621
 #include "libbb.h"
+#if ENABLE_FEATURE_USE_SENDFILE
+# include <sys/sendfile.h>
+#else
+# define sendfile(a,b,c,d) (-1)
+#endif
+/*
+ * We were using 0x7fff0000 as sendfile chunk size, but it
+ * was seen to cause largish delays when user tries to ^C a file copy.
+ * Let's use a saner size.
+ * Note: needs to be >= max(CONFIG_FEATURE_COPYBUF_KB),
+ * or else "copy to eof" code will use neddlesly short reads.
+ */
+#define SENDFILE_BIGBUF (16*1024*1024)
 /* Used by NOFORK applets (e.g. cat) - must not use xmalloc.
 …
     off_t total = 0;
     bool continue_on_write_error = 0;
+#if CONFIG_FEATURE_COPYBUF_KB <= 4
+    ssize_t sendfile_sz;
+#if CONFIG_FEATURE_COPYBUF_KB > 4
+    char *buffer = buffer; /* for compiler */
+    int buffer_size = 0;
+#else
     char buffer[CONFIG_FEATURE_COPYBUF_KB * 1024];
     enum { buffer_size = sizeof(buffer) };
-#else
-    char *buffer;
-    int buffer_size;
 #endif
 …
+    }
-#if CONFIG_FEATURE_COPYBUF_KB > 4
-    if (size > 0 && size <= 4 * 1024)
-        goto use_small_buf;
-    /* We want page-aligned buffer, just in case kernel is clever
-     * and can do page-aligned io more efficiently */
-    buffer = mmap(NULL, CONFIG_FEATURE_COPYBUF_KB * 1024,
-            PROT_READ | PROT_WRITE,
-            MAP_PRIVATE | MAP_ANON,
-            /* ignored: */ -1, 0);
-    buffer_size = CONFIG_FEATURE_COPYBUF_KB * 1024;
-    if (buffer == MAP_FAILED) {
- use_small_buf:
-        buffer = alloca(4 * 1024);
-        buffer_size = 4 * 1024;
+    }
-#endif
     if (src_fd < 0)
         goto out;
+    sendfile_sz = !ENABLE_FEATURE_USE_SENDFILE
+        ? 0
+        : SENDFILE_BIGBUF;
     if (!size) {
         size = buffer_size;
+        size = SENDFILE_BIGBUF;
         status = 1; /* copy until eof */
+    }
 …
         ssize_t rd;
+        rd = safe_read(src_fd, buffer, size > buffer_size ? buffer_size : size);
+        if (sendfile_sz) {
+            rd = sendfile(dst_fd, src_fd, NULL,
+                size > sendfile_sz ? sendfile_sz : size);
+            if (rd >= 0)
+                goto read_ok;
+            sendfile_sz = 0; /* do not try sendfile anymore */
+        }
+#if CONFIG_FEATURE_COPYBUF_KB > 4
+        if (buffer_size == 0) {
+            if (size > 0 && size <= 4 * 1024)
+                goto use_small_buf;
+            /* We want page-aligned buffer, just in case kernel is clever
+             * and can do page-aligned io more efficiently */
+            buffer = mmap(NULL, CONFIG_FEATURE_COPYBUF_KB * 1024,
+                    PROT_READ | PROT_WRITE,
+                    MAP_PRIVATE | MAP_ANON,
+                    /* ignored: */ -1, 0);
+            buffer_size = CONFIG_FEATURE_COPYBUF_KB * 1024;
+            if (buffer == MAP_FAILED) {
+ use_small_buf:
+                buffer = alloca(4 * 1024);
+                buffer_size = 4 * 1024;
+            }
+        }
+#endif
+        rd = safe_read(src_fd, buffer,
+            size > buffer_size ? buffer_size : size);
+        if (rd < 0) {
+            bb_perror_msg(bb_msg_read_error);
+            break;
+        }
+ read_ok:
         if (!rd) { /* eof - all done */
             status = 0;
             break;
+        }
-        if (rd < 0) {
-            bb_perror_msg(bb_msg_read_error);
-            break;
+        }
         /* dst_fd == -1 is a fake, else... */
         if (dst_fd >= 0) {
+        if (dst_fd >= 0 && !sendfile_sz) {
             ssize_t wr = full_write(dst_fd, buffer, rd);
             if (wr < rd) {
 …
  out:
+#if CONFIG_FEATURE_COPYBUF_KB > 4
+    if (buffer_size != 4 * 1024)
+    if (buffer_size > 4 * 1024)
         munmap(buffer, buffer_size);
-#endif
     return status ? -1 : total;
+}

branches/3.3/mindi-busybox/libbb/correct_password.c

-              r3232
+              r3621
 #include "libbb.h"
+/* Ask the user for a password.
+ * Return 1 if the user gives the correct password for entry PW,
+ * 0 if not.  Return 1 without asking if PW has an empty password.
+ *
+ * NULL pw means "just fake it for login with bad username" */
+#define SHADOW_BUFSIZE 256
+int FAST_FUNC correct_password(const struct passwd *pw)
+/* Retrieve encrypted password string for pw.
+ * If pw == NULL, return a string which fails password check against any
+ * password.
+ */
+#if !ENABLE_FEATURE_SHADOWPASSWDS
+#define get_passwd(pw, buffer) get_passwd(pw)
+#endif
+static const char *get_passwd(const struct passwd *pw, char buffer[SHADOW_BUFSIZE])
+{
+    char *unencrypted, *encrypted;
+    const char *correct;
+    int r;
+    /* fake salt. crypt() can choke otherwise. */
+    correct = "aa";
+    if (!pw) {
+        /* "aa" will never match */
+        goto fake_it;
+    }
+    correct = pw->pw_passwd;
+    const char *pass;
+    if (!pw)
+        return "aa"; /* "aa" will never match */
+    pass = pw->pw_passwd;
 #if ENABLE_FEATURE_SHADOWPASSWDS
     /* Using _r function to avoid pulling in static buffers */
     if ((correct[0] == 'x' || correct[0] == '*') && !correct[1]) {
+    if ((pass[0] == 'x' || pass[0] == '*') && !pass[1]) {
         struct spwd spw;
         char buffer[256];
+        int r;
         /* getspnam_r may return 0 yet set result to NULL.
          * At least glibc 2.4 does this. Be extra paranoid here. */
         struct spwd *result = NULL;
         r = getspnam_r(pw->pw_name, &spw, buffer, sizeof(buffer), &result);
         correct = (r || !result) ? "aa" : result->sp_pwdp;
+        r = getspnam_r(pw->pw_name, &spw, buffer, SHADOW_BUFSIZE, &result);
+        pass = (r || !result) ? "aa" : result->sp_pwdp;
+    }
 #endif
+    return pass;
+}
+    if (!correct[0]) /* empty password field? */
+/*
+ * Return 1 if PW has an empty password.
+ * Return 1 if the user gives the correct password for entry PW,
+ * 0 if not.
+ * NULL pw means "just fake it for login with bad username"
+ */
+int FAST_FUNC check_password(const struct passwd *pw, const char *plaintext)
+{
+    IF_FEATURE_SHADOWPASSWDS(char buffer[SHADOW_BUFSIZE];)
+    char *encrypted;
+    const char *pw_pass;
+    int r;
+    pw_pass = get_passwd(pw, buffer);
+    if (!pw_pass[0]) { /* empty password field? */
+        return 1;
+    }
+    encrypted = pw_encrypt(plaintext, /*salt:*/ pw_pass, 1);
+    r = (strcmp(encrypted, pw_pass) == 0);
+    free(encrypted);
+    return r;
+}
+/* Ask the user for a password.
+ * Return 1 without asking if PW has an empty password.
+ * Return -1 on EOF, error while reading input, or timeout.
+ * Return 1 if the user gives the correct password for entry PW,
+ * 0 if not.
+ *
+ * NULL pw means "just fake it for login with bad username"
+ */
+int FAST_FUNC ask_and_check_password_extended(const struct passwd *pw,
+        int timeout, const char *prompt)
+{
+    IF_FEATURE_SHADOWPASSWDS(char buffer[SHADOW_BUFSIZE];)
+    char *plaintext;
+    const char *pw_pass;
+    int r;
+    pw_pass = get_passwd(pw, buffer);
+    if (!pw_pass[0]) /* empty password field? */
         return 1;
+ fake_it:
     unencrypted = bb_ask_stdin("Password: ");
     if (!unencrypted) {
         return 0;
+    plaintext = bb_ask(STDIN_FILENO, timeout, prompt);
+    if (!plaintext) {
+        /* EOF (such as ^D) or error (such as ^C) or timeout */
+        return -1;
+    }
+    encrypted = pw_encrypt(unencrypted, correct, 1);
+    r = (strcmp(encrypted, correct) == 0);
+    free(encrypted);
+    memset(unencrypted, 0, strlen(unencrypted));
+    r = check_password(pw, plaintext);
+    nuke_str(plaintext);
     return r;
+}
+int FAST_FUNC ask_and_check_password(const struct passwd *pw)
+{
+    return ask_and_check_password_extended(pw, 0, "Password: ");
+}

branches/3.3/mindi-busybox/libbb/dump.c

r3232	r3621
334	334	}
335	335	}
336		if (fseek(stdin, dumper->pub.dump_skip, SEEK_SET)) {
	336	if (fseeko(stdin, dumper->pub.dump_skip, SEEK_SET)) {
337	337	bb_simple_perror_msg_and_die(fname);
338	338	}

branches/3.3/mindi-busybox/libbb/fclose_nonstdin.c

-              r2725
+              r3621
     /* Some more paranoid applets want ferror() check too */
     int r = ferror(f); /* NB: does NOT set errno! */
+    if (r) errno = EIO; /* so we'll help it */
+    if (r)
+        errno = EIO; /* so we'll help it */
     if (f != stdin)
         return (r | fclose(f)); /* fclose does set errno on error */

branches/3.3/mindi-busybox/libbb/fflush_stdout_and_exit.c

-              r2725
+              r3621
 void FAST_FUNC fflush_stdout_and_exit(int retval)
+{
+    xfunc_error_retval = retval;
     if (fflush(stdout))
         bb_perror_msg_and_die(bb_msg_standard_output);
+    if (ENABLE_FEATURE_PREFER_APPLETS && die_sleep < 0) {
+        /* We are in NOFORK applet. Do not exit() directly,
+         * but use xfunc_die() */
+        xfunc_error_retval = retval;
+        xfunc_die();
+    }
+    exit(retval);
+    /* In case we are in NOFORK applet. Do not exit() directly,
+     * but use xfunc_die() */
+    xfunc_die();
+}

branches/3.3/mindi-busybox/libbb/getpty.c

r3232	r3621
17	17	#if ENABLE_FEATURE_DEVPTS
18	18	p = open("/dev/ptmx", O_RDWR);
19		if (p > 0) {
	19	if (p >= 0) {
20	20	grantpt(p); /* chmod+chown corresponding slave pty */
21	21	unlockpt(p); /* (what does this do?) */

branches/3.3/mindi-busybox/libbb/hash_md5_sha.c

-              r3232
+              r3621
                 t = bb_bswap_64(t);
             /* wbuffer is suitably aligned for this */
             *(uint64_t *) (&ctx->wbuffer[64 - 8]) = t;
+            *(bb__aliased_uint64_t *) (&ctx->wbuffer[64 - 8]) = t;
+        }
         ctx->process_block(ctx);
 …
     /* Before we start, one word to the strange constants.
        They are defined in RFC 1321 as
        T[i] = (int)(4294967296.0 * fabs(sin(i))), i=1..64
+       T[i] = (int)(2^32 * fabs(sin(i))), i=1..64
      */
     static const uint32_t C_array[] = {
 …
             temp += FH(B, C, D);
             break;
         case 3:
+        default: /* case 3 */
             temp += FI(B, C, D);
+        }
 …
 #else  /* MD5_SMALL == 0 or 1 */
-    uint32_t A_save = A;
-    uint32_t B_save = B;
-    uint32_t C_save = C;
-    uint32_t D_save = D;
 # if MD5_SMALL == 1
     const uint32_t *pc;
 …
 # endif
     /* Add checksum to the starting values */
     ctx->hash[0] = A_save + A;
     ctx->hash[1] = B_save + B;
     ctx->hash[2] = C_save + C;
     ctx->hash[3] = D_save + D;
+    ctx->hash[0] += A;
+    ctx->hash[1] += B;
+    ctx->hash[2] += C;
+    ctx->hash[3] += D;
 #endif
+}
 …
             t = ctx->total64[0] << 3;
             t = SWAP_BE64(t);
             *(uint64_t *) (&ctx->wbuffer[128 - 8]) = t;
+            *(bb__aliased_uint64_t *) (&ctx->wbuffer[128 - 8]) = t;
             t = (ctx->total64[1] << 3) | (ctx->total64[0] >> 61);
             t = SWAP_BE64(t);
             *(uint64_t *) (&ctx->wbuffer[128 - 16]) = t;
+            *(bb__aliased_uint64_t *) (&ctx->wbuffer[128 - 16]) = t;
+        }
         sha512_process_block128(ctx);
 …
 #endif
+#define OPTIMIZE_SHA3_FOR_32 0
+/*
+ * SHA3 can be optimized for 32-bit CPUs with bit-slicing:
+ * every 64-bit word of state[] can be split into two 32-bit words
+ * by even/odd bits. In this form, all rotations of sha3 round
+ * are 32-bit - and there are lots of them.
+ * However, it requires either splitting/combining state words
+ * before/after sha3 round (code does this now)
+ * or shuffling bits before xor'ing them into state and in sha3_end.
+ * Without shuffling, bit-slicing results in -130 bytes of code
+ * and marginal speedup (but of course it gives wrong result).
+ * With shuffling it works, but +260 code bytes, and slower.
+ * Disabled for now:
+ */
+#if 0 /* LONG_MAX == 0x7fffffff */
+# undef OPTIMIZE_SHA3_FOR_32
+# define OPTIMIZE_SHA3_FOR_32 1
+#endif
 enum {
     SHA3_IBLK_BYTES = 72, /* 576 bits / 8 */
 };
+#if OPTIMIZE_SHA3_FOR_32
+/* This splits every 64-bit word into a pair of 32-bit words,
+ * even bits go into first word, odd bits go to second one.
+ * The conversion is done in-place.
+ */
+static void split_halves(uint64_t *state)
+{
+    /* Credit: Henry S. Warren, Hacker's Delight, Addison-Wesley, 2002 */
+    uint32_t *s32 = (uint32_t*)state;
+    uint32_t t, x0, x1;
+    int i;
+    for (i = 24; i >= 0; --i) {
+        x0 = s32[0];
+        t = (x0 ^ (x0 >> 1)) & 0x22222222; x0 = x0 ^ t ^ (t << 1);
+        t = (x0 ^ (x0 >> 2)) & 0x0C0C0C0C; x0 = x0 ^ t ^ (t << 2);
+        t = (x0 ^ (x0 >> 4)) & 0x00F000F0; x0 = x0 ^ t ^ (t << 4);
+        t = (x0 ^ (x0 >> 8)) & 0x0000FF00; x0 = x0 ^ t ^ (t << 8);
+        x1 = s32[1];
+        t = (x1 ^ (x1 >> 1)) & 0x22222222; x1 = x1 ^ t ^ (t << 1);
+        t = (x1 ^ (x1 >> 2)) & 0x0C0C0C0C; x1 = x1 ^ t ^ (t << 2);
+        t = (x1 ^ (x1 >> 4)) & 0x00F000F0; x1 = x1 ^ t ^ (t << 4);
+        t = (x1 ^ (x1 >> 8)) & 0x0000FF00; x1 = x1 ^ t ^ (t << 8);
+        *s32++ = (x0 & 0x0000FFFF) | (x1 << 16);
+        *s32++ = (x0 >> 16) | (x1 & 0xFFFF0000);
+    }
+}
+/* The reverse operation */
+static void combine_halves(uint64_t *state)
+{
+    uint32_t *s32 = (uint32_t*)state;
+    uint32_t t, x0, x1;
+    int i;
+    for (i = 24; i >= 0; --i) {
+        x0 = s32[0];
+        x1 = s32[1];
+        t = (x0 & 0x0000FFFF) | (x1 << 16);
+        x1 = (x0 >> 16) | (x1 & 0xFFFF0000);
+        x0 = t;
+        t = (x0 ^ (x0 >> 8)) & 0x0000FF00; x0 = x0 ^ t ^ (t << 8);
+        t = (x0 ^ (x0 >> 4)) & 0x00F000F0; x0 = x0 ^ t ^ (t << 4);
+        t = (x0 ^ (x0 >> 2)) & 0x0C0C0C0C; x0 = x0 ^ t ^ (t << 2);
+        t = (x0 ^ (x0 >> 1)) & 0x22222222; x0 = x0 ^ t ^ (t << 1);
+        *s32++ = x0;
+        t = (x1 ^ (x1 >> 8)) & 0x0000FF00; x1 = x1 ^ t ^ (t << 8);
+        t = (x1 ^ (x1 >> 4)) & 0x00F000F0; x1 = x1 ^ t ^ (t << 4);
+        t = (x1 ^ (x1 >> 2)) & 0x0C0C0C0C; x1 = x1 ^ t ^ (t << 2);
+        t = (x1 ^ (x1 >> 1)) & 0x22222222; x1 = x1 ^ t ^ (t << 1);
+        *s32++ = x1;
+    }
+}
+#endif
 /*
 …
     enum { NROUNDS = 24 };
+    /* Elements should be 64-bit, but top half is always zero or 0x80000000.
+     * We encode 63rd bits in a separate word below.
+     * Same is true for 31th bits, which lets us use 16-bit table instead of 64-bit.
+     * The speed penalty is lost in the noise.
+     */
+#if OPTIMIZE_SHA3_FOR_32
+    /*
+    static const uint32_t IOTA_CONST_0[NROUNDS] = {
+x00000001UL,
+x00000000UL,
+x00000000UL,
+x00000000UL,
+x00000001UL,
+x00000001UL,
+x00000001UL,
+x00000001UL,
+x00000000UL,
+x00000000UL,
+x00000001UL,
+x00000000UL,
+x00000001UL,
+x00000001UL,
+x00000001UL,
+x00000001UL,
+x00000000UL,
+x00000000UL,
+x00000000UL,
+x00000000UL,
+x00000001UL,
+x00000000UL,
+x00000001UL,
+x00000000UL,
+    };
+    ** bits are in lsb: 0101 0000 1111 0100 1111 0001
+    */
+    uint32_t IOTA_CONST_0bits = (uint32_t)(0x0050f4f1);
+    static const uint32_t IOTA_CONST_1[NROUNDS] = {
+x00000000UL,
+x00000089UL,
+x8000008bUL,
+x80008080UL,
+x0000008bUL,
+x00008000UL,
+x80008088UL,
+x80000082UL,
+x0000000bUL,
+x0000000aUL,
+x00008082UL,
+x00008003UL,
+x0000808bUL,
+x8000000bUL,
+x8000008aUL,
+x80000081UL,
+x80000081UL,
+x80000008UL,
+x00000083UL,
+x80008003UL,
+x80008088UL,
+x80000088UL,
+x00008000UL,
+x80008082UL,
+    };
+    uint32_t *const s32 = (uint32_t*)state;
+    unsigned round;
+    split_halves(state);
+    for (round = 0; round < NROUNDS; round++) {
+        unsigned x;
+        /* Theta */
+        {
+            uint32_t BC[20];
+            for (x = 0; x < 10; ++x) {
+                BC[x+10] = BC[x] = s32[x]^s32[x+10]^s32[x+20]^s32[x+30]^s32[x+40];
+            }
+            for (x = 0; x < 10; x += 2) {
+                uint32_t ta, tb;
+                ta = BC[x+8] ^ rotl32(BC[x+3], 1);
+                tb = BC[x+9] ^ BC[x+2];
+                s32[x+0] ^= ta;
+                s32[x+1] ^= tb;
+                s32[x+10] ^= ta;
+                s32[x+11] ^= tb;
+                s32[x+20] ^= ta;
+                s32[x+21] ^= tb;
+                s32[x+30] ^= ta;
+                s32[x+31] ^= tb;
+                s32[x+40] ^= ta;
+                s32[x+41] ^= tb;
+            }
+        }
+        /* RhoPi */
+        {
+            uint32_t t0a,t0b, t1a,t1b;
+            t1a = s32[1*2+0];
+            t1b = s32[1*2+1];
+#define RhoPi(PI_LANE, ROT_CONST) \
+    t0a = s32[PI_LANE*2+0];\
+    t0b = s32[PI_LANE*2+1];\
+    if (ROT_CONST & 1) {\
+        s32[PI_LANE*2+0] = rotl32(t1b, ROT_CONST/2+1);\
+        s32[PI_LANE*2+1] = ROT_CONST == 1 ? t1a : rotl32(t1a, ROT_CONST/2+0);\
+    } else {\
+        s32[PI_LANE*2+0] = rotl32(t1a, ROT_CONST/2);\
+        s32[PI_LANE*2+1] = rotl32(t1b, ROT_CONST/2);\
+    }\
+    t1a = t0a; t1b = t0b;
+            RhoPi(10, 1)
+            RhoPi( 7, 3)
+            RhoPi(11, 6)
+            RhoPi(17,10)
+            RhoPi(18,15)
+            RhoPi( 3,21)
+            RhoPi( 5,28)
+            RhoPi(16,36)
+            RhoPi( 8,45)
+            RhoPi(21,55)
+            RhoPi(24, 2)
+            RhoPi( 4,14)
+            RhoPi(15,27)
+            RhoPi(23,41)
+            RhoPi(19,56)
+            RhoPi(13, 8)
+            RhoPi(12,25)
+            RhoPi( 2,43)
+            RhoPi(20,62)
+            RhoPi(14,18)
+            RhoPi(22,39)
+            RhoPi( 9,61)
+            RhoPi( 6,20)
+            RhoPi( 1,44)
+#undef RhoPi
+        }
+        /* Chi */
+        for (x = 0; x <= 40;) {
+            uint32_t BC0, BC1, BC2, BC3, BC4;
+            BC0 = s32[x + 0*2];
+            BC1 = s32[x + 1*2];
+            BC2 = s32[x + 2*2];
+            s32[x + 0*2] = BC0 ^ ((~BC1) & BC2);
+            BC3 = s32[x + 3*2];
+            s32[x + 1*2] = BC1 ^ ((~BC2) & BC3);
+            BC4 = s32[x + 4*2];
+            s32[x + 2*2] = BC2 ^ ((~BC3) & BC4);
+            s32[x + 3*2] = BC3 ^ ((~BC4) & BC0);
+            s32[x + 4*2] = BC4 ^ ((~BC0) & BC1);
+            x++;
+            BC0 = s32[x + 0*2];
+            BC1 = s32[x + 1*2];
+            BC2 = s32[x + 2*2];
+            s32[x + 0*2] = BC0 ^ ((~BC1) & BC2);
+            BC3 = s32[x + 3*2];
+            s32[x + 1*2] = BC1 ^ ((~BC2) & BC3);
+            BC4 = s32[x + 4*2];
+            s32[x + 2*2] = BC2 ^ ((~BC3) & BC4);
+            s32[x + 3*2] = BC3 ^ ((~BC4) & BC0);
+            s32[x + 4*2] = BC4 ^ ((~BC0) & BC1);
+            x += 9;
+        }
+        /* Iota */
+        s32[0] ^= IOTA_CONST_0bits & 1;
+        IOTA_CONST_0bits >>= 1;
+        s32[1] ^= IOTA_CONST_1[round];
+    }
+    combine_halves(state);
+#else
+    /* Native 64-bit algorithm */
     static const uint16_t IOTA_CONST[NROUNDS] = {
+        /* Elements should be 64-bit, but top half is always zero
+         * or 0x80000000. We encode 63rd bits in a separate word below.
+         * Same is true for 31th bits, which lets us use 16-bit table
+         * instead of 64-bit. The speed penalty is lost in the noise.
+         */
 x0001,
 x8082,
 …
     /*static const uint8_t MOD5[10] = { 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, };*/
     unsigned x, y;
+    unsigned x;
     unsigned round;
 …
 #undef RhoPi_twice
+        }
         /* Chi */
+        for (y = 0; y <= 20; y += 5) {
+# if LONG_MAX > 0x7fffffff
+        for (x = 0; x <= 20; x += 5) {
             uint64_t BC0, BC1, BC2, BC3, BC4;
             BC0 = state[y + 0];
             BC1 = state[y + 1];
             BC2 = state[y + 2];
             state[y + 0] = BC0 ^ ((~BC1) & BC2);
             BC3 = state[y + 3];
             state[y + 1] = BC1 ^ ((~BC2) & BC3);
             BC4 = state[y + 4];
             state[y + 2] = BC2 ^ ((~BC3) & BC4);
             state[y + 3] = BC3 ^ ((~BC4) & BC0);
             state[y + 4] = BC4 ^ ((~BC0) & BC1);
+            BC0 = state[x + 0];
+            BC1 = state[x + 1];
+            BC2 = state[x + 2];
+            state[x + 0] = BC0 ^ ((~BC1) & BC2);
+            BC3 = state[x + 3];
+            state[x + 1] = BC1 ^ ((~BC2) & BC3);
+            BC4 = state[x + 4];
+            state[x + 2] = BC2 ^ ((~BC3) & BC4);
+            state[x + 3] = BC3 ^ ((~BC4) & BC0);
+            state[x + 4] = BC4 ^ ((~BC0) & BC1);
+        }
+# else
+        /* Reduced register pressure version
+         * for register-starved 32-bit arches
+         * (i386: -95 bytes, and it is _faster_)
+         */
+        for (x = 0; x <= 40;) {
+            uint32_t BC0, BC1, BC2, BC3, BC4;
+            uint32_t *const s32 = (uint32_t*)state;
+#  if SHA3_SMALL
+ do_half:
+#  endif
+            BC0 = s32[x + 0*2];
+            BC1 = s32[x + 1*2];
+            BC2 = s32[x + 2*2];
+            s32[x + 0*2] = BC0 ^ ((~BC1) & BC2);
+            BC3 = s32[x + 3*2];
+            s32[x + 1*2] = BC1 ^ ((~BC2) & BC3);
+            BC4 = s32[x + 4*2];
+            s32[x + 2*2] = BC2 ^ ((~BC3) & BC4);
+            s32[x + 3*2] = BC3 ^ ((~BC4) & BC0);
+            s32[x + 4*2] = BC4 ^ ((~BC0) & BC1);
+            x++;
+#  if SHA3_SMALL
+            if (x & 1)
+                goto do_half;
+            x += 8;
+#  else
+            BC0 = s32[x + 0*2];
+            BC1 = s32[x + 1*2];
+            BC2 = s32[x + 2*2];
+            s32[x + 0*2] = BC0 ^ ((~BC1) & BC2);
+            BC3 = s32[x + 3*2];
+            s32[x + 1*2] = BC1 ^ ((~BC2) & BC3);
+            BC4 = s32[x + 4*2];
+            s32[x + 2*2] = BC2 ^ ((~BC3) & BC4);
+            s32[x + 3*2] = BC3 ^ ((~BC4) & BC0);
+            s32[x + 4*2] = BC4 ^ ((~BC0) & BC1);
+            x += 9;
+#  endif
+        }
+# endif /* long is 32-bit */
         /* Iota */
         state[0] ^= IOTA_CONST[round]
 …
+        }
+    }
+#endif
+}

branches/3.3/mindi-busybox/libbb/human_readable.c

-              r2725
+              r3621
  *      The base ten "bytes" output could be handled similarly.
+ *
  *   2) This routine always outputs a decimal point and a tenths digit when
  *      display_unit != 0.  Hence, it isn't uncommon for the returned string
+ *   2) This routine outputs a decimal point and a tenths digit when
+ *      display_unit == 0.  Hence, it isn't uncommon for the returned string
  *      to have a length of 5 or 6.
+ *
+ *      It might be nice to add a flag to indicate no decimal digits in
+ *      that case.  This could be either an additional parameter, or a
+ *      special value of display_unit.  Such a flag would also be nice for du.
+ *
+ *      Some code to omit the decimal point and tenths digit is sketched out
+ *      and "#if 0"'d below.
+ *      If block_size is also 0, no decimal digits are printed.
+ *
  * Licensed under GPLv2, see file LICENSE in this source tree.
 …
         '\0', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'
     };
-    static char *str;
     unsigned frac; /* 0..9 - the fractional digit */
 …
+    }
+    if (!str) {
+        /* sufficient for any width of val */
+        str = xmalloc(sizeof(val)*3 + 2 + 3);
+    }
+    sprintf(str, fmt, val, frac, *u);
+    return str;
+    return auto_string(xasprintf(fmt, val, frac, *u));
+}
 …
 /* Convert unsigned long long value into compact 5-char representation.
  * String is not terminated (buf[5] is untouched) */
 void FAST_FUNC smart_ulltoa5(unsigned long long ul, char buf[5], const char *scale)
+char* FAST_FUNC smart_ulltoa5(unsigned long long ul, char buf[5], const char *scale)
+{
     const char *fmt;
 …
         buf[4] = scale[idx]; /* typically scale = " kmgt..." */
+    }
+    return buf + 5;
+}
 …
  * representation. Examples: "1234", "1.2k", " 27M", "123T"
  * String is not terminated (buf[4] is untouched) */
 void FAST_FUNC smart_ulltoa4(unsigned long long ul, char buf[4], const char *scale)
+char* FAST_FUNC smart_ulltoa4(unsigned long long ul, char buf[4], const char *scale)
+{
     const char *fmt;
 …
         buf[3] = scale[idx]; /* typically scale = " kmgt..." */
+    }
+    return buf + 4;
+}

branches/3.3/mindi-busybox/libbb/inet_common.c

-              r3232
+              r3621
+    }
     /* If we expect this to be a hostname, try hostname database first */
-#ifdef DEBUG
     if (hostfirst) {
+#ifdef DEBUG
         bb_error_msg("gethostbyname(%s)", name);
+    }
+#endif
+    if (hostfirst) {
+#endif
         hp = gethostbyname(name);
         if (hp != NULL) {
+        if (hp) {
             memcpy(&s_in->sin_addr, hp->h_addr_list[0],
                 sizeof(struct in_addr));
 …
 #endif
     np = getnetbyname(name);
     if (np != NULL) {
+    if (np) {
         s_in->sin_addr.s_addr = htonl(np->n_net);
         return 1;
 …
 #endif
     hp = gethostbyname(name);
     if (hp == NULL) {
+    if (!hp) {
         return -1;
+    }
 …
 /* numeric: & 0x8000: default instead of *,
+/* numeric: & 0x8000: "default" instead of "*",
  *          & 0x4000: host instead of net,
  *          & 0x0fff: don't resolve
 …
     struct addr {
         struct addr *next;
         struct sockaddr_in addr;
         int host;
+        uint32_t nip;
+        smallint is_host;
         char name[1];
     };
 …
     struct addr *pn;
     char *name;
     uint32_t ad, host_ad;
     int host = 0;
+    uint32_t nip;
+    smallint is_host;
     if (s_in->sin_family != AF_INET) {
 …
         return NULL;
+    }
+    ad = s_in->sin_addr.s_addr;
+#ifdef DEBUG
+    bb_error_msg("rresolve: %08x, mask %08x, num %08x", (unsigned)ad, netmask, numeric);
+#endif
+    if (ad == INADDR_ANY) {
+        if ((numeric & 0x0FFF) == 0) {
+            if (numeric & 0x8000)
+                return xstrdup("default");
+            return xstrdup("*");
+        }
+    }
+    nip = s_in->sin_addr.s_addr;
+#ifdef DEBUG
+    bb_error_msg("rresolve: %08x mask:%08x num:%08x", (unsigned)nip, netmask, numeric);
+#endif
     if (numeric & 0x0FFF)
+        return xstrdup(inet_ntoa(s_in->sin_addr));
+    if ((ad & (~netmask)) != 0 || (numeric & 0x4000))
+        host = 1;
+        return xmalloc_sockaddr2dotted_noport((void*)s_in);
+    if (nip == INADDR_ANY) {
+        if (numeric & 0x8000)
+            return xstrdup("default");
+        return xstrdup("*");
+    }
+    is_host = ((nip & (~netmask)) != 0 || (numeric & 0x4000));
     pn = cache;
     while (pn) {
         if (pn->addr.sin_addr.s_addr == ad && pn->host == host) {
+        if (pn->nip == nip && pn->is_host == is_host) {
 #ifdef DEBUG
             bb_error_msg("rresolve: found %s %08x in cache",
                       (host ? "host" : "net"), (unsigned)ad);
+                (is_host ? "host" : "net"), (unsigned)nip);
 #endif
             return xstrdup(pn->name);
 …
+    }
-    host_ad = ntohl(ad);
     name = NULL;
+    if (host) {
+        struct hostent *ent;
+#ifdef DEBUG
+        bb_error_msg("gethostbyaddr (%08x)", (unsigned)ad);
+#endif
+        ent = gethostbyaddr((char *) &ad, 4, AF_INET);
+        if (ent)
+            name = xstrdup(ent->h_name);
+    if (is_host) {
+#ifdef DEBUG
+        bb_error_msg("sockaddr2host_noport(%08x)", (unsigned)nip);
+#endif
+        name = xmalloc_sockaddr2host_noport((void*)s_in);
     } else if (ENABLE_FEATURE_ETC_NETWORKS) {
         struct netent *np;
 #ifdef DEBUG
         bb_error_msg("getnetbyaddr (%08x)", (unsigned)host_ad);
 #endif
         np = getnetbyaddr(host_ad, AF_INET);
+        bb_error_msg("getnetbyaddr(%08x)", (unsigned)ntohl(nip));
+#endif
+        np = getnetbyaddr(ntohl(nip), AF_INET);
         if (np)
             name = xstrdup(np->n_name);
+    }
     if (!name)
+        name = xstrdup(inet_ntoa(s_in->sin_addr));
+        name = xmalloc_sockaddr2dotted_noport((void*)s_in);
     pn = xmalloc(sizeof(*pn) + strlen(name)); /* no '+ 1', it's already accounted for */
     pn->next = cache;
     pn->addr = *s_in;
     pn->host = host;
+    pn->nip = nip;
+    pn->is_host = is_host;
     strcpy(pn->name, name);
     cache = pn;
     return name;
+}
 …
+    }
     memcpy(sin6, ai->ai_addr, sizeof(*sin6));
+    if (ai)
+        freeaddrinfo(ai);
+    freeaddrinfo(ai);
     return 0;
+}
 …
 char* FAST_FUNC INET6_rresolve(struct sockaddr_in6 *sin6, int numeric)
+{
-    char name[128];
-    int s;
     if (sin6->sin6_family != AF_INET6) {
 #ifdef DEBUG
 …
+    }
     if (numeric & 0x7FFF) {
+        inet_ntop(AF_INET6, &sin6->sin6_addr, name, sizeof(name));
+        return xstrdup(name);
+        return xmalloc_sockaddr2dotted_noport((void*)sin6);
+    }
     if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
 …
+    }
+    s = getnameinfo((struct sockaddr *) sin6, sizeof(*sin6),
+                name, sizeof(name),
+                /*serv,servlen:*/ NULL, 0,
+);
+    if (s != 0) {
+        bb_error_msg("getnameinfo failed");
+        return NULL;
+    }
+    return xstrdup(name);
+    return xmalloc_sockaddr2host_noport((void*)sin6);
+}

branches/3.3/mindi-busybox/libbb/inode_hash.c

-              r2725
+              r3621
 typedef struct ino_dev_hash_bucket_struct {
-    struct ino_dev_hash_bucket_struct *next;
     ino_t ino;
     dev_t dev;
+    /*
+     * Above fields can be 64-bit, while pointer may be 32-bit.
+     * Putting "next" field here may reduce size of this struct:
+     */
+    struct ino_dev_hash_bucket_struct *next;
+    /*
+     * Reportedly, on cramfs a file and a dir can have same ino.
+     * Need to also remember "file/dir" bit:
+     */
+    char isdir; /* bool */
     char name[1];
 } ino_dev_hashtable_bucket_t;
 #define HASH_SIZE      311   /* Should be prime */
 #define hash_inode(i)  ((i) % HASH_SIZE)
+#define HASH_SIZE      311u   /* Should be prime */
+#define hash_inode(i)  ((unsigned)(i) % HASH_SIZE)
 /* array of [HASH_SIZE] elements */
 …
         if ((bucket->ino == statbuf->st_ino)
          && (bucket->dev == statbuf->st_dev)
+         && (bucket->isdir == !!S_ISDIR(statbuf->st_mode))
         ) {
             return bucket->name;
 …
     ino_dev_hashtable_bucket_t *bucket;
-    i = hash_inode(statbuf->st_ino);
     if (!name)
         name = "";
 …
     bucket->ino = statbuf->st_ino;
     bucket->dev = statbuf->st_dev;
+    bucket->isdir = !!S_ISDIR(statbuf->st_mode);
     strcpy(bucket->name, name);
 …
         ino_dev_hashtable = xzalloc(HASH_SIZE * sizeof(*ino_dev_hashtable));
+    i = hash_inode(statbuf->st_ino);
     bucket->next = ino_dev_hashtable[i];
     ino_dev_hashtable[i] = bucket;
 …
+{
     int i;
     ino_dev_hashtable_bucket_t *bucket;
+    ino_dev_hashtable_bucket_t *bucket, *next;
+    for (i = 0; ino_dev_hashtable && i < HASH_SIZE; i++) {
+        while (ino_dev_hashtable[i] != NULL) {
+            bucket = ino_dev_hashtable[i]->next;
+            free(ino_dev_hashtable[i]);
+            ino_dev_hashtable[i] = bucket;
+    if (!ino_dev_hashtable)
+        return;
+    for (i = 0; i < HASH_SIZE; i++) {
+        bucket = ino_dev_hashtable[i];
+        while (bucket != NULL) {
+            next = bucket->next;
+            free(bucket);
+            bucket = next;
+        }
+    }

branches/3.3/mindi-busybox/libbb/kernel_version.c

-              r3232
+              r3621
+{
     struct utsname name;
     char *s, *t;
+    char *t;
     int i, r;
     uname(&name); /* never fails */
     s = name.release;
+    t = name.release;
     r = 0;
     for (i = 0; i < 3; i++) {
         t = strtok(s, ".");
+        t = strtok(t, ".");
         r = r * 256 + (t ? atoi(t) : 0);
         s = NULL;
+        t = NULL;
+    }
     return r;

branches/3.3/mindi-busybox/libbb/lineedit.c

-              r3232
+              r3621
+ *
  * PS1='\[\033[01;32m\]\u@\h\[\033[01;34m\] \w \$\[\033[00m\] '
+ *
+ * Unicode in PS1 is not fully supported: prompt length calulation is wrong,
+ * resulting in line wrap problems with long (multi-line) input.
+ *
+ * Multi-line PS1 (e.g. PS1="\n[\w]\n$ ") has problems with history
+ * browsing: up/down arrows result in scrolling.
+ * It stems from simplistic "cmdedit_y = cmdedit_prmt_len / cmdedit_termw"
+ * calculation of how many lines the prompt takes.
  */
+#include "libbb.h"
+#include "busybox.h"
+#include "NUM_APPLETS.h"
 #include "unicode.h"
 #ifndef _POSIX_VDISABLE
 …
     const char *cmdedit_prompt;
-#if ENABLE_FEATURE_EDITING_FANCY_PROMPT
-    int num_ok_lines; /* = 1; */
-#endif
 #if ENABLE_USERNAME_OR_HOMEDIR
 …
 #define command_ps       (S.command_ps      )
 #define cmdedit_prompt   (S.cmdedit_prompt  )
-#define num_ok_lines     (S.num_ok_lines    )
 #define user_buf         (S.user_buf        )
 #define home_pwd_buf     (S.home_pwd_buf    )
 …
     barrier(); \
     cmdedit_termw = 80; \
-    IF_FEATURE_EDITING_FANCY_PROMPT(num_ok_lines = 1;) \
     IF_USERNAME_OR_HOMEDIR(home_pwd_buf = (char*)null_str;) \
+    IF_FEATURE_EDITING_VI(delptr = delbuf;) \
 } while (0)
 …
 static NOINLINE unsigned complete_username(const char *ud)
+{
+    /* Using _r function to avoid pulling in static buffers */
+    char line_buff[256];
+    struct passwd pwd;
+    struct passwd *result;
+    struct passwd *pw;
     unsigned userlen;
 …
     setpwent();
     while (!getpwent_r(&pwd, line_buff, sizeof(line_buff), &result)) {
+    while ((pw = getpwent()) != NULL) {
         /* Null usernames should result in all users as possible completions. */
         if (/*!userlen || */ strncmp(ud, pwd.pw_name, userlen) == 0) {
             add_match(xasprintf("~%s/", pwd.pw_name));
+        }
+    }
     endpwent();
+        if (/* !ud[0] || */ is_prefixed_with(pw->pw_name, ud)) {
+            add_match(xasprintf("~%s/", pw->pw_name));
+        }
+    }
+    endpwent(); /* don't keep password file open */
     return 1 + userlen;
 …
     pf_len = strlen(pfind);
+#if ENABLE_FEATURE_SH_STANDALONE && NUM_APPLETS != 1
+    if (type == FIND_EXE_ONLY) {
+        const char *p = applet_names;
+        while (*p) {
+            if (strncmp(pfind, p, pf_len) == 0)
+                add_match(xstrdup(p));
+            while (*p++ != '\0')
+                continue;
+        }
+    }
+#endif
     for (i = 0; i < npaths; i++) {
         DIR *dir;
 …
                 continue;
             /* match? */
             if (strncmp(name_found, pfind, pf_len) != 0)
+            if (!is_prefixed_with(name_found, pfind))
                 continue; /* no */
 …
     line_input_t *n = xzalloc(sizeof(*n));
     n->flags = flags;
+#if MAX_HISTORY > 0
     n->max_history = MAX_HISTORY;
+#endif
     return n;
+}
 …
 #if MAX_HISTORY > 0
 unsigned size_from_HISTFILESIZE(const char *hp)
+unsigned FAST_FUNC size_from_HISTFILESIZE(const char *hp)
+{
     int size = MAX_HISTORY;
 …
     beep();
     return 0;
+}
+/* Lists command history. Used by shell 'history' builtins */
+void FAST_FUNC show_history(const line_input_t *st)
+{
+    int i;
+    if (!st)
+        return;
+    for (i = 0; i < st->cnt_history; i++)
+        printf("%4d %s\n", i, st->history[i]);
+}
 …
     save_history(str);
 # endif
-    IF_FEATURE_EDITING_FANCY_PROMPT(num_ok_lines++;)
+}
 …
 #endif
+/* Called just once at read_line_input() init time */
 #if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
 static void parse_and_put_prompt(const char *prmt_ptr)
+{
+    const char *p;
     cmdedit_prompt = prmt_ptr;
+    cmdedit_prmt_len = strlen(prmt_ptr);
+    p = strrchr(prmt_ptr, '\n');
+    cmdedit_prmt_len = unicode_strwidth(p ? p+1 : prmt_ptr);
     put_prompt();
+}
 …
 static void parse_and_put_prompt(const char *prmt_ptr)
+{
+    int prmt_len = 0;
+    size_t cur_prmt_len = 0;
+    int prmt_size = 0;
+    char *prmt_mem_ptr = xzalloc(1);
+# if ENABLE_USERNAME_OR_HOMEDIR
+    char *cwd_buf = NULL;
+# endif
     char flg_not_length = '[';
-    char *prmt_mem_ptr = xzalloc(1);
-    char *cwd_buf = xrealloc_getcwd_or_warn(NULL);
     char cbuf[2];
+    char c;
+    char *pbuf;
+    cmdedit_prmt_len = 0;
+    if (!cwd_buf) {
+        cwd_buf = (char *)bb_msg_unknown;
+    }
+    /*cmdedit_prmt_len = 0; - already is */
     cbuf[1] = '\0'; /* never changes */
     while (*prmt_ptr) {
+        char timebuf[sizeof("HH:MM:SS")];
         char *free_me = NULL;
+        char *pbuf;
+        char c;
         pbuf = cbuf;
         c = *prmt_ptr++;
         if (c == '\\') {
             const char *cp = prmt_ptr;
+            const char *cp;
             int l;
+            c = bb_process_escape_sequence(&prmt_ptr);
+/*
+ * Supported via bb_process_escape_sequence:
+ * \a   ASCII bell character (07)
+ * \e   ASCII escape character (033)
+ * \n   newline
+ * \r   carriage return
+ * \\   backslash
+ * \nnn char with octal code nnn
+ * Supported:
+ * \$   if the effective UID is 0, a #, otherwise a $
+ * \w   current working directory, with $HOME abbreviated with a tilde
+ *  Note: we do not support $PROMPT_DIRTRIM=n feature
+ * \W   basename of the current working directory, with $HOME abbreviated with a tilde
+ * \h   hostname up to the first '.'
+ * \H   hostname
+ * \u   username
+ * \[   begin a sequence of non-printing characters
+ * \]   end a sequence of non-printing characters
+ * \T   current time in 12-hour HH:MM:SS format
+ * \@   current time in 12-hour am/pm format
+ * \A   current time in 24-hour HH:MM format
+ * \t   current time in 24-hour HH:MM:SS format
+ *  (all of the above work as \A)
+ * Not supported:
+ * \!   history number of this command
+ * \#   command number of this command
+ * \j   number of jobs currently managed by the shell
+ * \l   basename of the shell's terminal device name
+ * \s   name of the shell, the basename of $0 (the portion following the final slash)
+ * \V   release of bash, version + patch level (e.g., 2.00.0)
+ * \d   date in "Weekday Month Date" format (e.g., "Tue May 26")
+ * \D{format}
+ *  format is passed to strftime(3).
+ *  An empty format results in a locale-specific time representation.
+ *  The braces are required.
+ * Mishandled by bb_process_escape_sequence:
+ * \v   version of bash (e.g., 2.00)
+ */
+            cp = prmt_ptr;
+            c = *cp;
+            if (c != 't') /* don't treat \t as tab */
+                c = bb_process_escape_sequence(&prmt_ptr);
             if (prmt_ptr == cp) {
                 if (*cp == '\0')
 …
                     break;
 # endif
+                case 'H':
                 case 'h':
                     pbuf = free_me = safe_gethostname();
+                    *strchrnul(pbuf, '.') = '\0';
+                    if (c == 'h')
+                        strchrnul(pbuf, '.')[0] = '\0';
                     break;
                 case '$':
                     c = (geteuid() == 0 ? '#' : '$');
                     break;
+                case 'T': /* 12-hour HH:MM:SS format */
+                case '@': /* 12-hour am/pm format */
+                case 'A': /* 24-hour HH:MM format */
+                case 't': /* 24-hour HH:MM:SS format */
+                    /* We show all of them as 24-hour HH:MM */
+                    strftime_HHMMSS(timebuf, sizeof(timebuf), NULL)[-3] = '\0';
+                    pbuf = timebuf;
+                    break;
 # if ENABLE_USERNAME_OR_HOMEDIR
+                case 'w':
+                    /* /home/user[/something] -> ~[/something] */
+                case 'w': /* current dir */
+                case 'W': /* basename of cur dir */
+                    if (!cwd_buf) {
+                        cwd_buf = xrealloc_getcwd_or_warn(NULL);
+                        if (!cwd_buf)
+                            cwd_buf = (char *)bb_msg_unknown;
+                        else if (home_pwd_buf[0]) {
+                            char *after_home_user;
+                            /* /home/user[/something] -> ~[/something] */
+                            after_home_user = is_prefixed_with(cwd_buf, home_pwd_buf);
+                            if (after_home_user
+                             && (*after_home_user == '/' || *after_home_user == '\0')
+                            ) {
+                                cwd_buf[0] = '~';
+                                overlapping_strcpy(cwd_buf + 1, after_home_user);
+                            }
+                        }
+                    }
                     pbuf = cwd_buf;
+                    l = strlen(home_pwd_buf);
+                    if (l != 0
+                     && strncmp(home_pwd_buf, cwd_buf, l) == 0
+                     && (cwd_buf[l]=='/' || cwd_buf[l]=='\0')
+                     && strlen(cwd_buf + l) < PATH_MAX
+                    ) {
+                        pbuf = free_me = xasprintf("~%s", cwd_buf + l);
+                    }
+                    if (c == 'w')
+                        break;
+                    cp = strrchr(pbuf, '/');
+                    if (cp)
+                        pbuf = (char*)cp + 1;
                     break;
 # endif
+                case 'W':
+                    pbuf = cwd_buf;
+                    cp = strrchr(pbuf, '/');
+                    if (cp != NULL && cp != pbuf)
+                        pbuf += (cp-pbuf) + 1;
+                    break;
+                case '!':
+                    pbuf = free_me = xasprintf("%d", num_ok_lines);
+                    break;
+                case 'e': case 'E':     /* \e \E = \033 */
+                    c = '\033';
+                    break;
+// bb_process_escape_sequence does this now:
+//              case 'e': case 'E':     /* \e \E = \033 */
+//                  c = '\033';
+//                  break;
                 case 'x': case 'X': {
                     char buf2[4];
 …
                 case '[': case ']':
                     if (c == flg_not_length) {
+                        flg_not_length = (flg_not_length == '[' ? ']' : '[');
+                        /* Toggle '['/']' hex 5b/5d */
+                        flg_not_length ^= 6;
                         continue;
+                    }
 …
         } /* if */
         cbuf[0] = c;
+        cur_prmt_len = strlen(pbuf);
+        prmt_len += cur_prmt_len;
+        if (flg_not_length != ']')
+            cmdedit_prmt_len += cur_prmt_len;
+        prmt_mem_ptr = strcat(xrealloc(prmt_mem_ptr, prmt_len+1), pbuf);
+        {
+            int n = strlen(pbuf);
+            prmt_size += n;
+            if (c == '\n')
+                cmdedit_prmt_len = 0;
+            else if (flg_not_length != ']') {
+#if 0 /*ENABLE_UNICODE_SUPPORT*/
+/* Won't work, pbuf is one BYTE string here instead of an one Unicode char string. */
+/* FIXME */
+                cmdedit_prmt_len += unicode_strwidth(pbuf);
+#else
+                cmdedit_prmt_len += n;
+#endif
+            }
+        }
+        prmt_mem_ptr = strcat(xrealloc(prmt_mem_ptr, prmt_size+1), pbuf);
         free(free_me);
     } /* while */
+# if ENABLE_USERNAME_OR_HOMEDIR
     if (cwd_buf != (char *)bb_msg_unknown)
         free(cwd_buf);
+# endif
     cmdedit_prompt = prmt_mem_ptr;
     put_prompt();
 …
             if (cursor == 0) { /* otherwise it may be bogus */
                 int col = ((ic >> 32) & 0x7fff) - 1;
+                if (col > cmdedit_prmt_len) {
+                /*
+                 * Is col > cmdedit_prmt_len?
+                 * If yes (terminal says cursor is farther to the right
+                 * of where we think it should be),
+                 * the prompt wasn't printed starting at col 1,
+                 * there was additional text before it.
+                 */
+                if ((int)(col - cmdedit_prmt_len) > 0) {
+                    /* Fix our understanding of current x position */
                     cmdedit_x += (col - cmdedit_prmt_len);
                     while (cmdedit_x >= cmdedit_termw) {
 …
     const char *matched_history_line;
     const char *saved_prompt;
+    unsigned saved_prmt_len;
     int32_t ic;
 …
     /* Save and replace the prompt */
     saved_prompt = cmdedit_prompt;
+    saved_prmt_len = cmdedit_prmt_len;
     goto set_prompt;
 …
  set_prompt:
                     cmdedit_prompt = xasprintf("(reverse-i-search)'%s': ", match_buf);
                     cmdedit_prmt_len = strlen(cmdedit_prompt);
+                    cmdedit_prmt_len = unicode_strwidth(cmdedit_prompt);
                     goto do_redraw;
+                }
 …
     free((char*)cmdedit_prompt);
     cmdedit_prompt = saved_prompt;
     cmdedit_prmt_len = strlen(cmdedit_prompt);
+    cmdedit_prmt_len = saved_prmt_len;
     redraw(cmdedit_y, command_len - cursor);
 …
     if (tcgetattr(STDIN_FILENO, &initial_settings) < 0
      || !(initial_settings.c_lflag & ECHO)
+     || (initial_settings.c_lflag & (ECHO|ICANON)) == ICANON
     ) {
+        /* Happens when e.g. stty -echo was run before */
+        /* Happens when e.g. stty -echo was run before.
+         * But if ICANON is not set, we don't come here.
+         * (example: interactive python ^Z-backgrounded,
+         * tty is still in "raw mode").
+         */
         parse_and_put_prompt(prompt);
         /* fflush_all(); - done by parse_and_put_prompt */
 …
              * Often, Alt-<key> generates ESC-<key>.
              */
             ic = lineedit_read_key(read_key_buffer, timeout);
+            ic = lineedit_read_key(read_key_buffer, 50);
             switch (ic) {
                 //case KEYCODE_LEFT: - bash doesn't do this
 …
 #endif
     if (command_len > 0)
+    if (command_len > 0) {
         remember_in_history(command);
+    }
     if (break_out > 0) {

branches/3.3/mindi-busybox/libbb/login.c

-              r2725
+              r3621
 static const char fmtstr_d[] ALIGN1 = "%A, %d %B %Y";
-static const char fmtstr_t[] ALIGN1 = "%H:%M:%S";
 void FAST_FUNC print_login_issue(const char *issue_file, const char *tty)
 …
                 break;
             case 't':
                 strftime(buf, sizeof(buf), fmtstr_t, localtime(&t));
+                strftime_HHMMSS(buf, sizeof(buf), &t);
                 break;
             case 'l':

branches/3.3/mindi-busybox/libbb/loop.c

-              r3232
+              r3621
     /* Open the file.  Barf if this doesn't work.  */
     mode = ro ? O_RDONLY : O_RDWR;
+ open_ffd:
     ffd = open(file, mode);
     if (ffd < 0) {
         if (mode != O_RDONLY) {
             mode = O_RDONLY;
             ffd = open(file, mode);
+            goto open_ffd;
+        }
+        if (ffd < 0)
+            return -errno;
+        return -errno;
+    }
     /* Find a loop device.  */
     try = *device ? *device : dev;
     /* 1048575 is a max possible minor number in Linux circa 2010 */
+    /* 1048575 (0xfffff) is a max possible minor number in Linux circa 2010 */
     for (i = 0; rc && i < 1048576; i++) {
         sprintf(dev, LOOP_FORMAT, i);
 …
+            }
             /* Ran out of block devices, return failure.  */
             rc = -ENOENT;
+            rc = -1;
             break;
+        }
 …
             dfd = open(try, mode);
+        }
+        if (dfd < 0)
+        if (dfd < 0) {
+            if (errno == ENXIO) {
+                /* Happens if loop module is not loaded */
+                rc = -1;
+                break;
+            }
             goto try_again;
+        }
         rc = ioctl(dfd, BB_LOOP_GET_STATUS, &loopinfo);
 …
                     ioctl(dfd, LOOP_CLR_FD, 0);
+            }
+        /* If this block device already set up right, re-use it.
+         * (Yes this is racy, but associating two loop devices with the same
+         * file isn't pretty either.  In general, mounting the same file twice
+         * without using losetup manually is problematic.)
+         */
+        } else
+        if (strcmp(file, (char *)loopinfo.lo_file_name) != 0
+         || offset != loopinfo.lo_offset
+        ) {
+        } else {
             rc = -1;
+        }

branches/3.3/mindi-busybox/libbb/make_directory.c

r3232	r3621
100	100	goto ret0;
101	101	}
	102	} else {
	103	if (flags & FILEUTILS_VERBOSE) {
	104	printf("created directory: '%s'\n", path);
	105	}
102	106	}
103	107

branches/3.3/mindi-busybox/libbb/match_fstype.c

-              r3232
+              r3621
+{
     int match = 1;
-    int len;
     if (!t_fstype)
 …
+    }
-    len = strlen(mt->mnt_type);
     while (1) {
+        if (strncmp(mt->mnt_type, t_fstype, len) == 0
+         && (t_fstype[len] == '\0' || t_fstype[len] == ',')
+        char *after_mnt_type = is_prefixed_with(t_fstype, mt->mnt_type);
+        if (after_mnt_type
+         && (*after_mnt_type == '\0' || *after_mnt_type == ',')
         ) {
             return match;

branches/3.3/mindi-busybox/libbb/messages.c

-              r3232
+              r3621
 const char bb_msg_you_must_be_root[] ALIGN1 = "you must be root";
 const char bb_msg_requires_arg[] ALIGN1 = "%s requires an argument";
 const char bb_msg_invalid_arg[] ALIGN1 = "invalid argument '%s' to '%s'";
+const char bb_msg_invalid_arg_to[] ALIGN1 = "invalid argument '%s' to '%s'";
 const char bb_msg_standard_input[] ALIGN1 = "standard input";
 const char bb_msg_standard_output[] ALIGN1 = "standard output";
 …
 const int const_int_1 = 1;
+//const int const_int_1 = 1;
 /* explicitly = 0, otherwise gcc may make it a common variable
  * and it will end up in bss */
 …
 # endif
 #endif
-/* We use it for "global" data via *(struct global*)&bb_common_bufsiz1.
- * Since gcc insists on aligning struct global's members, it would be a pity
- * (and an alignment fault on some CPUs) to mess it up. */
-char bb_common_bufsiz1[COMMON_BUFSIZE] ALIGNED(sizeof(long long));

branches/3.3/mindi-busybox/libbb/mode_string.c

-              r2725
+              r3621
 /* The previous version used "0pcCd?bB-?l?s???".  However, the '0', 'C',
  * and 'B' types don't appear to be available on linux.  So I removed them. */
 static const char type_chars[16] = "?pc?d?b?-?l?s???";
+static const char type_chars[16] ALIGN1 = "?pc?d?b?-?l?s???";
 /********************************** 0123456789abcdef */
 static const char mode_chars[7] = "rwxSTst";
+static const char mode_chars[7] ALIGN1 = "rwxSTst";
 const char* FAST_FUNC bb_mode_string(mode_t mode)

branches/3.3/mindi-busybox/libbb/obscure.c

-              r3232
+              r3621
     /* clean up */
     memset(p, 0, size);
+    nuke_str(p);
     free(p);
 …
     return 0;
+}
+#if ENABLE_UNIT_TEST
+/* Test obscure_msg() instead of obscure() in order not to print anything. */
+static const struct passwd pw = {
+    .pw_name = (char *)"johndoe",
+    .pw_gecos = (char *)"John Doe",
+};
+BBUNIT_DEFINE_TEST(obscure_weak_pass)
+{
+    /* Empty password */
+    BBUNIT_ASSERT_NOTNULL(obscure_msg("Ad4#21?'S|", "", &pw));
+    /* Pure numbers */
+    BBUNIT_ASSERT_NOTNULL(obscure_msg("Ad4#21?'S|", "23577315", &pw));
+    /* Similar to pw_name */
+    BBUNIT_ASSERT_NOTNULL(obscure_msg("Ad4#21?'S|", "johndoe123%", &pw));
+    /* Similar to pw_gecos, reversed */
+    BBUNIT_ASSERT_NOTNULL(obscure_msg("Ad4#21?'S|", "eoD nhoJ^44@", &pw));
+    /* Similar to the old password */
+    BBUNIT_ASSERT_NOTNULL(obscure_msg("Ad4#21?'S|", "d4#21?'S", &pw));
+    /* adjacent letters */
+    BBUNIT_ASSERT_NOTNULL(obscure_msg("Ad4#21?'S|", "qwerty123", &pw));
+    /* Many similar chars */
+    BBUNIT_ASSERT_NOTNULL(obscure_msg("Ad4#21?'S|", "^33Daaaaaa1", &pw));
+    BBUNIT_ENDTEST;
+}
+BBUNIT_DEFINE_TEST(obscure_strong_pass)
+{
+    BBUNIT_ASSERT_NULL(obscure_msg("Rt4##2&:'|", "}(^#rrSX3S*22", &pw));
+    BBUNIT_ENDTEST;
+}
+#endif /* ENABLE_UNIT_TEST */

branches/3.3/mindi-busybox/libbb/parse_mode.c

-              r2725
+              r3621
 #define FILEMODEBITS (S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO)
 int FAST_FUNC bb_parse_mode(const char *s, mode_t *current_mode)
+int FAST_FUNC bb_parse_mode(const char *s, unsigned current_mode)
+{
     static const mode_t who_mask[] = {
 …
         tmp = strtoul(s, &e, 8);
         if (*e || (tmp > 07777U)) { /* Check range and trailing chars. */
             return 0;
+            return -1;
+        }
+        *current_mode = tmp;
+        return 1;
+        return tmp;
+    }
     new_mode = *current_mode;
+    new_mode = current_mode;
     /* Note: we allow empty clauses, and hence empty modes.
 …
                 wholist |= who_mask[(int)(p-who_chars)];
                 if (!*++s) {
                     return 0;
+                    return -1;
+                }
                 goto WHO_LIST;
 …
             if ((*s != '+') && (*s != '-')) {
                 if (*s != '=') {
                     return 0;
+                    return -1;
+                }
                 /* Since op is '=', clear all bits corresponding to the
 …
+    }
+    *current_mode = new_mode;
+    return 1;
+    return new_mode;
+}

branches/3.3/mindi-busybox/libbb/platform.c

-              r3232
+              r3621
 #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)
 …
     va_end(p);
+    /* Note: can't use xstrdup/xmalloc, they call vasprintf (us) on failure! */
     if (r < 128) {
         va_end(p2);
         *string_ptr = xstrdup(buf);
         return r;
+    }
     *string_ptr = xmalloc(r+1);
     r = vsnprintf(*string_ptr, r+1, format, p2);
+        *string_ptr = strdup(buf);
+        return (*string_ptr ? r : -1);
+    }
+    *string_ptr = malloc(r+1);
+    r = (*string_ptr ? vsnprintf(*string_ptr, r+1, format, p2) : -1);
     va_end(p2);
 …
+}
 #endif
+#ifndef HAVE_TTYNAME_R
+int ttyname_r(int fd, char *buf, size_t buflen)
+{
+    int r;
+    char path[sizeof("/proc/self/fd/%d") + sizeof(int)*3];
+    if (!isatty(fd))
+        return errno == EINVAL ? ENOTTY : errno;
+    sprintf(path, "/proc/self/fd/%d", fd);
+    r = readlink(path, buf, buflen);
+    if (r < 0)
+        return errno;
+    if (r >= buflen)
+        return ERANGE;
+    buf[r] = '\0';
+    return 0;
+}
+#endif

branches/3.3/mindi-busybox/libbb/printable.c

-              r2725
+              r3621
     fputc(ch, file);
+}
+void FAST_FUNC visible(unsigned ch, char *buf, int flags)
+{
+    if (ch == '\t' && !(flags & VISIBLE_SHOW_TABS)) {
+        goto raw;
+    }
+    if (ch == '\n') {
+        if (flags & VISIBLE_ENDLINE)
+            *buf++ = '$';
+    } else {
+        if (ch >= 128) {
+            ch -= 128;
+            *buf++ = 'M';
+            *buf++ = '-';
+        }
+        if (ch < 32 || ch == 127) {
+            *buf++ = '^';
+            ch ^= 0x40;
+        }
+    }
+ raw:
+    *buf++ = ch;
+    *buf = '\0';
+}

branches/3.3/mindi-busybox/libbb/printable_string.c

-              r2725
+              r3621
 const char* FAST_FUNC printable_string(uni_stat_t *stats, const char *str)
+{
-    static char *saved[4];
-    static unsigned cur_saved; /* = 0 */
     char *dst;
     const char *s;
 …
+    }
 #endif
+    free(saved[cur_saved]);
+    saved[cur_saved] = dst;
+    cur_saved = (cur_saved + 1) & (ARRAY_SIZE(saved)-1);
+    return dst;
+    return auto_string(dst);
+}

branches/3.3/mindi-busybox/libbb/procps.c

-              r3232
+              r3621
         // .....
         char *tp = buf, *p;
+        char *tp, *p;
 #define SCAN(S, X) \
         if (strncmp(tp, S, sizeof(S)-1) == 0) {              \
             tp = skip_whitespace(tp + sizeof(S)-1);      \
+        if ((tp = is_prefixed_with(buf, S)) != NULL) {       \
+            tp = skip_whitespace(tp);                    \
             total->X += currec.X = fast_strtoul_10(&tp); \
             continue;                                    \
 …
             tp = skip_whitespace(skip_fields(tp, 4));
             // filter out /dev/something (something != zero)
             if (strncmp(tp, "/dev/", 5) != 0 || strcmp(tp, "/dev/zero\n") == 0) {
+            if (!is_prefixed_with(tp, "/dev/") || strcmp(tp, "/dev/zero\n") == 0) {
                 if (currec.smap_mode[1] == 'w') {
                     currec.mapped_rw = currec.smap_size;
 …
 #endif
-void BUG_comm_size(void);
 procps_status_t* FAST_FUNC procps_scan(procps_status_t* sp, int flags)
+{
 …
                 continue;*/
             cp[0] = '\0';
+            if (sizeof(sp->comm) < 16)
+                BUG_comm_size();
+            BUILD_BUG_ON(sizeof(sp->comm) < 16);
             comm1 = strchr(buf, '(');
             /*if (comm1)*/
 …
                     char *tp;
 #define SCAN_TWO(str, name, statement) \
     if (strncmp(buf, str, sizeof(str)-1) == 0) { \
         tp = skip_whitespace(buf + sizeof(str)-1); \
+    if ((tp = is_prefixed_with(buf, str)) != NULL) { \
+        tp = skip_whitespace(tp); \
         sscanf(tp, "%u", &sp->name); \
         statement; \
 …
             if (flags & PSSCAN_ARGVN) {
                 sp->argv_len = n;
+                sp->argv0 = xmalloc(n + 1);
+                memcpy(sp->argv0, buf, n + 1);
+                sp->argv0 = xmemdup(buf, n + 1);
                 /* sp->argv0[n] = '\0'; - buf has it */
             } else {
 …
             sz--;
+        }
+        if (base[0] == '-') /* "-sh" (login shell)? */
+            base++;
         /* If comm differs from argv0, prepend "{comm} ".
          * It allows to see thread names set by prctl(PR_SET_NAME).
          */
         if (base[0] == '-') /* "-sh" (login shell)? */
             base++;
+        if (!comm)
+            return;
         comm_len = strlen(comm);
         /* Why compare up to comm_len, not COMM_LEN-1?
 …
             buf[col - 1] = '\0';
+        }
     } else {
         snprintf(buf, col, "[%s]", comm);
+        snprintf(buf, col, "[%s]", comm ? comm : "?");
+    }
+}

branches/3.3/mindi-busybox/libbb/progress.c

-              r3232
+              r3621
     STALLTIME = 5
 };
-static unsigned int get_tty2_width(void)
+{
-    unsigned width;
-    get_terminal_width_height(2, &width, NULL);
-    return width;
+}
 void FAST_FUNC bb_progress_init(bb_progress_t *p, const char *curfile)
 …
     uoff_t beg_and_transferred;
     unsigned since_last_update, elapsed;
     int barlength;
+    int notty;
     int kiloscale;
 …
+    }
+    notty = !isatty(STDERR_FILENO);
     if (ENABLE_UNICODE_SUPPORT)
         fprintf(stderr, "\r%s", p->curfile);
+        fprintf(stderr, "\r%s" + notty, p->curfile);
     else
         fprintf(stderr, "\r%-20.20s", p->curfile);
+        fprintf(stderr, "\r%-20.20s" + notty, p->curfile);
     beg_and_transferred = beg_size + transferred;
     if (totalsize != 0) {
+        int barlength;
         unsigned ratio = 100 * beg_and_transferred / totalsize;
         fprintf(stderr, "%4u%%", ratio);
         barlength = get_tty2_width() - 49;
+        barlength = get_terminal_width(2) - 49;
         if (barlength > 0) {
             /* god bless gcc for variable arrays :) */
 …
         fprintf(stderr, "%3u:%02u:%02u ETA", hours, secs / 60, secs % 60);
+    }
+    if (notty)
+        fputc('\n', stderr);
+}

branches/3.3/mindi-busybox/libbb/pw_encrypt.c

-              r3232
+              r3621
 #include "libbb.h"
 /* static const uint8_t ascii64[] =
+/* static const uint8_t ascii64[] ALIGN1 =
  * "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  */
 …
     int len = 2/2;
     char *salt_ptr = salt;
+    if (algo[0] != 'd') { /* not des */
+    /* Standard chpasswd uses uppercase algos ("MD5", not "md5").
+     * Need to be case-insensitive in the code below.
+     */
+    if ((algo[0]|0x20) != 'd') { /* not des */
         len = 8/2; /* so far assuming md5 */
         *salt_ptr++ = '$';
 …
         *salt_ptr++ = '$';
 #if !ENABLE_USE_BB_CRYPT || ENABLE_USE_BB_CRYPT_SHA
         if (algo[0] == 's') { /* sha */
             salt[1] = '5' + (strcmp(algo, "sha512") == 0);
+        if ((algo[0]|0x20) == 's') { /* sha */
+            salt[1] = '5' + (strcasecmp(algo, "sha512") == 0);
             len = 16/2;
+        }
 …
 char* FAST_FUNC pw_encrypt(const char *clear, const char *salt, int cleanup)
+{
+    return xstrdup(crypt(clear, salt));
+    char *s;
+    s = crypt(clear, salt);
+    /*
+     * glibc used to return "" on malformed salts (for example, ""),
+     * but since 2.17 it returns NULL.
+     */
+    return xstrdup(s ? s : "");
+}

branches/3.3/mindi-busybox/libbb/pw_encrypt_md5.c

r2725	r3621
87	87	/* Get the length of the salt including "$1$" */
88	88	sl = 3;
89		while (s~~alt[sl] && salt[sl] != '$' && sl < (3 + 8)~~)
	89	while (sl < (3 + 8) && salt[sl] && salt[sl] != '$')
90	90	sl++;
91	91

branches/3.3/mindi-busybox/libbb/read_printf.c

-              r3232
+              r3621
  * Thankfully, poll() doesn't care about O_NONBLOCK flag.
  */
 ssize_t FAST_FUNC nonblock_immune_read(int fd, void *buf, size_t count, int loop_on_EINTR)
+ssize_t FAST_FUNC nonblock_immune_read(int fd, void *buf, size_t count)
+{
     struct pollfd pfd[1];
 …
     while (1) {
         n = loop_on_EINTR ? safe_read(fd, buf, count) : read(fd, buf, count);
+        n = safe_read(fd, buf, count);
         if (n >= 0 || errno != EAGAIN)
             return n;
 …
         pfd[0].events = POLLIN;
         /* note: safe_poll pulls in printf */
         loop_on_EINTR ? safe_poll(pfd, 1, -1) : poll(pfd, 1, -1);
+        safe_poll(pfd, 1, -1);
+    }
+}
 …
             sz += 128;
+        }
         if (nonblock_immune_read(fd, p, 1, /*loop_on_EINTR:*/ 1) != 1) {
+        if (nonblock_immune_read(fd, p, 1) != 1) {
             /* EOF/error */
             if (p == buf) { /* we read nothing */

branches/3.3/mindi-busybox/libbb/remove_file.c

r3232	r3621
79	79	}
80	80
	81	if (flags & FILEUTILS_VERBOSE) {
	82	printf("removed directory: '%s'\n", path);
	83	}
	84
81	85	return status;
82	86	}
…	…
99	103	}
100	104
	105	if (flags & FILEUTILS_VERBOSE) {
	106	printf("removed '%s'\n", path);
	107	}
	108
101	109	return 0;
102	110	}

branches/3.3/mindi-busybox/libbb/rtc.c

-              r2725
+              r3621
         while (fgets(buffer, sizeof(buffer), f)) {
             if (strncmp(buffer, "UTC", 3) == 0) {
+            if (is_prefixed_with(buffer, "UTC")) {
                 utc = 1;
                 break;
 …
+}
+/* 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 (!*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/rtc0";
         rtc = open(*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);
+}

branches/3.3/mindi-busybox/libbb/skip_whitespace.c

r2725	r3621
34	34	char* FAST_FUNC skip_dev_pfx(const char *tty_name)
35	35	{
36		if (~~strncmp(tty_name, "/dev/", 5) == 0~~)
	36	if (is_prefixed_with(tty_name, "/dev/"))
37	37	tty_name += 5;
38	38	return (char*)tty_name;

branches/3.3/mindi-busybox/libbb/speed_table.c

-              r2725
+              r3621
 struct speed_map {
+#if defined __FreeBSD__
+    /* On FreeBSD, B<num> constants don't fit into a short */
+    unsigned speed;
+#else
     unsigned short speed;
+#endif
     unsigned short value;
 };

branches/3.3/mindi-busybox/libbb/strrstr.c

-              r2725
+              r3621
  */
-#ifdef __DO_STRRSTR_TEST
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#else
 #include "libbb.h"
-#endif
 /*
 …
+}
+#ifdef __DO_STRRSTR_TEST
+int main(int argc, char **argv)
+#if ENABLE_UNIT_TEST
+BBUNIT_DEFINE_TEST(strrstr)
+{
     static const struct {
 …
     while (i < sizeof(test_array) / sizeof(test_array[0])) {
         const char *r = strrstr(test_array[i].h, test_array[i].n);
-        printf("'%s' vs. '%s': '%s' - ", test_array[i].h, test_array[i].n, r);
         if (r == NULL)
             r = test_array[i].h - 1;
         printf("%s\n", r == test_array[i].h + test_array[i].pos ? "PASSED" : "FAILED");
+        BBUNIT_ASSERT_EQ(r, test_array[i].h + test_array[i].pos);
         i++;
+    }
     return 0;
+    BBUNIT_ENDTEST;
+}
+#endif
+#endif /* ENABLE_UNIT_TEST */

branches/3.3/mindi-busybox/libbb/time.c

-              r3232
+              r3621
                     &ptm->tm_hour,
                     &ptm->tm_min,
+                    &end) >= 2) {
+                    &end) >= 2
+        ) {
             /* no adjustments needed */
         } else
 …
                     &ptm->tm_mon, &ptm->tm_mday,
                     &ptm->tm_hour, &ptm->tm_min,
+                    &end) >= 4) {
+                    &end) >= 4
+        ) {
             /* Adjust month from 1-12 to 0-11 */
             ptm->tm_mon -= 1;
 …
                     &ptm->tm_mon, &ptm->tm_mday,
                     &ptm->tm_hour, &ptm->tm_min,
+                    &end) >= 5) {
+            ptm->tm_year -= 1900; /* Adjust years */
+            ptm->tm_mon -= 1; /* Adjust month from 1-12 to 0-11 */
+        } else
+                    &end) >= 5
         /* yyyy-mm-dd HH:MM */
         if (sscanf(date_str, "%u-%u-%u %u:%u%c", &ptm->tm_year,
+         || sscanf(date_str, "%u-%u-%u %u:%u%c", &ptm->tm_year,
                     &ptm->tm_mon, &ptm->tm_mday,
                     &ptm->tm_hour, &ptm->tm_min,
+                    &end) >= 5) {
+                    &end) >= 5
+        ) {
             ptm->tm_year -= 1900; /* Adjust years */
             ptm->tm_mon -= 1; /* Adjust month from 1-12 to 0-11 */
 …
         } else
 #endif
-//TODO: coreutils 6.9 also accepts "yyyy-mm-dd HH" (no minutes)
+        {
             bb_error_msg_and_die(bb_msg_invalid_date, date_str);
 …
             /* else end != NUL and we error out */
+        }
+    } else if (date_str[0] == '@') {
+    } else
+    if (strchr(date_str, '-')
+        /* Why strchr('-') check?
+         * sscanf below will trash ptm->tm_year, this breaks
+         * if parse_str is "10101010" (iow, "MMddhhmm" form)
+         * because we destroy year. Do these sscanf
+         * only if we saw a dash in parse_str.
+         */
+        /* yyyy-mm-dd HH */
+     && (sscanf(date_str, "%u-%u-%u %u%c", &ptm->tm_year,
+                &ptm->tm_mon, &ptm->tm_mday,
+                &ptm->tm_hour,
+                &end) >= 4
+        /* yyyy-mm-dd */
+         || sscanf(date_str, "%u-%u-%u%c", &ptm->tm_year,
+                &ptm->tm_mon, &ptm->tm_mday,
+                &end) >= 3
+        )
+    ) {
+        ptm->tm_year -= 1900; /* Adjust years */
+        ptm->tm_mon -= 1; /* Adjust month from 1-12 to 0-11 */
+    } else
+    if (date_str[0] == '@') {
         time_t t = bb_strtol(date_str + 1, NULL, 10);
         if (!errno) {
 …
             bb_error_msg_and_die(bb_msg_invalid_date, date_str);
+        }
+        ptm->tm_sec = 0; /* assume zero if [.SS] is not given */
         if (end == '.') {
             /* xxx.SS */
 …
+}
+static char* strftime_fmt(char *buf, unsigned len, time_t *tp, const char *fmt)
+{
+    time_t t;
+    if (!tp) {
+        tp = &t;
+        time(tp);
+    }
+    /* Returns pointer to NUL */
+    return buf + strftime(buf, len, fmt, localtime(tp));
+}
+char* FAST_FUNC strftime_HHMMSS(char *buf, unsigned len, time_t *tp)
+{
+    return strftime_fmt(buf, len, tp, "%H:%M:%S");
+}
+char* FAST_FUNC strftime_YYYYMMDDHHMMSS(char *buf, unsigned len, time_t *tp)
+{
+    return strftime_fmt(buf, len, tp, "%Y-%m-%d %H:%M:%S");
+}
 #if ENABLE_MONOTONIC_SYSCALL

branches/3.3/mindi-busybox/libbb/u_signal_names.c

r3232	r3621
20	20	* HPPA: SIGSTKFLT == 36. */
21	21
22		static const char signals[][7] = {
	22	static const char signals[][7] ALIGN1 = {
23	23	// SUSv3 says kill must support these, and specifies the numerical values,
24	24	// http://www.opengroup.org/onlinepubs/009695399/utilities/kill.html

branches/3.3/mindi-busybox/libbb/udp_io.c

-              r3232
+              r3621
+{
 #ifdef IP_PKTINFO
     setsockopt(fd, IPPROTO_IP, IP_PKTINFO, &const_int_1, sizeof(int));
+    setsockopt_1(fd, IPPROTO_IP, IP_PKTINFO);
 #endif
 #if ENABLE_FEATURE_IPV6 && defined(IPV6_PKTINFO)
     setsockopt(fd, IPPROTO_IPV6, IPV6_PKTINFO, &const_int_1, sizeof(int));
+    setsockopt_1(fd, IPPROTO_IPV6, IPV6_PKTINFO);
 #endif
+}

branches/3.3/mindi-busybox/libbb/unicode.c

-              r3232
+              r3621
     size_t width;
+    /* We pass "" instead of "C" because some libc's have
+     * non-ASCII default locale for setlocale("") call
+     * (this allows users of such libc to have Unicoded
+     * system without having to mess with env).
+     *
+     * We set LC_CTYPE because (a) we may be called with $LC_CTYPE
+     * value in LANG, not with $LC_ALL, (b) internationalized
+     * LC_NUMERIC and LC_TIME are more PITA than benefit
+     * (for one, some utilities have hard time with comma
+     * used as a fractional separator).
+     */
 //TODO: avoid repeated calls by caching last string?
     setlocale(LC_ALL, (LANG && LANG[0]) ? LANG : "C");
+    setlocale(LC_CTYPE, LANG ? LANG : "");
     /* In unicode, this is a one character string */
+// can use unicode_strlen(string) too, but otherwise unicode_strlen() is unused
+    width = mbstowcs(NULL, unicode_0x394, INT_MAX);
+    width = unicode_strlen(unicode_0x394);
     unicode_status = (width == 1 ? UNICODE_ON : UNICODE_OFF);
+}
 …
 void FAST_FUNC init_unicode(void)
+{
+    if (unicode_status == UNICODE_UNKNOWN)
+        reinit_unicode(getenv("LANG"));
+    /* Some people set only $LC_CTYPE, not $LC_ALL, because they want
+     * only Unicode to be activated on their system, not the whole
+     * shebang of wrong decimal points, strange date formats and so on.
+     */
+    if (unicode_status == UNICODE_UNKNOWN) {
+        char *s = getenv("LC_ALL");
+        if (!s) s = getenv("LC_CTYPE");
+        if (!s) s = getenv("LANG");
+        reinit_unicode(s);
+    }
+}
 …
 void FAST_FUNC init_unicode(void)
+{
+    if (unicode_status == UNICODE_UNKNOWN)
+        reinit_unicode(getenv("LANG"));
+    if (unicode_status == UNICODE_UNKNOWN) {
+        char *s = getenv("LC_ALL");
+        if (!s) s = getenv("LC_CTYPE");
+        if (!s) s = getenv("LANG");
+        reinit_unicode(s);
+    }
+}
 # endif
 …
 /* The rest is mostly same for libc and for "homegrown" support */
-#if 0 // UNUSED
 size_t FAST_FUNC unicode_strlen(const char *string)
+{
 …
     return width;
+}
-#endif
 size_t FAST_FUNC unicode_strwidth(const char *string)

branches/3.3/mindi-busybox/libbb/update_passwd.c

-              r2725
+              r3621
     or if CONFIG_CHPASSWD=y and applet_name[0] == 'c' like in chpasswd
+) delete a user from all groups: update_passwd(FILE, NULL, NULL, MEMBER)
  This function does not validate the arguments fed to it
  so the calling program should take care of that.
 …
     char *sfx_char;
     char *name_colon;
-    unsigned user_len;
     int old_fd;
     int new_fd;
 …
         return ret;
+    check_selinux_update_passwd(name);
+    if (name)
+        check_selinux_update_passwd(name);
     /* New passwd file, "/etc/passwd+" for now */
     fnamesfx = xasprintf("%s+", filename);
     sfx_char = &fnamesfx[strlen(fnamesfx)-1];
+    name_colon = xasprintf("%s:", name);
+    user_len = strlen(name_colon);
+    name_colon = xasprintf("%s:", name ? name : "");
     if (shadow)
 …
         if (!line) /* EOF/error */
             break;
+        if (strncmp(name_colon, line, user_len) != 0) {
+        if (!name && member) {
+            /* Delete member from all groups */
+            /* line is "GROUP:PASSWD:[member1[,member2]...]" */
+            unsigned member_len = strlen(member);
+            char *list = strrchr(line, ':');
+            while (list) {
+                list++;
+ next_list_element:
+                if (is_prefixed_with(list, member)) {
+                    char c;
+                    changed_lines++;
+                    c = list[member_len];
+                    if (c == '\0') {
+                        if (list[-1] == ',')
+                            list--;
+                        *list = '\0';
+                        break;
+                    }
+                    if (c == ',') {
+                        overlapping_strcpy(list, list + member_len + 1);
+                        goto next_list_element;
+                    }
+                    changed_lines--;
+                }
+                list = strchr(list, ',');
+            }
             fprintf(new_fp, "%s\n", line);
             goto next;
+        }
+        cp = is_prefixed_with(line, name_colon);
+        if (!cp) {
+            fprintf(new_fp, "%s\n", line);
+            goto next;
+        }
         /* We have a match with "name:"... */
         cp = line + user_len; /* move past name: */
+        /* cp points past "name:" */
 #if ENABLE_FEATURE_ADDUSER_TO_GROUP || ENABLE_FEATURE_DEL_USER_FROM_GROUP

branches/3.3/mindi-busybox/libbb/utmp.c

-              r3232
+              r3621
 void FAST_FUNC write_new_utmp(pid_t pid, int new_type, const char *tty_name, const char *username, const char *hostname)
+{
     struct utmp utent;
+    struct utmpx utent;
     char *id;
     unsigned width;
 …
     strncpy(id, tty_name, width);
     touch(_PATH_UTMP);
     //utmpname(_PATH_UTMP);
     setutent();
+    touch(_PATH_UTMPX);
+    //utmpxname(_PATH_UTMPX);
+    setutxent();
     /* Append new one (hopefully, unless we collide on ut_id) */
     pututline(&utent);
     endutent();
+    pututxline(&utent);
+    endutxent();
 #if ENABLE_FEATURE_WTMP
     /* "man utmp" says wtmp file should *not* be created automagically */
     /*touch(bb_path_wtmp_file);*/
     updwtmp(bb_path_wtmp_file, &utent);
+    updwtmpx(bb_path_wtmp_file, &utent);
 #endif
+}
 …
 void FAST_FUNC update_utmp(pid_t pid, int new_type, const char *tty_name, const char *username, const char *hostname)
+{
     struct utmp utent;
     struct utmp *utp;
+    struct utmpx utent;
+    struct utmpx *utp;
     touch(_PATH_UTMP);
     //utmpname(_PATH_UTMP);
     setutent();
+    touch(_PATH_UTMPX);
+    //utmpxname(_PATH_UTMPX);
+    setutxent();
     /* Did init/getty/telnetd/sshd/... create an entry for us?
      * It should be (new_type-1), but we'd also reuse
      * any other potentially stale xxx_PROCESS entry */
     while ((utp = getutent()) != NULL) {
+    while ((utp = getutxent()) != NULL) {
         if (utp->ut_pid == pid
         // && ut->ut_line[0]
 …
                 memset(utp->ut_host, 0, sizeof(utp->ut_host));
+            }
             /* NB: pututline (see later) searches for matching utent
              * using getutid(utent) - we must not change ut_id
+            /* NB: pututxline (see later) searches for matching utxent
+             * using getutxid(utent) - we must not change ut_id
              * if we want *exactly this* record to be overwritten!
              */
 …
+        }
+    }
     //endutent(); - no need, pututline can deal with (and actually likes)
+    //endutxent(); - no need, pututxline can deal with (and actually likes)
     //the situation when utmp file is positioned on found record
 …
             write_new_utmp(pid, new_type, tty_name, username, hostname);
         else
             endutent();
+            endutxent();
         return;
+    }
     /* Make a copy. We can't use *utp, pututline's internal getutid
+    /* Make a copy. We can't use *utp, pututxline's internal getutxid
      * will overwrite it before it is used! */
     utent = *utp;
 …
     /* Update, or append new one */
     //setutent();
     pututline(&utent);
     endutent();
+    //setutxent();
+    pututxline(&utent);
+    endutxent();
 #if ENABLE_FEATURE_WTMP
     /* "man utmp" says wtmp file should *not* be created automagically */
     /*touch(bb_path_wtmp_file);*/
     updwtmp(bb_path_wtmp_file, &utent);
+    updwtmpx(bb_path_wtmp_file, &utent);
 #endif
+}
+/* man utmp:
+ * When init(8) finds that a process has exited, it locates its utmp entry
+ * by ut_pid, sets ut_type to DEAD_PROCESS, and clears ut_user, ut_host
+ * and ut_time with null bytes.
+ * [same applies to other processes which maintain utmp entries, like telnetd]
+ *
+ * We do not bother actually clearing fields:
+ * it might be interesting to know who was logged in and from where
+ */
+void FAST_FUNC update_utmp_DEAD_PROCESS(pid_t pid)
+{
+    update_utmp(pid, DEAD_PROCESS, NULL, NULL, NULL);
+}

branches/3.3/mindi-busybox/libbb/verror_msg.c

-              r2725
+              r3621
 #endif
+#if ENABLE_FEATURE_SYSLOG
+smallint syslog_level = LOG_ERR;
+#endif
 smallint logmode = LOGMODE_STDIO;
 const char *msg_eol = "\n";
 …
+{
     char *msg, *msg1;
+    char stack_msg[80];
     int applet_len, strerr_len, msgeol_len, used;
 …
     if (!s) /* nomsg[_and_die] uses NULL fmt */
         s = ""; /* some libc don't like printf(NULL) */
+    applet_len = strlen(applet_name) + 2; /* "applet: " */
+    strerr_len = strerr ? strlen(strerr) : 0;
+    msgeol_len = strlen(msg_eol);
+    /* This costs ~90 bytes of code, but avoids costly
+     * malloc()[in vasprintf]+realloc()+memmove()+free() in 99% of cases.
+     * ~40% speedup.
+     */
+    if ((int)sizeof(stack_msg) - applet_len > 0) {
+        va_list p2;
+        /* It is not portable to use va_list twice, need to va_copy it */
+        va_copy(p2, p);
+        used = vsnprintf(stack_msg + applet_len, (int)sizeof(stack_msg) - applet_len, s, p2);
+        va_end(p2);
+        msg = stack_msg;
+        used += applet_len;
+        if (used < (int)sizeof(stack_msg) - 3 - msgeol_len - strerr_len)
+            goto add_pfx_and_sfx;
+    }
     used = vasprintf(&msg, s, p);
 …
      * children can produce log messages simultaneously. */
-    applet_len = strlen(applet_name) + 2; /* "applet: " */
-    strerr_len = strerr ? strlen(strerr) : 0;
-    msgeol_len = strlen(msg_eol);
     /* can't use xrealloc: it calls error_msg on failure,
      * that may result in a recursion */
 …
         memmove(msg + applet_len, msg, used);
         used += applet_len;
+ add_pfx_and_sfx:
         strcpy(msg, applet_name);
         msg[applet_len - 2] = ':';
 …
 #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);
+    if (msg != stack_msg)
+        free(msg);
+}

branches/3.3/mindi-busybox/libbb/vfork_daemon_rexec.c

-              r3232
+              r3621
 #if ENABLE_FEATURE_PREFER_APPLETS
+static jmp_buf die_jmp;
+static void jump(void)
+{
+    /* Special case. We arrive here if NOFORK applet
+     * calls xfunc, which then decides to die.
+     * We don't die, but jump instead back to caller.
+     * NOFORK applets still cannot carelessly call xfuncs:
+     * p = xmalloc(10);
+     * q = xmalloc(10); // BUG! if this dies, we leak p!
+     */
+    /* | 0x100 allows to pass zero exitcode (longjmp can't pass 0).
+     * This works because exitcodes are bytes,
+     * run_nofork_applet() ensures that by "& 0xff" */
+    longjmp(die_jmp, xfunc_error_retval | 0x100);
+}
 struct nofork_save_area {
     jmp_buf die_jmp;
+    void (*die_func)(void);
     const char *applet_name;
     uint32_t option_mask32;
-    int die_sleep;
     uint8_t xfunc_error_retval;
 };
 …
+{
     memcpy(&save->die_jmp, &die_jmp, sizeof(die_jmp));
+    save->die_func = die_func;
     save->applet_name = applet_name;
+    save->option_mask32 = option_mask32;
     save->xfunc_error_retval = xfunc_error_retval;
-    save->option_mask32 = option_mask32;
-    save->die_sleep = die_sleep;
+}
 static void restore_nofork_data(struct nofork_save_area *save)
+{
     memcpy(&die_jmp, &save->die_jmp, sizeof(die_jmp));
+    die_func = save->die_func;
     applet_name = save->applet_name;
+    option_mask32 = save->option_mask32;
     xfunc_error_retval = save->xfunc_error_retval;
-    option_mask32 = save->option_mask32;
-    die_sleep = save->die_sleep;
+}
 …
     save_nofork_data(&old);
-    applet_name = APPLET_NAME(applet_no);
     xfunc_error_retval = EXIT_FAILURE;
 …
         argc++;
+    /* Special flag for xfunc_die(). If xfunc will "die"
+     * in NOFORK applet, xfunc_die() sees negative
+     * die_sleep and longjmp here instead. */
+    die_sleep = -1;
+    /* If xfunc "dies" in NOFORK applet, die_func longjmp's here instead */
+    die_func = jump;
     rc = setjmp(die_jmp);
     if (!rc) {
 …
         char *tmp_argv[argc+1];
         memcpy(tmp_argv, argv, (argc+1) * sizeof(tmp_argv[0]));
+        applet_name = tmp_argv[0];
         /* Finally we can call NOFORK applet's main() */
         rc = applet_main[applet_no](argc, tmp_argv);
+    } else { /* xfunc died in NOFORK applet */
+        /* in case they meant to return 0... */
+        if (rc == -2222)
+            rc = 0;
+    } else {
+        /* xfunc died in NOFORK applet */
+    }

branches/3.3/mindi-busybox/libbb/xatonum.c

-              r2725
+              r3621
     return xatou_range(numstr, 0, 0xffff);
+}
+const struct suffix_mult bkm_suffixes[] = {
+    { "b", 512 },
+    { "k", 1024 },
+    { "m", 1024*1024 },
+    { "", 0 }
+};
+const struct suffix_mult cwbkMG_suffixes[] = {
+    { "c", 1 },
+    { "w", 2 },
+    { "b", 512 },
+    { "kB", 1000 },
+    { "kD", 1000 },
+    { "k", 1024 },
+    { "KB", 1000 }, /* compat with coreutils dd */
+    { "KD", 1000 }, /* compat with coreutils dd */
+    { "K", 1024 },  /* compat with coreutils dd */
+    { "MB", 1000000 },
+    { "MD", 1000000 },
+    { "M", 1024*1024 },
+    { "GB", 1000000000 },
+    { "GD", 1000000000 },
+    { "G", 1024*1024*1024 },
+    /* "D" suffix for decimal is not in coreutils manpage, looks like it's deprecated */
+    /* coreutils also understands TPEZY suffixes for tera- and so on, with B suffix for decimal */
+    { "", 0 }
+};

branches/3.3/mindi-busybox/libbb/xconnect.c

-              r3232
+              r3621
 #include "libbb.h"
+int FAST_FUNC setsockopt_int(int fd, int level, int optname, int optval)
+{
+    return setsockopt(fd, level, optname, &optval, sizeof(int));
+}
+int FAST_FUNC setsockopt_1(int fd, int level, int optname)
+{
+    return setsockopt_int(fd, level, optname, 1);
+}
+int FAST_FUNC setsockopt_SOL_SOCKET_int(int fd, int optname, int optval)
+{
+    return setsockopt_int(fd, SOL_SOCKET, optname, optval);
+}
+int FAST_FUNC setsockopt_SOL_SOCKET_1(int fd, int optname)
+{
+    return setsockopt_SOL_SOCKET_int(fd, optname, 1);
+}
 void FAST_FUNC setsockopt_reuseaddr(int fd)
+{
     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &const_int_1, sizeof(const_int_1));
+    setsockopt_SOL_SOCKET_1(fd, SO_REUSEADDR);
+}
 int FAST_FUNC setsockopt_broadcast(int fd)
+{
+    return setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &const_int_1, sizeof(const_int_1));
+    return setsockopt_SOL_SOCKET_1(fd, SO_BROADCAST);
+}
+int FAST_FUNC setsockopt_keepalive(int fd)
+{
+    return setsockopt_SOL_SOCKET_1(fd, SO_KEEPALIVE);
+}
 …
     struct addrinfo hint;
     if (ENABLE_FEATURE_UNIX_LOCAL && strncmp(host, "local:", 6) == 0) {
+    if (ENABLE_FEATURE_UNIX_LOCAL && is_prefixed_with(host, "local:")) {
         struct sockaddr_un *sun;

branches/3.3/mindi-busybox/libbb/xfunc_die.c

-              r2725
+              r3621
  */
 /* Keeping it separate allows to NOT suck in stdio for VERY small applets.
+/* Keeping it separate allows to NOT pull in stdio for VERY small applets.
  * Try building busybox with only "true" enabled... */
 #include "libbb.h"
+int die_sleep;
+#if ENABLE_FEATURE_PREFER_APPLETS || ENABLE_HUSH
+jmp_buf die_jmp;
+#endif
+void (*die_func)(void);
 void FAST_FUNC xfunc_die(void)
+{
+    if (die_sleep) {
+        if ((ENABLE_FEATURE_PREFER_APPLETS || ENABLE_HUSH)
+         && die_sleep < 0
+        ) {
+            /* Special case. We arrive here if NOFORK applet
+             * calls xfunc, which then decides to die.
+             * We don't die, but jump instead back to caller.
+             * NOFORK applets still cannot carelessly call xfuncs:
+             * p = xmalloc(10);
+             * q = xmalloc(10); // BUG! if this dies, we leak p!
+             */
+            /* -2222 means "zero" (longjmp can't pass 0)
+             * run_nofork_applet() catches -2222. */
+            longjmp(die_jmp, xfunc_error_retval ? xfunc_error_retval : -2222);
+        }
+        sleep(die_sleep);
+    }
+    if (die_func)
+        die_func();
     exit(xfunc_error_retval);
+}

branches/3.3/mindi-busybox/libbb/xfuncs.c

-              r3232
+              r3621
 /* Turn on nonblocking I/O on a fd */
 void FAST_FUNC ndelay_on(int fd)
+int FAST_FUNC ndelay_on(int fd)
+{
     int flags = fcntl(fd, F_GETFL);
     if (flags & O_NONBLOCK)
         return;
+        return flags;
     fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+}
+void FAST_FUNC ndelay_off(int fd)
+    return flags;
+}
+int FAST_FUNC ndelay_off(int fd)
+{
     int flags = fcntl(fd, F_GETFL);
     if (!(flags & O_NONBLOCK))
         return;
+        return flags;
     fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
+    return flags;
+}
 …
         // If we can't, it's smaller.
         } else {
             if (bottom == top) {
 …
     return err;
+}
+int FAST_FUNC get_terminal_width(int fd)
+{
+    unsigned width;
+    get_terminal_width_height(fd, &width, NULL);
+    return width;
+}
 int FAST_FUNC tcsetattr_stdin_TCSANOW(const struct termios *tp)
 …
     return 0;
+}
+// Useful when we do know that pid is valid, and we just want to wait
+// for it to exit. Not existing pid is fatal. waitpid() status is not returned.
+int FAST_FUNC wait_for_exitstatus(pid_t pid)
+{
+    int exit_status, n;
+    n = safe_waitpid(pid, &exit_status, 0);
+    if (n < 0)
+        bb_perror_msg_and_die("waitpid");
+    return exit_status;
+}

branches/3.3/mindi-busybox/libbb/xfuncs_printf.c

-              r3232
+              r3621
+}
+void* FAST_FUNC xmemdup(const void *s, int n)
+{
+    return memcpy(xmalloc(n), s, n);
+}
 // Die if we can't open a file and return a FILE* to it.
 // Notice we haven't got xfread(), This is for use with fscanf() and friends.
 …
+{
     return xopen3(pathname, flags, 0666);
+}
+// Warn if we can't open a file and return a fd.
+int FAST_FUNC open3_or_warn(const char *pathname, int flags, int mode)
+{
+    int ret;
+    ret = open(pathname, flags, mode);
+    if (ret < 0) {
+        bb_perror_msg("can't open '%s'", pathname);
+    }
+    return ret;
+}
+// Warn if we can't open a file and return a fd.
+int FAST_FUNC open_or_warn(const char *pathname, int flags)
+{
+    return open3_or_warn(pathname, flags, 0666);
+}
 …
+}
+// Warn if we can't open a file and return a fd.
+int FAST_FUNC open3_or_warn(const char *pathname, int flags, int mode)
+{
+    int ret;
+    ret = open(pathname, flags, mode);
+    if (ret < 0) {
+        bb_perror_msg("can't open '%s'", pathname);
+    }
+    return ret;
+}
+// Warn if we can't open a file and return a fd.
+int FAST_FUNC open_or_warn(const char *pathname, int flags)
+{
+    return open3_or_warn(pathname, flags, 0666);
+int FAST_FUNC xopen_as_uid_gid(const char *pathname, int flags, uid_t u, gid_t g)
+{
+    int fd;
+    uid_t old_euid = geteuid();
+    gid_t old_egid = getegid();
+    xsetegid(g);
+    xseteuid(u);
+    fd = xopen(pathname, flags);
+    xseteuid(old_euid);
+    xsetegid(old_egid);
+    return fd;
+}
 …
+}
+void FAST_FUNC xsetegid(gid_t egid)
+{
+    if (setegid(egid)) bb_perror_msg_and_die("setegid");
+}
+void FAST_FUNC xseteuid(uid_t euid)
+{
+    if (seteuid(euid)) bb_perror_msg_and_die("seteuid");
+}
 // Die if we can't chdir to a new path.
 void FAST_FUNC xchdir(const char *path)
 …
     if (chdir(path))
         bb_perror_msg_and_die("can't change directory to '%s'", path);
+}
+void FAST_FUNC xfchdir(int fd)
+{
+    if (fchdir(fd))
+        bb_perror_msg_and_die("fchdir");
+}
 …
 char* FAST_FUNC xmalloc_ttyname(int fd)
+{
+    char *buf = xzalloc(128);
+    int r = ttyname_r(fd, buf, 127);
+    if (r) {
+        free(buf);
+        buf = NULL;
+    }
+    return buf;
+    char buf[128];
+    int r = ttyname_r(fd, buf, sizeof(buf) - 1);
+    if (r)
+        return NULL;
+    return xstrdup(buf);
+}
 …
+}
 #endif
+void FAST_FUNC xvfork_parent_waits_and_exits(void)
+{
+    pid_t pid;
+    fflush_all();
+    pid = xvfork();
+    if (pid > 0) {
+        /* Parent */
+        int exit_status = wait_for_exitstatus(pid);
+        if (WIFSIGNALED(exit_status))
+            kill_myself_with_sig(WTERMSIG(exit_status));
+        _exit(WEXITSTATUS(exit_status));
+    }
+    /* Child continues */
+}

branches/3.3/mindi-busybox/libbb/xreadlink.c

-              r2725
+              r3621
 /*
  * 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) do not have MAXSYMLINKS definition,
+ * set it to some reasonable value if it isn't defined */
+#ifndef MAXSYMLINKS
+# define MAXSYMLINKS 20
+#endif
 /*
 …
 char* FAST_FUNC xmalloc_realpath(const char *path)
+{
+#if defined(__GLIBC__) && !defined(__UCLIBC__)
+/* 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 */

Context Navigation

Changeset 3621 in MondoRescue for branches/3.3/mindi-busybox/libbb

Legend:

Download in other formats: