Fix the behavior of local shell variables to match that of bash and ash.

 -Erik

1 files changed, 109 insertions, 25 deletions

diff --git a/shell/hush.c b/shell/hush.c
index cfe0b826b..5a4966b07 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -55,7 +55,6 @@
  * to-do:
  *      port selected bugfixes from post-0.49 busybox lash - done?
  *      finish implementing reserved words: for, while, until, do, done
- *      finish implementing local variable assignment
  *      change { and } from special chars to reserved words
  *      builtins: break, continue, eval, return, set, trap, ulimit
  *      test magic exec
@@ -325,6 +324,7 @@ static int builtin_help(struct child_prog *child);
 static int builtin_jobs(struct child_prog *child);
 static int builtin_pwd(struct child_prog *child);
 static int builtin_read(struct child_prog *child);
+static int builtin_set(struct child_prog *child);
 static int builtin_shift(struct child_prog *child);
 static int builtin_source(struct child_prog *child);
 static int builtin_umask(struct child_prog *child);
@@ -388,6 +388,11 @@ static void checkjobs();
 static void insert_bg_job(struct pipe *pi);
 static void remove_bg_job(struct pipe *pi);
 static void free_pipe(struct pipe *pi);
+/*     local variable support */
+static char *get_local_var(const char *var);
+static int   set_local_var(const char *s);
+static void  unset_local_var(const char *name);
+
 
 /* Table of built-in functions.  They can be forked or not, depending on
  * context: within pipes, they fork.  As simple commands, they do not.
@@ -402,7 +407,8 @@ static struct built_in_command bltins[] = {
         {"continue", "Continue for, while or until loop", builtin_not_written},
         {"env", "Print all environment variables", builtin_env},
         {"eval", "Construct and run shell command", builtin_not_written},
-        {"exec", "Exec command, replacing this shell with the exec'd process", builtin_exec},
+        {"exec", "Exec command, replacing this shell with the exec'd process", 
+                builtin_exec},
         {"exit", "Exit from shell()", builtin_exit},
         {"export", "Set environment variable", builtin_export},
         {"fg", "Bring job into the foreground", builtin_fg_bg},
@@ -410,7 +416,7 @@ static struct built_in_command bltins[] = {
         {"pwd", "Print current directory", builtin_pwd},
         {"read", "Input environment variable", builtin_read},
         {"return", "Return from a function", builtin_not_written},
-        {"set", "Set/unset shell options", builtin_not_written},
+        {"set", "Set/unset shell local variables", builtin_set},
         {"shift", "Shift positional parameters", builtin_shift},
         {"trap", "Trap signals", builtin_not_written},
         {"ulimit","Controls resource limits", builtin_not_written},
@@ -472,16 +478,41 @@ static int builtin_exit(struct child_prog *child)
 static int builtin_export(struct child_prog *child)
 {
         int res;
+        char *value, *name = child->argv[1];
 
-        if (child->argv[1] == NULL) {
+        if (name == NULL) {
                 return (builtin_env(child));
         }
-        /* FIXME -- I leak memory.  This will be
-         * fixed up properly when we add local
-         * variable support -- I hope */
-        res = putenv(strdup(child->argv[1]));
+
+        value = strchr(name, '=');
+        if (!value) {
+                /* They are exporting something without an =VALUE.
+                 * Assume this is a local shell variable they are exporting */
+                name = get_local_var(name);
+                if (! name ) { 
+                        error_msg("export failed");
+                        return (EXIT_FAILURE);
+                }
+                /* FIXME -- I leak memory!!!!! */
+                value = malloc(strlen(child->argv[1]) + strlen(name) + 2);
+                sprintf(value, "%s=%s", child->argv[1], name);
+        } else {
+                /* Bourne shells always put exported variables into the 
+                 * local shell variable list.  Do that first... */
+                set_local_var(name);
+                /* FIXME -- I leak memory!!!!! */
+                value = strdup(name);
+        }
+
+        /* FIXME -- I leak memory!!!!!
+         * It seems most putenv implementations place the very char* pointer
+         * we pass in directly into the environ array, so the memory holding
+         * this string has to be persistant.  We can't even use the memory for
+         * the local shell variable list, since where that memory is keeps 
+         * changing due to reallocs... */
+        res = putenv(value);
         if (res)
-                fprintf(stderr, "export: %s\n", strerror(errno));
+                perror_msg("export");
         return (res);
 }
 
@@ -616,6 +647,27 @@ static int builtin_read(struct child_prog *child)
         return (res);
 }
 
+/* built-in 'set VAR=value' handler */
+static int builtin_set(struct child_prog *child)
+{
+        int res;
+        char *temp = child->argv[1];
+
+        if (child->argv[1] == NULL) {
+                char **e = __shell_local_env;
+                if (e == NULL) return EXIT_FAILURE;
+                for (; *e; e++) {
+                        puts(*e);
+                }
+                return EXIT_SUCCESS;
+        }
+        res = set_local_var(temp);
+        if (res)
+                fprintf(stderr, "set: %s\n", strerror(errno));
+        return (res);
+}
+
+
 /* Built-in 'shift' handler */
 static int builtin_shift(struct child_prog *child)
 {
@@ -685,6 +737,7 @@ static int builtin_unset(struct child_prog *child)
                 return EXIT_FAILURE;
         }
         unsetenv(child->argv[1]);
+        unset_local_var(child->argv[1]);
         return EXIT_SUCCESS;
 }
 
@@ -1610,7 +1663,27 @@ static int xglob(o_string *dest, int flags, glob_t *pglob)
         return gr;
 }
 
-/* This is used to set local variables (i.e. stuff not going into the environment) */
+/* This is used to get/check local shell variables */
+static char *get_local_var(const char *s)
+{
+        char **p;
+        int len;
+
+        if (!s)
+                return NULL;
+        if (!__shell_local_env)
+                return NULL;
+        len = strlen(s);
+
+        for (p = __shell_local_env; *p; p++) {
+                if (memcmp(s, *p, len) == 0 && (*p)[len] == '=') {
+                        return *p + len + 1;
+                }
+        }
+        return NULL;
+}
+
+/* This is used to set local shell variables */
 static int set_local_var(const char *s)
 {
         char **ep;
@@ -1653,7 +1726,8 @@ static int set_local_var(const char *s)
                         result = -1;
                         goto done_already;
                 }
-                memcpy((__ptr_t) new_environ, (__ptr_t) __shell_local_env, size * sizeof(char *));
+                memcpy((__ptr_t) new_environ, (__ptr_t) __shell_local_env, 
+                                size * sizeof(char *));
 
                 new_environ[size] = malloc (namelen + 1 + vallen + 1);
                 if (new_environ[size] == NULL) {
@@ -1688,26 +1762,35 @@ static int set_local_var(const char *s)
                 memcpy (&(*ep)[namelen + 1], value, vallen + 1);
         }
 
+        /* One last little detail...  If this variable is already
+         * in the environment we must set it there as well... */
+        tmp = getenv(name);
+        if (tmp) { 
+                /* FIXME -- I leak memory!!!!! */
+                putenv(strdup(s));
+        }
+
 done_already:
         free(name);
         return result;
 }
 
-char *get_local_var(const char *var)
+static void unset_local_var(const char *name)
 {
-        char **p;
-        int len;
-
-        len = strlen(var);
-
-        if (!__shell_local_env)
-                return 0;
+        char **ep, **dp;
+        size_t namelen;
 
-        for (p = __shell_local_env; *p; p++) {
-                if (memcmp(var, *p, len) == 0 && (*p)[len] == '=')
-                        return *p + len + 1;
+        if (!name)
+                return;
+        namelen = strlen(name);
+        for (dp = ep = __shell_local_env; ep && *ep != NULL; ++ep) {
+                if (memcmp (*ep, name, namelen)==0 && (*ep)[namelen] == '=') {
+                        *dp = *ep;
+                        ++dp;
+                        *ep = NULL;
+                        break;
+                }
         }
-        return 0;
 }
 
 static int is_assignment(const char *s)
@@ -2112,8 +2195,9 @@ static void lookup_param(o_string *dest, struct p_context *ctx, o_string *src)
 {
         const char *p=NULL;
         if (src->data) { 
-                p = get_local_var(src->data);
-                if (!p) p = getenv(src->data);
+                p = getenv(src->data);
+                if (!p) 
+                        p = get_local_var(src->data);
         }
         if (p) parse_string(dest, ctx, p);   /* recursion */
         b_free(src);