Merge commit '06f719fd79fe15ce6fd5431bc58fcb22851de24d^'

7 files changed, 355 insertions, 214 deletions

diff --git a/libbb/appletlib.c b/libbb/appletlib.c
index ab1d48c31..3b691f945 100644
--- a/libbb/appletlib.c
+++ b/libbb/appletlib.c
@@ -592,9 +592,11 @@ static const char usr_sbin[] ALIGN1 = "/usr/sbin/";
 static const char *const install_dir[] = {
         &usr_bin [8], /* "/" */
         &usr_bin [4], /* "/bin/" */
-        &usr_sbin[4], /* "/sbin/" */
-        usr_bin,
-        usr_sbin
+        &usr_sbin[4]  /* "/sbin/" */
+# if !ENABLE_INSTALL_NO_USR
+        ,usr_bin
+        ,usr_sbin
+# endif
 };
 
 
diff --git a/libbb/md5.c b/libbb/md5.c
index d8655ba91..051c8ede4 100644
--- a/libbb/md5.c
+++ b/libbb/md5.c
@@ -1,7 +1,7 @@
 /* vi: set sw=4 ts=4: */
 /*
- * md5.c - Compute MD5 checksum of strings according to the
- *         definition of MD5 in RFC 1321 from April 1992.
+ * Compute MD5 checksum of strings according to the
+ * definition of MD5 in RFC 1321 from April 1992.
  *
  * Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
  *
@@ -33,8 +33,7 @@ void FAST_FUNC md5_begin(md5_ctx_t *ctx)
         ctx->B = 0xefcdab89;
         ctx->C = 0x98badcfe;
         ctx->D = 0x10325476;
-        ctx->total = 0;
-        ctx->buflen = 0;
+        ctx->total64 = 0;
 }
 
 /* These are the four functions used in the four steps of the MD5 algorithm
@@ -49,13 +48,14 @@ void FAST_FUNC md5_begin(md5_ctx_t *ctx)
 
 #define rotl32(w, s) (((w) << (s)) | ((w) >> (32 - (s))))
 
-/* Hash a single block, 64 bytes long and 4-byte aligned. */
-static void md5_hash_block(const void *buffer, md5_ctx_t *ctx)
+/* Hash a single block, 64 bytes long and 4-byte aligned */
+static void md5_process_block64(md5_ctx_t *ctx)
 {
-        uint32_t correct_words[16];
-        const uint32_t *words = buffer;
-
 #if MD5_SIZE_VS_SPEED > 0
+        /* 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
+         */
         static const uint32_t C_array[] = {
                 /* round 1 */
                 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
@@ -64,7 +64,7 @@ static void md5_hash_block(const void *buffer, md5_ctx_t *ctx)
                 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
                 /* round 2 */
                 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
-                0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8,
+                0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
                 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
                 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
                 /* round 3 */
@@ -86,40 +86,33 @@ static void md5_hash_block(const void *buffer, md5_ctx_t *ctx)
                 5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2,   /* 3 */
                 0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9    /* 4 */
         };
-# if MD5_SIZE_VS_SPEED > 1
-        static const char S_array[] ALIGN1 = {
-                7, 12, 17, 22,
-                5, 9, 14, 20,
-                4, 11, 16, 23,
-                6, 10, 15, 21
-        };
-# endif /* MD5_SIZE_VS_SPEED > 1 */
 #endif
+        uint32_t *words = (void*) ctx->wbuffer;
         uint32_t A = ctx->A;
         uint32_t B = ctx->B;
         uint32_t C = ctx->C;
         uint32_t D = ctx->D;
 
-        /* Process all bytes in the buffer with 64 bytes in each round of
-           the loop.  */
-        uint32_t *cwp = correct_words;
-        uint32_t A_save = A;
-        uint32_t B_save = B;
-        uint32_t C_save = C;
-        uint32_t D_save = D;
+#if MD5_SIZE_VS_SPEED >= 2  /* 2 or 3 */
 
-#if MD5_SIZE_VS_SPEED > 1
+        static const char S_array[] ALIGN1 = {
+                7, 12, 17, 22,
+                5, 9, 14, 20,
+                4, 11, 16, 23,
+                6, 10, 15, 21
+        };
         const uint32_t *pc;
         const char *pp;
         const char *ps;
         int i;
         uint32_t temp;
 
+# if BB_BIG_ENDIAN
         for (i = 0; i < 16; i++)
-                cwp[i] = SWAP_LE32(words[i]);
-        words += 16;
+                words[i] = SWAP_LE32(words[i]);
+# endif
 
-# if MD5_SIZE_VS_SPEED > 2
+# if MD5_SIZE_VS_SPEED == 3
         pc = C_array;
         pp = P_array;
         ps = S_array - 4;
@@ -141,7 +134,7 @@ static void md5_hash_block(const void *buffer, md5_ctx_t *ctx)
                 case 3:
                         temp += FI(B, C, D);
                 }
-                temp += cwp[(int) (*pp++)] + *pc++;
+                temp += words[(int) (*pp++)] + *pc++;
                 temp = rotl32(temp, ps[i & 3]);
                 temp += B;
                 A = D;
@@ -149,13 +142,13 @@ static void md5_hash_block(const void *buffer, md5_ctx_t *ctx)
                 C = B;
                 B = temp;
         }
-# else
+# else  /* MD5_SIZE_VS_SPEED == 2 */
         pc = C_array;
         pp = P_array;
         ps = S_array;
 
         for (i = 0; i < 16; i++) {
-                temp = A + FF(B, C, D) + cwp[(int) (*pp++)] + *pc++;
+                temp = A + FF(B, C, D) + words[(int) (*pp++)] + *pc++;
                 temp = rotl32(temp, ps[i & 3]);
                 temp += B;
                 A = D;
@@ -165,7 +158,7 @@ static void md5_hash_block(const void *buffer, md5_ctx_t *ctx)
         }
         ps += 4;
         for (i = 0; i < 16; i++) {
-                temp = A + FG(B, C, D) + cwp[(int) (*pp++)] + *pc++;
+                temp = A + FG(B, C, D) + words[(int) (*pp++)] + *pc++;
                 temp = rotl32(temp, ps[i & 3]);
                 temp += B;
                 A = D;
@@ -175,7 +168,7 @@ static void md5_hash_block(const void *buffer, md5_ctx_t *ctx)
         }
         ps += 4;
         for (i = 0; i < 16; i++) {
-                temp = A + FH(B, C, D) + cwp[(int) (*pp++)] + *pc++;
+                temp = A + FH(B, C, D) + words[(int) (*pp++)] + *pc++;
                 temp = rotl32(temp, ps[i & 3]);
                 temp += B;
                 A = D;
@@ -185,7 +178,7 @@ static void md5_hash_block(const void *buffer, md5_ctx_t *ctx)
         }
         ps += 4;
         for (i = 0; i < 16; i++) {
-                temp = A + FI(B, C, D) + cwp[(int) (*pp++)] + *pc++;
+                temp = A + FI(B, C, D) + words[(int) (*pp++)] + *pc++;
                 temp = rotl32(temp, ps[i & 3]);
                 temp += B;
                 A = D;
@@ -193,35 +186,41 @@ static void md5_hash_block(const void *buffer, md5_ctx_t *ctx)
                 C = B;
                 B = temp;
         }
+# endif
+        /* Add checksum to the starting values */
+        ctx->A += A;
+        ctx->B += B;
+        ctx->C += C;
+        ctx->D += D;
+
+#else  /* MD5_SIZE_VS_SPEED == 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_SIZE_VS_SPEED == 1
+        const uint32_t *pc;
+        const char *pp;
+        int i;
+# endif
 
-# endif /* MD5_SIZE_VS_SPEED > 2 */
-#else
         /* First round: using the given function, the context and a constant
-           the next context is computed.  Because the algorithms processing
+           the next context is computed.  Because the algorithm's processing
            unit is a 32-bit word and it is determined to work on words in
            little endian byte order we perhaps have to change the byte order
            before the computation.  To reduce the work for the next steps
-           we store the swapped words in the array CORRECT_WORDS.  */
+           we save swapped words in WORDS array.  */
+# undef OP
 # define OP(a, b, c, d, s, T) \
         do { \
-                a += FF(b, c, d) + (*cwp++ = SWAP_LE32(*words)) + T; \
-                ++words; \
+                a += FF(b, c, d) + (*words IF_BIG_ENDIAN(= SWAP_LE32(*words))) + T; \
+                words++; \
                 a = rotl32(a, s); \
                 a += b; \
         } while (0)
 
-        /* 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
-         */
-
-# if MD5_SIZE_VS_SPEED == 1
-        const uint32_t *pc;
-        const char *pp;
-        int i;
-# endif /* MD5_SIZE_VS_SPEED */
-
-        /* Round 1.  */
+        /* Round 1 */
 # if MD5_SIZE_VS_SPEED == 1
         pc = C_array;
         for (i = 0; i < 4; i++) {
@@ -247,20 +246,21 @@ static void md5_hash_block(const void *buffer, md5_ctx_t *ctx)
         OP(D, A, B, C, 12, 0xfd987193);
         OP(C, D, A, B, 17, 0xa679438e);
         OP(B, C, D, A, 22, 0x49b40821);
-# endif /* MD5_SIZE_VS_SPEED == 1 */
+# endif
+        words -= 16;
 
         /* For the second to fourth round we have the possibly swapped words
-           in CORRECT_WORDS.  Redefine the macro to take an additional first
+           in WORDS.  Redefine the macro to take an additional first
            argument specifying the function to use.  */
 # undef OP
 # define OP(f, a, b, c, d, k, s, T) \
         do { \
-                a += f(b, c, d) + correct_words[k] + T; \
+                a += f(b, c, d) + words[k] + T; \
                 a = rotl32(a, s); \
                 a += b; \
         } while (0)
 
-        /* Round 2.  */
+        /* Round 2 */
 # if MD5_SIZE_VS_SPEED == 1
         pp = P_array;
         for (i = 0; i < 4; i++) {
@@ -286,9 +286,9 @@ static void md5_hash_block(const void *buffer, md5_ctx_t *ctx)
         OP(FG, D, A, B, C, 2, 9, 0xfcefa3f8);
         OP(FG, C, D, A, B, 7, 14, 0x676f02d9);
         OP(FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
-# endif /* MD5_SIZE_VS_SPEED == 1 */
+# endif
 
-        /* Round 3.  */
+        /* Round 3 */
 # if MD5_SIZE_VS_SPEED == 1
         for (i = 0; i < 4; i++) {
                 OP(FH, A, B, C, D, (int) (*pp++), 4, *pc++);
@@ -313,9 +313,9 @@ static void md5_hash_block(const void *buffer, md5_ctx_t *ctx)
         OP(FH, D, A, B, C, 12, 11, 0xe6db99e5);
         OP(FH, C, D, A, B, 15, 16, 0x1fa27cf8);
         OP(FH, B, C, D, A, 2, 23, 0xc4ac5665);
-# endif /* MD5_SIZE_VS_SPEED == 1 */
+# endif
 
-        /* Round 4.  */
+        /* Round 4 */
 # if MD5_SIZE_VS_SPEED == 1
         for (i = 0; i < 4; i++) {
                 OP(FI, A, B, C, D, (int) (*pp++), 6, *pc++);
@@ -340,52 +340,62 @@ static void md5_hash_block(const void *buffer, md5_ctx_t *ctx)
         OP(FI, D, A, B, C, 11, 10, 0xbd3af235);
         OP(FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
         OP(FI, B, C, D, A, 9, 21, 0xeb86d391);
-# endif /* MD5_SIZE_VS_SPEED == 1 */
-#endif  /* MD5_SIZE_VS_SPEED > 1 */
-
-        /* Add the starting values of the context.  */
-        A += A_save;
-        B += B_save;
-        C += C_save;
-        D += D_save;
-
-        /* Put checksum in context given as argument.  */
-        ctx->A = A;
-        ctx->B = B;
-        ctx->C = C;
-        ctx->D = D;
+# endif
+        /* Add checksum to the starting values */
+        ctx->A = A_save + A;
+        ctx->B = B_save + B;
+        ctx->C = C_save + C;
+        ctx->D = D_save + D;
+#endif
 }
 
 /* Feed data through a temporary buffer to call md5_hash_aligned_block()
  * with chunks of data that are 4-byte aligned and a multiple of 64 bytes.
  * This function's internal buffer remembers previous data until it has 64
  * bytes worth to pass on.  Call md5_end() to flush this buffer. */
-void FAST_FUNC md5_hash(const void *buffer, size_t len, md5_ctx_t *ctx)
+void FAST_FUNC md5_hash(md5_ctx_t *ctx, const void *buffer, size_t len)
 {
-        char *buf = (char *)buffer;
+        unsigned bufpos = ctx->total64 & 63;
+        unsigned remaining;
 
-        /* RFC 1321 specifies the possible length of the file up to 2^64 bits,
+        /* RFC 1321 specifies the possible length of the file up to 2^64 bits.
          * Here we only track the number of bytes.  */
-        ctx->total += len;
-
-        /* Process all input. */
-        while (len) {
-                unsigned i = 64 - ctx->buflen;
-
-                /* Copy data into aligned buffer. */
-                if (i > len)
-                        i = len;
-                memcpy(ctx->buffer + ctx->buflen, buf, i);
-                len -= i;
-                ctx->buflen += i;
-                buf += i;
+        ctx->total64 += len;
+#if 0
+        remaining = 64 - bufpos;
+
+        /* Hash whole blocks */
+        while (len >= remaining) {
+                memcpy(ctx->wbuffer + bufpos, buffer, remaining);
+                buffer = (const char *)buffer + remaining;
+                len -= remaining;
+                remaining = 64;
+                bufpos = 0;
+                md5_process_block64(ctx);
+        }
 
-                /* When buffer fills up, process it. */
-                if (ctx->buflen == 64) {
-                        md5_hash_block(ctx->buffer, ctx);
-                        ctx->buflen = 0;
-                }
+        /* Save last, partial blosk */
+        memcpy(ctx->wbuffer + bufpos, buffer, len);
+#else
+        /* Tiny bit smaller code */
+        while (1) {
+                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 != 64) break; ... ; bufpos = 0;" */
+                bufpos -= 64;
+                if (bufpos != 0)
+                        break;
+                /* Buffer is filled up, process it */
+                md5_process_block64(ctx);
+                /*bufpos = 0; - already is */
         }
+#endif
 }
 
 /* Process the remaining bytes in the buffer and put result from CTX
@@ -393,26 +403,31 @@ void FAST_FUNC md5_hash(const void *buffer, size_t len, md5_ctx_t *ctx)
  * endian byte order, so that a byte-wise output yields to the wanted
  * ASCII representation of the message digest.
  */
-void FAST_FUNC md5_end(void *resbuf, md5_ctx_t *ctx)
+void FAST_FUNC md5_end(md5_ctx_t *ctx, void *resbuf)
 {
-        char *buf = ctx->buffer;
-        int i;
-
-        /* Pad data to block size.  */
-        buf[ctx->buflen++] = 0x80;
-        memset(buf + ctx->buflen, 0, 128 - ctx->buflen);
-
-        /* Put the 64-bit file length in *bits* at the end of the buffer.  */
-        ctx->total <<= 3;
-        if (ctx->buflen > 56)
-                buf += 64;
-        for (i = 0; i < 8; i++)
-                buf[56 + i] = ctx->total >> (i*8);
-
-        /* Process last bytes.  */
-        if (buf != ctx->buffer)
-                md5_hash_block(ctx->buffer, ctx);
-        md5_hash_block(buf, ctx);
+        unsigned bufpos = ctx->total64 & 63;
+        /* Pad the buffer to the next 64-byte boundary with 0x80,0,0,0... */
+        ctx->wbuffer[bufpos++] = 0x80;
+
+        /* This loop iterates either once or twice, no more, no less */
+        while (1) {
+                unsigned remaining = 64 - bufpos;
+                memset(ctx->wbuffer + bufpos, 0, remaining);
+                /* Do we have enough space for the length count? */
+                if (remaining >= 8) {
+                        /* Store the 64-bit counter of bits in the buffer in BE format */
+                        uint64_t t = ctx->total64 << 3;
+                        unsigned i;
+                        for (i = 0; i < 8; i++) {
+                                ctx->wbuffer[56 + i] = t;
+                                t >>= 8;
+                        }
+                }
+                md5_process_block64(ctx);
+                if (remaining >= 8)
+                        break;
+                bufpos = 0;
+        }
 
         /* The MD5 result is in little endian byte order.
          * We (ab)use the fact that A-D are consecutive in memory.
diff --git a/libbb/procps.c b/libbb/procps.c
index 7ffcd8dbc..ec43b221e 100644
--- a/libbb/procps.c
+++ b/libbb/procps.c
@@ -121,7 +121,7 @@ void FAST_FUNC free_procps_scan(procps_status_t* sp)
         free(sp);
 }
 
-#if ENABLE_FEATURE_TOPMEM
+#if ENABLE_FEATURE_TOPMEM || ENABLE_PMAP
 static unsigned long fast_strtoul_16(char **endptr)
 {
         unsigned char c;
diff --git a/libbb/pw_encrypt_md5.c b/libbb/pw_encrypt_md5.c
index 58964b567..889e09cab 100644
--- a/libbb/pw_encrypt_md5.c
+++ b/libbb/pw_encrypt_md5.c
@@ -92,10 +92,10 @@ md5_crypt(char result[MD5_OUT_BUFSIZE], const unsigned char *pw, const unsigned
         /* Hash. the password first, since that is what is most unknown */
         md5_begin(&ctx);
         pw_len = strlen((char*)pw);
-        md5_hash(pw, pw_len, &ctx);
+        md5_hash(&ctx, pw, pw_len);
 
         /* Then the salt including "$1$" */
-        md5_hash(salt, sl, &ctx);
+        md5_hash(&ctx, salt, sl);
 
         /* Copy salt to result; skip "$1$" */
         memcpy(result, salt, sl);
@@ -105,19 +105,19 @@ md5_crypt(char result[MD5_OUT_BUFSIZE], const unsigned char *pw, const unsigned
 
         /* Then just as many characters of the MD5(pw, salt, pw) */
         md5_begin(&ctx1);
-        md5_hash(pw, pw_len, &ctx1);
-        md5_hash(salt, sl, &ctx1);
-        md5_hash(pw, pw_len, &ctx1);
-        md5_end(final, &ctx1);
+        md5_hash(&ctx1, pw, pw_len);
+        md5_hash(&ctx1, salt, sl);
+        md5_hash(&ctx1, pw, pw_len);
+        md5_end(&ctx1, final);
         for (pl = pw_len; pl > 0; pl -= 16)
-                md5_hash(final, pl > 16 ? 16 : pl, &ctx);
+                md5_hash(&ctx, final, pl > 16 ? 16 : pl);
 
         /* Then something really weird... */
         memset(final, 0, sizeof(final));
         for (i = pw_len; i; i >>= 1) {
-                md5_hash(((i & 1) ? final : (const unsigned char *) pw), 1, &ctx);
+                md5_hash(&ctx, ((i & 1) ? final : (const unsigned char *) pw), 1);
         }
-        md5_end(final, &ctx);
+        md5_end(&ctx, final);
 
         /* And now, just to make sure things don't run too fast.
          * On a 60 Mhz Pentium this takes 34 msec, so you would
@@ -126,21 +126,21 @@ md5_crypt(char result[MD5_OUT_BUFSIZE], const unsigned char *pw, const unsigned
         for (i = 0; i < 1000; i++) {
                 md5_begin(&ctx1);
                 if (i & 1)
-                        md5_hash(pw, pw_len, &ctx1);
+                        md5_hash(&ctx1, pw, pw_len);
                 else
-                        md5_hash(final, 16, &ctx1);
+                        md5_hash(&ctx1, final, 16);
 
                 if (i % 3)
-                        md5_hash(salt, sl, &ctx1);
+                        md5_hash(&ctx1, salt, sl);
 
                 if (i % 7)
-                        md5_hash(pw, pw_len, &ctx1);
+                        md5_hash(&ctx1, pw, pw_len);
 
                 if (i & 1)
-                        md5_hash(final, 16, &ctx1);
+                        md5_hash(&ctx1, final, 16);
                 else
-                        md5_hash(pw, pw_len, &ctx1);
-                md5_end(final, &ctx1);
+                        md5_hash(&ctx1, pw, pw_len);
+                md5_end(&ctx1, final);
         }
 
         p = result + sl + 4; /* 12 bytes max (sl is up to 8 bytes) */
diff --git a/libbb/sha1.c b/libbb/sha1.c
index beeb70cf6..d79291148 100644
--- a/libbb/sha1.c
+++ b/libbb/sha1.c
@@ -30,11 +30,29 @@
 
 #include "libbb.h"
 
-#define rotl32(x,n) (((x) << (n)) | ((x) >> (32 - (n))))
-#define rotr32(x,n) (((x) >> (n)) | ((x) << (32 - (n))))
-/* for sha512: */
-#define rotr64(x,n) (((x) >> (n)) | ((x) << (64 - (n))))
+/* gcc 4.2.1 optimizes rotr64 better with inline than with macro
+ * (for rotX32, there is no difference). Why? My guess is that
+ * macro requires clever common subexpression elimination heuristics
+ * in gcc, while inline basically forces it to happen.
+ */
+//#define rotl32(x,n) (((x) << (n)) | ((x) >> (32 - (n))))
+static ALWAYS_INLINE uint32_t rotl32(uint32_t x, unsigned n)
+{
+        return (x << n) | (x >> (32 - n));
+}
+//#define rotr32(x,n) (((x) >> (n)) | ((x) << (32 - (n))))
+static ALWAYS_INLINE uint32_t rotr32(uint32_t x, unsigned n)
+{
+        return (x >> n) | (x << (32 - n));
+}
+/* rotr64 in needed for sha512 only: */
+//#define rotr64(x,n) (((x) >> (n)) | ((x) << (64 - (n))))
+static ALWAYS_INLINE uint64_t rotr64(uint64_t x, unsigned n)
+{
+        return (x >> n) | (x << (64 - n));
+}
 #if BB_LITTLE_ENDIAN
+/* ALWAYS_INLINE below would hurt code size, using plain inline: */
 static inline uint64_t hton64(uint64_t v)
 {
         return (((uint64_t)htonl(v)) << 32) | htonl(v >> 32);
@@ -44,14 +62,6 @@ static inline uint64_t hton64(uint64_t v)
 #endif
 #define ntoh64(v) hton64(v)
 
-/* To check alignment gcc has an appropriate operator.  Other
-   compilers don't.  */
-#if defined(__GNUC__) && __GNUC__ >= 2
-# define UNALIGNED_P(p,type) (((uintptr_t) p) % __alignof__(type) != 0)
-#else
-# define UNALIGNED_P(p,type) (((uintptr_t) p) % sizeof(type) != 0)
-#endif
-
 
 /* Some arch headers have conflicting defines */
 #undef ch
@@ -65,11 +75,8 @@ static void FAST_FUNC sha1_process_block64(sha1_ctx_t *ctx)
         uint32_t W[80], a, b, c, d, e;
         const uint32_t *words = (uint32_t*) ctx->wbuffer;
 
-        for (t = 0; t < 16; ++t) {
-                W[t] = ntohl(*words);
-                words++;
-        }
-
+        for (t = 0; t < 16; ++t)
+                W[t] = ntohl(words[t]);
         for (/*t = 16*/; t < 80; ++t) {
                 uint32_t T = W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16];
                 W[t] = rotl32(T, 1);
@@ -190,11 +197,8 @@ static void FAST_FUNC sha256_process_block64(sha256_ctx_t *ctx)
 #define R1(x) (rotr32(x, 17) ^ rotr32(x, 19) ^ (x >> 10))
 
         /* Compute the message schedule according to FIPS 180-2:6.2.2 step 2.  */
-        for (t = 0; t < 16; ++t) {
-                W[t] = ntohl(*words);
-                words++;
-        }
-
+        for (t = 0; t < 16; ++t)
+                W[t] = ntohl(words[t]);
         for (/*t = 16*/; t < 64; ++t)
                 W[t] = R1(W[t - 2]) + W[t - 7] + R0(W[t - 15]) + W[t - 16];
 
@@ -269,10 +273,8 @@ static void FAST_FUNC sha512_process_block128(sha512_ctx_t *ctx)
 #define R1(x) (rotr64(x, 19) ^ rotr64(x, 61) ^ (x >> 6))
 
         /* Compute the message schedule according to FIPS 180-2:6.3.2 step 2.  */
-        for (t = 0; t < 16; ++t) {
-                W[t] = ntoh64(*words);
-                words++;
-        }
+        for (t = 0; t < 16; ++t)
+                W[t] = ntoh64(words[t]);
         for (/*t = 16*/; t < 80; ++t)
                 W[t] = R1(W[t - 2]) + W[t - 7] + R0(W[t - 15]) + W[t - 16];
 
@@ -327,7 +329,9 @@ static const uint32_t init256[] = {
         0x510e527f,
         0x9b05688c,
         0x1f83d9ab,
-        0x5be0cd19
+        0x5be0cd19,
+        0,
+        0,
 };
 static const uint32_t init512_lo[] = {
         0xf3bcc908,
@@ -337,7 +341,9 @@ static const uint32_t init512_lo[] = {
         0xade682d1,
         0x2b3e6c1f,
         0xfb41bd6b,
-        0x137e2179
+        0x137e2179,
+        0,
+        0,
 };
 
 /* Initialize structure containing state of computation.
@@ -345,7 +351,7 @@ static const uint32_t init512_lo[] = {
 void FAST_FUNC sha256_begin(sha256_ctx_t *ctx)
 {
         memcpy(ctx->hash, init256, sizeof(init256));
-        ctx->total64 = 0;
+        /*ctx->total64 = 0; - done by extending init256 with two 32-bit zeros */
         ctx->process_block = sha256_process_block64;
 }
 
@@ -354,36 +360,61 @@ void FAST_FUNC sha256_begin(sha256_ctx_t *ctx)
 void FAST_FUNC sha512_begin(sha512_ctx_t *ctx)
 {
         int i;
-        for (i = 0; i < 8; i++)
+        /* Two extra iterations zero out ctx->total64[] */
+        for (i = 0; i < 8+2; i++)
                 ctx->hash[i] = ((uint64_t)(init256[i]) << 32) + init512_lo[i];
-        ctx->total64[0] = ctx->total64[1] = 0;
+        /*ctx->total64[0] = ctx->total64[1] = 0; - already done */
 }
 
 
 /* Used also for sha256 */
-void FAST_FUNC sha1_hash(const void *buffer, size_t len, sha1_ctx_t *ctx)
+void FAST_FUNC sha1_hash(sha1_ctx_t *ctx, const void *buffer, size_t len)
 {
-        unsigned in_buf = ctx->total64 & 63;
-        unsigned add = 64 - in_buf;
+        unsigned bufpos = ctx->total64 & 63;
+        unsigned remaining;
 
         ctx->total64 += len;
-
-        while (len >= add) {    /* transfer whole blocks while possible  */
-                memcpy(ctx->wbuffer + in_buf, buffer, add);
-                buffer = (const char *)buffer + add;
-                len -= add;
-                add = 64;
-                in_buf = 0;
+#if 0
+        remaining = 64 - bufpos;
+
+        /* Hash whole blocks */
+        while (len >= remaining) {
+                memcpy(ctx->wbuffer + bufpos, buffer, remaining);
+                buffer = (const char *)buffer + remaining;
+                len -= remaining;
+                remaining = 64;
+                bufpos = 0;
                 ctx->process_block(ctx);
         }
 
-        memcpy(ctx->wbuffer + in_buf, buffer, len);
+        /* Save last, partial blosk */
+        memcpy(ctx->wbuffer + bufpos, buffer, len);
+#else
+        /* Tiny bit smaller code */
+        while (1) {
+                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 != 64) break; ... ; bufpos = 0;" */
+                bufpos -= 64;
+                if (bufpos != 0)
+                        break;
+                /* Buffer is filled up, process it */
+                ctx->process_block(ctx);
+                /*bufpos = 0; - already is */
+        }
+#endif
 }
 
-void FAST_FUNC sha512_hash(const void *buffer, size_t len, sha512_ctx_t *ctx)
+void FAST_FUNC sha512_hash(sha512_ctx_t *ctx, const void *buffer, size_t len)
 {
-        unsigned in_buf = ctx->total64[0] & 127;
-        unsigned add = 128 - in_buf;
+        unsigned bufpos = ctx->total64[0] & 127;
+        unsigned remaining;
 
         /* First increment the byte count.  FIPS 180-2 specifies the possible
            length of the file up to 2^128 _bits_.
@@ -391,36 +422,57 @@ void FAST_FUNC sha512_hash(const void *buffer, size_t len, sha512_ctx_t *ctx)
         ctx->total64[0] += len;
         if (ctx->total64[0] < len)
                 ctx->total64[1]++;
-
-        while (len >= add) {    /* transfer whole blocks while possible  */
-                memcpy(ctx->wbuffer + in_buf, buffer, add);
-                buffer = (const char *)buffer + add;
-                len -= add;
-                add = 128;
-                in_buf = 0;
+#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);
         }
 
-        memcpy(ctx->wbuffer + in_buf, buffer, len);
+        /* Save last, partial blosk */
+        memcpy(ctx->wbuffer + bufpos, buffer, len);
+#else
+        while (1) {
+                remaining = 128 - 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 != 128) break; ... ; bufpos = 0;" */
+                bufpos -= 128;
+                if (bufpos != 0)
+                        break;
+                /* Buffer is filled up, process it */
+                sha512_process_block128(ctx);
+                /*bufpos = 0; - already is */
+        }
+#endif
 }
 
 
 /* Used also for sha256 */
-void FAST_FUNC sha1_end(void *resbuf, sha1_ctx_t *ctx)
+void FAST_FUNC sha1_end(sha1_ctx_t *ctx, void *resbuf)
 {
-        unsigned pad, in_buf;
+        unsigned bufpos = ctx->total64 & 63;
 
-        in_buf = ctx->total64 & 63;
         /* Pad the buffer to the next 64-byte boundary with 0x80,0,0,0... */
-        ctx->wbuffer[in_buf++] = 0x80;
+        ctx->wbuffer[bufpos++] = 0x80;
 
         /* This loop iterates either once or twice, no more, no less */
         while (1) {
-                pad = 64 - in_buf;
-                memset(ctx->wbuffer + in_buf, 0, pad);
-                in_buf = 0;
+                unsigned remaining = 64 - bufpos;
+                memset(ctx->wbuffer + bufpos, 0, remaining);
                 /* Do we have enough space for the length count? */
-                if (pad >= 8) {
+                if (remaining >= 8) {
                         /* Store the 64-bit counter of bits in the buffer in BE format */
                         uint64_t t = ctx->total64 << 3;
                         t = hton64(t);
@@ -428,35 +480,32 @@ void FAST_FUNC sha1_end(void *resbuf, sha1_ctx_t *ctx)
                         *(uint64_t *) (&ctx->wbuffer[64 - 8]) = t;
                 }
                 ctx->process_block(ctx);
-                if (pad >= 8)
+                if (remaining >= 8)
                         break;
+                bufpos = 0;
         }
 
-        in_buf = (ctx->process_block == sha1_process_block64) ? 5 : 8;
+        bufpos = (ctx->process_block == sha1_process_block64) ? 5 : 8;
         /* This way we do not impose alignment constraints on resbuf: */
         if (BB_LITTLE_ENDIAN) {
                 unsigned i;
-                for (i = 0; i < in_buf; ++i)
+                for (i = 0; i < bufpos; ++i)
                         ctx->hash[i] = htonl(ctx->hash[i]);
         }
-        memcpy(resbuf, ctx->hash, sizeof(ctx->hash[0]) * in_buf);
+        memcpy(resbuf, ctx->hash, sizeof(ctx->hash[0]) * bufpos);
 }
 
-void FAST_FUNC sha512_end(void *resbuf, sha512_ctx_t *ctx)
+void FAST_FUNC sha512_end(sha512_ctx_t *ctx, void *resbuf)
 {
-        unsigned pad, in_buf;
+        unsigned bufpos = ctx->total64[0] & 127;
 
-        in_buf = ctx->total64[0] & 127;
-        /* Pad the buffer to the next 128-byte boundary with 0x80,0,0,0...
-         * (FIPS 180-2:5.1.2)
-         */
-        ctx->wbuffer[in_buf++] = 0x80;
+        /* Pad the buffer to the next 128-byte boundary with 0x80,0,0,0... */
+        ctx->wbuffer[bufpos++] = 0x80;
 
         while (1) {
-                pad = 128 - in_buf;
-                memset(ctx->wbuffer + in_buf, 0, pad);
-                in_buf = 0;
-                if (pad >= 16) {
+                unsigned remaining = 128 - bufpos;
+                memset(ctx->wbuffer + bufpos, 0, remaining);
+                if (remaining >= 16) {
                         /* Store the 128-bit counter of bits in the buffer in BE format */
                         uint64_t t;
                         t = ctx->total64[0] << 3;
@@ -467,8 +516,9 @@ void FAST_FUNC sha512_end(void *resbuf, sha512_ctx_t *ctx)
                         *(uint64_t *) (&ctx->wbuffer[128 - 16]) = t;
                 }
                 sha512_process_block128(ctx);
-                if (pad >= 16)
+                if (remaining >= 16)
                         break;
+                bufpos = 0;
         }
 
         if (BB_LITTLE_ENDIAN) {
diff --git a/libbb/uuencode.c b/libbb/uuencode.c
index 181f49de0..03e708fd5 100644
--- a/libbb/uuencode.c
+++ b/libbb/uuencode.c
@@ -1,6 +1,8 @@
 /* vi: set sw=4 ts=4: */
 /*
- * Copyright 2006 Rob Landley <rob@landley.net>
+ * Copyright 2003, Glenn McGrath
+ * Copyright 2006, Rob Landley <rob@landley.net>
+ * Copyright 2010, Denys Vlasenko
  *
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
@@ -69,3 +71,75 @@ void FAST_FUNC bb_uuencode(char *p, const void *src, int length, const char *tbl
                 length++;
         }
 }
+
+/*
+ * Decode base64 encoded stream.
+ * Can stop on EOF, specified char, or on uuencode-style "====" line:
+ * flags argument controls it.
+ */
+void FAST_FUNC read_base64(FILE *src_stream, FILE *dst_stream, int flags)
+{
+/* Note that EOF _can_ be passed as exit_char too */
+#define exit_char    ((int)(signed char)flags)
+#define uu_style_end (flags & BASE64_FLAG_UU_STOP)
+
+        int term_count = 0;
+
+        while (1) {
+                unsigned char translated[4];
+                int count = 0;
+
+                /* Process one group of 4 chars */
+                while (count < 4) {
+                        char *table_ptr;
+                        int ch;
+
+                        /* Get next _valid_ character.
+                         * bb_uuenc_tbl_base64[] contains this string:
+                         *  0         1         2         3         4         5         6
+                         *  012345678901234567890123456789012345678901234567890123456789012345
+                         * "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n"
+                         */
+                        do {
+                                ch = fgetc(src_stream);
+                                if (ch == exit_char && count == 0)
+                                        return;
+                                if (ch == EOF)
+                                        bb_error_msg_and_die("truncated base64 input");
+                                table_ptr = strchr(bb_uuenc_tbl_base64, ch);
+//TODO: add BASE64_FLAG_foo to die on bad char?
+//Note that then we may need to still allow '\r' (for mail processing)
+                        } while (!table_ptr);
+
+                        /* Convert encoded character to decimal */
+                        ch = table_ptr - bb_uuenc_tbl_base64;
+
+                        if (ch == 65 /* '\n' */) {
+                                /* Terminating "====" line? */
+                                if (uu_style_end && term_count == 4)
+                                        return; /* yes */
+                                term_count = 0;
+                                continue;
+                        }
+                        /* ch is 64 if char was '=', otherwise 0..63 */
+                        translated[count] = ch & 63; /* 64 -> 0 */
+                        if (ch == 64) {
+                                term_count++;
+                                break;
+                        }
+                        count++;
+                        term_count = 0;
+                }
+
+                /* Merge 6 bit chars to 8 bit.
+                 * count can be < 4 when we decode the tail:
+                 * "eQ==" -> "y", not "y NUL NUL"
+                 */
+                if (count > 1)
+                        fputc(translated[0] << 2 | translated[1] >> 4, dst_stream);
+                if (count > 2)
+                        fputc(translated[1] << 4 | translated[2] >> 2, dst_stream);
+                if (count > 3)
+                        fputc(translated[2] << 6 | translated[3], dst_stream);
+        } /* while (1) */
+}
diff --git a/libbb/xfuncs_printf.c b/libbb/xfuncs_printf.c
index ae950f94f..8e60e2165 100644
--- a/libbb/xfuncs_printf.c
+++ b/libbb/xfuncs_printf.c
@@ -134,7 +134,7 @@ int FAST_FUNC xopen3(const char *pathname, int flags, int mode)
         return ret;
 }
 
-// Die if we can't open an existing file and return a fd.
+// Die if we can't open a file and return a fd.
 int FAST_FUNC xopen(const char *pathname, int flags)
 {
         return xopen3(pathname, flags, 0666);