X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=shell%2Fhush.c;h=32b90876fde26c265a53b61af9678d9ca8661173;hb=a6ad397ea92cd9c53973243728d3e52640fe63ec;hp=d02e68d496a5ef08b64d215b10feaea3b8703335;hpb=385cc59117f2788d24d2cd75fd58f7ff044d501c;p=oweals%2Fbusybox.git diff --git a/shell/hush.c b/shell/hush.c index d02e68d49..32b90876f 100644 --- a/shell/hush.c +++ b/shell/hush.c @@ -37,29 +37,32 @@ * handle the recursion implicit in the various substitutions, especially * across continuation lines. * - * POSIX syntax not implemented: + * TODOs: + * grep for "TODO" and fix (some of them are easy) + * special variables (done: PWD, PPID, RANDOM) + * tilde expansion * aliases - * <(list) and >(list) Process Substitution - * Tilde Expansion + * follow IFS rules more precisely, including update semantics + * builtins mandated by standards we don't support: + * [un]alias, command, fc, getopts, newgrp, readonly, times + * make complex ${var%...} constructs support optional + * make here documents optional * - * Bash stuff (optionally enabled): - * &> and >& redirection of stdout+stderr - * Brace Expansion - * reserved words: [[ ]] function select - * substrings ${var:1:5} + * Bash compat TODO: + * redirection of stdout+stderr: &> and >& + * brace expansion: one/{two,three,four} + * reserved words: function select + * advanced test: [[ ]] + * process substitution: <(list) and >(list) + * =~: regex operator * let EXPR [EXPR...] - * Each EXPR is an arithmetic expression (ARITHMETIC EVALUATION) - * If the last arg evaluates to 0, let returns 1; 0 otherwise. - * NB: let `echo 'a=a + 1'` - error (IOW: multi-word expansion is used) + * Each EXPR is an arithmetic expression (ARITHMETIC EVALUATION) + * If the last arg evaluates to 0, let returns 1; 0 otherwise. + * NB: let `echo 'a=a + 1'` - error (IOW: multi-word expansion is used) * ((EXPR)) - * The EXPR is evaluated according to ARITHMETIC EVALUATION. - * This is exactly equivalent to let "expression". - * - * TODOs: - * grep for "TODO" and fix (some of them are easy) - * builtins: ulimit - * special variables (done: PWD) - * follow IFS rules more precisely, including update semantics + * The EXPR is evaluated according to ARITHMETIC EVALUATION. + * This is exactly equivalent to let "EXPR". + * $[EXPR]: synonym for $((EXPR)) * export builtin should be special, its arguments are assignments * and therefore expansion of them should be "one-word" expansion: * $ export i=`echo 'a b'` # export has one arg: "i=a b" @@ -84,6 +87,10 @@ #if ENABLE_HUSH_CASE # include #endif + +#include "shell_common.h" +#include "builtin_read.h" +#include "builtin_ulimit.h" #include "math.h" #include "match.h" #if ENABLE_HUSH_RANDOM_SUPPORT @@ -122,14 +129,18 @@ # define USE_FOR_MMU(...) #endif -#if defined SINGLE_APPLET_MAIN +#define SKIP_definitions 1 +#include "applet_tables.h" +#undef SKIP_definitions +#if NUM_APPLETS == 1 /* STANDALONE does not make sense, and won't compile */ # undef CONFIG_FEATURE_SH_STANDALONE # undef ENABLE_FEATURE_SH_STANDALONE # undef IF_FEATURE_SH_STANDALONE +# undef IF_NOT_FEATURE_SH_STANDALONE +# define ENABLE_FEATURE_SH_STANDALONE 0 # define IF_FEATURE_SH_STANDALONE(...) # define IF_NOT_FEATURE_SH_STANDALONE(...) __VA_ARGS__ -# define ENABLE_FEATURE_SH_STANDALONE 0 #endif #if !ENABLE_HUSH_INTERACTIVE @@ -520,6 +531,7 @@ struct globals { smalluint last_exitcode; /* are global_argv and global_argv[1..n] malloced? (note: not [0]) */ smalluint global_args_malloced; + smalluint inherited_set_is_saved; /* how many non-NULL argv's we have. NB: $# + 1 */ int global_argc; char **global_argv; @@ -617,10 +629,10 @@ static int builtin_return(char **argv) FAST_FUNC; * For example, 'unset foo | whatever' will parse and run, but foo will * still be set at the end. */ struct built_in_command { - const char *cmd; - int (*function)(char **argv) FAST_FUNC; + const char *b_cmd; + int (*b_function)(char **argv) FAST_FUNC; #if ENABLE_HUSH_HELP - const char *descr; + const char *b_descr; # define BLTIN(cmd, func, help) { cmd, func, help } #else # define BLTIN(cmd, func, help) { cmd, func } @@ -665,9 +677,12 @@ static const struct built_in_command bltins1[] = { #endif BLTIN("set" , builtin_set , "Set/unset positional parameters"), BLTIN("shift" , builtin_shift , "Shift positional parameters"), +#if ENABLE_HUSH_BASH_COMPAT + BLTIN("source" , builtin_source , "Run commands in a file"), +#endif BLTIN("trap" , builtin_trap , "Trap signals"), - BLTIN("type" , builtin_type , "Write a description of command type"), -// BLTIN("ulimit" , builtin_ulimit , "Control resource limits"), + BLTIN("type" , builtin_type , "Show command type"), + BLTIN("ulimit" , shell_builtin_ulimit , "Control resource limits"), BLTIN("umask" , builtin_umask , "Set file creation mask"), BLTIN("unset" , builtin_unset , "Unset variables"), BLTIN("wait" , builtin_wait , "Wait for process"), @@ -889,16 +904,6 @@ static void cmdedit_update_prompt(void); /* Utility functions */ -static int is_well_formed_var_name(const char *s, char terminator) -{ - if (!s || !(isalpha(*s) || *s == '_')) - return 0; - s++; - while (isalnum(*s) || *s == '_') - s++; - return *s == terminator; -} - /* Replace each \x with x in place, return ptr past NUL. */ static char *unbackslash(char *src) { @@ -1050,7 +1055,8 @@ static void restore_G_args(save_arg_t *sv, char **argv) * * Trap handlers will execute even within trap handlers. (right?) * - * User trap handlers are forgotten when subshell ("(cmd)") is entered. + * User trap handlers are forgotten when subshell ("(cmd)") is entered, + * except for handlers set to '' (empty string). * * If job control is off, backgrounded commands ("cmd &") * have SIGINT, SIGQUIT set to SIG_IGN. @@ -1106,7 +1112,7 @@ static void restore_G_args(save_arg_t *sv, char **argv) * after [v]fork, if we plan to be a shell: * unblock signals with special interactive handling * (child shell is not interactive), - * unset all traps (note: regardless of child shell's type - {}, (), etc) + * unset all traps except '' (note: regardless of child shell's type - {}, (), etc) * after [v]fork, if we plan to exec: * POSIX says fork clears pending signal mask in child - no need to clear it. * Restore blocked signal set to one inherited by shell just prior to exec. @@ -1118,7 +1124,7 @@ static void restore_G_args(save_arg_t *sv, char **argv) * Note 2 (compat): * Standard says "When a subshell is entered, traps that are not being ignored * are set to the default actions". bash interprets it so that traps which - * are set to "" (ignore) are NOT reset to defaults. We do the same. + * are set to '' (ignore) are NOT reset to defaults. We do the same. */ enum { SPECIAL_INTERACTIVE_SIGS = 0 @@ -1305,7 +1311,7 @@ static struct variable *get_local_var(const char *name) return NULL; } -static const char *get_local_var_value(const char *name) +static const char* FAST_FUNC get_local_var_value(const char *name) { struct variable **pp = get_ptr_to_local_var(name); if (pp) @@ -1508,7 +1514,7 @@ static void unset_vars(char **strings) #if ENABLE_SH_MATH_SUPPORT #define is_name(c) ((c) == '_' || isalpha((unsigned char)(c))) #define is_in_name(c) ((c) == '_' || isalnum((unsigned char)(c))) -static char *endofname(const char *name) +static char* FAST_FUNC endofname(const char *name) { char *p; @@ -1521,14 +1527,13 @@ static char *endofname(const char *name) } return p; } +#endif -static void arith_set_local_var(const char *name, const char *val, int flags) +static void FAST_FUNC set_local_var_from_halves(const char *name, const char *val) { - /* arith code doesnt malloc space, so do it for it */ char *var = xasprintf("%s=%s", name, val); - set_local_var(var, flags, /*lvl:*/ 0, /*ro:*/ 0); + set_local_var(var, /*flags:*/ 0, /*lvl:*/ 0, /*ro:*/ 0); } -#endif /* @@ -2043,7 +2048,7 @@ static const char *next_brace_sub(const char *cp) break; cp++; continue; - } + } /*{*/ if ((*cp == '}' && depth-- == 0) || (*cp == ',' && depth == 0)) break; if (*cp++ == '{') /*}*/ @@ -2400,6 +2405,23 @@ static char *expand_pseudo_dquoted(const char *str) return exp_str; } +#if ENABLE_SH_MATH_SUPPORT +static arith_t expand_and_evaluate_arith(const char *arg, int *errcode_p) +{ + arith_eval_hooks_t hooks; + arith_t res; + char *exp_str; + + hooks.lookupvar = get_local_var_value; + hooks.setvar = set_local_var_from_halves; + hooks.endofname = endofname; + exp_str = expand_pseudo_dquoted(arg); + res = arith(exp_str ? exp_str : arg, errcode_p, &hooks); + free(exp_str); + return res; +} +#endif + /* 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 @@ -2424,7 +2446,7 @@ static NOINLINE int expand_vars_to_list(o_string *output, int n, char *arg, char while ((p = strchr(arg, SPECIAL_VAR_SYMBOL)) != NULL) { char first_ch; int i; - char *dyn_val = NULL; + char *to_be_freed = NULL; const char *val = NULL; #if ENABLE_HUSH_TICK o_string subst_result = NULL_O_STRING; @@ -2519,27 +2541,19 @@ static NOINLINE int expand_vars_to_list(o_string *output, int n, char *arg, char * and $IFS-splitted */ debug_printf_subst("SUBST '%s' first_ch %x\n", arg, first_ch); G.last_exitcode = process_command_subs(&subst_result, arg); - debug_printf_subst("SUBST RES '%s'\n", subst_result.data); + debug_printf_subst("SUBST RES:%d '%s'\n", G.last_exitcode, subst_result.data); val = subst_result.data; goto store_val; #endif #if ENABLE_SH_MATH_SUPPORT case '+': { /* +cmd */ - arith_eval_hooks_t hooks; arith_t res; int errcode; - char *exp_str; arg++; /* skip '+' */ *p = '\0'; /* replace trailing */ debug_printf_subst("ARITH '%s' first_ch %x\n", arg, first_ch); - - exp_str = expand_pseudo_dquoted(arg); - hooks.lookupvar = get_local_var_value; - hooks.setvar = arith_set_local_var; - hooks.endofname = endofname; - res = arith(exp_str ? exp_str : arg, &errcode, &hooks); - free(exp_str); + res = expand_and_evaluate_arith(arg, &errcode); if (errcode < 0) { const char *msg = "error in arithmetic"; @@ -2564,35 +2578,32 @@ static NOINLINE int expand_vars_to_list(o_string *output, int n, char *arg, char #endif default: /* varname */ case_default: { - bool exp_len = false; - bool exp_null = false; char *var = arg; + char exp_len; /* '#' if it's ${#var} */ + char exp_op; char exp_save = exp_save; /* for compiler */ - char exp_op = exp_op; /* for compiler */ + char *exp_saveptr = exp_saveptr; /* points to expansion operator */ char *exp_word = exp_word; /* for compiler */ - size_t exp_off = 0; *p = '\0'; arg[0] = first_ch & 0x7f; /* prepare for expansions */ - if (var[0] == '#') { + exp_op = 0; + exp_len = var[0]; + if (exp_len == '#') { /* handle length expansion ${#var} */ - exp_len = true; - ++var; + var++; } else { /* maybe handle parameter expansion */ - exp_off = strcspn(var, ":-=+?%#"); - if (!var[exp_off]) - exp_off = 0; - if (exp_off) { - exp_save = var[exp_off]; - exp_null = exp_save == ':'; - exp_word = var + exp_off; - if (exp_null) - ++exp_word; + exp_saveptr = var + strcspn(var, "%#:-=+?"); + exp_save = *exp_saveptr; + if (exp_save) { + exp_word = exp_saveptr; + if (exp_save == ':') + exp_word++; exp_op = *exp_word++; - var[exp_off] = '\0'; + *exp_saveptr = '\0'; } } @@ -2607,43 +2618,118 @@ static NOINLINE int expand_vars_to_list(o_string *output, int n, char *arg, char val = get_local_var_value(var); /* handle any expansions */ - if (exp_len) { - debug_printf_expand("expand: length of '%s' = ", val); + if (exp_len == '#') { + debug_printf_expand("expand: length(%s)=", val); val = utoa(val ? strlen(val) : 0); debug_printf_expand("%s\n", val); - } else if (exp_off) { + } else if (exp_op) { if (exp_op == '%' || exp_op == '#') { + /* Standard-mandated substring removal ops: + * ${parameter%word} - remove smallest suffix pattern + * ${parameter%%word} - remove largest suffix pattern + * ${parameter#word} - remove smallest prefix pattern + * ${parameter##word} - remove largest prefix pattern + * + * Word is expanded to produce a glob pattern. + * Then var's value is matched to it and matching part removed. + */ if (val) { - /* we need to do a pattern match */ bool match_at_left; char *loc; scan_t scan = pick_scan(exp_op, *exp_word, &match_at_left); if (exp_op == *exp_word) /* ## or %% */ - ++exp_word; - val = dyn_val = xstrdup(val); - loc = scan(dyn_val, exp_word, match_at_left); - if (match_at_left) /* # or ## */ - val = loc; - else if (loc) /* % or %% and match was found */ - *loc = '\0'; + exp_word++; + val = to_be_freed = xstrdup(val); + { + char *exp_exp_word = expand_pseudo_dquoted(exp_word); + if (exp_exp_word) + exp_word = exp_exp_word; + loc = scan(to_be_freed, exp_word, match_at_left); + //bb_error_msg("op:%c str:'%s' pat:'%s' res:'%s'", + // exp_op, to_be_freed, exp_word, loc); + free(exp_exp_word); + } + if (loc) { /* match was found */ + if (match_at_left) /* # or ## */ + val = loc; + else /* % or %% */ + *loc = '\0'; + } } - } else { - /* we need to do an expansion */ - int exp_test = (!val || (exp_null && !val[0])); + } else if (!strchr("%#:-=+?"+3, exp_op)) { +#if ENABLE_HUSH_BASH_COMPAT + /* exp_op is ':' and next char isn't a subst operator. + * Assuming it's ${var:[N][:M]} bashism. + * TODO: N, M can be expressions similar to $((EXPR)): 2+2, 2+var etc + */ + char *end; + unsigned len = INT_MAX; + unsigned beg = 0; + end = --exp_word; + if (*exp_word != ':') /* not ${var::...} */ + beg = bb_strtou(exp_word, &end, 0); + //bb_error_msg("beg:'%s'=%u end:'%s'", exp_word, beg, end); + if (*end == ':') { + if (end[1] != '\0') /* not ${var:NUM:} */ + len = bb_strtou(end + 1, &end, 0); + else { + len = 0; + end++; + } + //bb_error_msg("len:%u end:'%s'", len, end); + } + if (*end == '\0') { + //bb_error_msg("from val:'%s'", val); + if (len == 0 || !val || beg >= strlen(val)) + val = ""; + else + val = to_be_freed = xstrndup(val + beg, len); + //bb_error_msg("val:'%s'", val); + } else +#endif + { + die_if_script("malformed ${%s...}", var); + val = ""; + } + } else { /* one of "-=+?" */ + /* Standard-mandated substitution ops: + * ${var?word} - indicate error if unset + * If var is unset, word (or a message indicating it is unset + * if word is null) is written to standard error + * and the shell exits with a non-zero exit status. + * Otherwise, the value of var is substituted. + * ${var-word} - use default value + * If var is unset, word is substituted. + * ${var=word} - assign and use default value + * If var is unset, word is assigned to var. + * In all cases, final value of var is substituted. + * ${var+word} - use alternative value + * If var is unset, null is substituted. + * Otherwise, word is substituted. + * + * Word is subjected to tilde expansion, parameter expansion, + * command substitution, and arithmetic expansion. + * If word is not needed, it is not expanded. + * + * Colon forms (${var:-word}, ${var:=word} etc) do the same, + * but also treat null var as if it is unset. + */ + int use_word = (!val || ((exp_save == ':') && !val[0])); if (exp_op == '+') - exp_test = !exp_test; + use_word = !use_word; debug_printf_expand("expand: op:%c (null:%s) test:%i\n", exp_op, - exp_null ? "true" : "false", exp_test); - if (exp_test) { + (exp_save == ':') ? "true" : "false", use_word); + if (use_word) { + to_be_freed = expand_pseudo_dquoted(exp_word); + if (to_be_freed) + exp_word = to_be_freed; if (exp_op == '?') { -//TODO: how interactive bash aborts expansion mid-command? - /* ${var?[error_msg_if_unset]} */ - /* ${var:?[error_msg_if_unset_or_null]} */ /* mimic bash message */ die_if_script("%s: %s", var, exp_word[0] ? exp_word : "parameter null or not set" ); +//TODO: how interactive bash aborts expansion mid-command? } else { val = exp_word; } @@ -2662,8 +2748,8 @@ static NOINLINE int expand_vars_to_list(o_string *output, int n, char *arg, char } } - var[exp_off] = exp_save; - } + *exp_saveptr = exp_save; + } /* if (exp_op) */ arg[0] = first_ch; #if ENABLE_HUSH_TICK @@ -2688,7 +2774,7 @@ static NOINLINE int expand_vars_to_list(o_string *output, int n, char *arg, char if (val) { o_addQstr(output, val, strlen(val)); } - free(dyn_val); + free(to_be_freed); /* Do the check to avoid writing to a const string */ if (*p != SPECIAL_VAR_SYMBOL) *p = SPECIAL_VAR_SYMBOL; @@ -2917,7 +3003,9 @@ static void re_execute_shell(char ***to_free, const char *s, char *g_argv0, char **g_argv, char **builtin_argv) { - char param_buf[sizeof("-$%x:%x:%x:%x:%x") + sizeof(unsigned) * 2]; +#define NOMMU_HACK_FMT ("-$%x:%x:%x:%x:%x:%llx" IF_HUSH_LOOPS(":%x")) + /* delims + 2 * (number of bytes in printed hex numbers) */ + char param_buf[sizeof(NOMMU_HACK_FMT) + 2 * (sizeof(int)*6 + sizeof(long long)*1)]; char *heredoc_argv[4]; struct variable *cur; # if ENABLE_HUSH_FUNCTIONS @@ -2925,6 +3013,7 @@ static void re_execute_shell(char ***to_free, const char *s, # endif char **argv, **pp; unsigned cnt; + unsigned long long empty_trap_mask; if (!g_argv0) { /* heredoc */ argv = heredoc_argv; @@ -2941,15 +3030,26 @@ static void re_execute_shell(char ***to_free, const char *s, if (pp) while (*pp++) cnt++; - sprintf(param_buf, "-$%x:%x:%x:%x:%x" IF_HUSH_LOOPS(":%x") + empty_trap_mask = 0; + if (G.traps) { + int sig; + for (sig = 1; sig < NSIG; sig++) { + if (G.traps[sig] && !G.traps[sig][0]) + empty_trap_mask |= 1LL << sig; + } + } + + sprintf(param_buf, NOMMU_HACK_FMT , (unsigned) G.root_pid , (unsigned) G.root_ppid , (unsigned) G.last_bg_pid , (unsigned) G.last_exitcode , cnt + , empty_trap_mask IF_HUSH_LOOPS(, G.depth_of_loop) ); - /* 1:hush 2:-$::: +#undef NOMMU_HACK_FMT + /* 1:hush 2:-$::: * 3:-c 4: 5: 6:NULL */ cnt += 6; @@ -3002,7 +3102,9 @@ static void re_execute_shell(char ***to_free, const char *s, * _inside_ group (just before echo 1), it works. * * I conclude it means we don't need to pass active traps here. - * exec syscall below resets them to SIG_DFL for us. + * Even if we would use signal handlers instead of signal masking + * in order to implement trap handling, + * exec syscall below resets signals to SIG_DFL for us. */ *pp++ = (char *) "-c"; *pp++ = (char *) s; @@ -3326,7 +3428,7 @@ static const struct built_in_command* find_builtin_helper(const char *name, const struct built_in_command *end) { while (x != end) { - if (strcmp(name, x->cmd) != 0) { + if (strcmp(name, x->b_cmd) != 0) { x++; continue; } @@ -3537,7 +3639,7 @@ static void exec_builtin(char ***to_free, char **argv) { #if BB_MMU - int rcode = x->function(argv); + int rcode = x->b_function(argv); fflush_all(); _exit(rcode); #else @@ -4097,7 +4199,8 @@ static NOINLINE int run_pipe(struct pipe *pi) if (argv[command->assignment_cnt] == NULL) { /* Assignments, but no command */ - /* Ensure redirects take effect. Try "a=t >file" */ + /* Ensure redirects take effect (that is, create files). + * Try "a=t >file": */ rcode = setup_redirects(command, squirrel); restore_redirects(squirrel); /* Set shell variables */ @@ -4108,6 +4211,11 @@ static NOINLINE int run_pipe(struct pipe *pi) set_local_var(p, /*exp:*/ 0, /*lvl:*/ 0, /*ro:*/ 0); argv++; } + /* Redirect error sets $? to 1. Othervise, + * if evaluating assignment value set $?, retain it. + * Try "false; q=`exit 2`; echo $?" - should print 2: */ + if (rcode == 0) + rcode = G.last_exitcode; /* Do we need to flag set_local_var() errors? * "assignment to readonly var" and "putenv error" */ @@ -4149,7 +4257,7 @@ static NOINLINE int run_pipe(struct pipe *pi) #endif if (x || funcp) { if (!funcp) { - if (x->function == builtin_exec && argv_expanded[1] == NULL) { + if (x->b_function == builtin_exec && argv_expanded[1] == NULL) { debug_printf("exec with redirects only\n"); rcode = setup_redirects(command, NULL); goto clean_up_and_ret1; @@ -4165,8 +4273,8 @@ static NOINLINE int run_pipe(struct pipe *pi) old_vars = set_vars_and_save_old(new_env); if (!funcp) { debug_printf_exec(": builtin '%s' '%s'...\n", - x->cmd, argv_expanded[1]); - rcode = x->function(argv_expanded) & 0xff; + x->b_cmd, argv_expanded[1]); + rcode = x->b_function(argv_expanded) & 0xff; fflush_all(); } #if ENABLE_HUSH_FUNCTIONS @@ -4406,9 +4514,15 @@ static void debug_print_tree(struct pipe *pi, int lvl) lvl*2, "", prn, command->assignment_cnt); if (command->group) { - fprintf(stderr, " group %s: (argv=%p)\n", + fprintf(stderr, " group %s: (argv=%p)%s%s\n", CMDTYPE[command->cmd_type], - argv); + argv +#if !BB_MMU + , " group_as_string:", command->group_as_string +#else + , "", "" +#endif + ); debug_print_tree(command->group, lvl+1); prn++; continue; @@ -5441,7 +5555,7 @@ static FILE *generate_stream_from_string(const char *s, pid_t *pid_p) pid_t pid; int channel[2]; # if !BB_MMU - char **to_free; + char **to_free = NULL; # endif xpipe(channel); @@ -5774,29 +5888,37 @@ static void add_till_backquote(o_string *dest, struct in_str *input) * echo $(echo '(TEST)' BEST) (TEST) BEST * echo $(echo 'TEST)' BEST) TEST) BEST * echo $(echo \(\(TEST\) BEST) ((TEST) BEST + * + * Also adapted to eat ${var%...} constructs, since ... part + * can contain arbitrary constructs, just like $(cmd). */ -static void add_till_closing_paren(o_string *dest, struct in_str *input, bool dbl) +#define DOUBLE_CLOSE_CHAR_FLAG 0x80 +static void add_till_closing_paren(o_string *dest, struct in_str *input, char end_ch) { - int count = 0; + char dbl = end_ch & DOUBLE_CLOSE_CHAR_FLAG; + end_ch &= (DOUBLE_CLOSE_CHAR_FLAG-1); while (1) { int ch = i_getch(input); if (ch == EOF) { - syntax_error_unterm_ch(')'); + syntax_error_unterm_ch(end_ch); /*xfunc_die(); - redundant */ } - if (ch == '(') - count++; - if (ch == ')') { - if (--count < 0) { - if (!dbl) - break; - if (i_peek(input) == ')') { - i_getch(input); - break; - } + if (ch == end_ch) { + if (!dbl) + break; + /* we look for closing )) of $((EXPR)) */ + if (i_peek(input) == end_ch) { + i_getch(input); /* eat second ')' */ + break; } } o_addchr(dest, ch); + if (ch == '(' || ch == '{') { + ch = (ch == '(' ? ')' : '}'); + add_till_closing_paren(dest, input, ch); + o_addchr(dest, ch); + continue; + } if (ch == '\'') { add_till_single_quote(dest, input); o_addchr(dest, ch); @@ -5807,6 +5929,11 @@ static void add_till_closing_paren(o_string *dest, struct in_str *input, bool db o_addchr(dest, ch); continue; } + if (ch == '`') { + add_till_backquote(dest, input); + o_addchr(dest, ch); + continue; + } if (ch == '\\') { /* \x. Copy verbatim. Important for \(, \) */ ch = i_getch(input); @@ -5867,84 +5994,52 @@ static int handle_dollar(o_string *as_string, case '@': /* args */ goto make_one_char_var; case '{': { - bool first_char, all_digits; - int expansion; + o_addchr(dest, SPECIAL_VAR_SYMBOL); - ch = i_getch(input); + ch = i_getch(input); /* eat '{' */ nommu_addchr(as_string, ch); - o_addchr(dest, SPECIAL_VAR_SYMBOL); - /* TODO: maybe someone will try to escape the '}' */ - expansion = 0; - first_char = true; - all_digits = false; + ch = i_getch(input); /* first char after '{' */ + nommu_addchr(as_string, ch); + /* It should be ${?}, or ${#var}, + * or even ${?+subst} - operator acting on a special variable, + * or the beginning of variable name. + */ + if (!strchr("$!?#*@_", ch) && !isalnum(ch)) { /* not one of those */ + bad_dollar_syntax: + syntax_error_unterm_str("${name}"); + debug_printf_parse("handle_dollar return 1: unterminated ${name}\n"); + return 1; + } + ch |= quote_mask; + + /* It's possible to just call add_till_closing_paren() at this point. + * However, this regresses some of our testsuite cases + * which check invalid constructs like ${%}. + * Oh well... let's check that the var name part is fine... */ + while (1) { + o_addchr(dest, ch); + debug_printf_parse(": '%c'\n", ch); + ch = i_getch(input); nommu_addchr(as_string, ch); - if (ch == '}') { + if (ch == '}') break; - } - if (first_char) { - if (ch == '#') { - /* ${#var}: length of var contents */ - goto char_ok; - } - if (isdigit(ch)) { - all_digits = true; - goto char_ok; - } - /* They're being verbose and doing ${?} */ - if (i_peek(input) == '}' && strchr("$!?#*@_", ch)) - goto char_ok; - } - - if (expansion < 2 - && ( (all_digits && !isdigit(ch)) - || (!all_digits && !isalnum(ch) && ch != '_') - ) - ) { + if (!isalnum(ch) && ch != '_') { /* handle parameter expansions * http://www.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html#tag_02_06_02 */ - if (first_char) - goto case_default; - switch (ch) { - case ':': /* null modifier */ - if (expansion == 0) { - debug_printf_parse(": null modifier\n"); - ++expansion; - break; - } - goto case_default; - case '#': /* remove prefix */ - case '%': /* remove suffix */ - if (expansion == 0) { - debug_printf_parse(": remove suffix/prefix\n"); - expansion = 2; - break; - } - goto case_default; - case '-': /* default value */ - case '=': /* assign default */ - case '+': /* alternative */ - case '?': /* error indicate */ - debug_printf_parse(": parameter expansion\n"); - expansion = 2; - break; - default: - case_default: - syntax_error_unterm_str("${name}"); - debug_printf_parse("handle_dollar return 1: unterminated ${name}\n"); - return 1; - } + if (!strchr("%#:-=+?", ch)) /* ${var... */ + goto bad_dollar_syntax; + /* Eat everything until closing '}' */ + o_addchr(dest, ch); +//TODO: add nommu_addchr hack here + add_till_closing_paren(dest, input, '}'); + break; } - char_ok: - debug_printf_parse(": '%c'\n", ch); - o_addchr(dest, ch | quote_mask); - quote_mask = 0; - first_char = false; - } /* while (1) */ + } o_addchr(dest, SPECIAL_VAR_SYMBOL); break; } @@ -5964,7 +6059,7 @@ static int handle_dollar(o_string *as_string, # if !BB_MMU pos = dest->length; # endif - add_till_closing_paren(dest, input, true); + add_till_closing_paren(dest, input, ')' | DOUBLE_CLOSE_CHAR_FLAG); # if !BB_MMU if (as_string) { o_addstr(as_string, dest->data + pos); @@ -5982,11 +6077,11 @@ static int handle_dollar(o_string *as_string, # if !BB_MMU pos = dest->length; # endif - add_till_closing_paren(dest, input, false); + add_till_closing_paren(dest, input, ')'); # if !BB_MMU if (as_string) { o_addstr(as_string, dest->data + pos); - o_addchr(as_string, '`'); + o_addchr(as_string, ')'); } # endif o_addchr(dest, SPECIAL_VAR_SYMBOL); @@ -6133,7 +6228,7 @@ static struct pipe *parse_stream(char **pstring, G.ifs = get_local_var_value("IFS"); if (G.ifs == NULL) - G.ifs = " \t\n"; + G.ifs = defifs; reset: #if ENABLE_HUSH_INTERACTIVE @@ -6211,10 +6306,15 @@ static struct pipe *parse_stream(char **pstring, is_special = "{}<>;&|()#'" /* special outside of "str" */ "\\$\"" IF_HUSH_TICK("`"); /* always special */ /* Are { and } special here? */ - if (ctx.command->argv /* word [word]{... */ - || dest.length /* word{... */ - || dest.o_quoted /* ""{... */ - || (next != ';' && next != ')' && !strchr(G.ifs, next)) /* {word */ + if (ctx.command->argv /* word [word]{... - non-special */ + || dest.length /* word{... - non-special */ + || dest.o_quoted /* ""{... - non-special */ + || (next != ';' /* }; - special */ + && next != ')' /* }) - special */ + && next != '&' /* }& and }&& ... - special */ + && next != '|' /* }|| ... - special */ + && !strchr(G.ifs, next) /* {word - non-special */ + ) ) { /* They are not special, skip "{}" */ is_special += 2; @@ -6535,6 +6635,9 @@ static struct pipe *parse_stream(char **pstring, * with redirect_opt_num(), but bash doesn't do it. * "echo foo 2| cat" yields "foo 2". */ done_command(&ctx); +#if !BB_MMU + o_reset_to_empty_unquoted(&ctx.as_string); +#endif } goto new_cmd; case '(': @@ -6668,10 +6771,17 @@ static void parse_and_run_file(FILE *f) } /* Called a few times only (or even once if "sh -c") */ -static void block_signals(int second_time) +static void init_sigmasks(void) { unsigned sig; unsigned mask; + sigset_t old_blocked_set; + + if (!G.inherited_set_is_saved) { + sigprocmask(SIG_SETMASK, NULL, &G.blocked_set); + G.inherited_set = G.blocked_set; + } + old_blocked_set = G.blocked_set; mask = (1 << SIGQUIT); if (G_interactive_fd) { @@ -6681,8 +6791,6 @@ static void block_signals(int second_time) } G.non_DFL_mask = mask; - if (!second_time) - sigprocmask(SIG_SETMASK, NULL, &G.blocked_set); sig = 0; while (mask) { if (mask & 1) @@ -6692,18 +6800,21 @@ static void block_signals(int second_time) } sigdelset(&G.blocked_set, SIGCHLD); - sigprocmask(SIG_SETMASK, &G.blocked_set, - second_time ? NULL : &G.inherited_set); + if (memcmp(&old_blocked_set, &G.blocked_set, sizeof(old_blocked_set)) != 0) + sigprocmask(SIG_SETMASK, &G.blocked_set, NULL); + /* POSIX allows shell to re-enable SIGCHLD * even if it was SIG_IGN on entry */ #if ENABLE_HUSH_FAST G.count_SIGCHLD++; /* ensure it is != G.handled_SIGCHLD */ - if (!second_time) + if (!G.inherited_set_is_saved) signal(SIGCHLD, SIGCHLD_handler); #else - if (!second_time) + if (!G.inherited_set_is_saved) signal(SIGCHLD, SIG_DFL); #endif + + G.inherited_set_is_saved = 1; } #if ENABLE_HUSH_JOB @@ -6765,14 +6876,13 @@ int hush_main(int argc, char **argv) .flg_export = 1, .flg_read_only = 1, }; - int signal_mask_is_inited = 0; int opt; unsigned builtin_argc; char **e; struct variable *cur_var; INIT_G(); - if (EXIT_SUCCESS) /* if EXIT_SUCCESS == 0, is already done */ + if (EXIT_SUCCESS) /* if EXIT_SUCCESS == 0, it is already done */ G.last_exitcode = EXIT_SUCCESS; #if !BB_MMU G.argv0_for_re_execing = argv[0]; @@ -6856,10 +6966,9 @@ int hush_main(int argc, char **argv) } /* Shell is non-interactive at first. We need to call - * block_signals(0) if we are going to execute "sh