Merge branch 'busybox' into merge

8 files changed, 122 insertions, 81 deletions

diff --git a/libbb/Kbuild.src b/libbb/Kbuild.src
index 6749cceda..c0cc2baf5 100644
--- a/libbb/Kbuild.src
+++ b/libbb/Kbuild.src
@@ -128,6 +128,7 @@ lib-$(CONFIG_UNICODE_SUPPORT) += unicode.o
 lib-$(CONFIG_FEATURE_CHECK_NAMES) += die_if_bad_username.o
 
 lib-$(CONFIG_NC_110_COMPAT) += udp_io.o
+lib-$(CONFIG_NETCAT) += udp_io.o
 lib-$(CONFIG_DNSD) += udp_io.o
 lib-$(CONFIG_NTPD) += udp_io.o
 lib-$(CONFIG_TFTP) += udp_io.o
@@ -146,7 +147,8 @@ lib-$(CONFIG_DELGROUP) += update_passwd.o
 lib-$(CONFIG_DELUSER) += update_passwd.o
 
 lib-$(CONFIG_FTPD) += pw_encrypt.o correct_password.o
-lib-$(CONFIG_PASSWD) += pw_encrypt.o update_passwd.o obscure.o
+lib-$(CONFIG_PASSWD) += pw_encrypt.o update_passwd.o
+lib-$(CONFIG_FEATURE_PASSWD_WEAK_CHECK) += obscure.o
 lib-$(CONFIG_CHPASSWD) += pw_encrypt.o update_passwd.o
 lib-$(CONFIG_CRYPTPW) += pw_encrypt.o
 lib-$(CONFIG_MKPASSWD) += pw_encrypt.o
diff --git a/libbb/bb_getsockname.c b/libbb/bb_getsockname.c
new file mode 100644
index 000000000..1af9b39b9
--- /dev/null
+++ b/libbb/bb_getsockname.c
@@ -0,0 +1,19 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Utility routines.
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+//kbuild:lib-y += bb_getsockname.o
+
+#include "libbb.h"
+
+int FAST_FUNC bb_getsockname(int sockfd, void *addr, socklen_t addrlen)
+{
+        /* The usefullness of this function is that for getsockname(),
+         * addrlen must go on stack (to _have_ an address to be passed),
+         * but many callers do not need its modified value.
+         * By using this shim, they can avoid unnecessary stack spillage.
+         */
+        return getsockname(sockfd, (struct sockaddr *)addr, &addrlen);
+}
diff --git a/libbb/crc32.c b/libbb/crc32.c
index b00b580d0..728bcb736 100644
--- a/libbb/crc32.c
+++ b/libbb/crc32.c
@@ -41,6 +41,16 @@ uint32_t* FAST_FUNC crc32_filltable(uint32_t *crc_table, int endian)
 
         return crc_table - 256;
 }
+/* Common uses: */
+uint32_t* FAST_FUNC crc32_new_table_le(void)
+{
+        return crc32_filltable(NULL, 0);
+}
+uint32_t* FAST_FUNC global_crc32_new_table_le(void)
+{
+        global_crc32_table = crc32_new_table_le();
+        return global_crc32_table;
+}
 
 uint32_t FAST_FUNC crc32_block_endian1(uint32_t val, const void *buf, unsigned len, uint32_t *crc_table)
 {
diff --git a/libbb/executable.c b/libbb/executable.c
index b28f020e0..8e2f99732 100644
--- a/libbb/executable.c
+++ b/libbb/executable.c
@@ -25,7 +25,8 @@ int FAST_FUNC file_is_executable(const char *name)
  *  you may call find_executable again with this PATHp to continue
  *  (if it's not NULL).
  * return NULL otherwise; (PATHp is undefined)
- * in all cases (*PATHp) contents will be trashed (s/:/NUL/).
+ * in all cases (*PATHp) contents are temporarily modified
+ * but are restored on return (s/:/NUL/ and back).
  */
 #if !ENABLE_PLATFORM_MINGW32
 #define next_path_sep(s) strchr(s, ':')
@@ -48,14 +49,30 @@ char* FAST_FUNC find_executable(const char *filename, char **PATHp)
 
         p = *PATHp;
         while (p) {
+                int ex;
+#if ENABLE_PLATFORM_MINGW32
+                char sep;
+
                 n = (char*)next_path_sep(p);
-                if (n)
-                        *n++ = '\0';
+                if (n) {
+                        sep = *n;
+                        *n = '\0';
+                }
+#else
+                n = strchr(p, ':');
+                if (n) *n = '\0';
+#endif
                 p = concat_path_file(
                         p[0] ? p : ".", /* handle "::" case */
                         filename
                 );
-                if (file_is_executable(p)) {
+                ex = file_is_executable(p);
+#if ENABLE_PLATFORM_MINGW32
+                if (n) *n++ = sep;
+#else
+                if (n) *n++ = ':';
+#endif
+                if (ex) {
                         *PATHp = n;
                         return p;
                 }
@@ -78,10 +95,8 @@ char* FAST_FUNC find_executable(const char *filename, char **PATHp)
  */
 int FAST_FUNC executable_exists(const char *filename)
 {
-        char *path = xstrdup(getenv("PATH"));
-        char *tmp = path;
-        char *ret = find_executable(filename, &tmp);
-        free(path);
+        char *path = getenv("PATH");
+        char *ret = find_executable(filename, &path);
         free(ret);
         return ret != NULL;
 }
diff --git a/libbb/lineedit.c b/libbb/lineedit.c
index 3df67abb1..f22f5768f 100644
--- a/libbb/lineedit.c
+++ b/libbb/lineedit.c
@@ -90,7 +90,8 @@ static bool BB_ispunct(CHAR_T c) { return ((unsigned)c < 256 && ispunct(c)); }
 # define CHAR_T char
 # define BB_isspace(c) isspace(c)
 # if ENABLE_FEATURE_EDITING_VI
-static bool BB_isalnum_or_underscore(CHAR_T c) {
+static bool BB_isalnum_or_underscore(CHAR_T c)
+{
         return ((unsigned)c < 256 && isalnum(c)) || c == '_';
 }
 # endif
diff --git a/libbb/make_directory.c b/libbb/make_directory.c
index 6422c863f..1f3aecf40 100644
--- a/libbb/make_directory.c
+++ b/libbb/make_directory.c
@@ -125,6 +125,7 @@ int FAST_FUNC bb_make_directory(char *path, long mode, int flags)
                         }
                 }
 
+                //bb_error_msg("mkdir '%s'", path);
                 if (mkdir(path, 0777) < 0) {
                         /* If we failed for any other reason than the directory
                          * already exists, output a diagnostic and return -1 */
@@ -151,13 +152,16 @@ int FAST_FUNC bb_make_directory(char *path, long mode, int flags)
                         /* Done.  If necessary, update perms on the newly
                          * created directory.  Failure to update here _is_
                          * an error. */
-                        if ((mode != -1) && (chmod(path, mode) < 0)) {
-                                fail_msg = "set permissions of";
-                                if (flags & FILEUTILS_IGNORE_CHMOD_ERR) {
-                                        flags = 0;
-                                        goto print_err;
+                        if (mode != -1) {
+                                //bb_error_msg("chmod 0%03lo mkdir '%s'", mode, path);
+                                if (chmod(path, mode) < 0) {
+                                        fail_msg = "set permissions of";
+                                        if (flags & FILEUTILS_IGNORE_CHMOD_ERR) {
+                                                flags = 0;
+                                                goto print_err;
+                                        }
+                                        break;
                                 }
-                                break;
                         }
                         goto ret0;
                 }
diff --git a/libbb/messages.c b/libbb/messages.c
index 31721a3b3..f5bbd3e32 100644
--- a/libbb/messages.c
+++ b/libbb/messages.c
@@ -6,11 +6,6 @@
  */
 #include "libbb.h"
 
-/* allow default system PATH to be extended via CFLAGS */
-#ifndef BB_ADDITIONAL_PATH
-#define BB_ADDITIONAL_PATH ""
-#endif
-
 /* allow version to be extended, via CFLAGS */
 #ifndef BB_EXTRA_VERSION
 #define BB_EXTRA_VERSION " ("AUTOCONF_TIMESTAMP")"
@@ -38,8 +33,7 @@ const char bb_busybox_exec_path[] ALIGN1 = CONFIG_BUSYBOX_EXEC_PATH;
 const char bb_default_login_shell[] ALIGN1 = LIBBB_DEFAULT_LOGIN_SHELL;
 /* util-linux manpage says /sbin:/bin:/usr/sbin:/usr/bin,
  * but I want to save a few bytes here. Check libbb.h before changing! */
-const char bb_PATH_root_path[] ALIGN1 =
-        "PATH=/sbin:/usr/sbin:/bin:/usr/bin" BB_ADDITIONAL_PATH;
+const char bb_PATH_root_path[] ALIGN1 = BB_PATH_ROOT_PATH;
 
 
 //const int const_int_1 = 1;
diff --git a/libbb/progress.c b/libbb/progress.c
index 64e6529ac..f1d980d68 100644
--- a/libbb/progress.c
+++ b/libbb/progress.c
@@ -71,10 +71,9 @@ void FAST_FUNC bb_progress_update(bb_progress_t *p,
                 uoff_t transferred,
                 uoff_t totalsize)
 {
-        uoff_t beg_and_transferred;
+        char numbuf5[6]; /* 5 + 1 for NUL */
         unsigned since_last_update, elapsed;
         int notty;
-        int kiloscale;
 
         //transferred = 1234; /* use for stall detection testing */
         //totalsize = 0; /* use for unknown size download testing */
@@ -95,74 +94,69 @@ void FAST_FUNC bb_progress_update(bb_progress_t *p,
                 return;
         }
 
-        kiloscale = 0;
+        /* Before we lose real, unscaled sizes, produce human-readable size string */
+        smart_ulltoa5(beg_size + transferred, numbuf5, " kMGTPEZY")[0] = '\0';
+
         /*
          * Scale sizes down if they are close to overflowing.
          * This allows calculations like (100 * transferred / totalsize)
          * without risking overflow: we guarantee 10 highest bits to be 0.
          * Introduced error is less than 1 / 2^12 ~= 0.025%
          */
-        if (ULONG_MAX > 0xffffffff || sizeof(off_t) == 4 || sizeof(off_t) != 8) {
-                /*
-                 * 64-bit CPU || small off_t: in either case,
-                 * >> is cheap, single-word operation.
-                 * ... || strange off_t: also use this code
-                 * (it is safe, just suboptimal wrt code size),
-                 * because 32/64 optimized one works only for 64-bit off_t.
-                 */
-                if (totalsize >= (1 << 22)) {
-                        totalsize >>= 10;
-                        beg_size >>= 10;
-                        transferred >>= 10;
-                        kiloscale = 1;
-                }
-        } else {
-                /* 32-bit CPU and 64-bit off_t.
-                 * Use a 40-bit shift, it is easier to do on 32-bit CPU.
-                 */
-/* ONE suppresses "warning: shift count >= width of type" */
-#define ONE (sizeof(off_t) > 4)
-                if (totalsize >= (uoff_t)(1ULL << 54*ONE)) {
-                        totalsize = (uint32_t)(totalsize >> 32*ONE) >> 8;
-                        beg_size = (uint32_t)(beg_size >> 32*ONE) >> 8;
-                        transferred = (uint32_t)(transferred >> 32*ONE) >> 8;
-                        kiloscale = 4;
-                }
+        while (totalsize >= (1 << 20)) {
+                totalsize >>= 8;
+                beg_size >>= 8;
+                transferred >>= 8;
         }
+        /* If they were huge, now they are scaled down to [1048575,4096] range.
+         * (N * totalsize) won't overflow 32 bits for N up to 4096.
+         */
+#if ULONG_MAX == 0xffffffff
+/* 32-bit CPU, uoff_t arithmetic is complex on it, cast variables to narrower types */
+# define totalsize   ((unsigned)totalsize)
+# define beg_size    ((unsigned)beg_size)
+# define transferred ((unsigned)transferred)
+#endif
 
         notty = !isatty(STDERR_FILENO);
 
         if (ENABLE_UNICODE_SUPPORT)
-                fprintf(stderr, "\r%s" + notty, p->curfile);
+                fprintf(stderr, "\r%s " + notty, p->curfile);
         else
-                fprintf(stderr, "\r%-20.20s" + notty, p->curfile);
-
-        beg_and_transferred = beg_size + transferred;
+                fprintf(stderr, "\r%-20.20s " + notty, p->curfile);
 
         if (totalsize != 0) {
                 int barlength;
-                unsigned ratio = 100 * beg_and_transferred / totalsize;
-                fprintf(stderr, "%4u%%", ratio);
-
-                barlength = get_terminal_width(2) - 49;
-                if (barlength > 0) {
-                        /* god bless gcc for variable arrays :) */
-                        char buf[barlength + 1];
-                        unsigned stars = (unsigned)barlength * beg_and_transferred / totalsize;
-                        memset(buf, ' ', barlength);
-                        buf[barlength] = '\0';
-                        memset(buf, '*', stars);
-                        fprintf(stderr, " |%s|", buf);
+                unsigned beg_and_transferred; /* does not need uoff_t, see scaling code */
+                unsigned ratio;
+
+                beg_and_transferred = beg_size + transferred;
+                ratio = 100 * beg_and_transferred / totalsize;
+                /* can't overflow ^^^^^^^^^^^^^^^ */
+                fprintf(stderr, "%3u%% ", ratio);
+
+                barlength = get_terminal_width(2) - 48;
+                /*
+                 * Must reject barlength <= 0 (terminal too narrow). While at it,
+                 * also reject: 1-char bar (useless), 2-char bar (ridiculous).
+                 */
+                if (barlength > 2) {
+                        if (barlength > 999)
+                                barlength = 999;
+                        {
+                                /* god bless gcc for variable arrays :) */
+                                char buf[barlength + 1];
+                                unsigned stars = (unsigned)barlength * beg_and_transferred / totalsize;
+                                /* can't overflow ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */
+                                memset(buf, ' ', barlength);
+                                buf[barlength] = '\0';
+                                memset(buf, '*', stars);
+                                fprintf(stderr, "|%s| ", buf);
+                        }
                 }
         }
 
-        while (beg_and_transferred >= 100000) {
-                beg_and_transferred >>= 10;
-                kiloscale++;
-        }
-        /* see http://en.wikipedia.org/wiki/Tera */
-        fprintf(stderr, "%6u%c", (unsigned)beg_and_transferred, " kMGTPEZY"[kiloscale]);
-#define beg_and_transferred dont_use_beg_and_transferred_below()
+        fputs(numbuf5, stderr); /* "NNNNk" */
 
         since_last_update = elapsed - p->last_change_sec;
         if ((unsigned)transferred != p->last_size) {
@@ -184,16 +178,18 @@ void FAST_FUNC bb_progress_update(bb_progress_t *p,
                 fprintf(stderr, " --:--:-- ETA");
         } else {
                 unsigned eta, secs, hours;
+                unsigned bytes;
 
-                totalsize -= beg_size; /* now it's "total to upload" */
+                bytes = totalsize - beg_size;
 
                 /* Estimated remaining time =
-                 * estimated_sec_to_dl_totalsize_bytes - elapsed_sec =
-                 * totalsize / average_bytes_sec_so_far - elapsed =
-                 * totalsize / (transferred/elapsed) - elapsed =
-                 * totalsize * elapsed / transferred - elapsed
+                 * estimated_sec_to_dl_bytes - elapsed_sec =
+                 * bytes / average_bytes_sec_so_far - elapsed =
+                 * bytes / (transferred/elapsed) - elapsed =
+                 * bytes * elapsed / transferred - elapsed
                  */
-                eta = totalsize * elapsed / transferred - elapsed;
+                eta = (unsigned long)bytes * elapsed / transferred - elapsed;
+                /* if 32bit, can overflow ^^^^^^^^^^, but this would only show bad ETA */
                 if (eta >= 1000*60*60)
                         eta = 1000*60*60 - 1;
                 secs = eta % 3600;