Merge branch 'busybox' into merge

5 files changed, 96 insertions, 18 deletions

diff --git a/libbb/appletlib.c b/libbb/appletlib.c
index 44161a219..14b21f827 100644
--- a/libbb/appletlib.c
+++ b/libbb/appletlib.c
@@ -608,7 +608,11 @@ static void install_links(const char *busybox, int use_symbolic_links,
         }
 }
 # else
-#  define install_links(x,y,z) ((void)0)
+static void install_links(const char *busybox UNUSED_PARAM,
+                int use_symbolic_links UNUSED_PARAM,
+                char *custom_install_dir UNUSED_PARAM)
+{
+}
 # endif
 
 /* If we were called as "busybox..." */
diff --git a/libbb/inode_hash.c b/libbb/inode_hash.c
index 715535ef5..f11c2afb2 100644
--- a/libbb/inode_hash.c
+++ b/libbb/inode_hash.c
@@ -11,14 +11,23 @@
 #include "libbb.h"
 
 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 */
 static ino_dev_hashtable_bucket_t **ino_dev_hashtable;
@@ -38,6 +47,7 @@ char* FAST_FUNC is_in_ino_dev_hashtable(const struct stat *statbuf)
         while (bucket != NULL) {
                 if ((bucket->ino == statbuf->st_ino)
                  && (bucket->dev == statbuf->st_dev)
+                 && (bucket->isdir == !!S_ISDIR(statbuf->st_mode))
                 ) {
                         return bucket->name;
                 }
@@ -52,17 +62,18 @@ void FAST_FUNC add_to_ino_dev_hashtable(const struct stat *statbuf, const char *
         int i;
         ino_dev_hashtable_bucket_t *bucket;
 
-        i = hash_inode(statbuf->st_ino);
         if (!name)
                 name = "";
         bucket = xmalloc(sizeof(ino_dev_hashtable_bucket_t) + strlen(name));
         bucket->ino = statbuf->st_ino;
         bucket->dev = statbuf->st_dev;
+        bucket->isdir = !!S_ISDIR(statbuf->st_mode);
         strcpy(bucket->name, name);
 
         if (!ino_dev_hashtable)
                 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;
 }
@@ -72,13 +83,18 @@ void FAST_FUNC add_to_ino_dev_hashtable(const struct stat *statbuf, const char *
 void FAST_FUNC reset_ino_dev_hashtable(void)
 {
         int i;
-        ino_dev_hashtable_bucket_t *bucket;
+        ino_dev_hashtable_bucket_t *bucket, *next;
+
+        if (!ino_dev_hashtable)
+                return;
+
+        for (i = 0; i < HASH_SIZE; i++) {
+                bucket = ino_dev_hashtable[i];
 
-        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;
+                while (bucket != NULL) {
+                        next = bucket->next;
+                        free(bucket);
+                        bucket = next;
                 }
         }
         free(ino_dev_hashtable);
diff --git a/libbb/loop.c b/libbb/loop.c
index 823fba079..c96c5e070 100644
--- a/libbb/loop.c
+++ b/libbb/loop.c
@@ -94,19 +94,19 @@ int FAST_FUNC set_loop(char **device, const char *file, unsigned long long offse
 
         /* 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);
 
@@ -121,7 +121,7 @@ int FAST_FUNC set_loop(char **device, const char *file, unsigned long long offse
                                         goto try_to_open;
                         }
                         /* Ran out of block devices, return failure.  */
-                        rc = -ENOENT;
+                        rc = -1;
                         break;
                 }
  try_to_open:
@@ -131,8 +131,14 @@ int FAST_FUNC set_loop(char **device, const char *file, unsigned long long offse
                         mode = O_RDONLY;
                         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);
 
diff --git a/libbb/pw_encrypt.c b/libbb/pw_encrypt.c
index 39ffa084f..bfc7030a8 100644
--- a/libbb/pw_encrypt.c
+++ b/libbb/pw_encrypt.c
@@ -142,7 +142,14 @@ char* FAST_FUNC pw_encrypt(const char *clear, const char *salt, int cleanup)
 
 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 : "");
 }
 
 #endif
diff --git a/libbb/replace.c b/libbb/replace.c
new file mode 100644
index 000000000..8711f957d
--- /dev/null
+++ b/libbb/replace.c
@@ -0,0 +1,45 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Utility routines.
+ *
+ * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ */
+
+//kbuild:lib-y += replace.o
+
+#include "libbb.h"
+
+unsigned FAST_FUNC count_strstr(const char *str, const char *sub)
+{
+        size_t sub_len = strlen(sub);
+        unsigned count = 0;
+
+        while ((str = strstr(str, sub)) != NULL) {
+                count++;
+                str += sub_len;
+        }
+        return count;
+}
+
+char* FAST_FUNC xmalloc_substitute_string(const char *src, int count, const char *sub, const char *repl)
+{
+        char *buf, *dst, *end;
+        size_t sub_len = strlen(sub);
+        size_t repl_len = strlen(repl);
+
+        //dbg_msg("subst(s:'%s',count:%d,sub:'%s',repl:'%s'", src, count, sub, repl);
+
+        buf = dst = xmalloc(strlen(src) + count * ((int)repl_len - (int)sub_len) + 1);
+        /* we replace each sub with repl */
+        while ((end = strstr(src, sub)) != NULL) {
+                dst = mempcpy(dst, src, end - src);
+                dst = mempcpy(dst, repl, repl_len);
+                /*src = end + 1; - GNU findutils 4.5.10 doesn't do this... */
+                src = end + sub_len; /* but this. Try "xargs -Iaa echo aaa" */
+        }
+        strcpy(dst, src);
+        //dbg_msg("subst9:'%s'", buf);
+        return buf;
+}