Merge branch 'busybox' into merge

9 files changed, 153 insertions, 120 deletions

diff --git a/libbb/appletlib.c b/libbb/appletlib.c
index 77a9c3b7d..6ed86e12b 100644
--- a/libbb/appletlib.c
+++ b/libbb/appletlib.c
@@ -25,6 +25,11 @@
  *
  * FEATURE_INSTALLER or FEATURE_SUID will still link printf routines in. :(
  */
+
+/* Define this accessor before we #define "errno" our way */
+#include <errno.h>
+static inline int *get_perrno(void) { return &errno; }
+
 #include "busybox.h"
 
 #if !(defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) \
@@ -318,8 +323,8 @@ void lbb_prepare(const char *applet
 void lbb_prepare(const char *applet
                 IF_FEATURE_INDIVIDUAL(, char **argv))
 {
-#ifdef __GLIBC__
-        (*(int **)not_const_pp(&bb_errno)) = __errno_location();
+#ifdef bb_cached_errno_ptr
+        (*(int **)not_const_pp(&bb_errno)) = get_perrno();
         barrier();
 #endif
         applet_name = applet;
diff --git a/libbb/dump.c b/libbb/dump.c
index 8029cca0e..1ba1132b3 100644
--- a/libbb/dump.c
+++ b/libbb/dump.c
@@ -13,13 +13,19 @@
 #include "libbb.h"
 #include "dump.h"
 
-static const char dot_flags_width_chars[] ALIGN1 = ".#-+ 0123456789";
-
-static const char size_conv_str[] ALIGN1 =
-"\x1\x4\x4\x4\x4\x4\x4\x8\x8\x8\x8\010cdiouxXeEfgG";
-
-static const char int_convs[] ALIGN1 = "diouxX";
-
+#define F_IGNORE        0x01            /* %_A */
+#define F_SETREP        0x02            /* rep count set, not default */
+#define F_ADDRESS       0x001           /* print offset */
+#define F_BPAD          0x002           /* blank pad */
+#define F_C             0x004           /* %_c */
+#define F_CHAR          0x008           /* %c */
+#define F_DBL           0x010           /* %[EefGf] */
+#define F_INT           0x020           /* %[di] */
+#define F_P             0x040           /* %_p */
+#define F_STR           0x080           /* %s */
+#define F_U             0x100           /* %_u */
+#define F_UINT          0x200           /* %[ouXx] */
+#define F_TEXT          0x400           /* no conversions */
 
 typedef struct priv_dumper_t {
         dumper_t pub;
@@ -39,6 +45,13 @@ typedef struct priv_dumper_t {
         unsigned char *get__savp;
 } priv_dumper_t;
 
+static const char dot_flags_width_chars[] ALIGN1 = ".#-+ 0123456789";
+
+static const char size_conv_str[] ALIGN1 =
+"\x1\x4\x4\x4\x4\x4\x4\x8\x8\x8\x8\010cdiouxXeEfgG";
+
+static const char int_convs[] ALIGN1 = "diouxX";
+
 dumper_t* FAST_FUNC alloc_dumper(void)
 {
         priv_dumper_t *dumper = xzalloc(sizeof(*dumper));
@@ -48,7 +61,6 @@ dumper_t* FAST_FUNC alloc_dumper(void)
         return &dumper->pub;
 }
 
-
 static NOINLINE int bb_dump_size(FS *fs)
 {
         FU *fu;
@@ -284,7 +296,9 @@ static NOINLINE void rewrite(priv_dumper_t *dumper, FS *fs)
          * repeat it as necessary.
          *
          * if rep count is greater than 1, no trailing whitespace
-         * gets output from the last iteration of the format unit.
+         * gets output from the last iteration of the format unit:
+         * 2/1 "%02x " prints "XX XX", not "XX XX "
+         * 2/1 "%02x\n" prints "XX\nXX", not "XX\nXX\n"
          */
         for (fu = fs->nextfu; fu; fu = fu->nextfu) {
                 if (!fu->nextfu
@@ -394,7 +408,6 @@ static unsigned char *get(priv_dumper_t *dumper)
                                 if (dumper->pub.dump_vflag != DUP) {
                                         puts("*");
                                 }
-                                return NULL;
                         }
                         memset(dumper->get__curp + nread, 0, need);
                         dumper->eaddress = dumper->address + nread;
@@ -453,7 +466,7 @@ static void bpad(PR *pr)
         for (p2 = ++p1; *p1 && strchr(" -0+#", *p1); ++p1)
                 if (pr->nospace)
                         pr->nospace--;
-        while ((*p2++ = *p1++) != 0)
+        while ((*p2++ = *p1++) != '\0')
                 continue;
 }
 
@@ -520,36 +533,43 @@ static void conv_u(PR *pr, unsigned char *p)
 
 static void display(priv_dumper_t* dumper)
 {
-        FS *fs;
-        FU *fu;
-        PR *pr;
-        int cnt;
-        unsigned char *bp, *savebp;
-        off_t saveaddress;
+        unsigned char *bp;
         unsigned char savech = '\0';
 
         while ((bp = get(dumper)) != NULL) {
+                FS *fs;
+                unsigned char *savebp;
+                off_t saveaddress;
+
                 fs = dumper->pub.fshead;
                 savebp = bp;
                 saveaddress = dumper->address;
                 for (; fs; fs = fs->nextfs, bp = savebp, dumper->address = saveaddress) {
+                        FU *fu;
                         for (fu = fs->nextfu; fu; fu = fu->nextfu) {
+                                int cnt;
                                 if (fu->flags & F_IGNORE) {
                                         break;
                                 }
                                 for (cnt = fu->reps; cnt; --cnt) {
+                                        PR *pr;
                                         for (pr = fu->nextpr; pr; dumper->address += pr->bcnt,
                                                                 bp += pr->bcnt, pr = pr->nextpr) {
-                                                if (dumper->eaddress && dumper->address >= dumper->eaddress
-                                                 && !(pr->flags & (F_TEXT | F_BPAD))
+                                                if (dumper->eaddress
+                                                 && dumper->address >= dumper->eaddress
                                                 ) {
-                                                        bpad(pr);
+                                                        if (dumper->pub.eofstring) {
+                                                                /* xxd support: requested to not pad incomplete blocks */
+                                                                fputs(dumper->pub.eofstring, stdout);
+                                                                return;
+                                                        }
+                                                        if (!(pr->flags & (F_TEXT | F_BPAD)))
+                                                                bpad(pr);
                                                 }
                                                 if (cnt == 1 && pr->nospace) {
                                                         savech = *pr->nospace;
                                                         *pr->nospace = '\0';
                                                 }
-/*                      PRINT; */
                                                 switch (pr->flags) {
                                                 case F_ADDRESS:
                                                         printf(pr->fmt, (unsigned) dumper->address);
@@ -638,7 +658,9 @@ static void display(priv_dumper_t* dumper)
                         }
                 }
         }
+
         if (dumper->endfu) {
+                PR *pr;
                 /*
                  * if eaddress not set, error or file size was multiple
                  * of blocksize, and no partial block ever found.
@@ -695,8 +717,7 @@ void FAST_FUNC bb_dump_add(dumper_t* pub_dumper, const char *fmt)
 {
         const char *p;
         FS *tfs;
-        FU *tfu, **nextfupp;
-        const char *savep;
+        FU **nextfupp;
 
         /* start new linked list of format units */
         tfs = xzalloc(sizeof(FS)); /*DBU:[dave@cray.com] start out NULL */
@@ -713,6 +734,9 @@ void FAST_FUNC bb_dump_add(dumper_t* pub_dumper, const char *fmt)
         /* take the format string and break it up into format units */
         p = fmt;
         for (;;) {
+                FU *tfu;
+                const char *savep;
+
                 p = skip_whitespace(p);
                 if (*p == '\0') {
                         break;
diff --git a/libbb/hash_md5_sha.c b/libbb/hash_md5_sha.c
index 9db79ea8b..d8f210173 100644
--- a/libbb/hash_md5_sha.c
+++ b/libbb/hash_md5_sha.c
@@ -38,35 +38,6 @@ static ALWAYS_INLINE uint64_t rotl64(uint64_t x, unsigned n)
         return (x << n) | (x >> (64 - n));
 }
 
-/* Feed data through a temporary buffer.
- * The internal buffer remembers previous data until it has 64
- * bytes worth to pass on.
- */
-static void FAST_FUNC common64_hash(md5_ctx_t *ctx, const void *buffer, size_t len)
-{
-        unsigned bufpos = ctx->total64 & 63;
-
-        ctx->total64 += len;
-
-        while (1) {
-                unsigned remaining = 64 - bufpos;
-                if (remaining > len)
-                        remaining = len;
-                /* Copy data into aligned buffer */
-                memcpy(ctx->wbuffer + bufpos, buffer, remaining);
-                len -= remaining;
-                buffer = (const char *)buffer + remaining;
-                bufpos += remaining;
-                /* Clever way to do "if (bufpos != N) break; ... ; bufpos = 0;" */
-                bufpos -= 64;
-                if (bufpos != 0)
-                        break;
-                /* Buffer is filled up, process it */
-                ctx->process_block(ctx);
-                /*bufpos = 0; - already is */
-        }
-}
-
 /* Process the remaining bytes in the buffer */
 static void FAST_FUNC common64_end(md5_ctx_t *ctx, int swap_needed)
 {
@@ -449,7 +420,29 @@ void FAST_FUNC md5_begin(md5_ctx_t *ctx)
 /* Used also for sha1 and sha256 */
 void FAST_FUNC md5_hash(md5_ctx_t *ctx, const void *buffer, size_t len)
 {
-        common64_hash(ctx, buffer, len);
+        unsigned bufpos = ctx->total64 & 63;
+
+        ctx->total64 += len;
+
+        while (1) {
+                unsigned remaining = 64 - bufpos;
+                if (remaining > len)
+                        remaining = len;
+                /* Copy data into aligned buffer */
+                memcpy(ctx->wbuffer + bufpos, buffer, remaining);
+                len -= remaining;
+                buffer = (const char *)buffer + remaining;
+                bufpos += remaining;
+
+                /* Clever way to do "if (bufpos != N) break; ... ; bufpos = 0;" */
+                bufpos -= 64;
+                if (bufpos != 0)
+                        break;
+
+                /* Buffer is filled up, process it */
+                ctx->process_block(ctx);
+                /*bufpos = 0; - already is */
+        }
 }
 
 /* Process the remaining bytes in the buffer and put result from CTX
@@ -816,7 +809,7 @@ void FAST_FUNC sha512_begin(sha512_ctx_t *ctx)
         int i;
         /* Two extra iterations zero out ctx->total64[2] */
         uint64_t *tp = ctx->total64;
-        for (i = 0; i < 2+8; i++)
+        for (i = 0; i < 8 + 2; i++)
                 tp[i] = ((uint64_t)(init256[i]) << 32) + init512_lo[i];
         /*ctx->total64[0] = ctx->total64[1] = 0; - already done */
 }
@@ -832,22 +825,7 @@ void FAST_FUNC sha512_hash(sha512_ctx_t *ctx, const void *buffer, size_t len)
         ctx->total64[0] += len;
         if (ctx->total64[0] < len)
                 ctx->total64[1]++;
-# if 0
-        remaining = 128 - bufpos;
 
-        /* Hash whole blocks */
-        while (len >= remaining) {
-                memcpy(ctx->wbuffer + bufpos, buffer, remaining);
-                buffer = (const char *)buffer + remaining;
-                len -= remaining;
-                remaining = 128;
-                bufpos = 0;
-                sha512_process_block128(ctx);
-        }
-
-        /* Save last, partial blosk */
-        memcpy(ctx->wbuffer + bufpos, buffer, len);
-# else
         while (1) {
                 remaining = 128 - bufpos;
                 if (remaining > len)
@@ -857,15 +835,16 @@ void FAST_FUNC sha512_hash(sha512_ctx_t *ctx, const void *buffer, size_t len)
                 len -= remaining;
                 buffer = (const char *)buffer + remaining;
                 bufpos += remaining;
+
                 /* Clever way to do "if (bufpos != N) break; ... ; bufpos = 0;" */
                 bufpos -= 128;
                 if (bufpos != 0)
                         break;
+
                 /* Buffer is filled up, process it */
                 sha512_process_block128(ctx);
                 /*bufpos = 0; - already is */
         }
-# endif
 }
 #endif /* NEED_SHA512 */
 
@@ -1398,10 +1377,12 @@ void FAST_FUNC sha3_hash(sha3_ctx_t *ctx, const void *buffer, size_t len)
                         bufpos++;
                         remaining--;
                 }
+
                 /* Clever way to do "if (bufpos != N) break; ... ; bufpos = 0;" */
                 bufpos -= ctx->input_block_bytes;
                 if (bufpos != 0)
                         break;
+
                 /* Buffer is filled up, process it */
                 sha3_process_block72(ctx->state);
                 /*bufpos = 0; - already is */
diff --git a/libbb/inet_cksum.c b/libbb/inet_cksum.c
index 3d5dc3adf..fee8648f3 100644
--- a/libbb/inet_cksum.c
+++ b/libbb/inet_cksum.c
@@ -6,8 +6,10 @@
 
 #include "libbb.h"
 
-uint16_t FAST_FUNC inet_cksum(uint16_t *addr, int nleft)
+uint16_t FAST_FUNC inet_cksum(const void *ptr, int nleft)
 {
+        const uint16_t *addr = ptr;
+
         /*
          * Our algorithm is simple, using a 32 bit accumulator,
          * we add sequential 16 bit words to it, and at the end, fold
diff --git a/libbb/kernel_version.c b/libbb/kernel_version.c
index 7769a091b..6bb32ce5f 100644
--- a/libbb/kernel_version.c
+++ b/libbb/kernel_version.c
@@ -19,15 +19,17 @@ int FAST_FUNC get_linux_version_code(void)
 {
         struct utsname name;
         char *t;
-        int i, r;
+        int r;
 
         uname(&name); /* never fails */
-        t = name.release;
-        r = 0;
-        for (i = 0; i < 3; i++) {
-                t = strtok(t, ".");
-                r = r * 256 + (t ? atoi(t) : 0);
-                t = NULL;
-        }
-        return r;
+        t = name.release - 1;
+        r = 1;
+        do {
+                r <<= 8;
+                if (t) {
+                        r += atoi(++t);
+                        t = strchr(t, '.');
+                }
+        } while (r < 0x1000000);
+        return r - 0x1000000;
 }
diff --git a/libbb/loop.c b/libbb/loop.c
index ada0c7638..85b2724e5 100644
--- a/libbb/loop.c
+++ b/libbb/loop.c
@@ -102,7 +102,8 @@ int FAST_FUNC get_free_loop(void)
  * search will re-use an existing loop device already bound to that
  * file/offset if it finds one.
  */
-int FAST_FUNC set_loop(char **device, const char *file, unsigned long long offset, unsigned flags)
+int FAST_FUNC set_loop(char **device, const char *file, unsigned long long offset,
+                unsigned long long sizelimit, unsigned flags)
 {
         char dev[LOOP_NAMESIZE];
         char *try;
@@ -185,6 +186,7 @@ int FAST_FUNC set_loop(char **device, const char *file, unsigned long long offse
                                 memset(&loopinfo, 0, sizeof(loopinfo));
                                 safe_strncpy((char *)loopinfo.lo_file_name, file, LO_NAME_SIZE);
                                 loopinfo.lo_offset = offset;
+                                loopinfo.lo_sizelimit = sizelimit;
                                 /*
                                  * Used by mount to set LO_FLAGS_AUTOCLEAR.
                                  * LO_FLAGS_READ_ONLY is not set because RO is controlled by open type of the file.
diff --git a/libbb/ptr_to_globals.c b/libbb/ptr_to_globals.c
index 8ba9cd154..2232c6864 100644
--- a/libbb/ptr_to_globals.c
+++ b/libbb/ptr_to_globals.c
@@ -14,7 +14,7 @@ struct globals;
  * but here we make it live in R/W memory */
 struct globals *ptr_to_globals;
 
-#ifdef __GLIBC__
+#ifdef errno
 int *bb_errno;
 #endif
 
@@ -27,7 +27,7 @@ int *bb_errno;
  * on weird architectures, compilers, linkers and so on */
 struct globals *const ptr_to_globals __attribute__ ((section (".data")));
 
-#ifdef __GLIBC__
+#ifdef errno
 int *const bb_errno __attribute__ ((section (".data")));
 #endif
 
diff --git a/libbb/recursive_action.c b/libbb/recursive_action.c
index 0831ecc3a..b1c4bfad7 100644
--- a/libbb/recursive_action.c
+++ b/libbb/recursive_action.c
@@ -21,10 +21,9 @@
  * is so stinking huge.
  */
 
-static int FAST_FUNC true_action(const char *fileName UNUSED_PARAM,
-                struct stat *statbuf UNUSED_PARAM,
-                void* userData UNUSED_PARAM,
-                int depth UNUSED_PARAM)
+static int FAST_FUNC true_action(struct recursive_state *state UNUSED_PARAM,
+                const char *fileName UNUSED_PARAM,
+                struct stat *statbuf UNUSED_PARAM)
 {
         return TRUE;
 }
@@ -65,12 +64,7 @@ static int FAST_FUNC true_action(const char *fileName UNUSED_PARAM,
  * 1: stat(statbuf). Calls dirAction and optionally recurse on link to dir.
  */
 
-int FAST_FUNC recursive_action(const char *fileName,
-                unsigned flags,
-                int FAST_FUNC (*fileAction)(const char *fileName, struct stat *statbuf, void* userData, int depth),
-                int FAST_FUNC (*dirAction)(const char *fileName, struct stat *statbuf, void* userData, int depth),
-                void* userData,
-                unsigned depth)
+static int recursive_action1(recursive_state_t *state, const char *fileName)
 {
         struct stat statbuf;
         unsigned follow;
@@ -78,24 +72,21 @@ int FAST_FUNC recursive_action(const char *fileName,
         DIR *dir;
         struct dirent *next;
 
-        if (!fileAction) fileAction = true_action;
-        if (!dirAction) dirAction = true_action;
-
         follow = ACTION_FOLLOWLINKS;
-        if (depth == 0)
+        if (state->depth == 0)
                 follow = ACTION_FOLLOWLINKS | ACTION_FOLLOWLINKS_L0;
-        follow &= flags;
+        follow &= state->flags;
         status = (follow ? stat : lstat)(fileName, &statbuf);
         if (status < 0) {
 #ifdef DEBUG_RECURS_ACTION
-                bb_error_msg("status=%d flags=%x", status, flags);
+                bb_error_msg("status=%d flags=%x", status, state->flags);
 #endif
-                if ((flags & ACTION_DANGLING_OK)
+                if ((state->flags & ACTION_DANGLING_OK)
                  && errno == ENOENT
                  && lstat(fileName, &statbuf) == 0
                 ) {
                         /* Dangling link */
-                        return fileAction(fileName, &statbuf, userData, depth);
+                        return state->fileAction(state, fileName, &statbuf);
                 }
                 goto done_nak_warn;
         }
@@ -103,20 +94,20 @@ int FAST_FUNC recursive_action(const char *fileName,
         /* If S_ISLNK(m), then we know that !S_ISDIR(m).
          * Then we can skip checking first part: if it is true, then
          * (!dir) is also true! */
-        if ( /* (!(flags & ACTION_FOLLOWLINKS) && S_ISLNK(statbuf.st_mode)) || */
+        if ( /* (!(state->flags & ACTION_FOLLOWLINKS) && S_ISLNK(statbuf.st_mode)) || */
          !S_ISDIR(statbuf.st_mode)
         ) {
-                return fileAction(fileName, &statbuf, userData, depth);
+                return state->fileAction(state, fileName, &statbuf);
         }
 
         /* It's a directory (or a link to one, and followLinks is set) */
 
-        if (!(flags & ACTION_RECURSE)) {
-                return dirAction(fileName, &statbuf, userData, depth);
+        if (!(state->flags & ACTION_RECURSE)) {
+                return state->dirAction(state, fileName, &statbuf);
         }
 
-        if (!(flags & ACTION_DEPTHFIRST)) {
-                status = dirAction(fileName, &statbuf, userData, depth);
+        if (!(state->flags & ACTION_DEPTHFIRST)) {
+                status = state->dirAction(state, fileName, &statbuf);
                 if (status == FALSE)
                         goto done_nak_warn;
                 if (status == SKIP)
@@ -140,11 +131,13 @@ int FAST_FUNC recursive_action(const char *fileName,
                         continue;
 
                 /* process every file (NB: ACTION_RECURSE is set in flags) */
-                s = recursive_action(nextFile, flags, fileAction, dirAction,
-                                                userData, depth + 1);
+                state->depth++;
+                s = recursive_action1(state, nextFile);
                 if (s == FALSE)
                         status = FALSE;
                 free(nextFile);
+                state->depth--;
+
 //#define RECURSE_RESULT_ABORT -1
 //              if (s == RECURSE_RESULT_ABORT) {
 //                      closedir(dir);
@@ -153,15 +146,36 @@ int FAST_FUNC recursive_action(const char *fileName,
         }
         closedir(dir);
 
-        if (flags & ACTION_DEPTHFIRST) {
-                if (!dirAction(fileName, &statbuf, userData, depth))
+        if (state->flags & ACTION_DEPTHFIRST) {
+                if (!state->dirAction(state, fileName, &statbuf))
                         goto done_nak_warn;
         }
 
         return status;
 
  done_nak_warn:
-        if (!(flags & ACTION_QUIET))
+        if (!(state->flags & ACTION_QUIET))
                 bb_simple_perror_msg(fileName);
         return FALSE;
 }
+
+int FAST_FUNC recursive_action(const char *fileName,
+                unsigned flags,
+                int FAST_FUNC (*fileAction)(struct recursive_state *state, const char *fileName, struct stat* statbuf),
+                int FAST_FUNC  (*dirAction)(struct recursive_state *state, const char *fileName, struct stat* statbuf),
+                void *userData)
+{
+        /* Keeping a part of variables of recusive descent in a "state structure"
+         * instead of passing ALL of them down as parameters of recursive_action1()
+         * relieves register pressure, both in recursive_action1()
+         * and in every file/dirAction().
+         */
+        recursive_state_t state;
+        state.flags = flags;
+        state.depth = 0;
+        state.userData = userData;
+        state.fileAction = fileAction ? fileAction : true_action;
+        state.dirAction  =  dirAction ?  dirAction : true_action;
+
+        return recursive_action1(&state, fileName);
+}
diff --git a/libbb/update_passwd.c b/libbb/update_passwd.c
index c605c4c64..7b67f30cd 100644
--- a/libbb/update_passwd.c
+++ b/libbb/update_passwd.c
@@ -18,17 +18,20 @@
 #if ENABLE_SELINUX
 static void check_selinux_update_passwd(const char *username)
 {
-        security_context_t context;
-        char *seuser;
+        security_context_t seuser;
+        char *p;
 
         if (getuid() != (uid_t)0 || is_selinux_enabled() == 0)
                 return;  /* No need to check */
 
-        if (getprevcon_raw(&context) < 0)
+        if (getprevcon_raw(&seuser) < 0)
                 bb_simple_perror_msg_and_die("getprevcon failed");
-        seuser = strtok(context, ":");
-        if (!seuser)
-                bb_error_msg_and_die("invalid context '%s'", context);
+
+        p = strchr(seuser, ':');
+        if (!p)
+                bb_error_msg_and_die("invalid context '%s'", seuser);
+        *p = '\0';
+
         if (strcmp(seuser, username) != 0) {
                 security_class_t tclass;
                 access_vector_t av;