shell/hush.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * A prototype Bourne shell grammar parser.
   4  * Intended to follow the original Thompson and Ritchie
   5  * "small and simple is beautiful" philosophy, which
   6  * incidentally is a good match to today's BusyBox.
   7  *
   8  * Copyright (C) 2000,2001  Larry Doolittle <larry@doolittle.boa.org>
   9  * Copyright (C) 2008,2009  Denys Vlasenko <vda.linux@googlemail.com>
  10  *
  11  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  12  *
  13  * Credits:
  14  *      The parser routines proper are all original material, first
  15  *      written Dec 2000 and Jan 2001 by Larry Doolittle.  The
  16  *      execution engine, the builtins, and much of the underlying
  17  *      support has been adapted from busybox-0.49pre's lash, which is
  18  *      Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
  19  *      written by Erik Andersen <andersen@codepoet.org>.  That, in turn,
  20  *      is based in part on ladsh.c, by Michael K. Johnson and Erik W.
  21  *      Troan, which they placed in the public domain.  I don't know
  22  *      how much of the Johnson/Troan code has survived the repeated
  23  *      rewrites.
  24  *
  25  * Other credits:
  26  *      o_addchr derived from similar w_addchar function in glibc-2.2.
  27  *      parse_redirect, redirect_opt_num, and big chunks of main
  28  *      and many builtins derived from contributions by Erik Andersen.
  29  *      Miscellaneous bugfixes from Matt Kraai.
  30  *
  31  * There are two big (and related) architecture differences between
  32  * this parser and the lash parser.  One is that this version is
  33  * actually designed from the ground up to understand nearly all
  34  * of the Bourne grammar.  The second, consequential change is that
  35  * the parser and input reader have been turned inside out.  Now,
  36  * the parser is in control, and asks for input as needed.  The old
  37  * way had the input reader in control, and it asked for parsing to
  38  * take place as needed.  The new way makes it much easier to properly
  39  * handle the recursion implicit in the various substitutions, especially
  40  * across continuation lines.
  41  *
  42  * TODOs:
  43  *      grep for "TODO" and fix (some of them are easy)
  44  *      make complex ${var%...} constructs support optional
  45  *      make here documents optional
  46  *      special variables (done: PWD, PPID, RANDOM)
  47  *      follow IFS rules more precisely, including update semantics
  48  *      tilde expansion
  49  *      aliases
  50  *      builtins mandated by standards we don't support:
  51  *          [un]alias, command, fc:
  52  *          command -v CMD: print "/path/to/CMD"
  53  *              prints "CMD" for builtins
  54  *              prints "alias ALIAS='EXPANSION'" for aliases
  55  *              prints nothing and sets $? to 1 if not found
  56  *          command -V CMD: print "CMD is /path/CMD|a shell builtin|etc"
  57  *          command [-p] CMD: run CMD, even if a function CMD also exists
  58  *              (can use this to override standalone shell as well)
  59  *              -p: use default $PATH
  60  *          command BLTIN: disables special-ness (e.g. errors do not abort)
  61  *          fc -l[nr] [BEG] [END]: list range of commands in history
  62  *          fc [-e EDITOR] [BEG] [END]: edit/rerun range of commands
  63  *          fc -s [PAT=REP] [CMD]: rerun CMD, replacing PAT with REP
  64  *
  65  * Bash compat TODO:
  66  *      redirection of stdout+stderr: &> and >&
  67  *      reserved words: function select
  68  *      advanced test: [[ ]]
  69  *      process substitution: <(list) and >(list)
  70  *      =~: regex operator
  71  *      let EXPR [EXPR...]
  72  *          Each EXPR is an arithmetic expression (ARITHMETIC EVALUATION)
  73  *          If the last arg evaluates to 0, let returns 1; 0 otherwise.
  74  *          NB: let `echo 'a=a + 1'` - error (IOW: multi-word expansion is used)
  75  *      ((EXPR))
  76  *          The EXPR is evaluated according to ARITHMETIC EVALUATION.
  77  *          This is exactly equivalent to let "EXPR".
  78  *      $[EXPR]: synonym for $((EXPR))
  79  *      indirect expansion: ${!VAR}
  80  *      substring op on @: ${@:n:m}
  81  *
  82  * Won't do:
  83  *      Some builtins mandated by standards:
  84  *          newgrp [GRP]: not a builtin in bash but a suid binary
  85  *              which spawns a new shell with new group ID
  86  *      In bash, export builtin is special, its arguments are assignments
  87  *          and therefore expansion of them should be "one-word" expansion:
  88  *              $ export i=`echo 'a  b'` # export has one arg: "i=a  b"
  89  *          compare with:
  90  *              $ ls i=`echo 'a  b'`     # ls has two args: "i=a" and "b"
  91  *              ls: cannot access i=a: No such file or directory
  92  *              ls: cannot access b: No such file or directory
  93  *          Note1: same applies to local builtin.
  94  *          Note2: bash 3.2.33(1) does this only if export word itself
  95  *          is not quoted:
  96  *              $ export i=`echo 'aaa  bbb'`; echo "$i"
  97  *              aaa  bbb
  98  *              $ "export" i=`echo 'aaa  bbb'`; echo "$i"
  99  *              aaa
 100  */
 101 //config:config HUSH
 102 //config:       bool "hush (64 kb)"
 103 //config:       default y
 104 //config:       help
 105 //config:       hush is a small shell. It handles the normal flow control
 106 //config:       constructs such as if/then/elif/else/fi, for/in/do/done, while loops,
 107 //config:       case/esac. Redirections, here documents, $((arithmetic))
 108 //config:       and functions are supported.
 109 //config:
 110 //config:       It will compile and work on no-mmu systems.
 111 //config:
 112 //config:       It does not handle select, aliases, tilde expansion,
 113 //config:       &>file and >&file redirection of stdout+stderr.
 114 //config:
 115 //config:config HUSH_BASH_COMPAT
 116 //config:       bool "bash-compatible extensions"
 117 //config:       default y
 118 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 119 //config:
 120 //config:config HUSH_BRACE_EXPANSION
 121 //config:       bool "Brace expansion"
 122 //config:       default y
 123 //config:       depends on HUSH_BASH_COMPAT
 124 //config:       help
 125 //config:       Enable {abc,def} extension.
 126 //config:
 127 //config:config HUSH_INTERACTIVE
 128 //config:       bool "Interactive mode"
 129 //config:       default y
 130 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 131 //config:       help
 132 //config:       Enable interactive mode (prompt and command editing).
 133 //config:       Without this, hush simply reads and executes commands
 134 //config:       from stdin just like a shell script from a file.
 135 //config:       No prompt, no PS1/PS2 magic shell variables.
 136 //config:
 137 //config:config HUSH_SAVEHISTORY
 138 //config:       bool "Save command history to .hush_history"
 139 //config:       default y
 140 //config:       depends on HUSH_INTERACTIVE && FEATURE_EDITING_SAVEHISTORY
 141 //config:
 142 //config:config HUSH_JOB
 143 //config:       bool "Job control"
 144 //config:       default y
 145 //config:       depends on HUSH_INTERACTIVE
 146 //config:       help
 147 //config:       Enable job control: Ctrl-Z backgrounds, Ctrl-C interrupts current
 148 //config:       command (not entire shell), fg/bg builtins work. Without this option,
 149 //config:       "cmd &" still works by simply spawning a process and immediately
 150 //config:       prompting for next command (or executing next command in a script),
 151 //config:       but no separate process group is formed.
 152 //config:
 153 //config:config HUSH_TICK
 154 //config:       bool "Support process substitution"
 155 //config:       default y
 156 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 157 //config:       help
 158 //config:       Enable `command` and $(command).
 159 //config:
 160 //config:config HUSH_IF
 161 //config:       bool "Support if/then/elif/else/fi"
 162 //config:       default y
 163 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 164 //config:
 165 //config:config HUSH_LOOPS
 166 //config:       bool "Support for, while and until loops"
 167 //config:       default y
 168 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 169 //config:
 170 //config:config HUSH_CASE
 171 //config:       bool "Support case ... esac statement"
 172 //config:       default y
 173 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 174 //config:       help
 175 //config:       Enable case ... esac statement. +400 bytes.
 176 //config:
 177 //config:config HUSH_FUNCTIONS
 178 //config:       bool "Support funcname() { commands; } syntax"
 179 //config:       default y
 180 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 181 //config:       help
 182 //config:       Enable support for shell functions. +800 bytes.
 183 //config:
 184 //config:config HUSH_LOCAL
 185 //config:       bool "local builtin"
 186 //config:       default y
 187 //config:       depends on HUSH_FUNCTIONS
 188 //config:       help
 189 //config:       Enable support for local variables in functions.
 190 //config:
 191 //config:config HUSH_RANDOM_SUPPORT
 192 //config:       bool "Pseudorandom generator and $RANDOM variable"
 193 //config:       default y
 194 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 195 //config:       help
 196 //config:       Enable pseudorandom generator and dynamic variable "$RANDOM".
 197 //config:       Each read of "$RANDOM" will generate a new pseudorandom value.
 198 //config:
 199 //config:config HUSH_MODE_X
 200 //config:       bool "Support 'hush -x' option and 'set -x' command"
 201 //config:       default y
 202 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 203 //config:       help
 204 //config:       This instructs hush to print commands before execution.
 205 //config:       Adds ~300 bytes.
 206 //config:
 207 //config:config HUSH_ECHO
 208 //config:       bool "echo builtin"
 209 //config:       default y
 210 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 211 //config:
 212 //config:config HUSH_PRINTF
 213 //config:       bool "printf builtin"
 214 //config:       default y
 215 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 216 //config:
 217 //config:config HUSH_TEST
 218 //config:       bool "test builtin"
 219 //config:       default y
 220 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 221 //config:
 222 //config:config HUSH_HELP
 223 //config:       bool "help builtin"
 224 //config:       default y
 225 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 226 //config:
 227 //config:config HUSH_EXPORT
 228 //config:       bool "export builtin"
 229 //config:       default y
 230 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 231 //config:
 232 //config:config HUSH_EXPORT_N
 233 //config:       bool "Support 'export -n' option"
 234 //config:       default y
 235 //config:       depends on HUSH_EXPORT
 236 //config:       help
 237 //config:       export -n unexports variables. It is a bash extension.
 238 //config:
 239 //config:config HUSH_READONLY
 240 //config:       bool "readonly builtin"
 241 //config:       default y
 242 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 243 //config:       help
 244 //config:       Enable support for read-only variables.
 245 //config:
 246 //config:config HUSH_KILL
 247 //config:       bool "kill builtin (supports kill %jobspec)"
 248 //config:       default y
 249 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 250 //config:
 251 //config:config HUSH_WAIT
 252 //config:       bool "wait builtin"
 253 //config:       default y
 254 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 255 //config:
 256 //config:config HUSH_TRAP
 257 //config:       bool "trap builtin"
 258 //config:       default y
 259 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 260 //config:
 261 //config:config HUSH_TYPE
 262 //config:       bool "type builtin"
 263 //config:       default y
 264 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 265 //config:
 266 //config:config HUSH_TIMES
 267 //config:       bool "times builtin"
 268 //config:       default y
 269 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 270 //config:
 271 //config:config HUSH_READ
 272 //config:       bool "read builtin"
 273 //config:       default y
 274 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 275 //config:
 276 //config:config HUSH_SET
 277 //config:       bool "set builtin"
 278 //config:       default y
 279 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 280 //config:
 281 //config:config HUSH_UNSET
 282 //config:       bool "unset builtin"
 283 //config:       default y
 284 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 285 //config:
 286 //config:config HUSH_ULIMIT
 287 //config:       bool "ulimit builtin"
 288 //config:       default y
 289 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 290 //config:
 291 //config:config HUSH_UMASK
 292 //config:       bool "umask builtin"
 293 //config:       default y
 294 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 295 //config:
 296 //config:config HUSH_GETOPTS
 297 //config:       bool "getopts builtin"
 298 //config:       default y
 299 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 300 //config:
 301 //config:config HUSH_MEMLEAK
 302 //config:       bool "memleak builtin (debugging)"
 303 //config:       default n
 304 //config:       depends on HUSH || SH_IS_HUSH || BASH_IS_HUSH
 305
 306 //applet:IF_HUSH(APPLET(hush, BB_DIR_BIN, BB_SUID_DROP))
 307 //                       APPLET_ODDNAME:name  main  location    suid_type     help
 308 //applet:IF_SH_IS_HUSH(  APPLET_ODDNAME(sh,   hush, BB_DIR_BIN, BB_SUID_DROP, hush))
 309 //applet:IF_BASH_IS_HUSH(APPLET_ODDNAME(bash, hush, BB_DIR_BIN, BB_SUID_DROP, hush))
 310
 311 //kbuild:lib-$(CONFIG_HUSH) += hush.o match.o shell_common.o
 312 //kbuild:lib-$(CONFIG_SH_IS_HUSH) += hush.o match.o shell_common.o
 313 //kbuild:lib-$(CONFIG_BASH_IS_HUSH) += hush.o match.o shell_common.o
 314 //kbuild:lib-$(CONFIG_HUSH_RANDOM_SUPPORT) += random.o
 315
 316 /* -i (interactive) and -s (read stdin) are also accepted,
 317  * but currently do nothing, therefore aren't shown in help.
 318  * NOMMU-specific options are not meant to be used by users,
 319  * therefore we don't show them either.
 320  */
 321 //usage:#define hush_trivial_usage
 322 //usage:        "[-enxl] [-c 'SCRIPT' [ARG0 [ARGS]] / FILE [ARGS]]"
 323 //usage:#define hush_full_usage "\n\n"
 324 //usage:        "Unix shell interpreter"
 325
 326 #if !(defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) \
 327         || defined(__APPLE__) \
 328     )
 329 # include <malloc.h>   /* for malloc_trim */
 330 #endif
 331 #include <glob.h>
 332 /* #include <dmalloc.h> */
 333 #if ENABLE_HUSH_CASE
 334 # include <fnmatch.h>
 335 #endif
 336 #include <sys/times.h>
 337 #include <sys/utsname.h> /* for setting $HOSTNAME */
 338
 339 #include "busybox.h"  /* for APPLET_IS_NOFORK/NOEXEC */
 340 #include "unicode.h"
 341 #include "shell_common.h"
 342 #include "math.h"
 343 #include "match.h"
 344 #if ENABLE_HUSH_RANDOM_SUPPORT
 345 # include "random.h"
 346 #else
 347 # define CLEAR_RANDOM_T(rnd) ((void)0)
 348 #endif
 349 #ifndef F_DUPFD_CLOEXEC
 350 # define F_DUPFD_CLOEXEC F_DUPFD
 351 #endif
 352 #ifndef PIPE_BUF
 353 # define PIPE_BUF 4096  /* amount of buffering in a pipe */
 354 #endif
 355
 356
 357 /* So far, all bash compat is controlled by one config option */
 358 /* Separate defines document which part of code implements what */
 359 #define BASH_PATTERN_SUBST ENABLE_HUSH_BASH_COMPAT
 360 #define BASH_SUBSTR        ENABLE_HUSH_BASH_COMPAT
 361 #define BASH_SOURCE        ENABLE_HUSH_BASH_COMPAT
 362 #define BASH_HOSTNAME_VAR  ENABLE_HUSH_BASH_COMPAT
 363 #define BASH_TEST2         (ENABLE_HUSH_BASH_COMPAT && ENABLE_HUSH_TEST)
 364 #define BASH_READ_D        ENABLE_HUSH_BASH_COMPAT
 365
 366
 367 /* Build knobs */
 368 #define LEAK_HUNTING 0
 369 #define BUILD_AS_NOMMU 0
 370 /* Enable/disable sanity checks. Ok to enable in production,
 371  * only adds a bit of bloat. Set to >1 to get non-production level verbosity.
 372  * Keeping 1 for now even in released versions.
 373  */
 374 #define HUSH_DEBUG 1
 375 /* Slightly bigger (+200 bytes), but faster hush.
 376  * So far it only enables a trick with counting SIGCHLDs and forks,
 377  * which allows us to do fewer waitpid's.
 378  * (we can detect a case where neither forks were done nor SIGCHLDs happened
 379  * and therefore waitpid will return the same result as last time)
 380  */
 381 #define ENABLE_HUSH_FAST 0
 382 /* TODO: implement simplified code for users which do not need ${var%...} ops
 383  * So far ${var%...} ops are always enabled:
 384  */
 385 #define ENABLE_HUSH_DOLLAR_OPS 1
 386
 387
 388 #if BUILD_AS_NOMMU
 389 # undef BB_MMU
 390 # undef USE_FOR_NOMMU
 391 # undef USE_FOR_MMU
 392 # define BB_MMU 0
 393 # define USE_FOR_NOMMU(...) __VA_ARGS__
 394 # define USE_FOR_MMU(...)
 395 #endif
 396
 397 #include "NUM_APPLETS.h"
 398 #if NUM_APPLETS == 1
 399 /* STANDALONE does not make sense, and won't compile */
 400 # undef CONFIG_FEATURE_SH_STANDALONE
 401 # undef ENABLE_FEATURE_SH_STANDALONE
 402 # undef IF_FEATURE_SH_STANDALONE
 403 # undef IF_NOT_FEATURE_SH_STANDALONE
 404 # define ENABLE_FEATURE_SH_STANDALONE 0
 405 # define IF_FEATURE_SH_STANDALONE(...)
 406 # define IF_NOT_FEATURE_SH_STANDALONE(...) __VA_ARGS__
 407 #endif
 408
 409 #if !ENABLE_HUSH_INTERACTIVE
 410 # undef ENABLE_FEATURE_EDITING
 411 # define ENABLE_FEATURE_EDITING 0
 412 # undef ENABLE_FEATURE_EDITING_FANCY_PROMPT
 413 # define ENABLE_FEATURE_EDITING_FANCY_PROMPT 0
 414 # undef ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
 415 # define ENABLE_FEATURE_EDITING_SAVE_ON_EXIT 0
 416 #endif
 417
 418 /* Do we support ANY keywords? */
 419 #if ENABLE_HUSH_IF || ENABLE_HUSH_LOOPS || ENABLE_HUSH_CASE
 420 # define HAS_KEYWORDS 1
 421 # define IF_HAS_KEYWORDS(...) __VA_ARGS__
 422 # define IF_HAS_NO_KEYWORDS(...)
 423 #else
 424 # define HAS_KEYWORDS 0
 425 # define IF_HAS_KEYWORDS(...)
 426 # define IF_HAS_NO_KEYWORDS(...) __VA_ARGS__
 427 #endif
 428
 429 /* If you comment out one of these below, it will be #defined later
 430  * to perform debug printfs to stderr: */
 431 #define debug_printf(...)        do {} while (0)
 432 /* Finer-grained debug switches */
 433 #define debug_printf_parse(...)  do {} while (0)
 434 #define debug_print_tree(a, b)   do {} while (0)
 435 #define debug_printf_exec(...)   do {} while (0)
 436 #define debug_printf_env(...)    do {} while (0)
 437 #define debug_printf_jobs(...)   do {} while (0)
 438 #define debug_printf_expand(...) do {} while (0)
 439 #define debug_printf_varexp(...) do {} while (0)
 440 #define debug_printf_glob(...)   do {} while (0)
 441 #define debug_printf_redir(...)  do {} while (0)
 442 #define debug_printf_list(...)   do {} while (0)
 443 #define debug_printf_subst(...)  do {} while (0)
 444 #define debug_printf_clean(...)  do {} while (0)
 445
 446 #define ERR_PTR ((void*)(long)1)
 447
 448 #define JOB_STATUS_FORMAT    "[%u] %-22s %.40s\n"
 449
 450 #define _SPECIAL_VARS_STR     "_*@$!?#"
 451 #define SPECIAL_VARS_STR     ("_*@$!?#" + 1)
 452 #define NUMERIC_SPECVARS_STR ("_*@$!?#" + 3)
 453 #if BASH_PATTERN_SUBST
 454 /* Support / and // replace ops */
 455 /* Note that // is stored as \ in "encoded" string representation */
 456 # define VAR_ENCODED_SUBST_OPS      "\\/%#:-=+?"
 457 # define VAR_SUBST_OPS             ("\\/%#:-=+?" + 1)
 458 # define MINUS_PLUS_EQUAL_QUESTION ("\\/%#:-=+?" + 5)
 459 #else
 460 # define VAR_ENCODED_SUBST_OPS      "%#:-=+?"
 461 # define VAR_SUBST_OPS              "%#:-=+?"
 462 # define MINUS_PLUS_EQUAL_QUESTION ("%#:-=+?" + 3)
 463 #endif
 464
 465 #define SPECIAL_VAR_SYMBOL   3
 466
 467 struct variable;
 468
 469 static const char hush_version_str[] ALIGN1 = "HUSH_VERSION="BB_VER;
 470
 471 /* This supports saving pointers malloced in vfork child,
 472  * to be freed in the parent.
 473  */
 474 #if !BB_MMU
 475 typedef struct nommu_save_t {
 476         char **new_env;
 477         struct variable *old_vars;
 478         char **argv;
 479         char **argv_from_re_execing;
 480 } nommu_save_t;
 481 #endif
 482
 483 enum {
 484         RES_NONE  = 0,
 485 #if ENABLE_HUSH_IF
 486         RES_IF    ,
 487         RES_THEN  ,
 488         RES_ELIF  ,
 489         RES_ELSE  ,
 490         RES_FI    ,
 491 #endif
 492 #if ENABLE_HUSH_LOOPS
 493         RES_FOR   ,
 494         RES_WHILE ,
 495         RES_UNTIL ,
 496         RES_DO    ,
 497         RES_DONE  ,
 498 #endif
 499 #if ENABLE_HUSH_LOOPS || ENABLE_HUSH_CASE
 500         RES_IN    ,
 501 #endif
 502 #if ENABLE_HUSH_CASE
 503         RES_CASE  ,
 504         /* three pseudo-keywords support contrived "case" syntax: */
 505         RES_CASE_IN,   /* "case ... IN", turns into RES_MATCH when IN is observed */
 506         RES_MATCH ,    /* "word)" */
 507         RES_CASE_BODY, /* "this command is inside CASE" */
 508         RES_ESAC  ,
 509 #endif
 510         RES_XXXX  ,
 511         RES_SNTX
 512 };
 513
 514 typedef struct o_string {
 515         char *data;
 516         int length; /* position where data is appended */
 517         int maxlen;
 518         int o_expflags;
 519         /* At least some part of the string was inside '' or "",
 520          * possibly empty one: word"", wo''rd etc. */
 521         smallint has_quoted_part;
 522         smallint has_empty_slot;
 523         smallint o_assignment; /* 0:maybe, 1:yes, 2:no */
 524 } o_string;
 525 enum {
 526         EXP_FLAG_SINGLEWORD     = 0x80, /* must be 0x80 */
 527         EXP_FLAG_GLOB           = 0x2,
 528         /* Protect newly added chars against globbing
 529          * by prepending \ to *, ?, [, \ */
 530         EXP_FLAG_ESC_GLOB_CHARS = 0x1,
 531 };
 532 enum {
 533         MAYBE_ASSIGNMENT      = 0,
 534         DEFINITELY_ASSIGNMENT = 1,
 535         NOT_ASSIGNMENT        = 2,
 536         /* Not an assignment, but next word may be: "if v=xyz cmd;" */
 537         WORD_IS_KEYWORD       = 3,
 538 };
 539 /* Used for initialization: o_string foo = NULL_O_STRING; */
 540 #define NULL_O_STRING { NULL }
 541
 542 #ifndef debug_printf_parse
 543 static const char *const assignment_flag[] = {
 544         "MAYBE_ASSIGNMENT",
 545         "DEFINITELY_ASSIGNMENT",
 546         "NOT_ASSIGNMENT",
 547         "WORD_IS_KEYWORD",
 548 };
 549 #endif
 550
 551 typedef struct in_str {
 552         const char *p;
 553 #if ENABLE_HUSH_INTERACTIVE
 554         smallint promptmode; /* 0: PS1, 1: PS2 */
 555 #endif
 556         int peek_buf[2];
 557         int last_char;
 558         FILE *file;
 559 } in_str;
 560
 561 /* The descrip member of this structure is only used to make
 562  * debugging output pretty */
 563 static const struct {
 564         int mode;
 565         signed char default_fd;
 566         char descrip[3];
 567 } redir_table[] = {
 568         { O_RDONLY,                  0, "<"  },
 569         { O_CREAT|O_TRUNC|O_WRONLY,  1, ">"  },
 570         { O_CREAT|O_APPEND|O_WRONLY, 1, ">>" },
 571         { O_CREAT|O_RDWR,            1, "<>" },
 572         { O_RDONLY,                  0, "<<" },
 573 /* Should not be needed. Bogus default_fd helps in debugging */
 574 /*      { O_RDONLY,                 77, "<<" }, */
 575 };
 576
 577 struct redir_struct {
 578         struct redir_struct *next;
 579         char *rd_filename;          /* filename */
 580         int rd_fd;                  /* fd to redirect */
 581         /* fd to redirect to, or -3 if rd_fd is to be closed (n>&-) */
 582         int rd_dup;
 583         smallint rd_type;           /* (enum redir_type) */
 584         /* note: for heredocs, rd_filename contains heredoc delimiter,
 585          * and subsequently heredoc itself; and rd_dup is a bitmask:
 586          * bit 0: do we need to trim leading tabs?
 587          * bit 1: is heredoc quoted (<<'delim' syntax) ?
 588          */
 589 };
 590 typedef enum redir_type {
 591         REDIRECT_INPUT     = 0,
 592         REDIRECT_OVERWRITE = 1,
 593         REDIRECT_APPEND    = 2,
 594         REDIRECT_IO        = 3,
 595         REDIRECT_HEREDOC   = 4,
 596         REDIRECT_HEREDOC2  = 5, /* REDIRECT_HEREDOC after heredoc is loaded */
 597
 598         REDIRFD_CLOSE      = -3,
 599         REDIRFD_SYNTAX_ERR = -2,
 600         REDIRFD_TO_FILE    = -1,
 601         /* otherwise, rd_fd is redirected to rd_dup */
 602
 603         HEREDOC_SKIPTABS = 1,
 604         HEREDOC_QUOTED   = 2,
 605 } redir_type;
 606
 607
 608 struct command {
 609         pid_t pid;                  /* 0 if exited */
 610         int assignment_cnt;         /* how many argv[i] are assignments? */
 611         smallint cmd_type;          /* CMD_xxx */
 612 #define CMD_NORMAL   0
 613 #define CMD_SUBSHELL 1
 614 #if BASH_TEST2
 615 /* used for "[[ EXPR ]]" */
 616 # define CMD_SINGLEWORD_NOGLOB 2
 617 #endif
 618 #if ENABLE_HUSH_FUNCTIONS
 619 # define CMD_FUNCDEF 3
 620 #endif
 621
 622         smalluint cmd_exitcode;
 623         /* if non-NULL, this "command" is { list }, ( list ), or a compound statement */
 624         struct pipe *group;
 625 #if !BB_MMU
 626         char *group_as_string;
 627 #endif
 628 #if ENABLE_HUSH_FUNCTIONS
 629         struct function *child_func;
 630 /* This field is used to prevent a bug here:
 631  * while...do f1() {a;}; f1; f1() {b;}; f1; done
 632  * When we execute "f1() {a;}" cmd, we create new function and clear
 633  * cmd->group, cmd->group_as_string, cmd->argv[0].
 634  * When we execute "f1() {b;}", we notice that f1 exists,
 635  * and that its "parent cmd" struct is still "alive",
 636  * we put those fields back into cmd->xxx
 637  * (struct function has ->parent_cmd ptr to facilitate that).
 638  * When we loop back, we can execute "f1() {a;}" again and set f1 correctly.
 639  * Without this trick, loop would execute a;b;b;b;...
 640  * instead of correct sequence a;b;a;b;...
 641  * When command is freed, it severs the link
 642  * (sets ->child_func->parent_cmd to NULL).
 643  */
 644 #endif
 645         char **argv;                /* command name and arguments */
 646 /* argv vector may contain variable references (^Cvar^C, ^C0^C etc)
 647  * and on execution these are substituted with their values.
 648  * Substitution can make _several_ words out of one argv[n]!
 649  * Example: argv[0]=='.^C*^C.' here: echo .$*.
 650  * References of the form ^C`cmd arg^C are `cmd arg` substitutions.
 651  */
 652         struct redir_struct *redirects; /* I/O redirections */
 653 };
 654 /* Is there anything in this command at all? */
 655 #define IS_NULL_CMD(cmd) \
 656         (!(cmd)->group && !(cmd)->argv && !(cmd)->redirects)
 657
 658 struct pipe {
 659         struct pipe *next;
 660         int num_cmds;               /* total number of commands in pipe */
 661         int alive_cmds;             /* number of commands running (not exited) */
 662         int stopped_cmds;           /* number of commands alive, but stopped */
 663 #if ENABLE_HUSH_JOB
 664         unsigned jobid;             /* job number */
 665         pid_t pgrp;                 /* process group ID for the job */
 666         char *cmdtext;              /* name of job */
 667 #endif
 668         struct command *cmds;       /* array of commands in pipe */
 669         smallint followup;          /* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */
 670         IF_HAS_KEYWORDS(smallint pi_inverted;) /* "! cmd | cmd" */
 671         IF_HAS_KEYWORDS(smallint res_word;) /* needed for if, for, while, until... */
 672 };
 673 typedef enum pipe_style {
 674         PIPE_SEQ = 0,
 675         PIPE_AND = 1,
 676         PIPE_OR  = 2,
 677         PIPE_BG  = 3,
 678 } pipe_style;
 679 /* Is there anything in this pipe at all? */
 680 #define IS_NULL_PIPE(pi) \
 681         ((pi)->num_cmds == 0 IF_HAS_KEYWORDS( && (pi)->res_word == RES_NONE))
 682
 683 /* This holds pointers to the various results of parsing */
 684 struct parse_context {
 685         /* linked list of pipes */
 686         struct pipe *list_head;
 687         /* last pipe (being constructed right now) */
 688         struct pipe *pipe;
 689         /* last command in pipe (being constructed right now) */
 690         struct command *command;
 691         /* last redirect in command->redirects list */
 692         struct redir_struct *pending_redirect;
 693 #if !BB_MMU
 694         o_string as_string;
 695 #endif
 696 #if HAS_KEYWORDS
 697         smallint ctx_res_w;
 698         smallint ctx_inverted; /* "! cmd | cmd" */
 699 #if ENABLE_HUSH_CASE
 700         smallint ctx_dsemicolon; /* ";;" seen */
 701 #endif
 702         /* bitmask of FLAG_xxx, for figuring out valid reserved words */
 703         int old_flag;
 704         /* group we are enclosed in:
 705          * example: "if pipe1; pipe2; then pipe3; fi"
 706          * when we see "if" or "then", we malloc and copy current context,
 707          * and make ->stack point to it. then we parse pipeN.
 708          * when closing "then" / fi" / whatever is found,
 709          * we move list_head into ->stack->command->group,
 710          * copy ->stack into current context, and delete ->stack.
 711          * (parsing of { list } and ( list ) doesn't use this method)
 712          */
 713         struct parse_context *stack;
 714 #endif
 715 };
 716
 717 /* On program start, environ points to initial environment.
 718  * putenv adds new pointers into it, unsetenv removes them.
 719  * Neither of these (de)allocates the strings.
 720  * setenv allocates new strings in malloc space and does putenv,
 721  * and thus setenv is unusable (leaky) for shell's purposes */
 722 #define setenv(...) setenv_is_leaky_dont_use()
 723 struct variable {
 724         struct variable *next;
 725         char *varstr;        /* points to "name=" portion */
 726 #if ENABLE_HUSH_LOCAL
 727         unsigned func_nest_level;
 728 #endif
 729         int max_len;         /* if > 0, name is part of initial env; else name is malloced */
 730         smallint flg_export; /* putenv should be done on this var */
 731         smallint flg_read_only;
 732 };
 733
 734 enum {
 735         BC_BREAK = 1,
 736         BC_CONTINUE = 2,
 737 };
 738
 739 #if ENABLE_HUSH_FUNCTIONS
 740 struct function {
 741         struct function *next;
 742         char *name;
 743         struct command *parent_cmd;
 744         struct pipe *body;
 745 # if !BB_MMU
 746         char *body_as_string;
 747 # endif
 748 };
 749 #endif
 750
 751
 752 /* set -/+o OPT support. (TODO: make it optional)
 753  * bash supports the following opts:
 754  * allexport       off
 755  * braceexpand     on
 756  * emacs           on
 757  * errexit         off
 758  * errtrace        off
 759  * functrace       off
 760  * hashall         on
 761  * histexpand      off
 762  * history         on
 763  * ignoreeof       off
 764  * interactive-comments    on
 765  * keyword         off
 766  * monitor         on
 767  * noclobber       off
 768  * noexec          off
 769  * noglob          off
 770  * nolog           off
 771  * notify          off
 772  * nounset         off
 773  * onecmd          off
 774  * physical        off
 775  * pipefail        off
 776  * posix           off
 777  * privileged      off
 778  * verbose         off
 779  * vi              off
 780  * xtrace          off
 781  */
 782 static const char o_opt_strings[] ALIGN1 =
 783         "pipefail\0"
 784         "noexec\0"
 785         "errexit\0"
 786 #if ENABLE_HUSH_MODE_X
 787         "xtrace\0"
 788 #endif
 789         ;
 790 enum {
 791         OPT_O_PIPEFAIL,
 792         OPT_O_NOEXEC,
 793         OPT_O_ERREXIT,
 794 #if ENABLE_HUSH_MODE_X
 795         OPT_O_XTRACE,
 796 #endif
 797         NUM_OPT_O
 798 };
 799
 800
 801 struct FILE_list {
 802         struct FILE_list *next;
 803         FILE *fp;
 804         int fd;
 805 };
 806
 807
 808 /* "Globals" within this file */
 809 /* Sorted roughly by size (smaller offsets == smaller code) */
 810 struct globals {
 811         /* interactive_fd != 0 means we are an interactive shell.
 812          * If we are, then saved_tty_pgrp can also be != 0, meaning
 813          * that controlling tty is available. With saved_tty_pgrp == 0,
 814          * job control still works, but terminal signals
 815          * (^C, ^Z, ^Y, ^\) won't work at all, and background
 816          * process groups can only be created with "cmd &".
 817          * With saved_tty_pgrp != 0, hush will use tcsetpgrp()
 818          * to give tty to the foreground process group,
 819          * and will take it back when the group is stopped (^Z)
 820          * or killed (^C).
 821          */
 822 #if ENABLE_HUSH_INTERACTIVE
 823         /* 'interactive_fd' is a fd# open to ctty, if we have one
 824          * _AND_ if we decided to act interactively */
 825         int interactive_fd;
 826         const char *PS1;
 827         const char *PS2;
 828 # define G_interactive_fd (G.interactive_fd)
 829 #else
 830 # define G_interactive_fd 0
 831 #endif
 832 #if ENABLE_FEATURE_EDITING
 833         line_input_t *line_input_state;
 834 #endif
 835         pid_t root_pid;
 836         pid_t root_ppid;
 837         pid_t last_bg_pid;
 838 #if ENABLE_HUSH_RANDOM_SUPPORT
 839         random_t random_gen;
 840 #endif
 841 #if ENABLE_HUSH_JOB
 842         int run_list_level;
 843         unsigned last_jobid;
 844         pid_t saved_tty_pgrp;
 845         struct pipe *job_list;
 846 # define G_saved_tty_pgrp (G.saved_tty_pgrp)
 847 #else
 848 # define G_saved_tty_pgrp 0
 849 #endif
 850         /* How deeply are we in context where "set -e" is ignored */
 851         int errexit_depth;
 852         /* "set -e" rules (do we follow them correctly?):
 853          * Exit if pipe, list, or compound command exits with a non-zero status.
 854          * Shell does not exit if failed command is part of condition in
 855          * if/while, part of && or || list except the last command, any command
 856          * in a pipe but the last, or if the command's return value is being
 857          * inverted with !. If a compound command other than a subshell returns a
 858          * non-zero status because a command failed while -e was being ignored, the
 859          * shell does not exit. A trap on ERR, if set, is executed before the shell
 860          * exits [ERR is a bashism].
 861          *
 862          * If a compound command or function executes in a context where -e is
 863          * ignored, none of the commands executed within are affected by the -e
 864          * setting. If a compound command or function sets -e while executing in a
 865          * context where -e is ignored, that setting does not have any effect until
 866          * the compound command or the command containing the function call completes.
 867          */
 868
 869         char o_opt[NUM_OPT_O];
 870 #if ENABLE_HUSH_MODE_X
 871 # define G_x_mode (G.o_opt[OPT_O_XTRACE])
 872 #else
 873 # define G_x_mode 0
 874 #endif
 875         smallint flag_SIGINT;
 876 #if ENABLE_HUSH_LOOPS
 877         smallint flag_break_continue;
 878 #endif
 879 #if ENABLE_HUSH_FUNCTIONS
 880         /* 0: outside of a function (or sourced file)
 881          * -1: inside of a function, ok to use return builtin
 882          * 1: return is invoked, skip all till end of func
 883          */
 884         smallint flag_return_in_progress;
 885 # define G_flag_return_in_progress (G.flag_return_in_progress)
 886 #else
 887 # define G_flag_return_in_progress 0
 888 #endif
 889         smallint exiting; /* used to prevent EXIT trap recursion */
 890         /* These four support $?, $#, and $1 */
 891         smalluint last_exitcode;
 892         smalluint last_bg_pid_exitcode;
 893 #if ENABLE_HUSH_SET
 894         /* are global_argv and global_argv[1..n] malloced? (note: not [0]) */
 895         smalluint global_args_malloced;
 896 # define G_global_args_malloced (G.global_args_malloced)
 897 #else
 898 # define G_global_args_malloced 0
 899 #endif
 900         /* how many non-NULL argv's we have. NB: $# + 1 */
 901         int global_argc;
 902         char **global_argv;
 903 #if !BB_MMU
 904         char *argv0_for_re_execing;
 905 #endif
 906 #if ENABLE_HUSH_LOOPS
 907         unsigned depth_break_continue;
 908         unsigned depth_of_loop;
 909 #endif
 910         const char *ifs;
 911         const char *cwd;
 912         struct variable *top_var;
 913         char **expanded_assignments;
 914 #if ENABLE_HUSH_FUNCTIONS
 915         struct function *top_func;
 916 # if ENABLE_HUSH_LOCAL
 917         struct variable **shadowed_vars_pp;
 918         unsigned func_nest_level;
 919 # endif
 920 #endif
 921         /* Signal and trap handling */
 922 #if ENABLE_HUSH_FAST
 923         unsigned count_SIGCHLD;
 924         unsigned handled_SIGCHLD;
 925         smallint we_have_children;
 926 #endif
 927         struct FILE_list *FILE_list;
 928         /* Which signals have non-DFL handler (even with no traps set)?
 929          * Set at the start to:
 930          * (SIGQUIT + maybe SPECIAL_INTERACTIVE_SIGS + maybe SPECIAL_JOBSTOP_SIGS)
 931          * SPECIAL_INTERACTIVE_SIGS are cleared after fork.
 932          * The rest is cleared right before execv syscalls.
 933          * Other than these two times, never modified.
 934          */
 935         unsigned special_sig_mask;
 936 #if ENABLE_HUSH_JOB
 937         unsigned fatal_sig_mask;
 938 # define G_fatal_sig_mask (G.fatal_sig_mask)
 939 #else
 940 # define G_fatal_sig_mask 0
 941 #endif
 942 #if ENABLE_HUSH_TRAP
 943         char **traps; /* char *traps[NSIG] */
 944 # define G_traps G.traps
 945 #else
 946 # define G_traps ((char**)NULL)
 947 #endif
 948         sigset_t pending_set;
 949 #if ENABLE_HUSH_MEMLEAK
 950         unsigned long memleak_value;
 951 #endif
 952 #if HUSH_DEBUG
 953         int debug_indent;
 954 #endif
 955         struct sigaction sa;
 956 #if ENABLE_FEATURE_EDITING
 957         char user_input_buf[CONFIG_FEATURE_EDITING_MAX_LEN];
 958 #endif
 959 };
 960 #define G (*ptr_to_globals)
 961 /* Not #defining name to G.name - this quickly gets unwieldy
 962  * (too many defines). Also, I actually prefer to see when a variable
 963  * is global, thus "G." prefix is a useful hint */
 964 #define INIT_G() do { \
 965         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
 966         /* memset(&G.sa, 0, sizeof(G.sa)); */  \
 967         sigfillset(&G.sa.sa_mask); \
 968         G.sa.sa_flags = SA_RESTART; \
 969 } while (0)
 970
 971
 972 /* Function prototypes for builtins */
 973 static int builtin_cd(char **argv) FAST_FUNC;
 974 #if ENABLE_HUSH_ECHO
 975 static int builtin_echo(char **argv) FAST_FUNC;
 976 #endif
 977 static int builtin_eval(char **argv) FAST_FUNC;
 978 static int builtin_exec(char **argv) FAST_FUNC;
 979 static int builtin_exit(char **argv) FAST_FUNC;
 980 #if ENABLE_HUSH_EXPORT
 981 static int builtin_export(char **argv) FAST_FUNC;
 982 #endif
 983 #if ENABLE_HUSH_READONLY
 984 static int builtin_readonly(char **argv) FAST_FUNC;
 985 #endif
 986 #if ENABLE_HUSH_JOB
 987 static int builtin_fg_bg(char **argv) FAST_FUNC;
 988 static int builtin_jobs(char **argv) FAST_FUNC;
 989 #endif
 990 #if ENABLE_HUSH_GETOPTS
 991 static int builtin_getopts(char **argv) FAST_FUNC;
 992 #endif
 993 #if ENABLE_HUSH_HELP
 994 static int builtin_help(char **argv) FAST_FUNC;
 995 #endif
 996 #if MAX_HISTORY && ENABLE_FEATURE_EDITING
 997 static int builtin_history(char **argv) FAST_FUNC;
 998 #endif
 999 #if ENABLE_HUSH_LOCAL
1000 static int builtin_local(char **argv) FAST_FUNC;
1001 #endif
1002 #if ENABLE_HUSH_MEMLEAK
1003 static int builtin_memleak(char **argv) FAST_FUNC;
1004 #endif
1005 #if ENABLE_HUSH_PRINTF
1006 static int builtin_printf(char **argv) FAST_FUNC;
1007 #endif
1008 static int builtin_pwd(char **argv) FAST_FUNC;
1009 #if ENABLE_HUSH_READ
1010 static int builtin_read(char **argv) FAST_FUNC;
1011 #endif
1012 #if ENABLE_HUSH_SET
1013 static int builtin_set(char **argv) FAST_FUNC;
1014 #endif
1015 static int builtin_shift(char **argv) FAST_FUNC;
1016 static int builtin_source(char **argv) FAST_FUNC;
1017 #if ENABLE_HUSH_TEST || BASH_TEST2
1018 static int builtin_test(char **argv) FAST_FUNC;
1019 #endif
1020 #if ENABLE_HUSH_TRAP
1021 static int builtin_trap(char **argv) FAST_FUNC;
1022 #endif
1023 #if ENABLE_HUSH_TYPE
1024 static int builtin_type(char **argv) FAST_FUNC;
1025 #endif
1026 #if ENABLE_HUSH_TIMES
1027 static int builtin_times(char **argv) FAST_FUNC;
1028 #endif
1029 static int builtin_true(char **argv) FAST_FUNC;
1030 #if ENABLE_HUSH_UMASK
1031 static int builtin_umask(char **argv) FAST_FUNC;
1032 #endif
1033 #if ENABLE_HUSH_UNSET
1034 static int builtin_unset(char **argv) FAST_FUNC;
1035 #endif
1036 #if ENABLE_HUSH_KILL
1037 static int builtin_kill(char **argv) FAST_FUNC;
1038 #endif
1039 #if ENABLE_HUSH_WAIT
1040 static int builtin_wait(char **argv) FAST_FUNC;
1041 #endif
1042 #if ENABLE_HUSH_LOOPS
1043 static int builtin_break(char **argv) FAST_FUNC;
1044 static int builtin_continue(char **argv) FAST_FUNC;
1045 #endif
1046 #if ENABLE_HUSH_FUNCTIONS
1047 static int builtin_return(char **argv) FAST_FUNC;
1048 #endif
1049
1050 /* Table of built-in functions.  They can be forked or not, depending on
1051  * context: within pipes, they fork.  As simple commands, they do not.
1052  * When used in non-forking context, they can change global variables
1053  * in the parent shell process.  If forked, of course they cannot.
1054  * For example, 'unset foo | whatever' will parse and run, but foo will
1055  * still be set at the end. */
1056 struct built_in_command {
1057         const char *b_cmd;
1058         int (*b_function)(char **argv) FAST_FUNC;
1059 #if ENABLE_HUSH_HELP
1060         const char *b_descr;
1061 # define BLTIN(cmd, func, help) { cmd, func, help }
1062 #else
1063 # define BLTIN(cmd, func, help) { cmd, func }
1064 #endif
1065 };
1066
1067 static const struct built_in_command bltins1[] = {
1068         BLTIN("."        , builtin_source  , "Run commands in file"),
1069         BLTIN(":"        , builtin_true    , NULL),
1070 #if ENABLE_HUSH_JOB
1071         BLTIN("bg"       , builtin_fg_bg   , "Resume job in background"),
1072 #endif
1073 #if ENABLE_HUSH_LOOPS
1074         BLTIN("break"    , builtin_break   , "Exit loop"),
1075 #endif
1076         BLTIN("cd"       , builtin_cd      , "Change directory"),
1077 #if ENABLE_HUSH_LOOPS
1078         BLTIN("continue" , builtin_continue, "Start new loop iteration"),
1079 #endif
1080         BLTIN("eval"     , builtin_eval    , "Construct and run shell command"),
1081         BLTIN("exec"     , builtin_exec    , "Execute command, don't return to shell"),
1082         BLTIN("exit"     , builtin_exit    , NULL),
1083 #if ENABLE_HUSH_EXPORT
1084         BLTIN("export"   , builtin_export  , "Set environment variables"),
1085 #endif
1086 #if ENABLE_HUSH_JOB
1087         BLTIN("fg"       , builtin_fg_bg   , "Bring job to foreground"),
1088 #endif
1089 #if ENABLE_HUSH_GETOPTS
1090         BLTIN("getopts"  , builtin_getopts , NULL),
1091 #endif
1092 #if ENABLE_HUSH_HELP
1093         BLTIN("help"     , builtin_help    , NULL),
1094 #endif
1095 #if MAX_HISTORY && ENABLE_FEATURE_EDITING
1096         BLTIN("history"  , builtin_history , "Show history"),
1097 #endif
1098 #if ENABLE_HUSH_JOB
1099         BLTIN("jobs"     , builtin_jobs    , "List jobs"),
1100 #endif
1101 #if ENABLE_HUSH_KILL
1102         BLTIN("kill"     , builtin_kill    , "Send signals to processes"),
1103 #endif
1104 #if ENABLE_HUSH_LOCAL
1105         BLTIN("local"    , builtin_local   , "Set local variables"),
1106 #endif
1107 #if ENABLE_HUSH_MEMLEAK
1108         BLTIN("memleak"  , builtin_memleak , NULL),
1109 #endif
1110 #if ENABLE_HUSH_READ
1111         BLTIN("read"     , builtin_read    , "Input into variable"),
1112 #endif
1113 #if ENABLE_HUSH_READONLY
1114         BLTIN("readonly" , builtin_readonly, "Make variables read-only"),
1115 #endif
1116 #if ENABLE_HUSH_FUNCTIONS
1117         BLTIN("return"   , builtin_return  , "Return from function"),
1118 #endif
1119 #if ENABLE_HUSH_SET
1120         BLTIN("set"      , builtin_set     , "Set positional parameters"),
1121 #endif
1122         BLTIN("shift"    , builtin_shift   , "Shift positional parameters"),
1123 #if BASH_SOURCE
1124         BLTIN("source"   , builtin_source  , NULL),
1125 #endif
1126 #if ENABLE_HUSH_TIMES
1127         BLTIN("times"    , builtin_times   , NULL),
1128 #endif
1129 #if ENABLE_HUSH_TRAP
1130         BLTIN("trap"     , builtin_trap    , "Trap signals"),
1131 #endif
1132         BLTIN("true"     , builtin_true    , NULL),
1133 #if ENABLE_HUSH_TYPE
1134         BLTIN("type"     , builtin_type    , "Show command type"),
1135 #endif
1136 #if ENABLE_HUSH_ULIMIT
1137         BLTIN("ulimit"   , shell_builtin_ulimit, "Control resource limits"),
1138 #endif
1139 #if ENABLE_HUSH_UMASK
1140         BLTIN("umask"    , builtin_umask   , "Set file creation mask"),
1141 #endif
1142 #if ENABLE_HUSH_UNSET
1143         BLTIN("unset"    , builtin_unset   , "Unset variables"),
1144 #endif
1145 #if ENABLE_HUSH_WAIT
1146         BLTIN("wait"     , builtin_wait    , "Wait for process to finish"),
1147 #endif
1148 };
1149 /* These builtins won't be used if we are on NOMMU and need to re-exec
1150  * (it's cheaper to run an external program in this case):
1151  */
1152 static const struct built_in_command bltins2[] = {
1153 #if ENABLE_HUSH_TEST
1154         BLTIN("["        , builtin_test    , NULL),
1155 #endif
1156 #if BASH_TEST2
1157         BLTIN("[["       , builtin_test    , NULL),
1158 #endif
1159 #if ENABLE_HUSH_ECHO
1160         BLTIN("echo"     , builtin_echo    , NULL),
1161 #endif
1162 #if ENABLE_HUSH_PRINTF
1163         BLTIN("printf"   , builtin_printf  , NULL),
1164 #endif
1165         BLTIN("pwd"      , builtin_pwd     , NULL),
1166 #if ENABLE_HUSH_TEST
1167         BLTIN("test"     , builtin_test    , NULL),
1168 #endif
1169 };
1170
1171
1172 /* Debug printouts.
1173  */
1174 #if HUSH_DEBUG
1175 /* prevent disasters with G.debug_indent < 0 */
1176 # define indent() fdprintf(2, "%*s", (G.debug_indent * 2) & 0xff, "")
1177 # define debug_enter() (G.debug_indent++)
1178 # define debug_leave() (G.debug_indent--)
1179 #else
1180 # define indent()      ((void)0)
1181 # define debug_enter() ((void)0)
1182 # define debug_leave() ((void)0)
1183 #endif
1184
1185 #ifndef debug_printf
1186 # define debug_printf(...) (indent(), fdprintf(2, __VA_ARGS__))
1187 #endif
1188
1189 #ifndef debug_printf_parse
1190 # define debug_printf_parse(...) (indent(), fdprintf(2, __VA_ARGS__))
1191 #endif
1192
1193 #ifndef debug_printf_exec
1194 #define debug_printf_exec(...) (indent(), fdprintf(2, __VA_ARGS__))
1195 #endif
1196
1197 #ifndef debug_printf_env
1198 # define debug_printf_env(...) (indent(), fdprintf(2, __VA_ARGS__))
1199 #endif
1200
1201 #ifndef debug_printf_jobs
1202 # define debug_printf_jobs(...) (indent(), fdprintf(2, __VA_ARGS__))
1203 # define DEBUG_JOBS 1
1204 #else
1205 # define DEBUG_JOBS 0
1206 #endif
1207
1208 #ifndef debug_printf_expand
1209 # define debug_printf_expand(...) (indent(), fdprintf(2, __VA_ARGS__))
1210 # define DEBUG_EXPAND 1
1211 #else
1212 # define DEBUG_EXPAND 0
1213 #endif
1214
1215 #ifndef debug_printf_varexp
1216 # define debug_printf_varexp(...) (indent(), fdprintf(2, __VA_ARGS__))
1217 #endif
1218
1219 #ifndef debug_printf_glob
1220 # define debug_printf_glob(...) (indent(), fdprintf(2, __VA_ARGS__))
1221 # define DEBUG_GLOB 1
1222 #else
1223 # define DEBUG_GLOB 0
1224 #endif
1225
1226 #ifndef debug_printf_redir
1227 # define debug_printf_redir(...) (indent(), fdprintf(2, __VA_ARGS__))
1228 #endif
1229
1230 #ifndef debug_printf_list
1231 # define debug_printf_list(...) (indent(), fdprintf(2, __VA_ARGS__))
1232 #endif
1233
1234 #ifndef debug_printf_subst
1235 # define debug_printf_subst(...) (indent(), fdprintf(2, __VA_ARGS__))
1236 #endif
1237
1238 #ifndef debug_printf_clean
1239 # define debug_printf_clean(...) (indent(), fdprintf(2, __VA_ARGS__))
1240 # define DEBUG_CLEAN 1
1241 #else
1242 # define DEBUG_CLEAN 0
1243 #endif
1244
1245 #if DEBUG_EXPAND
1246 static void debug_print_strings(const char *prefix, char **vv)
1247 {
1248         indent();
1249         fdprintf(2, "%s:\n", prefix);
1250         while (*vv)
1251                 fdprintf(2, " '%s'\n", *vv++);
1252 }
1253 #else
1254 # define debug_print_strings(prefix, vv) ((void)0)
1255 #endif
1256
1257
1258 /* Leak hunting. Use hush_leaktool.sh for post-processing.
1259  */
1260 #if LEAK_HUNTING
1261 static void *xxmalloc(int lineno, size_t size)
1262 {
1263         void *ptr = xmalloc((size + 0xff) & ~0xff);
1264         fdprintf(2, "line %d: malloc %p\n", lineno, ptr);
1265         return ptr;
1266 }
1267 static void *xxrealloc(int lineno, void *ptr, size_t size)
1268 {
1269         ptr = xrealloc(ptr, (size + 0xff) & ~0xff);
1270         fdprintf(2, "line %d: realloc %p\n", lineno, ptr);
1271         return ptr;
1272 }
1273 static char *xxstrdup(int lineno, const char *str)
1274 {
1275         char *ptr = xstrdup(str);
1276         fdprintf(2, "line %d: strdup %p\n", lineno, ptr);
1277         return ptr;
1278 }
1279 static void xxfree(void *ptr)
1280 {
1281         fdprintf(2, "free %p\n", ptr);
1282         free(ptr);
1283 }
1284 # define xmalloc(s)     xxmalloc(__LINE__, s)
1285 # define xrealloc(p, s) xxrealloc(__LINE__, p, s)
1286 # define xstrdup(s)     xxstrdup(__LINE__, s)
1287 # define free(p)        xxfree(p)
1288 #endif
1289
1290
1291 /* Syntax and runtime errors. They always abort scripts.
1292  * In interactive use they usually discard unparsed and/or unexecuted commands
1293  * and return to the prompt.
1294  * HUSH_DEBUG >= 2 prints line number in this file where it was detected.
1295  */
1296 #if HUSH_DEBUG < 2
1297 # define msg_and_die_if_script(lineno, ...)     msg_and_die_if_script(__VA_ARGS__)
1298 # define syntax_error(lineno, msg)              syntax_error(msg)
1299 # define syntax_error_at(lineno, msg)           syntax_error_at(msg)
1300 # define syntax_error_unterm_ch(lineno, ch)     syntax_error_unterm_ch(ch)
1301 # define syntax_error_unterm_str(lineno, s)     syntax_error_unterm_str(s)
1302 # define syntax_error_unexpected_ch(lineno, ch) syntax_error_unexpected_ch(ch)
1303 #endif
1304
1305 static void die_if_script(void)
1306 {
1307         if (!G_interactive_fd) {
1308                 if (G.last_exitcode) /* sometines it's 2, not 1 (bash compat) */
1309                         xfunc_error_retval = G.last_exitcode;
1310                 xfunc_die();
1311         }
1312 }
1313
1314 static void msg_and_die_if_script(unsigned lineno, const char *fmt, ...)
1315 {
1316         va_list p;
1317
1318 #if HUSH_DEBUG >= 2
1319         bb_error_msg("hush.c:%u", lineno);
1320 #endif
1321         va_start(p, fmt);
1322         bb_verror_msg(fmt, p, NULL);
1323         va_end(p);
1324         die_if_script();
1325 }
1326
1327 static void syntax_error(unsigned lineno UNUSED_PARAM, const char *msg)
1328 {
1329         if (msg)
1330                 bb_error_msg("syntax error: %s", msg);
1331         else
1332                 bb_error_msg("syntax error");
1333         die_if_script();
1334 }
1335
1336 static void syntax_error_at(unsigned lineno UNUSED_PARAM, const char *msg)
1337 {
1338         bb_error_msg("syntax error at '%s'", msg);
1339         die_if_script();
1340 }
1341
1342 static void syntax_error_unterm_str(unsigned lineno UNUSED_PARAM, const char *s)
1343 {
1344         bb_error_msg("syntax error: unterminated %s", s);
1345 //? source4.tests fails: in bash, echo ${^} in script does not terminate the script
1346 //      die_if_script();
1347 }
1348
1349 static void syntax_error_unterm_ch(unsigned lineno, char ch)
1350 {
1351         char msg[2] = { ch, '\0' };
1352         syntax_error_unterm_str(lineno, msg);
1353 }
1354
1355 static void syntax_error_unexpected_ch(unsigned lineno UNUSED_PARAM, int ch)
1356 {
1357         char msg[2];
1358         msg[0] = ch;
1359         msg[1] = '\0';
1360 #if HUSH_DEBUG >= 2
1361         bb_error_msg("hush.c:%u", lineno);
1362 #endif
1363         bb_error_msg("syntax error: unexpected %s", ch == EOF ? "EOF" : msg);
1364         die_if_script();
1365 }
1366
1367 #if HUSH_DEBUG < 2
1368 # undef msg_and_die_if_script
1369 # undef syntax_error
1370 # undef syntax_error_at
1371 # undef syntax_error_unterm_ch
1372 # undef syntax_error_unterm_str
1373 # undef syntax_error_unexpected_ch
1374 #else
1375 # define msg_and_die_if_script(...)     msg_and_die_if_script(__LINE__, __VA_ARGS__)
1376 # define syntax_error(msg)              syntax_error(__LINE__, msg)
1377 # define syntax_error_at(msg)           syntax_error_at(__LINE__, msg)
1378 # define syntax_error_unterm_ch(ch)     syntax_error_unterm_ch(__LINE__, ch)
1379 # define syntax_error_unterm_str(s)     syntax_error_unterm_str(__LINE__, s)
1380 # define syntax_error_unexpected_ch(ch) syntax_error_unexpected_ch(__LINE__, ch)
1381 #endif
1382
1383
1384 #if ENABLE_HUSH_INTERACTIVE
1385 static void cmdedit_update_prompt(void);
1386 #else
1387 # define cmdedit_update_prompt() ((void)0)
1388 #endif
1389
1390
1391 /* Utility functions
1392  */
1393 /* Replace each \x with x in place, return ptr past NUL. */
1394 static char *unbackslash(char *src)
1395 {
1396         char *dst = src = strchrnul(src, '\\');
1397         while (1) {
1398                 if (*src == '\\')
1399                         src++;
1400                 if ((*dst++ = *src++) == '\0')
1401                         break;
1402         }
1403         return dst;
1404 }
1405
1406 static char **add_strings_to_strings(char **strings, char **add, int need_to_dup)
1407 {
1408         int i;
1409         unsigned count1;
1410         unsigned count2;
1411         char **v;
1412
1413         v = strings;
1414         count1 = 0;
1415         if (v) {
1416                 while (*v) {
1417                         count1++;
1418                         v++;
1419                 }
1420         }
1421         count2 = 0;
1422         v = add;
1423         while (*v) {
1424                 count2++;
1425                 v++;
1426         }
1427         v = xrealloc(strings, (count1 + count2 + 1) * sizeof(char*));
1428         v[count1 + count2] = NULL;
1429         i = count2;
1430         while (--i >= 0)
1431                 v[count1 + i] = (need_to_dup ? xstrdup(add[i]) : add[i]);
1432         return v;
1433 }
1434 #if LEAK_HUNTING
1435 static char **xx_add_strings_to_strings(int lineno, char **strings, char **add, int need_to_dup)
1436 {
1437         char **ptr = add_strings_to_strings(strings, add, need_to_dup);
1438         fdprintf(2, "line %d: add_strings_to_strings %p\n", lineno, ptr);
1439         return ptr;
1440 }
1441 #define add_strings_to_strings(strings, add, need_to_dup) \
1442         xx_add_strings_to_strings(__LINE__, strings, add, need_to_dup)
1443 #endif
1444
1445 /* Note: takes ownership of "add" ptr (it is not strdup'ed) */
1446 static char **add_string_to_strings(char **strings, char *add)
1447 {
1448         char *v[2];
1449         v[0] = add;
1450         v[1] = NULL;
1451         return add_strings_to_strings(strings, v, /*dup:*/ 0);
1452 }
1453 #if LEAK_HUNTING
1454 static char **xx_add_string_to_strings(int lineno, char **strings, char *add)
1455 {
1456         char **ptr = add_string_to_strings(strings, add);
1457         fdprintf(2, "line %d: add_string_to_strings %p\n", lineno, ptr);
1458         return ptr;
1459 }
1460 #define add_string_to_strings(strings, add) \
1461         xx_add_string_to_strings(__LINE__, strings, add)
1462 #endif
1463
1464 static void free_strings(char **strings)
1465 {
1466         char **v;
1467
1468         if (!strings)
1469                 return;
1470         v = strings;
1471         while (*v) {
1472                 free(*v);
1473                 v++;
1474         }
1475         free(strings);
1476 }
1477
1478 static int fcntl_F_DUPFD(int fd, int avoid_fd)
1479 {
1480         int newfd;
1481  repeat:
1482         newfd = fcntl(fd, F_DUPFD, avoid_fd + 1);
1483         if (newfd < 0) {
1484                 if (errno == EBUSY)
1485                         goto repeat;
1486                 if (errno == EINTR)
1487                         goto repeat;
1488         }
1489         return newfd;
1490 }
1491
1492 static int xdup_CLOEXEC_and_close(int fd, int avoid_fd)
1493 {
1494         int newfd;
1495  repeat:
1496         newfd = fcntl(fd, F_DUPFD_CLOEXEC, avoid_fd + 1);
1497         if (newfd < 0) {
1498                 if (errno == EBUSY)
1499                         goto repeat;
1500                 if (errno == EINTR)
1501                         goto repeat;
1502                 /* fd was not open? */
1503                 if (errno == EBADF)
1504                         return fd;
1505                 xfunc_die();
1506         }
1507         if (F_DUPFD_CLOEXEC == F_DUPFD) /* if old libc (w/o F_DUPFD_CLOEXEC) */
1508                 fcntl(newfd, F_SETFD, FD_CLOEXEC);
1509         close(fd);
1510         return newfd;
1511 }
1512
1513
1514 /* Manipulating the list of open FILEs */
1515 static FILE *remember_FILE(FILE *fp)
1516 {
1517         if (fp) {
1518                 struct FILE_list *n = xmalloc(sizeof(*n));
1519                 n->next = G.FILE_list;
1520                 G.FILE_list = n;
1521                 n->fp = fp;
1522                 n->fd = fileno(fp);
1523                 close_on_exec_on(n->fd);
1524         }
1525         return fp;
1526 }
1527 static void fclose_and_forget(FILE *fp)
1528 {
1529         struct FILE_list **pp = &G.FILE_list;
1530         while (*pp) {
1531                 struct FILE_list *cur = *pp;
1532                 if (cur->fp == fp) {
1533                         *pp = cur->next;
1534                         free(cur);
1535                         break;
1536                 }
1537                 pp = &cur->next;
1538         }
1539         fclose(fp);
1540 }
1541 static int save_FILEs_on_redirect(int fd, int avoid_fd)
1542 {
1543         struct FILE_list *fl = G.FILE_list;
1544         while (fl) {
1545                 if (fd == fl->fd) {
1546                         /* We use it only on script files, they are all CLOEXEC */
1547                         fl->fd = xdup_CLOEXEC_and_close(fd, avoid_fd);
1548                         debug_printf_redir("redirect_fd %d: matches a script fd, moving it to %d\n", fd, fl->fd);
1549                         return 1;
1550                 }
1551                 fl = fl->next;
1552         }
1553         return 0;
1554 }
1555 static void restore_redirected_FILEs(void)
1556 {
1557         struct FILE_list *fl = G.FILE_list;
1558         while (fl) {
1559                 int should_be = fileno(fl->fp);
1560                 if (fl->fd != should_be) {
1561                         debug_printf_redir("restoring script fd from %d to %d\n", fl->fd, should_be);
1562                         xmove_fd(fl->fd, should_be);
1563                         fl->fd = should_be;
1564                 }
1565                 fl = fl->next;
1566         }
1567 }
1568 #if ENABLE_FEATURE_SH_STANDALONE && BB_MMU
1569 static void close_all_FILE_list(void)
1570 {
1571         struct FILE_list *fl = G.FILE_list;
1572         while (fl) {
1573                 /* fclose would also free FILE object.
1574                  * It is disastrous if we share memory with a vforked parent.
1575                  * I'm not sure we never come here after vfork.
1576                  * Therefore just close fd, nothing more.
1577                  */
1578                 /*fclose(fl->fp); - unsafe */
1579                 close(fl->fd);
1580                 fl = fl->next;
1581         }
1582 }
1583 #endif
1584 static int fd_in_FILEs(int fd)
1585 {
1586         struct FILE_list *fl = G.FILE_list;
1587         while (fl) {
1588                 if (fl->fd == fd)
1589                         return 1;
1590                 fl = fl->next;
1591         }
1592         return 0;
1593 }
1594
1595
1596 /* Helpers for setting new $n and restoring them back
1597  */
1598 typedef struct save_arg_t {
1599         char *sv_argv0;
1600         char **sv_g_argv;
1601         int sv_g_argc;
1602         IF_HUSH_SET(smallint sv_g_malloced;)
1603 } save_arg_t;
1604
1605 static void save_and_replace_G_args(save_arg_t *sv, char **argv)
1606 {
1607         sv->sv_argv0 = argv[0];
1608         sv->sv_g_argv = G.global_argv;
1609         sv->sv_g_argc = G.global_argc;
1610         IF_HUSH_SET(sv->sv_g_malloced = G.global_args_malloced;)
1611
1612         argv[0] = G.global_argv[0]; /* retain $0 */
1613         G.global_argv = argv;
1614         IF_HUSH_SET(G.global_args_malloced = 0;)
1615
1616         G.global_argc = 1 + string_array_len(argv + 1);
1617 }
1618
1619 static void restore_G_args(save_arg_t *sv, char **argv)
1620 {
1621 #if ENABLE_HUSH_SET
1622         if (G.global_args_malloced) {
1623                 /* someone ran "set -- arg1 arg2 ...", undo */
1624                 char **pp = G.global_argv;
1625                 while (*++pp) /* note: does not free $0 */
1626                         free(*pp);
1627                 free(G.global_argv);
1628         }
1629 #endif
1630         argv[0] = sv->sv_argv0;
1631         G.global_argv = sv->sv_g_argv;
1632         G.global_argc = sv->sv_g_argc;
1633         IF_HUSH_SET(G.global_args_malloced = sv->sv_g_malloced;)
1634 }
1635
1636
1637 /* Basic theory of signal handling in shell
1638  * ========================================
1639  * This does not describe what hush does, rather, it is current understanding
1640  * what it _should_ do. If it doesn't, it's a bug.
1641  * http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#trap
1642  *
1643  * Signals are handled only after each pipe ("cmd | cmd | cmd" thing)
1644  * is finished or backgrounded. It is the same in interactive and
1645  * non-interactive shells, and is the same regardless of whether
1646  * a user trap handler is installed or a shell special one is in effect.
1647  * ^C or ^Z from keyboard seems to execute "at once" because it usually
1648  * backgrounds (i.e. stops) or kills all members of currently running
1649  * pipe.
1650  *
1651  * Wait builtin is interruptible by signals for which user trap is set
1652  * or by SIGINT in interactive shell.
1653  *
1654  * Trap handlers will execute even within trap handlers. (right?)
1655  *
1656  * User trap handlers are forgotten when subshell ("(cmd)") is entered,
1657  * except for handlers set to '' (empty string).
1658  *
1659  * If job control is off, backgrounded commands ("cmd &")
1660  * have SIGINT, SIGQUIT set to SIG_IGN.
1661  *
1662  * Commands which are run in command substitution ("`cmd`")
1663  * have SIGTTIN, SIGTTOU, SIGTSTP set to SIG_IGN.
1664  *
1665  * Ordinary commands have signals set to SIG_IGN/DFL as inherited
1666  * by the shell from its parent.
1667  *
1668  * Signals which differ from SIG_DFL action
1669  * (note: child (i.e., [v]forked) shell is not an interactive shell):
1670  *
1671  * SIGQUIT: ignore
1672  * SIGTERM (interactive): ignore
1673  * SIGHUP (interactive):
1674  *    send SIGCONT to stopped jobs, send SIGHUP to all jobs and exit
1675  * SIGTTIN, SIGTTOU, SIGTSTP (if job control is on): ignore
1676  *    Note that ^Z is handled not by trapping SIGTSTP, but by seeing
1677  *    that all pipe members are stopped. Try this in bash:
1678  *    while :; do :; done - ^Z does not background it
1679  *    (while :; do :; done) - ^Z backgrounds it
1680  * SIGINT (interactive): wait for last pipe, ignore the rest
1681  *    of the command line, show prompt. NB: ^C does not send SIGINT
1682  *    to interactive shell while shell is waiting for a pipe,
1683  *    since shell is bg'ed (is not in foreground process group).
1684  *    Example 1: this waits 5 sec, but does not execute ls:
1685  *    "echo $$; sleep 5; ls -l" + "kill -INT <pid>"
1686  *    Example 2: this does not wait and does not execute ls:
1687  *    "echo $$; sleep 5 & wait; ls -l" + "kill -INT <pid>"
1688  *    Example 3: this does not wait 5 sec, but executes ls:
1689  *    "sleep 5; ls -l" + press ^C
1690  *    Example 4: this does not wait and does not execute ls:
1691  *    "sleep 5 & wait; ls -l" + press ^C
1692  *
1693  * (What happens to signals which are IGN on shell start?)
1694  * (What happens with signal mask on shell start?)
1695  *
1696  * Old implementation
1697  * ==================
1698  * We use in-kernel pending signal mask to determine which signals were sent.
1699  * We block all signals which we don't want to take action immediately,
1700  * i.e. we block all signals which need to have special handling as described
1701  * above, and all signals which have traps set.
1702  * After each pipe execution, we extract any pending signals via sigtimedwait()
1703  * and act on them.
1704  *
1705  * unsigned special_sig_mask: a mask of such "special" signals
1706  * sigset_t blocked_set:  current blocked signal set
1707  *
1708  * "trap - SIGxxx":
1709  *    clear bit in blocked_set unless it is also in special_sig_mask
1710  * "trap 'cmd' SIGxxx":
1711  *    set bit in blocked_set (even if 'cmd' is '')
1712  * after [v]fork, if we plan to be a shell:
1713  *    unblock signals with special interactive handling
1714  *    (child shell is not interactive),
1715  *    unset all traps except '' (note: regardless of child shell's type - {}, (), etc)
1716  * after [v]fork, if we plan to exec:
1717  *    POSIX says fork clears pending signal mask in child - no need to clear it.
1718  *    Restore blocked signal set to one inherited by shell just prior to exec.
1719  *
1720  * Note: as a result, we do not use signal handlers much. The only uses
1721  * are to count SIGCHLDs
1722  * and to restore tty pgrp on signal-induced exit.
1723  *
1724  * Note 2 (compat):
1725  * Standard says "When a subshell is entered, traps that are not being ignored
1726  * are set to the default actions". bash interprets it so that traps which
1727  * are set to '' (ignore) are NOT reset to defaults. We do the same.
1728  *
1729  * Problem: the above approach makes it unwieldy to catch signals while
1730  * we are in read builtin, or while we read commands from stdin:
1731  * masked signals are not visible!
1732  *
1733  * New implementation
1734  * ==================
1735  * We record each signal we are interested in by installing signal handler
1736  * for them - a bit like emulating kernel pending signal mask in userspace.
1737  * We are interested in: signals which need to have special handling
1738  * as described above, and all signals which have traps set.
1739  * Signals are recorded in pending_set.
1740  * After each pipe execution, we extract any pending signals
1741  * and act on them.
1742  *
1743  * unsigned special_sig_mask: a mask of shell-special signals.
1744  * unsigned fatal_sig_mask: a mask of signals on which we restore tty pgrp.
1745  * char *traps[sig] if trap for sig is set (even if it's '').
1746  * sigset_t pending_set: set of sigs we received.
1747  *
1748  * "trap - SIGxxx":
1749  *    if sig is in special_sig_mask, set handler back to:
1750  *        record_pending_signo, or to IGN if it's a tty stop signal
1751  *    if sig is in fatal_sig_mask, set handler back to sigexit.
1752  *    else: set handler back to SIG_DFL
1753  * "trap 'cmd' SIGxxx":
1754  *    set handler to record_pending_signo.
1755  * "trap '' SIGxxx":
1756  *    set handler to SIG_IGN.
1757  * after [v]fork, if we plan to be a shell:
1758  *    set signals with special interactive handling to SIG_DFL
1759  *    (because child shell is not interactive),
1760  *    unset all traps except '' (note: regardless of child shell's type - {}, (), etc)
1761  * after [v]fork, if we plan to exec:
1762  *    POSIX says fork clears pending signal mask in child - no need to clear it.
1763  *
1764  * To make wait builtin interruptible, we handle SIGCHLD as special signal,
1765  * otherwise (if we leave it SIG_DFL) sigsuspend in wait builtin will not wake up on it.
1766  *
1767  * Note (compat):
1768  * Standard says "When a subshell is entered, traps that are not being ignored
1769  * are set to the default actions". bash interprets it so that traps which
1770  * are set to '' (ignore) are NOT reset to defaults. We do the same.
1771  */
1772 enum {
1773         SPECIAL_INTERACTIVE_SIGS = 0
1774                 | (1 << SIGTERM)
1775                 | (1 << SIGINT)
1776                 | (1 << SIGHUP)
1777                 ,
1778         SPECIAL_JOBSTOP_SIGS = 0
1779 #if ENABLE_HUSH_JOB
1780                 | (1 << SIGTTIN)
1781                 | (1 << SIGTTOU)
1782                 | (1 << SIGTSTP)
1783 #endif
1784                 ,
1785 };
1786
1787 static void record_pending_signo(int sig)
1788 {
1789         sigaddset(&G.pending_set, sig);
1790 #if ENABLE_HUSH_FAST
1791         if (sig == SIGCHLD) {
1792                 G.count_SIGCHLD++;
1793 //bb_error_msg("[%d] SIGCHLD_handler: G.count_SIGCHLD:%d G.handled_SIGCHLD:%d", getpid(), G.count_SIGCHLD, G.handled_SIGCHLD);
1794         }
1795 #endif
1796 }
1797
1798 static sighandler_t install_sighandler(int sig, sighandler_t handler)
1799 {
1800         struct sigaction old_sa;
1801
1802         /* We could use signal() to install handlers... almost:
1803          * except that we need to mask ALL signals while handlers run.
1804          * I saw signal nesting in strace, race window isn't small.
1805          * SA_RESTART is also needed, but in Linux, signal()
1806          * sets SA_RESTART too.
1807          */
1808         /* memset(&G.sa, 0, sizeof(G.sa)); - already done */
1809         /* sigfillset(&G.sa.sa_mask);      - already done */
1810         /* G.sa.sa_flags = SA_RESTART;     - already done */
1811         G.sa.sa_handler = handler;
1812         sigaction(sig, &G.sa, &old_sa);
1813         return old_sa.sa_handler;
1814 }
1815
1816 static void hush_exit(int exitcode) NORETURN;
1817
1818 static void restore_ttypgrp_and__exit(void) NORETURN;
1819 static void restore_ttypgrp_and__exit(void)
1820 {
1821         /* xfunc has failed! die die die */
1822         /* no EXIT traps, this is an escape hatch! */
1823         G.exiting = 1;
1824         hush_exit(xfunc_error_retval);
1825 }
1826
1827 #if ENABLE_HUSH_JOB
1828
1829 /* Needed only on some libc:
1830  * It was observed that on exit(), fgetc'ed buffered data
1831  * gets "unwound" via lseek(fd, -NUM, SEEK_CUR).
1832  * With the net effect that even after fork(), not vfork(),
1833  * exit() in NOEXECed applet in "sh SCRIPT":
1834  *      noexec_applet_here
1835  *      echo END_OF_SCRIPT
1836  * lseeks fd in input FILE object from EOF to "e" in "echo END_OF_SCRIPT".
1837  * This makes "echo END_OF_SCRIPT" executed twice.
1838  * Similar problems can be seen with msg_and_die_if_script() -> xfunc_die()
1839  * and in `cmd` handling.
1840  * If set as die_func(), this makes xfunc_die() exit via _exit(), not exit():
1841  */
1842 static void fflush_and__exit(void) NORETURN;
1843 static void fflush_and__exit(void)
1844 {
1845         fflush_all();
1846         _exit(xfunc_error_retval);
1847 }
1848
1849 /* After [v]fork, in child: do not restore tty pgrp on xfunc death */
1850 # define disable_restore_tty_pgrp_on_exit() (die_func = fflush_and__exit)
1851 /* After [v]fork, in parent: restore tty pgrp on xfunc death */
1852 # define enable_restore_tty_pgrp_on_exit()  (die_func = restore_ttypgrp_and__exit)
1853
1854 /* Restores tty foreground process group, and exits.
1855  * May be called as signal handler for fatal signal
1856  * (will resend signal to itself, producing correct exit state)
1857  * or called directly with -EXITCODE.
1858  * We also call it if xfunc is exiting.
1859  */
1860 static void sigexit(int sig) NORETURN;
1861 static void sigexit(int sig)
1862 {
1863         /* Careful: we can end up here after [v]fork. Do not restore
1864          * tty pgrp then, only top-level shell process does that */
1865         if (G_saved_tty_pgrp && getpid() == G.root_pid) {
1866                 /* Disable all signals: job control, SIGPIPE, etc.
1867                  * Mostly paranoid measure, to prevent infinite SIGTTOU.
1868                  */
1869                 sigprocmask_allsigs(SIG_BLOCK);
1870                 tcsetpgrp(G_interactive_fd, G_saved_tty_pgrp);
1871         }
1872
1873         /* Not a signal, just exit */
1874         if (sig <= 0)
1875                 _exit(- sig);
1876
1877         kill_myself_with_sig(sig); /* does not return */
1878 }
1879 #else
1880
1881 # define disable_restore_tty_pgrp_on_exit() ((void)0)
1882 # define enable_restore_tty_pgrp_on_exit()  ((void)0)
1883
1884 #endif
1885
1886 static sighandler_t pick_sighandler(unsigned sig)
1887 {
1888         sighandler_t handler = SIG_DFL;
1889         if (sig < sizeof(unsigned)*8) {
1890                 unsigned sigmask = (1 << sig);
1891
1892 #if ENABLE_HUSH_JOB
1893                 /* is sig fatal? */
1894                 if (G_fatal_sig_mask & sigmask)
1895                         handler = sigexit;
1896                 else
1897 #endif
1898                 /* sig has special handling? */
1899                 if (G.special_sig_mask & sigmask) {
1900                         handler = record_pending_signo;
1901                         /* TTIN/TTOU/TSTP can't be set to record_pending_signo
1902                          * in order to ignore them: they will be raised
1903                          * in an endless loop when we try to do some
1904                          * terminal ioctls! We do have to _ignore_ these.
1905                          */
1906                         if (SPECIAL_JOBSTOP_SIGS & sigmask)
1907                                 handler = SIG_IGN;
1908                 }
1909         }
1910         return handler;
1911 }
1912
1913 /* Restores tty foreground process group, and exits. */
1914 static void hush_exit(int exitcode)
1915 {
1916 #if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
1917         save_history(G.line_input_state);
1918 #endif
1919
1920         fflush_all();
1921         if (G.exiting <= 0 && G_traps && G_traps[0] && G_traps[0][0]) {
1922                 char *argv[3];
1923                 /* argv[0] is unused */
1924                 argv[1] = G_traps[0];
1925                 argv[2] = NULL;
1926                 G.exiting = 1; /* prevent EXIT trap recursion */
1927                 /* Note: G_traps[0] is not cleared!
1928                  * "trap" will still show it, if executed
1929                  * in the handler */
1930                 builtin_eval(argv);
1931         }
1932
1933 #if ENABLE_FEATURE_CLEAN_UP
1934         {
1935                 struct variable *cur_var;
1936                 if (G.cwd != bb_msg_unknown)
1937                         free((char*)G.cwd);
1938                 cur_var = G.top_var;
1939                 while (cur_var) {
1940                         struct variable *tmp = cur_var;
1941                         if (!cur_var->max_len)
1942                                 free(cur_var->varstr);
1943                         cur_var = cur_var->next;
1944                         free(tmp);
1945                 }
1946         }
1947 #endif
1948
1949         fflush_all();
1950 #if ENABLE_HUSH_JOB
1951         sigexit(- (exitcode & 0xff));
1952 #else
1953         _exit(exitcode);
1954 #endif
1955 }
1956
1957
1958 //TODO: return a mask of ALL handled sigs?
1959 static int check_and_run_traps(void)
1960 {
1961         int last_sig = 0;
1962
1963         while (1) {
1964                 int sig;
1965
1966                 if (sigisemptyset(&G.pending_set))
1967                         break;
1968                 sig = 0;
1969                 do {
1970                         sig++;
1971                         if (sigismember(&G.pending_set, sig)) {
1972                                 sigdelset(&G.pending_set, sig);
1973                                 goto got_sig;
1974                         }
1975                 } while (sig < NSIG);
1976                 break;
1977  got_sig:
1978                 if (G_traps && G_traps[sig]) {
1979                         debug_printf_exec("%s: sig:%d handler:'%s'\n", __func__, sig, G.traps[sig]);
1980                         if (G_traps[sig][0]) {
1981                                 /* We have user-defined handler */
1982                                 smalluint save_rcode;
1983                                 char *argv[3];
1984                                 /* argv[0] is unused */
1985                                 argv[1] = G_traps[sig];
1986                                 argv[2] = NULL;
1987                                 save_rcode = G.last_exitcode;
1988                                 builtin_eval(argv);
1989 //FIXME: shouldn't it be set to 128 + sig instead?
1990                                 G.last_exitcode = save_rcode;
1991                                 last_sig = sig;
1992                         } /* else: "" trap, ignoring signal */
1993                         continue;
1994                 }
1995                 /* not a trap: special action */
1996                 switch (sig) {
1997                 case SIGINT:
1998                         debug_printf_exec("%s: sig:%d default SIGINT handler\n", __func__, sig);
1999                         G.flag_SIGINT = 1;
2000                         last_sig = sig;
2001                         break;
2002 #if ENABLE_HUSH_JOB
2003                 case SIGHUP: {
2004 //TODO: why are we doing this? ash and dash don't do this,
2005 //they have no handler for SIGHUP at all,
2006 //they rely on kernel to send SIGHUP+SIGCONT to orphaned process groups
2007                         struct pipe *job;
2008                         debug_printf_exec("%s: sig:%d default SIGHUP handler\n", __func__, sig);
2009                         /* bash is observed to signal whole process groups,
2010                          * not individual processes */
2011                         for (job = G.job_list; job; job = job->next) {
2012                                 if (job->pgrp <= 0)
2013                                         continue;
2014                                 debug_printf_exec("HUPing pgrp %d\n", job->pgrp);
2015                                 if (kill(- job->pgrp, SIGHUP) == 0)
2016                                         kill(- job->pgrp, SIGCONT);
2017                         }
2018                         sigexit(SIGHUP);
2019                 }
2020 #endif
2021 #if ENABLE_HUSH_FAST
2022                 case SIGCHLD:
2023                         debug_printf_exec("%s: sig:%d default SIGCHLD handler\n", __func__, sig);
2024                         G.count_SIGCHLD++;
2025 //bb_error_msg("[%d] check_and_run_traps: G.count_SIGCHLD:%d G.handled_SIGCHLD:%d", getpid(), G.count_SIGCHLD, G.handled_SIGCHLD);
2026                         /* Note:
2027                          * We don't do 'last_sig = sig' here -> NOT returning this sig.
2028                          * This simplifies wait builtin a bit.
2029                          */
2030                         break;
2031 #endif
2032                 default: /* ignored: */
2033                         debug_printf_exec("%s: sig:%d default handling is to ignore\n", __func__, sig);
2034                         /* SIGTERM, SIGQUIT, SIGTTIN, SIGTTOU, SIGTSTP */
2035                         /* Note:
2036                          * We don't do 'last_sig = sig' here -> NOT returning this sig.
2037                          * Example: wait is not interrupted by TERM
2038                          * in interactive shell, because TERM is ignored.
2039                          */
2040                         break;
2041                 }
2042         }
2043         return last_sig;
2044 }
2045
2046
2047 static const char *get_cwd(int force)
2048 {
2049         if (force || G.cwd == NULL) {
2050                 /* xrealloc_getcwd_or_warn(arg) calls free(arg),
2051                  * we must not try to free(bb_msg_unknown) */
2052                 if (G.cwd == bb_msg_unknown)
2053                         G.cwd = NULL;
2054                 G.cwd = xrealloc_getcwd_or_warn((char *)G.cwd);
2055                 if (!G.cwd)
2056                         G.cwd = bb_msg_unknown;
2057         }
2058         return G.cwd;
2059 }
2060
2061
2062 /*
2063  * Shell and environment variable support
2064  */
2065 static struct variable **get_ptr_to_local_var(const char *name, unsigned len)
2066 {
2067         struct variable **pp;
2068         struct variable *cur;
2069
2070         pp = &G.top_var;
2071         while ((cur = *pp) != NULL) {
2072                 if (strncmp(cur->varstr, name, len) == 0 && cur->varstr[len] == '=')
2073                         return pp;
2074                 pp = &cur->next;
2075         }
2076         return NULL;
2077 }
2078
2079 static const char* FAST_FUNC get_local_var_value(const char *name)
2080 {
2081         struct variable **vpp;
2082         unsigned len = strlen(name);
2083
2084         if (G.expanded_assignments) {
2085                 char **cpp = G.expanded_assignments;
2086                 while (*cpp) {
2087                         char *cp = *cpp;
2088                         if (strncmp(cp, name, len) == 0 && cp[len] == '=')
2089                                 return cp + len + 1;
2090                         cpp++;
2091                 }
2092         }
2093
2094         vpp = get_ptr_to_local_var(name, len);
2095         if (vpp)
2096                 return (*vpp)->varstr + len + 1;
2097
2098         if (strcmp(name, "PPID") == 0)
2099                 return utoa(G.root_ppid);
2100         // bash compat: UID? EUID?
2101 #if ENABLE_HUSH_RANDOM_SUPPORT
2102         if (strcmp(name, "RANDOM") == 0)
2103                 return utoa(next_random(&G.random_gen));
2104 #endif
2105         return NULL;
2106 }
2107
2108 /* str holds "NAME=VAL" and is expected to be malloced.
2109  * We take ownership of it.
2110  */
2111 #define SETFLAG_EXPORT   (1 << 0)
2112 #define SETFLAG_UNEXPORT (1 << 1)
2113 #define SETFLAG_MAKE_RO  (1 << 2)
2114 #define SETFLAG_LOCAL_SHIFT    3
2115 static int set_local_var(char *str, unsigned flags)
2116 {
2117         struct variable **var_pp;
2118         struct variable *cur;
2119         char *free_me = NULL;
2120         char *eq_sign;
2121         int name_len;
2122         IF_HUSH_LOCAL(unsigned local_lvl = (flags >> SETFLAG_LOCAL_SHIFT);)
2123
2124         eq_sign = strchr(str, '=');
2125         if (!eq_sign) { /* not expected to ever happen? */
2126                 free(str);
2127                 return -1;
2128         }
2129
2130         name_len = eq_sign - str + 1; /* including '=' */
2131         var_pp = &G.top_var;
2132         while ((cur = *var_pp) != NULL) {
2133                 if (strncmp(cur->varstr, str, name_len) != 0) {
2134                         var_pp = &cur->next;
2135                         continue;
2136                 }
2137
2138                 /* We found an existing var with this name */
2139                 if (cur->flg_read_only) {
2140                         bb_error_msg("%s: readonly variable", str);
2141                         free(str);
2142 //NOTE: in bash, assignment in "export READONLY_VAR=Z" fails, and sets $?=1,
2143 //but export per se succeeds (does put the var in env). We don't mimic that.
2144                         return -1;
2145                 }
2146                 if (flags & SETFLAG_UNEXPORT) { // && cur->flg_export ?
2147                         debug_printf_env("%s: unsetenv '%s'\n", __func__, str);
2148                         *eq_sign = '\0';
2149                         unsetenv(str);
2150                         *eq_sign = '=';
2151                 }
2152 #if ENABLE_HUSH_LOCAL
2153                 if (cur->func_nest_level < local_lvl) {
2154                         /* New variable is declared as local,
2155                          * and existing one is global, or local
2156                          * from enclosing function.
2157                          * Remove and save old one: */
2158                         *var_pp = cur->next;
2159                         cur->next = *G.shadowed_vars_pp;
2160                         *G.shadowed_vars_pp = cur;
2161                         /* bash 3.2.33(1) and exported vars:
2162                          * # export z=z
2163                          * # f() { local z=a; env | grep ^z; }
2164                          * # f
2165                          * z=a
2166                          * # env | grep ^z
2167                          * z=z
2168                          */
2169                         if (cur->flg_export)
2170                                 flags |= SETFLAG_EXPORT;
2171                         break;
2172                 }
2173 #endif
2174                 if (strcmp(cur->varstr + name_len, eq_sign + 1) == 0) {
2175  free_and_exp:
2176                         free(str);
2177                         goto exp;
2178                 }
2179                 if (cur->max_len != 0) {
2180                         if (cur->max_len >= strlen(str)) {
2181                                 /* This one is from startup env, reuse space */
2182                                 strcpy(cur->varstr, str);
2183                                 goto free_and_exp;
2184                         }
2185                         /* Can't reuse */
2186                         cur->max_len = 0;
2187                         goto set_str_and_exp;
2188                 }
2189                 /* max_len == 0 signifies "malloced" var, which we can
2190                  * (and have to) free. But we can't free(cur->varstr) here:
2191                  * if cur->flg_export is 1, it is in the environment.
2192                  * We should either unsetenv+free, or wait until putenv,
2193                  * then putenv(new)+free(old).
2194                  */
2195                 free_me = cur->varstr;
2196                 goto set_str_and_exp;
2197         }
2198
2199         /* Not found - create new variable struct */
2200         cur = xzalloc(sizeof(*cur));
2201         IF_HUSH_LOCAL(cur->func_nest_level = local_lvl;)
2202         cur->next = *var_pp;
2203         *var_pp = cur;
2204
2205  set_str_and_exp:
2206         cur->varstr = str;
2207  exp:
2208 #if !BB_MMU || ENABLE_HUSH_READONLY
2209         if (flags & SETFLAG_MAKE_RO) {
2210                 cur->flg_read_only = 1;
2211         }
2212 #endif
2213         if (flags & SETFLAG_EXPORT)
2214                 cur->flg_export = 1;
2215         if (name_len == 4 && cur->varstr[0] == 'P' && cur->varstr[1] == 'S')
2216                 cmdedit_update_prompt();
2217         if (cur->flg_export) {
2218                 if (flags & SETFLAG_UNEXPORT) {
2219                         cur->flg_export = 0;
2220                         /* unsetenv was already done */
2221                 } else {
2222                         int i;
2223                         debug_printf_env("%s: putenv '%s'\n", __func__, cur->varstr);
2224                         i = putenv(cur->varstr);
2225                         /* only now we can free old exported malloced string */
2226                         free(free_me);
2227                         return i;
2228                 }
2229         }
2230         free(free_me);
2231         return 0;
2232 }
2233
2234 /* Used at startup and after each cd */
2235 static void set_pwd_var(unsigned flag)
2236 {
2237         set_local_var(xasprintf("PWD=%s", get_cwd(/*force:*/ 1)), flag);
2238 }
2239
2240 static int unset_local_var_len(const char *name, int name_len)
2241 {
2242         struct variable *cur;
2243         struct variable **var_pp;
2244
2245         if (!name)
2246                 return EXIT_SUCCESS;
2247         var_pp = &G.top_var;
2248         while ((cur = *var_pp) != NULL) {
2249                 if (strncmp(cur->varstr, name, name_len) == 0 && cur->varstr[name_len] == '=') {
2250                         if (cur->flg_read_only) {
2251                                 bb_error_msg("%s: readonly variable", name);
2252                                 return EXIT_FAILURE;
2253                         }
2254                         *var_pp = cur->next;
2255                         debug_printf_env("%s: unsetenv '%s'\n", __func__, cur->varstr);
2256                         bb_unsetenv(cur->varstr);
2257                         if (name_len == 3 && cur->varstr[0] == 'P' && cur->varstr[1] == 'S')
2258                                 cmdedit_update_prompt();
2259                         if (!cur->max_len)
2260                                 free(cur->varstr);
2261                         free(cur);
2262                         return EXIT_SUCCESS;
2263                 }
2264                 var_pp = &cur->next;
2265         }
2266         return EXIT_SUCCESS;
2267 }
2268
2269 #if ENABLE_HUSH_UNSET
2270 static int unset_local_var(const char *name)
2271 {
2272         return unset_local_var_len(name, strlen(name));
2273 }
2274 #endif
2275
2276 static void unset_vars(char **strings)
2277 {
2278         char **v;
2279
2280         if (!strings)
2281                 return;
2282         v = strings;
2283         while (*v) {
2284                 const char *eq = strchrnul(*v, '=');
2285                 unset_local_var_len(*v, (int)(eq - *v));
2286                 v++;
2287         }
2288         free(strings);
2289 }
2290
2291 #if BASH_HOSTNAME_VAR || ENABLE_FEATURE_SH_MATH || ENABLE_HUSH_READ
2292 static void FAST_FUNC set_local_var_from_halves(const char *name, const char *val)
2293 {
2294         char *var = xasprintf("%s=%s", name, val);
2295         set_local_var(var, /*flag:*/ 0);
2296 }
2297 #endif
2298
2299
2300 /*
2301  * Helpers for "var1=val1 var2=val2 cmd" feature
2302  */
2303 static void add_vars(struct variable *var)
2304 {
2305         struct variable *next;
2306
2307         while (var) {
2308                 next = var->next;
2309                 var->next = G.top_var;
2310                 G.top_var = var;
2311                 if (var->flg_export) {
2312                         debug_printf_env("%s: restoring exported '%s'\n", __func__, var->varstr);
2313                         putenv(var->varstr);
2314                 } else {
2315                         debug_printf_env("%s: restoring variable '%s'\n", __func__, var->varstr);
2316                 }
2317                 var = next;
2318         }
2319 }
2320
2321 static struct variable *set_vars_and_save_old(char **strings)
2322 {
2323         char **s;
2324         struct variable *old = NULL;
2325
2326         if (!strings)
2327                 return old;
2328         s = strings;
2329         while (*s) {
2330                 struct variable *var_p;
2331                 struct variable **var_pp;
2332                 char *eq;
2333
2334                 eq = strchr(*s, '=');
2335                 if (eq) {
2336                         var_pp = get_ptr_to_local_var(*s, eq - *s);
2337                         if (var_pp) {
2338                                 var_p = *var_pp;
2339                                 if (var_p->flg_read_only) {
2340                                         char **p;
2341                                         bb_error_msg("%s: readonly variable", *s);
2342                                         /*
2343                                          * "VAR=V BLTIN" unsets VARs after BLTIN completes.
2344                                          * If VAR is readonly, leaving it in the list
2345                                          * after asssignment error (msg above)
2346                                          * causes doubled error message later, on unset.
2347                                          */
2348                                         debug_printf_env("removing/freeing '%s' element\n", *s);
2349                                         free(*s);
2350                                         p = s;
2351                                         do { *p = p[1]; p++; } while (*p);
2352                                         goto next;
2353                                 }
2354                                 /* Remove variable from global linked list */
2355                                 debug_printf_env("%s: removing '%s'\n", __func__, var_p->varstr);
2356                                 *var_pp = var_p->next;
2357                                 /* Add it to returned list */
2358                                 var_p->next = old;
2359                                 old = var_p;
2360                         }
2361                         set_local_var(*s, SETFLAG_EXPORT);
2362                 }
2363  next:
2364                 s++;
2365         }
2366         return old;
2367 }
2368
2369
2370 /*
2371  * Unicode helper
2372  */
2373 static void reinit_unicode_for_hush(void)
2374 {
2375         /* Unicode support should be activated even if LANG is set
2376          * _during_ shell execution, not only if it was set when
2377          * shell was started. Therefore, re-check LANG every time:
2378          */
2379         if (ENABLE_FEATURE_CHECK_UNICODE_IN_ENV
2380          || ENABLE_UNICODE_USING_LOCALE
2381         ) {
2382                 const char *s = get_local_var_value("LC_ALL");
2383                 if (!s) s = get_local_var_value("LC_CTYPE");
2384                 if (!s) s = get_local_var_value("LANG");
2385                 reinit_unicode(s);
2386         }
2387 }
2388
2389 /*
2390  * in_str support (strings, and "strings" read from files).
2391  */
2392
2393 #if ENABLE_HUSH_INTERACTIVE
2394 /* To test correct lineedit/interactive behavior, type from command line:
2395  *      echo $P\
2396  *      \
2397  *      AT\
2398  *      H\
2399  *      \
2400  * It exercises a lot of corner cases.
2401  */
2402 static void cmdedit_update_prompt(void)
2403 {
2404         if (ENABLE_FEATURE_EDITING_FANCY_PROMPT) {
2405                 G.PS1 = get_local_var_value("PS1");
2406                 if (G.PS1 == NULL)
2407                         G.PS1 = "\\w \\$ ";
2408                 G.PS2 = get_local_var_value("PS2");
2409         } else {
2410                 G.PS1 = NULL;
2411         }
2412         if (G.PS2 == NULL)
2413                 G.PS2 = "> ";
2414 }
2415 static const char *setup_prompt_string(int promptmode)
2416 {
2417         const char *prompt_str;
2418         debug_printf("setup_prompt_string %d ", promptmode);
2419         if (!ENABLE_FEATURE_EDITING_FANCY_PROMPT) {
2420                 /* Set up the prompt */
2421                 if (promptmode == 0) { /* PS1 */
2422                         free((char*)G.PS1);
2423                         /* bash uses $PWD value, even if it is set by user.
2424                          * It uses current dir only if PWD is unset.
2425                          * We always use current dir. */
2426                         G.PS1 = xasprintf("%s %c ", get_cwd(0), (geteuid() != 0) ? '$' : '#');
2427                         prompt_str = G.PS1;
2428                 } else
2429                         prompt_str = G.PS2;
2430         } else
2431                 prompt_str = (promptmode == 0) ? G.PS1 : G.PS2;
2432         debug_printf("prompt_str '%s'\n", prompt_str);
2433         return prompt_str;
2434 }
2435 static int get_user_input(struct in_str *i)
2436 {
2437         int r;
2438         const char *prompt_str;
2439
2440         prompt_str = setup_prompt_string(i->promptmode);
2441 # if ENABLE_FEATURE_EDITING
2442         for (;;) {
2443                 reinit_unicode_for_hush();
2444                 if (G.flag_SIGINT) {
2445                         /* There was ^C'ed, make it look prettier: */
2446                         bb_putchar('\n');
2447                         G.flag_SIGINT = 0;
2448                 }
2449                 /* buglet: SIGINT will not make new prompt to appear _at once_,
2450                  * only after <Enter>. (^C works immediately) */
2451                 r = read_line_input(G.line_input_state, prompt_str,
2452                                 G.user_input_buf, CONFIG_FEATURE_EDITING_MAX_LEN-1
2453                 );
2454                 /* read_line_input intercepts ^C, "convert" it to SIGINT */
2455                 if (r == 0)
2456                         raise(SIGINT);
2457                 check_and_run_traps();
2458                 if (r != 0 && !G.flag_SIGINT)
2459                         break;
2460                 /* ^C or SIGINT: repeat */
2461                 /* bash prints ^C even on real SIGINT (non-kbd generated) */
2462                 write(STDOUT_FILENO, "^C", 2);
2463                 G.last_exitcode = 128 + SIGINT;
2464         }
2465         if (r < 0) {
2466                 /* EOF/error detected */
2467                 i->p = NULL;
2468                 i->peek_buf[0] = r = EOF;
2469                 return r;
2470         }
2471         i->p = G.user_input_buf;
2472         return (unsigned char)*i->p++;
2473 # else
2474         for (;;) {
2475                 G.flag_SIGINT = 0;
2476                 if (i->last_char == '\0' || i->last_char == '\n') {
2477                         /* Why check_and_run_traps here? Try this interactively:
2478                          * $ trap 'echo INT' INT; (sleep 2; kill -INT $$) &
2479                          * $ <[enter], repeatedly...>
2480                          * Without check_and_run_traps, handler never runs.
2481                          */
2482                         check_and_run_traps();
2483                         fputs(prompt_str, stdout);
2484                 }
2485                 fflush_all();
2486 //FIXME: here ^C or SIGINT will have effect only after <Enter>
2487                 r = fgetc(i->file);
2488                 /* In !ENABLE_FEATURE_EDITING we don't use read_line_input,
2489                  * no ^C masking happens during fgetc, no special code for ^C:
2490                  * it generates SIGINT as usual.
2491                  */
2492                 check_and_run_traps();
2493                 if (G.flag_SIGINT)
2494                         G.last_exitcode = 128 + SIGINT;
2495                 if (r != '\0')
2496                         break;
2497         }
2498         return r;
2499 # endif
2500 }
2501 /* This is the magic location that prints prompts
2502  * and gets data back from the user */
2503 static int fgetc_interactive(struct in_str *i)
2504 {
2505         int ch;
2506         /* If it's interactive stdin, get new line. */
2507         if (G_interactive_fd && i->file == stdin) {
2508                 /* Returns first char (or EOF), the rest is in i->p[] */
2509                 ch = get_user_input(i);
2510                 i->promptmode = 1; /* PS2 */
2511         } else {
2512                 /* Not stdin: script file, sourced file, etc */
2513                 do ch = fgetc(i->file); while (ch == '\0');
2514         }
2515         return ch;
2516 }
2517 #else
2518 static inline int fgetc_interactive(struct in_str *i)
2519 {
2520         int ch;
2521         do ch = fgetc(i->file); while (ch == '\0');
2522         return ch;
2523 }
2524 #endif  /* INTERACTIVE */
2525
2526 static int i_getch(struct in_str *i)
2527 {
2528         int ch;
2529
2530         if (!i->file) {
2531                 /* string-based in_str */
2532                 ch = (unsigned char)*i->p;
2533                 if (ch != '\0') {
2534                         i->p++;
2535                         i->last_char = ch;
2536                         return ch;
2537                 }
2538                 return EOF;
2539         }
2540
2541         /* FILE-based in_str */
2542
2543 #if ENABLE_FEATURE_EDITING
2544         /* This can be stdin, check line editing char[] buffer */
2545         if (i->p && *i->p != '\0') {
2546                 ch = (unsigned char)*i->p++;
2547                 goto out;
2548         }
2549 #endif
2550         /* peek_buf[] is an int array, not char. Can contain EOF. */
2551         ch = i->peek_buf[0];
2552         if (ch != 0) {
2553                 int ch2 = i->peek_buf[1];
2554                 i->peek_buf[0] = ch2;
2555                 if (ch2 == 0) /* very likely, avoid redundant write */
2556                         goto out;
2557                 i->peek_buf[1] = 0;
2558                 goto out;
2559         }
2560
2561         ch = fgetc_interactive(i);
2562  out:
2563         debug_printf("file_get: got '%c' %d\n", ch, ch);
2564         i->last_char = ch;
2565         return ch;
2566 }
2567
2568 static int i_peek(struct in_str *i)
2569 {
2570         int ch;
2571
2572         if (!i->file) {
2573                 /* string-based in_str */
2574                 /* Doesn't report EOF on NUL. None of the callers care. */
2575                 return (unsigned char)*i->p;
2576         }
2577
2578         /* FILE-based in_str */
2579
2580 #if ENABLE_FEATURE_EDITING && ENABLE_HUSH_INTERACTIVE
2581         /* This can be stdin, check line editing char[] buffer */
2582         if (i->p && *i->p != '\0')
2583                 return (unsigned char)*i->p;
2584 #endif
2585         /* peek_buf[] is an int array, not char. Can contain EOF. */
2586         ch = i->peek_buf[0];
2587         if (ch != 0)
2588                 return ch;
2589
2590         /* Need to get a new char */
2591         ch = fgetc_interactive(i);
2592         debug_printf("file_peek: got '%c' %d\n", ch, ch);
2593
2594         /* Save it by either rolling back line editing buffer, or in i->peek_buf[0] */
2595 #if ENABLE_FEATURE_EDITING && ENABLE_HUSH_INTERACTIVE
2596         if (i->p) {
2597                 i->p -= 1;
2598                 return ch;
2599         }
2600 #endif
2601         i->peek_buf[0] = ch;
2602         /*i->peek_buf[1] = 0; - already is */
2603         return ch;
2604 }
2605
2606 /* Only ever called if i_peek() was called, and did not return EOF.
2607  * IOW: we know the previous peek saw an ordinary char, not EOF, not NUL,
2608  * not end-of-line. Therefore we never need to read a new editing line here.
2609  */
2610 static int i_peek2(struct in_str *i)
2611 {
2612         int ch;
2613
2614         /* There are two cases when i->p[] buffer exists.
2615          * (1) it's a string in_str.
2616          * (2) It's a file, and we have a saved line editing buffer.
2617          * In both cases, we know that i->p[0] exists and not NUL, and
2618          * the peek2 result is in i->p[1].
2619          */
2620         if (i->p)
2621                 return (unsigned char)i->p[1];
2622
2623         /* Now we know it is a file-based in_str. */
2624
2625         /* peek_buf[] is an int array, not char. Can contain EOF. */
2626         /* Is there 2nd char? */
2627         ch = i->peek_buf[1];
2628         if (ch == 0) {
2629                 /* We did not read it yet, get it now */
2630                 do ch = fgetc(i->file); while (ch == '\0');
2631                 i->peek_buf[1] = ch;
2632         }
2633
2634         debug_printf("file_peek2: got '%c' %d\n", ch, ch);
2635         return ch;
2636 }
2637
2638 static void setup_file_in_str(struct in_str *i, FILE *f)
2639 {
2640         memset(i, 0, sizeof(*i));
2641         /* i->promptmode = 0; - PS1 (memset did it) */
2642         i->file = f;
2643         /* i->p = NULL; */
2644 }
2645
2646 static void setup_string_in_str(struct in_str *i, const char *s)
2647 {
2648         memset(i, 0, sizeof(*i));
2649         /* i->promptmode = 0; - PS1 (memset did it) */
2650         /*i->file = NULL */;
2651         i->p = s;
2652 }
2653
2654
2655 /*
2656  * o_string support
2657  */
2658 #define B_CHUNK  (32 * sizeof(char*))
2659
2660 static void o_reset_to_empty_unquoted(o_string *o)
2661 {
2662         o->length = 0;
2663         o->has_quoted_part = 0;
2664         if (o->data)
2665                 o->data[0] = '\0';
2666 }
2667
2668 static void o_free(o_string *o)
2669 {
2670         free(o->data);
2671         memset(o, 0, sizeof(*o));
2672 }
2673
2674 static ALWAYS_INLINE void o_free_unsafe(o_string *o)
2675 {
2676         free(o->data);
2677 }
2678
2679 static void o_grow_by(o_string *o, int len)
2680 {
2681         if (o->length + len > o->maxlen) {
2682                 o->maxlen += (2 * len) | (B_CHUNK-1);
2683                 o->data = xrealloc(o->data, 1 + o->maxlen);
2684         }
2685 }
2686
2687 static void o_addchr(o_string *o, int ch)
2688 {
2689         debug_printf("o_addchr: '%c' o->length=%d o=%p\n", ch, o->length, o);
2690         if (o->length < o->maxlen) {
2691                 /* likely. avoid o_grow_by() call */
2692  add:
2693                 o->data[o->length] = ch;
2694                 o->length++;
2695                 o->data[o->length] = '\0';
2696                 return;
2697         }
2698         o_grow_by(o, 1);
2699         goto add;
2700 }
2701
2702 #if 0
2703 /* Valid only if we know o_string is not empty */
2704 static void o_delchr(o_string *o)
2705 {
2706         o->length--;
2707         o->data[o->length] = '\0';
2708 }
2709 #endif
2710
2711 static void o_addblock(o_string *o, const char *str, int len)
2712 {
2713         o_grow_by(o, len);
2714         ((char*)mempcpy(&o->data[o->length], str, len))[0] = '\0';
2715         o->length += len;
2716 }
2717
2718 static void o_addstr(o_string *o, const char *str)
2719 {
2720         o_addblock(o, str, strlen(str));
2721 }
2722
2723 #if !BB_MMU
2724 static void nommu_addchr(o_string *o, int ch)
2725 {
2726         if (o)
2727                 o_addchr(o, ch);
2728 }
2729 #else
2730 # define nommu_addchr(o, str) ((void)0)
2731 #endif
2732
2733 static void o_addstr_with_NUL(o_string *o, const char *str)
2734 {
2735         o_addblock(o, str, strlen(str) + 1);
2736 }
2737
2738 /*
2739  * HUSH_BRACE_EXPANSION code needs corresponding quoting on variable expansion side.
2740  * Currently, "v='{q,w}'; echo $v" erroneously expands braces in $v.
2741  * Apparently, on unquoted $v bash still does globbing
2742  * ("v='*.txt'; echo $v" prints all .txt files),
2743  * but NOT brace expansion! Thus, there should be TWO independent
2744  * quoting mechanisms on $v expansion side: one protects
2745  * $v from brace expansion, and other additionally protects "$v" against globbing.
2746  * We have only second one.
2747  */
2748
2749 #if ENABLE_HUSH_BRACE_EXPANSION
2750 # define MAYBE_BRACES "{}"
2751 #else
2752 # define MAYBE_BRACES ""
2753 #endif
2754
2755 /* My analysis of quoting semantics tells me that state information
2756  * is associated with a destination, not a source.
2757  */
2758 static void o_addqchr(o_string *o, int ch)
2759 {
2760         int sz = 1;
2761         char *found = strchr("*?[\\" MAYBE_BRACES, ch);
2762         if (found)
2763                 sz++;
2764         o_grow_by(o, sz);
2765         if (found) {
2766                 o->data[o->length] = '\\';
2767                 o->length++;
2768         }
2769         o->data[o->length] = ch;
2770         o->length++;
2771         o->data[o->length] = '\0';
2772 }
2773
2774 static void o_addQchr(o_string *o, int ch)
2775 {
2776         int sz = 1;
2777         if ((o->o_expflags & EXP_FLAG_ESC_GLOB_CHARS)
2778          && strchr("*?[\\" MAYBE_BRACES, ch)
2779         ) {
2780                 sz++;
2781                 o->data[o->length] = '\\';
2782                 o->length++;
2783         }
2784         o_grow_by(o, sz);
2785         o->data[o->length] = ch;
2786         o->length++;
2787         o->data[o->length] = '\0';
2788 }
2789
2790 static void o_addqblock(o_string *o, const char *str, int len)
2791 {
2792         while (len) {
2793                 char ch;
2794                 int sz;
2795                 int ordinary_cnt = strcspn(str, "*?[\\" MAYBE_BRACES);
2796                 if (ordinary_cnt > len) /* paranoia */
2797                         ordinary_cnt = len;
2798                 o_addblock(o, str, ordinary_cnt);
2799                 if (ordinary_cnt == len)
2800                         return; /* NUL is already added by o_addblock */
2801                 str += ordinary_cnt;
2802                 len -= ordinary_cnt + 1; /* we are processing + 1 char below */
2803
2804                 ch = *str++;
2805                 sz = 1;
2806                 if (ch) { /* it is necessarily one of "*?[\\" MAYBE_BRACES */
2807                         sz++;
2808                         o->data[o->length] = '\\';
2809                         o->length++;
2810                 }
2811                 o_grow_by(o, sz);
2812                 o->data[o->length] = ch;
2813                 o->length++;
2814         }
2815         o->data[o->length] = '\0';
2816 }
2817
2818 static void o_addQblock(o_string *o, const char *str, int len)
2819 {
2820         if (!(o->o_expflags & EXP_FLAG_ESC_GLOB_CHARS)) {
2821                 o_addblock(o, str, len);
2822                 return;
2823         }
2824         o_addqblock(o, str, len);
2825 }
2826
2827 static void o_addQstr(o_string *o, const char *str)
2828 {
2829         o_addQblock(o, str, strlen(str));
2830 }
2831
2832 /* A special kind of o_string for $VAR and `cmd` expansion.
2833  * It contains char* list[] at the beginning, which is grown in 16 element
2834  * increments. Actual string data starts at the next multiple of 16 * (char*).
2835  * list[i] contains an INDEX (int!) into this string data.
2836  * It means that if list[] needs to grow, data needs to be moved higher up
2837  * but list[i]'s need not be modified.
2838  * NB: remembering how many list[i]'s you have there is crucial.
2839  * o_finalize_list() operation post-processes this structure - calculates
2840  * and stores actual char* ptrs in list[]. Oh, it NULL terminates it as well.
2841  */
2842 #if DEBUG_EXPAND || DEBUG_GLOB
2843 static void debug_print_list(const char *prefix, o_string *o, int n)
2844 {
2845         char **list = (char**)o->data;
2846         int string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
2847         int i = 0;
2848
2849         indent();
2850         fdprintf(2, "%s: list:%p n:%d string_start:%d length:%d maxlen:%d glob:%d quoted:%d escape:%d\n",
2851                         prefix, list, n, string_start, o->length, o->maxlen,
2852                         !!(o->o_expflags & EXP_FLAG_GLOB),
2853                         o->has_quoted_part,
2854                         !!(o->o_expflags & EXP_FLAG_ESC_GLOB_CHARS));
2855         while (i < n) {
2856                 indent();
2857                 fdprintf(2, " list[%d]=%d '%s' %p\n", i, (int)(uintptr_t)list[i],
2858                                 o->data + (int)(uintptr_t)list[i] + string_start,
2859                                 o->data + (int)(uintptr_t)list[i] + string_start);
2860                 i++;
2861         }
2862         if (n) {
2863                 const char *p = o->data + (int)(uintptr_t)list[n - 1] + string_start;
2864                 indent();
2865                 fdprintf(2, " total_sz:%ld\n", (long)((p + strlen(p) + 1) - o->data));
2866         }
2867 }
2868 #else
2869 # define debug_print_list(prefix, o, n) ((void)0)
2870 #endif
2871
2872 /* n = o_save_ptr_helper(str, n) "starts new string" by storing an index value
2873  * in list[n] so that it points past last stored byte so far.
2874  * It returns n+1. */
2875 static int o_save_ptr_helper(o_string *o, int n)
2876 {
2877         char **list = (char**)o->data;
2878         int string_start;
2879         int string_len;
2880
2881         if (!o->has_empty_slot) {
2882                 string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
2883                 string_len = o->length - string_start;
2884                 if (!(n & 0xf)) { /* 0, 0x10, 0x20...? */
2885                         debug_printf_list("list[%d]=%d string_start=%d (growing)\n", n, string_len, string_start);
2886                         /* list[n] points to string_start, make space for 16 more pointers */
2887                         o->maxlen += 0x10 * sizeof(list[0]);
2888                         o->data = xrealloc(o->data, o->maxlen + 1);
2889                         list = (char**)o->data;
2890                         memmove(list + n + 0x10, list + n, string_len);
2891                         o->length += 0x10 * sizeof(list[0]);
2892                 } else {
2893                         debug_printf_list("list[%d]=%d string_start=%d\n",
2894                                         n, string_len, string_start);
2895                 }
2896         } else {
2897                 /* We have empty slot at list[n], reuse without growth */
2898                 string_start = ((n+1 + 0xf) & ~0xf) * sizeof(list[0]); /* NB: n+1! */
2899                 string_len = o->length - string_start;
2900                 debug_printf_list("list[%d]=%d string_start=%d (empty slot)\n",
2901                                 n, string_len, string_start);
2902                 o->has_empty_slot = 0;
2903         }
2904         o->has_quoted_part = 0;
2905         list[n] = (char*)(uintptr_t)string_len;
2906         return n + 1;
2907 }
2908
2909 /* "What was our last o_save_ptr'ed position (byte offset relative o->data)?" */
2910 static int o_get_last_ptr(o_string *o, int n)
2911 {
2912         char **list = (char**)o->data;
2913         int string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
2914
2915         return ((int)(uintptr_t)list[n-1]) + string_start;
2916 }
2917
2918 #if ENABLE_HUSH_BRACE_EXPANSION
2919 /* There in a GNU extension, GLOB_BRACE, but it is not usable:
2920  * first, it processes even {a} (no commas), second,
2921  * I didn't manage to make it return strings when they don't match
2922  * existing files. Need to re-implement it.
2923  */
2924
2925 /* Helper */
2926 static int glob_needed(const char *s)
2927 {
2928         while (*s) {
2929                 if (*s == '\\') {
2930                         if (!s[1])
2931                                 return 0;
2932                         s += 2;
2933                         continue;
2934                 }
2935                 if (*s == '*' || *s == '[' || *s == '?' || *s == '{')
2936                         return 1;
2937                 s++;
2938         }
2939         return 0;
2940 }
2941 /* Return pointer to next closing brace or to comma */
2942 static const char *next_brace_sub(const char *cp)
2943 {
2944         unsigned depth = 0;
2945         cp++;
2946         while (*cp != '\0') {
2947                 if (*cp == '\\') {
2948                         if (*++cp == '\0')
2949                                 break;
2950                         cp++;
2951                         continue;
2952                 }
2953                 if ((*cp == '}' && depth-- == 0) || (*cp == ',' && depth == 0))
2954                         break;
2955                 if (*cp++ == '{')
2956                         depth++;
2957         }
2958
2959         return *cp != '\0' ? cp : NULL;
2960 }
2961 /* Recursive brace globber. Note: may garble pattern[]. */
2962 static int glob_brace(char *pattern, o_string *o, int n)
2963 {
2964         char *new_pattern_buf;
2965         const char *begin;
2966         const char *next;
2967         const char *rest;
2968         const char *p;
2969         size_t rest_len;
2970
2971         debug_printf_glob("glob_brace('%s')\n", pattern);
2972
2973         begin = pattern;
2974         while (1) {
2975                 if (*begin == '\0')
2976                         goto simple_glob;
2977                 if (*begin == '{') {
2978                         /* Find the first sub-pattern and at the same time
2979                          * find the rest after the closing brace */
2980                         next = next_brace_sub(begin);
2981                         if (next == NULL) {
2982                                 /* An illegal expression */
2983                                 goto simple_glob;
2984                         }
2985                         if (*next == '}') {
2986                                 /* "{abc}" with no commas - illegal
2987                                  * brace expr, disregard and skip it */
2988                                 begin = next + 1;
2989                                 continue;
2990                         }
2991                         break;
2992                 }
2993                 if (*begin == '\\' && begin[1] != '\0')
2994                         begin++;
2995                 begin++;
2996         }
2997         debug_printf_glob("begin:%s\n", begin);
2998         debug_printf_glob("next:%s\n", next);
2999
3000         /* Now find the end of the whole brace expression */
3001         rest = next;
3002         while (*rest != '}') {
3003                 rest = next_brace_sub(rest);
3004                 if (rest == NULL) {
3005                         /* An illegal expression */
3006                         goto simple_glob;
3007                 }
3008                 debug_printf_glob("rest:%s\n", rest);
3009         }
3010         rest_len = strlen(++rest) + 1;
3011
3012         /* We are sure the brace expression is well-formed */
3013
3014         /* Allocate working buffer large enough for our work */
3015         new_pattern_buf = xmalloc(strlen(pattern));
3016
3017         /* We have a brace expression.  BEGIN points to the opening {,
3018          * NEXT points past the terminator of the first element, and REST
3019          * points past the final }.  We will accumulate result names from
3020          * recursive runs for each brace alternative in the buffer using
3021          * GLOB_APPEND.  */
3022
3023         p = begin + 1;
3024         while (1) {
3025                 /* Construct the new glob expression */
3026                 memcpy(
3027                         mempcpy(
3028                                 mempcpy(new_pattern_buf,
3029                                         /* We know the prefix for all sub-patterns */
3030                                         pattern, begin - pattern),
3031                                 p, next - p),
3032                         rest, rest_len);
3033
3034                 /* Note: glob_brace() may garble new_pattern_buf[].
3035                  * That's why we re-copy prefix every time (1st memcpy above).
3036                  */
3037                 n = glob_brace(new_pattern_buf, o, n);
3038                 if (*next == '}') {
3039                         /* We saw the last entry */
3040                         break;
3041                 }
3042                 p = next + 1;
3043                 next = next_brace_sub(next);
3044         }
3045         free(new_pattern_buf);
3046         return n;
3047
3048  simple_glob:
3049         {
3050                 int gr;
3051                 glob_t globdata;
3052
3053                 memset(&globdata, 0, sizeof(globdata));
3054                 gr = glob(pattern, 0, NULL, &globdata);
3055                 debug_printf_glob("glob('%s'):%d\n", pattern, gr);
3056                 if (gr != 0) {
3057                         if (gr == GLOB_NOMATCH) {
3058                                 globfree(&globdata);
3059                                 /* NB: garbles parameter */
3060                                 unbackslash(pattern);
3061                                 o_addstr_with_NUL(o, pattern);
3062                                 debug_printf_glob("glob pattern '%s' is literal\n", pattern);
3063                                 return o_save_ptr_helper(o, n);
3064                         }
3065                         if (gr == GLOB_NOSPACE)
3066                                 bb_error_msg_and_die(bb_msg_memory_exhausted);
3067                         /* GLOB_ABORTED? Only happens with GLOB_ERR flag,
3068                          * but we didn't specify it. Paranoia again. */
3069                         bb_error_msg_and_die("glob error %d on '%s'", gr, pattern);
3070                 }
3071                 if (globdata.gl_pathv && globdata.gl_pathv[0]) {
3072                         char **argv = globdata.gl_pathv;
3073                         while (1) {
3074                                 o_addstr_with_NUL(o, *argv);
3075                                 n = o_save_ptr_helper(o, n);
3076                                 argv++;
3077                                 if (!*argv)
3078                                         break;
3079                         }
3080                 }
3081                 globfree(&globdata);
3082         }
3083         return n;
3084 }
3085 /* Performs globbing on last list[],
3086  * saving each result as a new list[].
3087  */
3088 static int perform_glob(o_string *o, int n)
3089 {
3090         char *pattern, *copy;
3091
3092         debug_printf_glob("start perform_glob: n:%d o->data:%p\n", n, o->data);
3093         if (!o->data)
3094                 return o_save_ptr_helper(o, n);
3095         pattern = o->data + o_get_last_ptr(o, n);
3096         debug_printf_glob("glob pattern '%s'\n", pattern);
3097         if (!glob_needed(pattern)) {
3098                 /* unbackslash last string in o in place, fix length */
3099                 o->length = unbackslash(pattern) - o->data;
3100                 debug_printf_glob("glob pattern '%s' is literal\n", pattern);
3101                 return o_save_ptr_helper(o, n);
3102         }
3103
3104         copy = xstrdup(pattern);
3105         /* "forget" pattern in o */
3106         o->length = pattern - o->data;
3107         n = glob_brace(copy, o, n);
3108         free(copy);
3109         if (DEBUG_GLOB)
3110                 debug_print_list("perform_glob returning", o, n);
3111         return n;
3112 }
3113
3114 #else /* !HUSH_BRACE_EXPANSION */
3115
3116 /* Helper */
3117 static int glob_needed(const char *s)
3118 {
3119         while (*s) {
3120                 if (*s == '\\') {
3121                         if (!s[1])
3122                                 return 0;
3123                         s += 2;
3124                         continue;
3125                 }
3126                 if (*s == '*' || *s == '[' || *s == '?')
3127                         return 1;
3128                 s++;
3129         }
3130         return 0;
3131 }
3132 /* Performs globbing on last list[],
3133  * saving each result as a new list[].
3134  */
3135 static int perform_glob(o_string *o, int n)
3136 {
3137         glob_t globdata;
3138         int gr;
3139         char *pattern;
3140
3141         debug_printf_glob("start perform_glob: n:%d o->data:%p\n", n, o->data);
3142         if (!o->data)
3143                 return o_save_ptr_helper(o, n);
3144         pattern = o->data + o_get_last_ptr(o, n);
3145         debug_printf_glob("glob pattern '%s'\n", pattern);
3146         if (!glob_needed(pattern)) {
3147  literal:
3148                 /* unbackslash last string in o in place, fix length */
3149                 o->length = unbackslash(pattern) - o->data;
3150                 debug_printf_glob("glob pattern '%s' is literal\n", pattern);
3151                 return o_save_ptr_helper(o, n);
3152         }
3153
3154         memset(&globdata, 0, sizeof(globdata));
3155         /* Can't use GLOB_NOCHECK: it does not unescape the string.
3156          * If we glob "*.\*" and don't find anything, we need
3157          * to fall back to using literal "*.*", but GLOB_NOCHECK
3158          * will return "*.\*"!
3159          */
3160         gr = glob(pattern, 0, NULL, &globdata);
3161         debug_printf_glob("glob('%s'):%d\n", pattern, gr);
3162         if (gr != 0) {
3163                 if (gr == GLOB_NOMATCH) {
3164                         globfree(&globdata);
3165                         goto literal;
3166                 }
3167                 if (gr == GLOB_NOSPACE)
3168                         bb_error_msg_and_die(bb_msg_memory_exhausted);
3169                 /* GLOB_ABORTED? Only happens with GLOB_ERR flag,
3170                  * but we didn't specify it. Paranoia again. */
3171                 bb_error_msg_and_die("glob error %d on '%s'", gr, pattern);
3172         }
3173         if (globdata.gl_pathv && globdata.gl_pathv[0]) {
3174                 char **argv = globdata.gl_pathv;
3175                 /* "forget" pattern in o */
3176                 o->length = pattern - o->data;
3177                 while (1) {
3178                         o_addstr_with_NUL(o, *argv);
3179                         n = o_save_ptr_helper(o, n);
3180                         argv++;
3181                         if (!*argv)
3182                                 break;
3183                 }
3184         }
3185         globfree(&globdata);
3186         if (DEBUG_GLOB)
3187                 debug_print_list("perform_glob returning", o, n);
3188         return n;
3189 }
3190
3191 #endif /* !HUSH_BRACE_EXPANSION */
3192
3193 /* If o->o_expflags & EXP_FLAG_GLOB, glob the string so far remembered.
3194  * Otherwise, just finish current list[] and start new */
3195 static int o_save_ptr(o_string *o, int n)
3196 {
3197         if (o->o_expflags & EXP_FLAG_GLOB) {
3198                 /* If o->has_empty_slot, list[n] was already globbed
3199                  * (if it was requested back then when it was filled)
3200                  * so don't do that again! */
3201                 if (!o->has_empty_slot)
3202                         return perform_glob(o, n); /* o_save_ptr_helper is inside */
3203         }
3204         return o_save_ptr_helper(o, n);
3205 }
3206
3207 /* "Please convert list[n] to real char* ptrs, and NULL terminate it." */
3208 static char **o_finalize_list(o_string *o, int n)
3209 {
3210         char **list;
3211         int string_start;
3212
3213         n = o_save_ptr(o, n); /* force growth for list[n] if necessary */
3214         if (DEBUG_EXPAND)
3215                 debug_print_list("finalized", o, n);
3216         debug_printf_expand("finalized n:%d\n", n);
3217         list = (char**)o->data;
3218         string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
3219         list[--n] = NULL;
3220         while (n) {
3221                 n--;
3222                 list[n] = o->data + (int)(uintptr_t)list[n] + string_start;
3223         }
3224         return list;
3225 }
3226
3227 static void free_pipe_list(struct pipe *pi);
3228
3229 /* Returns pi->next - next pipe in the list */
3230 static struct pipe *free_pipe(struct pipe *pi)
3231 {
3232         struct pipe *next;
3233         int i;
3234
3235         debug_printf_clean("free_pipe (pid %d)\n", getpid());
3236         for (i = 0; i < pi->num_cmds; i++) {
3237                 struct command *command;
3238                 struct redir_struct *r, *rnext;
3239
3240                 command = &pi->cmds[i];
3241                 debug_printf_clean("  command %d:\n", i);
3242                 if (command->argv) {
3243                         if (DEBUG_CLEAN) {
3244                                 int a;
3245                                 char **p;
3246                                 for (a = 0, p = command->argv; *p; a++, p++) {
3247                                         debug_printf_clean("   argv[%d] = %s\n", a, *p);
3248                                 }
3249                         }
3250                         free_strings(command->argv);
3251                         //command->argv = NULL;
3252                 }
3253                 /* not "else if": on syntax error, we may have both! */
3254                 if (command->group) {
3255                         debug_printf_clean("   begin group (cmd_type:%d)\n",
3256                                         command->cmd_type);
3257                         free_pipe_list(command->group);
3258                         debug_printf_clean("   end group\n");
3259                         //command->group = NULL;
3260                 }
3261                 /* else is crucial here.
3262                  * If group != NULL, child_func is meaningless */
3263 #if ENABLE_HUSH_FUNCTIONS
3264                 else if (command->child_func) {
3265                         debug_printf_exec("cmd %p releases child func at %p\n", command, command->child_func);
3266                         command->child_func->parent_cmd = NULL;
3267                 }
3268 #endif
3269 #if !BB_MMU
3270                 free(command->group_as_string);
3271                 //command->group_as_string = NULL;
3272 #endif
3273                 for (r = command->redirects; r; r = rnext) {
3274                         debug_printf_clean("   redirect %d%s",
3275                                         r->rd_fd, redir_table[r->rd_type].descrip);
3276                         /* guard against the case >$FOO, where foo is unset or blank */
3277                         if (r->rd_filename) {
3278                                 debug_printf_clean(" fname:'%s'\n", r->rd_filename);
3279                                 free(r->rd_filename);
3280                                 //r->rd_filename = NULL;
3281                         }
3282                         debug_printf_clean(" rd_dup:%d\n", r->rd_dup);
3283                         rnext = r->next;
3284                         free(r);
3285                 }
3286                 //command->redirects = NULL;
3287         }
3288         free(pi->cmds);   /* children are an array, they get freed all at once */
3289         //pi->cmds = NULL;
3290 #if ENABLE_HUSH_JOB
3291         free(pi->cmdtext);
3292         //pi->cmdtext = NULL;
3293 #endif
3294
3295         next = pi->next;
3296         free(pi);
3297         return next;
3298 }
3299
3300 static void free_pipe_list(struct pipe *pi)
3301 {
3302         while (pi) {
3303 #if HAS_KEYWORDS
3304                 debug_printf_clean("pipe reserved word %d\n", pi->res_word);
3305 #endif
3306                 debug_printf_clean("pipe followup code %d\n", pi->followup);
3307                 pi = free_pipe(pi);
3308         }
3309 }
3310
3311
3312 /*** Parsing routines ***/
3313
3314 #ifndef debug_print_tree
3315 static void debug_print_tree(struct pipe *pi, int lvl)
3316 {
3317         static const char *const PIPE[] = {
3318                 [PIPE_SEQ] = "SEQ",
3319                 [PIPE_AND] = "AND",
3320                 [PIPE_OR ] = "OR" ,
3321                 [PIPE_BG ] = "BG" ,
3322         };
3323         static const char *RES[] = {
3324                 [RES_NONE ] = "NONE" ,
3325 # if ENABLE_HUSH_IF
3326                 [RES_IF   ] = "IF"   ,
3327                 [RES_THEN ] = "THEN" ,
3328                 [RES_ELIF ] = "ELIF" ,
3329                 [RES_ELSE ] = "ELSE" ,
3330                 [RES_FI   ] = "FI"   ,
3331 # endif
3332 # if ENABLE_HUSH_LOOPS
3333                 [RES_FOR  ] = "FOR"  ,
3334                 [RES_WHILE] = "WHILE",
3335                 [RES_UNTIL] = "UNTIL",
3336                 [RES_DO   ] = "DO"   ,
3337                 [RES_DONE ] = "DONE" ,
3338 # endif
3339 # if ENABLE_HUSH_LOOPS || ENABLE_HUSH_CASE
3340                 [RES_IN   ] = "IN"   ,
3341 # endif
3342 # if ENABLE_HUSH_CASE
3343                 [RES_CASE ] = "CASE" ,
3344                 [RES_CASE_IN ] = "CASE_IN" ,
3345                 [RES_MATCH] = "MATCH",
3346                 [RES_CASE_BODY] = "CASE_BODY",
3347                 [RES_ESAC ] = "ESAC" ,
3348 # endif
3349                 [RES_XXXX ] = "XXXX" ,
3350                 [RES_SNTX ] = "SNTX" ,
3351         };
3352         static const char *const CMDTYPE[] = {
3353                 "{}",
3354                 "()",
3355                 "[noglob]",
3356 # if ENABLE_HUSH_FUNCTIONS
3357                 "func()",
3358 # endif
3359         };
3360
3361         int pin, prn;
3362
3363         pin = 0;
3364         while (pi) {
3365                 fdprintf(2, "%*spipe %d res_word=%s followup=%d %s\n", lvl*2, "",
3366                                 pin, RES[pi->res_word], pi->followup, PIPE[pi->followup]);
3367                 prn = 0;
3368                 while (prn < pi->num_cmds) {
3369                         struct command *command = &pi->cmds[prn];
3370                         char **argv = command->argv;
3371
3372                         fdprintf(2, "%*s cmd %d assignment_cnt:%d",
3373                                         lvl*2, "", prn,
3374                                         command->assignment_cnt);
3375                         if (command->group) {
3376                                 fdprintf(2, " group %s: (argv=%p)%s%s\n",
3377                                                 CMDTYPE[command->cmd_type],
3378                                                 argv
3379 # if !BB_MMU
3380                                                 , " group_as_string:", command->group_as_string
3381 # else
3382                                                 , "", ""
3383 # endif
3384                                 );
3385                                 debug_print_tree(command->group, lvl+1);
3386                                 prn++;
3387                                 continue;
3388                         }
3389                         if (argv) while (*argv) {
3390                                 fdprintf(2, " '%s'", *argv);
3391                                 argv++;
3392                         }
3393                         fdprintf(2, "\n");
3394                         prn++;
3395                 }
3396                 pi = pi->next;
3397                 pin++;
3398         }
3399 }
3400 #endif /* debug_print_tree */
3401
3402 static struct pipe *new_pipe(void)
3403 {
3404         struct pipe *pi;
3405         pi = xzalloc(sizeof(struct pipe));
3406         /*pi->res_word = RES_NONE; - RES_NONE is 0 anyway */
3407         return pi;
3408 }
3409
3410 /* Command (member of a pipe) is complete, or we start a new pipe
3411  * if ctx->command is NULL.
3412  * No errors possible here.
3413  */
3414 static int done_command(struct parse_context *ctx)
3415 {
3416         /* The command is really already in the pipe structure, so
3417          * advance the pipe counter and make a new, null command. */
3418         struct pipe *pi = ctx->pipe;
3419         struct command *command = ctx->command;
3420
3421 #if 0   /* Instead we emit error message at run time */
3422         if (ctx->pending_redirect) {
3423                 /* For example, "cmd >" (no filename to redirect to) */
3424                 syntax_error("invalid redirect");
3425                 ctx->pending_redirect = NULL;
3426         }
3427 #endif
3428
3429         if (command) {
3430                 if (IS_NULL_CMD(command)) {
3431                         debug_printf_parse("done_command: skipping null cmd, num_cmds=%d\n", pi->num_cmds);
3432                         goto clear_and_ret;
3433                 }
3434                 pi->num_cmds++;
3435                 debug_printf_parse("done_command: ++num_cmds=%d\n", pi->num_cmds);
3436                 //debug_print_tree(ctx->list_head, 20);
3437         } else {
3438                 debug_printf_parse("done_command: initializing, num_cmds=%d\n", pi->num_cmds);
3439         }
3440
3441         /* Only real trickiness here is that the uncommitted
3442          * command structure is not counted in pi->num_cmds. */
3443         pi->cmds = xrealloc(pi->cmds, sizeof(*pi->cmds) * (pi->num_cmds+1));
3444         ctx->command = command = &pi->cmds[pi->num_cmds];
3445  clear_and_ret:
3446         memset(command, 0, sizeof(*command));
3447         return pi->num_cmds; /* used only for 0/nonzero check */
3448 }
3449
3450 static void done_pipe(struct parse_context *ctx, pipe_style type)
3451 {
3452         int not_null;
3453
3454         debug_printf_parse("done_pipe entered, followup %d\n", type);
3455         /* Close previous command */
3456         not_null = done_command(ctx);
3457 #if HAS_KEYWORDS
3458         ctx->pipe->pi_inverted = ctx->ctx_inverted;
3459         ctx->ctx_inverted = 0;
3460         ctx->pipe->res_word = ctx->ctx_res_w;
3461 #endif
3462         if (type == PIPE_BG && ctx->list_head != ctx->pipe) {
3463                 /* Necessary since && and || have precedence over &:
3464                  * "cmd1 && cmd2 &" must spawn both cmds, not only cmd2,
3465                  * in a backgrounded subshell.
3466                  */
3467                 struct pipe *pi;
3468                 struct command *command;
3469
3470                 /* Is this actually this construct, all pipes end with && or ||? */
3471                 pi = ctx->list_head;
3472                 while (pi != ctx->pipe) {
3473                         if (pi->followup != PIPE_AND && pi->followup != PIPE_OR)
3474                                 goto no_conv;
3475                         pi = pi->next;
3476                 }
3477
3478                 debug_printf_parse("BG with more than one pipe, converting to { p1 &&...pN; } &\n");
3479                 pi->followup = PIPE_SEQ; /* close pN _not_ with "&"! */
3480                 pi = xzalloc(sizeof(*pi));
3481                 pi->followup = PIPE_BG;
3482                 pi->num_cmds = 1;
3483                 pi->cmds = xzalloc(sizeof(pi->cmds[0]));
3484                 command = &pi->cmds[0];
3485                 if (CMD_NORMAL != 0) /* "if xzalloc didn't do that already" */
3486                         command->cmd_type = CMD_NORMAL;
3487                 command->group = ctx->list_head;
3488 #if !BB_MMU
3489                 command->group_as_string = xstrndup(
3490                             ctx->as_string.data,
3491                             ctx->as_string.length - 1 /* do not copy last char, "&" */
3492                 );
3493 #endif
3494                 /* Replace all pipes in ctx with one newly created */
3495                 ctx->list_head = ctx->pipe = pi;
3496         } else {
3497  no_conv:
3498                 ctx->pipe->followup = type;
3499         }
3500
3501         /* Without this check, even just <enter> on command line generates
3502          * tree of three NOPs (!). Which is harmless but annoying.
3503          * IOW: it is safe to do it unconditionally. */
3504         if (not_null
3505 #if ENABLE_HUSH_IF
3506          || ctx->ctx_res_w == RES_FI
3507 #endif
3508 #if ENABLE_HUSH_LOOPS
3509          || ctx->ctx_res_w == RES_DONE
3510          || ctx->ctx_res_w == RES_FOR
3511          || ctx->ctx_res_w == RES_IN
3512 #endif
3513 #if ENABLE_HUSH_CASE
3514          || ctx->ctx_res_w == RES_ESAC
3515 #endif
3516         ) {
3517                 struct pipe *new_p;
3518                 debug_printf_parse("done_pipe: adding new pipe: "
3519                                 "not_null:%d ctx->ctx_res_w:%d\n",
3520                                 not_null, ctx->ctx_res_w);
3521                 new_p = new_pipe();
3522                 ctx->pipe->next = new_p;
3523                 ctx->pipe = new_p;
3524                 /* RES_THEN, RES_DO etc are "sticky" -
3525                  * they remain set for pipes inside if/while.
3526                  * This is used to control execution.
3527                  * RES_FOR and RES_IN are NOT sticky (needed to support
3528                  * cases where variable or value happens to match a keyword):
3529                  */
3530 #if ENABLE_HUSH_LOOPS
3531                 if (ctx->ctx_res_w == RES_FOR
3532                  || ctx->ctx_res_w == RES_IN)
3533                         ctx->ctx_res_w = RES_NONE;
3534 #endif
3535 #if ENABLE_HUSH_CASE
3536                 if (ctx->ctx_res_w == RES_MATCH)
3537                         ctx->ctx_res_w = RES_CASE_BODY;
3538                 if (ctx->ctx_res_w == RES_CASE)
3539                         ctx->ctx_res_w = RES_CASE_IN;
3540 #endif
3541                 ctx->command = NULL; /* trick done_command below */
3542                 /* Create the memory for command, roughly:
3543                  * ctx->pipe->cmds = new struct command;
3544                  * ctx->command = &ctx->pipe->cmds[0];
3545                  */
3546                 done_command(ctx);
3547                 //debug_print_tree(ctx->list_head, 10);
3548         }
3549         debug_printf_parse("done_pipe return\n");
3550 }
3551
3552 static void initialize_context(struct parse_context *ctx)
3553 {
3554         memset(ctx, 0, sizeof(*ctx));
3555         ctx->pipe = ctx->list_head = new_pipe();
3556         /* Create the memory for command, roughly:
3557          * ctx->pipe->cmds = new struct command;
3558          * ctx->command = &ctx->pipe->cmds[0];
3559          */
3560         done_command(ctx);
3561 }
3562
3563 /* If a reserved word is found and processed, parse context is modified
3564  * and 1 is returned.
3565  */
3566 #if HAS_KEYWORDS
3567 struct reserved_combo {
3568         char literal[6];
3569         unsigned char res;
3570         unsigned char assignment_flag;
3571         int flag;
3572 };
3573 enum {
3574         FLAG_END   = (1 << RES_NONE ),
3575 # if ENABLE_HUSH_IF
3576         FLAG_IF    = (1 << RES_IF   ),
3577         FLAG_THEN  = (1 << RES_THEN ),
3578         FLAG_ELIF  = (1 << RES_ELIF ),
3579         FLAG_ELSE  = (1 << RES_ELSE ),
3580         FLAG_FI    = (1 << RES_FI   ),
3581 # endif
3582 # if ENABLE_HUSH_LOOPS
3583         FLAG_FOR   = (1 << RES_FOR  ),
3584         FLAG_WHILE = (1 << RES_WHILE),
3585         FLAG_UNTIL = (1 << RES_UNTIL),
3586         FLAG_DO    = (1 << RES_DO   ),
3587         FLAG_DONE  = (1 << RES_DONE ),
3588         FLAG_IN    = (1 << RES_IN   ),
3589 # endif
3590 # if ENABLE_HUSH_CASE
3591         FLAG_MATCH = (1 << RES_MATCH),
3592         FLAG_ESAC  = (1 << RES_ESAC ),
3593 # endif
3594         FLAG_START = (1 << RES_XXXX ),
3595 };
3596
3597 static const struct reserved_combo* match_reserved_word(o_string *word)
3598 {
3599         /* Mostly a list of accepted follow-up reserved words.
3600          * FLAG_END means we are done with the sequence, and are ready
3601          * to turn the compound list into a command.
3602          * FLAG_START means the word must start a new compound list.
3603          */
3604         static const struct reserved_combo reserved_list[] = {
3605 # if ENABLE_HUSH_IF
3606                 { "!",     RES_NONE,  NOT_ASSIGNMENT  , 0 },
3607                 { "if",    RES_IF,    MAYBE_ASSIGNMENT, FLAG_THEN | FLAG_START },
3608                 { "then",  RES_THEN,  MAYBE_ASSIGNMENT, FLAG_ELIF | FLAG_ELSE | FLAG_FI },
3609                 { "elif",  RES_ELIF,  MAYBE_ASSIGNMENT, FLAG_THEN },
3610                 { "else",  RES_ELSE,  MAYBE_ASSIGNMENT, FLAG_FI   },
3611                 { "fi",    RES_FI,    NOT_ASSIGNMENT  , FLAG_END  },
3612 # endif
3613 # if ENABLE_HUSH_LOOPS
3614                 { "for",   RES_FOR,   NOT_ASSIGNMENT  , FLAG_IN | FLAG_DO | FLAG_START },
3615                 { "while", RES_WHILE, MAYBE_ASSIGNMENT, FLAG_DO | FLAG_START },
3616                 { "until", RES_UNTIL, MAYBE_ASSIGNMENT, FLAG_DO | FLAG_START },
3617                 { "in",    RES_IN,    NOT_ASSIGNMENT  , FLAG_DO   },
3618                 { "do",    RES_DO,    MAYBE_ASSIGNMENT, FLAG_DONE },
3619                 { "done",  RES_DONE,  NOT_ASSIGNMENT  , FLAG_END  },
3620 # endif
3621 # if ENABLE_HUSH_CASE
3622                 { "case",  RES_CASE,  NOT_ASSIGNMENT  , FLAG_MATCH | FLAG_START },
3623                 { "esac",  RES_ESAC,  NOT_ASSIGNMENT  , FLAG_END  },
3624 # endif
3625         };
3626         const struct reserved_combo *r;
3627
3628         for (r = reserved_list; r < reserved_list + ARRAY_SIZE(reserved_list); r++) {
3629                 if (strcmp(word->data, r->literal) == 0)
3630                         return r;
3631         }
3632         return NULL;
3633 }
3634 /* Return 0: not a keyword, 1: keyword
3635  */
3636 static int reserved_word(o_string *word, struct parse_context *ctx)
3637 {
3638 # if ENABLE_HUSH_CASE
3639         static const struct reserved_combo reserved_match = {
3640                 "",        RES_MATCH, NOT_ASSIGNMENT , FLAG_MATCH | FLAG_ESAC
3641         };
3642 # endif
3643         const struct reserved_combo *r;
3644
3645         if (word->has_quoted_part)
3646                 return 0;
3647         r = match_reserved_word(word);
3648         if (!r)
3649                 return 0;
3650
3651         debug_printf("found reserved word %s, res %d\n", r->literal, r->res);
3652 # if ENABLE_HUSH_CASE
3653         if (r->res == RES_IN && ctx->ctx_res_w == RES_CASE_IN) {
3654                 /* "case word IN ..." - IN part starts first MATCH part */
3655                 r = &reserved_match;
3656         } else
3657 # endif
3658         if (r->flag == 0) { /* '!' */
3659                 if (ctx->ctx_inverted) { /* bash doesn't accept '! ! true' */
3660                         syntax_error("! ! command");
3661                         ctx->ctx_res_w = RES_SNTX;
3662                 }
3663                 ctx->ctx_inverted = 1;
3664                 return 1;
3665         }
3666         if (r->flag & FLAG_START) {
3667                 struct parse_context *old;
3668
3669                 old = xmemdup(ctx, sizeof(*ctx));
3670                 debug_printf_parse("push stack %p\n", old);
3671                 initialize_context(ctx);
3672                 ctx->stack = old;
3673         } else if (/*ctx->ctx_res_w == RES_NONE ||*/ !(ctx->old_flag & (1 << r->res))) {
3674                 syntax_error_at(word->data);
3675                 ctx->ctx_res_w = RES_SNTX;
3676                 return 1;
3677         } else {
3678                 /* "{...} fi" is ok. "{...} if" is not
3679                  * Example:
3680                  * if { echo foo; } then { echo bar; } fi */
3681                 if (ctx->command->group)
3682                         done_pipe(ctx, PIPE_SEQ);
3683         }
3684
3685         ctx->ctx_res_w = r->res;
3686         ctx->old_flag = r->flag;
3687         word->o_assignment = r->assignment_flag;
3688         debug_printf_parse("word->o_assignment='%s'\n", assignment_flag[word->o_assignment]);
3689
3690         if (ctx->old_flag & FLAG_END) {
3691                 struct parse_context *old;
3692
3693                 done_pipe(ctx, PIPE_SEQ);
3694                 debug_printf_parse("pop stack %p\n", ctx->stack);
3695                 old = ctx->stack;
3696                 old->command->group = ctx->list_head;
3697                 old->command->cmd_type = CMD_NORMAL;
3698 # if !BB_MMU
3699                 /* At this point, the compound command's string is in
3700                  * ctx->as_string... except for the leading keyword!
3701                  * Consider this example: "echo a | if true; then echo a; fi"
3702                  * ctx->as_string will contain "true; then echo a; fi",
3703                  * with "if " remaining in old->as_string!
3704                  */
3705                 {
3706                         char *str;
3707                         int len = old->as_string.length;
3708                         /* Concatenate halves */
3709                         o_addstr(&old->as_string, ctx->as_string.data);
3710                         o_free_unsafe(&ctx->as_string);
3711                         /* Find where leading keyword starts in first half */
3712                         str = old->as_string.data + len;
3713                         if (str > old->as_string.data)
3714                                 str--; /* skip whitespace after keyword */
3715                         while (str > old->as_string.data && isalpha(str[-1]))
3716                                 str--;
3717                         /* Ugh, we're done with this horrid hack */
3718                         old->command->group_as_string = xstrdup(str);
3719                         debug_printf_parse("pop, remembering as:'%s'\n",
3720                                         old->command->group_as_string);
3721                 }
3722 # endif
3723                 *ctx = *old;   /* physical copy */
3724                 free(old);
3725         }
3726         return 1;
3727 }
3728 #endif /* HAS_KEYWORDS */
3729
3730 /* Word is complete, look at it and update parsing context.
3731  * Normal return is 0. Syntax errors return 1.
3732  * Note: on return, word is reset, but not o_free'd!
3733  */
3734 static int done_word(o_string *word, struct parse_context *ctx)
3735 {
3736         struct command *command = ctx->command;
3737
3738         debug_printf_parse("done_word entered: '%s' %p\n", word->data, command);
3739         if (word->length == 0 && !word->has_quoted_part) {
3740                 debug_printf_parse("done_word return 0: true null, ignored\n");
3741                 return 0;
3742         }
3743
3744         if (ctx->pending_redirect) {
3745                 /* We do not glob in e.g. >*.tmp case. bash seems to glob here
3746                  * only if run as "bash", not "sh" */
3747                 /* http://www.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html
3748                  * "2.7 Redirection
3749                  * ...the word that follows the redirection operator
3750                  * shall be subjected to tilde expansion, parameter expansion,
3751                  * command substitution, arithmetic expansion, and quote
3752                  * removal. Pathname expansion shall not be performed
3753                  * on the word by a non-interactive shell; an interactive
3754                  * shell may perform it, but shall do so only when
3755                  * the expansion would result in one word."
3756                  */
3757                 ctx->pending_redirect->rd_filename = xstrdup(word->data);
3758                 /* Cater for >\file case:
3759                  * >\a creates file a; >\\a, >"\a", >"\\a" create file \a
3760                  * Same with heredocs:
3761                  * for <<\H delim is H; <<\\H, <<"\H", <<"\\H" - \H
3762                  */
3763                 if (ctx->pending_redirect->rd_type == REDIRECT_HEREDOC) {
3764                         unbackslash(ctx->pending_redirect->rd_filename);
3765                         /* Is it <<"HEREDOC"? */
3766                         if (word->has_quoted_part) {
3767                                 ctx->pending_redirect->rd_dup |= HEREDOC_QUOTED;
3768                         }
3769                 }
3770                 debug_printf_parse("word stored in rd_filename: '%s'\n", word->data);
3771                 ctx->pending_redirect = NULL;
3772         } else {
3773 #if HAS_KEYWORDS
3774 # if ENABLE_HUSH_CASE
3775                 if (ctx->ctx_dsemicolon
3776                  && strcmp(word->data, "esac") != 0 /* not "... pattern) cmd;; esac" */
3777                 ) {
3778                         /* already done when ctx_dsemicolon was set to 1: */
3779                         /* ctx->ctx_res_w = RES_MATCH; */
3780                         ctx->ctx_dsemicolon = 0;
3781                 } else
3782 # endif
3783                 if (!command->argv /* if it's the first word... */
3784 # if ENABLE_HUSH_LOOPS
3785                  && ctx->ctx_res_w != RES_FOR /* ...not after FOR or IN */
3786                  && ctx->ctx_res_w != RES_IN
3787 # endif
3788 # if ENABLE_HUSH_CASE
3789                  && ctx->ctx_res_w != RES_CASE
3790 # endif
3791                 ) {
3792                         int reserved = reserved_word(word, ctx);
3793                         debug_printf_parse("checking for reserved-ness: %d\n", reserved);
3794                         if (reserved) {
3795                                 o_reset_to_empty_unquoted(word);
3796                                 debug_printf_parse("done_word return %d\n",
3797                                                 (ctx->ctx_res_w == RES_SNTX));
3798                                 return (ctx->ctx_res_w == RES_SNTX);
3799                         }
3800 # if BASH_TEST2
3801                         if (strcmp(word->data, "[[") == 0) {
3802                                 command->cmd_type = CMD_SINGLEWORD_NOGLOB;
3803                         }
3804                         /* fall through */
3805 # endif
3806                 }
3807 #endif
3808                 if (command->group) {
3809                         /* "{ echo foo; } echo bar" - bad */
3810                         syntax_error_at(word->data);
3811                         debug_printf_parse("done_word return 1: syntax error, "
3812                                         "groups and arglists don't mix\n");
3813                         return 1;
3814                 }
3815
3816                 /* If this word wasn't an assignment, next ones definitely
3817                  * can't be assignments. Even if they look like ones. */
3818                 if (word->o_assignment != DEFINITELY_ASSIGNMENT
3819                  && word->o_assignment != WORD_IS_KEYWORD
3820                 ) {
3821                         word->o_assignment = NOT_ASSIGNMENT;
3822                 } else {
3823                         if (word->o_assignment == DEFINITELY_ASSIGNMENT) {
3824                                 command->assignment_cnt++;
3825                                 debug_printf_parse("++assignment_cnt=%d\n", command->assignment_cnt);
3826                         }
3827                         debug_printf_parse("word->o_assignment was:'%s'\n", assignment_flag[word->o_assignment]);
3828                         word->o_assignment = MAYBE_ASSIGNMENT;
3829                 }
3830                 debug_printf_parse("word->o_assignment='%s'\n", assignment_flag[word->o_assignment]);
3831
3832                 if (word->has_quoted_part
3833                  /* optimization: and if it's ("" or '') or ($v... or `cmd`...): */
3834                  && (word->data[0] == '\0' || word->data[0] == SPECIAL_VAR_SYMBOL)
3835                  /* (otherwise it's known to be not empty and is already safe) */
3836                 ) {
3837                         /* exclude "$@" - it can expand to no word despite "" */
3838                         char *p = word->data;
3839                         while (p[0] == SPECIAL_VAR_SYMBOL
3840                             && (p[1] & 0x7f) == '@'
3841                             && p[2] == SPECIAL_VAR_SYMBOL
3842                         ) {
3843                                 p += 3;
3844                         }
3845                 }
3846                 command->argv = add_string_to_strings(command->argv, xstrdup(word->data));
3847                 debug_print_strings("word appended to argv", command->argv);
3848         }
3849
3850 #if ENABLE_HUSH_LOOPS
3851         if (ctx->ctx_res_w == RES_FOR) {
3852                 if (word->has_quoted_part
3853                  || !is_well_formed_var_name(command->argv[0], '\0')
3854                 ) {
3855                         /* bash says just "not a valid identifier" */
3856                         syntax_error("not a valid identifier in for");
3857                         return 1;
3858                 }
3859                 /* Force FOR to have just one word (variable name) */
3860                 /* NB: basically, this makes hush see "for v in ..."
3861                  * syntax as if it is "for v; in ...". FOR and IN become
3862                  * two pipe structs in parse tree. */
3863                 done_pipe(ctx, PIPE_SEQ);
3864         }
3865 #endif
3866 #if ENABLE_HUSH_CASE
3867         /* Force CASE to have just one word */
3868         if (ctx->ctx_res_w == RES_CASE) {
3869                 done_pipe(ctx, PIPE_SEQ);
3870         }
3871 #endif
3872
3873         o_reset_to_empty_unquoted(word);
3874
3875         debug_printf_parse("done_word return 0\n");
3876         return 0;
3877 }
3878
3879
3880 /* Peek ahead in the input to find out if we have a "&n" construct,
3881  * as in "2>&1", that represents duplicating a file descriptor.
3882  * Return:
3883  * REDIRFD_CLOSE if >&- "close fd" construct is seen,
3884  * REDIRFD_SYNTAX_ERR if syntax error,
3885  * REDIRFD_TO_FILE if no & was seen,
3886  * or the number found.
3887  */
3888 #if BB_MMU
3889 #define parse_redir_right_fd(as_string, input) \
3890         parse_redir_right_fd(input)
3891 #endif
3892 static int parse_redir_right_fd(o_string *as_string, struct in_str *input)
3893 {
3894         int ch, d, ok;
3895
3896         ch = i_peek(input);
3897         if (ch != '&')
3898                 return REDIRFD_TO_FILE;
3899
3900         ch = i_getch(input);  /* get the & */
3901         nommu_addchr(as_string, ch);
3902         ch = i_peek(input);
3903         if (ch == '-') {
3904                 ch = i_getch(input);
3905                 nommu_addchr(as_string, ch);
3906                 return REDIRFD_CLOSE;
3907         }
3908         d = 0;
3909         ok = 0;
3910         while (ch != EOF && isdigit(ch)) {
3911                 d = d*10 + (ch-'0');
3912                 ok = 1;
3913                 ch = i_getch(input);
3914                 nommu_addchr(as_string, ch);
3915                 ch = i_peek(input);
3916         }
3917         if (ok) return d;
3918
3919 //TODO: this is the place to catch ">&file" bashism (redirect both fd 1 and 2)
3920
3921         bb_error_msg("ambiguous redirect");
3922         return REDIRFD_SYNTAX_ERR;
3923 }
3924
3925 /* Return code is 0 normal, 1 if a syntax error is detected
3926  */
3927 static int parse_redirect(struct parse_context *ctx,
3928                 int fd,
3929                 redir_type style,
3930                 struct in_str *input)
3931 {
3932         struct command *command = ctx->command;
3933         struct redir_struct *redir;
3934         struct redir_struct **redirp;
3935         int dup_num;
3936
3937         dup_num = REDIRFD_TO_FILE;
3938         if (style != REDIRECT_HEREDOC) {
3939                 /* Check for a '>&1' type redirect */
3940                 dup_num = parse_redir_right_fd(&ctx->as_string, input);
3941                 if (dup_num == REDIRFD_SYNTAX_ERR)
3942                         return 1;
3943         } else {
3944                 int ch = i_peek(input);
3945                 dup_num = (ch == '-'); /* HEREDOC_SKIPTABS bit is 1 */
3946                 if (dup_num) { /* <<-... */
3947                         ch = i_getch(input);
3948                         nommu_addchr(&ctx->as_string, ch);
3949                         ch = i_peek(input);
3950                 }
3951         }
3952
3953         if (style == REDIRECT_OVERWRITE && dup_num == REDIRFD_TO_FILE) {
3954                 int ch = i_peek(input);
3955                 if (ch == '|') {
3956                         /* >|FILE redirect ("clobbering" >).
3957                          * Since we do not support "set -o noclobber" yet,
3958                          * >| and > are the same for now. Just eat |.
3959                          */
3960                         ch = i_getch(input);
3961                         nommu_addchr(&ctx->as_string, ch);
3962                 }
3963         }
3964
3965         /* Create a new redir_struct and append it to the linked list */
3966         redirp = &command->redirects;
3967         while ((redir = *redirp) != NULL) {
3968                 redirp = &(redir->next);
3969         }
3970         *redirp = redir = xzalloc(sizeof(*redir));
3971         /* redir->next = NULL; */
3972         /* redir->rd_filename = NULL; */
3973         redir->rd_type = style;
3974         redir->rd_fd = (fd == -1) ? redir_table[style].default_fd : fd;
3975
3976         debug_printf_parse("redirect type %d %s\n", redir->rd_fd,
3977                                 redir_table[style].descrip);
3978
3979         redir->rd_dup = dup_num;
3980         if (style != REDIRECT_HEREDOC && dup_num != REDIRFD_TO_FILE) {
3981                 /* Erik had a check here that the file descriptor in question
3982                  * is legit; I postpone that to "run time"
3983                  * A "-" representation of "close me" shows up as a -3 here */
3984                 debug_printf_parse("duplicating redirect '%d>&%d'\n",
3985                                 redir->rd_fd, redir->rd_dup);
3986         } else {
3987 #if 0           /* Instead we emit error message at run time */
3988                 if (ctx->pending_redirect) {
3989                         /* For example, "cmd > <file" */
3990                         syntax_error("invalid redirect");
3991                 }
3992 #endif
3993                 /* Set ctx->pending_redirect, so we know what to do at the
3994                  * end of the next parsed word. */
3995                 ctx->pending_redirect = redir;
3996         }
3997         return 0;
3998 }
3999
4000 /* If a redirect is immediately preceded by a number, that number is
4001  * supposed to tell which file descriptor to redirect.  This routine
4002  * looks for such preceding numbers.  In an ideal world this routine
4003  * needs to handle all the following classes of redirects...
4004  *     echo 2>foo     # redirects fd  2 to file "foo", nothing passed to echo
4005  *     echo 49>foo    # redirects fd 49 to file "foo", nothing passed to echo
4006  *     echo -2>foo    # redirects fd  1 to file "foo",    "-2" passed to echo
4007  *     echo 49x>foo   # redirects fd  1 to file "foo",   "49x" passed to echo
4008  *
4009  * http://www.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html
4010  * "2.7 Redirection
4011  * ... If n is quoted, the number shall not be recognized as part of
4012  * the redirection expression. For example:
4013  * echo \2>a
4014  * writes the character 2 into file a"
4015  * We are getting it right by setting ->has_quoted_part on any \<char>
4016  *
4017  * A -1 return means no valid number was found,
4018  * the caller should use the appropriate default for this redirection.
4019  */
4020 static int redirect_opt_num(o_string *o)
4021 {
4022         int num;
4023
4024         if (o->data == NULL)
4025                 return -1;
4026         num = bb_strtou(o->data, NULL, 10);
4027         if (errno || num < 0)
4028                 return -1;
4029         o_reset_to_empty_unquoted(o);
4030         return num;
4031 }
4032
4033 #if BB_MMU
4034 #define fetch_till_str(as_string, input, word, skip_tabs) \
4035         fetch_till_str(input, word, skip_tabs)
4036 #endif
4037 static char *fetch_till_str(o_string *as_string,
4038                 struct in_str *input,
4039                 const char *word,
4040                 int heredoc_flags)
4041 {
4042         o_string heredoc = NULL_O_STRING;
4043         unsigned past_EOL;
4044         int prev = 0; /* not \ */
4045         int ch;
4046
4047         goto jump_in;
4048
4049         while (1) {
4050                 ch = i_getch(input);
4051                 if (ch != EOF)
4052                         nommu_addchr(as_string, ch);
4053                 if (ch == '\n' || ch == EOF) {
4054  check_heredoc_end:
4055                         if ((heredoc_flags & HEREDOC_QUOTED) || prev != '\\') {
4056                                 if (strcmp(heredoc.data + past_EOL, word) == 0) {
4057                                         heredoc.data[past_EOL] = '\0';
4058                                         debug_printf_parse("parsed heredoc '%s'\n", heredoc.data);
4059                                         return heredoc.data;
4060                                 }
4061                                 if (ch == '\n') {
4062                                         /* This is a new line.
4063                                          * Remember position and backslash-escaping status.
4064                                          */
4065                                         o_addchr(&heredoc, ch);
4066                                         prev = ch;
4067  jump_in:
4068                                         past_EOL = heredoc.length;
4069                                         /* Get 1st char of next line, possibly skipping leading tabs */
4070                                         do {
4071                                                 ch = i_getch(input);
4072                                                 if (ch != EOF)
4073                                                         nommu_addchr(as_string, ch);
4074                                         } while ((heredoc_flags & HEREDOC_SKIPTABS) && ch == '\t');
4075                                         /* If this immediately ended the line,
4076                                          * go back to end-of-line checks.
4077                                          */
4078                                         if (ch == '\n')
4079                                                 goto check_heredoc_end;
4080                                 }
4081                         }
4082                 }
4083                 if (ch == EOF) {
4084                         o_free_unsafe(&heredoc);
4085                         return NULL;
4086                 }
4087                 o_addchr(&heredoc, ch);
4088                 nommu_addchr(as_string, ch);
4089                 if (prev == '\\' && ch == '\\')
4090                         /* Correctly handle foo\\<eol> (not a line cont.) */
4091                         prev = 0; /* not \ */
4092                 else
4093                         prev = ch;
4094         }
4095 }
4096
4097 /* Look at entire parse tree for not-yet-loaded REDIRECT_HEREDOCs
4098  * and load them all. There should be exactly heredoc_cnt of them.
4099  */
4100 static int fetch_heredocs(int heredoc_cnt, struct parse_context *ctx, struct in_str *input)
4101 {
4102         struct pipe *pi = ctx->list_head;
4103
4104         while (pi && heredoc_cnt) {
4105                 int i;
4106                 struct command *cmd = pi->cmds;
4107
4108                 debug_printf_parse("fetch_heredocs: num_cmds:%d cmd argv0:'%s'\n",
4109                                 pi->num_cmds,
4110                                 cmd->argv ? cmd->argv[0] : "NONE");
4111                 for (i = 0; i < pi->num_cmds; i++) {
4112                         struct redir_struct *redir = cmd->redirects;
4113
4114                         debug_printf_parse("fetch_heredocs: %d cmd argv0:'%s'\n",
4115                                         i, cmd->argv ? cmd->argv[0] : "NONE");
4116                         while (redir) {
4117                                 if (redir->rd_type == REDIRECT_HEREDOC) {
4118                                         char *p;
4119
4120                                         redir->rd_type = REDIRECT_HEREDOC2;
4121                                         /* redir->rd_dup is (ab)used to indicate <<- */
4122                                         p = fetch_till_str(&ctx->as_string, input,
4123                                                         redir->rd_filename, redir->rd_dup);
4124                                         if (!p) {
4125                                                 syntax_error("unexpected EOF in here document");
4126                                                 return 1;
4127                                         }
4128                                         free(redir->rd_filename);
4129                                         redir->rd_filename = p;
4130                                         heredoc_cnt--;
4131                                 }
4132                                 redir = redir->next;
4133                         }
4134                         cmd++;
4135                 }
4136                 pi = pi->next;
4137         }
4138 #if 0
4139         /* Should be 0. If it isn't, it's a parse error */
4140         if (heredoc_cnt)
4141                 bb_error_msg_and_die("heredoc BUG 2");
4142 #endif
4143         return 0;
4144 }
4145
4146
4147 static int run_list(struct pipe *pi);
4148 #if BB_MMU
4149 #define parse_stream(pstring, input, end_trigger) \
4150         parse_stream(input, end_trigger)
4151 #endif
4152 static struct pipe *parse_stream(char **pstring,
4153                 struct in_str *input,
4154                 int end_trigger);
4155
4156
4157 #if !ENABLE_HUSH_FUNCTIONS
4158 #define parse_group(dest, ctx, input, ch) \
4159         parse_group(ctx, input, ch)
4160 #endif
4161 static int parse_group(o_string *dest, struct parse_context *ctx,
4162         struct in_str *input, int ch)
4163 {
4164         /* dest contains characters seen prior to ( or {.
4165          * Typically it's empty, but for function defs,
4166          * it contains function name (without '()'). */
4167         struct pipe *pipe_list;
4168         int endch;
4169         struct command *command = ctx->command;
4170
4171         debug_printf_parse("parse_group entered\n");
4172 #if ENABLE_HUSH_FUNCTIONS
4173         if (ch == '(' && !dest->has_quoted_part) {
4174                 if (dest->length)
4175                         if (done_word(dest, ctx))
4176                                 return 1;
4177                 if (!command->argv)
4178                         goto skip; /* (... */
4179                 if (command->argv[1]) { /* word word ... (... */
4180                         syntax_error_unexpected_ch('(');
4181                         return 1;
4182                 }
4183                 /* it is "word(..." or "word (..." */
4184                 do
4185                         ch = i_getch(input);
4186                 while (ch == ' ' || ch == '\t');
4187                 if (ch != ')') {
4188                         syntax_error_unexpected_ch(ch);
4189                         return 1;
4190                 }
4191                 nommu_addchr(&ctx->as_string, ch);
4192                 do
4193                         ch = i_getch(input);
4194                 while (ch == ' ' || ch == '\t' || ch == '\n');
4195                 if (ch != '{') {
4196                         syntax_error_unexpected_ch(ch);
4197                         return 1;
4198                 }
4199                 nommu_addchr(&ctx->as_string, ch);
4200                 command->cmd_type = CMD_FUNCDEF;
4201                 goto skip;
4202         }
4203 #endif
4204
4205 #if 0 /* Prevented by caller */
4206         if (command->argv /* word [word]{... */
4207          || dest->length /* word{... */
4208          || dest->has_quoted_part /* ""{... */
4209         ) {
4210                 syntax_error(NULL);
4211                 debug_printf_parse("parse_group return 1: "
4212                         "syntax error, groups and arglists don't mix\n");
4213                 return 1;
4214         }
4215 #endif
4216
4217 #if ENABLE_HUSH_FUNCTIONS
4218  skip:
4219 #endif
4220         endch = '}';
4221         if (ch == '(') {
4222                 endch = ')';
4223                 command->cmd_type = CMD_SUBSHELL;
4224         } else {
4225                 /* bash does not allow "{echo...", requires whitespace */
4226                 ch = i_peek(input);
4227                 if (ch != ' ' && ch != '\t' && ch != '\n'
4228                  && ch != '('   /* but "{(..." is allowed (without whitespace) */
4229                 ) {
4230                         syntax_error_unexpected_ch(ch);
4231                         return 1;
4232                 }
4233                 if (ch != '(') {
4234                         ch = i_getch(input);
4235                         nommu_addchr(&ctx->as_string, ch);
4236                 }
4237         }
4238
4239         {
4240 #if BB_MMU
4241 # define as_string NULL
4242 #else
4243                 char *as_string = NULL;
4244 #endif
4245                 pipe_list = parse_stream(&as_string, input, endch);
4246 #if !BB_MMU
4247                 if (as_string)
4248                         o_addstr(&ctx->as_string, as_string);
4249 #endif
4250                 /* empty ()/{} or parse error? */
4251                 if (!pipe_list || pipe_list == ERR_PTR) {
4252                         /* parse_stream already emitted error msg */
4253                         if (!BB_MMU)
4254                                 free(as_string);
4255                         debug_printf_parse("parse_group return 1: "
4256                                 "parse_stream returned %p\n", pipe_list);
4257                         return 1;
4258                 }
4259                 command->group = pipe_list;
4260 #if !BB_MMU
4261                 as_string[strlen(as_string) - 1] = '\0'; /* plink ')' or '}' */
4262                 command->group_as_string = as_string;
4263                 debug_printf_parse("end of group, remembering as:'%s'\n",
4264                                 command->group_as_string);
4265 #endif
4266 #undef as_string
4267         }
4268         debug_printf_parse("parse_group return 0\n");
4269         return 0;
4270         /* command remains "open", available for possible redirects */
4271 }
4272
4273 static int i_getch_and_eat_bkslash_nl(struct in_str *input)
4274 {
4275         for (;;) {
4276                 int ch, ch2;
4277
4278                 ch = i_getch(input);
4279                 if (ch != '\\')
4280                         return ch;
4281                 ch2 = i_peek(input);
4282                 if (ch2 != '\n')
4283                         return ch;
4284                 /* backslash+newline, skip it */
4285                 i_getch(input);
4286         }
4287 }
4288
4289 static int i_peek_and_eat_bkslash_nl(struct in_str *input)
4290 {
4291         for (;;) {
4292                 int ch, ch2;
4293
4294                 ch = i_peek(input);
4295                 if (ch != '\\')
4296                         return ch;
4297                 ch2 = i_peek2(input);
4298                 if (ch2 != '\n')
4299                         return ch;
4300                 /* backslash+newline, skip it */
4301                 i_getch(input);
4302                 i_getch(input);
4303         }
4304 }
4305
4306 #if ENABLE_HUSH_TICK || ENABLE_FEATURE_SH_MATH || ENABLE_HUSH_DOLLAR_OPS
4307 /* Subroutines for copying $(...) and `...` things */
4308 static int add_till_backquote(o_string *dest, struct in_str *input, int in_dquote);
4309 /* '...' */
4310 static int add_till_single_quote(o_string *dest, struct in_str *input)
4311 {
4312         while (1) {
4313                 int ch = i_getch(input);
4314                 if (ch == EOF) {
4315                         syntax_error_unterm_ch('\'');
4316                         return 0;
4317                 }
4318                 if (ch == '\'')
4319                         return 1;
4320                 o_addchr(dest, ch);
4321         }
4322 }
4323 /* "...\"...`..`...." - do we need to handle "...$(..)..." too? */
4324 static int add_till_double_quote(o_string *dest, struct in_str *input)
4325 {
4326         while (1) {
4327                 int ch = i_getch(input);
4328                 if (ch == EOF) {
4329                         syntax_error_unterm_ch('"');
4330                         return 0;
4331                 }
4332                 if (ch == '"')
4333                         return 1;
4334                 if (ch == '\\') {  /* \x. Copy both chars. */
4335                         o_addchr(dest, ch);
4336                         ch = i_getch(input);
4337                 }
4338                 o_addchr(dest, ch);
4339                 if (ch == '`') {
4340                         if (!add_till_backquote(dest, input, /*in_dquote:*/ 1))
4341                                 return 0;
4342                         o_addchr(dest, ch);
4343                         continue;
4344                 }
4345                 //if (ch == '$') ...
4346         }
4347 }
4348 /* Process `cmd` - copy contents until "`" is seen. Complicated by
4349  * \` quoting.
4350  * "Within the backquoted style of command substitution, backslash
4351  * shall retain its literal meaning, except when followed by: '$', '`', or '\'.
4352  * The search for the matching backquote shall be satisfied by the first
4353  * backquote found without a preceding backslash; during this search,
4354  * if a non-escaped backquote is encountered within a shell comment,
4355  * a here-document, an embedded command substitution of the $(command)
4356  * form, or a quoted string, undefined results occur. A single-quoted
4357  * or double-quoted string that begins, but does not end, within the
4358  * "`...`" sequence produces undefined results."
4359  * Example                               Output
4360  * echo `echo '\'TEST\`echo ZZ\`BEST`    \TESTZZBEST
4361  */
4362 static int add_till_backquote(o_string *dest, struct in_str *input, int in_dquote)
4363 {
4364         while (1) {
4365                 int ch = i_getch(input);
4366                 if (ch == '`')
4367                         return 1;
4368                 if (ch == '\\') {
4369                         /* \x. Copy both unless it is \`, \$, \\ and maybe \" */
4370                         ch = i_getch(input);
4371                         if (ch != '`'
4372                          && ch != '$'
4373                          && ch != '\\'
4374                          && (!in_dquote || ch != '"')
4375                         ) {
4376                                 o_addchr(dest, '\\');
4377                         }
4378                 }
4379                 if (ch == EOF) {
4380                         syntax_error_unterm_ch('`');
4381                         return 0;
4382                 }
4383                 o_addchr(dest, ch);
4384         }
4385 }
4386 /* Process $(cmd) - copy contents until ")" is seen. Complicated by
4387  * quoting and nested ()s.
4388  * "With the $(command) style of command substitution, all characters
4389  * following the open parenthesis to the matching closing parenthesis
4390  * constitute the command. Any valid shell script can be used for command,
4391  * except a script consisting solely of redirections which produces
4392  * unspecified results."
4393  * Example                              Output
4394  * echo $(echo '(TEST)' BEST)           (TEST) BEST
4395  * echo $(echo 'TEST)' BEST)            TEST) BEST
4396  * echo $(echo \(\(TEST\) BEST)         ((TEST) BEST
4397  *
4398  * Also adapted to eat ${var%...} and $((...)) constructs, since ... part
4399  * can contain arbitrary constructs, just like $(cmd).
4400  * In bash compat mode, it needs to also be able to stop on ':' or '/'
4401  * for ${var:N[:M]} and ${var/P[/R]} parsing.
4402  */
4403 #define DOUBLE_CLOSE_CHAR_FLAG 0x80
4404 static int add_till_closing_bracket(o_string *dest, struct in_str *input, unsigned end_ch)
4405 {
4406         int ch;
4407         char dbl = end_ch & DOUBLE_CLOSE_CHAR_FLAG;
4408 # if BASH_SUBSTR || BASH_PATTERN_SUBST
4409         char end_char2 = end_ch >> 8;
4410 # endif
4411         end_ch &= (DOUBLE_CLOSE_CHAR_FLAG - 1);
4412
4413         while (1) {
4414                 ch = i_getch(input);
4415                 if (ch == EOF) {
4416                         syntax_error_unterm_ch(end_ch);
4417                         return 0;
4418                 }
4419                 if (ch == end_ch
4420 # if BASH_SUBSTR || BASH_PATTERN_SUBST
4421                         || ch == end_char2
4422 # endif
4423                 ) {
4424                         if (!dbl)
4425                                 break;
4426                         /* we look for closing )) of $((EXPR)) */
4427                         if (i_peek_and_eat_bkslash_nl(input) == end_ch) {
4428                                 i_getch(input); /* eat second ')' */
4429                                 break;
4430                         }
4431                 }
4432                 o_addchr(dest, ch);
4433                 if (ch == '(' || ch == '{') {
4434                         ch = (ch == '(' ? ')' : '}');
4435                         if (!add_till_closing_bracket(dest, input, ch))
4436                                 return 0;
4437                         o_addchr(dest, ch);
4438                         continue;
4439                 }
4440                 if (ch == '\'') {
4441                         if (!add_till_single_quote(dest, input))
4442                                 return 0;
4443                         o_addchr(dest, ch);
4444                         continue;
4445                 }
4446                 if (ch == '"') {
4447                         if (!add_till_double_quote(dest, input))
4448                                 return 0;
4449                         o_addchr(dest, ch);
4450                         continue;
4451                 }
4452                 if (ch == '`') {
4453                         if (!add_till_backquote(dest, input, /*in_dquote:*/ 0))
4454                                 return 0;
4455                         o_addchr(dest, ch);
4456                         continue;
4457                 }
4458                 if (ch == '\\') {
4459                         /* \x. Copy verbatim. Important for  \(, \) */
4460                         ch = i_getch(input);
4461                         if (ch == EOF) {
4462                                 syntax_error_unterm_ch(')');
4463                                 return 0;
4464                         }
4465 #if 0
4466                         if (ch == '\n') {
4467                                 /* "backslash+newline", ignore both */
4468                                 o_delchr(dest); /* undo insertion of '\' */
4469                                 continue;
4470                         }
4471 #endif
4472                         o_addchr(dest, ch);
4473                         continue;
4474                 }
4475         }
4476         return ch;
4477 }
4478 #endif /* ENABLE_HUSH_TICK || ENABLE_FEATURE_SH_MATH || ENABLE_HUSH_DOLLAR_OPS */
4479
4480 /* Return code: 0 for OK, 1 for syntax error */
4481 #if BB_MMU
4482 #define parse_dollar(as_string, dest, input, quote_mask) \
4483         parse_dollar(dest, input, quote_mask)
4484 #define as_string NULL
4485 #endif
4486 static int parse_dollar(o_string *as_string,
4487                 o_string *dest,
4488                 struct in_str *input, unsigned char quote_mask)
4489 {
4490         int ch = i_peek_and_eat_bkslash_nl(input);  /* first character after the $ */
4491
4492         debug_printf_parse("parse_dollar entered: ch='%c'\n", ch);
4493         if (isalpha(ch)) {
4494                 ch = i_getch(input);
4495                 nommu_addchr(as_string, ch);
4496  make_var:
4497                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4498                 while (1) {
4499                         debug_printf_parse(": '%c'\n", ch);
4500                         o_addchr(dest, ch | quote_mask);
4501                         quote_mask = 0;
4502                         ch = i_peek_and_eat_bkslash_nl(input);
4503                         if (!isalnum(ch) && ch != '_') {
4504                                 /* End of variable name reached */
4505                                 break;
4506                         }
4507                         ch = i_getch(input);
4508                         nommu_addchr(as_string, ch);
4509                 }
4510                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4511         } else if (isdigit(ch)) {
4512  make_one_char_var:
4513                 ch = i_getch(input);
4514                 nommu_addchr(as_string, ch);
4515                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4516                 debug_printf_parse(": '%c'\n", ch);
4517                 o_addchr(dest, ch | quote_mask);
4518                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4519         } else switch (ch) {
4520         case '$': /* pid */
4521         case '!': /* last bg pid */
4522         case '?': /* last exit code */
4523         case '#': /* number of args */
4524         case '*': /* args */
4525         case '@': /* args */
4526                 goto make_one_char_var;
4527         case '{': {
4528                 char len_single_ch;
4529
4530                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4531
4532                 ch = i_getch(input); /* eat '{' */
4533                 nommu_addchr(as_string, ch);
4534
4535                 ch = i_getch_and_eat_bkslash_nl(input); /* first char after '{' */
4536                 /* It should be ${?}, or ${#var},
4537                  * or even ${?+subst} - operator acting on a special variable,
4538                  * or the beginning of variable name.
4539                  */
4540                 if (ch == EOF
4541                  || (!strchr(_SPECIAL_VARS_STR, ch) && !isalnum(ch)) /* not one of those */
4542                 ) {
4543  bad_dollar_syntax:
4544                         syntax_error_unterm_str("${name}");
4545                         debug_printf_parse("parse_dollar return 0: unterminated ${name}\n");
4546                         return 0;
4547                 }
4548                 nommu_addchr(as_string, ch);
4549                 len_single_ch = ch;
4550                 ch |= quote_mask;
4551
4552                 /* It's possible to just call add_till_closing_bracket() at this point.
4553                  * However, this regresses some of our testsuite cases
4554                  * which check invalid constructs like ${%}.
4555                  * Oh well... let's check that the var name part is fine... */
4556
4557                 while (1) {
4558                         unsigned pos;
4559
4560                         o_addchr(dest, ch);
4561                         debug_printf_parse(": '%c'\n", ch);
4562
4563                         ch = i_getch(input);
4564                         nommu_addchr(as_string, ch);
4565                         if (ch == '}')
4566                                 break;
4567
4568                         if (!isalnum(ch) && ch != '_') {
4569                                 unsigned end_ch;
4570                                 unsigned char last_ch;
4571                                 /* handle parameter expansions
4572                                  * http://www.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html#tag_02_06_02
4573                                  */
4574                                 if (!strchr(VAR_SUBST_OPS, ch)) { /* ${var<bad_char>... */
4575                                         if (len_single_ch != '#'
4576                                         /*|| !strchr(SPECIAL_VARS_STR, ch) - disallow errors like ${#+} ? */
4577                                          || i_peek(input) != '}'
4578                                         ) {
4579                                                 goto bad_dollar_syntax;
4580                                         }
4581                                         /* else: it's "length of C" ${#C} op,
4582                                          * where C is a single char
4583                                          * special var name, e.g. ${#!}.
4584                                          */
4585                                 }
4586                                 /* Eat everything until closing '}' (or ':') */
4587                                 end_ch = '}';
4588                                 if (BASH_SUBSTR
4589                                  && ch == ':'
4590                                  && !strchr(MINUS_PLUS_EQUAL_QUESTION, i_peek(input))
4591                                 ) {
4592                                         /* It's ${var:N[:M]} thing */
4593                                         end_ch = '}' * 0x100 + ':';
4594                                 }
4595                                 if (BASH_PATTERN_SUBST
4596                                  && ch == '/'
4597                                 ) {
4598                                         /* It's ${var/[/]pattern[/repl]} thing */
4599                                         if (i_peek(input) == '/') { /* ${var//pattern[/repl]}? */
4600                                                 i_getch(input);
4601                                                 nommu_addchr(as_string, '/');
4602                                                 ch = '\\';
4603                                         }
4604                                         end_ch = '}' * 0x100 + '/';
4605                                 }
4606                                 o_addchr(dest, ch);
4607  again:
4608                                 if (!BB_MMU)
4609                                         pos = dest->length;
4610 #if ENABLE_HUSH_DOLLAR_OPS
4611                                 last_ch = add_till_closing_bracket(dest, input, end_ch);
4612                                 if (last_ch == 0) /* error? */
4613                                         return 0;
4614 #else
4615 #error Simple code to only allow ${var} is not implemented
4616 #endif
4617                                 if (as_string) {
4618                                         o_addstr(as_string, dest->data + pos);
4619                                         o_addchr(as_string, last_ch);
4620                                 }
4621
4622                                 if ((BASH_SUBSTR || BASH_PATTERN_SUBST)
4623                                          && (end_ch & 0xff00)
4624                                 ) {
4625                                         /* close the first block: */
4626                                         o_addchr(dest, SPECIAL_VAR_SYMBOL);
4627                                         /* while parsing N from ${var:N[:M]}
4628                                          * or pattern from ${var/[/]pattern[/repl]} */
4629                                         if ((end_ch & 0xff) == last_ch) {
4630                                                 /* got ':' or '/'- parse the rest */
4631                                                 end_ch = '}';
4632                                                 goto again;
4633                                         }
4634                                         /* got '}' */
4635                                         if (BASH_SUBSTR && end_ch == '}' * 0x100 + ':') {
4636                                                 /* it's ${var:N} - emulate :999999999 */
4637                                                 o_addstr(dest, "999999999");
4638                                         } /* else: it's ${var/[/]pattern} */
4639                                 }
4640                                 break;
4641                         }
4642                         len_single_ch = 0; /* it can't be ${#C} op */
4643                 }
4644                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4645                 break;
4646         }
4647 #if ENABLE_FEATURE_SH_MATH || ENABLE_HUSH_TICK
4648         case '(': {
4649                 unsigned pos;
4650
4651                 ch = i_getch(input);
4652                 nommu_addchr(as_string, ch);
4653 # if ENABLE_FEATURE_SH_MATH
4654                 if (i_peek_and_eat_bkslash_nl(input) == '(') {
4655                         ch = i_getch(input);
4656                         nommu_addchr(as_string, ch);
4657                         o_addchr(dest, SPECIAL_VAR_SYMBOL);
4658                         o_addchr(dest, /*quote_mask |*/ '+');
4659                         if (!BB_MMU)
4660                                 pos = dest->length;
4661                         if (!add_till_closing_bracket(dest, input, ')' | DOUBLE_CLOSE_CHAR_FLAG))
4662                                 return 0; /* error */
4663                         if (as_string) {
4664                                 o_addstr(as_string, dest->data + pos);
4665                                 o_addchr(as_string, ')');
4666                                 o_addchr(as_string, ')');
4667                         }
4668                         o_addchr(dest, SPECIAL_VAR_SYMBOL);
4669                         break;
4670                 }
4671 # endif
4672 # if ENABLE_HUSH_TICK
4673                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4674                 o_addchr(dest, quote_mask | '`');
4675                 if (!BB_MMU)
4676                         pos = dest->length;
4677                 if (!add_till_closing_bracket(dest, input, ')'))
4678                         return 0; /* error */
4679                 if (as_string) {
4680                         o_addstr(as_string, dest->data + pos);
4681                         o_addchr(as_string, ')');
4682                 }
4683                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4684 # endif
4685                 break;
4686         }
4687 #endif
4688         case '_':
4689                 ch = i_getch(input);
4690                 nommu_addchr(as_string, ch);
4691                 ch = i_peek_and_eat_bkslash_nl(input);
4692                 if (isalnum(ch)) { /* it's $_name or $_123 */
4693                         ch = '_';
4694                         goto make_var;
4695                 }
4696                 /* else: it's $_ */
4697         /* TODO: $_ and $-: */
4698         /* $_ Shell or shell script name; or last argument of last command
4699          * (if last command wasn't a pipe; if it was, bash sets $_ to "");
4700          * but in command's env, set to full pathname used to invoke it */
4701         /* $- Option flags set by set builtin or shell options (-i etc) */
4702         default:
4703                 o_addQchr(dest, '$');
4704         }
4705         debug_printf_parse("parse_dollar return 1 (ok)\n");
4706         return 1;
4707 #undef as_string
4708 }
4709
4710 #if BB_MMU
4711 # if BASH_PATTERN_SUBST
4712 #define encode_string(as_string, dest, input, dquote_end, process_bkslash) \
4713         encode_string(dest, input, dquote_end, process_bkslash)
4714 # else
4715 /* only ${var/pattern/repl} (its pattern part) needs additional mode */
4716 #define encode_string(as_string, dest, input, dquote_end, process_bkslash) \
4717         encode_string(dest, input, dquote_end)
4718 # endif
4719 #define as_string NULL
4720
4721 #else /* !MMU */
4722
4723 # if BASH_PATTERN_SUBST
4724 /* all parameters are needed, no macro tricks */
4725 # else
4726 #define encode_string(as_string, dest, input, dquote_end, process_bkslash) \
4727         encode_string(as_string, dest, input, dquote_end)
4728 # endif
4729 #endif
4730 static int encode_string(o_string *as_string,
4731                 o_string *dest,
4732                 struct in_str *input,
4733                 int dquote_end,
4734                 int process_bkslash)
4735 {
4736 #if !BASH_PATTERN_SUBST
4737         const int process_bkslash = 1;
4738 #endif
4739         int ch;
4740         int next;
4741
4742  again:
4743         ch = i_getch(input);
4744         if (ch != EOF)
4745                 nommu_addchr(as_string, ch);
4746         if (ch == dquote_end) { /* may be only '"' or EOF */
4747                 debug_printf_parse("encode_string return 1 (ok)\n");
4748                 return 1;
4749         }
4750         /* note: can't move it above ch == dquote_end check! */
4751         if (ch == EOF) {
4752                 syntax_error_unterm_ch('"');
4753                 return 0; /* error */
4754         }
4755         next = '\0';
4756         if (ch != '\n') {
4757                 next = i_peek(input);
4758         }
4759         debug_printf_parse("\" ch=%c (%d) escape=%d\n",
4760                         ch, ch, !!(dest->o_expflags & EXP_FLAG_ESC_GLOB_CHARS));
4761         if (process_bkslash && ch == '\\') {
4762                 if (next == EOF) {
4763                         syntax_error("\\<eof>");
4764                         xfunc_die();
4765                 }
4766                 /* bash:
4767                  * "The backslash retains its special meaning [in "..."]
4768                  * only when followed by one of the following characters:
4769                  * $, `, ", \, or <newline>.  A double quote may be quoted
4770                  * within double quotes by preceding it with a backslash."
4771                  * NB: in (unquoted) heredoc, above does not apply to ",
4772                  * therefore we check for it by "next == dquote_end" cond.
4773                  */
4774                 if (next == dquote_end || strchr("$`\\\n", next)) {
4775                         ch = i_getch(input); /* eat next */
4776                         if (ch == '\n')
4777                                 goto again; /* skip \<newline> */
4778                 } /* else: ch remains == '\\', and we double it below: */
4779                 o_addqchr(dest, ch); /* \c if c is a glob char, else just c */
4780                 nommu_addchr(as_string, ch);
4781                 goto again;
4782         }
4783         if (ch == '$') {
4784                 if (!parse_dollar(as_string, dest, input, /*quote_mask:*/ 0x80)) {
4785                         debug_printf_parse("encode_string return 0: "
4786                                         "parse_dollar returned 0 (error)\n");
4787                         return 0;
4788                 }
4789                 goto again;
4790         }
4791 #if ENABLE_HUSH_TICK
4792         if (ch == '`') {
4793                 //unsigned pos = dest->length;
4794                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4795                 o_addchr(dest, 0x80 | '`');
4796                 if (!add_till_backquote(dest, input, /*in_dquote:*/ dquote_end == '"'))
4797                         return 0; /* error */
4798                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4799                 //debug_printf_subst("SUBST RES3 '%s'\n", dest->data + pos);
4800                 goto again;
4801         }
4802 #endif
4803         o_addQchr(dest, ch);
4804         goto again;
4805 #undef as_string
4806 }
4807
4808 /*
4809  * Scan input until EOF or end_trigger char.
4810  * Return a list of pipes to execute, or NULL on EOF
4811  * or if end_trigger character is met.
4812  * On syntax error, exit if shell is not interactive,
4813  * reset parsing machinery and start parsing anew,
4814  * or return ERR_PTR.
4815  */
4816 static struct pipe *parse_stream(char **pstring,
4817                 struct in_str *input,
4818                 int end_trigger)
4819 {
4820         struct parse_context ctx;
4821         o_string dest = NULL_O_STRING;
4822         int heredoc_cnt;
4823
4824         /* Single-quote triggers a bypass of the main loop until its mate is
4825          * found.  When recursing, quote state is passed in via dest->o_expflags.
4826          */
4827         debug_printf_parse("parse_stream entered, end_trigger='%c'\n",
4828                         end_trigger ? end_trigger : 'X');
4829         debug_enter();
4830
4831         /* If very first arg is "" or '', dest.data may end up NULL.
4832          * Preventing this: */
4833         o_addchr(&dest, '\0');
4834         dest.length = 0;
4835
4836         /* We used to separate words on $IFS here. This was wrong.
4837          * $IFS is used only for word splitting when $var is expanded,
4838          * here we should use blank chars as separators, not $IFS
4839          */
4840
4841         if (MAYBE_ASSIGNMENT != 0)
4842                 dest.o_assignment = MAYBE_ASSIGNMENT;
4843         initialize_context(&ctx);
4844         heredoc_cnt = 0;
4845         while (1) {
4846                 const char *is_blank;
4847                 const char *is_special;
4848                 int ch;
4849                 int next;
4850                 int redir_fd;
4851                 redir_type redir_style;
4852
4853                 ch = i_getch(input);
4854                 debug_printf_parse(": ch=%c (%d) escape=%d\n",
4855                                 ch, ch, !!(dest.o_expflags & EXP_FLAG_ESC_GLOB_CHARS));
4856                 if (ch == EOF) {
4857                         struct pipe *pi;
4858
4859                         if (heredoc_cnt) {
4860                                 syntax_error_unterm_str("here document");
4861                                 goto parse_error;
4862                         }
4863                         if (end_trigger == ')') {
4864                                 syntax_error_unterm_ch('(');
4865                                 goto parse_error;
4866                         }
4867                         if (end_trigger == '}') {
4868                                 syntax_error_unterm_ch('{');
4869                                 goto parse_error;
4870                         }
4871
4872                         if (done_word(&dest, &ctx)) {
4873                                 goto parse_error;
4874                         }
4875                         o_free(&dest);
4876                         done_pipe(&ctx, PIPE_SEQ);
4877                         pi = ctx.list_head;
4878                         /* If we got nothing... */
4879                         /* (this makes bare "&" cmd a no-op.
4880                          * bash says: "syntax error near unexpected token '&'") */
4881                         if (pi->num_cmds == 0
4882                         IF_HAS_KEYWORDS(&& pi->res_word == RES_NONE)
4883                         ) {
4884                                 free_pipe_list(pi);
4885                                 pi = NULL;
4886                         }
4887 #if !BB_MMU
4888                         debug_printf_parse("as_string1 '%s'\n", ctx.as_string.data);
4889                         if (pstring)
4890                                 *pstring = ctx.as_string.data;
4891                         else
4892                                 o_free_unsafe(&ctx.as_string);
4893 #endif
4894                         debug_leave();
4895                         debug_printf_parse("parse_stream return %p\n", pi);
4896                         return pi;
4897                 }
4898                 nommu_addchr(&ctx.as_string, ch);
4899
4900                 next = '\0';
4901                 if (ch != '\n')
4902                         next = i_peek(input);
4903
4904                 is_special = "{}<>;&|()#'" /* special outside of "str" */
4905                                 "\\$\"" IF_HUSH_TICK("`"); /* always special */
4906                 /* Are { and } special here? */
4907                 if (ctx.command->argv /* word [word]{... - non-special */
4908                  || dest.length       /* word{... - non-special */
4909                  || dest.has_quoted_part     /* ""{... - non-special */
4910                  || (next != ';'             /* }; - special */
4911                     && next != ')'           /* }) - special */
4912                     && next != '('           /* {( - special */
4913                     && next != '&'           /* }& and }&& ... - special */
4914                     && next != '|'           /* }|| ... - special */
4915                     && !strchr(defifs, next) /* {word - non-special */
4916                     )
4917                 ) {
4918                         /* They are not special, skip "{}" */
4919                         is_special += 2;
4920                 }
4921                 is_special = strchr(is_special, ch);
4922                 is_blank = strchr(defifs, ch);
4923
4924                 if (!is_special && !is_blank) { /* ordinary char */
4925  ordinary_char:
4926                         o_addQchr(&dest, ch);
4927                         if ((dest.o_assignment == MAYBE_ASSIGNMENT
4928                             || dest.o_assignment == WORD_IS_KEYWORD)
4929                          && ch == '='
4930                          && is_well_formed_var_name(dest.data, '=')
4931                         ) {
4932                                 dest.o_assignment = DEFINITELY_ASSIGNMENT;
4933                                 debug_printf_parse("dest.o_assignment='%s'\n", assignment_flag[dest.o_assignment]);
4934                         }
4935                         continue;
4936                 }
4937
4938                 if (is_blank) {
4939                         if (done_word(&dest, &ctx)) {
4940                                 goto parse_error;
4941                         }
4942                         if (ch == '\n') {
4943                                 /* Is this a case when newline is simply ignored?
4944                                  * Some examples:
4945                                  * "cmd | <newline> cmd ..."
4946                                  * "case ... in <newline> word) ..."
4947                                  */
4948                                 if (IS_NULL_CMD(ctx.command)
4949                                  && dest.length == 0 && !dest.has_quoted_part
4950                                 ) {
4951                                         /* This newline can be ignored. But...
4952                                          * Without check #1, interactive shell
4953                                          * ignores even bare <newline>,
4954                                          * and shows the continuation prompt:
4955                                          * ps1_prompt$ <enter>
4956                                          * ps2> _   <=== wrong, should be ps1
4957                                          * Without check #2, "cmd & <newline>"
4958                                          * is similarly mistreated.
4959                                          * (BTW, this makes "cmd & cmd"
4960                                          * and "cmd && cmd" non-orthogonal.
4961                                          * Really, ask yourself, why
4962                                          * "cmd && <newline>" doesn't start
4963                                          * cmd but waits for more input?
4964                                          * The only reason is that it might be
4965                                          * a "cmd1 && <nl> cmd2 &" construct,
4966                                          * cmd1 may need to run in BG).
4967                                          */
4968                                         struct pipe *pi = ctx.list_head;
4969                                         if (pi->num_cmds != 0       /* check #1 */
4970                                          && pi->followup != PIPE_BG /* check #2 */
4971                                         ) {
4972                                                 continue;
4973                                         }
4974                                 }
4975                                 /* Treat newline as a command separator. */
4976                                 done_pipe(&ctx, PIPE_SEQ);
4977                                 debug_printf_parse("heredoc_cnt:%d\n", heredoc_cnt);
4978                                 if (heredoc_cnt) {
4979                                         if (fetch_heredocs(heredoc_cnt, &ctx, input)) {
4980                                                 goto parse_error;
4981                                         }
4982                                         heredoc_cnt = 0;
4983                                 }
4984                                 dest.o_assignment = MAYBE_ASSIGNMENT;
4985                                 debug_printf_parse("dest.o_assignment='%s'\n", assignment_flag[dest.o_assignment]);
4986                                 ch = ';';
4987                                 /* note: if (is_blank) continue;
4988                                  * will still trigger for us */
4989                         }
4990                 }
4991
4992                 /* "cmd}" or "cmd }..." without semicolon or &:
4993                  * } is an ordinary char in this case, even inside { cmd; }
4994                  * Pathological example: { ""}; } should exec "}" cmd
4995                  */
4996                 if (ch == '}') {
4997                         if (dest.length != 0 /* word} */
4998                          || dest.has_quoted_part    /* ""} */
4999                         ) {
5000                                 goto ordinary_char;
5001                         }
5002                         if (!IS_NULL_CMD(ctx.command)) { /* cmd } */
5003                                 /* Generally, there should be semicolon: "cmd; }"
5004                                  * However, bash allows to omit it if "cmd" is
5005                                  * a group. Examples:
5006                                  * { { echo 1; } }
5007                                  * {(echo 1)}
5008                                  * { echo 0 >&2 | { echo 1; } }
5009                                  * { while false; do :; done }
5010                                  * { case a in b) ;; esac }
5011                                  */
5012                                 if (ctx.command->group)
5013                                         goto term_group;
5014                                 goto ordinary_char;
5015                         }
5016                         if (!IS_NULL_PIPE(ctx.pipe)) /* cmd | } */
5017                                 /* Can't be an end of {cmd}, skip the check */
5018                                 goto skip_end_trigger;
5019                         /* else: } does terminate a group */
5020                 }
5021  term_group:
5022                 if (end_trigger && end_trigger == ch
5023                  && (ch != ';' || heredoc_cnt == 0)
5024 #if ENABLE_HUSH_CASE
5025                  && (ch != ')'
5026                     || ctx.ctx_res_w != RES_MATCH
5027                     || (!dest.has_quoted_part && strcmp(dest.data, "esac") == 0)
5028                     )
5029 #endif
5030                 ) {
5031                         if (heredoc_cnt) {
5032                                 /* This is technically valid:
5033                                  * { cat <<HERE; }; echo Ok
5034                                  * heredoc
5035                                  * heredoc
5036                                  * HERE
5037                                  * but we don't support this.
5038                                  * We require heredoc to be in enclosing {}/(),
5039                                  * if any.
5040                                  */
5041                                 syntax_error_unterm_str("here document");
5042                                 goto parse_error;
5043                         }
5044                         if (done_word(&dest, &ctx)) {
5045                                 goto parse_error;
5046                         }
5047                         done_pipe(&ctx, PIPE_SEQ);
5048                         dest.o_assignment = MAYBE_ASSIGNMENT;
5049                         debug_printf_parse("dest.o_assignment='%s'\n", assignment_flag[dest.o_assignment]);
5050                         /* Do we sit outside of any if's, loops or case's? */
5051                         if (!HAS_KEYWORDS
5052                         IF_HAS_KEYWORDS(|| (ctx.ctx_res_w == RES_NONE && ctx.old_flag == 0))
5053                         ) {
5054                                 o_free(&dest);
5055 #if !BB_MMU
5056                                 debug_printf_parse("as_string2 '%s'\n", ctx.as_string.data);
5057                                 if (pstring)
5058                                         *pstring = ctx.as_string.data;
5059                                 else
5060                                         o_free_unsafe(&ctx.as_string);
5061 #endif
5062                                 if (ch != ';' && IS_NULL_PIPE(ctx.list_head)) {
5063                                         /* Example: bare "{ }", "()" */
5064                                         G.last_exitcode = 2; /* bash compat */
5065                                         syntax_error_unexpected_ch(ch);
5066                                         goto parse_error2;
5067                                 }
5068                                 debug_printf_parse("parse_stream return %p: "
5069                                                 "end_trigger char found\n",
5070                                                 ctx.list_head);
5071                                 debug_leave();
5072                                 return ctx.list_head;
5073                         }
5074                 }
5075  skip_end_trigger:
5076                 if (is_blank)
5077                         continue;
5078
5079                 /* Catch <, > before deciding whether this word is
5080                  * an assignment. a=1 2>z b=2: b=2 is still assignment */
5081                 switch (ch) {
5082                 case '>':
5083                         redir_fd = redirect_opt_num(&dest);
5084                         if (done_word(&dest, &ctx)) {
5085                                 goto parse_error;
5086                         }
5087                         redir_style = REDIRECT_OVERWRITE;
5088                         if (next == '>') {
5089                                 redir_style = REDIRECT_APPEND;
5090                                 ch = i_getch(input);
5091                                 nommu_addchr(&ctx.as_string, ch);
5092                         }
5093 #if 0
5094                         else if (next == '(') {
5095                                 syntax_error(">(process) not supported");
5096                                 goto parse_error;
5097                         }
5098 #endif
5099                         if (parse_redirect(&ctx, redir_fd, redir_style, input))
5100                                 goto parse_error;
5101                         continue; /* back to top of while (1) */
5102                 case '<':
5103                         redir_fd = redirect_opt_num(&dest);
5104                         if (done_word(&dest, &ctx)) {
5105                                 goto parse_error;
5106                         }
5107                         redir_style = REDIRECT_INPUT;
5108                         if (next == '<') {
5109                                 redir_style = REDIRECT_HEREDOC;
5110                                 heredoc_cnt++;
5111                                 debug_printf_parse("++heredoc_cnt=%d\n", heredoc_cnt);
5112                                 ch = i_getch(input);
5113                                 nommu_addchr(&ctx.as_string, ch);
5114                         } else if (next == '>') {
5115                                 redir_style = REDIRECT_IO;
5116                                 ch = i_getch(input);
5117                                 nommu_addchr(&ctx.as_string, ch);
5118                         }
5119 #if 0
5120                         else if (next == '(') {
5121                                 syntax_error("<(process) not supported");
5122                                 goto parse_error;
5123                         }
5124 #endif
5125                         if (parse_redirect(&ctx, redir_fd, redir_style, input))
5126                                 goto parse_error;
5127                         continue; /* back to top of while (1) */
5128                 case '#':
5129                         if (dest.length == 0 && !dest.has_quoted_part) {
5130                                 /* skip "#comment" */
5131                                 while (1) {
5132                                         ch = i_peek(input);
5133                                         if (ch == EOF || ch == '\n')
5134                                                 break;
5135                                         i_getch(input);
5136                                         /* note: we do not add it to &ctx.as_string */
5137                                 }
5138                                 nommu_addchr(&ctx.as_string, '\n');
5139                                 continue; /* back to top of while (1) */
5140                         }
5141                         break;
5142                 case '\\':
5143                         if (next == '\n') {
5144                                 /* It's "\<newline>" */
5145 #if !BB_MMU
5146                                 /* Remove trailing '\' from ctx.as_string */
5147                                 ctx.as_string.data[--ctx.as_string.length] = '\0';
5148 #endif
5149                                 ch = i_getch(input); /* eat it */
5150                                 continue; /* back to top of while (1) */
5151                         }
5152                         break;
5153                 }
5154
5155                 if (dest.o_assignment == MAYBE_ASSIGNMENT
5156                  /* check that we are not in word in "a=1 2>word b=1": */
5157                  && !ctx.pending_redirect
5158                 ) {
5159                         /* ch is a special char and thus this word
5160                          * cannot be an assignment */
5161                         dest.o_assignment = NOT_ASSIGNMENT;
5162                         debug_printf_parse("dest.o_assignment='%s'\n", assignment_flag[dest.o_assignment]);
5163                 }
5164
5165                 /* Note: nommu_addchr(&ctx.as_string, ch) is already done */
5166
5167                 switch (ch) {
5168                 case '#': /* non-comment #: "echo a#b" etc */
5169                         o_addQchr(&dest, ch);
5170                         break;
5171                 case '\\':
5172                         if (next == EOF) {
5173                                 syntax_error("\\<eof>");
5174                                 xfunc_die();
5175                         }
5176                         ch = i_getch(input);
5177                         /* note: ch != '\n' (that case does not reach this place) */
5178                         o_addchr(&dest, '\\');
5179                         /*nommu_addchr(&ctx.as_string, '\\'); - already done */
5180                         o_addchr(&dest, ch);
5181                         nommu_addchr(&ctx.as_string, ch);
5182                         /* Example: echo Hello \2>file
5183                          * we need to know that word 2 is quoted */
5184                         dest.has_quoted_part = 1;
5185                         break;
5186                 case '$':
5187                         if (!parse_dollar(&ctx.as_string, &dest, input, /*quote_mask:*/ 0)) {
5188                                 debug_printf_parse("parse_stream parse error: "
5189                                         "parse_dollar returned 0 (error)\n");
5190                                 goto parse_error;
5191                         }
5192                         break;
5193                 case '\'':
5194                         dest.has_quoted_part = 1;
5195                         if (next == '\'' && !ctx.pending_redirect) {
5196  insert_empty_quoted_str_marker:
5197                                 nommu_addchr(&ctx.as_string, next);
5198                                 i_getch(input); /* eat second ' */
5199                                 o_addchr(&dest, SPECIAL_VAR_SYMBOL);
5200                                 o_addchr(&dest, SPECIAL_VAR_SYMBOL);
5201                         } else {
5202                                 while (1) {
5203                                         ch = i_getch(input);
5204                                         if (ch == EOF) {
5205                                                 syntax_error_unterm_ch('\'');
5206                                                 goto parse_error;
5207                                         }
5208                                         nommu_addchr(&ctx.as_string, ch);
5209                                         if (ch == '\'')
5210                                                 break;
5211                                         o_addqchr(&dest, ch);
5212                                 }
5213                         }
5214                         break;
5215                 case '"':
5216                         dest.has_quoted_part = 1;
5217                         if (next == '"' && !ctx.pending_redirect)
5218                                 goto insert_empty_quoted_str_marker;
5219                         if (dest.o_assignment == NOT_ASSIGNMENT)
5220                                 dest.o_expflags |= EXP_FLAG_ESC_GLOB_CHARS;
5221                         if (!encode_string(&ctx.as_string, &dest, input, '"', /*process_bkslash:*/ 1))
5222                                 goto parse_error;
5223                         dest.o_expflags &= ~EXP_FLAG_ESC_GLOB_CHARS;
5224                         break;
5225 #if ENABLE_HUSH_TICK
5226                 case '`': {
5227                         USE_FOR_NOMMU(unsigned pos;)
5228
5229                         o_addchr(&dest, SPECIAL_VAR_SYMBOL);
5230                         o_addchr(&dest, '`');
5231                         USE_FOR_NOMMU(pos = dest.length;)
5232                         if (!add_till_backquote(&dest, input, /*in_dquote:*/ 0))
5233                                 goto parse_error;
5234 # if !BB_MMU
5235                         o_addstr(&ctx.as_string, dest.data + pos);
5236                         o_addchr(&ctx.as_string, '`');
5237 # endif
5238                         o_addchr(&dest, SPECIAL_VAR_SYMBOL);
5239                         //debug_printf_subst("SUBST RES3 '%s'\n", dest.data + pos);
5240                         break;
5241                 }
5242 #endif
5243                 case ';':
5244 #if ENABLE_HUSH_CASE
5245  case_semi:
5246 #endif
5247                         if (done_word(&dest, &ctx)) {
5248                                 goto parse_error;
5249                         }
5250                         done_pipe(&ctx, PIPE_SEQ);
5251 #if ENABLE_HUSH_CASE
5252                         /* Eat multiple semicolons, detect
5253                          * whether it means something special */
5254                         while (1) {
5255                                 ch = i_peek(input);
5256                                 if (ch != ';')
5257                                         break;
5258                                 ch = i_getch(input);
5259                                 nommu_addchr(&ctx.as_string, ch);
5260                                 if (ctx.ctx_res_w == RES_CASE_BODY) {
5261                                         ctx.ctx_dsemicolon = 1;
5262                                         ctx.ctx_res_w = RES_MATCH;
5263                                         break;
5264                                 }
5265                         }
5266 #endif
5267  new_cmd:
5268                         /* We just finished a cmd. New one may start
5269                          * with an assignment */
5270                         dest.o_assignment = MAYBE_ASSIGNMENT;
5271                         debug_printf_parse("dest.o_assignment='%s'\n", assignment_flag[dest.o_assignment]);
5272                         break;
5273                 case '&':
5274                         if (done_word(&dest, &ctx)) {
5275                                 goto parse_error;
5276                         }
5277                         if (next == '&') {
5278                                 ch = i_getch(input);
5279                                 nommu_addchr(&ctx.as_string, ch);
5280                                 done_pipe(&ctx, PIPE_AND);
5281                         } else {
5282                                 done_pipe(&ctx, PIPE_BG);
5283                         }
5284                         goto new_cmd;
5285                 case '|':
5286                         if (done_word(&dest, &ctx)) {
5287                                 goto parse_error;
5288                         }
5289 #if ENABLE_HUSH_CASE
5290                         if (ctx.ctx_res_w == RES_MATCH)
5291                                 break; /* we are in case's "word | word)" */
5292 #endif
5293                         if (next == '|') { /* || */
5294                                 ch = i_getch(input);
5295                                 nommu_addchr(&ctx.as_string, ch);
5296                                 done_pipe(&ctx, PIPE_OR);
5297                         } else {
5298                                 /* we could pick up a file descriptor choice here
5299                                  * with redirect_opt_num(), but bash doesn't do it.
5300                                  * "echo foo 2| cat" yields "foo 2". */
5301                                 done_command(&ctx);
5302                         }
5303                         goto new_cmd;
5304                 case '(':
5305 #if ENABLE_HUSH_CASE
5306                         /* "case... in [(]word)..." - skip '(' */
5307                         if (ctx.ctx_res_w == RES_MATCH
5308                          && ctx.command->argv == NULL /* not (word|(... */
5309                          && dest.length == 0 /* not word(... */
5310                          && dest.has_quoted_part == 0 /* not ""(... */
5311                         ) {
5312                                 continue;
5313                         }
5314 #endif
5315                 case '{':
5316                         if (parse_group(&dest, &ctx, input, ch) != 0) {
5317                                 goto parse_error;
5318                         }
5319                         goto new_cmd;
5320                 case ')':
5321 #if ENABLE_HUSH_CASE
5322                         if (ctx.ctx_res_w == RES_MATCH)
5323                                 goto case_semi;
5324 #endif
5325                 case '}':
5326                         /* proper use of this character is caught by end_trigger:
5327                          * if we see {, we call parse_group(..., end_trigger='}')
5328                          * and it will match } earlier (not here). */
5329                         G.last_exitcode = 2;
5330                         syntax_error_unexpected_ch(ch);
5331                         goto parse_error2;
5332                 default:
5333                         if (HUSH_DEBUG)
5334                                 bb_error_msg_and_die("BUG: unexpected %c\n", ch);
5335                 }
5336         } /* while (1) */
5337
5338  parse_error:
5339         G.last_exitcode = 1;
5340  parse_error2:
5341         {
5342                 struct parse_context *pctx;
5343                 IF_HAS_KEYWORDS(struct parse_context *p2;)
5344
5345                 /* Clean up allocated tree.
5346                  * Sample for finding leaks on syntax error recovery path.
5347                  * Run it from interactive shell, watch pmap `pidof hush`.
5348                  * while if false; then false; fi; do break; fi
5349                  * Samples to catch leaks at execution:
5350                  * while if (true | { true;}); then echo ok; fi; do break; done
5351                  * while if (true | { true;}); then echo ok; fi; do (if echo ok; break; then :; fi) | cat; break; done
5352                  */
5353                 pctx = &ctx;
5354                 do {
5355                         /* Update pipe/command counts,
5356                          * otherwise freeing may miss some */
5357                         done_pipe(pctx, PIPE_SEQ);
5358                         debug_printf_clean("freeing list %p from ctx %p\n",
5359                                         pctx->list_head, pctx);
5360                         debug_print_tree(pctx->list_head, 0);
5361                         free_pipe_list(pctx->list_head);
5362                         debug_printf_clean("freed list %p\n", pctx->list_head);
5363 #if !BB_MMU
5364                         o_free_unsafe(&pctx->as_string);
5365 #endif
5366                         IF_HAS_KEYWORDS(p2 = pctx->stack;)
5367                         if (pctx != &ctx) {
5368                                 free(pctx);
5369                         }
5370                         IF_HAS_KEYWORDS(pctx = p2;)
5371                 } while (HAS_KEYWORDS && pctx);
5372
5373                 o_free(&dest);
5374 #if !BB_MMU
5375                 if (pstring)
5376                         *pstring = NULL;
5377 #endif
5378                 debug_leave();
5379                 return ERR_PTR;
5380         }
5381 }
5382
5383
5384 /*** Execution routines ***/
5385
5386 /* Expansion can recurse, need forward decls: */
5387 #if !BASH_PATTERN_SUBST && !ENABLE_HUSH_CASE
5388 /* only ${var/pattern/repl} (its pattern part) needs additional mode */
5389 #define expand_string_to_string(str, do_unbackslash) \
5390         expand_string_to_string(str)
5391 #endif
5392 static char *expand_string_to_string(const char *str, int do_unbackslash);
5393 #if ENABLE_HUSH_TICK
5394 static int process_command_subs(o_string *dest, const char *s);
5395 #endif
5396
5397 /* expand_strvec_to_strvec() takes a list of strings, expands
5398  * all variable references within and returns a pointer to
5399  * a list of expanded strings, possibly with larger number
5400  * of strings. (Think VAR="a b"; echo $VAR).
5401  * This new list is allocated as a single malloc block.
5402  * NULL-terminated list of char* pointers is at the beginning of it,
5403  * followed by strings themselves.
5404  * Caller can deallocate entire list by single free(list). */
5405
5406 /* A horde of its helpers come first: */
5407
5408 static void o_addblock_duplicate_backslash(o_string *o, const char *str, int len)
5409 {
5410         while (--len >= 0) {
5411                 char c = *str++;
5412
5413 #if ENABLE_HUSH_BRACE_EXPANSION
5414                 if (c == '{' || c == '}') {
5415                         /* { -> \{, } -> \} */
5416                         o_addchr(o, '\\');
5417                         /* And now we want to add { or } and continue:
5418                          *  o_addchr(o, c);
5419                          *  continue;
5420                          * luckily, just falling through achieves this.
5421                          */
5422                 }
5423 #endif
5424                 o_addchr(o, c);
5425                 if (c == '\\') {
5426                         /* \z -> \\\z; \<eol> -> \\<eol> */
5427                         o_addchr(o, '\\');
5428                         if (len) {
5429                                 len--;
5430                                 o_addchr(o, '\\');
5431                                 o_addchr(o, *str++);
5432                         }
5433                 }
5434         }
5435 }
5436
5437 /* Store given string, finalizing the word and starting new one whenever
5438  * we encounter IFS char(s). This is used for expanding variable values.
5439  * End-of-string does NOT finalize word: think about 'echo -$VAR-'.
5440  * Return in *ended_with_ifs:
5441  * 1 - ended with IFS char, else 0 (this includes case of empty str).
5442  */
5443 static int expand_on_ifs(int *ended_with_ifs, o_string *output, int n, const char *str)
5444 {
5445         int last_is_ifs = 0;
5446
5447         while (1) {
5448                 int word_len;
5449
5450                 if (!*str)  /* EOL - do not finalize word */
5451                         break;
5452                 word_len = strcspn(str, G.ifs);
5453                 if (word_len) {
5454                         /* We have WORD_LEN leading non-IFS chars */
5455                         if (!(output->o_expflags & EXP_FLAG_GLOB)) {
5456                                 o_addblock(output, str, word_len);
5457                         } else {
5458                                 /* Protect backslashes against globbing up :)
5459                                  * Example: "v='\*'; echo b$v" prints "b\*"
5460                                  * (and does not try to glob on "*")
5461                                  */
5462                                 o_addblock_duplicate_backslash(output, str, word_len);
5463                                 /*/ Why can't we do it easier? */
5464                                 /*o_addblock(output, str, word_len); - WRONG: "v='\*'; echo Z$v" prints "Z*" instead of "Z\*" */
5465                                 /*o_addqblock(output, str, word_len); - WRONG: "v='*'; echo Z$v" prints "Z*" instead of Z* files */
5466                         }
5467                         last_is_ifs = 0;
5468                         str += word_len;
5469                         if (!*str)  /* EOL - do not finalize word */
5470                                 break;
5471                 }
5472
5473                 /* We know str here points to at least one IFS char */
5474                 last_is_ifs = 1;
5475                 str += strspn(str, G.ifs); /* skip IFS chars */
5476                 if (!*str)  /* EOL - do not finalize word */
5477                         break;
5478
5479                 /* Start new word... but not always! */
5480                 /* Case "v=' a'; echo ''$v": we do need to finalize empty word: */
5481                 if (output->has_quoted_part
5482                 /* Case "v=' a'; echo $v":
5483                  * here nothing precedes the space in $v expansion,
5484                  * therefore we should not finish the word
5485                  * (IOW: if there *is* word to finalize, only then do it):
5486                  */
5487                  || (n > 0 && output->data[output->length - 1])
5488                 ) {
5489                         o_addchr(output, '\0');
5490                         debug_print_list("expand_on_ifs", output, n);
5491                         n = o_save_ptr(output, n);
5492                 }
5493         }
5494
5495         if (ended_with_ifs)
5496                 *ended_with_ifs = last_is_ifs;
5497         debug_print_list("expand_on_ifs[1]", output, n);
5498         return n;
5499 }
5500
5501 /* Helper to expand $((...)) and heredoc body. These act as if
5502  * they are in double quotes, with the exception that they are not :).
5503  * Just the rules are similar: "expand only $var and `cmd`"
5504  *
5505  * Returns malloced string.
5506  * As an optimization, we return NULL if expansion is not needed.
5507  */
5508 #if !BASH_PATTERN_SUBST
5509 /* only ${var/pattern/repl} (its pattern part) needs additional mode */
5510 #define encode_then_expand_string(str, process_bkslash, do_unbackslash) \
5511         encode_then_expand_string(str)
5512 #endif
5513 static char *encode_then_expand_string(const char *str, int process_bkslash, int do_unbackslash)
5514 {
5515 #if !BASH_PATTERN_SUBST
5516         const int do_unbackslash = 1;
5517 #endif
5518         char *exp_str;
5519         struct in_str input;
5520         o_string dest = NULL_O_STRING;
5521
5522         if (!strchr(str, '$')
5523          && !strchr(str, '\\')
5524 #if ENABLE_HUSH_TICK
5525          && !strchr(str, '`')
5526 #endif
5527         ) {
5528                 return NULL;
5529         }
5530
5531         /* We need to expand. Example:
5532          * echo $(($a + `echo 1`)) $((1 + $((2)) ))
5533          */
5534         setup_string_in_str(&input, str);
5535         encode_string(NULL, &dest, &input, EOF, process_bkslash);
5536 //TODO: error check (encode_string returns 0 on error)?
5537         //bb_error_msg("'%s' -> '%s'", str, dest.data);
5538         exp_str = expand_string_to_string(dest.data, /*unbackslash:*/ do_unbackslash);
5539         //bb_error_msg("'%s' -> '%s'", dest.data, exp_str);
5540         o_free_unsafe(&dest);
5541         return exp_str;
5542 }
5543
5544 #if ENABLE_FEATURE_SH_MATH
5545 static arith_t expand_and_evaluate_arith(const char *arg, const char **errmsg_p)
5546 {
5547         arith_state_t math_state;
5548         arith_t res;
5549         char *exp_str;
5550
5551         math_state.lookupvar = get_local_var_value;
5552         math_state.setvar = set_local_var_from_halves;
5553         //math_state.endofname = endofname;
5554         exp_str = encode_then_expand_string(arg, /*process_bkslash:*/ 1, /*unbackslash:*/ 1);
5555         res = arith(&math_state, exp_str ? exp_str : arg);
5556         free(exp_str);
5557         if (errmsg_p)
5558                 *errmsg_p = math_state.errmsg;
5559         if (math_state.errmsg)
5560                 msg_and_die_if_script(math_state.errmsg);
5561         return res;
5562 }
5563 #endif
5564
5565 #if BASH_PATTERN_SUBST
5566 /* ${var/[/]pattern[/repl]} helpers */
5567 static char *strstr_pattern(char *val, const char *pattern, int *size)
5568 {
5569         while (1) {
5570                 char *end = scan_and_match(val, pattern, SCAN_MOVE_FROM_RIGHT + SCAN_MATCH_LEFT_HALF);
5571                 debug_printf_varexp("val:'%s' pattern:'%s' end:'%s'\n", val, pattern, end);
5572                 if (end) {
5573                         *size = end - val;
5574                         return val;
5575                 }
5576                 if (*val == '\0')
5577                         return NULL;
5578                 /* Optimization: if "*pat" did not match the start of "string",
5579                  * we know that "tring", "ring" etc will not match too:
5580                  */
5581                 if (pattern[0] == '*')
5582                         return NULL;
5583                 val++;
5584         }
5585 }
5586 static char *replace_pattern(char *val, const char *pattern, const char *repl, char exp_op)
5587 {
5588         char *result = NULL;
5589         unsigned res_len = 0;
5590         unsigned repl_len = strlen(repl);
5591
5592         while (1) {
5593                 int size;
5594                 char *s = strstr_pattern(val, pattern, &size);
5595                 if (!s)
5596                         break;
5597
5598                 result = xrealloc(result, res_len + (s - val) + repl_len + 1);
5599                 strcpy(mempcpy(result + res_len, val, s - val), repl);
5600                 res_len += (s - val) + repl_len;
5601                 debug_printf_varexp("val:'%s' s:'%s' result:'%s'\n", val, s, result);
5602
5603                 val = s + size;
5604                 if (exp_op == '/')
5605                         break;
5606         }
5607         if (*val && result) {
5608                 result = xrealloc(result, res_len + strlen(val) + 1);
5609                 strcpy(result + res_len, val);
5610                 debug_printf_varexp("val:'%s' result:'%s'\n", val, result);
5611         }
5612         debug_printf_varexp("result:'%s'\n", result);
5613         return result;
5614 }
5615 #endif /* BASH_PATTERN_SUBST */
5616
5617 /* Helper:
5618  * Handles <SPECIAL_VAR_SYMBOL>varname...<SPECIAL_VAR_SYMBOL> construct.
5619  */
5620 static NOINLINE const char *expand_one_var(char **to_be_freed_pp, char *arg, char **pp)
5621 {
5622         const char *val = NULL;
5623         char *to_be_freed = NULL;
5624         char *p = *pp;
5625         char *var;
5626         char first_char;
5627         char exp_op;
5628         char exp_save = exp_save; /* for compiler */
5629         char *exp_saveptr; /* points to expansion operator */
5630         char *exp_word = exp_word; /* for compiler */
5631         char arg0;
5632
5633         *p = '\0'; /* replace trailing SPECIAL_VAR_SYMBOL */
5634         var = arg;
5635         exp_saveptr = arg[1] ? strchr(VAR_ENCODED_SUBST_OPS, arg[1]) : NULL;
5636         arg0 = arg[0];
5637         first_char = arg[0] = arg0 & 0x7f;
5638         exp_op = 0;
5639
5640         if (first_char == '#' && arg[1] /* ${#...} but not ${#} */
5641          && (!exp_saveptr               /* and ( not(${#<op_char>...}) */
5642             || (arg[2] == '\0' && strchr(SPECIAL_VARS_STR, arg[1])) /* or ${#C} "len of $C" ) */
5643             )           /* NB: skipping ^^^specvar check mishandles ${#::2} */
5644         ) {
5645                 /* It must be length operator: ${#var} */
5646                 var++;
5647                 exp_op = 'L';
5648         } else {
5649                 /* Maybe handle parameter expansion */
5650                 if (exp_saveptr /* if 2nd char is one of expansion operators */
5651                  && strchr(NUMERIC_SPECVARS_STR, first_char) /* 1st char is special variable */
5652                 ) {
5653                         /* ${?:0}, ${#[:]%0} etc */
5654                         exp_saveptr = var + 1;
5655                 } else {
5656                         /* ${?}, ${var}, ${var:0}, ${var[:]%0} etc */
5657                         exp_saveptr = var+1 + strcspn(var+1, VAR_ENCODED_SUBST_OPS);
5658                 }
5659                 exp_op = exp_save = *exp_saveptr;
5660                 if (exp_op) {
5661                         exp_word = exp_saveptr + 1;
5662                         if (exp_op == ':') {
5663                                 exp_op = *exp_word++;
5664 //TODO: try ${var:} and ${var:bogus} in non-bash config
5665                                 if (BASH_SUBSTR
5666                                  && (!exp_op || !strchr(MINUS_PLUS_EQUAL_QUESTION, exp_op))
5667                                 ) {
5668                                         /* oops... it's ${var:N[:M]}, not ${var:?xxx} or some such */
5669                                         exp_op = ':';
5670                                         exp_word--;
5671                                 }
5672                         }
5673                         *exp_saveptr = '\0';
5674                 } /* else: it's not an expansion op, but bare ${var} */
5675         }
5676
5677         /* Look up the variable in question */
5678         if (isdigit(var[0])) {
5679                 /* parse_dollar should have vetted var for us */
5680                 int n = xatoi_positive(var);
5681                 if (n < G.global_argc)
5682                         val = G.global_argv[n];
5683                 /* else val remains NULL: $N with too big N */
5684         } else {
5685                 switch (var[0]) {
5686                 case '$': /* pid */
5687                         val = utoa(G.root_pid);
5688                         break;
5689                 case '!': /* bg pid */
5690                         val = G.last_bg_pid ? utoa(G.last_bg_pid) : "";
5691                         break;
5692                 case '?': /* exitcode */
5693                         val = utoa(G.last_exitcode);
5694                         break;
5695                 case '#': /* argc */
5696                         val = utoa(G.global_argc ? G.global_argc-1 : 0);
5697                         break;
5698                 default:
5699                         val = get_local_var_value(var);
5700                 }
5701         }
5702
5703         /* Handle any expansions */
5704         if (exp_op == 'L') {
5705                 reinit_unicode_for_hush();
5706                 debug_printf_expand("expand: length(%s)=", val);
5707                 val = utoa(val ? unicode_strlen(val) : 0);
5708                 debug_printf_expand("%s\n", val);
5709         } else if (exp_op) {
5710                 if (exp_op == '%' || exp_op == '#') {
5711                         /* Standard-mandated substring removal ops:
5712                          * ${parameter%word} - remove smallest suffix pattern
5713                          * ${parameter%%word} - remove largest suffix pattern
5714                          * ${parameter#word} - remove smallest prefix pattern
5715                          * ${parameter##word} - remove largest prefix pattern
5716                          *
5717                          * Word is expanded to produce a glob pattern.
5718                          * Then var's value is matched to it and matching part removed.
5719                          */
5720                         if (val && val[0]) {
5721                                 char *t;
5722                                 char *exp_exp_word;
5723                                 char *loc;
5724                                 unsigned scan_flags = pick_scan(exp_op, *exp_word);
5725                                 if (exp_op == *exp_word)  /* ## or %% */
5726                                         exp_word++;
5727                                 exp_exp_word = encode_then_expand_string(exp_word, /*process_bkslash:*/ 1, /*unbackslash:*/ 1);
5728                                 if (exp_exp_word)
5729                                         exp_word = exp_exp_word;
5730                                 /* HACK ALERT. We depend here on the fact that
5731                                  * G.global_argv and results of utoa and get_local_var_value
5732                                  * are actually in writable memory:
5733                                  * scan_and_match momentarily stores NULs there. */
5734                                 t = (char*)val;
5735                                 loc = scan_and_match(t, exp_word, scan_flags);
5736                                 //bb_error_msg("op:%c str:'%s' pat:'%s' res:'%s'",
5737                                 //              exp_op, t, exp_word, loc);
5738                                 free(exp_exp_word);
5739                                 if (loc) { /* match was found */
5740                                         if (scan_flags & SCAN_MATCH_LEFT_HALF) /* #[#] */
5741                                                 val = loc; /* take right part */
5742                                         else /* %[%] */
5743                                                 val = to_be_freed = xstrndup(val, loc - val); /* left */
5744                                 }
5745                         }
5746                 }
5747 #if BASH_PATTERN_SUBST
5748                 else if (exp_op == '/' || exp_op == '\\') {
5749                         /* It's ${var/[/]pattern[/repl]} thing.
5750                          * Note that in encoded form it has TWO parts:
5751                          * var/pattern<SPECIAL_VAR_SYMBOL>repl<SPECIAL_VAR_SYMBOL>
5752                          * and if // is used, it is encoded as \:
5753                          * var\pattern<SPECIAL_VAR_SYMBOL>repl<SPECIAL_VAR_SYMBOL>
5754                          */
5755                         /* Empty variable always gives nothing: */
5756                         // "v=''; echo ${v/*/w}" prints "", not "w"
5757                         if (val && val[0]) {
5758                                 /* pattern uses non-standard expansion.
5759                                  * repl should be unbackslashed and globbed
5760                                  * by the usual expansion rules:
5761                                  * >az; >bz;
5762                                  * v='a bz'; echo "${v/a*z/a*z}" prints "a*z"
5763                                  * v='a bz'; echo "${v/a*z/\z}"  prints "\z"
5764                                  * v='a bz'; echo ${v/a*z/a*z}   prints "az"
5765                                  * v='a bz'; echo ${v/a*z/\z}    prints "z"
5766                                  * (note that a*z _pattern_ is never globbed!)
5767                                  */
5768                                 char *pattern, *repl, *t;
5769                                 pattern = encode_then_expand_string(exp_word, /*process_bkslash:*/ 0, /*unbackslash:*/ 0);
5770                                 if (!pattern)
5771                                         pattern = xstrdup(exp_word);
5772                                 debug_printf_varexp("pattern:'%s'->'%s'\n", exp_word, pattern);
5773                                 *p++ = SPECIAL_VAR_SYMBOL;
5774                                 exp_word = p;
5775                                 p = strchr(p, SPECIAL_VAR_SYMBOL);
5776                                 *p = '\0';
5777                                 repl = encode_then_expand_string(exp_word, /*process_bkslash:*/ arg0 & 0x80, /*unbackslash:*/ 1);
5778                                 debug_printf_varexp("repl:'%s'->'%s'\n", exp_word, repl);
5779                                 /* HACK ALERT. We depend here on the fact that
5780                                  * G.global_argv and results of utoa and get_local_var_value
5781                                  * are actually in writable memory:
5782                                  * replace_pattern momentarily stores NULs there. */
5783                                 t = (char*)val;
5784                                 to_be_freed = replace_pattern(t,
5785                                                 pattern,
5786                                                 (repl ? repl : exp_word),
5787                                                 exp_op);
5788                                 if (to_be_freed) /* at least one replace happened */
5789                                         val = to_be_freed;
5790                                 free(pattern);
5791                                 free(repl);
5792                         }
5793                 }
5794 #endif /* BASH_PATTERN_SUBST */
5795                 else if (exp_op == ':') {
5796 #if BASH_SUBSTR && ENABLE_FEATURE_SH_MATH
5797                         /* It's ${var:N[:M]} bashism.
5798                          * Note that in encoded form it has TWO parts:
5799                          * var:N<SPECIAL_VAR_SYMBOL>M<SPECIAL_VAR_SYMBOL>
5800                          */
5801                         arith_t beg, len;
5802                         const char *errmsg;
5803
5804                         beg = expand_and_evaluate_arith(exp_word, &errmsg);
5805                         if (errmsg)
5806                                 goto arith_err;
5807                         debug_printf_varexp("beg:'%s'=%lld\n", exp_word, (long long)beg);
5808                         *p++ = SPECIAL_VAR_SYMBOL;
5809                         exp_word = p;
5810                         p = strchr(p, SPECIAL_VAR_SYMBOL);
5811                         *p = '\0';
5812                         len = expand_and_evaluate_arith(exp_word, &errmsg);
5813                         if (errmsg)
5814                                 goto arith_err;
5815                         debug_printf_varexp("len:'%s'=%lld\n", exp_word, (long long)len);
5816                         if (beg < 0) {
5817                                 /* negative beg counts from the end */
5818                                 beg = (arith_t)strlen(val) + beg;
5819                                 if (beg < 0) /* ${v: -999999} is "" */
5820                                         beg = len = 0;
5821                         }
5822                         debug_printf_varexp("from val:'%s'\n", val);
5823                         if (len < 0) {
5824                                 /* in bash, len=-n means strlen()-n */
5825                                 len = (arith_t)strlen(val) - beg + len;
5826                                 if (len < 0) /* bash compat */
5827                                         msg_and_die_if_script("%s: substring expression < 0", var);
5828                         }
5829                         if (len <= 0 || !val || beg >= strlen(val)) {
5830  arith_err:
5831                                 val = NULL;
5832                         } else {
5833                                 /* Paranoia. What if user entered 9999999999999
5834                                  * which fits in arith_t but not int? */
5835                                 if (len >= INT_MAX)
5836                                         len = INT_MAX;
5837                                 val = to_be_freed = xstrndup(val + beg, len);
5838                         }
5839                         debug_printf_varexp("val:'%s'\n", val);
5840 #else /* not (HUSH_SUBSTR_EXPANSION && FEATURE_SH_MATH) */
5841                         msg_and_die_if_script("malformed ${%s:...}", var);
5842                         val = NULL;
5843 #endif
5844                 } else { /* one of "-=+?" */
5845                         /* Standard-mandated substitution ops:
5846                          * ${var?word} - indicate error if unset
5847                          *      If var is unset, word (or a message indicating it is unset
5848                          *      if word is null) is written to standard error
5849                          *      and the shell exits with a non-zero exit status.
5850                          *      Otherwise, the value of var is substituted.
5851                          * ${var-word} - use default value
5852                          *      If var is unset, word is substituted.
5853                          * ${var=word} - assign and use default value
5854                          *      If var is unset, word is assigned to var.
5855                          *      In all cases, final value of var is substituted.
5856                          * ${var+word} - use alternative value
5857                          *      If var is unset, null is substituted.
5858                          *      Otherwise, word is substituted.
5859                          *
5860                          * Word is subjected to tilde expansion, parameter expansion,
5861                          * command substitution, and arithmetic expansion.
5862                          * If word is not needed, it is not expanded.
5863                          *
5864                          * Colon forms (${var:-word}, ${var:=word} etc) do the same,
5865                          * but also treat null var as if it is unset.
5866                          */
5867                         int use_word = (!val || ((exp_save == ':') && !val[0]));
5868                         if (exp_op == '+')
5869                                 use_word = !use_word;
5870                         debug_printf_expand("expand: op:%c (null:%s) test:%i\n", exp_op,
5871                                         (exp_save == ':') ? "true" : "false", use_word);
5872                         if (use_word) {
5873                                 to_be_freed = encode_then_expand_string(exp_word, /*process_bkslash:*/ 1, /*unbackslash:*/ 1);
5874                                 if (to_be_freed)
5875                                         exp_word = to_be_freed;
5876                                 if (exp_op == '?') {
5877                                         /* mimic bash message */
5878                                         msg_and_die_if_script("%s: %s",
5879                                                 var,
5880                                                 exp_word[0]
5881                                                 ? exp_word
5882                                                 : "parameter null or not set"
5883                                                 /* ash has more specific messages, a-la: */
5884                                                 /*: (exp_save == ':' ? "parameter null or not set" : "parameter not set")*/
5885                                         );
5886 //TODO: how interactive bash aborts expansion mid-command?
5887                                 } else {
5888                                         val = exp_word;
5889                                 }
5890
5891                                 if (exp_op == '=') {
5892                                         /* ${var=[word]} or ${var:=[word]} */
5893                                         if (isdigit(var[0]) || var[0] == '#') {
5894                                                 /* mimic bash message */
5895                                                 msg_and_die_if_script("$%s: cannot assign in this way", var);
5896                                                 val = NULL;
5897                                         } else {
5898                                                 char *new_var = xasprintf("%s=%s", var, val);
5899                                                 set_local_var(new_var, /*flag:*/ 0);
5900                                         }
5901                                 }
5902                         }
5903                 } /* one of "-=+?" */
5904
5905                 *exp_saveptr = exp_save;
5906         } /* if (exp_op) */
5907
5908         arg[0] = arg0;
5909
5910         *pp = p;
5911         *to_be_freed_pp = to_be_freed;
5912         return val;
5913 }
5914
5915 /* Expand all variable references in given string, adding words to list[]
5916  * at n, n+1,... positions. Return updated n (so that list[n] is next one
5917  * to be filled). This routine is extremely tricky: has to deal with
5918  * variables/parameters with whitespace, $* and $@, and constructs like
5919  * 'echo -$*-'. If you play here, you must run testsuite afterwards! */
5920 static NOINLINE int expand_vars_to_list(o_string *output, int n, char *arg)
5921 {
5922         /* output->o_expflags & EXP_FLAG_SINGLEWORD (0x80) if we are in
5923          * expansion of right-hand side of assignment == 1-element expand.
5924          */
5925         char cant_be_null = 0; /* only bit 0x80 matters */
5926         int ended_in_ifs = 0;  /* did last unquoted expansion end with IFS chars? */
5927         char *p;
5928
5929         debug_printf_expand("expand_vars_to_list: arg:'%s' singleword:%x\n", arg,
5930                         !!(output->o_expflags & EXP_FLAG_SINGLEWORD));
5931         debug_print_list("expand_vars_to_list", output, n);
5932         n = o_save_ptr(output, n);
5933         debug_print_list("expand_vars_to_list[0]", output, n);
5934
5935         while ((p = strchr(arg, SPECIAL_VAR_SYMBOL)) != NULL) {
5936                 char first_ch;
5937                 char *to_be_freed = NULL;
5938                 const char *val = NULL;
5939 #if ENABLE_HUSH_TICK
5940                 o_string subst_result = NULL_O_STRING;
5941 #endif
5942 #if ENABLE_FEATURE_SH_MATH
5943                 char arith_buf[sizeof(arith_t)*3 + 2];
5944 #endif
5945
5946                 if (ended_in_ifs) {
5947                         o_addchr(output, '\0');
5948                         n = o_save_ptr(output, n);
5949                         ended_in_ifs = 0;
5950                 }
5951
5952                 o_addblock(output, arg, p - arg);
5953                 debug_print_list("expand_vars_to_list[1]", output, n);
5954                 arg = ++p;
5955                 p = strchr(p, SPECIAL_VAR_SYMBOL);
5956
5957                 /* Fetch special var name (if it is indeed one of them)
5958                  * and quote bit, force the bit on if singleword expansion -
5959                  * important for not getting v=$@ expand to many words. */
5960                 first_ch = arg[0] | (output->o_expflags & EXP_FLAG_SINGLEWORD);
5961
5962                 /* Is this variable quoted and thus expansion can't be null?
5963                  * "$@" is special. Even if quoted, it can still
5964                  * expand to nothing (not even an empty string),
5965                  * thus it is excluded. */
5966                 if ((first_ch & 0x7f) != '@')
5967                         cant_be_null |= first_ch;
5968
5969                 switch (first_ch & 0x7f) {
5970                 /* Highest bit in first_ch indicates that var is double-quoted */
5971                 case '*':
5972                 case '@': {
5973                         int i;
5974                         if (!G.global_argv[1])
5975                                 break;
5976                         i = 1;
5977                         cant_be_null |= first_ch; /* do it for "$@" _now_, when we know it's not empty */
5978                         if (!(first_ch & 0x80)) { /* unquoted $* or $@ */
5979                                 while (G.global_argv[i]) {
5980                                         n = expand_on_ifs(NULL, output, n, G.global_argv[i]);
5981                                         debug_printf_expand("expand_vars_to_list: argv %d (last %d)\n", i, G.global_argc - 1);
5982                                         if (G.global_argv[i++][0] && G.global_argv[i]) {
5983                                                 /* this argv[] is not empty and not last:
5984                                                  * put terminating NUL, start new word */
5985                                                 o_addchr(output, '\0');
5986                                                 debug_print_list("expand_vars_to_list[2]", output, n);
5987                                                 n = o_save_ptr(output, n);
5988                                                 debug_print_list("expand_vars_to_list[3]", output, n);
5989                                         }
5990                                 }
5991                         } else
5992                         /* If EXP_FLAG_SINGLEWORD, we handle assignment 'a=....$@.....'
5993                          * and in this case should treat it like '$*' - see 'else...' below */
5994                         if (first_ch == ('@'|0x80)  /* quoted $@ */
5995                          && !(output->o_expflags & EXP_FLAG_SINGLEWORD) /* not v="$@" case */
5996                         ) {
5997                                 while (1) {
5998                                         o_addQstr(output, G.global_argv[i]);
5999                                         if (++i >= G.global_argc)
6000                                                 break;
6001                                         o_addchr(output, '\0');
6002                                         debug_print_list("expand_vars_to_list[4]", output, n);
6003                                         n = o_save_ptr(output, n);
6004                                 }
6005                         } else { /* quoted $* (or v="$@" case): add as one word */
6006                                 while (1) {
6007                                         o_addQstr(output, G.global_argv[i]);
6008                                         if (!G.global_argv[++i])
6009                                                 break;
6010                                         if (G.ifs[0])
6011                                                 o_addchr(output, G.ifs[0]);
6012                                 }
6013                                 output->has_quoted_part = 1;
6014                         }
6015                         break;
6016                 }
6017                 case SPECIAL_VAR_SYMBOL: /* <SPECIAL_VAR_SYMBOL><SPECIAL_VAR_SYMBOL> */
6018                         /* "Empty variable", used to make "" etc to not disappear */
6019                         output->has_quoted_part = 1;
6020                         arg++;
6021                         cant_be_null = 0x80;
6022                         break;
6023 #if ENABLE_HUSH_TICK
6024                 case '`': /* <SPECIAL_VAR_SYMBOL>`cmd<SPECIAL_VAR_SYMBOL> */
6025                         *p = '\0'; /* replace trailing <SPECIAL_VAR_SYMBOL> */
6026                         arg++;
6027                         /* Can't just stuff it into output o_string,
6028                          * expanded result may need to be globbed
6029                          * and $IFS-split */
6030                         debug_printf_subst("SUBST '%s' first_ch %x\n", arg, first_ch);
6031                         G.last_exitcode = process_command_subs(&subst_result, arg);
6032                         debug_printf_subst("SUBST RES:%d '%s'\n", G.last_exitcode, subst_result.data);
6033                         val = subst_result.data;
6034                         goto store_val;
6035 #endif
6036 #if ENABLE_FEATURE_SH_MATH
6037                 case '+': { /* <SPECIAL_VAR_SYMBOL>+cmd<SPECIAL_VAR_SYMBOL> */
6038                         arith_t res;
6039
6040                         arg++; /* skip '+' */
6041                         *p = '\0'; /* replace trailing <SPECIAL_VAR_SYMBOL> */
6042                         debug_printf_subst("ARITH '%s' first_ch %x\n", arg, first_ch);
6043                         res = expand_and_evaluate_arith(arg, NULL);
6044                         debug_printf_subst("ARITH RES '"ARITH_FMT"'\n", res);
6045                         sprintf(arith_buf, ARITH_FMT, res);
6046                         val = arith_buf;
6047                         break;
6048                 }
6049 #endif
6050                 default:
6051                         val = expand_one_var(&to_be_freed, arg, &p);
6052  IF_HUSH_TICK(store_val:)
6053                         if (!(first_ch & 0x80)) { /* unquoted $VAR */
6054                                 debug_printf_expand("unquoted '%s', output->o_escape:%d\n", val,
6055                                                 !!(output->o_expflags & EXP_FLAG_ESC_GLOB_CHARS));
6056                                 if (val && val[0]) {
6057                                         n = expand_on_ifs(&ended_in_ifs, output, n, val);
6058                                         val = NULL;
6059                                 }
6060                         } else { /* quoted $VAR, val will be appended below */
6061                                 output->has_quoted_part = 1;
6062                                 debug_printf_expand("quoted '%s', output->o_escape:%d\n", val,
6063                                                 !!(output->o_expflags & EXP_FLAG_ESC_GLOB_CHARS));
6064                         }
6065                         break;
6066                 } /* switch (char after <SPECIAL_VAR_SYMBOL>) */
6067
6068                 if (val && val[0]) {
6069                         o_addQstr(output, val);
6070                 }
6071                 free(to_be_freed);
6072
6073                 /* Restore NULL'ed SPECIAL_VAR_SYMBOL.
6074                  * Do the check to avoid writing to a const string. */
6075                 if (*p != SPECIAL_VAR_SYMBOL)
6076                         *p = SPECIAL_VAR_SYMBOL;
6077
6078 #if ENABLE_HUSH_TICK
6079                 o_free(&subst_result);
6080 #endif
6081                 arg = ++p;
6082         } /* end of "while (SPECIAL_VAR_SYMBOL is found) ..." */
6083
6084         if (arg[0]) {
6085                 if (ended_in_ifs) {
6086                         o_addchr(output, '\0');
6087                         n = o_save_ptr(output, n);
6088                 }
6089                 debug_print_list("expand_vars_to_list[a]", output, n);
6090                 /* this part is literal, and it was already pre-quoted
6091                  * if needed (much earlier), do not use o_addQstr here! */
6092                 o_addstr_with_NUL(output, arg);
6093                 debug_print_list("expand_vars_to_list[b]", output, n);
6094         } else if (output->length == o_get_last_ptr(output, n) /* expansion is empty */
6095          && !(cant_be_null & 0x80) /* and all vars were not quoted. */
6096         ) {
6097                 n--;
6098                 /* allow to reuse list[n] later without re-growth */
6099                 output->has_empty_slot = 1;
6100         } else {
6101                 o_addchr(output, '\0');
6102         }
6103
6104         return n;
6105 }
6106
6107 static char **expand_variables(char **argv, unsigned expflags)
6108 {
6109         int n;
6110         char **list;
6111         o_string output = NULL_O_STRING;
6112
6113         output.o_expflags = expflags;
6114
6115         n = 0;
6116         while (*argv) {
6117                 n = expand_vars_to_list(&output, n, *argv);
6118                 argv++;
6119         }
6120         debug_print_list("expand_variables", &output, n);
6121
6122         /* output.data (malloced in one block) gets returned in "list" */
6123         list = o_finalize_list(&output, n);
6124         debug_print_strings("expand_variables[1]", list);
6125         return list;
6126 }
6127
6128 static char **expand_strvec_to_strvec(char **argv)
6129 {
6130         return expand_variables(argv, EXP_FLAG_GLOB | EXP_FLAG_ESC_GLOB_CHARS);
6131 }
6132
6133 #if BASH_TEST2
6134 static char **expand_strvec_to_strvec_singleword_noglob(char **argv)
6135 {
6136         return expand_variables(argv, EXP_FLAG_SINGLEWORD);
6137 }
6138 #endif
6139
6140 /* Used for expansion of right hand of assignments,
6141  * $((...)), heredocs, variable espansion parts.
6142  *
6143  * NB: should NOT do globbing!
6144  * "export v=/bin/c*; env | grep ^v=" outputs "v=/bin/c*"
6145  */
6146 static char *expand_string_to_string(const char *str, int do_unbackslash)
6147 {
6148 #if !BASH_PATTERN_SUBST && !ENABLE_HUSH_CASE
6149         const int do_unbackslash = 1;
6150 #endif
6151         char *argv[2], **list;
6152
6153         debug_printf_expand("string_to_string<='%s'\n", str);
6154         /* This is generally an optimization, but it also
6155          * handles "", which otherwise trips over !list[0] check below.
6156          * (is this ever happens that we actually get str="" here?)
6157          */
6158         if (!strchr(str, SPECIAL_VAR_SYMBOL) && !strchr(str, '\\')) {
6159                 //TODO: Can use on strings with \ too, just unbackslash() them?
6160                 debug_printf_expand("string_to_string(fast)=>'%s'\n", str);
6161                 return xstrdup(str);
6162         }
6163
6164         argv[0] = (char*)str;
6165         argv[1] = NULL;
6166         list = expand_variables(argv, do_unbackslash
6167                         ? EXP_FLAG_ESC_GLOB_CHARS | EXP_FLAG_SINGLEWORD
6168                         : EXP_FLAG_SINGLEWORD
6169         );
6170         if (HUSH_DEBUG)
6171                 if (!list[0] || list[1])
6172                         bb_error_msg_and_die("BUG in varexp2");
6173         /* actually, just move string 2*sizeof(char*) bytes back */
6174         overlapping_strcpy((char*)list, list[0]);
6175         if (do_unbackslash)
6176                 unbackslash((char*)list);
6177         debug_printf_expand("string_to_string=>'%s'\n", (char*)list);
6178         return (char*)list;
6179 }
6180
6181 /* Used for "eval" builtin and case string */
6182 static char* expand_strvec_to_string(char **argv)
6183 {
6184         char **list;
6185
6186         list = expand_variables(argv, EXP_FLAG_SINGLEWORD);
6187         /* Convert all NULs to spaces */
6188         if (list[0]) {
6189                 int n = 1;
6190                 while (list[n]) {
6191                         if (HUSH_DEBUG)
6192                                 if (list[n-1] + strlen(list[n-1]) + 1 != list[n])
6193                                         bb_error_msg_and_die("BUG in varexp3");
6194                         /* bash uses ' ' regardless of $IFS contents */
6195                         list[n][-1] = ' ';
6196                         n++;
6197                 }
6198         }
6199         overlapping_strcpy((char*)list, list[0] ? list[0] : "");
6200         debug_printf_expand("strvec_to_string='%s'\n", (char*)list);
6201         return (char*)list;
6202 }
6203
6204 static char **expand_assignments(char **argv, int count)
6205 {
6206         int i;
6207         char **p;
6208
6209         G.expanded_assignments = p = NULL;
6210         /* Expand assignments into one string each */
6211         for (i = 0; i < count; i++) {
6212                 G.expanded_assignments = p = add_string_to_strings(p, expand_string_to_string(argv[i], /*unbackslash:*/ 1));
6213         }
6214         G.expanded_assignments = NULL;
6215         return p;
6216 }
6217
6218
6219 static void switch_off_special_sigs(unsigned mask)
6220 {
6221         unsigned sig = 0;
6222         while ((mask >>= 1) != 0) {
6223                 sig++;
6224                 if (!(mask & 1))
6225                         continue;
6226 #if ENABLE_HUSH_TRAP
6227                 if (G_traps) {
6228                         if (G_traps[sig] && !G_traps[sig][0])
6229                                 /* trap is '', has to remain SIG_IGN */
6230                                 continue;
6231                         free(G_traps[sig]);
6232                         G_traps[sig] = NULL;
6233                 }
6234 #endif
6235                 /* We are here only if no trap or trap was not '' */
6236                 install_sighandler(sig, SIG_DFL);
6237         }
6238 }
6239
6240 #if BB_MMU
6241 /* never called */
6242 void re_execute_shell(char ***to_free, const char *s,
6243                 char *g_argv0, char **g_argv,
6244                 char **builtin_argv) NORETURN;
6245
6246 static void reset_traps_to_defaults(void)
6247 {
6248         /* This function is always called in a child shell
6249          * after fork (not vfork, NOMMU doesn't use this function).
6250          */
6251         IF_HUSH_TRAP(unsigned sig;)
6252         unsigned mask;
6253
6254         /* Child shells are not interactive.
6255          * SIGTTIN/SIGTTOU/SIGTSTP should not have special handling.
6256          * Testcase: (while :; do :; done) + ^Z should background.
6257          * Same goes for SIGTERM, SIGHUP, SIGINT.
6258          */
6259         mask = (G.special_sig_mask & SPECIAL_INTERACTIVE_SIGS) | G_fatal_sig_mask;
6260         if (!G_traps && !mask)
6261                 return; /* already no traps and no special sigs */
6262
6263         /* Switch off special sigs */
6264         switch_off_special_sigs(mask);
6265 # if ENABLE_HUSH_JOB
6266         G_fatal_sig_mask = 0;
6267 # endif
6268         G.special_sig_mask &= ~SPECIAL_INTERACTIVE_SIGS;
6269         /* SIGQUIT,SIGCHLD and maybe SPECIAL_JOBSTOP_SIGS
6270          * remain set in G.special_sig_mask */
6271
6272 # if ENABLE_HUSH_TRAP
6273         if (!G_traps)
6274                 return;
6275
6276         /* Reset all sigs to default except ones with empty traps */
6277         for (sig = 0; sig < NSIG; sig++) {
6278                 if (!G_traps[sig])
6279                         continue; /* no trap: nothing to do */
6280                 if (!G_traps[sig][0])
6281                         continue; /* empty trap: has to remain SIG_IGN */
6282                 /* sig has non-empty trap, reset it: */
6283                 free(G_traps[sig]);
6284                 G_traps[sig] = NULL;
6285                 /* There is no signal for trap 0 (EXIT) */
6286                 if (sig == 0)
6287                         continue;
6288                 install_sighandler(sig, pick_sighandler(sig));
6289         }
6290 # endif
6291 }
6292
6293 #else /* !BB_MMU */
6294
6295 static void re_execute_shell(char ***to_free, const char *s,
6296                 char *g_argv0, char **g_argv,
6297                 char **builtin_argv) NORETURN;
6298 static void re_execute_shell(char ***to_free, const char *s,
6299                 char *g_argv0, char **g_argv,
6300                 char **builtin_argv)
6301 {
6302 # define NOMMU_HACK_FMT ("-$%x:%x:%x:%x:%x:%llx" IF_HUSH_LOOPS(":%x"))
6303         /* delims + 2 * (number of bytes in printed hex numbers) */
6304         char param_buf[sizeof(NOMMU_HACK_FMT) + 2 * (sizeof(int)*6 + sizeof(long long)*1)];
6305         char *heredoc_argv[4];
6306         struct variable *cur;
6307 # if ENABLE_HUSH_FUNCTIONS
6308         struct function *funcp;
6309 # endif
6310         char **argv, **pp;
6311         unsigned cnt;
6312         unsigned long long empty_trap_mask;
6313
6314         if (!g_argv0) { /* heredoc */
6315                 argv = heredoc_argv;
6316                 argv[0] = (char *) G.argv0_for_re_execing;
6317                 argv[1] = (char *) "-<";
6318                 argv[2] = (char *) s;
6319                 argv[3] = NULL;
6320                 pp = &argv[3]; /* used as pointer to empty environment */
6321                 goto do_exec;
6322         }
6323
6324         cnt = 0;
6325         pp = builtin_argv;
6326         if (pp) while (*pp++)
6327                 cnt++;
6328
6329         empty_trap_mask = 0;
6330         if (G_traps) {
6331                 int sig;
6332                 for (sig = 1; sig < NSIG; sig++) {
6333                         if (G_traps[sig] && !G_traps[sig][0])
6334                                 empty_trap_mask |= 1LL << sig;
6335                 }
6336         }
6337
6338         sprintf(param_buf, NOMMU_HACK_FMT
6339                         , (unsigned) G.root_pid
6340                         , (unsigned) G.root_ppid
6341                         , (unsigned) G.last_bg_pid
6342                         , (unsigned) G.last_exitcode
6343                         , cnt
6344                         , empty_trap_mask
6345                         IF_HUSH_LOOPS(, G.depth_of_loop)
6346                         );
6347 # undef NOMMU_HACK_FMT
6348         /* 1:hush 2:-$<pid>:<pid>:<exitcode>:<etc...> <vars...> <funcs...>
6349          * 3:-c 4:<cmd> 5:<arg0> <argN...> 6:NULL
6350          */
6351         cnt += 6;
6352         for (cur = G.top_var; cur; cur = cur->next) {
6353                 if (!cur->flg_export || cur->flg_read_only)
6354                         cnt += 2;
6355         }
6356 # if ENABLE_HUSH_FUNCTIONS
6357         for (funcp = G.top_func; funcp; funcp = funcp->next)
6358                 cnt += 3;
6359 # endif
6360         pp = g_argv;
6361         while (*pp++)
6362                 cnt++;
6363         *to_free = argv = pp = xzalloc(sizeof(argv[0]) * cnt);
6364         *pp++ = (char *) G.argv0_for_re_execing;
6365         *pp++ = param_buf;
6366         for (cur = G.top_var; cur; cur = cur->next) {
6367                 if (strcmp(cur->varstr, hush_version_str) == 0)
6368                         continue;
6369                 if (cur->flg_read_only) {
6370                         *pp++ = (char *) "-R";
6371                         *pp++ = cur->varstr;
6372                 } else if (!cur->flg_export) {
6373                         *pp++ = (char *) "-V";
6374                         *pp++ = cur->varstr;
6375                 }
6376         }
6377 # if ENABLE_HUSH_FUNCTIONS
6378         for (funcp = G.top_func; funcp; funcp = funcp->next) {
6379                 *pp++ = (char *) "-F";
6380                 *pp++ = funcp->name;
6381                 *pp++ = funcp->body_as_string;
6382         }
6383 # endif
6384         /* We can pass activated traps here. Say, -Tnn:trap_string
6385          *
6386          * However, POSIX says that subshells reset signals with traps
6387          * to SIG_DFL.
6388          * I tested bash-3.2 and it not only does that with true subshells
6389          * of the form ( list ), but with any forked children shells.
6390          * I set trap "echo W" WINCH; and then tried:
6391          *
6392          * { echo 1; sleep 20; echo 2; } &
6393          * while true; do echo 1; sleep 20; echo 2; break; done &
6394          * true | { echo 1; sleep 20; echo 2; } | cat
6395          *
6396          * In all these cases sending SIGWINCH to the child shell
6397          * did not run the trap. If I add trap "echo V" WINCH;
6398          * _inside_ group (just before echo 1), it works.
6399          *
6400          * I conclude it means we don't need to pass active traps here.
6401          */
6402         *pp++ = (char *) "-c";
6403         *pp++ = (char *) s;
6404         if (builtin_argv) {
6405                 while (*++builtin_argv)
6406                         *pp++ = *builtin_argv;
6407                 *pp++ = (char *) "";
6408         }
6409         *pp++ = g_argv0;
6410         while (*g_argv)
6411                 *pp++ = *g_argv++;
6412         /* *pp = NULL; - is already there */
6413         pp = environ;
6414
6415  do_exec:
6416         debug_printf_exec("re_execute_shell pid:%d cmd:'%s'\n", getpid(), s);
6417         /* Don't propagate SIG_IGN to the child */
6418         if (SPECIAL_JOBSTOP_SIGS != 0)
6419                 switch_off_special_sigs(G.special_sig_mask & SPECIAL_JOBSTOP_SIGS);
6420         execve(bb_busybox_exec_path, argv, pp);
6421         /* Fallback. Useful for init=/bin/hush usage etc */
6422         if (argv[0][0] == '/')
6423                 execve(argv[0], argv, pp);
6424         xfunc_error_retval = 127;
6425         bb_error_msg_and_die("can't re-execute the shell");
6426 }
6427 #endif  /* !BB_MMU */
6428
6429
6430 static int run_and_free_list(struct pipe *pi);
6431
6432 /* Executing from string: eval, sh -c '...'
6433  *          or from file: /etc/profile, . file, sh <script>, sh (intereactive)
6434  * end_trigger controls how often we stop parsing
6435  * NUL: parse all, execute, return
6436  * ';': parse till ';' or newline, execute, repeat till EOF
6437  */
6438 static void parse_and_run_stream(struct in_str *inp, int end_trigger)
6439 {
6440         /* Why we need empty flag?
6441          * An obscure corner case "false; ``; echo $?":
6442          * empty command in `` should still set $? to 0.
6443          * But we can't just set $? to 0 at the start,
6444          * this breaks "false; echo `echo $?`" case.
6445          */
6446         bool empty = 1;
6447         while (1) {
6448                 struct pipe *pipe_list;
6449
6450 #if ENABLE_HUSH_INTERACTIVE
6451                 if (end_trigger == ';')
6452                         inp->promptmode = 0; /* PS1 */
6453 #endif
6454                 pipe_list = parse_stream(NULL, inp, end_trigger);
6455                 if (!pipe_list || pipe_list == ERR_PTR) { /* EOF/error */
6456                         /* If we are in "big" script
6457                          * (not in `cmd` or something similar)...
6458                          */
6459                         if (pipe_list == ERR_PTR && end_trigger == ';') {
6460                                 /* Discard cached input (rest of line) */
6461                                 int ch = inp->last_char;
6462                                 while (ch != EOF && ch != '\n') {
6463                                         //bb_error_msg("Discarded:'%c'", ch);
6464                                         ch = i_getch(inp);
6465                                 }
6466                                 /* Force prompt */
6467                                 inp->p = NULL;
6468                                 /* This stream isn't empty */
6469                                 empty = 0;
6470                                 continue;
6471                         }
6472                         if (!pipe_list && empty)
6473                                 G.last_exitcode = 0;
6474                         break;
6475                 }
6476                 debug_print_tree(pipe_list, 0);
6477                 debug_printf_exec("parse_and_run_stream: run_and_free_list\n");
6478                 run_and_free_list(pipe_list);
6479                 empty = 0;
6480                 if (G_flag_return_in_progress == 1)
6481                         break;
6482         }
6483 }
6484
6485 static void parse_and_run_string(const char *s)
6486 {
6487         struct in_str input;
6488         setup_string_in_str(&input, s);
6489         parse_and_run_stream(&input, '\0');
6490 }
6491
6492 static void parse_and_run_file(FILE *f)
6493 {
6494         struct in_str input;
6495         setup_file_in_str(&input, f);
6496         parse_and_run_stream(&input, ';');
6497 }
6498
6499 #if ENABLE_HUSH_TICK
6500 static FILE *generate_stream_from_string(const char *s, pid_t *pid_p)
6501 {
6502         pid_t pid;
6503         int channel[2];
6504 # if !BB_MMU
6505         char **to_free = NULL;
6506 # endif
6507
6508         xpipe(channel);
6509         pid = BB_MMU ? xfork() : xvfork();
6510         if (pid == 0) { /* child */
6511                 disable_restore_tty_pgrp_on_exit();
6512                 /* Process substitution is not considered to be usual
6513                  * 'command execution'.
6514                  * SUSv3 says ctrl-Z should be ignored, ctrl-C should not.
6515                  */
6516                 bb_signals(0
6517                         + (1 << SIGTSTP)
6518                         + (1 << SIGTTIN)
6519                         + (1 << SIGTTOU)
6520                         , SIG_IGN);
6521                 CLEAR_RANDOM_T(&G.random_gen); /* or else $RANDOM repeats in child */
6522                 close(channel[0]); /* NB: close _first_, then move fd! */
6523                 xmove_fd(channel[1], 1);
6524                 /* Prevent it from trying to handle ctrl-z etc */
6525                 IF_HUSH_JOB(G.run_list_level = 1;)
6526 # if ENABLE_HUSH_TRAP
6527                 /* Awful hack for `trap` or $(trap).
6528                  *
6529                  * http://www.opengroup.org/onlinepubs/009695399/utilities/trap.html
6530                  * contains an example where "trap" is executed in a subshell:
6531                  *
6532                  * save_traps=$(trap)
6533                  * ...
6534                  * eval "$save_traps"
6535                  *
6536                  * Standard does not say that "trap" in subshell shall print
6537                  * parent shell's traps. It only says that its output
6538                  * must have suitable form, but then, in the above example
6539                  * (which is not supposed to be normative), it implies that.
6540                  *
6541                  * bash (and probably other shell) does implement it
6542                  * (traps are reset to defaults, but "trap" still shows them),
6543                  * but as a result, "trap" logic is hopelessly messed up:
6544                  *
6545                  * # trap
6546                  * trap -- 'echo Ho' SIGWINCH  <--- we have a handler
6547                  * # (trap)        <--- trap is in subshell - no output (correct, traps are reset)
6548                  * # true | trap   <--- trap is in subshell - no output (ditto)
6549                  * # echo `true | trap`    <--- in subshell - output (but traps are reset!)
6550                  * trap -- 'echo Ho' SIGWINCH
6551                  * # echo `(trap)`         <--- in subshell in subshell - output
6552                  * trap -- 'echo Ho' SIGWINCH
6553                  * # echo `true | (trap)`  <--- in subshell in subshell in subshell - output!
6554                  * trap -- 'echo Ho' SIGWINCH
6555                  *
6556                  * The rules when to forget and when to not forget traps
6557                  * get really complex and nonsensical.
6558                  *
6559                  * Our solution: ONLY bare $(trap) or `trap` is special.
6560                  */
6561                 s = skip_whitespace(s);
6562                 if (is_prefixed_with(s, "trap")
6563                  && skip_whitespace(s + 4)[0] == '\0'
6564                 ) {
6565                         static const char *const argv[] = { NULL, NULL };
6566                         builtin_trap((char**)argv);
6567                         fflush_all(); /* important */
6568                         _exit(0);
6569                 }
6570 # endif
6571 # if BB_MMU
6572                 reset_traps_to_defaults();
6573                 parse_and_run_string(s);
6574                 _exit(G.last_exitcode);
6575 # else
6576         /* We re-execute after vfork on NOMMU. This makes this script safe:
6577          * yes "0123456789012345678901234567890" | dd bs=32 count=64k >BIG
6578          * huge=`cat BIG` # was blocking here forever
6579          * echo OK
6580          */
6581                 re_execute_shell(&to_free,
6582                                 s,
6583                                 G.global_argv[0],
6584                                 G.global_argv + 1,
6585                                 NULL);
6586 # endif
6587         }
6588
6589         /* parent */
6590         *pid_p = pid;
6591 # if ENABLE_HUSH_FAST
6592         G.count_SIGCHLD++;
6593 //bb_error_msg("[%d] fork in generate_stream_from_string:"
6594 //              " G.count_SIGCHLD:%d G.handled_SIGCHLD:%d",
6595 //              getpid(), G.count_SIGCHLD, G.handled_SIGCHLD);
6596 # endif
6597         enable_restore_tty_pgrp_on_exit();
6598 # if !BB_MMU
6599         free(to_free);
6600 # endif
6601         close(channel[1]);
6602         return remember_FILE(xfdopen_for_read(channel[0]));
6603 }
6604
6605 /* Return code is exit status of the process that is run. */
6606 static int process_command_subs(o_string *dest, const char *s)
6607 {
6608         FILE *fp;
6609         struct in_str pipe_str;
6610         pid_t pid;
6611         int status, ch, eol_cnt;
6612
6613         fp = generate_stream_from_string(s, &pid);
6614
6615         /* Now send results of command back into original context */
6616         setup_file_in_str(&pipe_str, fp);
6617         eol_cnt = 0;
6618         while ((ch = i_getch(&pipe_str)) != EOF) {
6619                 if (ch == '\n') {
6620                         eol_cnt++;
6621                         continue;
6622                 }
6623                 while (eol_cnt) {
6624                         o_addchr(dest, '\n');
6625                         eol_cnt--;
6626                 }
6627                 o_addQchr(dest, ch);
6628         }
6629
6630         debug_printf("done reading from `cmd` pipe, closing it\n");
6631         fclose_and_forget(fp);
6632         /* We need to extract exitcode. Test case
6633          * "true; echo `sleep 1; false` $?"
6634          * should print 1 */
6635         safe_waitpid(pid, &status, 0);
6636         debug_printf("child exited. returning its exitcode:%d\n", WEXITSTATUS(status));
6637         return WEXITSTATUS(status);
6638 }
6639 #endif /* ENABLE_HUSH_TICK */
6640
6641
6642 static void setup_heredoc(struct redir_struct *redir)
6643 {
6644         struct fd_pair pair;
6645         pid_t pid;
6646         int len, written;
6647         /* the _body_ of heredoc (misleading field name) */
6648         const char *heredoc = redir->rd_filename;
6649         char *expanded;
6650 #if !BB_MMU
6651         char **to_free;
6652 #endif
6653
6654         expanded = NULL;
6655         if (!(redir->rd_dup & HEREDOC_QUOTED)) {
6656                 expanded = encode_then_expand_string(heredoc, /*process_bkslash:*/ 1, /*unbackslash:*/ 1);
6657                 if (expanded)
6658                         heredoc = expanded;
6659         }
6660         len = strlen(heredoc);
6661
6662         close(redir->rd_fd); /* often saves dup2+close in xmove_fd */
6663         xpiped_pair(pair);
6664         xmove_fd(pair.rd, redir->rd_fd);
6665
6666         /* Try writing without forking. Newer kernels have
6667          * dynamically growing pipes. Must use non-blocking write! */
6668         ndelay_on(pair.wr);
6669         while (1) {
6670                 written = write(pair.wr, heredoc, len);
6671                 if (written <= 0)
6672                         break;
6673                 len -= written;
6674                 if (len == 0) {
6675                         close(pair.wr);
6676                         free(expanded);
6677                         return;
6678                 }
6679                 heredoc += written;
6680         }
6681         ndelay_off(pair.wr);
6682
6683         /* Okay, pipe buffer was not big enough */
6684         /* Note: we must not create a stray child (bastard? :)
6685          * for the unsuspecting parent process. Child creates a grandchild
6686          * and exits before parent execs the process which consumes heredoc
6687          * (that exec happens after we return from this function) */
6688 #if !BB_MMU
6689         to_free = NULL;
6690 #endif
6691         pid = xvfork();
6692         if (pid == 0) {
6693                 /* child */
6694                 disable_restore_tty_pgrp_on_exit();
6695                 pid = BB_MMU ? xfork() : xvfork();
6696                 if (pid != 0)
6697                         _exit(0);
6698                 /* grandchild */
6699                 close(redir->rd_fd); /* read side of the pipe */
6700 #if BB_MMU
6701                 full_write(pair.wr, heredoc, len); /* may loop or block */
6702                 _exit(0);
6703 #else
6704                 /* Delegate blocking writes to another process */
6705                 xmove_fd(pair.wr, STDOUT_FILENO);
6706                 re_execute_shell(&to_free, heredoc, NULL, NULL, NULL);
6707 #endif
6708         }
6709         /* parent */
6710 #if ENABLE_HUSH_FAST
6711         G.count_SIGCHLD++;
6712 //bb_error_msg("[%d] fork in setup_heredoc: G.count_SIGCHLD:%d G.handled_SIGCHLD:%d", getpid(), G.count_SIGCHLD, G.handled_SIGCHLD);
6713 #endif
6714         enable_restore_tty_pgrp_on_exit();
6715 #if !BB_MMU
6716         free(to_free);
6717 #endif
6718         close(pair.wr);
6719         free(expanded);
6720         wait(NULL); /* wait till child has died */
6721 }
6722
6723 struct squirrel {
6724         int orig_fd;
6725         int moved_to;
6726         /* moved_to = n: fd was moved to n; restore back to orig_fd after redir */
6727         /* moved_to = -1: fd was opened by redirect; close orig_fd after redir */
6728 };
6729
6730 static struct squirrel *append_squirrel(struct squirrel *sq, int i, int orig, int moved)
6731 {
6732         sq = xrealloc(sq, (i + 2) * sizeof(sq[0]));
6733         sq[i].orig_fd = orig;
6734         sq[i].moved_to = moved;
6735         sq[i+1].orig_fd = -1; /* end marker */
6736         return sq;
6737 }
6738
6739 static struct squirrel *add_squirrel(struct squirrel *sq, int fd, int avoid_fd)
6740 {
6741         int moved_to;
6742         int i;
6743
6744         if (sq) for (i = 0; sq[i].orig_fd >= 0; i++) {
6745                 /* If we collide with an already moved fd... */
6746                 if (fd == sq[i].moved_to) {
6747                         sq[i].moved_to = fcntl_F_DUPFD(sq[i].moved_to, avoid_fd);
6748                         debug_printf_redir("redirect_fd %d: already busy, moving to %d\n", fd, sq[i].moved_to);
6749                         if (sq[i].moved_to < 0) /* what? */
6750                                 xfunc_die();
6751                         return sq;
6752                 }
6753                 if (fd == sq[i].orig_fd) {
6754                         /* Example: echo Hello >/dev/null 1>&2 */
6755                         debug_printf_redir("redirect_fd %d: already moved\n", fd);
6756                         return sq;
6757                 }
6758         }
6759
6760         /* If this fd is open, we move and remember it; if it's closed, moved_to = -1 */
6761         moved_to = fcntl_F_DUPFD(fd, avoid_fd);
6762         debug_printf_redir("redirect_fd %d: previous fd is moved to %d (-1 if it was closed)\n", fd, moved_to);
6763         if (moved_to < 0 && errno != EBADF)
6764                 xfunc_die();
6765         return append_squirrel(sq, i, fd, moved_to);
6766 }
6767
6768 static struct squirrel *add_squirrel_closed(struct squirrel *sq, int fd)
6769 {
6770         int i;
6771
6772         if (sq) for (i = 0; sq[i].orig_fd >= 0; i++) {
6773                 /* If we collide with an already moved fd... */
6774                 if (fd == sq[i].orig_fd) {
6775                         /* Examples:
6776                          * "echo 3>FILE 3>&- 3>FILE"
6777                          * "echo 3>&- 3>FILE"
6778                          * No need for last redirect to insert
6779                          * another "need to close 3" indicator.
6780                          */
6781                         debug_printf_redir("redirect_fd %d: already moved or closed\n", fd);
6782                         return sq;
6783                 }
6784         }
6785
6786         debug_printf_redir("redirect_fd %d: previous fd was closed\n", fd);
6787         return append_squirrel(sq, i, fd, -1);
6788 }
6789
6790 /* fd: redirect wants this fd to be used (e.g. 3>file).
6791  * Move all conflicting internally used fds,
6792  * and remember them so that we can restore them later.
6793  */
6794 static int save_fd_on_redirect(int fd, int avoid_fd, struct squirrel **sqp)
6795 {
6796         if (avoid_fd < 9) /* the important case here is that it can be -1 */
6797                 avoid_fd = 9;
6798
6799 #if ENABLE_HUSH_INTERACTIVE
6800         if (fd == G.interactive_fd) {
6801                 /* Testcase: "ls -l /proc/$$/fd 255>&-" should work */
6802                 G.interactive_fd = xdup_CLOEXEC_and_close(G.interactive_fd, avoid_fd);
6803                 debug_printf_redir("redirect_fd %d: matches interactive_fd, moving it to %d\n", fd, G.interactive_fd);
6804                 return 1; /* "we closed fd" */
6805         }
6806 #endif
6807         /* Are we called from setup_redirects(squirrel==NULL)? Two cases:
6808          * (1) Redirect in a forked child. No need to save FILEs' fds,
6809          * we aren't going to use them anymore, ok to trash.
6810          * (2) "exec 3>FILE". Bummer. We can save script FILEs' fds,
6811          * but how are we doing to restore them?
6812          * "fileno(fd) = new_fd" can't be done.
6813          */
6814         if (!sqp)
6815                 return 0;
6816
6817         /* If this one of script's fds? */
6818         if (save_FILEs_on_redirect(fd, avoid_fd))
6819                 return 1; /* yes. "we closed fd" */
6820
6821         /* Check whether it collides with any open fds (e.g. stdio), save fds as needed */
6822         *sqp = add_squirrel(*sqp, fd, avoid_fd);
6823         return 0; /* "we did not close fd" */
6824 }
6825
6826 static void restore_redirects(struct squirrel *sq)
6827 {
6828         if (sq) {
6829                 int i;
6830                 for (i = 0; sq[i].orig_fd >= 0; i++) {
6831                         if (sq[i].moved_to >= 0) {
6832                                 /* We simply die on error */
6833                                 debug_printf_redir("restoring redirected fd from %d to %d\n", sq[i].moved_to, sq[i].orig_fd);
6834                                 xmove_fd(sq[i].moved_to, sq[i].orig_fd);
6835                         } else {
6836                                 /* cmd1 9>FILE; cmd2_should_see_fd9_closed */
6837                                 debug_printf_redir("restoring redirected fd %d: closing it\n", sq[i].orig_fd);
6838                                 close(sq[i].orig_fd);
6839                         }
6840                 }
6841                 free(sq);
6842         }
6843
6844         /* If moved, G.interactive_fd stays on new fd, not restoring it */
6845
6846         restore_redirected_FILEs();
6847 }
6848
6849 #if ENABLE_FEATURE_SH_STANDALONE && BB_MMU
6850 static void close_saved_fds_and_FILE_fds(void)
6851 {
6852         if (G_interactive_fd)
6853                 close(G_interactive_fd);
6854         close_all_FILE_list();
6855 }
6856 #endif
6857
6858 static int internally_opened_fd(int fd, struct squirrel *sq)
6859 {
6860         int i;
6861
6862 #if ENABLE_HUSH_INTERACTIVE
6863         if (fd == G.interactive_fd)
6864                 return 1;
6865 #endif
6866         /* If this one of script's fds? */
6867         if (fd_in_FILEs(fd))
6868                 return 1;
6869
6870         if (sq) for (i = 0; sq[i].orig_fd >= 0; i++) {
6871                 if (fd == sq[i].moved_to)
6872                         return 1;
6873         }
6874         return 0;
6875 }
6876
6877 /* squirrel != NULL means we squirrel away copies of stdin, stdout,
6878  * and stderr if they are redirected. */
6879 static int setup_redirects(struct command *prog, struct squirrel **sqp)
6880 {
6881         struct redir_struct *redir;
6882
6883         for (redir = prog->redirects; redir; redir = redir->next) {
6884                 int newfd;
6885                 int closed;
6886
6887                 if (redir->rd_type == REDIRECT_HEREDOC2) {
6888                         /* "rd_fd<<HERE" case */
6889                         save_fd_on_redirect(redir->rd_fd, /*avoid:*/ 0, sqp);
6890                         /* for REDIRECT_HEREDOC2, rd_filename holds _contents_
6891                          * of the heredoc */
6892                         debug_printf_parse("set heredoc '%s'\n",
6893                                         redir->rd_filename);
6894                         setup_heredoc(redir);
6895                         continue;
6896                 }
6897
6898                 if (redir->rd_dup == REDIRFD_TO_FILE) {
6899                         /* "rd_fd<*>file" case (<*> is <,>,>>,<>) */
6900                         char *p;
6901                         int mode;
6902
6903                         if (redir->rd_filename == NULL) {
6904                                 /*
6905                                  * Examples:
6906                                  * "cmd >" (no filename)
6907                                  * "cmd > <file" (2nd redirect starts too early)
6908                                  */
6909                                 syntax_error("invalid redirect");
6910                                 continue;
6911                         }
6912                         mode = redir_table[redir->rd_type].mode;
6913                         p = expand_string_to_string(redir->rd_filename, /*unbackslash:*/ 1);
6914                         newfd = open_or_warn(p, mode);
6915                         free(p);
6916                         if (newfd < 0) {
6917                                 /* Error message from open_or_warn can be lost
6918                                  * if stderr has been redirected, but bash
6919                                  * and ash both lose it as well
6920                                  * (though zsh doesn't!)
6921                                  */
6922                                 return 1;
6923                         }
6924                         if (newfd == redir->rd_fd && sqp) {
6925                                 /* open() gave us precisely the fd we wanted.
6926                                  * This means that this fd was not busy
6927                                  * (not opened to anywhere).
6928                                  * Remember to close it on restore:
6929                                  */
6930                                 *sqp = add_squirrel_closed(*sqp, newfd);
6931                                 debug_printf_redir("redir to previously closed fd %d\n", newfd);
6932                         }
6933                 } else {
6934                         /* "rd_fd>&rd_dup" or "rd_fd>&-" case */
6935                         newfd = redir->rd_dup;
6936                 }
6937
6938                 if (newfd == redir->rd_fd)
6939                         continue;
6940
6941                 /* if "N>FILE": move newfd to redir->rd_fd */
6942                 /* if "N>&M": dup newfd to redir->rd_fd */
6943                 /* if "N>&-": close redir->rd_fd (newfd is REDIRFD_CLOSE) */
6944
6945                 closed = save_fd_on_redirect(redir->rd_fd, /*avoid:*/ newfd, sqp);
6946                 if (newfd == REDIRFD_CLOSE) {
6947                         /* "N>&-" means "close me" */
6948                         if (!closed) {
6949                                 /* ^^^ optimization: saving may already
6950                                  * have closed it. If not... */
6951                                 close(redir->rd_fd);
6952                         }
6953                         /* Sometimes we do another close on restore, getting EBADF.
6954                          * Consider "echo 3>FILE 3>&-"
6955                          * first redirect remembers "need to close 3",
6956                          * and second redirect closes 3! Restore code then closes 3 again.
6957                          */
6958                 } else {
6959                         /* if newfd is a script fd or saved fd, simulate EBADF */
6960                         if (internally_opened_fd(newfd, sqp ? *sqp : NULL)) {
6961                                 //errno = EBADF;
6962                                 //bb_perror_msg_and_die("can't duplicate file descriptor");
6963                                 newfd = -1; /* same effect as code above */
6964                         }
6965                         xdup2(newfd, redir->rd_fd);
6966                         if (redir->rd_dup == REDIRFD_TO_FILE)
6967                                 /* "rd_fd > FILE" */
6968                                 close(newfd);
6969                         /* else: "rd_fd > rd_dup" */
6970                 }
6971         }
6972         return 0;
6973 }
6974
6975 static char *find_in_path(const char *arg)
6976 {
6977         char *ret = NULL;
6978         const char *PATH = get_local_var_value("PATH");
6979
6980         if (!PATH)
6981                 return NULL;
6982
6983         while (1) {
6984                 const char *end = strchrnul(PATH, ':');
6985                 int sz = end - PATH; /* must be int! */
6986
6987                 free(ret);
6988                 if (sz != 0) {
6989                         ret = xasprintf("%.*s/%s", sz, PATH, arg);
6990                 } else {
6991                         /* We have xxx::yyyy in $PATH,
6992                          * it means "use current dir" */
6993                         ret = xstrdup(arg);
6994                 }
6995                 if (access(ret, F_OK) == 0)
6996                         break;
6997
6998                 if (*end == '\0') {
6999                         free(ret);
7000                         return NULL;
7001                 }
7002                 PATH = end + 1;
7003         }
7004
7005         return ret;
7006 }
7007
7008 static const struct built_in_command *find_builtin_helper(const char *name,
7009                 const struct built_in_command *x,
7010                 const struct built_in_command *end)
7011 {
7012         while (x != end) {
7013                 if (strcmp(name, x->b_cmd) != 0) {
7014                         x++;
7015                         continue;
7016                 }
7017                 debug_printf_exec("found builtin '%s'\n", name);
7018                 return x;
7019         }
7020         return NULL;
7021 }
7022 static const struct built_in_command *find_builtin1(const char *name)
7023 {
7024         return find_builtin_helper(name, bltins1, &bltins1[ARRAY_SIZE(bltins1)]);
7025 }
7026 static const struct built_in_command *find_builtin(const char *name)
7027 {
7028         const struct built_in_command *x = find_builtin1(name);
7029         if (x)
7030                 return x;
7031         return find_builtin_helper(name, bltins2, &bltins2[ARRAY_SIZE(bltins2)]);
7032 }
7033
7034 #if ENABLE_HUSH_FUNCTIONS
7035 static struct function **find_function_slot(const char *name)
7036 {
7037         struct function **funcpp = &G.top_func;
7038         while (*funcpp) {
7039                 if (strcmp(name, (*funcpp)->name) == 0) {
7040                         break;
7041                 }
7042                 funcpp = &(*funcpp)->next;
7043         }
7044         return funcpp;
7045 }
7046
7047 static const struct function *find_function(const char *name)
7048 {
7049         const struct function *funcp = *find_function_slot(name);
7050         if (funcp)
7051                 debug_printf_exec("found function '%s'\n", name);
7052         return funcp;
7053 }
7054
7055 /* Note: takes ownership on name ptr */
7056 static struct function *new_function(char *name)
7057 {
7058         struct function **funcpp = find_function_slot(name);
7059         struct function *funcp = *funcpp;
7060
7061         if (funcp != NULL) {
7062                 struct command *cmd = funcp->parent_cmd;
7063                 debug_printf_exec("func %p parent_cmd %p\n", funcp, cmd);
7064                 if (!cmd) {
7065                         debug_printf_exec("freeing & replacing function '%s'\n", funcp->name);
7066                         free(funcp->name);
7067                         /* Note: if !funcp->body, do not free body_as_string!
7068                          * This is a special case of "-F name body" function:
7069                          * body_as_string was not malloced! */
7070                         if (funcp->body) {
7071                                 free_pipe_list(funcp->body);
7072 # if !BB_MMU
7073                                 free(funcp->body_as_string);
7074 # endif
7075                         }
7076                 } else {
7077                         debug_printf_exec("reinserting in tree & replacing function '%s'\n", funcp->name);
7078                         cmd->argv[0] = funcp->name;
7079                         cmd->group = funcp->body;
7080 # if !BB_MMU
7081                         cmd->group_as_string = funcp->body_as_string;
7082 # endif
7083                 }
7084         } else {
7085                 debug_printf_exec("remembering new function '%s'\n", name);
7086                 funcp = *funcpp = xzalloc(sizeof(*funcp));
7087                 /*funcp->next = NULL;*/
7088         }
7089
7090         funcp->name = name;
7091         return funcp;
7092 }
7093
7094 # if ENABLE_HUSH_UNSET
7095 static void unset_func(const char *name)
7096 {
7097         struct function **funcpp = find_function_slot(name);
7098         struct function *funcp = *funcpp;
7099
7100         if (funcp != NULL) {
7101                 debug_printf_exec("freeing function '%s'\n", funcp->name);
7102                 *funcpp = funcp->next;
7103                 /* funcp is unlinked now, deleting it.
7104                  * Note: if !funcp->body, the function was created by
7105                  * "-F name body", do not free ->body_as_string
7106                  * and ->name as they were not malloced. */
7107                 if (funcp->body) {
7108                         free_pipe_list(funcp->body);
7109                         free(funcp->name);
7110 #  if !BB_MMU
7111                         free(funcp->body_as_string);
7112 #  endif
7113                 }
7114                 free(funcp);
7115         }
7116 }
7117 # endif
7118
7119 # if BB_MMU
7120 #define exec_function(to_free, funcp, argv) \
7121         exec_function(funcp, argv)
7122 # endif
7123 static void exec_function(char ***to_free,
7124                 const struct function *funcp,
7125                 char **argv) NORETURN;
7126 static void exec_function(char ***to_free,
7127                 const struct function *funcp,
7128                 char **argv)
7129 {
7130 # if BB_MMU
7131         int n;
7132
7133         argv[0] = G.global_argv[0];
7134         G.global_argv = argv;
7135         G.global_argc = n = 1 + string_array_len(argv + 1);
7136
7137 // Example when we are here: "cmd | func"
7138 // func will run with saved-redirect fds open.
7139 // $ f() { echo /proc/self/fd/*; }
7140 // $ true | f
7141 // /proc/self/fd/0 /proc/self/fd/1 /proc/self/fd/2 /proc/self/fd/255 /proc/self/fd/3
7142 // stdio^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ G_interactive_fd^ DIR fd for glob
7143 // Same in script:
7144 // $ . ./SCRIPT
7145 // /proc/self/fd/0 /proc/self/fd/1 /proc/self/fd/2 /proc/self/fd/255 /proc/self/fd/3 /proc/self/fd/4
7146 // stdio^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ G_interactive_fd^ opened ./SCRIPT DIR fd for glob
7147 // They are CLOEXEC so external programs won't see them, but
7148 // for "more correctness" we might want to close those extra fds here:
7149 //?     close_saved_fds_and_FILE_fds();
7150
7151         /* "we are in function, ok to use return" */
7152         G_flag_return_in_progress = -1;
7153         IF_HUSH_LOCAL(G.func_nest_level++;)
7154
7155         /* On MMU, funcp->body is always non-NULL */
7156         n = run_list(funcp->body);
7157         fflush_all();
7158         _exit(n);
7159 # else
7160 //?     close_saved_fds_and_FILE_fds();
7161
7162 //TODO: check whether "true | func_with_return" works
7163
7164         re_execute_shell(to_free,
7165                         funcp->body_as_string,
7166                         G.global_argv[0],
7167                         argv + 1,
7168                         NULL);
7169 # endif
7170 }
7171
7172 static int run_function(const struct function *funcp, char **argv)
7173 {
7174         int rc;
7175         save_arg_t sv;
7176         smallint sv_flg;
7177
7178         save_and_replace_G_args(&sv, argv);
7179
7180         /* "we are in function, ok to use return" */
7181         sv_flg = G_flag_return_in_progress;
7182         G_flag_return_in_progress = -1;
7183         IF_HUSH_LOCAL(G.func_nest_level++;)
7184
7185         /* On MMU, funcp->body is always non-NULL */
7186 # if !BB_MMU
7187         if (!funcp->body) {
7188                 /* Function defined by -F */
7189                 parse_and_run_string(funcp->body_as_string);
7190                 rc = G.last_exitcode;
7191         } else
7192 # endif
7193         {
7194                 rc = run_list(funcp->body);
7195         }
7196
7197 # if ENABLE_HUSH_LOCAL
7198         {
7199                 struct variable *var;
7200                 struct variable **var_pp;
7201
7202                 var_pp = &G.top_var;
7203                 while ((var = *var_pp) != NULL) {
7204                         if (var->func_nest_level < G.func_nest_level) {
7205                                 var_pp = &var->next;
7206                                 continue;
7207                         }
7208                         /* Unexport */
7209                         if (var->flg_export)
7210                                 bb_unsetenv(var->varstr);
7211                         /* Remove from global list */
7212                         *var_pp = var->next;
7213                         /* Free */
7214                         if (!var->max_len)
7215                                 free(var->varstr);
7216                         free(var);
7217                 }
7218                 G.func_nest_level--;
7219         }
7220 # endif
7221         G_flag_return_in_progress = sv_flg;
7222
7223         restore_G_args(&sv, argv);
7224
7225         return rc;
7226 }
7227 #endif /* ENABLE_HUSH_FUNCTIONS */
7228
7229
7230 #if BB_MMU
7231 #define exec_builtin(to_free, x, argv) \
7232         exec_builtin(x, argv)
7233 #else
7234 #define exec_builtin(to_free, x, argv) \
7235         exec_builtin(to_free, argv)
7236 #endif
7237 static void exec_builtin(char ***to_free,
7238                 const struct built_in_command *x,
7239                 char **argv) NORETURN;
7240 static void exec_builtin(char ***to_free,
7241                 const struct built_in_command *x,
7242                 char **argv)
7243 {
7244 #if BB_MMU
7245         int rcode;
7246         fflush_all();
7247 //?     close_saved_fds_and_FILE_fds();
7248         rcode = x->b_function(argv);
7249         fflush_all();
7250         _exit(rcode);
7251 #else
7252         fflush_all();
7253         /* On NOMMU, we must never block!
7254          * Example: { sleep 99 | read line; } & echo Ok
7255          */
7256         re_execute_shell(to_free,
7257                         argv[0],
7258                         G.global_argv[0],
7259                         G.global_argv + 1,
7260                         argv);
7261 #endif
7262 }
7263
7264
7265 static void execvp_or_die(char **argv) NORETURN;
7266 static void execvp_or_die(char **argv)
7267 {
7268         int e;
7269         debug_printf_exec("execing '%s'\n", argv[0]);
7270         /* Don't propagate SIG_IGN to the child */
7271         if (SPECIAL_JOBSTOP_SIGS != 0)
7272                 switch_off_special_sigs(G.special_sig_mask & SPECIAL_JOBSTOP_SIGS);
7273         execvp(argv[0], argv);
7274         e = 2;
7275         if (errno == EACCES) e = 126;
7276         if (errno == ENOENT) e = 127;
7277         bb_perror_msg("can't execute '%s'", argv[0]);
7278         _exit(e);
7279 }
7280
7281 #if ENABLE_HUSH_MODE_X
7282 static void dump_cmd_in_x_mode(char **argv)
7283 {
7284         if (G_x_mode && argv) {
7285                 /* We want to output the line in one write op */
7286                 char *buf, *p;
7287                 int len;
7288                 int n;
7289
7290                 len = 3;
7291                 n = 0;
7292                 while (argv[n])
7293                         len += strlen(argv[n++]) + 1;
7294                 buf = xmalloc(len);
7295                 buf[0] = '+';
7296                 p = buf + 1;
7297                 n = 0;
7298                 while (argv[n])
7299                         p += sprintf(p, " %s", argv[n++]);
7300                 *p++ = '\n';
7301                 *p = '\0';
7302                 fputs(buf, stderr);
7303                 free(buf);
7304         }
7305 }
7306 #else
7307 # define dump_cmd_in_x_mode(argv) ((void)0)
7308 #endif
7309
7310 #if BB_MMU
7311 #define pseudo_exec_argv(nommu_save, argv, assignment_cnt, argv_expanded) \
7312         pseudo_exec_argv(argv, assignment_cnt, argv_expanded)
7313 #define pseudo_exec(nommu_save, command, argv_expanded) \
7314         pseudo_exec(command, argv_expanded)
7315 #endif
7316
7317 /* Called after [v]fork() in run_pipe, or from builtin_exec.
7318  * Never returns.
7319  * Don't exit() here.  If you don't exec, use _exit instead.
7320  * The at_exit handlers apparently confuse the calling process,
7321  * in particular stdin handling. Not sure why? -- because of vfork! (vda)
7322  */
7323 static void pseudo_exec_argv(nommu_save_t *nommu_save,
7324                 char **argv, int assignment_cnt,
7325                 char **argv_expanded) NORETURN;
7326 static NOINLINE void pseudo_exec_argv(nommu_save_t *nommu_save,
7327                 char **argv, int assignment_cnt,
7328                 char **argv_expanded)
7329 {
7330         char **new_env;
7331
7332         new_env = expand_assignments(argv, assignment_cnt);
7333         dump_cmd_in_x_mode(new_env);
7334
7335         if (!argv[assignment_cnt]) {
7336                 /* Case when we are here: ... | var=val | ...
7337                  * (note that we do not exit early, i.e., do not optimize out
7338                  * expand_assignments(): think about ... | var=`sleep 1` | ...
7339                  */
7340                 free_strings(new_env);
7341                 _exit(EXIT_SUCCESS);
7342         }
7343
7344 #if BB_MMU
7345         set_vars_and_save_old(new_env);
7346         free(new_env); /* optional */
7347         /* we can also destroy set_vars_and_save_old's return value,
7348          * to save memory */
7349 #else
7350         nommu_save->new_env = new_env;
7351         nommu_save->old_vars = set_vars_and_save_old(new_env);
7352 #endif
7353
7354         if (argv_expanded) {
7355                 argv = argv_expanded;
7356         } else {
7357                 argv = expand_strvec_to_strvec(argv + assignment_cnt);
7358 #if !BB_MMU
7359                 nommu_save->argv = argv;
7360 #endif
7361         }
7362         dump_cmd_in_x_mode(argv);
7363
7364 #if ENABLE_FEATURE_SH_STANDALONE || BB_MMU
7365         if (strchr(argv[0], '/') != NULL)
7366                 goto skip;
7367 #endif
7368
7369 #if ENABLE_HUSH_FUNCTIONS
7370         /* Check if the command matches any functions (this goes before bltins) */
7371         {
7372                 const struct function *funcp = find_function(argv[0]);
7373                 if (funcp) {
7374                         exec_function(&nommu_save->argv_from_re_execing, funcp, argv);
7375                 }
7376         }
7377 #endif
7378
7379         /* Check if the command matches any of the builtins.
7380          * Depending on context, this might be redundant.  But it's
7381          * easier to waste a few CPU cycles than it is to figure out
7382          * if this is one of those cases.
7383          */
7384         {
7385                 /* On NOMMU, it is more expensive to re-execute shell
7386                  * just in order to run echo or test builtin.
7387                  * It's better to skip it here and run corresponding
7388                  * non-builtin later. */
7389                 const struct built_in_command *x;
7390                 x = BB_MMU ? find_builtin(argv[0]) : find_builtin1(argv[0]);
7391                 if (x) {
7392                         exec_builtin(&nommu_save->argv_from_re_execing, x, argv);
7393                 }
7394         }
7395
7396 #if ENABLE_FEATURE_SH_STANDALONE
7397         /* Check if the command matches any busybox applets */
7398         {
7399                 int a = find_applet_by_name(argv[0]);
7400                 if (a >= 0) {
7401 # if BB_MMU /* see above why on NOMMU it is not allowed */
7402                         if (APPLET_IS_NOEXEC(a)) {
7403                                 /* Do not leak open fds from opened script files etc.
7404                                  * Testcase: interactive "ls -l /proc/self/fd"
7405                                  * should not show tty fd open.
7406                                  */
7407                                 close_saved_fds_and_FILE_fds();
7408 //FIXME: should also close saved redir fds
7409                                 /* Without this, "rm -i FILE" can't be ^C'ed: */
7410                                 switch_off_special_sigs(G.special_sig_mask);
7411                                 debug_printf_exec("running applet '%s'\n", argv[0]);
7412                                 run_noexec_applet_and_exit(a, argv[0], argv);
7413                         }
7414 # endif
7415                         /* Re-exec ourselves */
7416                         debug_printf_exec("re-execing applet '%s'\n", argv[0]);
7417                         /* Don't propagate SIG_IGN to the child */
7418                         if (SPECIAL_JOBSTOP_SIGS != 0)
7419                                 switch_off_special_sigs(G.special_sig_mask & SPECIAL_JOBSTOP_SIGS);
7420                         execv(bb_busybox_exec_path, argv);
7421                         /* If they called chroot or otherwise made the binary no longer
7422                          * executable, fall through */
7423                 }
7424         }
7425 #endif
7426
7427 #if ENABLE_FEATURE_SH_STANDALONE || BB_MMU
7428  skip:
7429 #endif
7430         execvp_or_die(argv);
7431 }
7432
7433 /* Called after [v]fork() in run_pipe
7434  */
7435 static void pseudo_exec(nommu_save_t *nommu_save,
7436                 struct command *command,
7437                 char **argv_expanded) NORETURN;
7438 static void pseudo_exec(nommu_save_t *nommu_save,
7439                 struct command *command,
7440                 char **argv_expanded)
7441 {
7442         if (command->argv) {
7443                 pseudo_exec_argv(nommu_save, command->argv,
7444                                 command->assignment_cnt, argv_expanded);
7445         }
7446
7447         if (command->group) {
7448                 /* Cases when we are here:
7449                  * ( list )
7450                  * { list } &
7451                  * ... | ( list ) | ...
7452                  * ... | { list } | ...
7453                  */
7454 #if BB_MMU
7455                 int rcode;
7456                 debug_printf_exec("pseudo_exec: run_list\n");
7457                 reset_traps_to_defaults();
7458                 rcode = run_list(command->group);
7459                 /* OK to leak memory by not calling free_pipe_list,
7460                  * since this process is about to exit */
7461                 _exit(rcode);
7462 #else
7463                 re_execute_shell(&nommu_save->argv_from_re_execing,
7464                                 command->group_as_string,
7465                                 G.global_argv[0],
7466                                 G.global_argv + 1,
7467                                 NULL);
7468 #endif
7469         }
7470
7471         /* Case when we are here: ... | >file */
7472         debug_printf_exec("pseudo_exec'ed null command\n");
7473         _exit(EXIT_SUCCESS);
7474 }
7475
7476 #if ENABLE_HUSH_JOB
7477 static const char *get_cmdtext(struct pipe *pi)
7478 {
7479         char **argv;
7480         char *p;
7481         int len;
7482
7483         /* This is subtle. ->cmdtext is created only on first backgrounding.
7484          * (Think "cat, <ctrl-z>, fg, <ctrl-z>, fg, <ctrl-z>...." here...)
7485          * On subsequent bg argv is trashed, but we won't use it */
7486         if (pi->cmdtext)
7487                 return pi->cmdtext;
7488
7489         argv = pi->cmds[0].argv;
7490         if (!argv) {
7491                 pi->cmdtext = xzalloc(1);
7492                 return pi->cmdtext;
7493         }
7494         len = 0;
7495         do {
7496                 len += strlen(*argv) + 1;
7497         } while (*++argv);
7498         p = xmalloc(len);
7499         pi->cmdtext = p;
7500         argv = pi->cmds[0].argv;
7501         do {
7502                 p = stpcpy(p, *argv);
7503                 *p++ = ' ';
7504         } while (*++argv);
7505         p[-1] = '\0';
7506         return pi->cmdtext;
7507 }
7508
7509 static void remove_job_from_table(struct pipe *pi)
7510 {
7511         struct pipe *prev_pipe;
7512
7513         if (pi == G.job_list) {
7514                 G.job_list = pi->next;
7515         } else {
7516                 prev_pipe = G.job_list;
7517                 while (prev_pipe->next != pi)
7518                         prev_pipe = prev_pipe->next;
7519                 prev_pipe->next = pi->next;
7520         }
7521         G.last_jobid = 0;
7522         if (G.job_list)
7523                 G.last_jobid = G.job_list->jobid;
7524 }
7525
7526 static void delete_finished_job(struct pipe *pi)
7527 {
7528         remove_job_from_table(pi);
7529         free_pipe(pi);
7530 }
7531
7532 static void clean_up_last_dead_job(void)
7533 {
7534         if (G.job_list && !G.job_list->alive_cmds)
7535                 delete_finished_job(G.job_list);
7536 }
7537
7538 static void insert_job_into_table(struct pipe *pi)
7539 {
7540         struct pipe *job, **jobp;
7541         int i;
7542
7543         clean_up_last_dead_job();
7544
7545         /* Find the end of the list, and find next job ID to use */
7546         i = 0;
7547         jobp = &G.job_list;
7548         while ((job = *jobp) != NULL) {
7549                 if (job->jobid > i)
7550                         i = job->jobid;
7551                 jobp = &job->next;
7552         }
7553         pi->jobid = i + 1;
7554
7555         /* Create a new job struct at the end */
7556         job = *jobp = xmemdup(pi, sizeof(*pi));
7557         job->next = NULL;
7558         job->cmds = xzalloc(sizeof(pi->cmds[0]) * pi->num_cmds);
7559         /* Cannot copy entire pi->cmds[] vector! This causes double frees */
7560         for (i = 0; i < pi->num_cmds; i++) {
7561                 job->cmds[i].pid = pi->cmds[i].pid;
7562                 /* all other fields are not used and stay zero */
7563         }
7564         job->cmdtext = xstrdup(get_cmdtext(pi));
7565
7566         if (G_interactive_fd)
7567                 printf("[%u] %u %s\n", job->jobid, (unsigned)job->cmds[0].pid, job->cmdtext);
7568         G.last_jobid = job->jobid;
7569 }
7570 #endif /* JOB */
7571
7572 static int job_exited_or_stopped(struct pipe *pi)
7573 {
7574         int rcode, i;
7575
7576         if (pi->alive_cmds != pi->stopped_cmds)
7577                 return -1;
7578
7579         /* All processes in fg pipe have exited or stopped */
7580         rcode = 0;
7581         i = pi->num_cmds;
7582         while (--i >= 0) {
7583                 rcode = pi->cmds[i].cmd_exitcode;
7584                 /* usually last process gives overall exitstatus,
7585                  * but with "set -o pipefail", last *failed* process does */
7586                 if (G.o_opt[OPT_O_PIPEFAIL] == 0 || rcode != 0)
7587                         break;
7588         }
7589         IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
7590         return rcode;
7591 }
7592
7593 static int process_wait_result(struct pipe *fg_pipe, pid_t childpid, int status)
7594 {
7595 #if ENABLE_HUSH_JOB
7596         struct pipe *pi;
7597 #endif
7598         int i, dead;
7599
7600         dead = WIFEXITED(status) || WIFSIGNALED(status);
7601
7602 #if DEBUG_JOBS
7603         if (WIFSTOPPED(status))
7604                 debug_printf_jobs("pid %d stopped by sig %d (exitcode %d)\n",
7605                                 childpid, WSTOPSIG(status), WEXITSTATUS(status));
7606         if (WIFSIGNALED(status))
7607                 debug_printf_jobs("pid %d killed by sig %d (exitcode %d)\n",
7608                                 childpid, WTERMSIG(status), WEXITSTATUS(status));
7609         if (WIFEXITED(status))
7610                 debug_printf_jobs("pid %d exited, exitcode %d\n",
7611                                 childpid, WEXITSTATUS(status));
7612 #endif
7613         /* Were we asked to wait for a fg pipe? */
7614         if (fg_pipe) {
7615                 i = fg_pipe->num_cmds;
7616
7617                 while (--i >= 0) {
7618                         int rcode;
7619
7620                         debug_printf_jobs("check pid %d\n", fg_pipe->cmds[i].pid);
7621                         if (fg_pipe->cmds[i].pid != childpid)
7622                                 continue;
7623                         if (dead) {
7624                                 int ex;
7625                                 fg_pipe->cmds[i].pid = 0;
7626                                 fg_pipe->alive_cmds--;
7627                                 ex = WEXITSTATUS(status);
7628                                 /* bash prints killer signal's name for *last*
7629                                  * process in pipe (prints just newline for SIGINT/SIGPIPE).
7630                                  * Mimic this. Example: "sleep 5" + (^\ or kill -QUIT)
7631                                  */
7632                                 if (WIFSIGNALED(status)) {
7633                                         int sig = WTERMSIG(status);
7634                                         if (i == fg_pipe->num_cmds-1)
7635                                                 /* TODO: use strsignal() instead for bash compat? but that's bloat... */
7636                                                 puts(sig == SIGINT || sig == SIGPIPE ? "" : get_signame(sig));
7637                                         /* TODO: if (WCOREDUMP(status)) + " (core dumped)"; */
7638                                         /* TODO: MIPS has 128 sigs (1..128), what if sig==128 here?
7639                                          * Maybe we need to use sig | 128? */
7640                                         ex = sig + 128;
7641                                 }
7642                                 fg_pipe->cmds[i].cmd_exitcode = ex;
7643                         } else {
7644                                 fg_pipe->stopped_cmds++;
7645                         }
7646                         debug_printf_jobs("fg_pipe: alive_cmds %d stopped_cmds %d\n",
7647                                         fg_pipe->alive_cmds, fg_pipe->stopped_cmds);
7648                         rcode = job_exited_or_stopped(fg_pipe);
7649                         if (rcode >= 0) {
7650 /* Note: *non-interactive* bash does not continue if all processes in fg pipe
7651  * are stopped. Testcase: "cat | cat" in a script (not on command line!)
7652  * and "killall -STOP cat" */
7653                                 if (G_interactive_fd) {
7654 #if ENABLE_HUSH_JOB
7655                                         if (fg_pipe->alive_cmds != 0)
7656                                                 insert_job_into_table(fg_pipe);
7657 #endif
7658                                         return rcode;
7659                                 }
7660                                 if (fg_pipe->alive_cmds == 0)
7661                                         return rcode;
7662                         }
7663                         /* There are still running processes in the fg_pipe */
7664                         return -1;
7665                 }
7666                 /* It wasn't in fg_pipe, look for process in bg pipes */
7667         }
7668
7669 #if ENABLE_HUSH_JOB
7670         /* We were asked to wait for bg or orphaned children */
7671         /* No need to remember exitcode in this case */
7672         for (pi = G.job_list; pi; pi = pi->next) {
7673                 for (i = 0; i < pi->num_cmds; i++) {
7674                         if (pi->cmds[i].pid == childpid)
7675                                 goto found_pi_and_prognum;
7676                 }
7677         }
7678         /* Happens when shell is used as init process (init=/bin/sh) */
7679         debug_printf("checkjobs: pid %d was not in our list!\n", childpid);
7680         return -1; /* this wasn't a process from fg_pipe */
7681
7682  found_pi_and_prognum:
7683         if (dead) {
7684                 /* child exited */
7685                 int rcode = WEXITSTATUS(status);
7686                 if (WIFSIGNALED(status))
7687                         rcode = 128 + WTERMSIG(status);
7688                 pi->cmds[i].cmd_exitcode = rcode;
7689                 if (G.last_bg_pid == pi->cmds[i].pid)
7690                         G.last_bg_pid_exitcode = rcode;
7691                 pi->cmds[i].pid = 0;
7692                 pi->alive_cmds--;
7693                 if (!pi->alive_cmds) {
7694                         if (G_interactive_fd) {
7695                                 printf(JOB_STATUS_FORMAT, pi->jobid,
7696                                                 "Done", pi->cmdtext);
7697                                 delete_finished_job(pi);
7698                         } else {
7699 /*
7700  * bash deletes finished jobs from job table only in interactive mode,
7701  * after "jobs" cmd, or if pid of a new process matches one of the old ones
7702  * (see cleanup_dead_jobs(), delete_old_job(), J_NOTIFIED in bash source).
7703  * Testcase script: "(exit 3) & sleep 1; wait %1; echo $?" prints 3 in bash.
7704  * We only retain one "dead" job, if it's the single job on the list.
7705  * This covers most of real-world scenarios where this is useful.
7706  */
7707                                 if (pi != G.job_list)
7708                                         delete_finished_job(pi);
7709                         }
7710                 }
7711         } else {
7712                 /* child stopped */
7713                 pi->stopped_cmds++;
7714         }
7715 #endif
7716         return -1; /* this wasn't a process from fg_pipe */
7717 }
7718
7719 /* Check to see if any processes have exited -- if they have,
7720  * figure out why and see if a job has completed.
7721  *
7722  * If non-NULL fg_pipe: wait for its completion or stop.
7723  * Return its exitcode or zero if stopped.
7724  *
7725  * Alternatively (fg_pipe == NULL, waitfor_pid != 0):
7726  * waitpid(WNOHANG), if waitfor_pid exits or stops, return exitcode+1,
7727  * else return <0 if waitpid errors out (e.g. ECHILD: nothing to wait for)
7728  * or 0 if no children changed status.
7729  *
7730  * Alternatively (fg_pipe == NULL, waitfor_pid == 0),
7731  * return <0 if waitpid errors out (e.g. ECHILD: nothing to wait for)
7732  * or 0 if no children changed status.
7733  */
7734 static int checkjobs(struct pipe *fg_pipe, pid_t waitfor_pid)
7735 {
7736         int attributes;
7737         int status;
7738         int rcode = 0;
7739
7740         debug_printf_jobs("checkjobs %p\n", fg_pipe);
7741
7742         attributes = WUNTRACED;
7743         if (fg_pipe == NULL)
7744                 attributes |= WNOHANG;
7745
7746         errno = 0;
7747 #if ENABLE_HUSH_FAST
7748         if (G.handled_SIGCHLD == G.count_SIGCHLD) {
7749 //bb_error_msg("[%d] checkjobs: G.count_SIGCHLD:%d G.handled_SIGCHLD:%d children?:%d fg_pipe:%p",
7750 //getpid(), G.count_SIGCHLD, G.handled_SIGCHLD, G.we_have_children, fg_pipe);
7751                 /* There was neither fork nor SIGCHLD since last waitpid */
7752                 /* Avoid doing waitpid syscall if possible */
7753                 if (!G.we_have_children) {
7754                         errno = ECHILD;
7755                         return -1;
7756                 }
7757                 if (fg_pipe == NULL) { /* is WNOHANG set? */
7758                         /* We have children, but they did not exit
7759                          * or stop yet (we saw no SIGCHLD) */
7760                         return 0;
7761                 }
7762                 /* else: !WNOHANG, waitpid will block, can't short-circuit */
7763         }
7764 #endif
7765
7766 /* Do we do this right?
7767  * bash-3.00# sleep 20 | false
7768  * <ctrl-Z pressed>
7769  * [3]+  Stopped          sleep 20 | false
7770  * bash-3.00# echo $?
7771  * 1   <========== bg pipe is not fully done, but exitcode is already known!
7772  * [hush 1.14.0: yes we do it right]
7773  */
7774         while (1) {
7775                 pid_t childpid;
7776 #if ENABLE_HUSH_FAST
7777                 int i;
7778                 i = G.count_SIGCHLD;
7779 #endif
7780                 childpid = waitpid(-1, &status, attributes);
7781                 if (childpid <= 0) {
7782                         if (childpid && errno != ECHILD)
7783                                 bb_perror_msg("waitpid");
7784 #if ENABLE_HUSH_FAST
7785                         else { /* Until next SIGCHLD, waitpid's are useless */
7786                                 G.we_have_children = (childpid == 0);
7787                                 G.handled_SIGCHLD = i;
7788 //bb_error_msg("[%d] checkjobs: waitpid returned <= 0, G.count_SIGCHLD:%d G.handled_SIGCHLD:%d", getpid(), G.count_SIGCHLD, G.handled_SIGCHLD);
7789                         }
7790 #endif
7791                         /* ECHILD (no children), or 0 (no change in children status) */
7792                         rcode = childpid;
7793                         break;
7794                 }
7795                 rcode = process_wait_result(fg_pipe, childpid, status);
7796                 if (rcode >= 0) {
7797                         /* fg_pipe exited or stopped */
7798                         break;
7799                 }
7800                 if (childpid == waitfor_pid) {
7801                         debug_printf_exec("childpid==waitfor_pid:%d status:0x%08x\n", childpid, status);
7802                         rcode = WEXITSTATUS(status);
7803                         if (WIFSIGNALED(status))
7804                                 rcode = 128 + WTERMSIG(status);
7805                         if (WIFSTOPPED(status))
7806                                 /* bash: "cmd & wait $!" and cmd stops: $? = 128 + stopsig */
7807                                 rcode = 128 + WSTOPSIG(status);
7808                         rcode++;
7809                         break; /* "wait PID" called us, give it exitcode+1 */
7810                 }
7811                 /* This wasn't one of our processes, or */
7812                 /* fg_pipe still has running processes, do waitpid again */
7813         } /* while (waitpid succeeds)... */
7814
7815         return rcode;
7816 }
7817
7818 #if ENABLE_HUSH_JOB
7819 static int checkjobs_and_fg_shell(struct pipe *fg_pipe)
7820 {
7821         pid_t p;
7822         int rcode = checkjobs(fg_pipe, 0 /*(no pid to wait for)*/);
7823         if (G_saved_tty_pgrp) {
7824                 /* Job finished, move the shell to the foreground */
7825                 p = getpgrp(); /* our process group id */
7826                 debug_printf_jobs("fg'ing ourself: getpgrp()=%d\n", (int)p);
7827                 tcsetpgrp(G_interactive_fd, p);
7828         }
7829         return rcode;
7830 }
7831 #endif
7832
7833 /* Start all the jobs, but don't wait for anything to finish.
7834  * See checkjobs().
7835  *
7836  * Return code is normally -1, when the caller has to wait for children
7837  * to finish to determine the exit status of the pipe.  If the pipe
7838  * is a simple builtin command, however, the action is done by the
7839  * time run_pipe returns, and the exit code is provided as the
7840  * return value.
7841  *
7842  * Returns -1 only if started some children. IOW: we have to
7843  * mask out retvals of builtins etc with 0xff!
7844  *
7845  * The only case when we do not need to [v]fork is when the pipe
7846  * is single, non-backgrounded, non-subshell command. Examples:
7847  * cmd ; ...   { list } ; ...
7848  * cmd && ...  { list } && ...
7849  * cmd || ...  { list } || ...
7850  * If it is, then we can run cmd as a builtin, NOFORK,
7851  * or (if SH_STANDALONE) an applet, and we can run the { list }
7852  * with run_list. If it isn't one of these, we fork and exec cmd.
7853  *
7854  * Cases when we must fork:
7855  * non-single:   cmd | cmd
7856  * backgrounded: cmd &     { list } &
7857  * subshell:     ( list ) [&]
7858  */
7859 #if !ENABLE_HUSH_MODE_X
7860 #define redirect_and_varexp_helper(new_env_p, old_vars_p, command, squirrel, argv_expanded) \
7861         redirect_and_varexp_helper(new_env_p, old_vars_p, command, squirrel)
7862 #endif
7863 static int redirect_and_varexp_helper(char ***new_env_p,
7864                 struct variable **old_vars_p,
7865                 struct command *command,
7866                 struct squirrel **sqp,
7867                 char **argv_expanded)
7868 {
7869         /* setup_redirects acts on file descriptors, not FILEs.
7870          * This is perfect for work that comes after exec().
7871          * Is it really safe for inline use?  Experimentally,
7872          * things seem to work. */
7873         int rcode = setup_redirects(command, sqp);
7874         if (rcode == 0) {
7875                 char **new_env = expand_assignments(command->argv, command->assignment_cnt);
7876                 *new_env_p = new_env;
7877                 dump_cmd_in_x_mode(new_env);
7878                 dump_cmd_in_x_mode(argv_expanded);
7879                 if (old_vars_p)
7880                         *old_vars_p = set_vars_and_save_old(new_env);
7881         }
7882         return rcode;
7883 }
7884 static NOINLINE int run_pipe(struct pipe *pi)
7885 {
7886         static const char *const null_ptr = NULL;
7887
7888         int cmd_no;
7889         int next_infd;
7890         struct command *command;
7891         char **argv_expanded;
7892         char **argv;
7893         struct squirrel *squirrel = NULL;
7894         int rcode;
7895
7896         debug_printf_exec("run_pipe start: members:%d\n", pi->num_cmds);
7897         debug_enter();
7898
7899         /* Testcase: set -- q w e; (IFS='' echo "$*"; IFS=''; echo "$*"); echo "$*"
7900          * Result should be 3 lines: q w e, qwe, q w e
7901          */
7902         G.ifs = get_local_var_value("IFS");
7903         if (!G.ifs)
7904                 G.ifs = defifs;
7905
7906         IF_HUSH_JOB(pi->pgrp = -1;)
7907         pi->stopped_cmds = 0;
7908         command = &pi->cmds[0];
7909         argv_expanded = NULL;
7910
7911         if (pi->num_cmds != 1
7912          || pi->followup == PIPE_BG
7913          || command->cmd_type == CMD_SUBSHELL
7914         ) {
7915                 goto must_fork;
7916         }
7917
7918         pi->alive_cmds = 1;
7919
7920         debug_printf_exec(": group:%p argv:'%s'\n",
7921                 command->group, command->argv ? command->argv[0] : "NONE");
7922
7923         if (command->group) {
7924 #if ENABLE_HUSH_FUNCTIONS
7925                 if (command->cmd_type == CMD_FUNCDEF) {
7926                         /* "executing" func () { list } */
7927                         struct function *funcp;
7928
7929                         funcp = new_function(command->argv[0]);
7930                         /* funcp->name is already set to argv[0] */
7931                         funcp->body = command->group;
7932 # if !BB_MMU
7933                         funcp->body_as_string = command->group_as_string;
7934                         command->group_as_string = NULL;
7935 # endif
7936                         command->group = NULL;
7937                         command->argv[0] = NULL;
7938                         debug_printf_exec("cmd %p has child func at %p\n", command, funcp);
7939                         funcp->parent_cmd = command;
7940                         command->child_func = funcp;
7941
7942                         debug_printf_exec("run_pipe: return EXIT_SUCCESS\n");
7943                         debug_leave();
7944                         return EXIT_SUCCESS;
7945                 }
7946 #endif
7947                 /* { list } */
7948                 debug_printf("non-subshell group\n");
7949                 rcode = 1; /* exitcode if redir failed */
7950                 if (setup_redirects(command, &squirrel) == 0) {
7951                         debug_printf_exec(": run_list\n");
7952                         rcode = run_list(command->group) & 0xff;
7953                 }
7954                 restore_redirects(squirrel);
7955                 IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
7956                 debug_leave();
7957                 debug_printf_exec("run_pipe: return %d\n", rcode);
7958                 return rcode;
7959         }
7960
7961         argv = command->argv ? command->argv : (char **) &null_ptr;
7962         {
7963                 const struct built_in_command *x;
7964 #if ENABLE_HUSH_FUNCTIONS
7965                 const struct function *funcp;
7966 #else
7967                 enum { funcp = 0 };
7968 #endif
7969                 char **new_env = NULL;
7970                 struct variable *old_vars = NULL;
7971
7972                 if (argv[command->assignment_cnt] == NULL) {
7973                         /* Assignments, but no command */
7974                         /* Ensure redirects take effect (that is, create files).
7975                          * Try "a=t >file" */
7976 #if 0 /* A few cases in testsuite fail with this code. FIXME */
7977                         rcode = redirect_and_varexp_helper(&new_env, /*old_vars:*/ NULL, command, &squirrel, /*argv_expanded:*/ NULL);
7978                         /* Set shell variables */
7979                         if (new_env) {
7980                                 argv = new_env;
7981                                 while (*argv) {
7982                                         if (set_local_var(*argv, /*flag:*/ 0)) {
7983                                                 /* assignment to readonly var / putenv error? */
7984                                                 rcode = 1;
7985                                         }
7986                                         argv++;
7987                                 }
7988                         }
7989                         /* Redirect error sets $? to 1. Otherwise,
7990                          * if evaluating assignment value set $?, retain it.
7991                          * Try "false; q=`exit 2`; echo $?" - should print 2: */
7992                         if (rcode == 0)
7993                                 rcode = G.last_exitcode;
7994                         /* Exit, _skipping_ variable restoring code: */
7995                         goto clean_up_and_ret0;
7996
7997 #else /* Older, bigger, but more correct code */
7998
7999                         rcode = setup_redirects(command, &squirrel);
8000                         restore_redirects(squirrel);
8001                         /* Set shell variables */
8002                         if (G_x_mode)
8003                                 bb_putchar_stderr('+');
8004                         while (*argv) {
8005                                 char *p = expand_string_to_string(*argv, /*unbackslash:*/ 1);
8006                                 if (G_x_mode)
8007                                         fprintf(stderr, " %s", p);
8008                                 debug_printf_exec("set shell var:'%s'->'%s'\n",
8009                                                 *argv, p);
8010                                 if (set_local_var(p, /*flag:*/ 0)) {
8011                                         /* assignment to readonly var / putenv error? */
8012                                         rcode = 1;
8013                                 }
8014                                 argv++;
8015                         }
8016                         if (G_x_mode)
8017                                 bb_putchar_stderr('\n');
8018                         /* Redirect error sets $? to 1. Otherwise,
8019                          * if evaluating assignment value set $?, retain it.
8020                          * Try "false; q=`exit 2`; echo $?" - should print 2: */
8021                         if (rcode == 0)
8022                                 rcode = G.last_exitcode;
8023                         IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
8024                         debug_leave();
8025                         debug_printf_exec("run_pipe: return %d\n", rcode);
8026                         return rcode;
8027 #endif
8028                 }
8029
8030                 /* Expand the rest into (possibly) many strings each */
8031 #if BASH_TEST2
8032                 if (command->cmd_type == CMD_SINGLEWORD_NOGLOB) {
8033                         argv_expanded = expand_strvec_to_strvec_singleword_noglob(argv + command->assignment_cnt);
8034                 } else
8035 #endif
8036                 {
8037                         argv_expanded = expand_strvec_to_strvec(argv + command->assignment_cnt);
8038                 }
8039
8040                 /* if someone gives us an empty string: `cmd with empty output` */
8041                 if (!argv_expanded[0]) {
8042                         free(argv_expanded);
8043                         debug_leave();
8044                         return G.last_exitcode;
8045                 }
8046
8047 #if ENABLE_HUSH_FUNCTIONS
8048                 /* Check if argv[0] matches any functions (this goes before bltins) */
8049                 funcp = find_function(argv_expanded[0]);
8050 #endif
8051                 x = NULL;
8052                 if (!funcp)
8053                         x = find_builtin(argv_expanded[0]);
8054                 if (x || funcp) {
8055                         if (!funcp) {
8056                                 if (x->b_function == builtin_exec && argv_expanded[1] == NULL) {
8057                                         debug_printf("exec with redirects only\n");
8058                                         rcode = setup_redirects(command, NULL);
8059                                         /* rcode=1 can be if redir file can't be opened */
8060                                         goto clean_up_and_ret1;
8061                                 }
8062                         }
8063                         rcode = redirect_and_varexp_helper(&new_env, &old_vars, command, &squirrel, argv_expanded);
8064                         if (rcode == 0) {
8065                                 if (!funcp) {
8066                                         debug_printf_exec(": builtin '%s' '%s'...\n",
8067                                                 x->b_cmd, argv_expanded[1]);
8068                                         fflush_all();
8069                                         rcode = x->b_function(argv_expanded) & 0xff;
8070                                         fflush_all();
8071                                 }
8072 #if ENABLE_HUSH_FUNCTIONS
8073                                 else {
8074 # if ENABLE_HUSH_LOCAL
8075                                         struct variable **sv;
8076                                         sv = G.shadowed_vars_pp;
8077                                         G.shadowed_vars_pp = &old_vars;
8078 # endif
8079                                         debug_printf_exec(": function '%s' '%s'...\n",
8080                                                 funcp->name, argv_expanded[1]);
8081                                         rcode = run_function(funcp, argv_expanded) & 0xff;
8082 # if ENABLE_HUSH_LOCAL
8083                                         G.shadowed_vars_pp = sv;
8084 # endif
8085                                 }
8086 #endif
8087                         }
8088  clean_up_and_ret:
8089                         unset_vars(new_env);
8090                         add_vars(old_vars);
8091 /* clean_up_and_ret0: */
8092                         restore_redirects(squirrel);
8093                         /*
8094                          * Try "usleep 99999999" + ^C + "echo $?"
8095                          * with FEATURE_SH_NOFORK=y.
8096                          */
8097                         if (!funcp) {
8098                                 /* It was builtin or nofork.
8099                                  * if this would be a real fork/execed program,
8100                                  * it should have died if a fatal sig was received.
8101                                  * But OTOH, there was no separate process,
8102                                  * the sig was sent to _shell_, not to non-existing
8103                                  * child.
8104                                  * Let's just handle ^C only, this one is obvious:
8105                                  * we aren't ok with exitcode 0 when ^C was pressed
8106                                  * during builtin/nofork.
8107                                  */
8108                                 if (sigismember(&G.pending_set, SIGINT))
8109                                         rcode = 128 + SIGINT;
8110                         }
8111  clean_up_and_ret1:
8112                         free(argv_expanded);
8113                         IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
8114                         debug_leave();
8115                         debug_printf_exec("run_pipe return %d\n", rcode);
8116                         return rcode;
8117                 }
8118
8119                 if (ENABLE_FEATURE_SH_NOFORK) {
8120                         int n = find_applet_by_name(argv_expanded[0]);
8121                         if (n >= 0 && APPLET_IS_NOFORK(n)) {
8122                                 rcode = redirect_and_varexp_helper(&new_env, &old_vars, command, &squirrel, argv_expanded);
8123                                 if (rcode == 0) {
8124                                         debug_printf_exec(": run_nofork_applet '%s' '%s'...\n",
8125                                                 argv_expanded[0], argv_expanded[1]);
8126                                         /*
8127                                          * Note: signals (^C) can't interrupt here.
8128                                          * We remember them and they will be acted upon
8129                                          * after applet returns.
8130                                          * This makes applets which can run for a long time
8131                                          * and/or wait for user input ineligible for NOFORK:
8132                                          * for example, "yes" or "rm" (rm -i waits for input).
8133                                          */
8134                                         rcode = run_nofork_applet(n, argv_expanded);
8135                                 }
8136                                 goto clean_up_and_ret;
8137                         }
8138                 }
8139                 /* It is neither builtin nor applet. We must fork. */
8140         }
8141
8142  must_fork:
8143         /* NB: argv_expanded may already be created, and that
8144          * might include `cmd` runs! Do not rerun it! We *must*
8145          * use argv_expanded if it's non-NULL */
8146
8147         /* Going to fork a child per each pipe member */
8148         pi->alive_cmds = 0;
8149         next_infd = 0;
8150
8151         cmd_no = 0;
8152         while (cmd_no < pi->num_cmds) {
8153                 struct fd_pair pipefds;
8154 #if !BB_MMU
8155                 volatile nommu_save_t nommu_save;
8156                 nommu_save.new_env = NULL;
8157                 nommu_save.old_vars = NULL;
8158                 nommu_save.argv = NULL;
8159                 nommu_save.argv_from_re_execing = NULL;
8160 #endif
8161                 command = &pi->cmds[cmd_no];
8162                 cmd_no++;
8163                 if (command->argv) {
8164                         debug_printf_exec(": pipe member '%s' '%s'...\n",
8165                                         command->argv[0], command->argv[1]);
8166                 } else {
8167                         debug_printf_exec(": pipe member with no argv\n");
8168                 }
8169
8170                 /* pipes are inserted between pairs of commands */
8171                 pipefds.rd = 0;
8172                 pipefds.wr = 1;
8173                 if (cmd_no < pi->num_cmds)
8174                         xpiped_pair(pipefds);
8175
8176                 command->pid = BB_MMU ? fork() : vfork();
8177                 if (!command->pid) { /* child */
8178 #if ENABLE_HUSH_JOB
8179                         disable_restore_tty_pgrp_on_exit();
8180                         CLEAR_RANDOM_T(&G.random_gen); /* or else $RANDOM repeats in child */
8181
8182                         /* Every child adds itself to new process group
8183                          * with pgid == pid_of_first_child_in_pipe */
8184                         if (G.run_list_level == 1 && G_interactive_fd) {
8185                                 pid_t pgrp;
8186                                 pgrp = pi->pgrp;
8187                                 if (pgrp < 0) /* true for 1st process only */
8188                                         pgrp = getpid();
8189                                 if (setpgid(0, pgrp) == 0
8190                                  && pi->followup != PIPE_BG
8191                                  && G_saved_tty_pgrp /* we have ctty */
8192                                 ) {
8193                                         /* We do it in *every* child, not just first,
8194                                          * to avoid races */
8195                                         tcsetpgrp(G_interactive_fd, pgrp);
8196                                 }
8197                         }
8198 #endif
8199                         if (pi->alive_cmds == 0 && pi->followup == PIPE_BG) {
8200                                 /* 1st cmd in backgrounded pipe
8201                                  * should have its stdin /dev/null'ed */
8202                                 close(0);
8203                                 if (open(bb_dev_null, O_RDONLY))
8204                                         xopen("/", O_RDONLY);
8205                         } else {
8206                                 xmove_fd(next_infd, 0);
8207                         }
8208                         xmove_fd(pipefds.wr, 1);
8209                         if (pipefds.rd > 1)
8210                                 close(pipefds.rd);
8211                         /* Like bash, explicit redirects override pipes,
8212                          * and the pipe fd (fd#1) is available for dup'ing:
8213                          * "cmd1 2>&1 | cmd2": fd#1 is duped to fd#2, thus stderr
8214                          * of cmd1 goes into pipe.
8215                          */
8216                         if (setup_redirects(command, NULL)) {
8217                                 /* Happens when redir file can't be opened:
8218                                  * $ hush -c 'echo FOO >&2 | echo BAR 3>/qwe/rty; echo BAZ'
8219                                  * FOO
8220                                  * hush: can't open '/qwe/rty': No such file or directory
8221                                  * BAZ
8222                                  * (echo BAR is not executed, it hits _exit(1) below)
8223                                  */
8224                                 _exit(1);
8225                         }
8226
8227                         /* Stores to nommu_save list of env vars putenv'ed
8228                          * (NOMMU, on MMU we don't need that) */
8229                         /* cast away volatility... */
8230                         pseudo_exec((nommu_save_t*) &nommu_save, command, argv_expanded);
8231                         /* pseudo_exec() does not return */
8232                 }
8233
8234                 /* parent or error */
8235 #if ENABLE_HUSH_FAST
8236                 G.count_SIGCHLD++;
8237 //bb_error_msg("[%d] fork in run_pipe: G.count_SIGCHLD:%d G.handled_SIGCHLD:%d", getpid(), G.count_SIGCHLD, G.handled_SIGCHLD);
8238 #endif
8239                 enable_restore_tty_pgrp_on_exit();
8240 #if !BB_MMU
8241                 /* Clean up after vforked child */
8242                 free(nommu_save.argv);
8243                 free(nommu_save.argv_from_re_execing);
8244                 unset_vars(nommu_save.new_env);
8245                 add_vars(nommu_save.old_vars);
8246 #endif
8247                 free(argv_expanded);
8248                 argv_expanded = NULL;
8249                 if (command->pid < 0) { /* [v]fork failed */
8250                         /* Clearly indicate, was it fork or vfork */
8251                         bb_perror_msg(BB_MMU ? "vfork"+1 : "vfork");
8252                 } else {
8253                         pi->alive_cmds++;
8254 #if ENABLE_HUSH_JOB
8255                         /* Second and next children need to know pid of first one */
8256                         if (pi->pgrp < 0)
8257                                 pi->pgrp = command->pid;
8258 #endif
8259                 }
8260
8261                 if (cmd_no > 1)
8262                         close(next_infd);
8263                 if (cmd_no < pi->num_cmds)
8264                         close(pipefds.wr);
8265                 /* Pass read (output) pipe end to next iteration */
8266                 next_infd = pipefds.rd;
8267         }
8268
8269         if (!pi->alive_cmds) {
8270                 debug_leave();
8271                 debug_printf_exec("run_pipe return 1 (all forks failed, no children)\n");
8272                 return 1;
8273         }
8274
8275         debug_leave();
8276         debug_printf_exec("run_pipe return -1 (%u children started)\n", pi->alive_cmds);
8277         return -1;
8278 }
8279
8280 /* NB: called by pseudo_exec, and therefore must not modify any
8281  * global data until exec/_exit (we can be a child after vfork!) */
8282 static int run_list(struct pipe *pi)
8283 {
8284 #if ENABLE_HUSH_CASE
8285         char *case_word = NULL;
8286 #endif
8287 #if ENABLE_HUSH_LOOPS
8288         struct pipe *loop_top = NULL;
8289         char **for_lcur = NULL;
8290         char **for_list = NULL;
8291 #endif
8292         smallint last_followup;
8293         smalluint rcode;
8294 #if ENABLE_HUSH_IF || ENABLE_HUSH_CASE
8295         smalluint cond_code = 0;
8296 #else
8297         enum { cond_code = 0 };
8298 #endif
8299 #if HAS_KEYWORDS
8300         smallint rword;      /* RES_foo */
8301         smallint last_rword; /* ditto */
8302 #endif
8303
8304         debug_printf_exec("run_list start lvl %d\n", G.run_list_level);
8305         debug_enter();
8306
8307 #if ENABLE_HUSH_LOOPS
8308         /* Check syntax for "for" */
8309         {
8310                 struct pipe *cpipe;
8311                 for (cpipe = pi; cpipe; cpipe = cpipe->next) {
8312                         if (cpipe->res_word != RES_FOR && cpipe->res_word != RES_IN)
8313                                 continue;
8314                         /* current word is FOR or IN (BOLD in comments below) */
8315                         if (cpipe->next == NULL) {
8316                                 syntax_error("malformed for");
8317                                 debug_leave();
8318                                 debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
8319                                 return 1;
8320                         }
8321                         /* "FOR v; do ..." and "for v IN a b; do..." are ok */
8322                         if (cpipe->next->res_word == RES_DO)
8323                                 continue;
8324                         /* next word is not "do". It must be "in" then ("FOR v in ...") */
8325                         if (cpipe->res_word == RES_IN /* "for v IN a b; not_do..."? */
8326                          || cpipe->next->res_word != RES_IN /* FOR v not_do_and_not_in..."? */
8327                         ) {
8328                                 syntax_error("malformed for");
8329                                 debug_leave();
8330                                 debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
8331                                 return 1;
8332                         }
8333                 }
8334         }
8335 #endif
8336
8337         /* Past this point, all code paths should jump to ret: label
8338          * in order to return, no direct "return" statements please.
8339          * This helps to ensure that no memory is leaked. */
8340
8341 #if ENABLE_HUSH_JOB
8342         G.run_list_level++;
8343 #endif
8344
8345 #if HAS_KEYWORDS
8346         rword = RES_NONE;
8347         last_rword = RES_XXXX;
8348 #endif
8349         last_followup = PIPE_SEQ;
8350         rcode = G.last_exitcode;
8351
8352         /* Go through list of pipes, (maybe) executing them. */
8353         for (; pi; pi = IF_HUSH_LOOPS(rword == RES_DONE ? loop_top : ) pi->next) {
8354                 int r;
8355                 int sv_errexit_depth;
8356
8357                 if (G.flag_SIGINT)
8358                         break;
8359                 if (G_flag_return_in_progress == 1)
8360                         break;
8361
8362                 IF_HAS_KEYWORDS(rword = pi->res_word;)
8363                 debug_printf_exec(": rword=%d cond_code=%d last_rword=%d\n",
8364                                 rword, cond_code, last_rword);
8365
8366                 sv_errexit_depth = G.errexit_depth;
8367                 if (IF_HAS_KEYWORDS(rword == RES_IF || rword == RES_ELIF ||)
8368                     pi->followup != PIPE_SEQ
8369                 ) {
8370                         G.errexit_depth++;
8371                 }
8372 #if ENABLE_HUSH_LOOPS
8373                 if ((rword == RES_WHILE || rword == RES_UNTIL || rword == RES_FOR)
8374                  && loop_top == NULL /* avoid bumping G.depth_of_loop twice */
8375                 ) {
8376                         /* start of a loop: remember where loop starts */
8377                         loop_top = pi;
8378                         G.depth_of_loop++;
8379                 }
8380 #endif
8381                 /* Still in the same "if...", "then..." or "do..." branch? */
8382                 if (IF_HAS_KEYWORDS(rword == last_rword &&) 1) {
8383                         if ((rcode == 0 && last_followup == PIPE_OR)
8384                          || (rcode != 0 && last_followup == PIPE_AND)
8385                         ) {
8386                                 /* It is "<true> || CMD" or "<false> && CMD"
8387                                  * and we should not execute CMD */
8388                                 debug_printf_exec("skipped cmd because of || or &&\n");
8389                                 last_followup = pi->followup;
8390                                 goto dont_check_jobs_but_continue;
8391                         }
8392                 }
8393                 last_followup = pi->followup;
8394                 IF_HAS_KEYWORDS(last_rword = rword;)
8395 #if ENABLE_HUSH_IF
8396                 if (cond_code) {
8397                         if (rword == RES_THEN) {
8398                                 /* if false; then ... fi has exitcode 0! */
8399                                 G.last_exitcode = rcode = EXIT_SUCCESS;
8400                                 /* "if <false> THEN cmd": skip cmd */
8401                                 continue;
8402                         }
8403                 } else {
8404                         if (rword == RES_ELSE || rword == RES_ELIF) {
8405                                 /* "if <true> then ... ELSE/ELIF cmd":
8406                                  * skip cmd and all following ones */
8407                                 break;
8408                         }
8409                 }
8410 #endif
8411 #if ENABLE_HUSH_LOOPS
8412                 if (rword == RES_FOR) { /* && pi->num_cmds - always == 1 */
8413                         if (!for_lcur) {
8414                                 /* first loop through for */
8415
8416                                 static const char encoded_dollar_at[] ALIGN1 = {
8417                                         SPECIAL_VAR_SYMBOL, '@' | 0x80, SPECIAL_VAR_SYMBOL, '\0'
8418                                 }; /* encoded representation of "$@" */
8419                                 static const char *const encoded_dollar_at_argv[] = {
8420                                         encoded_dollar_at, NULL
8421                                 }; /* argv list with one element: "$@" */
8422                                 char **vals;
8423
8424                                 vals = (char**)encoded_dollar_at_argv;
8425                                 if (pi->next->res_word == RES_IN) {
8426                                         /* if no variable values after "in" we skip "for" */
8427                                         if (!pi->next->cmds[0].argv) {
8428                                                 G.last_exitcode = rcode = EXIT_SUCCESS;
8429                                                 debug_printf_exec(": null FOR: exitcode EXIT_SUCCESS\n");
8430                                                 break;
8431                                         }
8432                                         vals = pi->next->cmds[0].argv;
8433                                 } /* else: "for var; do..." -> assume "$@" list */
8434                                 /* create list of variable values */
8435                                 debug_print_strings("for_list made from", vals);
8436                                 for_list = expand_strvec_to_strvec(vals);
8437                                 for_lcur = for_list;
8438                                 debug_print_strings("for_list", for_list);
8439                         }
8440                         if (!*for_lcur) {
8441                                 /* "for" loop is over, clean up */
8442                                 free(for_list);
8443                                 for_list = NULL;
8444                                 for_lcur = NULL;
8445                                 break;
8446                         }
8447                         /* Insert next value from for_lcur */
8448                         /* note: *for_lcur already has quotes removed, $var expanded, etc */
8449                         set_local_var(xasprintf("%s=%s", pi->cmds[0].argv[0], *for_lcur++), /*flag:*/ 0);
8450                         continue;
8451                 }
8452                 if (rword == RES_IN) {
8453                         continue; /* "for v IN list;..." - "in" has no cmds anyway */
8454                 }
8455                 if (rword == RES_DONE) {
8456                         continue; /* "done" has no cmds too */
8457                 }
8458 #endif
8459 #if ENABLE_HUSH_CASE
8460                 if (rword == RES_CASE) {
8461                         debug_printf_exec("CASE cond_code:%d\n", cond_code);
8462                         case_word = expand_strvec_to_string(pi->cmds->argv);
8463                         unbackslash(case_word);
8464                         continue;
8465                 }
8466                 if (rword == RES_MATCH) {
8467                         char **argv;
8468
8469                         debug_printf_exec("MATCH cond_code:%d\n", cond_code);
8470                         if (!case_word) /* "case ... matched_word) ... WORD)": we executed selected branch, stop */
8471                                 break;
8472                         /* all prev words didn't match, does this one match? */
8473                         argv = pi->cmds->argv;
8474                         while (*argv) {
8475                                 char *pattern = expand_string_to_string(*argv, /*unbackslash:*/ 0);
8476                                 /* TODO: which FNM_xxx flags to use? */
8477                                 cond_code = (fnmatch(pattern, case_word, /*flags:*/ 0) != 0);
8478                                 debug_printf_exec("fnmatch(pattern:'%s',str:'%s'):%d\n", pattern, case_word, cond_code);
8479                                 free(pattern);
8480                                 if (cond_code == 0) { /* match! we will execute this branch */
8481                                         free(case_word);
8482                                         case_word = NULL; /* make future "word)" stop */
8483                                         break;
8484                                 }
8485                                 argv++;
8486                         }
8487                         continue;
8488                 }
8489                 if (rword == RES_CASE_BODY) { /* inside of a case branch */
8490                         debug_printf_exec("CASE_BODY cond_code:%d\n", cond_code);
8491                         if (cond_code != 0)
8492                                 continue; /* not matched yet, skip this pipe */
8493                 }
8494                 if (rword == RES_ESAC) {
8495                         debug_printf_exec("ESAC cond_code:%d\n", cond_code);
8496                         if (case_word) {
8497                                 /* "case" did not match anything: still set $? (to 0) */
8498                                 G.last_exitcode = rcode = EXIT_SUCCESS;
8499                         }
8500                 }
8501 #endif
8502                 /* Just pressing <enter> in shell should check for jobs.
8503                  * OTOH, in non-interactive shell this is useless
8504                  * and only leads to extra job checks */
8505                 if (pi->num_cmds == 0) {
8506                         if (G_interactive_fd)
8507                                 goto check_jobs_and_continue;
8508                         continue;
8509                 }
8510
8511                 /* After analyzing all keywords and conditions, we decided
8512                  * to execute this pipe. NB: have to do checkjobs(NULL)
8513                  * after run_pipe to collect any background children,
8514                  * even if list execution is to be stopped. */
8515                 debug_printf_exec(": run_pipe with %d members\n", pi->num_cmds);
8516 #if ENABLE_HUSH_LOOPS
8517                 G.flag_break_continue = 0;
8518 #endif
8519                 rcode = r = run_pipe(pi); /* NB: rcode is a smalluint, r is int */
8520                 if (r != -1) {
8521                         /* We ran a builtin, function, or group.
8522                          * rcode is already known
8523                          * and we don't need to wait for anything. */
8524                         debug_printf_exec(": builtin/func exitcode %d\n", rcode);
8525                         G.last_exitcode = rcode;
8526                         check_and_run_traps();
8527 #if ENABLE_HUSH_LOOPS
8528                         /* Was it "break" or "continue"? */
8529                         if (G.flag_break_continue) {
8530                                 smallint fbc = G.flag_break_continue;
8531                                 /* We might fall into outer *loop*,
8532                                  * don't want to break it too */
8533                                 if (loop_top) {
8534                                         G.depth_break_continue--;
8535                                         if (G.depth_break_continue == 0)
8536                                                 G.flag_break_continue = 0;
8537                                         /* else: e.g. "continue 2" should *break* once, *then* continue */
8538                                 } /* else: "while... do... { we are here (innermost list is not a loop!) };...done" */
8539                                 if (G.depth_break_continue != 0 || fbc == BC_BREAK) {
8540                                         checkjobs(NULL, 0 /*(no pid to wait for)*/);
8541                                         break;
8542                                 }
8543                                 /* "continue": simulate end of loop */
8544                                 rword = RES_DONE;
8545                                 continue;
8546                         }
8547 #endif
8548                         if (G_flag_return_in_progress == 1) {
8549                                 checkjobs(NULL, 0 /*(no pid to wait for)*/);
8550                                 break;
8551                         }
8552                 } else if (pi->followup == PIPE_BG) {
8553                         /* What does bash do with attempts to background builtins? */
8554                         /* even bash 3.2 doesn't do that well with nested bg:
8555                          * try "{ { sleep 10; echo DEEP; } & echo HERE; } &".
8556                          * I'm NOT treating inner &'s as jobs */
8557 #if ENABLE_HUSH_JOB
8558                         if (G.run_list_level == 1)
8559                                 insert_job_into_table(pi);
8560 #endif
8561                         /* Last command's pid goes to $! */
8562                         G.last_bg_pid = pi->cmds[pi->num_cmds - 1].pid;
8563                         G.last_bg_pid_exitcode = 0;
8564                         debug_printf_exec(": cmd&: exitcode EXIT_SUCCESS\n");
8565 /* Check pi->pi_inverted? "! sleep 1 & echo $?": bash says 1. dash and ash say 0 */
8566                         rcode = EXIT_SUCCESS;
8567                         goto check_traps;
8568                 } else {
8569 #if ENABLE_HUSH_JOB
8570                         if (G.run_list_level == 1 && G_interactive_fd) {
8571                                 /* Waits for completion, then fg's main shell */
8572                                 rcode = checkjobs_and_fg_shell(pi);
8573                                 debug_printf_exec(": checkjobs_and_fg_shell exitcode %d\n", rcode);
8574                                 goto check_traps;
8575                         }
8576 #endif
8577                         /* This one just waits for completion */
8578                         rcode = checkjobs(pi, 0 /*(no pid to wait for)*/);
8579                         debug_printf_exec(": checkjobs exitcode %d\n", rcode);
8580  check_traps:
8581                         G.last_exitcode = rcode;
8582                         check_and_run_traps();
8583                 }
8584
8585                 /* Handle "set -e" */
8586                 if (rcode != 0 && G.o_opt[OPT_O_ERREXIT]) {
8587                         debug_printf_exec("ERREXIT:1 errexit_depth:%d\n", G.errexit_depth);
8588                         if (G.errexit_depth == 0)
8589                                 hush_exit(rcode);
8590                 }
8591                 G.errexit_depth = sv_errexit_depth;
8592
8593                 /* Analyze how result affects subsequent commands */
8594 #if ENABLE_HUSH_IF
8595                 if (rword == RES_IF || rword == RES_ELIF)
8596                         cond_code = rcode;
8597 #endif
8598  check_jobs_and_continue:
8599                 checkjobs(NULL, 0 /*(no pid to wait for)*/);
8600  dont_check_jobs_but_continue: ;
8601 #if ENABLE_HUSH_LOOPS
8602                 /* Beware of "while false; true; do ..."! */
8603                 if (pi->next
8604                  && (pi->next->res_word == RES_DO || pi->next->res_word == RES_DONE)
8605                  /* check for RES_DONE is needed for "while ...; do \n done" case */
8606                 ) {
8607                         if (rword == RES_WHILE) {
8608                                 if (rcode) {
8609                                         /* "while false; do...done" - exitcode 0 */
8610                                         G.last_exitcode = rcode = EXIT_SUCCESS;
8611                                         debug_printf_exec(": while expr is false: breaking (exitcode:EXIT_SUCCESS)\n");
8612                                         break;
8613                                 }
8614                         }
8615                         if (rword == RES_UNTIL) {
8616                                 if (!rcode) {
8617                                         debug_printf_exec(": until expr is true: breaking\n");
8618                                         break;
8619                                 }
8620                         }
8621                 }
8622 #endif
8623         } /* for (pi) */
8624
8625 #if ENABLE_HUSH_JOB
8626         G.run_list_level--;
8627 #endif
8628 #if ENABLE_HUSH_LOOPS
8629         if (loop_top)
8630                 G.depth_of_loop--;
8631         free(for_list);
8632 #endif
8633 #if ENABLE_HUSH_CASE
8634         free(case_word);
8635 #endif
8636         debug_leave();
8637         debug_printf_exec("run_list lvl %d return %d\n", G.run_list_level + 1, rcode);
8638         return rcode;
8639 }
8640
8641 /* Select which version we will use */
8642 static int run_and_free_list(struct pipe *pi)
8643 {
8644         int rcode = 0;
8645         debug_printf_exec("run_and_free_list entered\n");
8646         if (!G.o_opt[OPT_O_NOEXEC]) {
8647                 debug_printf_exec(": run_list: 1st pipe with %d cmds\n", pi->num_cmds);
8648                 rcode = run_list(pi);
8649         }
8650         /* free_pipe_list has the side effect of clearing memory.
8651          * In the long run that function can be merged with run_list,
8652          * but doing that now would hobble the debugging effort. */
8653         free_pipe_list(pi);
8654         debug_printf_exec("run_and_free_list return %d\n", rcode);
8655         return rcode;
8656 }
8657
8658
8659 static void install_sighandlers(unsigned mask)
8660 {
8661         sighandler_t old_handler;
8662         unsigned sig = 0;
8663         while ((mask >>= 1) != 0) {
8664                 sig++;
8665                 if (!(mask & 1))
8666                         continue;
8667                 old_handler = install_sighandler(sig, pick_sighandler(sig));
8668                 /* POSIX allows shell to re-enable SIGCHLD
8669                  * even if it was SIG_IGN on entry.
8670                  * Therefore we skip IGN check for it:
8671                  */
8672                 if (sig == SIGCHLD)
8673                         continue;
8674                 /* bash re-enables SIGHUP which is SIG_IGNed on entry.
8675                  * Try: "trap '' HUP; bash; echo RET" and type "kill -HUP $$"
8676                  */
8677                 //if (sig == SIGHUP) continue; - TODO?
8678                 if (old_handler == SIG_IGN) {
8679                         /* oops... restore back to IGN, and record this fact */
8680                         install_sighandler(sig, old_handler);
8681 #if ENABLE_HUSH_TRAP
8682                         if (!G_traps)
8683                                 G_traps = xzalloc(sizeof(G_traps[0]) * NSIG);
8684                         free(G_traps[sig]);
8685                         G_traps[sig] = xzalloc(1); /* == xstrdup(""); */
8686 #endif
8687                 }
8688         }
8689 }
8690
8691 /* Called a few times only (or even once if "sh -c") */
8692 static void install_special_sighandlers(void)
8693 {
8694         unsigned mask;
8695
8696         /* Which signals are shell-special? */
8697         mask = (1 << SIGQUIT) | (1 << SIGCHLD);
8698         if (G_interactive_fd) {
8699                 mask |= SPECIAL_INTERACTIVE_SIGS;
8700                 if (G_saved_tty_pgrp) /* we have ctty, job control sigs work */
8701                         mask |= SPECIAL_JOBSTOP_SIGS;
8702         }
8703         /* Careful, do not re-install handlers we already installed */
8704         if (G.special_sig_mask != mask) {
8705                 unsigned diff = mask & ~G.special_sig_mask;
8706                 G.special_sig_mask = mask;
8707                 install_sighandlers(diff);
8708         }
8709 }
8710
8711 #if ENABLE_HUSH_JOB
8712 /* helper */
8713 /* Set handlers to restore tty pgrp and exit */
8714 static void install_fatal_sighandlers(void)
8715 {
8716         unsigned mask;
8717
8718         /* We will restore tty pgrp on these signals */
8719         mask = 0
8720                 /*+ (1 << SIGILL ) * HUSH_DEBUG*/
8721                 /*+ (1 << SIGFPE ) * HUSH_DEBUG*/
8722                 + (1 << SIGBUS ) * HUSH_DEBUG
8723                 + (1 << SIGSEGV) * HUSH_DEBUG
8724                 /*+ (1 << SIGTRAP) * HUSH_DEBUG*/
8725                 + (1 << SIGABRT)
8726         /* bash 3.2 seems to handle these just like 'fatal' ones */
8727                 + (1 << SIGPIPE)
8728                 + (1 << SIGALRM)
8729         /* if we are interactive, SIGHUP, SIGTERM and SIGINT are special sigs.
8730          * if we aren't interactive... but in this case
8731          * we never want to restore pgrp on exit, and this fn is not called
8732          */
8733                 /*+ (1 << SIGHUP )*/
8734                 /*+ (1 << SIGTERM)*/
8735                 /*+ (1 << SIGINT )*/
8736         ;
8737         G_fatal_sig_mask = mask;
8738
8739         install_sighandlers(mask);
8740 }
8741 #endif
8742
8743 static int set_mode(int state, char mode, const char *o_opt)
8744 {
8745         int idx;
8746         switch (mode) {
8747         case 'n':
8748                 G.o_opt[OPT_O_NOEXEC] = state;
8749                 break;
8750         case 'x':
8751                 IF_HUSH_MODE_X(G_x_mode = state;)
8752                 break;
8753         case 'o':
8754                 if (!o_opt) {
8755                         /* "set -+o" without parameter.
8756                          * in bash, set -o produces this output:
8757                          *  pipefail        off
8758                          * and set +o:
8759                          *  set +o pipefail
8760                          * We always use the second form.
8761                          */
8762                         const char *p = o_opt_strings;
8763                         idx = 0;
8764                         while (*p) {
8765                                 printf("set %co %s\n", (G.o_opt[idx] ? '-' : '+'), p);
8766                                 idx++;
8767                                 p += strlen(p) + 1;
8768                         }
8769                         break;
8770                 }
8771                 idx = index_in_strings(o_opt_strings, o_opt);
8772                 if (idx >= 0) {
8773                         G.o_opt[idx] = state;
8774                         break;
8775                 }
8776         case 'e':
8777                 G.o_opt[OPT_O_ERREXIT] = state;
8778                 break;
8779         default:
8780                 return EXIT_FAILURE;
8781         }
8782         return EXIT_SUCCESS;
8783 }
8784
8785 int hush_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
8786 int hush_main(int argc, char **argv)
8787 {
8788         enum {
8789                 OPT_login = (1 << 0),
8790         };
8791         unsigned flags;
8792         int opt;
8793         unsigned builtin_argc;
8794         char **e;
8795         struct variable *cur_var;
8796         struct variable *shell_ver;
8797
8798         INIT_G();
8799         if (EXIT_SUCCESS != 0) /* if EXIT_SUCCESS == 0, it is already done */
8800                 G.last_exitcode = EXIT_SUCCESS;
8801
8802 #if ENABLE_HUSH_FAST
8803         G.count_SIGCHLD++; /* ensure it is != G.handled_SIGCHLD */
8804 #endif
8805 #if !BB_MMU
8806         G.argv0_for_re_execing = argv[0];
8807 #endif
8808         /* Deal with HUSH_VERSION */
8809         shell_ver = xzalloc(sizeof(*shell_ver));
8810         shell_ver->flg_export = 1;
8811         shell_ver->flg_read_only = 1;
8812         /* Code which handles ${var<op>...} needs writable values for all variables,
8813          * therefore we xstrdup: */
8814         shell_ver->varstr = xstrdup(hush_version_str);
8815         /* Create shell local variables from the values
8816          * currently living in the environment */
8817         debug_printf_env("unsetenv '%s'\n", "HUSH_VERSION");
8818         unsetenv("HUSH_VERSION"); /* in case it exists in initial env */
8819         G.top_var = shell_ver;
8820         cur_var = G.top_var;
8821         e = environ;
8822         if (e) while (*e) {
8823                 char *value = strchr(*e, '=');
8824                 if (value) { /* paranoia */
8825                         cur_var->next = xzalloc(sizeof(*cur_var));
8826                         cur_var = cur_var->next;
8827                         cur_var->varstr = *e;
8828                         cur_var->max_len = strlen(*e);
8829                         cur_var->flg_export = 1;
8830                 }
8831                 e++;
8832         }
8833         /* (Re)insert HUSH_VERSION into env (AFTER we scanned the env!) */
8834         debug_printf_env("putenv '%s'\n", shell_ver->varstr);
8835         putenv(shell_ver->varstr);
8836
8837         /* Export PWD */
8838         set_pwd_var(SETFLAG_EXPORT);
8839
8840 #if BASH_HOSTNAME_VAR
8841         /* Set (but not export) HOSTNAME unless already set */
8842         if (!get_local_var_value("HOSTNAME")) {
8843                 struct utsname uts;
8844                 uname(&uts);
8845                 set_local_var_from_halves("HOSTNAME", uts.nodename);
8846         }
8847         /* bash also exports SHLVL and _,
8848          * and sets (but doesn't export) the following variables:
8849          * BASH=/bin/bash
8850          * BASH_VERSINFO=([0]="3" [1]="2" [2]="0" [3]="1" [4]="release" [5]="i386-pc-linux-gnu")
8851          * BASH_VERSION='3.2.0(1)-release'
8852          * HOSTTYPE=i386
8853          * MACHTYPE=i386-pc-linux-gnu
8854          * OSTYPE=linux-gnu
8855          * PPID=<NNNNN> - we also do it elsewhere
8856          * EUID=<NNNNN>
8857          * UID=<NNNNN>
8858          * GROUPS=()
8859          * LINES=<NNN>
8860          * COLUMNS=<NNN>
8861          * BASH_ARGC=()
8862          * BASH_ARGV=()
8863          * BASH_LINENO=()
8864          * BASH_SOURCE=()
8865          * DIRSTACK=()
8866          * PIPESTATUS=([0]="0")
8867          * HISTFILE=/<xxx>/.bash_history
8868          * HISTFILESIZE=500
8869          * HISTSIZE=500
8870          * MAILCHECK=60
8871          * PATH=/usr/gnu/bin:/usr/local/bin:/bin:/usr/bin:.
8872          * SHELL=/bin/bash
8873          * SHELLOPTS=braceexpand:emacs:hashall:histexpand:history:interactive-comments:monitor
8874          * TERM=dumb
8875          * OPTERR=1
8876          * OPTIND=1
8877          * IFS=$' \t\n'
8878          * PS1='\s-\v\$ '
8879          * PS2='> '
8880          * PS4='+ '
8881          */
8882 #endif
8883
8884 #if ENABLE_FEATURE_EDITING
8885         G.line_input_state = new_line_input_t(FOR_SHELL);
8886 #endif
8887
8888         /* Initialize some more globals to non-zero values */
8889         cmdedit_update_prompt();
8890
8891         die_func = restore_ttypgrp_and__exit;
8892
8893         /* Shell is non-interactive at first. We need to call
8894          * install_special_sighandlers() if we are going to execute "sh <script>",
8895          * "sh -c <cmds>" or login shell's /etc/profile and friends.
8896          * If we later decide that we are interactive, we run install_special_sighandlers()
8897          * in order to intercept (more) signals.
8898          */
8899
8900         /* Parse options */
8901         /* http://www.opengroup.org/onlinepubs/9699919799/utilities/sh.html */
8902         flags = (argv[0] && argv[0][0] == '-') ? OPT_login : 0;
8903         builtin_argc = 0;
8904         while (1) {
8905                 opt = getopt(argc, argv, "+c:exinsl"
8906 #if !BB_MMU
8907                                 "<:$:R:V:"
8908 # if ENABLE_HUSH_FUNCTIONS
8909                                 "F:"
8910 # endif
8911 #endif
8912                 );
8913                 if (opt <= 0)
8914                         break;
8915                 switch (opt) {
8916                 case 'c':
8917                         /* Possibilities:
8918                          * sh ... -c 'script'
8919                          * sh ... -c 'script' ARG0 [ARG1...]
8920                          * On NOMMU, if builtin_argc != 0,
8921                          * sh ... -c 'builtin' BARGV... "" ARG0 [ARG1...]
8922                          * "" needs to be replaced with NULL
8923                          * and BARGV vector fed to builtin function.
8924                          * Note: the form without ARG0 never happens:
8925                          * sh ... -c 'builtin' BARGV... ""
8926                          */
8927                         if (!G.root_pid) {
8928                                 G.root_pid = getpid();
8929                                 G.root_ppid = getppid();
8930                         }
8931                         G.global_argv = argv + optind;
8932                         G.global_argc = argc - optind;
8933                         if (builtin_argc) {
8934                                 /* -c 'builtin' [BARGV...] "" ARG0 [ARG1...] */
8935                                 const struct built_in_command *x;
8936
8937                                 install_special_sighandlers();
8938                                 x = find_builtin(optarg);
8939                                 if (x) { /* paranoia */
8940                                         G.global_argc -= builtin_argc; /* skip [BARGV...] "" */
8941                                         G.global_argv += builtin_argc;
8942                                         G.global_argv[-1] = NULL; /* replace "" */
8943                                         fflush_all();
8944                                         G.last_exitcode = x->b_function(argv + optind - 1);
8945                                 }
8946                                 goto final_return;
8947                         }
8948                         if (!G.global_argv[0]) {
8949                                 /* -c 'script' (no params): prevent empty $0 */
8950                                 G.global_argv--; /* points to argv[i] of 'script' */
8951                                 G.global_argv[0] = argv[0];
8952                                 G.global_argc++;
8953                         } /* else -c 'script' ARG0 [ARG1...]: $0 is ARG0 */
8954                         install_special_sighandlers();
8955                         parse_and_run_string(optarg);
8956                         goto final_return;
8957                 case 'i':
8958                         /* Well, we cannot just declare interactiveness,
8959                          * we have to have some stuff (ctty, etc) */
8960                         /* G_interactive_fd++; */
8961                         break;
8962                 case 's':
8963                         /* "-s" means "read from stdin", but this is how we always
8964                          * operate, so simply do nothing here. */
8965                         break;
8966                 case 'l':
8967                         flags |= OPT_login;
8968                         break;
8969 #if !BB_MMU
8970                 case '<': /* "big heredoc" support */
8971                         full_write1_str(optarg);
8972                         _exit(0);
8973                 case '$': {
8974                         unsigned long long empty_trap_mask;
8975
8976                         G.root_pid = bb_strtou(optarg, &optarg, 16);
8977                         optarg++;
8978                         G.root_ppid = bb_strtou(optarg, &optarg, 16);
8979                         optarg++;
8980                         G.last_bg_pid = bb_strtou(optarg, &optarg, 16);
8981                         optarg++;
8982                         G.last_exitcode = bb_strtou(optarg, &optarg, 16);
8983                         optarg++;
8984                         builtin_argc = bb_strtou(optarg, &optarg, 16);
8985                         optarg++;
8986                         empty_trap_mask = bb_strtoull(optarg, &optarg, 16);
8987                         if (empty_trap_mask != 0) {
8988                                 IF_HUSH_TRAP(int sig;)
8989                                 install_special_sighandlers();
8990 # if ENABLE_HUSH_TRAP
8991                                 G_traps = xzalloc(sizeof(G_traps[0]) * NSIG);
8992                                 for (sig = 1; sig < NSIG; sig++) {
8993                                         if (empty_trap_mask & (1LL << sig)) {
8994                                                 G_traps[sig] = xzalloc(1); /* == xstrdup(""); */
8995                                                 install_sighandler(sig, SIG_IGN);
8996                                         }
8997                                 }
8998 # endif
8999                         }
9000 # if ENABLE_HUSH_LOOPS
9001                         optarg++;
9002                         G.depth_of_loop = bb_strtou(optarg, &optarg, 16);
9003 # endif
9004                         break;
9005                 }
9006                 case 'R':
9007                 case 'V':
9008                         set_local_var(xstrdup(optarg), opt == 'R' ? SETFLAG_MAKE_RO : 0);
9009                         break;
9010 # if ENABLE_HUSH_FUNCTIONS
9011                 case 'F': {
9012                         struct function *funcp = new_function(optarg);
9013                         /* funcp->name is already set to optarg */
9014                         /* funcp->body is set to NULL. It's a special case. */
9015                         funcp->body_as_string = argv[optind];
9016                         optind++;
9017                         break;
9018                 }
9019 # endif
9020 #endif
9021                 case 'n':
9022                 case 'x':
9023                 case 'e':
9024                         if (set_mode(1, opt, NULL) == 0) /* no error */
9025                                 break;
9026                 default:
9027 #ifndef BB_VER
9028                         fprintf(stderr, "Usage: sh [FILE]...\n"
9029                                         "   or: sh -c command [args]...\n\n");
9030                         exit(EXIT_FAILURE);
9031 #else
9032                         bb_show_usage();
9033 #endif
9034                 }
9035         } /* option parsing loop */
9036
9037         /* Skip options. Try "hush -l": $1 should not be "-l"! */
9038         G.global_argc = argc - (optind - 1);
9039         G.global_argv = argv + (optind - 1);
9040         G.global_argv[0] = argv[0];
9041
9042         if (!G.root_pid) {
9043                 G.root_pid = getpid();
9044                 G.root_ppid = getppid();
9045         }
9046
9047         /* If we are login shell... */
9048         if (flags & OPT_login) {
9049                 FILE *input;
9050                 debug_printf("sourcing /etc/profile\n");
9051                 input = fopen_for_read("/etc/profile");
9052                 if (input != NULL) {
9053                         remember_FILE(input);
9054                         install_special_sighandlers();
9055                         parse_and_run_file(input);
9056                         fclose_and_forget(input);
9057                 }
9058                 /* bash: after sourcing /etc/profile,
9059                  * tries to source (in the given order):
9060                  * ~/.bash_profile, ~/.bash_login, ~/.profile,
9061                  * stopping on first found. --noprofile turns this off.
9062                  * bash also sources ~/.bash_logout on exit.
9063                  * If called as sh, skips .bash_XXX files.
9064                  */
9065         }
9066
9067         if (G.global_argv[1]) {
9068                 FILE *input;
9069                 /*
9070                  * "bash <script>" (which is never interactive (unless -i?))
9071                  * sources $BASH_ENV here (without scanning $PATH).
9072                  * If called as sh, does the same but with $ENV.
9073                  * Also NB, per POSIX, $ENV should undergo parameter expansion.
9074                  */
9075                 G.global_argc--;
9076                 G.global_argv++;
9077                 debug_printf("running script '%s'\n", G.global_argv[0]);
9078                 xfunc_error_retval = 127; /* for "hush /does/not/exist" case */
9079                 input = xfopen_for_read(G.global_argv[0]);
9080                 xfunc_error_retval = 1;
9081                 remember_FILE(input);
9082                 install_special_sighandlers();
9083                 parse_and_run_file(input);
9084 #if ENABLE_FEATURE_CLEAN_UP
9085                 fclose_and_forget(input);
9086 #endif
9087                 goto final_return;
9088         }
9089
9090         /* Up to here, shell was non-interactive. Now it may become one.
9091          * NB: don't forget to (re)run install_special_sighandlers() as needed.
9092          */
9093
9094         /* A shell is interactive if the '-i' flag was given,
9095          * or if all of the following conditions are met:
9096          *    no -c command
9097          *    no arguments remaining or the -s flag given
9098          *    standard input is a terminal
9099          *    standard output is a terminal
9100          * Refer to Posix.2, the description of the 'sh' utility.
9101          */
9102 #if ENABLE_HUSH_JOB
9103         if (isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)) {
9104                 G_saved_tty_pgrp = tcgetpgrp(STDIN_FILENO);
9105                 debug_printf("saved_tty_pgrp:%d\n", G_saved_tty_pgrp);
9106                 if (G_saved_tty_pgrp < 0)
9107                         G_saved_tty_pgrp = 0;
9108
9109                 /* try to dup stdin to high fd#, >= 255 */
9110                 G_interactive_fd = fcntl_F_DUPFD(STDIN_FILENO, 254);
9111                 if (G_interactive_fd < 0) {
9112                         /* try to dup to any fd */
9113                         G_interactive_fd = dup(STDIN_FILENO);
9114                         if (G_interactive_fd < 0) {
9115                                 /* give up */
9116                                 G_interactive_fd = 0;
9117                                 G_saved_tty_pgrp = 0;
9118                         }
9119                 }
9120 // TODO: track & disallow any attempts of user
9121 // to (inadvertently) close/redirect G_interactive_fd
9122         }
9123         debug_printf("interactive_fd:%d\n", G_interactive_fd);
9124         if (G_interactive_fd) {
9125                 close_on_exec_on(G_interactive_fd);
9126
9127                 if (G_saved_tty_pgrp) {
9128                         /* If we were run as 'hush &', sleep until we are
9129                          * in the foreground (tty pgrp == our pgrp).
9130                          * If we get started under a job aware app (like bash),
9131                          * make sure we are now in charge so we don't fight over
9132                          * who gets the foreground */
9133                         while (1) {
9134                                 pid_t shell_pgrp = getpgrp();
9135                                 G_saved_tty_pgrp = tcgetpgrp(G_interactive_fd);
9136                                 if (G_saved_tty_pgrp == shell_pgrp)
9137                                         break;
9138                                 /* send TTIN to ourself (should stop us) */
9139                                 kill(- shell_pgrp, SIGTTIN);
9140                         }
9141                 }
9142
9143                 /* Install more signal handlers */
9144                 install_special_sighandlers();
9145
9146                 if (G_saved_tty_pgrp) {
9147                         /* Set other signals to restore saved_tty_pgrp */
9148                         install_fatal_sighandlers();
9149                         /* Put ourselves in our own process group
9150                          * (bash, too, does this only if ctty is available) */
9151                         bb_setpgrp(); /* is the same as setpgid(our_pid, our_pid); */
9152                         /* Grab control of the terminal */
9153                         tcsetpgrp(G_interactive_fd, getpid());
9154                 }
9155                 enable_restore_tty_pgrp_on_exit();
9156
9157 # if ENABLE_HUSH_SAVEHISTORY && MAX_HISTORY > 0
9158                 {
9159                         const char *hp = get_local_var_value("HISTFILE");
9160                         if (!hp) {
9161                                 hp = get_local_var_value("HOME");
9162                                 if (hp)
9163                                         hp = concat_path_file(hp, ".hush_history");
9164                         } else {
9165                                 hp = xstrdup(hp);
9166                         }
9167                         if (hp) {
9168                                 G.line_input_state->hist_file = hp;
9169                                 //set_local_var(xasprintf("HISTFILE=%s", ...));
9170                         }
9171 #  if ENABLE_FEATURE_SH_HISTFILESIZE
9172                         hp = get_local_var_value("HISTFILESIZE");
9173                         G.line_input_state->max_history = size_from_HISTFILESIZE(hp);
9174 #  endif
9175                 }
9176 # endif
9177         } else {
9178                 install_special_sighandlers();
9179         }
9180 #elif ENABLE_HUSH_INTERACTIVE
9181         /* No job control compiled in, only prompt/line editing */
9182         if (isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)) {
9183                 G_interactive_fd = fcntl_F_DUPFD(STDIN_FILENO, 254);
9184                 if (G_interactive_fd < 0) {
9185                         /* try to dup to any fd */
9186                         G_interactive_fd = dup(STDIN_FILENO);
9187                         if (G_interactive_fd < 0)
9188                                 /* give up */
9189                                 G_interactive_fd = 0;
9190                 }
9191         }
9192         if (G_interactive_fd) {
9193                 close_on_exec_on(G_interactive_fd);
9194         }
9195         install_special_sighandlers();
9196 #else
9197         /* We have interactiveness code disabled */
9198         install_special_sighandlers();
9199 #endif
9200         /* bash:
9201          * if interactive but not a login shell, sources ~/.bashrc
9202          * (--norc turns this off, --rcfile <file> overrides)
9203          */
9204
9205         if (!ENABLE_FEATURE_SH_EXTRA_QUIET && G_interactive_fd) {
9206                 /* note: ash and hush share this string */
9207                 printf("\n\n%s %s\n"
9208                         IF_HUSH_HELP("Enter 'help' for a list of built-in commands.\n")
9209                         "\n",
9210                         bb_banner,
9211                         "hush - the humble shell"
9212                 );
9213         }
9214
9215         parse_and_run_file(stdin);
9216
9217  final_return:
9218         hush_exit(G.last_exitcode);
9219 }
9220
9221
9222 /*
9223  * Built-ins
9224  */
9225 static int FAST_FUNC builtin_true(char **argv UNUSED_PARAM)
9226 {
9227         return 0;
9228 }
9229
9230 #if ENABLE_HUSH_TEST || ENABLE_HUSH_ECHO || ENABLE_HUSH_PRINTF || ENABLE_HUSH_KILL
9231 static int run_applet_main(char **argv, int (*applet_main_func)(int argc, char **argv))
9232 {
9233         int argc = string_array_len(argv);
9234         return applet_main_func(argc, argv);
9235 }
9236 #endif
9237 #if ENABLE_HUSH_TEST || BASH_TEST2
9238 static int FAST_FUNC builtin_test(char **argv)
9239 {
9240         return run_applet_main(argv, test_main);
9241 }
9242 #endif
9243 #if ENABLE_HUSH_ECHO
9244 static int FAST_FUNC builtin_echo(char **argv)
9245 {
9246         return run_applet_main(argv, echo_main);
9247 }
9248 #endif
9249 #if ENABLE_HUSH_PRINTF
9250 static int FAST_FUNC builtin_printf(char **argv)
9251 {
9252         return run_applet_main(argv, printf_main);
9253 }
9254 #endif
9255
9256 #if ENABLE_HUSH_HELP
9257 static int FAST_FUNC builtin_help(char **argv UNUSED_PARAM)
9258 {
9259         const struct built_in_command *x;
9260
9261         printf(
9262                 "Built-in commands:\n"
9263                 "------------------\n");
9264         for (x = bltins1; x != &bltins1[ARRAY_SIZE(bltins1)]; x++) {
9265                 if (x->b_descr)
9266                         printf("%-10s%s\n", x->b_cmd, x->b_descr);
9267         }
9268         return EXIT_SUCCESS;
9269 }
9270 #endif
9271
9272 #if MAX_HISTORY && ENABLE_FEATURE_EDITING
9273 static int FAST_FUNC builtin_history(char **argv UNUSED_PARAM)
9274 {
9275         show_history(G.line_input_state);
9276         return EXIT_SUCCESS;
9277 }
9278 #endif
9279
9280 static char **skip_dash_dash(char **argv)
9281 {
9282         argv++;
9283         if (argv[0] && argv[0][0] == '-' && argv[0][1] == '-' && argv[0][2] == '\0')
9284                 argv++;
9285         return argv;
9286 }
9287
9288 static int FAST_FUNC builtin_cd(char **argv)
9289 {
9290         const char *newdir;
9291
9292         argv = skip_dash_dash(argv);
9293         newdir = argv[0];
9294         if (newdir == NULL) {
9295                 /* bash does nothing (exitcode 0) if HOME is ""; if it's unset,
9296                  * bash says "bash: cd: HOME not set" and does nothing
9297                  * (exitcode 1)
9298                  */
9299                 const char *home = get_local_var_value("HOME");
9300                 newdir = home ? home : "/";
9301         }
9302         if (chdir(newdir)) {
9303                 /* Mimic bash message exactly */
9304                 bb_perror_msg("cd: %s", newdir);
9305                 return EXIT_FAILURE;
9306         }
9307         /* Read current dir (get_cwd(1) is inside) and set PWD.
9308          * Note: do not enforce exporting. If PWD was unset or unexported,
9309          * set it again, but do not export. bash does the same.
9310          */
9311         set_pwd_var(/*flag:*/ 0);
9312         return EXIT_SUCCESS;
9313 }
9314
9315 static int FAST_FUNC builtin_pwd(char **argv UNUSED_PARAM)
9316 {
9317         puts(get_cwd(0));
9318         return EXIT_SUCCESS;
9319 }
9320
9321 static int FAST_FUNC builtin_eval(char **argv)
9322 {
9323         int rcode = EXIT_SUCCESS;
9324
9325         argv = skip_dash_dash(argv);
9326         if (*argv) {
9327                 char *str = expand_strvec_to_string(argv);
9328                 /* bash:
9329                  * eval "echo Hi; done" ("done" is syntax error):
9330                  * "echo Hi" will not execute too.
9331                  */
9332                 parse_and_run_string(str);
9333                 free(str);
9334                 rcode = G.last_exitcode;
9335         }
9336         return rcode;
9337 }
9338
9339 static int FAST_FUNC builtin_exec(char **argv)
9340 {
9341         argv = skip_dash_dash(argv);
9342         if (argv[0] == NULL)
9343                 return EXIT_SUCCESS; /* bash does this */
9344
9345         /* Careful: we can end up here after [v]fork. Do not restore
9346          * tty pgrp then, only top-level shell process does that */
9347         if (G_saved_tty_pgrp && getpid() == G.root_pid)
9348                 tcsetpgrp(G_interactive_fd, G_saved_tty_pgrp);
9349
9350         /* Saved-redirect fds, script fds and G_interactive_fd are still
9351          * open here. However, they are all CLOEXEC, and execv below
9352          * closes them. Try interactive "exec ls -l /proc/self/fd",
9353          * it should show no extra open fds in the "ls" process.
9354          * If we'd try to run builtins/NOEXECs, this would need improving.
9355          */
9356         //close_saved_fds_and_FILE_fds();
9357
9358         /* TODO: if exec fails, bash does NOT exit! We do.
9359          * We'll need to undo trap cleanup (it's inside execvp_or_die)
9360          * and tcsetpgrp, and this is inherently racy.
9361          */
9362         execvp_or_die(argv);
9363 }
9364
9365 static int FAST_FUNC builtin_exit(char **argv)
9366 {
9367         debug_printf_exec("%s()\n", __func__);
9368
9369         /* interactive bash:
9370          * # trap "echo EEE" EXIT
9371          * # exit
9372          * exit
9373          * There are stopped jobs.
9374          * (if there are _stopped_ jobs, running ones don't count)
9375          * # exit
9376          * exit
9377          * EEE (then bash exits)
9378          *
9379          * TODO: we can use G.exiting = -1 as indicator "last cmd was exit"
9380          */
9381
9382         /* note: EXIT trap is run by hush_exit */
9383         argv = skip_dash_dash(argv);
9384         if (argv[0] == NULL)
9385                 hush_exit(G.last_exitcode);
9386         /* mimic bash: exit 123abc == exit 255 + error msg */
9387         xfunc_error_retval = 255;
9388         /* bash: exit -2 == exit 254, no error msg */
9389         hush_exit(xatoi(argv[0]) & 0xff);
9390 }
9391
9392 #if ENABLE_HUSH_TYPE
9393 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/type.html */
9394 static int FAST_FUNC builtin_type(char **argv)
9395 {
9396         int ret = EXIT_SUCCESS;
9397
9398         while (*++argv) {
9399                 const char *type;
9400                 char *path = NULL;
9401
9402                 if (0) {} /* make conditional compile easier below */
9403                 /*else if (find_alias(*argv))
9404                         type = "an alias";*/
9405 #if ENABLE_HUSH_FUNCTIONS
9406                 else if (find_function(*argv))
9407                         type = "a function";
9408 #endif
9409                 else if (find_builtin(*argv))
9410                         type = "a shell builtin";
9411                 else if ((path = find_in_path(*argv)) != NULL)
9412                         type = path;
9413                 else {
9414                         bb_error_msg("type: %s: not found", *argv);
9415                         ret = EXIT_FAILURE;
9416                         continue;
9417                 }
9418
9419                 printf("%s is %s\n", *argv, type);
9420                 free(path);
9421         }
9422
9423         return ret;
9424 }
9425 #endif
9426
9427 #if ENABLE_HUSH_READ
9428 /* Interruptibility of read builtin in bash
9429  * (tested on bash-4.2.8 by sending signals (not by ^C)):
9430  *
9431  * Empty trap makes read ignore corresponding signal, for any signal.
9432  *
9433  * SIGINT:
9434  * - terminates non-interactive shell;
9435  * - interrupts read in interactive shell;
9436  * if it has non-empty trap:
9437  * - executes trap and returns to command prompt in interactive shell;
9438  * - executes trap and returns to read in non-interactive shell;
9439  * SIGTERM:
9440  * - is ignored (does not interrupt) read in interactive shell;
9441  * - terminates non-interactive shell;
9442  * if it has non-empty trap:
9443  * - executes trap and returns to read;
9444  * SIGHUP:
9445  * - terminates shell (regardless of interactivity);
9446  * if it has non-empty trap:
9447  * - executes trap and returns to read;
9448  * SIGCHLD from children:
9449  * - does not interrupt read regardless of interactivity:
9450  *   try: sleep 1 & read x; echo $x
9451  */
9452 static int FAST_FUNC builtin_read(char **argv)
9453 {
9454         const char *r;
9455         char *opt_n = NULL;
9456         char *opt_p = NULL;
9457         char *opt_t = NULL;
9458         char *opt_u = NULL;
9459         char *opt_d = NULL; /* optimized out if !BASH */
9460         const char *ifs;
9461         int read_flags;
9462
9463         /* "!": do not abort on errors.
9464          * Option string must start with "sr" to match BUILTIN_READ_xxx
9465          */
9466         read_flags = getopt32(argv,
9467 #if BASH_READ_D
9468                 "!srn:p:t:u:d:", &opt_n, &opt_p, &opt_t, &opt_u, &opt_d
9469 #else
9470                 "!srn:p:t:u:", &opt_n, &opt_p, &opt_t, &opt_u
9471 #endif
9472         );
9473         if (read_flags == (uint32_t)-1)
9474                 return EXIT_FAILURE;
9475         argv += optind;
9476         ifs = get_local_var_value("IFS"); /* can be NULL */
9477
9478  again:
9479         r = shell_builtin_read(set_local_var_from_halves,
9480                 argv,
9481                 ifs,
9482                 read_flags,
9483                 opt_n,
9484                 opt_p,
9485                 opt_t,
9486                 opt_u,
9487                 opt_d
9488         );
9489
9490         if ((uintptr_t)r == 1 && errno == EINTR) {
9491                 unsigned sig = check_and_run_traps();
9492                 if (sig != SIGINT)
9493                         goto again;
9494         }
9495
9496         if ((uintptr_t)r > 1) {
9497                 bb_error_msg("%s", r);
9498                 r = (char*)(uintptr_t)1;
9499         }
9500
9501         return (uintptr_t)r;
9502 }
9503 #endif
9504
9505 #if ENABLE_HUSH_UMASK
9506 static int FAST_FUNC builtin_umask(char **argv)
9507 {
9508         int rc;
9509         mode_t mask;
9510
9511         rc = 1;
9512         mask = umask(0);
9513         argv = skip_dash_dash(argv);
9514         if (argv[0]) {
9515                 mode_t old_mask = mask;
9516
9517                 /* numeric umasks are taken as-is */
9518                 /* symbolic umasks are inverted: "umask a=rx" calls umask(222) */
9519                 if (!isdigit(argv[0][0]))
9520                         mask ^= 0777;
9521                 mask = bb_parse_mode(argv[0], mask);
9522                 if (!isdigit(argv[0][0]))
9523                         mask ^= 0777;
9524                 if ((unsigned)mask > 0777) {
9525                         mask = old_mask;
9526                         /* bash messages:
9527                          * bash: umask: 'q': invalid symbolic mode operator
9528                          * bash: umask: 999: octal number out of range
9529                          */
9530                         bb_error_msg("%s: invalid mode '%s'", "umask", argv[0]);
9531                         rc = 0;
9532                 }
9533         } else {
9534                 /* Mimic bash */
9535                 printf("%04o\n", (unsigned) mask);
9536                 /* fall through and restore mask which we set to 0 */
9537         }
9538         umask(mask);
9539
9540         return !rc; /* rc != 0 - success */
9541 }
9542 #endif
9543
9544 #if ENABLE_HUSH_EXPORT || ENABLE_HUSH_TRAP
9545 static void print_escaped(const char *s)
9546 {
9547         if (*s == '\'')
9548                 goto squote;
9549         do {
9550                 const char *p = strchrnul(s, '\'');
9551                 /* print 'xxxx', possibly just '' */
9552                 printf("'%.*s'", (int)(p - s), s);
9553                 if (*p == '\0')
9554                         break;
9555                 s = p;
9556  squote:
9557                 /* s points to '; print "'''...'''" */
9558                 putchar('"');
9559                 do putchar('\''); while (*++s == '\'');
9560                 putchar('"');
9561         } while (*s);
9562 }
9563 #endif
9564
9565 #if ENABLE_HUSH_EXPORT || ENABLE_HUSH_LOCAL || ENABLE_HUSH_READONLY
9566 static int helper_export_local(char **argv, unsigned flags)
9567 {
9568         do {
9569                 char *name = *argv;
9570                 char *name_end = strchrnul(name, '=');
9571
9572                 /* So far we do not check that name is valid (TODO?) */
9573
9574                 if (*name_end == '\0') {
9575                         struct variable *var, **vpp;
9576
9577                         vpp = get_ptr_to_local_var(name, name_end - name);
9578                         var = vpp ? *vpp : NULL;
9579
9580                         if (flags & SETFLAG_UNEXPORT) {
9581                                 /* export -n NAME (without =VALUE) */
9582                                 if (var) {
9583                                         var->flg_export = 0;
9584                                         debug_printf_env("%s: unsetenv '%s'\n", __func__, name);
9585                                         unsetenv(name);
9586                                 } /* else: export -n NOT_EXISTING_VAR: no-op */
9587                                 continue;
9588                         }
9589                         if (flags & SETFLAG_EXPORT) {
9590                                 /* export NAME (without =VALUE) */
9591                                 if (var) {
9592                                         var->flg_export = 1;
9593                                         debug_printf_env("%s: putenv '%s'\n", __func__, var->varstr);
9594                                         putenv(var->varstr);
9595                                         continue;
9596                                 }
9597                         }
9598                         if (flags & SETFLAG_MAKE_RO) {
9599                                 /* readonly NAME (without =VALUE) */
9600                                 if (var) {
9601                                         var->flg_read_only = 1;
9602                                         continue;
9603                                 }
9604                         }
9605 # if ENABLE_HUSH_LOCAL
9606                         /* Is this "local" bltin? */
9607                         if (!(flags & (SETFLAG_EXPORT|SETFLAG_UNEXPORT|SETFLAG_MAKE_RO))) {
9608                                 unsigned lvl = flags >> SETFLAG_LOCAL_SHIFT;
9609                                 if (var && var->func_nest_level == lvl) {
9610                                         /* "local x=abc; ...; local x" - ignore second local decl */
9611                                         continue;
9612                                 }
9613                         }
9614 # endif
9615                         /* Exporting non-existing variable.
9616                          * bash does not put it in environment,
9617                          * but remembers that it is exported,
9618                          * and does put it in env when it is set later.
9619                          * We just set it to "" and export.
9620                          */
9621                         /* Or, it's "local NAME" (without =VALUE).
9622                          * bash sets the value to "".
9623                          */
9624                         /* Or, it's "readonly NAME" (without =VALUE).
9625                          * bash remembers NAME and disallows its creation
9626                          * in the future.
9627                          */
9628                         name = xasprintf("%s=", name);
9629                 } else {
9630                         /* (Un)exporting/making local NAME=VALUE */
9631                         name = xstrdup(name);
9632                 }
9633                 if (set_local_var(name, flags))
9634                         return EXIT_FAILURE;
9635         } while (*++argv);
9636         return EXIT_SUCCESS;
9637 }
9638 #endif
9639
9640 #if ENABLE_HUSH_EXPORT
9641 static int FAST_FUNC builtin_export(char **argv)
9642 {
9643         unsigned opt_unexport;
9644
9645 #if ENABLE_HUSH_EXPORT_N
9646         /* "!": do not abort on errors */
9647         opt_unexport = getopt32(argv, "!n");
9648         if (opt_unexport == (uint32_t)-1)
9649                 return EXIT_FAILURE;
9650         argv += optind;
9651 #else
9652         opt_unexport = 0;
9653         argv++;
9654 #endif
9655
9656         if (argv[0] == NULL) {
9657                 char **e = environ;
9658                 if (e) {
9659                         while (*e) {
9660 #if 0
9661                                 puts(*e++);
9662 #else
9663                                 /* ash emits: export VAR='VAL'
9664                                  * bash: declare -x VAR="VAL"
9665                                  * we follow ash example */
9666                                 const char *s = *e++;
9667                                 const char *p = strchr(s, '=');
9668
9669                                 if (!p) /* wtf? take next variable */
9670                                         continue;
9671                                 /* export var= */
9672                                 printf("export %.*s", (int)(p - s) + 1, s);
9673                                 print_escaped(p + 1);
9674                                 putchar('\n');
9675 #endif
9676                         }
9677                         /*fflush_all(); - done after each builtin anyway */
9678                 }
9679                 return EXIT_SUCCESS;
9680         }
9681
9682         return helper_export_local(argv, opt_unexport ? SETFLAG_UNEXPORT : SETFLAG_EXPORT);
9683 }
9684 #endif
9685
9686 #if ENABLE_HUSH_LOCAL
9687 static int FAST_FUNC builtin_local(char **argv)
9688 {
9689         if (G.func_nest_level == 0) {
9690                 bb_error_msg("%s: not in a function", argv[0]);
9691                 return EXIT_FAILURE; /* bash compat */
9692         }
9693         argv++;
9694         return helper_export_local(argv, G.func_nest_level << SETFLAG_LOCAL_SHIFT);
9695 }
9696 #endif
9697
9698 #if ENABLE_HUSH_READONLY
9699 static int FAST_FUNC builtin_readonly(char **argv)
9700 {
9701         argv++;
9702         if (*argv == NULL) {
9703                 /* bash: readonly [-p]: list all readonly VARs
9704                  * (-p has no effect in bash)
9705                  */
9706                 struct variable *e;
9707                 for (e = G.top_var; e; e = e->next) {
9708                         if (e->flg_read_only) {
9709 //TODO: quote value: readonly VAR='VAL'
9710                                 printf("readonly %s\n", e->varstr);
9711                         }
9712                 }
9713                 return EXIT_SUCCESS;
9714         }
9715         return helper_export_local(argv, SETFLAG_MAKE_RO);
9716 }
9717 #endif
9718
9719 #if ENABLE_HUSH_UNSET
9720 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#unset */
9721 static int FAST_FUNC builtin_unset(char **argv)
9722 {
9723         int ret;
9724         unsigned opts;
9725
9726         /* "!": do not abort on errors */
9727         /* "+": stop at 1st non-option */
9728         opts = getopt32(argv, "!+vf");
9729         if (opts == (unsigned)-1)
9730                 return EXIT_FAILURE;
9731         if (opts == 3) {
9732                 bb_error_msg("unset: -v and -f are exclusive");
9733                 return EXIT_FAILURE;
9734         }
9735         argv += optind;
9736
9737         ret = EXIT_SUCCESS;
9738         while (*argv) {
9739                 if (!(opts & 2)) { /* not -f */
9740                         if (unset_local_var(*argv)) {
9741                                 /* unset <nonexistent_var> doesn't fail.
9742                                  * Error is when one tries to unset RO var.
9743                                  * Message was printed by unset_local_var. */
9744                                 ret = EXIT_FAILURE;
9745                         }
9746                 }
9747 # if ENABLE_HUSH_FUNCTIONS
9748                 else {
9749                         unset_func(*argv);
9750                 }
9751 # endif
9752                 argv++;
9753         }
9754         return ret;
9755 }
9756 #endif
9757
9758 #if ENABLE_HUSH_SET
9759 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#set
9760  * built-in 'set' handler
9761  * SUSv3 says:
9762  * set [-abCefhmnuvx] [-o option] [argument...]
9763  * set [+abCefhmnuvx] [+o option] [argument...]
9764  * set -- [argument...]
9765  * set -o
9766  * set +o
9767  * Implementations shall support the options in both their hyphen and
9768  * plus-sign forms. These options can also be specified as options to sh.
9769  * Examples:
9770  * Write out all variables and their values: set
9771  * Set $1, $2, and $3 and set "$#" to 3: set c a b
9772  * Turn on the -x and -v options: set -xv
9773  * Unset all positional parameters: set --
9774  * Set $1 to the value of x, even if it begins with '-' or '+': set -- "$x"
9775  * Set the positional parameters to the expansion of x, even if x expands
9776  * with a leading '-' or '+': set -- $x
9777  *
9778  * So far, we only support "set -- [argument...]" and some of the short names.
9779  */
9780 static int FAST_FUNC builtin_set(char **argv)
9781 {
9782         int n;
9783         char **pp, **g_argv;
9784         char *arg = *++argv;
9785
9786         if (arg == NULL) {
9787                 struct variable *e;
9788                 for (e = G.top_var; e; e = e->next)
9789                         puts(e->varstr);
9790                 return EXIT_SUCCESS;
9791         }
9792
9793         do {
9794                 if (strcmp(arg, "--") == 0) {
9795                         ++argv;
9796                         goto set_argv;
9797                 }
9798                 if (arg[0] != '+' && arg[0] != '-')
9799                         break;
9800                 for (n = 1; arg[n]; ++n) {
9801                         if (set_mode((arg[0] == '-'), arg[n], argv[1]))
9802                                 goto error;
9803                         if (arg[n] == 'o' && argv[1])
9804                                 argv++;
9805                 }
9806         } while ((arg = *++argv) != NULL);
9807         /* Now argv[0] is 1st argument */
9808
9809         if (arg == NULL)
9810                 return EXIT_SUCCESS;
9811  set_argv:
9812
9813         /* NB: G.global_argv[0] ($0) is never freed/changed */
9814         g_argv = G.global_argv;
9815         if (G.global_args_malloced) {
9816                 pp = g_argv;
9817                 while (*++pp)
9818                         free(*pp);
9819                 g_argv[1] = NULL;
9820         } else {
9821                 G.global_args_malloced = 1;
9822                 pp = xzalloc(sizeof(pp[0]) * 2);
9823                 pp[0] = g_argv[0]; /* retain $0 */
9824                 g_argv = pp;
9825         }
9826         /* This realloc's G.global_argv */
9827         G.global_argv = pp = add_strings_to_strings(g_argv, argv, /*dup:*/ 1);
9828
9829         G.global_argc = 1 + string_array_len(pp + 1);
9830
9831         return EXIT_SUCCESS;
9832
9833         /* Nothing known, so abort */
9834  error:
9835         bb_error_msg("set: %s: invalid option", arg);
9836         return EXIT_FAILURE;
9837 }
9838 #endif
9839
9840 static int FAST_FUNC builtin_shift(char **argv)
9841 {
9842         int n = 1;
9843         argv = skip_dash_dash(argv);
9844         if (argv[0]) {
9845                 n = bb_strtou(argv[0], NULL, 10);
9846                 if (errno || n < 0) {
9847                         /* shared string with ash.c */
9848                         bb_error_msg("Illegal number: %s", argv[0]);
9849                         /*
9850                          * ash aborts in this case.
9851                          * bash prints error message and set $? to 1.
9852                          * Interestingly, for "shift 99999" bash does not
9853                          * print error message, but does set $? to 1
9854                          * (and does no shifting at all).
9855                          */
9856                 }
9857         }
9858         if (n >= 0 && n < G.global_argc) {
9859                 if (G_global_args_malloced) {
9860                         int m = 1;
9861                         while (m <= n)
9862                                 free(G.global_argv[m++]);
9863                 }
9864                 G.global_argc -= n;
9865                 memmove(&G.global_argv[1], &G.global_argv[n+1],
9866                                 G.global_argc * sizeof(G.global_argv[0]));
9867                 return EXIT_SUCCESS;
9868         }
9869         return EXIT_FAILURE;
9870 }
9871
9872 #if ENABLE_HUSH_GETOPTS
9873 static int FAST_FUNC builtin_getopts(char **argv)
9874 {
9875 /* http://pubs.opengroup.org/onlinepubs/9699919799/utilities/getopts.html
9876
9877 TODO:
9878 If an invalid option is seen, getopts places ? into VAR and, if
9879 not silent, prints an error message and unsets OPTARG. If
9880 getopts is silent, the option character found is placed in
9881 OPTARG and no diagnostic message is printed.
9882
9883 If a required argument is not found, and getopts is not silent,
9884 a question mark (?) is placed in VAR, OPTARG is unset, and a
9885 diagnostic message is printed.  If getopts is silent, then a
9886 colon (:) is placed in VAR and OPTARG is set to the option
9887 character found.
9888
9889 Test that VAR is a valid variable name?
9890
9891 "Whenever the shell is invoked, OPTIND shall be initialized to 1"
9892 */
9893         char cbuf[2];
9894         const char *cp, *optstring, *var;
9895         int c, exitcode;
9896
9897         optstring = *++argv;
9898         if (!optstring || !(var = *++argv)) {
9899                 bb_error_msg("usage: getopts OPTSTRING VAR [ARGS]");
9900                 return EXIT_FAILURE;
9901         }
9902
9903         cp = get_local_var_value("OPTERR");
9904         opterr = cp ? atoi(cp) : 1;
9905         cp = get_local_var_value("OPTIND");
9906         optind = cp ? atoi(cp) : 0;
9907         optarg = NULL;
9908
9909         /* getopts stops on first non-option. Add "+" to force that */
9910         /*if (optstring[0] != '+')*/ {
9911                 char *s = alloca(strlen(optstring) + 2);
9912                 sprintf(s, "+%s", optstring);
9913                 optstring = s;
9914         }
9915
9916         if (argv[1])
9917                 argv[0] = G.global_argv[0]; /* for error messages */
9918         else
9919                 argv = G.global_argv;
9920         c = getopt(string_array_len(argv), argv, optstring);
9921         exitcode = EXIT_SUCCESS;
9922         if (c < 0) { /* -1: end of options */
9923                 exitcode = EXIT_FAILURE;
9924                 c = '?';
9925         }
9926         cbuf[0] = c;
9927         cbuf[1] = '\0';
9928         set_local_var_from_halves(var, cbuf);
9929         set_local_var_from_halves("OPTIND", utoa(optind));
9930
9931         /* Always set or unset, never left as-is, even on exit/error:
9932          * "If no option was found, or if the option that was found
9933          * does not have an option-argument, OPTARG shall be unset."
9934          */
9935         if (optarg)
9936                 set_local_var_from_halves("OPTARG", optarg);
9937         else
9938                 unset_local_var("OPTARG");
9939
9940         return exitcode;
9941 }
9942 #endif
9943
9944 static int FAST_FUNC builtin_source(char **argv)
9945 {
9946         char *arg_path, *filename;
9947         FILE *input;
9948         save_arg_t sv;
9949         char *args_need_save;
9950 #if ENABLE_HUSH_FUNCTIONS
9951         smallint sv_flg;
9952 #endif
9953
9954         argv = skip_dash_dash(argv);
9955         filename = argv[0];
9956         if (!filename) {
9957                 /* bash says: "bash: .: filename argument required" */
9958                 return 2; /* bash compat */
9959         }
9960         arg_path = NULL;
9961         if (!strchr(filename, '/')) {
9962                 arg_path = find_in_path(filename);
9963                 if (arg_path)
9964                         filename = arg_path;
9965         }
9966         input = remember_FILE(fopen_or_warn(filename, "r"));
9967         free(arg_path);
9968         if (!input) {
9969                 /* bb_perror_msg("%s", *argv); - done by fopen_or_warn */
9970                 /* POSIX: non-interactive shell should abort here,
9971                  * not merely fail. So far no one complained :)
9972                  */
9973                 return EXIT_FAILURE;
9974         }
9975
9976 #if ENABLE_HUSH_FUNCTIONS
9977         sv_flg = G_flag_return_in_progress;
9978         /* "we are inside sourced file, ok to use return" */
9979         G_flag_return_in_progress = -1;
9980 #endif
9981         args_need_save = argv[1]; /* used as a boolean variable */
9982         if (args_need_save)
9983                 save_and_replace_G_args(&sv, argv);
9984
9985         /* "false; . ./empty_line; echo Zero:$?" should print 0 */
9986         G.last_exitcode = 0;
9987         parse_and_run_file(input);
9988         fclose_and_forget(input);
9989
9990         if (args_need_save) /* can't use argv[1] instead: "shift" can mangle it */
9991                 restore_G_args(&sv, argv);
9992 #if ENABLE_HUSH_FUNCTIONS
9993         G_flag_return_in_progress = sv_flg;
9994 #endif
9995
9996         return G.last_exitcode;
9997 }
9998
9999 #if ENABLE_HUSH_TRAP
10000 static int FAST_FUNC builtin_trap(char **argv)
10001 {
10002         int sig;
10003         char *new_cmd;
10004
10005         if (!G_traps)
10006                 G_traps = xzalloc(sizeof(G_traps[0]) * NSIG);
10007
10008         argv++;
10009         if (!*argv) {
10010                 int i;
10011                 /* No args: print all trapped */
10012                 for (i = 0; i < NSIG; ++i) {
10013                         if (G_traps[i]) {
10014                                 printf("trap -- ");
10015                                 print_escaped(G_traps[i]);
10016                                 /* note: bash adds "SIG", but only if invoked
10017                                  * as "bash". If called as "sh", or if set -o posix,
10018                                  * then it prints short signal names.
10019                                  * We are printing short names: */
10020                                 printf(" %s\n", get_signame(i));
10021                         }
10022                 }
10023                 /*fflush_all(); - done after each builtin anyway */
10024                 return EXIT_SUCCESS;
10025         }
10026
10027         new_cmd = NULL;
10028         /* If first arg is a number: reset all specified signals */
10029         sig = bb_strtou(*argv, NULL, 10);
10030         if (errno == 0) {
10031                 int ret;
10032  process_sig_list:
10033                 ret = EXIT_SUCCESS;
10034                 while (*argv) {
10035                         sighandler_t handler;
10036
10037                         sig = get_signum(*argv++);
10038                         if (sig < 0) {
10039                                 ret = EXIT_FAILURE;
10040                                 /* Mimic bash message exactly */
10041                                 bb_error_msg("trap: %s: invalid signal specification", argv[-1]);
10042                                 continue;
10043                         }
10044
10045                         free(G_traps[sig]);
10046                         G_traps[sig] = xstrdup(new_cmd);
10047
10048                         debug_printf("trap: setting SIG%s (%i) to '%s'\n",
10049                                 get_signame(sig), sig, G_traps[sig]);
10050
10051                         /* There is no signal for 0 (EXIT) */
10052                         if (sig == 0)
10053                                 continue;
10054
10055                         if (new_cmd)
10056                                 handler = (new_cmd[0] ? record_pending_signo : SIG_IGN);
10057                         else
10058                                 /* We are removing trap handler */
10059                                 handler = pick_sighandler(sig);
10060                         install_sighandler(sig, handler);
10061                 }
10062                 return ret;
10063         }
10064
10065         if (!argv[1]) { /* no second arg */
10066                 bb_error_msg("trap: invalid arguments");
10067                 return EXIT_FAILURE;
10068         }
10069
10070         /* First arg is "-": reset all specified to default */
10071         /* First arg is "--": skip it, the rest is "handler SIGs..." */
10072         /* Everything else: set arg as signal handler
10073          * (includes "" case, which ignores signal) */
10074         if (argv[0][0] == '-') {
10075                 if (argv[0][1] == '\0') { /* "-" */
10076                         /* new_cmd remains NULL: "reset these sigs" */
10077                         goto reset_traps;
10078                 }
10079                 if (argv[0][1] == '-' && argv[0][2] == '\0') { /* "--" */
10080                         argv++;
10081                 }
10082                 /* else: "-something", no special meaning */
10083         }
10084         new_cmd = *argv;
10085  reset_traps:
10086         argv++;
10087         goto process_sig_list;
10088 }
10089 #endif
10090
10091 #if ENABLE_HUSH_JOB
10092 static struct pipe *parse_jobspec(const char *str)
10093 {
10094         struct pipe *pi;
10095         unsigned jobnum;
10096
10097         if (sscanf(str, "%%%u", &jobnum) != 1) {
10098                 if (str[0] != '%'
10099                  || (str[1] != '%' && str[1] != '+' && str[1] != '\0')
10100                 ) {
10101                         bb_error_msg("bad argument '%s'", str);
10102                         return NULL;
10103                 }
10104                 /* It is "%%", "%+" or "%" - current job */
10105                 jobnum = G.last_jobid;
10106                 if (jobnum == 0) {
10107                         bb_error_msg("no current job");
10108                         return NULL;
10109                 }
10110         }
10111         for (pi = G.job_list; pi; pi = pi->next) {
10112                 if (pi->jobid == jobnum) {
10113                         return pi;
10114                 }
10115         }
10116         bb_error_msg("%u: no such job", jobnum);
10117         return NULL;
10118 }
10119
10120 static int FAST_FUNC builtin_jobs(char **argv UNUSED_PARAM)
10121 {
10122         struct pipe *job;
10123         const char *status_string;
10124
10125         checkjobs(NULL, 0 /*(no pid to wait for)*/);
10126         for (job = G.job_list; job; job = job->next) {
10127                 if (job->alive_cmds == job->stopped_cmds)
10128                         status_string = "Stopped";
10129                 else
10130                         status_string = "Running";
10131
10132                 printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->cmdtext);
10133         }
10134
10135         clean_up_last_dead_job();
10136
10137         return EXIT_SUCCESS;
10138 }
10139
10140 /* built-in 'fg' and 'bg' handler */
10141 static int FAST_FUNC builtin_fg_bg(char **argv)
10142 {
10143         int i;
10144         struct pipe *pi;
10145
10146         if (!G_interactive_fd)
10147                 return EXIT_FAILURE;
10148
10149         /* If they gave us no args, assume they want the last backgrounded task */
10150         if (!argv[1]) {
10151                 for (pi = G.job_list; pi; pi = pi->next) {
10152                         if (pi->jobid == G.last_jobid) {
10153                                 goto found;
10154                         }
10155                 }
10156                 bb_error_msg("%s: no current job", argv[0]);
10157                 return EXIT_FAILURE;
10158         }
10159
10160         pi = parse_jobspec(argv[1]);
10161         if (!pi)
10162                 return EXIT_FAILURE;
10163  found:
10164         /* TODO: bash prints a string representation
10165          * of job being foregrounded (like "sleep 1 | cat") */
10166         if (argv[0][0] == 'f' && G_saved_tty_pgrp) {
10167                 /* Put the job into the foreground.  */
10168                 tcsetpgrp(G_interactive_fd, pi->pgrp);
10169         }
10170
10171         /* Restart the processes in the job */
10172         debug_printf_jobs("reviving %d procs, pgrp %d\n", pi->num_cmds, pi->pgrp);
10173         for (i = 0; i < pi->num_cmds; i++) {
10174                 debug_printf_jobs("reviving pid %d\n", pi->cmds[i].pid);
10175         }
10176         pi->stopped_cmds = 0;
10177
10178         i = kill(- pi->pgrp, SIGCONT);
10179         if (i < 0) {
10180                 if (errno == ESRCH) {
10181                         delete_finished_job(pi);
10182                         return EXIT_SUCCESS;
10183                 }
10184                 bb_perror_msg("kill (SIGCONT)");
10185         }
10186
10187         if (argv[0][0] == 'f') {
10188                 remove_job_from_table(pi); /* FG job shouldn't be in job table */
10189                 return checkjobs_and_fg_shell(pi);
10190         }
10191         return EXIT_SUCCESS;
10192 }
10193 #endif
10194
10195 #if ENABLE_HUSH_KILL
10196 static int FAST_FUNC builtin_kill(char **argv)
10197 {
10198         int ret = 0;
10199
10200 # if ENABLE_HUSH_JOB
10201         if (argv[1] && strcmp(argv[1], "-l") != 0) {
10202                 int i = 1;
10203
10204                 do {
10205                         struct pipe *pi;
10206                         char *dst;
10207                         int j, n;
10208
10209                         if (argv[i][0] != '%')
10210                                 continue;
10211                         /*
10212                          * "kill %N" - job kill
10213                          * Converting to pgrp / pid kill
10214                          */
10215                         pi = parse_jobspec(argv[i]);
10216                         if (!pi) {
10217                                 /* Eat bad jobspec */
10218                                 j = i;
10219                                 do {
10220                                         j++;
10221                                         argv[j - 1] = argv[j];
10222                                 } while (argv[j]);
10223                                 ret = 1;
10224                                 i--;
10225                                 continue;
10226                         }
10227                         /*
10228                          * In jobs started under job control, we signal
10229                          * entire process group by kill -PGRP_ID.
10230                          * This happens, f.e., in interactive shell.
10231                          *
10232                          * Otherwise, we signal each child via
10233                          * kill PID1 PID2 PID3.
10234                          * Testcases:
10235                          * sh -c 'sleep 1|sleep 1 & kill %1'
10236                          * sh -c 'true|sleep 2 & sleep 1; kill %1'
10237                          * sh -c 'true|sleep 1 & sleep 2; kill %1'
10238                          */
10239                         n = G_interactive_fd ? 1 : pi->num_cmds;
10240                         dst = alloca(n * sizeof(int)*4);
10241                         argv[i] = dst;
10242                         if (G_interactive_fd)
10243                                 dst += sprintf(dst, " -%u", (int)pi->pgrp);
10244                         else for (j = 0; j < n; j++) {
10245                                 struct command *cmd = &pi->cmds[j];
10246                                 /* Skip exited members of the job */
10247                                 if (cmd->pid == 0)
10248                                         continue;
10249                                 /*
10250                                  * kill_main has matching code to expect
10251                                  * leading space. Needed to not confuse
10252                                  * negative pids with "kill -SIGNAL_NO" syntax
10253                                  */
10254                                 dst += sprintf(dst, " %u", (int)cmd->pid);
10255                         }
10256                         *dst = '\0';
10257                 } while (argv[++i]);
10258         }
10259 # endif
10260
10261         if (argv[1] || ret == 0) {
10262                 ret = run_applet_main(argv, kill_main);
10263         }
10264         /* else: ret = 1, "kill %bad_jobspec" case */
10265         return ret;
10266 }
10267 #endif
10268
10269 #if ENABLE_HUSH_WAIT
10270 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/wait.html */
10271 #if !ENABLE_HUSH_JOB
10272 # define wait_for_child_or_signal(pipe,pid) wait_for_child_or_signal(pid)
10273 #endif
10274 static int wait_for_child_or_signal(struct pipe *waitfor_pipe, pid_t waitfor_pid)
10275 {
10276         int ret = 0;
10277         for (;;) {
10278                 int sig;
10279                 sigset_t oldset;
10280
10281                 if (!sigisemptyset(&G.pending_set))
10282                         goto check_sig;
10283
10284                 /* waitpid is not interruptible by SA_RESTARTed
10285                  * signals which we use. Thus, this ugly dance:
10286                  */
10287
10288                 /* Make sure possible SIGCHLD is stored in kernel's
10289                  * pending signal mask before we call waitpid.
10290                  * Or else we may race with SIGCHLD, lose it,
10291                  * and get stuck in sigsuspend...
10292                  */
10293                 sigfillset(&oldset); /* block all signals, remember old set */
10294                 sigprocmask(SIG_SETMASK, &oldset, &oldset);
10295
10296                 if (!sigisemptyset(&G.pending_set)) {
10297                         /* Crap! we raced with some signal! */
10298                         goto restore;
10299                 }
10300
10301                 /*errno = 0; - checkjobs does this */
10302 /* Can't pass waitfor_pipe into checkjobs(): it won't be interruptible */
10303                 ret = checkjobs(NULL, waitfor_pid); /* waitpid(WNOHANG) inside */
10304                 debug_printf_exec("checkjobs:%d\n", ret);
10305 #if ENABLE_HUSH_JOB
10306                 if (waitfor_pipe) {
10307                         int rcode = job_exited_or_stopped(waitfor_pipe);
10308                         debug_printf_exec("job_exited_or_stopped:%d\n", rcode);
10309                         if (rcode >= 0) {
10310                                 ret = rcode;
10311                                 sigprocmask(SIG_SETMASK, &oldset, NULL);
10312                                 break;
10313                         }
10314                 }
10315 #endif
10316                 /* if ECHILD, there are no children (ret is -1 or 0) */
10317                 /* if ret == 0, no children changed state */
10318                 /* if ret != 0, it's exitcode+1 of exited waitfor_pid child */
10319                 if (errno == ECHILD || ret) {
10320                         ret--;
10321                         if (ret < 0) /* if ECHILD, may need to fix "ret" */
10322                                 ret = 0;
10323                         sigprocmask(SIG_SETMASK, &oldset, NULL);
10324                         break;
10325                 }
10326                 /* Wait for SIGCHLD or any other signal */
10327                 /* It is vitally important for sigsuspend that SIGCHLD has non-DFL handler! */
10328                 /* Note: sigsuspend invokes signal handler */
10329                 sigsuspend(&oldset);
10330  restore:
10331                 sigprocmask(SIG_SETMASK, &oldset, NULL);
10332  check_sig:
10333                 /* So, did we get a signal? */
10334                 sig = check_and_run_traps();
10335                 if (sig /*&& sig != SIGCHLD - always true */) {
10336                         /* Do this for any (non-ignored) signal, not only for ^C */
10337                         ret = 128 + sig;
10338                         break;
10339                 }
10340                 /* SIGCHLD, or no signal, or ignored one, such as SIGQUIT. Repeat */
10341         }
10342         return ret;
10343 }
10344
10345 static int FAST_FUNC builtin_wait(char **argv)
10346 {
10347         int ret;
10348         int status;
10349
10350         argv = skip_dash_dash(argv);
10351         if (argv[0] == NULL) {
10352                 /* Don't care about wait results */
10353                 /* Note 1: must wait until there are no more children */
10354                 /* Note 2: must be interruptible */
10355                 /* Examples:
10356                  * $ sleep 3 & sleep 6 & wait
10357                  * [1] 30934 sleep 3
10358                  * [2] 30935 sleep 6
10359                  * [1] Done                   sleep 3
10360                  * [2] Done                   sleep 6
10361                  * $ sleep 3 & sleep 6 & wait
10362                  * [1] 30936 sleep 3
10363                  * [2] 30937 sleep 6
10364                  * [1] Done                   sleep 3
10365                  * ^C <-- after ~4 sec from keyboard
10366                  * $
10367                  */
10368                 return wait_for_child_or_signal(NULL, 0 /*(no job and no pid to wait for)*/);
10369         }
10370
10371         do {
10372                 pid_t pid = bb_strtou(*argv, NULL, 10);
10373                 if (errno || pid <= 0) {
10374 #if ENABLE_HUSH_JOB
10375                         if (argv[0][0] == '%') {
10376                                 struct pipe *wait_pipe;
10377                                 ret = 127; /* bash compat for bad jobspecs */
10378                                 wait_pipe = parse_jobspec(*argv);
10379                                 if (wait_pipe) {
10380                                         ret = job_exited_or_stopped(wait_pipe);
10381                                         if (ret < 0) {
10382                                                 ret = wait_for_child_or_signal(wait_pipe, 0);
10383                                         } else {
10384                                                 /* waiting on "last dead job" removes it */
10385                                                 clean_up_last_dead_job();
10386                                         }
10387                                 }
10388                                 /* else: parse_jobspec() already emitted error msg */
10389                                 continue;
10390                         }
10391 #endif
10392                         /* mimic bash message */
10393                         bb_error_msg("wait: '%s': not a pid or valid job spec", *argv);
10394                         ret = EXIT_FAILURE;
10395                         continue; /* bash checks all argv[] */
10396                 }
10397
10398                 /* Do we have such child? */
10399                 ret = waitpid(pid, &status, WNOHANG);
10400                 if (ret < 0) {
10401                         /* No */
10402                         ret = 127;
10403                         if (errno == ECHILD) {
10404                                 if (pid == G.last_bg_pid) {
10405                                         /* "wait $!" but last bg task has already exited. Try:
10406                                          * (sleep 1; exit 3) & sleep 2; echo $?; wait $!; echo $?
10407                                          * In bash it prints exitcode 0, then 3.
10408                                          * In dash, it is 127.
10409                                          */
10410                                         ret = G.last_bg_pid_exitcode;
10411                                 } else {
10412                                         /* Example: "wait 1". mimic bash message */
10413                                         bb_error_msg("wait: pid %d is not a child of this shell", (int)pid);
10414                                 }
10415                         } else {
10416                                 /* ??? */
10417                                 bb_perror_msg("wait %s", *argv);
10418                         }
10419                         continue; /* bash checks all argv[] */
10420                 }
10421                 if (ret == 0) {
10422                         /* Yes, and it still runs */
10423                         ret = wait_for_child_or_signal(NULL, pid);
10424                 } else {
10425                         /* Yes, and it just exited */
10426                         process_wait_result(NULL, pid, status);
10427                         ret = WEXITSTATUS(status);
10428                         if (WIFSIGNALED(status))
10429                                 ret = 128 + WTERMSIG(status);
10430                 }
10431         } while (*++argv);
10432
10433         return ret;
10434 }
10435 #endif
10436
10437 #if ENABLE_HUSH_LOOPS || ENABLE_HUSH_FUNCTIONS
10438 static unsigned parse_numeric_argv1(char **argv, unsigned def, unsigned def_min)
10439 {
10440         if (argv[1]) {
10441                 def = bb_strtou(argv[1], NULL, 10);
10442                 if (errno || def < def_min || argv[2]) {
10443                         bb_error_msg("%s: bad arguments", argv[0]);
10444                         def = UINT_MAX;
10445                 }
10446         }
10447         return def;
10448 }
10449 #endif
10450
10451 #if ENABLE_HUSH_LOOPS
10452 static int FAST_FUNC builtin_break(char **argv)
10453 {
10454         unsigned depth;
10455         if (G.depth_of_loop == 0) {
10456                 bb_error_msg("%s: only meaningful in a loop", argv[0]);
10457                 /* if we came from builtin_continue(), need to undo "= 1" */
10458                 G.flag_break_continue = 0;
10459                 return EXIT_SUCCESS; /* bash compat */
10460         }
10461         G.flag_break_continue++; /* BC_BREAK = 1, or BC_CONTINUE = 2 */
10462
10463         G.depth_break_continue = depth = parse_numeric_argv1(argv, 1, 1);
10464         if (depth == UINT_MAX)
10465                 G.flag_break_continue = BC_BREAK;
10466         if (G.depth_of_loop < depth)
10467                 G.depth_break_continue = G.depth_of_loop;
10468
10469         return EXIT_SUCCESS;
10470 }
10471
10472 static int FAST_FUNC builtin_continue(char **argv)
10473 {
10474         G.flag_break_continue = 1; /* BC_CONTINUE = 2 = 1+1 */
10475         return builtin_break(argv);
10476 }
10477 #endif
10478
10479 #if ENABLE_HUSH_FUNCTIONS
10480 static int FAST_FUNC builtin_return(char **argv)
10481 {
10482         int rc;
10483
10484         if (G_flag_return_in_progress != -1) {
10485                 bb_error_msg("%s: not in a function or sourced script", argv[0]);
10486                 return EXIT_FAILURE; /* bash compat */
10487         }
10488
10489         G_flag_return_in_progress = 1;
10490
10491         /* bash:
10492          * out of range: wraps around at 256, does not error out
10493          * non-numeric param:
10494          * f() { false; return qwe; }; f; echo $?
10495          * bash: return: qwe: numeric argument required  <== we do this
10496          * 255  <== we also do this
10497          */
10498         rc = parse_numeric_argv1(argv, G.last_exitcode, 0);
10499         return rc;
10500 }
10501 #endif
10502
10503 #if ENABLE_HUSH_TIMES
10504 static int FAST_FUNC builtin_times(char **argv UNUSED_PARAM)
10505 {
10506         static const uint8_t times_tbl[] ALIGN1 = {
10507                 ' ',  offsetof(struct tms, tms_utime),
10508                 '\n', offsetof(struct tms, tms_stime),
10509                 ' ',  offsetof(struct tms, tms_cutime),
10510                 '\n', offsetof(struct tms, tms_cstime),
10511                 0
10512         };
10513         const uint8_t *p;
10514         unsigned clk_tck;
10515         struct tms buf;
10516
10517         clk_tck = bb_clk_tck();
10518
10519         times(&buf);
10520         p = times_tbl;
10521         do {
10522                 unsigned sec, frac;
10523                 unsigned long t;
10524                 t = *(clock_t *)(((char *) &buf) + p[1]);
10525                 sec = t / clk_tck;
10526                 frac = t % clk_tck;
10527                 printf("%um%u.%03us%c",
10528                         sec / 60, sec % 60,
10529                         (frac * 1000) / clk_tck,
10530                         p[0]);
10531                 p += 2;
10532         } while (*p);
10533
10534         return EXIT_SUCCESS;
10535 }
10536 #endif
10537
10538 #if ENABLE_HUSH_MEMLEAK
10539 static int FAST_FUNC builtin_memleak(char **argv UNUSED_PARAM)
10540 {
10541         void *p;
10542         unsigned long l;
10543
10544 # ifdef M_TRIM_THRESHOLD
10545         /* Optional. Reduces probability of false positives */
10546         malloc_trim(0);
10547 # endif
10548         /* Crude attempt to find where "free memory" starts,
10549          * sans fragmentation. */
10550         p = malloc(240);
10551         l = (unsigned long)p;
10552         free(p);
10553         p = malloc(3400);
10554         if (l < (unsigned long)p) l = (unsigned long)p;
10555         free(p);
10556
10557
10558 # if 0  /* debug */
10559         {
10560                 struct mallinfo mi = mallinfo();
10561                 printf("top alloc:0x%lx malloced:%d+%d=%d\n", l,
10562                         mi.arena, mi.hblkhd, mi.arena + mi.hblkhd);
10563         }
10564 # endif
10565
10566         if (!G.memleak_value)
10567                 G.memleak_value = l;
10568
10569         l -= G.memleak_value;
10570         if ((long)l < 0)
10571                 l = 0;
10572         l /= 1024;
10573         if (l > 127)
10574                 l = 127;
10575
10576         /* Exitcode is "how many kilobytes we leaked since 1st call" */
10577         return l;
10578 }
10579 #endif