Merge commit 'e4dcba1c103dc28e927e004791e331aaf604383d^'

6 files changed, 136 insertions, 100 deletions

diff --git a/libbb/Config.src b/libbb/Config.src
index 74dc9c549..f6c7a11ea 100644
--- a/libbb/Config.src
+++ b/libbb/Config.src
@@ -43,6 +43,17 @@ config FEATURE_ETC_NETWORKS
           a rarely used feature which allows you to use names
           instead of IP/mask pairs in route command.
 
+config FEATURE_USE_TERMIOS
+        bool "Use termios to manipulate the screen"
+        default y
+        depends on MORE || TOP || POWERTOP
+        help
+          This option allows utilities such as 'more' and 'top' to determine
+          the size of the screen. If you leave this disabled, your utilities
+          that display things on the screen will be especially primitive and
+          will be unable to determine the current screen size, and will be
+          unable to move the cursor.
+
 config FEATURE_EDITING
         bool "Command line editing"
         default y
diff --git a/libbb/crc32.c b/libbb/crc32.c
index 520b1ffb9..c63bf0772 100644
--- a/libbb/crc32.c
+++ b/libbb/crc32.c
@@ -18,6 +18,8 @@
 
 #include "libbb.h"
 
+uint32_t *global_crc32_table;
+
 uint32_t* FAST_FUNC crc32_filltable(uint32_t *crc_table, int endian)
 {
         uint32_t polynomial = endian ? 0x04c11db7 : 0xedb88320;
@@ -40,3 +42,25 @@ uint32_t* FAST_FUNC crc32_filltable(uint32_t *crc_table, int endian)
 
         return crc_table - 256;
 }
+
+uint32_t FAST_FUNC crc32_block_endian1(uint32_t val, const void *buf, unsigned len, uint32_t *crc_table)
+{
+        const void *end = (uint8_t*)buf + len;
+
+        while (buf != end) {
+                val = (val << 8) ^ crc_table[(val >> 24) ^ *(uint8_t*)buf];
+                buf = (uint8_t*)buf + 1;
+        }
+        return val;
+}
+
+uint32_t FAST_FUNC crc32_block_endian0(uint32_t val, const void *buf, unsigned len, uint32_t *crc_table)
+{
+        const void *end = (uint8_t*)buf + len;
+
+        while (buf != end) {
+                val = crc_table[(uint8_t)val ^ *(uint8_t*)buf] ^ (val >> 8);
+                buf = (uint8_t*)buf + 1;
+        }
+        return val;
+}
diff --git a/libbb/hash_md5_sha.c b/libbb/hash_md5_sha.c
index aeacddef8..e427f6080 100644
--- a/libbb/hash_md5_sha.c
+++ b/libbb/hash_md5_sha.c
@@ -473,20 +473,13 @@ void FAST_FUNC md5_end(md5_ctx_t *ctx, void *resbuf)
 
 
 /*
- * Based on shasum from http://www.netsw.org/crypto/hash/
- * Majorly hacked up to use Dr Brian Gladman's sha1 code
+ * SHA1 part is:
+ * Copyright 2007 Rob Landley <rob@landley.net>
  *
- * Copyright (C) 2002 Dr Brian Gladman <brg@gladman.me.uk>, Worcester, UK.
- * Copyright (C) 2003 Glenn L. McGrath
- * Copyright (C) 2003 Erik Andersen
- *
- * Licensed under GPLv2 or later, see file LICENSE in this source tree.
- *
- * ---------------------------------------------------------------------------
- * Issue Date: 10/11/2002
+ * Based on the public domain SHA-1 in C by Steve Reid <steve@edmweb.com>
+ * from http://www.mirrors.wiretapped.net/security/cryptography/hashes/sha1/
  *
- * This is a byte oriented version of SHA1 that operates on arrays of bytes
- * stored in memory. It runs at 22 cycles per byte on a Pentium P4 processor
+ * Licensed under GPLv2, see file LICENSE in this source tree.
  *
  * ---------------------------------------------------------------------------
  *
@@ -503,16 +496,18 @@ void FAST_FUNC md5_end(md5_ctx_t *ctx, void *resbuf)
 
 static void FAST_FUNC sha1_process_block64(sha1_ctx_t *ctx)
 {
-        unsigned t;
-        uint32_t W[80], a, b, c, d, e;
-        const uint32_t *words = (uint32_t*) ctx->wbuffer;
+        static const uint32_t rconsts[] = {
+                0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6
+        };
+        int i, j;
+        int cnt;
+        uint32_t W[16+16];
+        uint32_t a, b, c, d, e;
 
-        for (t = 0; t < 16; ++t)
-                W[t] = SWAP_BE32(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);
-        }
+        /* On-stack work buffer frees up one register in the main loop
+         * which otherwise will be needed to hold ctx pointer */
+        for (i = 0; i < 16; i++)
+                W[i] = W[i+16] = SWAP_BE32(((uint32_t*)ctx->wbuffer)[i]);
 
         a = ctx->hash[0];
         b = ctx->hash[1];
@@ -520,39 +515,41 @@ static void FAST_FUNC sha1_process_block64(sha1_ctx_t *ctx)
         d = ctx->hash[3];
         e = ctx->hash[4];
 
-#undef ch
-#undef parity
-#undef maj
-#undef rnd
-#define ch(x,y,z)        ((z) ^ ((x) & ((y) ^ (z))))
-#define parity(x,y,z)    ((x) ^ (y) ^ (z))
-#define maj(x,y,z)       (((x) & (y)) | ((z) & ((x) | (y))))
-/* A normal version as set out in the FIPS.  */
-#define rnd(f,k) \
-        do { \
-                uint32_t T = a; \
-                a = rotl32(a, 5) + f(b, c, d) + e + k + W[t]; \
-                e = d; \
-                d = c; \
-                c = rotl32(b, 30); \
-                b = T; \
-        } while (0)
-
-        for (t = 0; t < 20; ++t)
-                rnd(ch, 0x5a827999);
-
-        for (/*t = 20*/; t < 40; ++t)
-                rnd(parity, 0x6ed9eba1);
-
-        for (/*t = 40*/; t < 60; ++t)
-                rnd(maj, 0x8f1bbcdc);
-
-        for (/*t = 60*/; t < 80; ++t)
-                rnd(parity, 0xca62c1d6);
-#undef ch
-#undef parity
-#undef maj
-#undef rnd
+        /* 4 rounds of 20 operations each */
+        cnt = 0;
+        for (i = 0; i < 4; i++) {
+                j = 19;
+                do {
+                        uint32_t work;
+
+                        work = c ^ d;
+                        if (i == 0) {
+                                work = (work & b) ^ d;
+                                if (j <= 3)
+                                        goto ge16;
+                                /* Used to do SWAP_BE32 here, but this
+                                 * requires ctx (see comment above) */
+                                work += W[cnt];
+                        } else {
+                                if (i == 2)
+                                        work = ((b | c) & d) | (b & c);
+                                else /* i = 1 or 3 */
+                                        work ^= b;
+ ge16:
+                                W[cnt] = W[cnt+16] = rotl32(W[cnt+13] ^ W[cnt+8] ^ W[cnt+2] ^ W[cnt], 1);
+                                work += W[cnt];
+                        }
+                        work += e + rotl32(a, 5) + rconsts[i];
+
+                        /* Rotate by one for next time */
+                        e = d;
+                        d = c;
+                        c = /* b = */ rotl32(b, 30);
+                        b = a;
+                        a = work;
+                        cnt = (cnt + 1) & 15;
+                } while (--j >= 0);
+        }
 
         ctx->hash[0] += a;
         ctx->hash[1] += b;
diff --git a/libbb/human_readable.c b/libbb/human_readable.c
index 22dc5d23f..50cbe41bb 100644
--- a/libbb/human_readable.c
+++ b/libbb/human_readable.c
@@ -94,7 +94,7 @@ const char* FAST_FUNC make_human_readable_str(unsigned long long val,
 
 /* 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[6], const char *scale)
+void FAST_FUNC smart_ulltoa5(unsigned long long ul, char buf[5], const char *scale)
 {
         const char *fmt;
         char c;
@@ -150,7 +150,7 @@ void FAST_FUNC smart_ulltoa5(unsigned long long ul, char buf[6], const char *sca
 /* Convert unsigned long long value into compact 4-char
  * 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[5], const char *scale)
+void FAST_FUNC smart_ulltoa4(unsigned long long ul, char buf[4], const char *scale)
 {
         const char *fmt;
         char c;
diff --git a/libbb/parse_config.c b/libbb/parse_config.c
index 3fff9f212..9dbfaf5d7 100644
--- a/libbb/parse_config.c
+++ b/libbb/parse_config.c
@@ -187,19 +187,7 @@ again:
 
 #if 0 /* unused so far */
                 if (flags & PARSE_ESCAPE) {
-                        const char *from;
-                        char *to;
-
-                        from = to = tokens[t];
-                        while (*from) {
-                                if (*from == '\\') {
-                                        from++;
-                                        *to++ = bb_process_escape_sequence(&from);
-                                } else {
-                                        *to++ = *from++;
-                                }
-                        }
-                        *to = '\0';
+                        strcpy_and_process_escape_sequences(tokens[t], tokens[t]);
                 }
 #endif
                 /* Skip possible delimiters */
diff --git a/libbb/process_escape_sequence.c b/libbb/process_escape_sequence.c
index 82cbe10dc..346ecfa1e 100644
--- a/libbb/process_escape_sequence.c
+++ b/libbb/process_escape_sequence.c
@@ -18,52 +18,42 @@
 
 char FAST_FUNC bb_process_escape_sequence(const char **ptr)
 {
-        /* bash builtin "echo -e '\ec'" interprets \e as ESC,
-         * but coreutils "/bin/echo -e '\ec'" does not.
-         * manpages tend to support coreutils way.
-         * Update: coreutils added support for \e on 28 Oct 2009. */
-        static const char charmap[] ALIGN1 = {
-                'a',  'b', 'e', 'f',  'n',  'r',  't',  'v',  '\\', 0,
-                '\a', '\b', 27, '\f', '\n', '\r', '\t', '\v', '\\', '\\' };
-
-        const char *p;
         const char *q;
         unsigned num_digits;
-        unsigned r;
         unsigned n;
-        unsigned d;
         unsigned base;
 
         num_digits = n = 0;
         base = 8;
         q = *ptr;
 
-#ifdef WANT_HEX_ESCAPES
-        if (*q == 'x') {
+        if (WANT_HEX_ESCAPES && *q == 'x') {
                 ++q;
                 base = 16;
                 ++num_digits;
         }
-#endif
 
         /* bash requires leading 0 in octal escapes:
          * \02 works, \2 does not (prints \ and 2).
          * We treat \2 as a valid octal escape sequence. */
         do {
-                d = (unsigned char)(*q) - '0';
-#ifdef WANT_HEX_ESCAPES
-                if (d >= 10) {
-                        d = (unsigned char)(_tolower(*q)) - 'a' + 10;
-                }
+                unsigned r;
+#if !WANT_HEX_ESCAPES
+                unsigned d = (unsigned char)(*q) - '0';
+#else
+                unsigned d = (unsigned char)_tolower(*q) - '0';
+                if (d >= 10)
+                        d += ('0' - 'a' + 10);
 #endif
-
                 if (d >= base) {
-#ifdef WANT_HEX_ESCAPES
-                        if ((base == 16) && (!--num_digits)) {
-/*                              return '\\'; */
-                                --q;
+                        if (WANT_HEX_ESCAPES && base == 16) {
+                                --num_digits;
+                                if (num_digits == 0) {
+                                        /* \x<bad_char>: return '\',
+                                         * leave ptr pointing to x */
+                                        return '\\';
+                                }
                         }
-#endif
                         break;
                 }
 
@@ -76,21 +66,47 @@ char FAST_FUNC bb_process_escape_sequence(const char **ptr)
                 ++q;
         } while (++num_digits < 3);
 
-        if (num_digits == 0) {  /* mnemonic escape sequence? */
-                p = charmap;
+        if (num_digits == 0) {
+                /* Not octal or hex escape sequence.
+                 * Is it one-letter one? */
+
+                /* bash builtin "echo -e '\ec'" interprets \e as ESC,
+                 * but coreutils "/bin/echo -e '\ec'" does not.
+                 * Manpages tend to support coreutils way.
+                 * Update: coreutils added support for \e on 28 Oct 2009. */
+                static const char charmap[] ALIGN1 = {
+                        'a',  'b', 'e', 'f',  'n',  'r',  't',  'v',  '\\', '\0',
+                        '\a', '\b', 27, '\f', '\n', '\r', '\t', '\v', '\\', '\\',
+                };
+                const char *p = charmap;
                 do {
                         if (*p == *q) {
                                 q++;
                                 break;
                         }
-                } while (*++p);
+                } while (*++p != '\0');
                 /* p points to found escape char or NUL,
-                 * advance it and find what it translates to */
-                p += sizeof(charmap) / 2;
-                n = *p;
+                 * advance it and find what it translates to.
+                 * Note that \NUL and unrecognized sequence \z return '\'
+                 * and leave ptr pointing to NUL or z. */
+                n = p[sizeof(charmap) / 2];
         }
 
         *ptr = q;
 
         return (char) n;
 }
+
+char* FAST_FUNC strcpy_and_process_escape_sequences(char *dst, const char *src)
+{
+        while (1) {
+                char c, c1;
+                c = c1 = *src++;
+                if (c1 == '\\')
+                        c1 = bb_process_escape_sequence(&src);
+                *dst = c1;
+                if (c == '\0')
+                        return dst;
+                dst++;
+        }
+}