REDIRECT_IO = 5
} redir_type;
-/* The descrip member of this structure is only used to make debugging
- * output pretty */
+/* The descrip member of this structure is only used to make
+ * debugging output pretty */
static const struct {
int mode;
signed char default_fd;
};
struct redir_struct {
- struct redir_struct *next; /* pointer to the next redirect in the list */
- redir_type type; /* type of redirection */
+ struct redir_struct *next;
+ smallint /*redir_type*/ rd_type;
int fd; /* file descriptor being redirected */
int dup; /* -1, or file descriptor being duplicated */
char *rd_filename; /* filename */
struct child_prog {
pid_t pid; /* 0 if exited */
+ smallint is_stopped; /* is the program currently running? */
+ smallint subshell; /* flag, non-zero if group must be forked */
char **argv; /* program name and arguments */
struct pipe *group; /* if non-NULL, first in group or subshell */
- smallint subshell; /* flag, non-zero if group must be forked */
- smallint is_stopped; /* is the program currently running? */
struct redir_struct *redirects; /* I/O redirections */
struct pipe *family; /* pointer back to the child's parent pipe */
};
smallint o_glob;
smallint nonnull;
smallint has_empty_slot;
+ smallint o_assignment; /* 0:maybe, 1:yes, 2:no */
} o_string;
+enum {
+ MAYBE_ASSIGNMENT = 0,
+ DEFINITELY_ASSIGNMENT = 1,
+ NOT_ASSIGNMENT = 2,
+};
/* Used for initialization: o_string foo = NULL_O_STRING; */
#define NULL_O_STRING { NULL }
return *s == '=';
}
+/* Replace each \x with x in place, return ptr past NUL. */
+static char *unbackslash(char *src)
+{
+ char *dst = src;
+ while (1) {
+ if (*src == '\\')
+ src++;
+ if ((*dst++ = *src++) == '\0')
+ break;
+ }
+ return dst;
+}
+
static char **add_malloced_strings_to_strings(char **strings, char **add)
{
int i;
o->data[o->length] = '\0';
}
+static void o_addstr_duplicate_backslash(o_string *o, const char *str, int len)
+{
+ while (len) {
+ o_addchr(o, *str);
+ if (*str++ == '\\'
+ && (*str != '*' && *str != '?' && *str != '[')
+ ) {
+ o_addchr(o, '\\');
+ }
+ len--;
+ }
+}
+
/* My analysis of quoting semantics tells me that state information
* is associated with a destination, not a source.
*/
}
/* o_glob performs globbing on last list[], saving each result
- * as a new list[]. unbackslash() is just a helper */
-static char *unbackslash(char *src)
-{
- char *dst = src;
- while (1) {
- if (*src == '\\')
- src++;
- if ((*dst++ = *src++) == '\0')
- break;
- }
- return dst;
-}
+ * as a new list[]. */
static int o_glob(o_string *o, int n)
{
glob_t globdata;
}
if (redir->dup == -1) {
char *p;
- mode = redir_table[redir->type].mode;
+ mode = redir_table[redir->rd_type].mode;
+//TODO: check redir to names like '\\'
p = expand_string_to_string(redir->rd_filename);
openfd = open_or_warn(p, mode);
free(p);
for (i = 0; is_assignment(argv[i]); i++) {
p = expand_string_to_string(argv[i]);
putenv(p);
+//FIXME: do we leak p?!
}
for (x = bltins; x != &bltins[ARRAY_SIZE(bltins)]; x++) {
if (strcmp(argv[i], x->cmd) == 0) {
while (1) {
int word_len = strcspn(str, ifs);
if (word_len) {
- o_addstr(output, str, word_len);
+ if (output->o_quote || !output->o_glob)
+ o_addQstr(output, str, word_len);
+ else /* protect backslashes against globbing up :) */
+ o_addstr_duplicate_backslash(output, str, word_len);
str += word_len;
}
if (!*str) /* EOL - do not finalize word */
static int expand_vars_to_list(o_string *output, int n, char *arg, char or_mask)
{
/* or_mask is either 0 (normal case) or 0x80
- * (expansion of right-hand side of assignment == 1-element expand) */
+ * (expansion of right-hand side of assignment == 1-element expand.
+ * It will also do no globbing, and thus we must not backslash-quote!) */
char first_ch, ored_ch;
int i;
break;
if (!(first_ch & 0x80)) { /* unquoted $* or $@ */
while (global_argv[i]) {
+//see expand_on_ifs below - same??
n = expand_on_ifs(output, n, global_argv[i]);
debug_printf_expand("expand_vars_to_list: argv %d (last %d)\n", i, global_argc-1);
if (global_argv[i++][0] && global_argv[i]) {
arg[0] = first_ch & 0x7f;
if (isdigit(arg[0])) {
i = xatoi_u(arg);
- val = NULL;
if (i < global_argc)
val = global_argv[i];
+ /* else val remains NULL: $N with too big N */
} else
val = lookup_param(arg);
arg[0] = first_ch;
if (!(first_ch & 0x80)) { /* unquoted $VAR */
debug_printf_expand("unquoted '%s', output->o_quote:%d\n", val, output->o_quote);
if (val) {
+ /* unquoted var's contents should be globbed, so don't quote */
+ smallint sv = output->o_quote;
+ output->o_quote = 0;
n = expand_on_ifs(output, n, val);
val = NULL;
+ output->o_quote = sv;
}
- } else /* quoted $VAR, val will be appended below */
+ } else { /* quoted $VAR, val will be appended below */
debug_printf_expand("quoted '%s', output->o_quote:%d\n", val, output->o_quote);
+ }
}
if (val) {
o_addQstr(output, val, strlen(val)); ///maybe q?
if (or_mask & 0x100) {
output.o_quote = 1;
+/* why? */
output.o_glob = 1;
}
child->redirects = redir;
}
- redir->type = style;
+ redir->rd_type = style;
redir->fd = (fd == -1) ? redir_table[style].default_fd : fd;
debug_printf("Redirect type %d%s\n", redir->fd, redir_table[style].descrip);
{
struct child_prog *child = ctx->child;
+ /* If this word wasn't an assignment, next ones definitely
+ * can't be assignments. Even if they look like ones. */
+ if (word->o_assignment != DEFINITELY_ASSIGNMENT) {
+ word->o_assignment = NOT_ASSIGNMENT;
+ } else {
+ word->o_assignment = MAYBE_ASSIGNMENT;
+ }
+
debug_printf_parse("done_word entered: '%s' %p\n", word->data, child);
if (word->length == 0 && word->nonnull == 0) {
debug_printf_parse("done_word return 0: true null, ignored\n");
/* We do not glob in e.g. >*.tmp case. bash seems to glob here
* only if run as "bash", not "sh" */
ctx->pending_redirect->rd_filename = xstrdup(word->data);
+ word->o_assignment = NOT_ASSIGNMENT;
debug_printf("word stored in rd_filename: '%s'\n", word->data);
} else {
if (child->group) { /* TODO: example how to trigger? */
debug_printf_parse(": checking '%s' for reserved-ness\n", word->data);
if (reserved_word(word, ctx)) {
o_reset(word);
+ word->o_assignment = NOT_ASSIGNMENT;
debug_printf_parse("done_word return %d\n", (ctx->res_w == RES_SNTX));
return (ctx->res_w == RES_SNTX);
}
}
- if (word->nonnull
- /* && word->data[0] != */
+ if (word->nonnull /* we saw "xx" or 'xx' */
+ /* optimization: and if it's ("" or '') or ($v... or `cmd`...): */
+ && (word->data[0] == '\0' || word->data[0] == SPECIAL_VAR_SYMBOL)
+ /* (otherwise it's "abc".... and is already safe) */
) {
- /* Insert "empty variable" reference, this makes e.g. "", '',
- * $empty"" etc to not disappear */
+ /* Insert "empty variable" reference, this makes
+ * e.g. "", $empty"" etc to not disappear */
o_addchr(word, SPECIAL_VAR_SYMBOL);
o_addchr(word, SPECIAL_VAR_SYMBOL);
}
continue;
}
while (eol_cnt) {
- o_addQchr(dest, '\n');
+ o_addchr(dest, '\n');
eol_cnt--;
}
- /* Even unquoted `echo '\'` results in two backslashes
- * (which are converted into one by globbing later) */
- if (!dest->o_quote && ch == '\\') {
- o_addchr(dest, ch);
- }
+// /* Even unquoted `echo '\'` results in two backslashes
+// * (which are converted into one by globbing later) */
+// if (!dest->o_quote && ch == '\\') {
+// o_addchr(dest, ch);
+// }
o_addQchr(dest, ch);
}
return 0;
}
-/* Return code is 0 for normal exit, 1 for syntax error */
+/* Scan input, call done_word() whenever full IFS delemited word was seen.
+ * call done_pipe if '\n' was seen (and end_trigger != NULL)
+ * Return if (non-quoted) char in end_trigger was seen; or on parse error. */
+/* Return code is 0 if end_trigger char is met,
+ * -1 on EOF (but if end_trigger == NULL then return 0)
+ * 1 for syntax error */
static int parse_stream(o_string *dest, struct p_context *ctx,
struct in_str *input, const char *end_trigger)
{
int ch, m;
int redir_fd;
redir_type redir_style;
+ int shadow_quote = dest->o_quote;
int next;
/* Only double-quote state is handled in the state variable dest->o_quote.
ch = i_getch(input);
if (ch != EOF) {
m = charmap[ch];
- if (ch != '\n')
+ if (ch != '\n') {
next = i_peek(input);
+ }
}
debug_printf_parse(": ch=%c (%d) m=%d quote=%d\n",
ch, ch, m, dest->o_quote);
if (m == CHAR_ORDINARY
- || (m != CHAR_SPECIAL && dest->o_quote)
+ || (m != CHAR_SPECIAL && shadow_quote)
) {
if (ch == EOF) {
syntax("unterminated \"");
return 1;
}
o_addQchr(dest, ch);
+ if (dest->o_assignment == MAYBE_ASSIGNMENT
+ && ch == '='
+ && is_assignment(dest->data)
+ ) {
+ dest->o_assignment = DEFINITELY_ASSIGNMENT;
+ }
continue;
}
if (m == CHAR_IFS) {
}
}
if (end_trigger) {
- if (!dest->o_quote && strchr(end_trigger, ch)) {
+ if (!shadow_quote && strchr(end_trigger, ch)) {
/* Special case: (...word) makes last word terminate,
* as if ';' is seen */
if (ch == ')') {
done_word(dest, ctx);
+//err chk?
done_pipe(ctx, PIPE_SEQ);
}
if (ctx->res_w == RES_NONE) {
}
if (m == CHAR_IFS)
continue;
+
+ if (dest->o_assignment == MAYBE_ASSIGNMENT) {
+ /* ch is a special char and thus this word
+ * cannot be an assignment: */
+ dest->o_assignment = NOT_ASSIGNMENT;
+ }
+
switch (ch) {
case '#':
- if (dest->length == 0 && !dest->o_quote) {
+ if (dest->length == 0 && !shadow_quote) {
while (1) {
ch = i_peek(input);
if (ch == EOF || ch == '\n')
* an ! appearing in double quotes is escaped using
* a backslash. The backslash preceding the ! is not removed."
*/
- if (dest->o_quote) {
+ if (shadow_quote) { //NOT SURE dest->o_quote) {
if (strchr("$`\"\\", next) != NULL) {
o_addqchr(dest, i_getch(input));
} else {
}
if (ch == '\'')
break;
- o_addqchr(dest, ch);
+ if (dest->o_assignment == NOT_ASSIGNMENT)
+ o_addqchr(dest, ch);
+ else
+ o_addchr(dest, ch);
}
break;
case '"':
dest->nonnull = 1;
- dest->o_quote ^= 1; /* invert */
+ shadow_quote ^= 1; /* invert */
+ if (dest->o_assignment == NOT_ASSIGNMENT)
+ dest->o_quote ^= 1;
break;
#if ENABLE_HUSH_TICK
case '`': {
//int pos = dest->length;
o_addchr(dest, SPECIAL_VAR_SYMBOL);
- o_addchr(dest, dest->o_quote ? 0x80 | '`' : '`');
+ o_addchr(dest, shadow_quote /*or dest->o_quote??*/ ? 0x80 | '`' : '`');
add_till_backquote(dest, input);
o_addchr(dest, SPECIAL_VAR_SYMBOL);
//debug_printf_subst("SUBST RES3 '%s'\n", dest->data + pos);
bb_error_msg_and_die("BUG: unexpected %c\n", ch);
}
} /* while (1) */
- /* Complain if quote? No, maybe we just finished a command substitution
- * that was quoted. Example:
- * $ echo "`cat foo` plus more"
- * and we just got the EOF generated by the subshell that ran "cat foo"
- * The only real complaint is if we got an EOF when end_trigger != NULL,
- * that is, we were really supposed to get end_trigger, and never got
- * one before the EOF. Can't use the standard "syntax error" return code,
- * so that parse_stream_outer can distinguish the EOF and exit smoothly. */
debug_printf_parse("parse_stream return %d\n", -(end_trigger != NULL));
if (end_trigger)
return -1;
projects / oweals / busybox.git / commitdiff