4 files changed, 127 insertions, 101 deletions

diff --git a/win32/isaac.c b/win32/isaac.c
index 8e9da9baf..ba51d199a 100644
--- a/win32/isaac.c
+++ b/win32/isaac.c
@@ -19,34 +19,36 @@ You may use this code in any way you wish, and it is free.  No warrantee.
 */
 #include "libbb.h"
 
-/* external results */
-static uint32_t randrsl[256];
+typedef struct {
+        /* external results */
+        uint32_t randrsl[256];
 
-/* internal state */
-static uint32_t mm[256];
-static uint32_t aa=0, bb=0, cc=0;
+        /* internal state */
+        uint32_t mm[256];
+        uint32_t aa, bb, cc;
+} isaac_t;
 
 
-static void isaac(void)
+static void isaac(isaac_t *t)
 {
    register uint32_t i,x,y;
 
-   cc = cc + 1;    /* cc just gets incremented once per 256 results */
-   bb = bb + cc;   /* then combined with bb */
+   t->cc = t->cc + 1;    /* cc just gets incremented once per 256 results */
+   t->bb = t->bb + t->cc;   /* then combined with bb */
 
    for (i=0; i<256; ++i)
    {
-     x = mm[i];
+     x = t->mm[i];
      switch (i%4)
      {
-     case 0: aa = aa^(aa<<13); break;
-     case 1: aa = aa^(aa>>6); break;
-     case 2: aa = aa^(aa<<2); break;
-     case 3: aa = aa^(aa>>16); break;
+     case 0: t->aa = t->aa^(t->aa<<13); break;
+     case 1: t->aa = t->aa^(t->aa>>6); break;
+     case 2: t->aa = t->aa^(t->aa<<2); break;
+     case 3: t->aa = t->aa^(t->aa>>16); break;
      }
-     aa              = mm[(i+128)%256] + aa;
-     mm[i]      = y  = mm[(x>>2)%256] + aa + bb;
-     randrsl[i] = bb = mm[(y>>10)%256] + x;
+     t->aa              = t->mm[(i+128)%256] + t->aa;
+     t->mm[i]      = y  = t->mm[(x>>2)%256] + t->aa + t->bb;
+     t->randrsl[i] = t->bb = t->mm[(y>>10)%256] + x;
 
      /* Note that bits 2..9 are chosen from x but 10..17 are chosen
         from y.  The only important thing here is that 2..9 and 10..17
@@ -71,11 +73,11 @@ static void isaac(void)
    h^=a>>9;  c+=h; a+=b; \
 }
 
-static void randinit(int flag)
+static void randinit(isaac_t *t, int flag)
 {
    int i;
    uint32_t a,b,c,d,e,f,g,h;
-   aa=bb=cc=0;
+   t->aa = t->bb = t->cc = 0;
    a=b=c=d=e=f=g=h=0x9e3779b9;  /* the golden ratio */
 
    for (i=0; i<4; ++i)          /* scramble it */
@@ -87,27 +89,28 @@ static void randinit(int flag)
    {
      if (flag)                  /* use all the information in the seed */
      {
-       a+=randrsl[i  ]; b+=randrsl[i+1]; c+=randrsl[i+2]; d+=randrsl[i+3];
-       e+=randrsl[i+4]; f+=randrsl[i+5]; g+=randrsl[i+6]; h+=randrsl[i+7];
+       a+=t->randrsl[i  ]; b+=t->randrsl[i+1]; c+=t->randrsl[i+2];
+       d+=t->randrsl[i+3]; e+=t->randrsl[i+4]; f+=t->randrsl[i+5];
+       g+=t->randrsl[i+6]; h+=t->randrsl[i+7];
      }
      mix(a,b,c,d,e,f,g,h);
-     mm[i  ]=a; mm[i+1]=b; mm[i+2]=c; mm[i+3]=d;
-     mm[i+4]=e; mm[i+5]=f; mm[i+6]=g; mm[i+7]=h;
+     t->mm[i  ]=a; t->mm[i+1]=b; t->mm[i+2]=c; t->mm[i+3]=d;
+     t->mm[i+4]=e; t->mm[i+5]=f; t->mm[i+6]=g; t->mm[i+7]=h;
    }
 
    if (flag)
    {        /* do a second pass to make all of the seed affect all of mm */
      for (i=0; i<256; i+=8)
      {
-       a+=mm[i  ]; b+=mm[i+1]; c+=mm[i+2]; d+=mm[i+3];
-       e+=mm[i+4]; f+=mm[i+5]; g+=mm[i+6]; h+=mm[i+7];
+       a+=t->mm[i  ]; b+=t->mm[i+1]; c+=t->mm[i+2]; d+=t->mm[i+3];
+       e+=t->mm[i+4]; f+=t->mm[i+5]; g+=t->mm[i+6]; h+=t->mm[i+7];
        mix(a,b,c,d,e,f,g,h);
-       mm[i  ]=a; mm[i+1]=b; mm[i+2]=c; mm[i+3]=d;
-       mm[i+4]=e; mm[i+5]=f; mm[i+6]=g; mm[i+7]=h;
+       t->mm[i  ]=a; t->mm[i+1]=b; t->mm[i+2]=c; t->mm[i+3]=d;
+       t->mm[i+4]=e; t->mm[i+5]=f; t->mm[i+6]=g; t->mm[i+7]=h;
      }
    }
 
-   isaac();            /* fill in the first set of results */
+   isaac(t);            /* fill in the first set of results */
 }
 
 /* call 'fn' to put data in 'dt' then copy it to generator state */
@@ -115,7 +118,7 @@ static void randinit(int flag)
         fn(&dt); \
         u = (uint32_t *)&dt; \
         for (j=0; j<sizeof(dt)/sizeof(uint32_t); ++j) { \
-                randrsl[i++] = *u++; \
+                t->randrsl[i++] = *u++; \
         }
 
 /*
@@ -123,7 +126,7 @@ static void randinit(int flag)
  * This is unlikely to be very robust:  don't rely on it for
  * anything that needs to be secure.
  */
-static void get_entropy(void)
+static void get_entropy(isaac_t *t)
 {
         int i, j, len;
         SYSTEMTIME tm;
@@ -136,9 +139,9 @@ static void get_entropy(void)
         unsigned char buf[16];
 
         i = 0;
-        randrsl[i++] = (uint32_t)GetCurrentProcessId();
-        randrsl[i++] = (uint32_t)GetCurrentThreadId();
-        randrsl[i++] = (uint32_t)GetTickCount();
+        t->randrsl[i++] = (uint32_t)GetCurrentProcessId();
+        t->randrsl[i++] = (uint32_t)GetCurrentThreadId();
+        t->randrsl[i++] = (uint32_t)GetTickCount();
 
         GET_DATA(GetLocalTime, tm)
         GET_DATA(GlobalMemoryStatus, ms)
@@ -159,12 +162,12 @@ static void get_entropy(void)
 
         u = (uint32_t *)buf;
         for (j=0; j<sizeof(buf)/sizeof(uint32_t); ++j) {
-                randrsl[i++] = *u++;
+                t->randrsl[i++] = *u++;
         }
 
 #if 0
         {
-                unsigned char *p = (unsigned char *)randrsl;
+                unsigned char *p = (unsigned char *)t->randrsl;
 
                 for (j=0; j<i*sizeof(uint32_t); ++j) {
                         fprintf(stderr, "%02x", *p++);
@@ -180,8 +183,8 @@ static void get_entropy(void)
 #endif
 }
 
-#define RAND_BYTES sizeof(randrsl)
-#define RAND_WORDS (sizeof(randrsl)/sizeof(randrsl[0]))
+#define RAND_BYTES sizeof(t->randrsl)
+#define RAND_WORDS (sizeof(t->randrsl)/sizeof(t->randrsl[0]))
 
 /*
  * Place 'count' random bytes in the buffer 'buf'.  You're responsible
@@ -189,29 +192,26 @@ static void get_entropy(void)
  */
 ssize_t get_random_bytes(void *buf, ssize_t count)
 {
-        static int initialised = 0;
+        static isaac_t *t = NULL;
         static int rand_index = 0;
-        int i;
         ssize_t save_count = count;
-        unsigned char *ptr = (unsigned char *)randrsl;
+        unsigned char *ptr;
 
         if (buf == NULL || count < 0) {
                 errno = EINVAL;
                 return -1;
         }
 
-        if (!initialised) {
-                aa = bb = cc = (uint32_t)0;
-                for (i=0; i<RAND_WORDS; ++i)
-                        mm[i] = randrsl[i] = (uint32_t)0;
+        if (!t) {
+                t = xzalloc(sizeof(isaac_t));
 
-                get_entropy();
-                randinit(1);
-                isaac();
+                get_entropy(t);
+                randinit(t, 1);
+                isaac(t);
                 rand_index = 0;
-                initialised = 1;
         }
 
+        ptr = (unsigned char *)t->randrsl;
         while (count > 0) {
                 int bytes_left = RAND_BYTES - rand_index;
 
@@ -231,7 +231,7 @@ ssize_t get_random_bytes(void *buf, ssize_t count)
 
                 if (rand_index >= RAND_BYTES) {
                         /* generate more */
-                        isaac();
+                        isaac(t);
                         rand_index = 0;
                 }
         }
diff --git a/win32/mingw.c b/win32/mingw.c
index bedf14784..4c449514a 100644
--- a/win32/mingw.c
+++ b/win32/mingw.c
@@ -676,11 +676,14 @@ int mingw_rename(const char *pold, const char *pnew)
 
 static char *gethomedir(void)
 {
-        static char buf[PATH_MAX];
-        DWORD len = sizeof(buf);
+        static char *buf = NULL;
+        DWORD len = PATH_MAX;
         HANDLE h;
         char *s;
 
+        if (!buf)
+                buf = xmalloc(PATH_MAX);
+
         buf[0] = '\0';
         if ( !OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &h) )
                 return buf;
@@ -701,11 +704,17 @@ static char *gethomedir(void)
         return buf;
 }
 
+#define NAME_LEN 100
 static char *get_user_name(void)
 {
-        static char user_name[100] = "";
+        static char *user_name = NULL;
         char *s;
-        DWORD len = sizeof(user_name);
+        DWORD len = NAME_LEN;
+
+        if ( user_name == NULL ) {
+                user_name = xmalloc(NAME_LEN);
+                user_name[0] = '\0';
+        }
 
         if ( user_name[0] != '\0' ) {
                 return user_name;
@@ -857,7 +866,12 @@ char *realpath(const char *path, char *resolved_path)
 
 const char *get_busybox_exec_path(void)
 {
-        static char path[PATH_MAX] = "";
+        static char *path = NULL;
+
+        if (!path) {
+                path = xmalloc(PATH_MAX);
+                path[0] = '\0';
+        }
 
         if (!*path)
                 GetModuleFileName(NULL, path, PATH_MAX);
diff --git a/win32/mntent.c b/win32/mntent.c
index 9b04a9c5e..f9a2d26d4 100644
--- a/win32/mntent.c
+++ b/win32/mntent.c
@@ -7,6 +7,11 @@
 struct mntdata {
         DWORD flags;
         int index;
+        struct mntent me;
+        char mnt_fsname[4];
+        char mnt_dir[4];
+        char mnt_type[100];
+        char mnt_opts[4];
 };
 
 FILE *setmntent(const char *file UNUSED_PARAM, const char *mode UNUSED_PARAM)
@@ -26,34 +31,35 @@ FILE *setmntent(const char *file UNUSED_PARAM, const char *mode UNUSED_PARAM)
 struct mntent *getmntent(FILE *stream)
 {
         struct mntdata *data = (struct mntdata *)stream;
-        static char mnt_fsname[4];
-        static char mnt_dir[4];
-        static char mnt_type[100];
-        static char mnt_opts[4];
-        static struct mntent my_mount_entry =
-                                        { mnt_fsname, mnt_dir, mnt_type, mnt_opts, 0, 0 };
         struct mntent *entry;
 
+        data->me.mnt_fsname = data->mnt_fsname;
+        data->me.mnt_dir = data->mnt_dir;
+        data->me.mnt_type = data->mnt_type;
+        data->me.mnt_opts = data->mnt_opts;
+        data->me.mnt_freq = 0;
+        data->me.mnt_passno = 0;
+
         entry = NULL;
         while ( ++data->index < 26 ) {
                 if ( (data->flags & 1<<data->index) != 0 ) {
-                        mnt_fsname[0] = 'A' + data->index;
-                        mnt_fsname[1] = ':';
-                        mnt_fsname[2] = '\0';
-                        mnt_dir[0] = 'A' + data->index;
-                        mnt_dir[1] = ':';
-                        mnt_dir[2] = '\\';
-                        mnt_dir[3] = '\0';
-                        mnt_type[0] = '\0';
-                        mnt_opts[0] = '\0';
+                        data->mnt_fsname[0] = 'A' + data->index;
+                        data->mnt_fsname[1] = ':';
+                        data->mnt_fsname[2] = '\0';
+                        data->mnt_dir[0] = 'A' + data->index;
+                        data->mnt_dir[1] = ':';
+                        data->mnt_dir[2] = '\\';
+                        data->mnt_dir[3] = '\0';
+                        data->mnt_type[0] = '\0';
+                        data->mnt_opts[0] = '\0';
 
-                        if ( GetDriveType(mnt_dir) == DRIVE_FIXED ) {
-                                if ( !GetVolumeInformation(mnt_dir, NULL, 0, NULL, NULL,
-                                                                NULL, mnt_type, 100) ) {
-                                        mnt_type[0] = '\0';
+                        if ( GetDriveType(data->mnt_dir) == DRIVE_FIXED ) {
+                                if ( !GetVolumeInformation(data->mnt_dir, NULL, 0, NULL, NULL,
+                                                                NULL, data->mnt_type, 100) ) {
+                                        data->mnt_type[0] = '\0';
                                 }
 
-                                entry = &my_mount_entry;
+                                entry = &data->me;
                                 break;
                         }
                 }
diff --git a/win32/process.c b/win32/process.c
index 96561c482..0d6d70970 100644
--- a/win32/process.c
+++ b/win32/process.c
@@ -39,43 +39,50 @@ next_path_sep(const char *path)
         return strchr(has_dos_drive_prefix(path) ? path+2 : path, ':');
 }
 
-static char *
-parse_interpreter(const char *cmd, char **name, char **opts)
+typedef struct {
+        char *path;
+        char *name;
+        char *opts;
+        char buf[100];
+} interp_t;
+
+static int
+parse_interpreter(const char *cmd, interp_t *interp)
 {
-        static char buf[100];
         char *path, *t;
         int n, fd;
 
         fd = open(cmd, O_RDONLY);
         if (fd < 0)
-                return NULL;
-        n = read(fd, buf, sizeof(buf)-1);
+                return 0;
+        n = read(fd, interp->buf, sizeof(interp->buf)-1);
         close(fd);
         if (n < 4)      /* at least '#!/x' and not error */
-                return NULL;
+                return 0;
 
         /*
          * See http://www.in-ulm.de/~mascheck/various/shebang/ for trivia
          * relating to '#!'.
          */
-        if (buf[0] != '#' || buf[1] != '!')
-                return NULL;
-        buf[n] = '\0';
-        if ((t=strchr(buf, '\n')) == NULL)
-                return NULL;
+        if (interp->buf[0] != '#' || interp->buf[1] != '!')
+                return 0;
+        interp->buf[n] = '\0';
+        if ((t=strchr(interp->buf, '\n')) == NULL)
+                return 0;
         t[1] = '\0';
 
-        if ((path=strtok(buf+2, " \t\r\n")) == NULL)
-                return NULL;
+        if ((path=strtok(interp->buf+2, " \t\r\n")) == NULL)
+                return 0;
 
         t = (char *)bb_basename(path);
         if (*t == '\0')
-                return NULL;
+                return 0;
 
-        *name = t;
-        *opts = strtok(NULL, "\r\n");
+        interp->path = path;
+        interp->name = t;
+        interp->opts = strtok(NULL, "\r\n");
 
-        return path;
+        return 1;
 }
 
 /*
@@ -284,36 +291,35 @@ mingw_spawn_interpreter(int mode, const char *prog, char *const *argv, char *con
 {
         intptr_t ret;
         int nopts;
-        char *int_name, *opts;
-        char *int_path = parse_interpreter(prog, &int_name, &opts);
+        interp_t interp;
         char **new_argv;
         int argc = -1;
         char *fullpath = NULL;
 
-        if (!int_path)
+        if (!parse_interpreter(prog, &interp))
                 return spawnveq(mode, prog, argv, envp);
 
-        nopts = opts != NULL;
+        nopts = interp.opts != NULL;
         while (argv[++argc])
                 ;
 
         new_argv = xmalloc(sizeof(*argv)*(argc+nopts+2));
-        new_argv[1] = opts;
+        new_argv[1] = interp.opts;
         new_argv[nopts+1] = (char *)prog; /* pass absolute path */
         memcpy(new_argv+nopts+2, argv+1, sizeof(*argv)*argc);
 
-        if ((fullpath=add_win32_extension(int_path)) != NULL ||
-                        file_is_executable(int_path)) {
-                new_argv[0] = fullpath ? fullpath : int_path;
+        if ((fullpath=add_win32_extension(interp.path)) != NULL ||
+                        file_is_executable(interp.path)) {
+                new_argv[0] = fullpath ? fullpath : interp.path;
                 ret = spawnveq(mode, new_argv[0], new_argv, envp);
         } else
 #if ENABLE_FEATURE_PREFER_APPLETS || ENABLE_FEATURE_SH_STANDALONE
-        if (find_applet_by_name(int_name) >= 0) {
-                new_argv[0] = int_name;
+        if (find_applet_by_name(interp.name) >= 0) {
+                new_argv[0] = interp.name;
                 ret = mingw_spawn_applet(mode, new_argv, envp);
         } else
 #endif
-        if ((fullpath=find_first_executable(int_name)) != NULL) {
+        if ((fullpath=find_first_executable(interp.name)) != NULL) {
                 new_argv[0] = fullpath;
                 ret = spawnveq(mode, fullpath, new_argv, envp);
         }