hush: move towards more correct variable expansion

hush: fix a few cases in FOR v IN ... construct
      unfortunately, code growth is big - ~600 bytes

1 files changed, 304 insertions, 63 deletions

diff --git a/shell/hush.c b/shell/hush.c
index dfb819122..803970b57 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -85,13 +85,14 @@
 
 /* If you comment out one of these below, it will be #defined later
  * to perform debug printfs to stderr: */
-#define debug_printf(...)       do {} while (0)
+#define debug_printf(...)        do {} while (0)
 /* Finer-grained debug switches */
-#define debug_printf_parse(...) do {} while (0)
-#define debug_print_tree(a, b)  do {} while (0)
-#define debug_printf_exec(...)  do {} while (0)
-#define debug_printf_jobs(...)  do {} while (0)
-#define debug_printf_clean(...) do {} while (0)
+#define debug_printf_parse(...)  do {} while (0)
+#define debug_print_tree(a, b)   do {} while (0)
+#define debug_printf_exec(...)   do {} while (0)
+#define debug_printf_jobs(...)   do {} while (0)
+#define debug_printf_expand(...) do {} while (0)
+#define debug_printf_clean(...)  do {} while (0)
 
 #ifndef debug_printf
 #define debug_printf(...) fprintf(stderr, __VA_ARGS__)
@@ -110,6 +111,11 @@
 #define DEBUG_SHELL_JOBS 1
 #endif
 
+#ifndef debug_printf_expand
+#define debug_printf_expand(...) fprintf(stderr, __VA_ARGS__)
+#define DEBUG_EXPAND 1
+#endif
+
 #ifndef debug_printf_clean
 /* broken, of course, but OK for testing */
 static const char *indenter(int i)
@@ -229,6 +235,12 @@ struct child_prog {
 	int sp;                     /* number of SPECIAL_VAR_SYMBOL */
 	int type;
 };
+// sp counting seems to be broken...
+/* argv vector may contain variable references (^Cvar^C, ^C0^C etc)
+ * and on execution these are substituted with their values.
+ * Substitution can make _several_ words out of one argv[n]!
+ * Example: argv[0]=='.^C*^C.' here: echo .$*.
+ */
 
 struct pipe {
 	struct pipe *next;
@@ -430,7 +442,7 @@ static void delete_finished_bg_job(struct pipe *pi);
 int checkjobs_and_fg_shell(struct pipe* fg_pipe); /* never called */
 #endif
 /*     local variable support */
-static char **make_list_in(char **inp, char *name);
+static char **do_variable_expansion(char **argv);
 static char *insert_var_value(char *inp);
 static const char *get_local_var(const char *var);
 static int set_local_var(const char *s, int flg_export);
@@ -1265,10 +1277,8 @@ static void restore_redirects(int squirrel[])
 	for (i = 0; i < 3; i++) {
 		fd = squirrel[i];
 		if (fd != -1) {
-			/* No error checking.  I sure wouldn't know what
-			 * to do with an error if I found one! */
-			dup2(fd, i);
-			close(fd);
+			/* We simply die on error */
+			xmove_fd(fd, i);
 		}
 	}
 }
@@ -1916,9 +1926,9 @@ static int run_list_real(struct pipe *pi)
 	enum { level = 0 };
 #endif
 
-	char *save_name = NULL;
-	char **list = NULL;
-	char **save_list = NULL;
+	char *for_varname = NULL;
+	char **for_lcur = NULL;
+	char **for_list = NULL;
 	struct pipe *rpipe;
 	int flag_rep = 0;
 	int save_num_progs;
@@ -2018,30 +2028,29 @@ static int run_list_real(struct pipe *pi)
 		if (rmode == RES_ELIF && !if_code)
 			break;
 		if (rmode == RES_FOR && pi->num_progs) {
-			if (!list) {
+			if (!for_lcur) {
 				/* if no variable values after "in" we skip "for" */
 				if (!pi->next->progs->argv)
 					continue;
 				/* create list of variable values */
-				list = make_list_in(pi->next->progs->argv,
-						pi->progs->argv[0]);
-				save_list = list;
-				save_name = pi->progs->argv[0];
+				for_list = do_variable_expansion(pi->next->progs->argv);
+				for_lcur = for_list;
+				for_varname = pi->progs->argv[0];
 				pi->progs->argv[0] = NULL;
 				flag_rep = 1;
 			}
-			if (!*list) {
-				free(pi->progs->argv[0]);
-				free(save_list);
-				list = NULL;
+			free(pi->progs->argv[0]);
+			if (!*for_lcur) {
+				free(for_list);
+				for_lcur = NULL;
 				flag_rep = 0;
-				pi->progs->argv[0] = save_name;
+				pi->progs->argv[0] = for_varname;
 				pi->progs->glob_result.gl_pathv[0] = pi->progs->argv[0];
 				continue;
 			}
-			/* insert new value from list for variable */
-			free(pi->progs->argv[0]);
-			pi->progs->argv[0] = *list++;
+			/* insert next value from for_lcur */
+		//vda: does it need escaping?
+			pi->progs->argv[0] = xasprintf("%s=%s", for_varname, *for_lcur++);
 			pi->progs->glob_result.gl_pathv[0] = pi->progs->argv[0];
 		}
 		if (rmode == RES_IN)
@@ -2288,50 +2297,267 @@ static int xglob(o_string *dest, int flags, glob_t *pglob)
 	return gr;
 }
 
-static char **make_list_in(char **inp, char *name)
+
+/* do_variable_expansion() takes a list of strings, expands
+ * all variable references within and returns a pointer to
+ * a list of expanded strings, possibly with larger number
+ * of strings. (Think VAR="a b"; echo $VAR).
+ * This new list is allocated as a single malloc block.
+ * NULL-terminated list of char* pointers is at the beginning of it,
+ * followed by strings themself.
+ * Caller can deallocate entire list by single free(list). */
+
+/* Helpers first:
+ * count_XXX estimates, how large block do we need. It's okay
+ * to over-estimate sizes a bit, if it makes code simpler */
+static int count_ifs(const char *str)
 {
-	int len, i;
-#if 0
-	int name_len = strlen(name);
-#endif
-	int n;
-	char **list;
-	char *p1, *p2, *p3;
+	int cnt = 0;
+	debug_printf_expand("count_ifs('%s') ifs='%s'", str, ifs);
+	while (1) {
+		str += strcspn(str, ifs);
+		if (!*str) break;
+		str++; // str += strspn(str, ifs); ?
+		cnt++; // cnt += strspn(str, ifs); ?
+	}
+	debug_printf_expand(" return %d\n", cnt);
+	return cnt;
+}
 
-	/* create list of variable values */
-	list = xmalloc(sizeof(*list));
-	n = 0;
-	for (i = 0; inp[i]; i++) {
-		p3 = insert_var_value(inp[i]);
-		p1 = p3;
-		while (*p1) {
-			if (*p1 == ' ') {
-				p1++;
-				continue;
+static void count_var_expansion_space(int *countp, int *lenp, char *arg)
+{
+	char first_ch;
+	int i;
+	int len = *lenp;
+	int count = *countp;
+	const char *val;
+	char *p;
+
+	while ((p = strchr(arg, SPECIAL_VAR_SYMBOL))) {
+		len += p - arg;
+		arg = ++p;
+		p = strchr(p, SPECIAL_VAR_SYMBOL);
+		first_ch = arg[0];
+
+		switch (first_ch & 0x7f) {
+		/* high bit in 1st_ch indicates that var is double-quoted */
+		case '$': /* pid */
+		case '!': /* bg pid */
+		case '?': /* exitcode */
+		case '#': /* argc */
+			len += sizeof(int)*3 + 1; /* enough for int */
+			break;
+		case '*':
+		case '@':
+			for (i = 1; i < global_argc; i++) {
+				len += strlen(global_argv[i]) + 1;
+				count++;
+				if (!(first_ch & 0x80))
+					count += count_ifs(global_argv[i]);
+			}
+			break;
+		default:
+			*p = '\0';
+			arg[0] = first_ch & 0x7f;
+			val = lookup_param(arg);
+			arg[0] = first_ch;
+			*p = SPECIAL_VAR_SYMBOL;
+
+			if (val) {
+				len += strlen(val) + 1;
+				if (!(first_ch & 0x80))
+					count += count_ifs(val);
 			}
-			p2 = strchrnul(p1, ' ');
-			len = p2 - p1;
-			/* we use n + 2 in realloc for list, because we add
-			 * new element and then we will add NULL element */
-			list = xrealloc(list, sizeof(*list) * (n + 2));
-			list[n] = xasprintf("%s=%.*s", name, len, p1);
-#if 0 /* faster, but more code */
-			list[n] = xmalloc(2 + name_len + len);
-			strcpy(list[n], name);
-			list[n][name_len] = '=';
-			strncat(&(list[n][name_len + 1]), p1, len);
-			list[n][name_len + len + 1] = '\0';
-#endif
-			n++;
-			p1 = p2;
 		}
-		if (p3 != inp[i])
-			free(p3);
+		arg = ++p;
 	}
+
+	len += strlen(arg) + 1;
+	count++;
+	*lenp = len;
+	*countp = count;
+}
+
+/* Store given string, finalizing the word and starting new one whenever
+ * we encounter ifs char(s). This is used for expanding variable values.
+ * End-of-string does NOT finalize word, because cases like echo -$VAR- */
+static int expand_on_ifs(char **list, int n, char **posp, const char *str)
+{
+	char *pos = *posp;
+	while (1) {
+		int word_len = strcspn(str, ifs);
+		if (word_len) {
+			memcpy(pos, str, word_len); /* store non-ifs chars */
+			pos += word_len;
+			str += word_len;
+			if (!*str) /* EOL - do not finalize word */
+				break;
+			*pos++ = '\0';
+			if (n) debug_printf_expand("expand_on_ifs finalized list[%d]=%p '%s' "
+				"strlen=%d next=%p pos=%p\n", n-1, list[n-1], list[n-1],
+				strlen(list[n-1]), list[n-1] + strlen(list[n-1]) + 1, pos);
+			list[n++] = pos;
+		}
+		if (!*str) break; /* EOL, not ifs char */
+		str += strspn(str, ifs); /* skip ifs chars */
+	}
+	*posp = pos;
+	return n;
+}
+
+/* Expand all variable references in given string, adding words to list[]
+ * at n, n+1,... positions. Return updated n (so that list[n] is next one
+ * to be filled). This routine is extremely tricky: has to deal with
+ * variables/parameters with whitespace, $* and $@, and constructs like
+ * 'echo -$*-'. If you play here, you must run testsuite afterwards! */
+/* NB: support for double-quoted expansion is not used yet (we never set
+ * magic bit 0x80 elsewhere...) */
+/* NB: another bug is that we cannot detect empty strings yet:
+ * "" or $empty"" expands to zero words, has to expand to empty word */
+static int expand_vars_to_list(char **list, int n, char **posp, char *arg)
+{
+	char first_ch, ored_ch;
+	const char *val;
+	char *p;
+	char *pos = *posp;
+
+	ored_ch = 0;
+
+	if (n) debug_printf_expand("expand_vars_to_list finalized list[%d]=%p '%s' "
+		"strlen=%d next=%p pos=%p\n", n-1, list[n-1], list[n-1],
+		strlen(list[n-1]), list[n-1] + strlen(list[n-1]) + 1, pos);
+	list[n++] = pos;
+
+	while ((p = strchr(arg, SPECIAL_VAR_SYMBOL))) {
+		memcpy(pos, arg, p - arg);
+		pos += (p - arg);
+		arg = ++p;
+		p = strchr(p, SPECIAL_VAR_SYMBOL);
+
+		first_ch = arg[0];
+		ored_ch |= first_ch;
+		val = NULL;
+		switch (first_ch & 0x7f) {
+		/* Highest bit in first_ch indicates that var is double-quoted */
+		case '$': /* pid */
+			/* FIXME: (echo $$) should still print pid of main shell */
+			val = utoa(getpid());
+			break;
+		case '!': /* bg pid */
+			val = last_bg_pid ? utoa(last_bg_pid) : (char*)"";
+			break;
+		case '?': /* exitcode */
+			val = utoa(last_return_code);
+			break;
+		case '#': /* argc */
+			val = utoa(global_argc ? global_argc-1 : 0);
+			break;
+		case '*':
+		case '@':
+			if (!(first_ch & 0x80)) { /* unquoted $* or $@ */
+				int i = 1;
+				while (i < global_argc) {
+					n = expand_on_ifs(list, n, &pos, global_argv[i]);
+					debug_printf_expand("expand_vars_to_list: argv %d (last %d)\n", i, global_argc-1);
+					if (global_argv[i++][0] && i < global_argc) {
+						/* this argv[] is not empty and not last:
+						 * put terminating NUL, start new word */
+						*pos++ = '\0';
+						if (n) debug_printf_expand("expand_vars_to_list 2 finalized list[%d]=%p '%s' "
+							"strlen=%d next=%p pos=%p\n", n-1, list[n-1], list[n-1],
+							strlen(list[n-1]), list[n-1] + strlen(list[n-1]) + 1, pos);
+						list[n++] = pos;
+					}
+				}
+			} else if (first_ch == ('@'|0x80)) { /* quoted $@ */
+				/* TODO */
+			} else { /* quoted $* */
+				/* TODO */
+			}
+			break;
+		default:
+			*p = '\0';
+			arg[0] = first_ch & 0x7f;
+			val = lookup_param(arg);
+			arg[0] = first_ch;
+			*p = SPECIAL_VAR_SYMBOL;
+			if (!(first_ch & 0x80)) { /* unquoted var */
+				if (val) {
+					n = expand_on_ifs(list, n, &pos, val);
+					val = NULL;
+				}
+			}
+		}
+		if (val) {
+			strcpy(pos, val);
+			pos += strlen(val);
+		}
+		arg = ++p;
+	}
+	debug_printf_expand("expand_vars_to_list adding tail '%s' at %p\n", arg, pos);
+	strcpy(pos, arg);
+	pos += strlen(arg) + 1;
+	if (pos == list[n-1] + 1) { /* expansion is empty */
+		if (!(ored_ch & 0x80)) { /* all vars were not quoted... */
+			debug_printf_expand("expand_vars_to_list list[%d] empty, going back\n", n);
+			pos--;
+			n--;
+		}
+	}
+
+	*posp = pos;
+	return n;
+}
+
+static char **do_variable_expansion(char **argv)
+{
+	int n;
+	int count = 1;
+	int len = 0;
+	char *pos, **v, **list;
+
+	v = argv;
+	if (!*v) debug_printf_expand("count_var_expansion_space: "
+			"argv[0]=NULL count=%d len=%d alloc_space=%d\n",
+			count, len, sizeof(char*) * count + len);
+	while (*v) {
+		count_var_expansion_space(&count, &len, *v);
+		debug_printf_expand("count_var_expansion_space: "
+			"'%s' count=%d len=%d alloc_space=%d\n",
+			*v, count, len, sizeof(char*) * count + len);
+		v++;
+	}
+	len += sizeof(char*) * count; /* total to alloc */
+	list = xmalloc(len);
+	pos = (char*)(list + count);
+	debug_printf_expand("list=%p, list[0] should be %p\n", list, pos);
+	n = 0;
+	v = argv;
+	while (*v)
+		n = expand_vars_to_list(list, n, &pos, *v++);
+
+	if(n) debug_printf_expand("finalized list[%d]=%p '%s' "
+		"strlen=%d next=%p pos=%p\n", n-1, list[n-1], list[n-1],
+		strlen(list[n-1]), list[n-1] + strlen(list[n-1]) + 1, pos);
 	list[n] = NULL;
+
+#ifdef DEBUG_EXPAND
+	{
+		int m = 0;
+		while (m <= n) {
+			debug_printf_expand("list[%d]=%p '%s'\n", m, list[m], list[m]);
+			m++;
+		}
+		debug_printf_expand("used_space=%d\n", pos - (char*)list);
+	}
+#endif
+	/* To be removed / made conditional later. */
+	if (pos - (char*)list > len)
+		bb_error_msg_and_die("BUG in varexp");
 	return list;
 }
 
+
 static char *insert_var_value(char *inp)
 {
 	int res_str_len = 0;
@@ -2404,6 +2630,21 @@ static char *insert_var_value(char *inp)
 	return (res_str == NULL) ? inp : res_str;
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 /* This is used to get/check local shell variables */
 static const char *get_local_var(const char *s)
 {
@@ -2986,7 +3227,7 @@ static const char *lookup_param(const char *src)
 }
 
 /* Make new string for parser */
-static char* make_string(char ** inp)
+static char* make_string(char **inp)
 {
 	char *p;
 	char *str = NULL;