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         i = 0;
6745         if (sq) for (; sq[i].orig_fd >= 0; i++) {
6746                 /* If we collide with an already moved fd... */
6747                 if (fd == sq[i].moved_to) {
6748                         sq[i].moved_to = fcntl_F_DUPFD(sq[i].moved_to, avoid_fd);
6749                         debug_printf_redir("redirect_fd %d: already busy, moving to %d\n", fd, sq[i].moved_to);
6750                         if (sq[i].moved_to < 0) /* what? */
6751                                 xfunc_die();
6752                         return sq;
6753                 }
6754                 if (fd == sq[i].orig_fd) {
6755                         /* Example: echo Hello >/dev/null 1>&2 */
6756                         debug_printf_redir("redirect_fd %d: already moved\n", fd);
6757                         return sq;
6758                 }
6759         }
6760
6761         /* If this fd is open, we move and remember it; if it's closed, moved_to = -1 */
6762         moved_to = fcntl_F_DUPFD(fd, avoid_fd);
6763         debug_printf_redir("redirect_fd %d: previous fd is moved to %d (-1 if it was closed)\n", fd, moved_to);
6764         if (moved_to < 0 && errno != EBADF)
6765                 xfunc_die();
6766         return append_squirrel(sq, i, fd, moved_to);
6767 }
6768
6769 static struct squirrel *add_squirrel_closed(struct squirrel *sq, int fd)
6770 {
6771         int i;
6772
6773         i = 0;
6774         if (sq) for (; sq[i].orig_fd >= 0; i++) {
6775                 /* If we collide with an already moved fd... */
6776                 if (fd == sq[i].orig_fd) {
6777                         /* Examples:
6778                          * "echo 3>FILE 3>&- 3>FILE"
6779                          * "echo 3>&- 3>FILE"
6780                          * No need for last redirect to insert
6781                          * another "need to close 3" indicator.
6782                          */
6783                         debug_printf_redir("redirect_fd %d: already moved or closed\n", fd);
6784                         return sq;
6785                 }
6786         }
6787
6788         debug_printf_redir("redirect_fd %d: previous fd was closed\n", fd);
6789         return append_squirrel(sq, i, fd, -1);
6790 }
6791
6792 /* fd: redirect wants this fd to be used (e.g. 3>file).
6793  * Move all conflicting internally used fds,
6794  * and remember them so that we can restore them later.
6795  */
6796 static int save_fd_on_redirect(int fd, int avoid_fd, struct squirrel **sqp)
6797 {
6798         if (avoid_fd < 9) /* the important case here is that it can be -1 */
6799                 avoid_fd = 9;
6800
6801 #if ENABLE_HUSH_INTERACTIVE
6802         if (fd == G.interactive_fd) {
6803                 /* Testcase: "ls -l /proc/$$/fd 255>&-" should work */
6804                 G.interactive_fd = xdup_CLOEXEC_and_close(G.interactive_fd, avoid_fd);
6805                 debug_printf_redir("redirect_fd %d: matches interactive_fd, moving it to %d\n", fd, G.interactive_fd);
6806                 return 1; /* "we closed fd" */
6807         }
6808 #endif
6809         /* Are we called from setup_redirects(squirrel==NULL)? Two cases:
6810          * (1) Redirect in a forked child. No need to save FILEs' fds,
6811          * we aren't going to use them anymore, ok to trash.
6812          * (2) "exec 3>FILE". Bummer. We can save script FILEs' fds,
6813          * but how are we doing to restore them?
6814          * "fileno(fd) = new_fd" can't be done.
6815          */
6816         if (!sqp)
6817                 return 0;
6818
6819         /* If this one of script's fds? */
6820         if (save_FILEs_on_redirect(fd, avoid_fd))
6821                 return 1; /* yes. "we closed fd" */
6822
6823         /* Check whether it collides with any open fds (e.g. stdio), save fds as needed */
6824         *sqp = add_squirrel(*sqp, fd, avoid_fd);
6825         return 0; /* "we did not close fd" */
6826 }
6827
6828 static void restore_redirects(struct squirrel *sq)
6829 {
6830         if (sq) {
6831                 int i;
6832                 for (i = 0; sq[i].orig_fd >= 0; i++) {
6833                         if (sq[i].moved_to >= 0) {
6834                                 /* We simply die on error */
6835                                 debug_printf_redir("restoring redirected fd from %d to %d\n", sq[i].moved_to, sq[i].orig_fd);
6836                                 xmove_fd(sq[i].moved_to, sq[i].orig_fd);
6837                         } else {
6838                                 /* cmd1 9>FILE; cmd2_should_see_fd9_closed */
6839                                 debug_printf_redir("restoring redirected fd %d: closing it\n", sq[i].orig_fd);
6840                                 close(sq[i].orig_fd);
6841                         }
6842                 }
6843                 free(sq);
6844         }
6845
6846         /* If moved, G.interactive_fd stays on new fd, not restoring it */
6847
6848         restore_redirected_FILEs();
6849 }
6850
6851 #if ENABLE_FEATURE_SH_STANDALONE && BB_MMU
6852 static void close_saved_fds_and_FILE_fds(void)
6853 {
6854         if (G_interactive_fd)
6855                 close(G_interactive_fd);
6856         close_all_FILE_list();
6857 }
6858 #endif
6859
6860 static int internally_opened_fd(int fd, struct squirrel *sq)
6861 {
6862         int i;
6863
6864 #if ENABLE_HUSH_INTERACTIVE
6865         if (fd == G.interactive_fd)
6866                 return 1;
6867 #endif
6868         /* If this one of script's fds? */
6869         if (fd_in_FILEs(fd))
6870                 return 1;
6871
6872         if (sq) for (i = 0; sq[i].orig_fd >= 0; i++) {
6873                 if (fd == sq[i].moved_to)
6874                         return 1;
6875         }
6876         return 0;
6877 }
6878
6879 /* squirrel != NULL means we squirrel away copies of stdin, stdout,
6880  * and stderr if they are redirected. */
6881 static int setup_redirects(struct command *prog, struct squirrel **sqp)
6882 {
6883         struct redir_struct *redir;
6884
6885         for (redir = prog->redirects; redir; redir = redir->next) {
6886                 int newfd;
6887                 int closed;
6888
6889                 if (redir->rd_type == REDIRECT_HEREDOC2) {
6890                         /* "rd_fd<<HERE" case */
6891                         save_fd_on_redirect(redir->rd_fd, /*avoid:*/ 0, sqp);
6892                         /* for REDIRECT_HEREDOC2, rd_filename holds _contents_
6893                          * of the heredoc */
6894                         debug_printf_parse("set heredoc '%s'\n",
6895                                         redir->rd_filename);
6896                         setup_heredoc(redir);
6897                         continue;
6898                 }
6899
6900                 if (redir->rd_dup == REDIRFD_TO_FILE) {
6901                         /* "rd_fd<*>file" case (<*> is <,>,>>,<>) */
6902                         char *p;
6903                         int mode;
6904
6905                         if (redir->rd_filename == NULL) {
6906                                 /*
6907                                  * Examples:
6908                                  * "cmd >" (no filename)
6909                                  * "cmd > <file" (2nd redirect starts too early)
6910                                  */
6911                                 syntax_error("invalid redirect");
6912                                 continue;
6913                         }
6914                         mode = redir_table[redir->rd_type].mode;
6915                         p = expand_string_to_string(redir->rd_filename, /*unbackslash:*/ 1);
6916                         newfd = open_or_warn(p, mode);
6917                         free(p);
6918                         if (newfd < 0) {
6919                                 /* Error message from open_or_warn can be lost
6920                                  * if stderr has been redirected, but bash
6921                                  * and ash both lose it as well
6922                                  * (though zsh doesn't!)
6923                                  */
6924                                 return 1;
6925                         }
6926                         if (newfd == redir->rd_fd && sqp) {
6927                                 /* open() gave us precisely the fd we wanted.
6928                                  * This means that this fd was not busy
6929                                  * (not opened to anywhere).
6930                                  * Remember to close it on restore:
6931                                  */
6932                                 *sqp = add_squirrel_closed(*sqp, newfd);
6933                                 debug_printf_redir("redir to previously closed fd %d\n", newfd);
6934                         }
6935                 } else {
6936                         /* "rd_fd>&rd_dup" or "rd_fd>&-" case */
6937                         newfd = redir->rd_dup;
6938                 }
6939
6940                 if (newfd == redir->rd_fd)
6941                         continue;
6942
6943                 /* if "N>FILE": move newfd to redir->rd_fd */
6944                 /* if "N>&M": dup newfd to redir->rd_fd */
6945                 /* if "N>&-": close redir->rd_fd (newfd is REDIRFD_CLOSE) */
6946
6947                 closed = save_fd_on_redirect(redir->rd_fd, /*avoid:*/ newfd, sqp);
6948                 if (newfd == REDIRFD_CLOSE) {
6949                         /* "N>&-" means "close me" */
6950                         if (!closed) {
6951                                 /* ^^^ optimization: saving may already
6952                                  * have closed it. If not... */
6953                                 close(redir->rd_fd);
6954                         }
6955                         /* Sometimes we do another close on restore, getting EBADF.
6956                          * Consider "echo 3>FILE 3>&-"
6957                          * first redirect remembers "need to close 3",
6958                          * and second redirect closes 3! Restore code then closes 3 again.
6959                          */
6960                 } else {
6961                         /* if newfd is a script fd or saved fd, simulate EBADF */
6962                         if (internally_opened_fd(newfd, sqp ? *sqp : NULL)) {
6963                                 //errno = EBADF;
6964                                 //bb_perror_msg_and_die("can't duplicate file descriptor");
6965                                 newfd = -1; /* same effect as code above */
6966                         }
6967                         xdup2(newfd, redir->rd_fd);
6968                         if (redir->rd_dup == REDIRFD_TO_FILE)
6969                                 /* "rd_fd > FILE" */
6970                                 close(newfd);
6971                         /* else: "rd_fd > rd_dup" */
6972                 }
6973         }
6974         return 0;
6975 }
6976
6977 static char *find_in_path(const char *arg)
6978 {
6979         char *ret = NULL;
6980         const char *PATH = get_local_var_value("PATH");
6981
6982         if (!PATH)
6983                 return NULL;
6984
6985         while (1) {
6986                 const char *end = strchrnul(PATH, ':');
6987                 int sz = end - PATH; /* must be int! */
6988
6989                 free(ret);
6990                 if (sz != 0) {
6991                         ret = xasprintf("%.*s/%s", sz, PATH, arg);
6992                 } else {
6993                         /* We have xxx::yyyy in $PATH,
6994                          * it means "use current dir" */
6995                         ret = xstrdup(arg);
6996                 }
6997                 if (access(ret, F_OK) == 0)
6998                         break;
6999
7000                 if (*end == '\0') {
7001                         free(ret);
7002                         return NULL;
7003                 }
7004                 PATH = end + 1;
7005         }
7006
7007         return ret;
7008 }
7009
7010 static const struct built_in_command *find_builtin_helper(const char *name,
7011                 const struct built_in_command *x,
7012                 const struct built_in_command *end)
7013 {
7014         while (x != end) {
7015                 if (strcmp(name, x->b_cmd) != 0) {
7016                         x++;
7017                         continue;
7018                 }
7019                 debug_printf_exec("found builtin '%s'\n", name);
7020                 return x;
7021         }
7022         return NULL;
7023 }
7024 static const struct built_in_command *find_builtin1(const char *name)
7025 {
7026         return find_builtin_helper(name, bltins1, &bltins1[ARRAY_SIZE(bltins1)]);
7027 }
7028 static const struct built_in_command *find_builtin(const char *name)
7029 {
7030         const struct built_in_command *x = find_builtin1(name);
7031         if (x)
7032                 return x;
7033         return find_builtin_helper(name, bltins2, &bltins2[ARRAY_SIZE(bltins2)]);
7034 }
7035
7036 #if ENABLE_HUSH_FUNCTIONS
7037 static struct function **find_function_slot(const char *name)
7038 {
7039         struct function **funcpp = &G.top_func;
7040         while (*funcpp) {
7041                 if (strcmp(name, (*funcpp)->name) == 0) {
7042                         break;
7043                 }
7044                 funcpp = &(*funcpp)->next;
7045         }
7046         return funcpp;
7047 }
7048
7049 static const struct function *find_function(const char *name)
7050 {
7051         const struct function *funcp = *find_function_slot(name);
7052         if (funcp)
7053                 debug_printf_exec("found function '%s'\n", name);
7054         return funcp;
7055 }
7056
7057 /* Note: takes ownership on name ptr */
7058 static struct function *new_function(char *name)
7059 {
7060         struct function **funcpp = find_function_slot(name);
7061         struct function *funcp = *funcpp;
7062
7063         if (funcp != NULL) {
7064                 struct command *cmd = funcp->parent_cmd;
7065                 debug_printf_exec("func %p parent_cmd %p\n", funcp, cmd);
7066                 if (!cmd) {
7067                         debug_printf_exec("freeing & replacing function '%s'\n", funcp->name);
7068                         free(funcp->name);
7069                         /* Note: if !funcp->body, do not free body_as_string!
7070                          * This is a special case of "-F name body" function:
7071                          * body_as_string was not malloced! */
7072                         if (funcp->body) {
7073                                 free_pipe_list(funcp->body);
7074 # if !BB_MMU
7075                                 free(funcp->body_as_string);
7076 # endif
7077                         }
7078                 } else {
7079                         debug_printf_exec("reinserting in tree & replacing function '%s'\n", funcp->name);
7080                         cmd->argv[0] = funcp->name;
7081                         cmd->group = funcp->body;
7082 # if !BB_MMU
7083                         cmd->group_as_string = funcp->body_as_string;
7084 # endif
7085                 }
7086         } else {
7087                 debug_printf_exec("remembering new function '%s'\n", name);
7088                 funcp = *funcpp = xzalloc(sizeof(*funcp));
7089                 /*funcp->next = NULL;*/
7090         }
7091
7092         funcp->name = name;
7093         return funcp;
7094 }
7095
7096 # if ENABLE_HUSH_UNSET
7097 static void unset_func(const char *name)
7098 {
7099         struct function **funcpp = find_function_slot(name);
7100         struct function *funcp = *funcpp;
7101
7102         if (funcp != NULL) {
7103                 debug_printf_exec("freeing function '%s'\n", funcp->name);
7104                 *funcpp = funcp->next;
7105                 /* funcp is unlinked now, deleting it.
7106                  * Note: if !funcp->body, the function was created by
7107                  * "-F name body", do not free ->body_as_string
7108                  * and ->name as they were not malloced. */
7109                 if (funcp->body) {
7110                         free_pipe_list(funcp->body);
7111                         free(funcp->name);
7112 #  if !BB_MMU
7113                         free(funcp->body_as_string);
7114 #  endif
7115                 }
7116                 free(funcp);
7117         }
7118 }
7119 # endif
7120
7121 # if BB_MMU
7122 #define exec_function(to_free, funcp, argv) \
7123         exec_function(funcp, argv)
7124 # endif
7125 static void exec_function(char ***to_free,
7126                 const struct function *funcp,
7127                 char **argv) NORETURN;
7128 static void exec_function(char ***to_free,
7129                 const struct function *funcp,
7130                 char **argv)
7131 {
7132 # if BB_MMU
7133         int n;
7134
7135         argv[0] = G.global_argv[0];
7136         G.global_argv = argv;
7137         G.global_argc = n = 1 + string_array_len(argv + 1);
7138
7139 // Example when we are here: "cmd | func"
7140 // func will run with saved-redirect fds open.
7141 // $ f() { echo /proc/self/fd/*; }
7142 // $ true | f
7143 // /proc/self/fd/0 /proc/self/fd/1 /proc/self/fd/2 /proc/self/fd/255 /proc/self/fd/3
7144 // stdio^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ G_interactive_fd^ DIR fd for glob
7145 // Same in script:
7146 // $ . ./SCRIPT
7147 // /proc/self/fd/0 /proc/self/fd/1 /proc/self/fd/2 /proc/self/fd/255 /proc/self/fd/3 /proc/self/fd/4
7148 // stdio^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ G_interactive_fd^ opened ./SCRIPT DIR fd for glob
7149 // They are CLOEXEC so external programs won't see them, but
7150 // for "more correctness" we might want to close those extra fds here:
7151 //?     close_saved_fds_and_FILE_fds();
7152
7153         /* "we are in function, ok to use return" */
7154         G_flag_return_in_progress = -1;
7155         IF_HUSH_LOCAL(G.func_nest_level++;)
7156
7157         /* On MMU, funcp->body is always non-NULL */
7158         n = run_list(funcp->body);
7159         fflush_all();
7160         _exit(n);
7161 # else
7162 //?     close_saved_fds_and_FILE_fds();
7163
7164 //TODO: check whether "true | func_with_return" works
7165
7166         re_execute_shell(to_free,
7167                         funcp->body_as_string,
7168                         G.global_argv[0],
7169                         argv + 1,
7170                         NULL);
7171 # endif
7172 }
7173
7174 static int run_function(const struct function *funcp, char **argv)
7175 {
7176         int rc;
7177         save_arg_t sv;
7178         smallint sv_flg;
7179
7180         save_and_replace_G_args(&sv, argv);
7181
7182         /* "we are in function, ok to use return" */
7183         sv_flg = G_flag_return_in_progress;
7184         G_flag_return_in_progress = -1;
7185         IF_HUSH_LOCAL(G.func_nest_level++;)
7186
7187         /* On MMU, funcp->body is always non-NULL */
7188 # if !BB_MMU
7189         if (!funcp->body) {
7190                 /* Function defined by -F */
7191                 parse_and_run_string(funcp->body_as_string);
7192                 rc = G.last_exitcode;
7193         } else
7194 # endif
7195         {
7196                 rc = run_list(funcp->body);
7197         }
7198
7199 # if ENABLE_HUSH_LOCAL
7200         {
7201                 struct variable *var;
7202                 struct variable **var_pp;
7203
7204                 var_pp = &G.top_var;
7205                 while ((var = *var_pp) != NULL) {
7206                         if (var->func_nest_level < G.func_nest_level) {
7207                                 var_pp = &var->next;
7208                                 continue;
7209                         }
7210                         /* Unexport */
7211                         if (var->flg_export)
7212                                 bb_unsetenv(var->varstr);
7213                         /* Remove from global list */
7214                         *var_pp = var->next;
7215                         /* Free */
7216                         if (!var->max_len)
7217                                 free(var->varstr);
7218                         free(var);
7219                 }
7220                 G.func_nest_level--;
7221         }
7222 # endif
7223         G_flag_return_in_progress = sv_flg;
7224
7225         restore_G_args(&sv, argv);
7226
7227         return rc;
7228 }
7229 #endif /* ENABLE_HUSH_FUNCTIONS */
7230
7231
7232 #if BB_MMU
7233 #define exec_builtin(to_free, x, argv) \
7234         exec_builtin(x, argv)
7235 #else
7236 #define exec_builtin(to_free, x, argv) \
7237         exec_builtin(to_free, argv)
7238 #endif
7239 static void exec_builtin(char ***to_free,
7240                 const struct built_in_command *x,
7241                 char **argv) NORETURN;
7242 static void exec_builtin(char ***to_free,
7243                 const struct built_in_command *x,
7244                 char **argv)
7245 {
7246 #if BB_MMU
7247         int rcode;
7248         fflush_all();
7249 //?     close_saved_fds_and_FILE_fds();
7250         rcode = x->b_function(argv);
7251         fflush_all();
7252         _exit(rcode);
7253 #else
7254         fflush_all();
7255         /* On NOMMU, we must never block!
7256          * Example: { sleep 99 | read line; } & echo Ok
7257          */
7258         re_execute_shell(to_free,
7259                         argv[0],
7260                         G.global_argv[0],
7261                         G.global_argv + 1,
7262                         argv);
7263 #endif
7264 }
7265
7266
7267 static void execvp_or_die(char **argv) NORETURN;
7268 static void execvp_or_die(char **argv)
7269 {
7270         int e;
7271         debug_printf_exec("execing '%s'\n", argv[0]);
7272         /* Don't propagate SIG_IGN to the child */
7273         if (SPECIAL_JOBSTOP_SIGS != 0)
7274                 switch_off_special_sigs(G.special_sig_mask & SPECIAL_JOBSTOP_SIGS);
7275         execvp(argv[0], argv);
7276         e = 2;
7277         if (errno == EACCES) e = 126;
7278         if (errno == ENOENT) e = 127;
7279         bb_perror_msg("can't execute '%s'", argv[0]);
7280         _exit(e);
7281 }
7282
7283 #if ENABLE_HUSH_MODE_X
7284 static void dump_cmd_in_x_mode(char **argv)
7285 {
7286         if (G_x_mode && argv) {
7287                 /* We want to output the line in one write op */
7288                 char *buf, *p;
7289                 int len;
7290                 int n;
7291
7292                 len = 3;
7293                 n = 0;
7294                 while (argv[n])
7295                         len += strlen(argv[n++]) + 1;
7296                 buf = xmalloc(len);
7297                 buf[0] = '+';
7298                 p = buf + 1;
7299                 n = 0;
7300                 while (argv[n])
7301                         p += sprintf(p, " %s", argv[n++]);
7302                 *p++ = '\n';
7303                 *p = '\0';
7304                 fputs(buf, stderr);
7305                 free(buf);
7306         }
7307 }
7308 #else
7309 # define dump_cmd_in_x_mode(argv) ((void)0)
7310 #endif
7311
7312 #if BB_MMU
7313 #define pseudo_exec_argv(nommu_save, argv, assignment_cnt, argv_expanded) \
7314         pseudo_exec_argv(argv, assignment_cnt, argv_expanded)
7315 #define pseudo_exec(nommu_save, command, argv_expanded) \
7316         pseudo_exec(command, argv_expanded)
7317 #endif
7318
7319 /* Called after [v]fork() in run_pipe, or from builtin_exec.
7320  * Never returns.
7321  * Don't exit() here.  If you don't exec, use _exit instead.
7322  * The at_exit handlers apparently confuse the calling process,
7323  * in particular stdin handling. Not sure why? -- because of vfork! (vda)
7324  */
7325 static void pseudo_exec_argv(nommu_save_t *nommu_save,
7326                 char **argv, int assignment_cnt,
7327                 char **argv_expanded) NORETURN;
7328 static NOINLINE void pseudo_exec_argv(nommu_save_t *nommu_save,
7329                 char **argv, int assignment_cnt,
7330                 char **argv_expanded)
7331 {
7332         char **new_env;
7333
7334         new_env = expand_assignments(argv, assignment_cnt);
7335         dump_cmd_in_x_mode(new_env);
7336
7337         if (!argv[assignment_cnt]) {
7338                 /* Case when we are here: ... | var=val | ...
7339                  * (note that we do not exit early, i.e., do not optimize out
7340                  * expand_assignments(): think about ... | var=`sleep 1` | ...
7341                  */
7342                 free_strings(new_env);
7343                 _exit(EXIT_SUCCESS);
7344         }
7345
7346 #if BB_MMU
7347         set_vars_and_save_old(new_env);
7348         free(new_env); /* optional */
7349         /* we can also destroy set_vars_and_save_old's return value,
7350          * to save memory */
7351 #else
7352         nommu_save->new_env = new_env;
7353         nommu_save->old_vars = set_vars_and_save_old(new_env);
7354 #endif
7355
7356         if (argv_expanded) {
7357                 argv = argv_expanded;
7358         } else {
7359                 argv = expand_strvec_to_strvec(argv + assignment_cnt);
7360 #if !BB_MMU
7361                 nommu_save->argv = argv;
7362 #endif
7363         }
7364         dump_cmd_in_x_mode(argv);
7365
7366 #if ENABLE_FEATURE_SH_STANDALONE || BB_MMU
7367         if (strchr(argv[0], '/') != NULL)
7368                 goto skip;
7369 #endif
7370
7371 #if ENABLE_HUSH_FUNCTIONS
7372         /* Check if the command matches any functions (this goes before bltins) */
7373         {
7374                 const struct function *funcp = find_function(argv[0]);
7375                 if (funcp) {
7376                         exec_function(&nommu_save->argv_from_re_execing, funcp, argv);
7377                 }
7378         }
7379 #endif
7380
7381         /* Check if the command matches any of the builtins.
7382          * Depending on context, this might be redundant.  But it's
7383          * easier to waste a few CPU cycles than it is to figure out
7384          * if this is one of those cases.
7385          */
7386         {
7387                 /* On NOMMU, it is more expensive to re-execute shell
7388                  * just in order to run echo or test builtin.
7389                  * It's better to skip it here and run corresponding
7390                  * non-builtin later. */
7391                 const struct built_in_command *x;
7392                 x = BB_MMU ? find_builtin(argv[0]) : find_builtin1(argv[0]);
7393                 if (x) {
7394                         exec_builtin(&nommu_save->argv_from_re_execing, x, argv);
7395                 }
7396         }
7397
7398 #if ENABLE_FEATURE_SH_STANDALONE
7399         /* Check if the command matches any busybox applets */
7400         {
7401                 int a = find_applet_by_name(argv[0]);
7402                 if (a >= 0) {
7403 # if BB_MMU /* see above why on NOMMU it is not allowed */
7404                         if (APPLET_IS_NOEXEC(a)) {
7405                                 /* Do not leak open fds from opened script files etc.
7406                                  * Testcase: interactive "ls -l /proc/self/fd"
7407                                  * should not show tty fd open.
7408                                  */
7409                                 close_saved_fds_and_FILE_fds();
7410 //FIXME: should also close saved redir fds
7411                                 /* Without this, "rm -i FILE" can't be ^C'ed: */
7412                                 switch_off_special_sigs(G.special_sig_mask);
7413                                 debug_printf_exec("running applet '%s'\n", argv[0]);
7414                                 run_noexec_applet_and_exit(a, argv[0], argv);
7415                         }
7416 # endif
7417                         /* Re-exec ourselves */
7418                         debug_printf_exec("re-execing applet '%s'\n", argv[0]);
7419                         /* Don't propagate SIG_IGN to the child */
7420                         if (SPECIAL_JOBSTOP_SIGS != 0)
7421                                 switch_off_special_sigs(G.special_sig_mask & SPECIAL_JOBSTOP_SIGS);
7422                         execv(bb_busybox_exec_path, argv);
7423                         /* If they called chroot or otherwise made the binary no longer
7424                          * executable, fall through */
7425                 }
7426         }
7427 #endif
7428
7429 #if ENABLE_FEATURE_SH_STANDALONE || BB_MMU
7430  skip:
7431 #endif
7432         execvp_or_die(argv);
7433 }
7434
7435 /* Called after [v]fork() in run_pipe
7436  */
7437 static void pseudo_exec(nommu_save_t *nommu_save,
7438                 struct command *command,
7439                 char **argv_expanded) NORETURN;
7440 static void pseudo_exec(nommu_save_t *nommu_save,
7441                 struct command *command,
7442                 char **argv_expanded)
7443 {
7444         if (command->argv) {
7445                 pseudo_exec_argv(nommu_save, command->argv,
7446                                 command->assignment_cnt, argv_expanded);
7447         }
7448
7449         if (command->group) {
7450                 /* Cases when we are here:
7451                  * ( list )
7452                  * { list } &
7453                  * ... | ( list ) | ...
7454                  * ... | { list } | ...
7455                  */
7456 #if BB_MMU
7457                 int rcode;
7458                 debug_printf_exec("pseudo_exec: run_list\n");
7459                 reset_traps_to_defaults();
7460                 rcode = run_list(command->group);
7461                 /* OK to leak memory by not calling free_pipe_list,
7462                  * since this process is about to exit */
7463                 _exit(rcode);
7464 #else
7465                 re_execute_shell(&nommu_save->argv_from_re_execing,
7466                                 command->group_as_string,
7467                                 G.global_argv[0],
7468                                 G.global_argv + 1,
7469                                 NULL);
7470 #endif
7471         }
7472
7473         /* Case when we are here: ... | >file */
7474         debug_printf_exec("pseudo_exec'ed null command\n");
7475         _exit(EXIT_SUCCESS);
7476 }
7477
7478 #if ENABLE_HUSH_JOB
7479 static const char *get_cmdtext(struct pipe *pi)
7480 {
7481         char **argv;
7482         char *p;
7483         int len;
7484
7485         /* This is subtle. ->cmdtext is created only on first backgrounding.
7486          * (Think "cat, <ctrl-z>, fg, <ctrl-z>, fg, <ctrl-z>...." here...)
7487          * On subsequent bg argv is trashed, but we won't use it */
7488         if (pi->cmdtext)
7489                 return pi->cmdtext;
7490
7491         argv = pi->cmds[0].argv;
7492         if (!argv) {
7493                 pi->cmdtext = xzalloc(1);
7494                 return pi->cmdtext;
7495         }
7496         len = 0;
7497         do {
7498                 len += strlen(*argv) + 1;
7499         } while (*++argv);
7500         p = xmalloc(len);
7501         pi->cmdtext = p;
7502         argv = pi->cmds[0].argv;
7503         do {
7504                 p = stpcpy(p, *argv);
7505                 *p++ = ' ';
7506         } while (*++argv);
7507         p[-1] = '\0';
7508         return pi->cmdtext;
7509 }
7510
7511 static void remove_job_from_table(struct pipe *pi)
7512 {
7513         struct pipe *prev_pipe;
7514
7515         if (pi == G.job_list) {
7516                 G.job_list = pi->next;
7517         } else {
7518                 prev_pipe = G.job_list;
7519                 while (prev_pipe->next != pi)
7520                         prev_pipe = prev_pipe->next;
7521                 prev_pipe->next = pi->next;
7522         }
7523         G.last_jobid = 0;
7524         if (G.job_list)
7525                 G.last_jobid = G.job_list->jobid;
7526 }
7527
7528 static void delete_finished_job(struct pipe *pi)
7529 {
7530         remove_job_from_table(pi);
7531         free_pipe(pi);
7532 }
7533
7534 static void clean_up_last_dead_job(void)
7535 {
7536         if (G.job_list && !G.job_list->alive_cmds)
7537                 delete_finished_job(G.job_list);
7538 }
7539
7540 static void insert_job_into_table(struct pipe *pi)
7541 {
7542         struct pipe *job, **jobp;
7543         int i;
7544
7545         clean_up_last_dead_job();
7546
7547         /* Find the end of the list, and find next job ID to use */
7548         i = 0;
7549         jobp = &G.job_list;
7550         while ((job = *jobp) != NULL) {
7551                 if (job->jobid > i)
7552                         i = job->jobid;
7553                 jobp = &job->next;
7554         }
7555         pi->jobid = i + 1;
7556
7557         /* Create a new job struct at the end */
7558         job = *jobp = xmemdup(pi, sizeof(*pi));
7559         job->next = NULL;
7560         job->cmds = xzalloc(sizeof(pi->cmds[0]) * pi->num_cmds);
7561         /* Cannot copy entire pi->cmds[] vector! This causes double frees */
7562         for (i = 0; i < pi->num_cmds; i++) {
7563                 job->cmds[i].pid = pi->cmds[i].pid;
7564                 /* all other fields are not used and stay zero */
7565         }
7566         job->cmdtext = xstrdup(get_cmdtext(pi));
7567
7568         if (G_interactive_fd)
7569                 printf("[%u] %u %s\n", job->jobid, (unsigned)job->cmds[0].pid, job->cmdtext);
7570         G.last_jobid = job->jobid;
7571 }
7572 #endif /* JOB */
7573
7574 static int job_exited_or_stopped(struct pipe *pi)
7575 {
7576         int rcode, i;
7577
7578         if (pi->alive_cmds != pi->stopped_cmds)
7579                 return -1;
7580
7581         /* All processes in fg pipe have exited or stopped */
7582         rcode = 0;
7583         i = pi->num_cmds;
7584         while (--i >= 0) {
7585                 rcode = pi->cmds[i].cmd_exitcode;
7586                 /* usually last process gives overall exitstatus,
7587                  * but with "set -o pipefail", last *failed* process does */
7588                 if (G.o_opt[OPT_O_PIPEFAIL] == 0 || rcode != 0)
7589                         break;
7590         }
7591         IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
7592         return rcode;
7593 }
7594
7595 static int process_wait_result(struct pipe *fg_pipe, pid_t childpid, int status)
7596 {
7597 #if ENABLE_HUSH_JOB
7598         struct pipe *pi;
7599 #endif
7600         int i, dead;
7601
7602         dead = WIFEXITED(status) || WIFSIGNALED(status);
7603
7604 #if DEBUG_JOBS
7605         if (WIFSTOPPED(status))
7606                 debug_printf_jobs("pid %d stopped by sig %d (exitcode %d)\n",
7607                                 childpid, WSTOPSIG(status), WEXITSTATUS(status));
7608         if (WIFSIGNALED(status))
7609                 debug_printf_jobs("pid %d killed by sig %d (exitcode %d)\n",
7610                                 childpid, WTERMSIG(status), WEXITSTATUS(status));
7611         if (WIFEXITED(status))
7612                 debug_printf_jobs("pid %d exited, exitcode %d\n",
7613                                 childpid, WEXITSTATUS(status));
7614 #endif
7615         /* Were we asked to wait for a fg pipe? */
7616         if (fg_pipe) {
7617                 i = fg_pipe->num_cmds;
7618
7619                 while (--i >= 0) {
7620                         int rcode;
7621
7622                         debug_printf_jobs("check pid %d\n", fg_pipe->cmds[i].pid);
7623                         if (fg_pipe->cmds[i].pid != childpid)
7624                                 continue;
7625                         if (dead) {
7626                                 int ex;
7627                                 fg_pipe->cmds[i].pid = 0;
7628                                 fg_pipe->alive_cmds--;
7629                                 ex = WEXITSTATUS(status);
7630                                 /* bash prints killer signal's name for *last*
7631                                  * process in pipe (prints just newline for SIGINT/SIGPIPE).
7632                                  * Mimic this. Example: "sleep 5" + (^\ or kill -QUIT)
7633                                  */
7634                                 if (WIFSIGNALED(status)) {
7635                                         int sig = WTERMSIG(status);
7636                                         if (i == fg_pipe->num_cmds-1)
7637                                                 /* TODO: use strsignal() instead for bash compat? but that's bloat... */
7638                                                 puts(sig == SIGINT || sig == SIGPIPE ? "" : get_signame(sig));
7639                                         /* TODO: if (WCOREDUMP(status)) + " (core dumped)"; */
7640                                         /* TODO: MIPS has 128 sigs (1..128), what if sig==128 here?
7641                                          * Maybe we need to use sig | 128? */
7642                                         ex = sig + 128;
7643                                 }
7644                                 fg_pipe->cmds[i].cmd_exitcode = ex;
7645                         } else {
7646                                 fg_pipe->stopped_cmds++;
7647                         }
7648                         debug_printf_jobs("fg_pipe: alive_cmds %d stopped_cmds %d\n",
7649                                         fg_pipe->alive_cmds, fg_pipe->stopped_cmds);
7650                         rcode = job_exited_or_stopped(fg_pipe);
7651                         if (rcode >= 0) {
7652 /* Note: *non-interactive* bash does not continue if all processes in fg pipe
7653  * are stopped. Testcase: "cat | cat" in a script (not on command line!)
7654  * and "killall -STOP cat" */
7655                                 if (G_interactive_fd) {
7656 #if ENABLE_HUSH_JOB
7657                                         if (fg_pipe->alive_cmds != 0)
7658                                                 insert_job_into_table(fg_pipe);
7659 #endif
7660                                         return rcode;
7661                                 }
7662                                 if (fg_pipe->alive_cmds == 0)
7663                                         return rcode;
7664                         }
7665                         /* There are still running processes in the fg_pipe */
7666                         return -1;
7667                 }
7668                 /* It wasn't in fg_pipe, look for process in bg pipes */
7669         }
7670
7671 #if ENABLE_HUSH_JOB
7672         /* We were asked to wait for bg or orphaned children */
7673         /* No need to remember exitcode in this case */
7674         for (pi = G.job_list; pi; pi = pi->next) {
7675                 for (i = 0; i < pi->num_cmds; i++) {
7676                         if (pi->cmds[i].pid == childpid)
7677                                 goto found_pi_and_prognum;
7678                 }
7679         }
7680         /* Happens when shell is used as init process (init=/bin/sh) */
7681         debug_printf("checkjobs: pid %d was not in our list!\n", childpid);
7682         return -1; /* this wasn't a process from fg_pipe */
7683
7684  found_pi_and_prognum:
7685         if (dead) {
7686                 /* child exited */
7687                 int rcode = WEXITSTATUS(status);
7688                 if (WIFSIGNALED(status))
7689                         rcode = 128 + WTERMSIG(status);
7690                 pi->cmds[i].cmd_exitcode = rcode;
7691                 if (G.last_bg_pid == pi->cmds[i].pid)
7692                         G.last_bg_pid_exitcode = rcode;
7693                 pi->cmds[i].pid = 0;
7694                 pi->alive_cmds--;
7695                 if (!pi->alive_cmds) {
7696                         if (G_interactive_fd) {
7697                                 printf(JOB_STATUS_FORMAT, pi->jobid,
7698                                                 "Done", pi->cmdtext);
7699                                 delete_finished_job(pi);
7700                         } else {
7701 /*
7702  * bash deletes finished jobs from job table only in interactive mode,
7703  * after "jobs" cmd, or if pid of a new process matches one of the old ones
7704  * (see cleanup_dead_jobs(), delete_old_job(), J_NOTIFIED in bash source).
7705  * Testcase script: "(exit 3) & sleep 1; wait %1; echo $?" prints 3 in bash.
7706  * We only retain one "dead" job, if it's the single job on the list.
7707  * This covers most of real-world scenarios where this is useful.
7708  */
7709                                 if (pi != G.job_list)
7710                                         delete_finished_job(pi);
7711                         }
7712                 }
7713         } else {
7714                 /* child stopped */
7715                 pi->stopped_cmds++;
7716         }
7717 #endif
7718         return -1; /* this wasn't a process from fg_pipe */
7719 }
7720
7721 /* Check to see if any processes have exited -- if they have,
7722  * figure out why and see if a job has completed.
7723  *
7724  * If non-NULL fg_pipe: wait for its completion or stop.
7725  * Return its exitcode or zero if stopped.
7726  *
7727  * Alternatively (fg_pipe == NULL, waitfor_pid != 0):
7728  * waitpid(WNOHANG), if waitfor_pid exits or stops, return exitcode+1,
7729  * else return <0 if waitpid errors out (e.g. ECHILD: nothing to wait for)
7730  * or 0 if no children changed status.
7731  *
7732  * Alternatively (fg_pipe == NULL, waitfor_pid == 0),
7733  * return <0 if waitpid errors out (e.g. ECHILD: nothing to wait for)
7734  * or 0 if no children changed status.
7735  */
7736 static int checkjobs(struct pipe *fg_pipe, pid_t waitfor_pid)
7737 {
7738         int attributes;
7739         int status;
7740         int rcode = 0;
7741
7742         debug_printf_jobs("checkjobs %p\n", fg_pipe);
7743
7744         attributes = WUNTRACED;
7745         if (fg_pipe == NULL)
7746                 attributes |= WNOHANG;
7747
7748         errno = 0;
7749 #if ENABLE_HUSH_FAST
7750         if (G.handled_SIGCHLD == G.count_SIGCHLD) {
7751 //bb_error_msg("[%d] checkjobs: G.count_SIGCHLD:%d G.handled_SIGCHLD:%d children?:%d fg_pipe:%p",
7752 //getpid(), G.count_SIGCHLD, G.handled_SIGCHLD, G.we_have_children, fg_pipe);
7753                 /* There was neither fork nor SIGCHLD since last waitpid */
7754                 /* Avoid doing waitpid syscall if possible */
7755                 if (!G.we_have_children) {
7756                         errno = ECHILD;
7757                         return -1;
7758                 }
7759                 if (fg_pipe == NULL) { /* is WNOHANG set? */
7760                         /* We have children, but they did not exit
7761                          * or stop yet (we saw no SIGCHLD) */
7762                         return 0;
7763                 }
7764                 /* else: !WNOHANG, waitpid will block, can't short-circuit */
7765         }
7766 #endif
7767
7768 /* Do we do this right?
7769  * bash-3.00# sleep 20 | false
7770  * <ctrl-Z pressed>
7771  * [3]+  Stopped          sleep 20 | false
7772  * bash-3.00# echo $?
7773  * 1   <========== bg pipe is not fully done, but exitcode is already known!
7774  * [hush 1.14.0: yes we do it right]
7775  */
7776         while (1) {
7777                 pid_t childpid;
7778 #if ENABLE_HUSH_FAST
7779                 int i;
7780                 i = G.count_SIGCHLD;
7781 #endif
7782                 childpid = waitpid(-1, &status, attributes);
7783                 if (childpid <= 0) {
7784                         if (childpid && errno != ECHILD)
7785                                 bb_perror_msg("waitpid");
7786 #if ENABLE_HUSH_FAST
7787                         else { /* Until next SIGCHLD, waitpid's are useless */
7788                                 G.we_have_children = (childpid == 0);
7789                                 G.handled_SIGCHLD = i;
7790 //bb_error_msg("[%d] checkjobs: waitpid returned <= 0, G.count_SIGCHLD:%d G.handled_SIGCHLD:%d", getpid(), G.count_SIGCHLD, G.handled_SIGCHLD);
7791                         }
7792 #endif
7793                         /* ECHILD (no children), or 0 (no change in children status) */
7794                         rcode = childpid;
7795                         break;
7796                 }
7797                 rcode = process_wait_result(fg_pipe, childpid, status);
7798                 if (rcode >= 0) {
7799                         /* fg_pipe exited or stopped */
7800                         break;
7801                 }
7802                 if (childpid == waitfor_pid) {
7803                         debug_printf_exec("childpid==waitfor_pid:%d status:0x%08x\n", childpid, status);
7804                         rcode = WEXITSTATUS(status);
7805                         if (WIFSIGNALED(status))
7806                                 rcode = 128 + WTERMSIG(status);
7807                         if (WIFSTOPPED(status))
7808                                 /* bash: "cmd & wait $!" and cmd stops: $? = 128 + stopsig */
7809                                 rcode = 128 + WSTOPSIG(status);
7810                         rcode++;
7811                         break; /* "wait PID" called us, give it exitcode+1 */
7812                 }
7813                 /* This wasn't one of our processes, or */
7814                 /* fg_pipe still has running processes, do waitpid again */
7815         } /* while (waitpid succeeds)... */
7816
7817         return rcode;
7818 }
7819
7820 #if ENABLE_HUSH_JOB
7821 static int checkjobs_and_fg_shell(struct pipe *fg_pipe)
7822 {
7823         pid_t p;
7824         int rcode = checkjobs(fg_pipe, 0 /*(no pid to wait for)*/);
7825         if (G_saved_tty_pgrp) {
7826                 /* Job finished, move the shell to the foreground */
7827                 p = getpgrp(); /* our process group id */
7828                 debug_printf_jobs("fg'ing ourself: getpgrp()=%d\n", (int)p);
7829                 tcsetpgrp(G_interactive_fd, p);
7830         }
7831         return rcode;
7832 }
7833 #endif
7834
7835 /* Start all the jobs, but don't wait for anything to finish.
7836  * See checkjobs().
7837  *
7838  * Return code is normally -1, when the caller has to wait for children
7839  * to finish to determine the exit status of the pipe.  If the pipe
7840  * is a simple builtin command, however, the action is done by the
7841  * time run_pipe returns, and the exit code is provided as the
7842  * return value.
7843  *
7844  * Returns -1 only if started some children. IOW: we have to
7845  * mask out retvals of builtins etc with 0xff!
7846  *
7847  * The only case when we do not need to [v]fork is when the pipe
7848  * is single, non-backgrounded, non-subshell command. Examples:
7849  * cmd ; ...   { list } ; ...
7850  * cmd && ...  { list } && ...
7851  * cmd || ...  { list } || ...
7852  * If it is, then we can run cmd as a builtin, NOFORK,
7853  * or (if SH_STANDALONE) an applet, and we can run the { list }
7854  * with run_list. If it isn't one of these, we fork and exec cmd.
7855  *
7856  * Cases when we must fork:
7857  * non-single:   cmd | cmd
7858  * backgrounded: cmd &     { list } &
7859  * subshell:     ( list ) [&]
7860  */
7861 #if !ENABLE_HUSH_MODE_X
7862 #define redirect_and_varexp_helper(new_env_p, old_vars_p, command, squirrel, argv_expanded) \
7863         redirect_and_varexp_helper(new_env_p, old_vars_p, command, squirrel)
7864 #endif
7865 static int redirect_and_varexp_helper(char ***new_env_p,
7866                 struct variable **old_vars_p,
7867                 struct command *command,
7868                 struct squirrel **sqp,
7869                 char **argv_expanded)
7870 {
7871         /* setup_redirects acts on file descriptors, not FILEs.
7872          * This is perfect for work that comes after exec().
7873          * Is it really safe for inline use?  Experimentally,
7874          * things seem to work. */
7875         int rcode = setup_redirects(command, sqp);
7876         if (rcode == 0) {
7877                 char **new_env = expand_assignments(command->argv, command->assignment_cnt);
7878                 *new_env_p = new_env;
7879                 dump_cmd_in_x_mode(new_env);
7880                 dump_cmd_in_x_mode(argv_expanded);
7881                 if (old_vars_p)
7882                         *old_vars_p = set_vars_and_save_old(new_env);
7883         }
7884         return rcode;
7885 }
7886 static NOINLINE int run_pipe(struct pipe *pi)
7887 {
7888         static const char *const null_ptr = NULL;
7889
7890         int cmd_no;
7891         int next_infd;
7892         struct command *command;
7893         char **argv_expanded;
7894         char **argv;
7895         struct squirrel *squirrel = NULL;
7896         int rcode;
7897
7898         debug_printf_exec("run_pipe start: members:%d\n", pi->num_cmds);
7899         debug_enter();
7900
7901         /* Testcase: set -- q w e; (IFS='' echo "$*"; IFS=''; echo "$*"); echo "$*"
7902          * Result should be 3 lines: q w e, qwe, q w e
7903          */
7904         G.ifs = get_local_var_value("IFS");
7905         if (!G.ifs)
7906                 G.ifs = defifs;
7907
7908         IF_HUSH_JOB(pi->pgrp = -1;)
7909         pi->stopped_cmds = 0;
7910         command = &pi->cmds[0];
7911         argv_expanded = NULL;
7912
7913         if (pi->num_cmds != 1
7914          || pi->followup == PIPE_BG
7915          || command->cmd_type == CMD_SUBSHELL
7916         ) {
7917                 goto must_fork;
7918         }
7919
7920         pi->alive_cmds = 1;
7921
7922         debug_printf_exec(": group:%p argv:'%s'\n",
7923                 command->group, command->argv ? command->argv[0] : "NONE");
7924
7925         if (command->group) {
7926 #if ENABLE_HUSH_FUNCTIONS
7927                 if (command->cmd_type == CMD_FUNCDEF) {
7928                         /* "executing" func () { list } */
7929                         struct function *funcp;
7930
7931                         funcp = new_function(command->argv[0]);
7932                         /* funcp->name is already set to argv[0] */
7933                         funcp->body = command->group;
7934 # if !BB_MMU
7935                         funcp->body_as_string = command->group_as_string;
7936                         command->group_as_string = NULL;
7937 # endif
7938                         command->group = NULL;
7939                         command->argv[0] = NULL;
7940                         debug_printf_exec("cmd %p has child func at %p\n", command, funcp);
7941                         funcp->parent_cmd = command;
7942                         command->child_func = funcp;
7943
7944                         debug_printf_exec("run_pipe: return EXIT_SUCCESS\n");
7945                         debug_leave();
7946                         return EXIT_SUCCESS;
7947                 }
7948 #endif
7949                 /* { list } */
7950                 debug_printf("non-subshell group\n");
7951                 rcode = 1; /* exitcode if redir failed */
7952                 if (setup_redirects(command, &squirrel) == 0) {
7953                         debug_printf_exec(": run_list\n");
7954                         rcode = run_list(command->group) & 0xff;
7955                 }
7956                 restore_redirects(squirrel);
7957                 IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
7958                 debug_leave();
7959                 debug_printf_exec("run_pipe: return %d\n", rcode);
7960                 return rcode;
7961         }
7962
7963         argv = command->argv ? command->argv : (char **) &null_ptr;
7964         {
7965                 const struct built_in_command *x;
7966 #if ENABLE_HUSH_FUNCTIONS
7967                 const struct function *funcp;
7968 #else
7969                 enum { funcp = 0 };
7970 #endif
7971                 char **new_env = NULL;
7972                 struct variable *old_vars = NULL;
7973
7974                 if (argv[command->assignment_cnt] == NULL) {
7975                         /* Assignments, but no command */
7976                         /* Ensure redirects take effect (that is, create files).
7977                          * Try "a=t >file" */
7978 #if 0 /* A few cases in testsuite fail with this code. FIXME */
7979                         rcode = redirect_and_varexp_helper(&new_env, /*old_vars:*/ NULL, command, &squirrel, /*argv_expanded:*/ NULL);
7980                         /* Set shell variables */
7981                         if (new_env) {
7982                                 argv = new_env;
7983                                 while (*argv) {
7984                                         if (set_local_var(*argv, /*flag:*/ 0)) {
7985                                                 /* assignment to readonly var / putenv error? */
7986                                                 rcode = 1;
7987                                         }
7988                                         argv++;
7989                                 }
7990                         }
7991                         /* Redirect error sets $? to 1. Otherwise,
7992                          * if evaluating assignment value set $?, retain it.
7993                          * Try "false; q=`exit 2`; echo $?" - should print 2: */
7994                         if (rcode == 0)
7995                                 rcode = G.last_exitcode;
7996                         /* Exit, _skipping_ variable restoring code: */
7997                         goto clean_up_and_ret0;
7998
7999 #else /* Older, bigger, but more correct code */
8000
8001                         rcode = setup_redirects(command, &squirrel);
8002                         restore_redirects(squirrel);
8003                         /* Set shell variables */
8004                         if (G_x_mode)
8005                                 bb_putchar_stderr('+');
8006                         while (*argv) {
8007                                 char *p = expand_string_to_string(*argv, /*unbackslash:*/ 1);
8008                                 if (G_x_mode)
8009                                         fprintf(stderr, " %s", p);
8010                                 debug_printf_exec("set shell var:'%s'->'%s'\n",
8011                                                 *argv, p);
8012                                 if (set_local_var(p, /*flag:*/ 0)) {
8013                                         /* assignment to readonly var / putenv error? */
8014                                         rcode = 1;
8015                                 }
8016                                 argv++;
8017                         }
8018                         if (G_x_mode)
8019                                 bb_putchar_stderr('\n');
8020                         /* Redirect error sets $? to 1. Otherwise,
8021                          * if evaluating assignment value set $?, retain it.
8022                          * Try "false; q=`exit 2`; echo $?" - should print 2: */
8023                         if (rcode == 0)
8024                                 rcode = G.last_exitcode;
8025                         IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
8026                         debug_leave();
8027                         debug_printf_exec("run_pipe: return %d\n", rcode);
8028                         return rcode;
8029 #endif
8030                 }
8031
8032                 /* Expand the rest into (possibly) many strings each */
8033 #if BASH_TEST2
8034                 if (command->cmd_type == CMD_SINGLEWORD_NOGLOB) {
8035                         argv_expanded = expand_strvec_to_strvec_singleword_noglob(argv + command->assignment_cnt);
8036                 } else
8037 #endif
8038                 {
8039                         argv_expanded = expand_strvec_to_strvec(argv + command->assignment_cnt);
8040                 }
8041
8042                 /* if someone gives us an empty string: `cmd with empty output` */
8043                 if (!argv_expanded[0]) {
8044                         free(argv_expanded);
8045                         debug_leave();
8046                         return G.last_exitcode;
8047                 }
8048
8049 #if ENABLE_HUSH_FUNCTIONS
8050                 /* Check if argv[0] matches any functions (this goes before bltins) */
8051                 funcp = find_function(argv_expanded[0]);
8052 #endif
8053                 x = NULL;
8054                 if (!funcp)
8055                         x = find_builtin(argv_expanded[0]);
8056                 if (x || funcp) {
8057                         if (!funcp) {
8058                                 if (x->b_function == builtin_exec && argv_expanded[1] == NULL) {
8059                                         debug_printf("exec with redirects only\n");
8060                                         rcode = setup_redirects(command, NULL);
8061                                         /* rcode=1 can be if redir file can't be opened */
8062                                         goto clean_up_and_ret1;
8063                                 }
8064                         }
8065                         rcode = redirect_and_varexp_helper(&new_env, &old_vars, command, &squirrel, argv_expanded);
8066                         if (rcode == 0) {
8067                                 if (!funcp) {
8068                                         debug_printf_exec(": builtin '%s' '%s'...\n",
8069                                                 x->b_cmd, argv_expanded[1]);
8070                                         fflush_all();
8071                                         rcode = x->b_function(argv_expanded) & 0xff;
8072                                         fflush_all();
8073                                 }
8074 #if ENABLE_HUSH_FUNCTIONS
8075                                 else {
8076 # if ENABLE_HUSH_LOCAL
8077                                         struct variable **sv;
8078                                         sv = G.shadowed_vars_pp;
8079                                         G.shadowed_vars_pp = &old_vars;
8080 # endif
8081                                         debug_printf_exec(": function '%s' '%s'...\n",
8082                                                 funcp->name, argv_expanded[1]);
8083                                         rcode = run_function(funcp, argv_expanded) & 0xff;
8084 # if ENABLE_HUSH_LOCAL
8085                                         G.shadowed_vars_pp = sv;
8086 # endif
8087                                 }
8088 #endif
8089                         }
8090  clean_up_and_ret:
8091                         unset_vars(new_env);
8092                         add_vars(old_vars);
8093 /* clean_up_and_ret0: */
8094                         restore_redirects(squirrel);
8095                         /*
8096                          * Try "usleep 99999999" + ^C + "echo $?"
8097                          * with FEATURE_SH_NOFORK=y.
8098                          */
8099                         if (!funcp) {
8100                                 /* It was builtin or nofork.
8101                                  * if this would be a real fork/execed program,
8102                                  * it should have died if a fatal sig was received.
8103                                  * But OTOH, there was no separate process,
8104                                  * the sig was sent to _shell_, not to non-existing
8105                                  * child.
8106                                  * Let's just handle ^C only, this one is obvious:
8107                                  * we aren't ok with exitcode 0 when ^C was pressed
8108                                  * during builtin/nofork.
8109                                  */
8110                                 if (sigismember(&G.pending_set, SIGINT))
8111                                         rcode = 128 + SIGINT;
8112                         }
8113  clean_up_and_ret1:
8114                         free(argv_expanded);
8115                         IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
8116                         debug_leave();
8117                         debug_printf_exec("run_pipe return %d\n", rcode);
8118                         return rcode;
8119                 }
8120
8121                 if (ENABLE_FEATURE_SH_NOFORK) {
8122                         int n = find_applet_by_name(argv_expanded[0]);
8123                         if (n >= 0 && APPLET_IS_NOFORK(n)) {
8124                                 rcode = redirect_and_varexp_helper(&new_env, &old_vars, command, &squirrel, argv_expanded);
8125                                 if (rcode == 0) {
8126                                         debug_printf_exec(": run_nofork_applet '%s' '%s'...\n",
8127                                                 argv_expanded[0], argv_expanded[1]);
8128                                         /*
8129                                          * Note: signals (^C) can't interrupt here.
8130                                          * We remember them and they will be acted upon
8131                                          * after applet returns.
8132                                          * This makes applets which can run for a long time
8133                                          * and/or wait for user input ineligible for NOFORK:
8134                                          * for example, "yes" or "rm" (rm -i waits for input).
8135                                          */
8136                                         rcode = run_nofork_applet(n, argv_expanded);
8137                                 }
8138                                 goto clean_up_and_ret;
8139                         }
8140                 }
8141                 /* It is neither builtin nor applet. We must fork. */
8142         }
8143
8144  must_fork:
8145         /* NB: argv_expanded may already be created, and that
8146          * might include `cmd` runs! Do not rerun it! We *must*
8147          * use argv_expanded if it's non-NULL */
8148
8149         /* Going to fork a child per each pipe member */
8150         pi->alive_cmds = 0;
8151         next_infd = 0;
8152
8153         cmd_no = 0;
8154         while (cmd_no < pi->num_cmds) {
8155                 struct fd_pair pipefds;
8156 #if !BB_MMU
8157                 volatile nommu_save_t nommu_save;
8158                 nommu_save.new_env = NULL;
8159                 nommu_save.old_vars = NULL;
8160                 nommu_save.argv = NULL;
8161                 nommu_save.argv_from_re_execing = NULL;
8162 #endif
8163                 command = &pi->cmds[cmd_no];
8164                 cmd_no++;
8165                 if (command->argv) {
8166                         debug_printf_exec(": pipe member '%s' '%s'...\n",
8167                                         command->argv[0], command->argv[1]);
8168                 } else {
8169                         debug_printf_exec(": pipe member with no argv\n");
8170                 }
8171
8172                 /* pipes are inserted between pairs of commands */
8173                 pipefds.rd = 0;
8174                 pipefds.wr = 1;
8175                 if (cmd_no < pi->num_cmds)
8176                         xpiped_pair(pipefds);
8177
8178                 command->pid = BB_MMU ? fork() : vfork();
8179                 if (!command->pid) { /* child */
8180 #if ENABLE_HUSH_JOB
8181                         disable_restore_tty_pgrp_on_exit();
8182                         CLEAR_RANDOM_T(&G.random_gen); /* or else $RANDOM repeats in child */
8183
8184                         /* Every child adds itself to new process group
8185                          * with pgid == pid_of_first_child_in_pipe */
8186                         if (G.run_list_level == 1 && G_interactive_fd) {
8187                                 pid_t pgrp;
8188                                 pgrp = pi->pgrp;
8189                                 if (pgrp < 0) /* true for 1st process only */
8190                                         pgrp = getpid();
8191                                 if (setpgid(0, pgrp) == 0
8192                                  && pi->followup != PIPE_BG
8193                                  && G_saved_tty_pgrp /* we have ctty */
8194                                 ) {
8195                                         /* We do it in *every* child, not just first,
8196                                          * to avoid races */
8197                                         tcsetpgrp(G_interactive_fd, pgrp);
8198                                 }
8199                         }
8200 #endif
8201                         if (pi->alive_cmds == 0 && pi->followup == PIPE_BG) {
8202                                 /* 1st cmd in backgrounded pipe
8203                                  * should have its stdin /dev/null'ed */
8204                                 close(0);
8205                                 if (open(bb_dev_null, O_RDONLY))
8206                                         xopen("/", O_RDONLY);
8207                         } else {
8208                                 xmove_fd(next_infd, 0);
8209                         }
8210                         xmove_fd(pipefds.wr, 1);
8211                         if (pipefds.rd > 1)
8212                                 close(pipefds.rd);
8213                         /* Like bash, explicit redirects override pipes,
8214                          * and the pipe fd (fd#1) is available for dup'ing:
8215                          * "cmd1 2>&1 | cmd2": fd#1 is duped to fd#2, thus stderr
8216                          * of cmd1 goes into pipe.
8217                          */
8218                         if (setup_redirects(command, NULL)) {
8219                                 /* Happens when redir file can't be opened:
8220                                  * $ hush -c 'echo FOO >&2 | echo BAR 3>/qwe/rty; echo BAZ'
8221                                  * FOO
8222                                  * hush: can't open '/qwe/rty': No such file or directory
8223                                  * BAZ
8224                                  * (echo BAR is not executed, it hits _exit(1) below)
8225                                  */
8226                                 _exit(1);
8227                         }
8228
8229                         /* Stores to nommu_save list of env vars putenv'ed
8230                          * (NOMMU, on MMU we don't need that) */
8231                         /* cast away volatility... */
8232                         pseudo_exec((nommu_save_t*) &nommu_save, command, argv_expanded);
8233                         /* pseudo_exec() does not return */
8234                 }
8235
8236                 /* parent or error */
8237 #if ENABLE_HUSH_FAST
8238                 G.count_SIGCHLD++;
8239 //bb_error_msg("[%d] fork in run_pipe: G.count_SIGCHLD:%d G.handled_SIGCHLD:%d", getpid(), G.count_SIGCHLD, G.handled_SIGCHLD);
8240 #endif
8241                 enable_restore_tty_pgrp_on_exit();
8242 #if !BB_MMU
8243                 /* Clean up after vforked child */
8244                 free(nommu_save.argv);
8245                 free(nommu_save.argv_from_re_execing);
8246                 unset_vars(nommu_save.new_env);
8247                 add_vars(nommu_save.old_vars);
8248 #endif
8249                 free(argv_expanded);
8250                 argv_expanded = NULL;
8251                 if (command->pid < 0) { /* [v]fork failed */
8252                         /* Clearly indicate, was it fork or vfork */
8253                         bb_perror_msg(BB_MMU ? "vfork"+1 : "vfork");
8254                 } else {
8255                         pi->alive_cmds++;
8256 #if ENABLE_HUSH_JOB
8257                         /* Second and next children need to know pid of first one */
8258                         if (pi->pgrp < 0)
8259                                 pi->pgrp = command->pid;
8260 #endif
8261                 }
8262
8263                 if (cmd_no > 1)
8264                         close(next_infd);
8265                 if (cmd_no < pi->num_cmds)
8266                         close(pipefds.wr);
8267                 /* Pass read (output) pipe end to next iteration */
8268                 next_infd = pipefds.rd;
8269         }
8270
8271         if (!pi->alive_cmds) {
8272                 debug_leave();
8273                 debug_printf_exec("run_pipe return 1 (all forks failed, no children)\n");
8274                 return 1;
8275         }
8276
8277         debug_leave();
8278         debug_printf_exec("run_pipe return -1 (%u children started)\n", pi->alive_cmds);
8279         return -1;
8280 }
8281
8282 /* NB: called by pseudo_exec, and therefore must not modify any
8283  * global data until exec/_exit (we can be a child after vfork!) */
8284 static int run_list(struct pipe *pi)
8285 {
8286 #if ENABLE_HUSH_CASE
8287         char *case_word = NULL;
8288 #endif
8289 #if ENABLE_HUSH_LOOPS
8290         struct pipe *loop_top = NULL;
8291         char **for_lcur = NULL;
8292         char **for_list = NULL;
8293 #endif
8294         smallint last_followup;
8295         smalluint rcode;
8296 #if ENABLE_HUSH_IF || ENABLE_HUSH_CASE
8297         smalluint cond_code = 0;
8298 #else
8299         enum { cond_code = 0 };
8300 #endif
8301 #if HAS_KEYWORDS
8302         smallint rword;      /* RES_foo */
8303         smallint last_rword; /* ditto */
8304 #endif
8305
8306         debug_printf_exec("run_list start lvl %d\n", G.run_list_level);
8307         debug_enter();
8308
8309 #if ENABLE_HUSH_LOOPS
8310         /* Check syntax for "for" */
8311         {
8312                 struct pipe *cpipe;
8313                 for (cpipe = pi; cpipe; cpipe = cpipe->next) {
8314                         if (cpipe->res_word != RES_FOR && cpipe->res_word != RES_IN)
8315                                 continue;
8316                         /* current word is FOR or IN (BOLD in comments below) */
8317                         if (cpipe->next == NULL) {
8318                                 syntax_error("malformed for");
8319                                 debug_leave();
8320                                 debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
8321                                 return 1;
8322                         }
8323                         /* "FOR v; do ..." and "for v IN a b; do..." are ok */
8324                         if (cpipe->next->res_word == RES_DO)
8325                                 continue;
8326                         /* next word is not "do". It must be "in" then ("FOR v in ...") */
8327                         if (cpipe->res_word == RES_IN /* "for v IN a b; not_do..."? */
8328                          || cpipe->next->res_word != RES_IN /* FOR v not_do_and_not_in..."? */
8329                         ) {
8330                                 syntax_error("malformed for");
8331                                 debug_leave();
8332                                 debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
8333                                 return 1;
8334                         }
8335                 }
8336         }
8337 #endif
8338
8339         /* Past this point, all code paths should jump to ret: label
8340          * in order to return, no direct "return" statements please.
8341          * This helps to ensure that no memory is leaked. */
8342
8343 #if ENABLE_HUSH_JOB
8344         G.run_list_level++;
8345 #endif
8346
8347 #if HAS_KEYWORDS
8348         rword = RES_NONE;
8349         last_rword = RES_XXXX;
8350 #endif
8351         last_followup = PIPE_SEQ;
8352         rcode = G.last_exitcode;
8353
8354         /* Go through list of pipes, (maybe) executing them. */
8355         for (; pi; pi = IF_HUSH_LOOPS(rword == RES_DONE ? loop_top : ) pi->next) {
8356                 int r;
8357                 int sv_errexit_depth;
8358
8359                 if (G.flag_SIGINT)
8360                         break;
8361                 if (G_flag_return_in_progress == 1)
8362                         break;
8363
8364                 IF_HAS_KEYWORDS(rword = pi->res_word;)
8365                 debug_printf_exec(": rword=%d cond_code=%d last_rword=%d\n",
8366                                 rword, cond_code, last_rword);
8367
8368                 sv_errexit_depth = G.errexit_depth;
8369                 if (IF_HAS_KEYWORDS(rword == RES_IF || rword == RES_ELIF ||)
8370                     pi->followup != PIPE_SEQ
8371                 ) {
8372                         G.errexit_depth++;
8373                 }
8374 #if ENABLE_HUSH_LOOPS
8375                 if ((rword == RES_WHILE || rword == RES_UNTIL || rword == RES_FOR)
8376                  && loop_top == NULL /* avoid bumping G.depth_of_loop twice */
8377                 ) {
8378                         /* start of a loop: remember where loop starts */
8379                         loop_top = pi;
8380                         G.depth_of_loop++;
8381                 }
8382 #endif
8383                 /* Still in the same "if...", "then..." or "do..." branch? */
8384                 if (IF_HAS_KEYWORDS(rword == last_rword &&) 1) {
8385                         if ((rcode == 0 && last_followup == PIPE_OR)
8386                          || (rcode != 0 && last_followup == PIPE_AND)
8387                         ) {
8388                                 /* It is "<true> || CMD" or "<false> && CMD"
8389                                  * and we should not execute CMD */
8390                                 debug_printf_exec("skipped cmd because of || or &&\n");
8391                                 last_followup = pi->followup;
8392                                 goto dont_check_jobs_but_continue;
8393                         }
8394                 }
8395                 last_followup = pi->followup;
8396                 IF_HAS_KEYWORDS(last_rword = rword;)
8397 #if ENABLE_HUSH_IF
8398                 if (cond_code) {
8399                         if (rword == RES_THEN) {
8400                                 /* if false; then ... fi has exitcode 0! */
8401                                 G.last_exitcode = rcode = EXIT_SUCCESS;
8402                                 /* "if <false> THEN cmd": skip cmd */
8403                                 continue;
8404                         }
8405                 } else {
8406                         if (rword == RES_ELSE || rword == RES_ELIF) {
8407                                 /* "if <true> then ... ELSE/ELIF cmd":
8408                                  * skip cmd and all following ones */
8409                                 break;
8410                         }
8411                 }
8412 #endif
8413 #if ENABLE_HUSH_LOOPS
8414                 if (rword == RES_FOR) { /* && pi->num_cmds - always == 1 */
8415                         if (!for_lcur) {
8416                                 /* first loop through for */
8417
8418                                 static const char encoded_dollar_at[] ALIGN1 = {
8419                                         SPECIAL_VAR_SYMBOL, '@' | 0x80, SPECIAL_VAR_SYMBOL, '\0'
8420                                 }; /* encoded representation of "$@" */
8421                                 static const char *const encoded_dollar_at_argv[] = {
8422                                         encoded_dollar_at, NULL
8423                                 }; /* argv list with one element: "$@" */
8424                                 char **vals;
8425
8426                                 vals = (char**)encoded_dollar_at_argv;
8427                                 if (pi->next->res_word == RES_IN) {
8428                                         /* if no variable values after "in" we skip "for" */
8429                                         if (!pi->next->cmds[0].argv) {
8430                                                 G.last_exitcode = rcode = EXIT_SUCCESS;
8431                                                 debug_printf_exec(": null FOR: exitcode EXIT_SUCCESS\n");
8432                                                 break;
8433                                         }
8434                                         vals = pi->next->cmds[0].argv;
8435                                 } /* else: "for var; do..." -> assume "$@" list */
8436                                 /* create list of variable values */
8437                                 debug_print_strings("for_list made from", vals);
8438                                 for_list = expand_strvec_to_strvec(vals);
8439                                 for_lcur = for_list;
8440                                 debug_print_strings("for_list", for_list);
8441                         }
8442                         if (!*for_lcur) {
8443                                 /* "for" loop is over, clean up */
8444                                 free(for_list);
8445                                 for_list = NULL;
8446                                 for_lcur = NULL;
8447                                 break;
8448                         }
8449                         /* Insert next value from for_lcur */
8450                         /* note: *for_lcur already has quotes removed, $var expanded, etc */
8451                         set_local_var(xasprintf("%s=%s", pi->cmds[0].argv[0], *for_lcur++), /*flag:*/ 0);
8452                         continue;
8453                 }
8454                 if (rword == RES_IN) {
8455                         continue; /* "for v IN list;..." - "in" has no cmds anyway */
8456                 }
8457                 if (rword == RES_DONE) {
8458                         continue; /* "done" has no cmds too */
8459                 }
8460 #endif
8461 #if ENABLE_HUSH_CASE
8462                 if (rword == RES_CASE) {
8463                         debug_printf_exec("CASE cond_code:%d\n", cond_code);
8464                         case_word = expand_strvec_to_string(pi->cmds->argv);
8465                         unbackslash(case_word);
8466                         continue;
8467                 }
8468                 if (rword == RES_MATCH) {
8469                         char **argv;
8470
8471                         debug_printf_exec("MATCH cond_code:%d\n", cond_code);
8472                         if (!case_word) /* "case ... matched_word) ... WORD)": we executed selected branch, stop */
8473                                 break;
8474                         /* all prev words didn't match, does this one match? */
8475                         argv = pi->cmds->argv;
8476                         while (*argv) {
8477                                 char *pattern = expand_string_to_string(*argv, /*unbackslash:*/ 0);
8478                                 /* TODO: which FNM_xxx flags to use? */
8479                                 cond_code = (fnmatch(pattern, case_word, /*flags:*/ 0) != 0);
8480                                 debug_printf_exec("fnmatch(pattern:'%s',str:'%s'):%d\n", pattern, case_word, cond_code);
8481                                 free(pattern);
8482                                 if (cond_code == 0) { /* match! we will execute this branch */
8483                                         free(case_word);
8484                                         case_word = NULL; /* make future "word)" stop */
8485                                         break;
8486                                 }
8487                                 argv++;
8488                         }
8489                         continue;
8490                 }
8491                 if (rword == RES_CASE_BODY) { /* inside of a case branch */
8492                         debug_printf_exec("CASE_BODY cond_code:%d\n", cond_code);
8493                         if (cond_code != 0)
8494                                 continue; /* not matched yet, skip this pipe */
8495                 }
8496                 if (rword == RES_ESAC) {
8497                         debug_printf_exec("ESAC cond_code:%d\n", cond_code);
8498                         if (case_word) {
8499                                 /* "case" did not match anything: still set $? (to 0) */
8500                                 G.last_exitcode = rcode = EXIT_SUCCESS;
8501                         }
8502                 }
8503 #endif
8504                 /* Just pressing <enter> in shell should check for jobs.
8505                  * OTOH, in non-interactive shell this is useless
8506                  * and only leads to extra job checks */
8507                 if (pi->num_cmds == 0) {
8508                         if (G_interactive_fd)
8509                                 goto check_jobs_and_continue;
8510                         continue;
8511                 }
8512
8513                 /* After analyzing all keywords and conditions, we decided
8514                  * to execute this pipe. NB: have to do checkjobs(NULL)
8515                  * after run_pipe to collect any background children,
8516                  * even if list execution is to be stopped. */
8517                 debug_printf_exec(": run_pipe with %d members\n", pi->num_cmds);
8518 #if ENABLE_HUSH_LOOPS
8519                 G.flag_break_continue = 0;
8520 #endif
8521                 rcode = r = run_pipe(pi); /* NB: rcode is a smalluint, r is int */
8522                 if (r != -1) {
8523                         /* We ran a builtin, function, or group.
8524                          * rcode is already known
8525                          * and we don't need to wait for anything. */
8526                         debug_printf_exec(": builtin/func exitcode %d\n", rcode);
8527                         G.last_exitcode = rcode;
8528                         check_and_run_traps();
8529 #if ENABLE_HUSH_LOOPS
8530                         /* Was it "break" or "continue"? */
8531                         if (G.flag_break_continue) {
8532                                 smallint fbc = G.flag_break_continue;
8533                                 /* We might fall into outer *loop*,
8534                                  * don't want to break it too */
8535                                 if (loop_top) {
8536                                         G.depth_break_continue--;
8537                                         if (G.depth_break_continue == 0)
8538                                                 G.flag_break_continue = 0;
8539                                         /* else: e.g. "continue 2" should *break* once, *then* continue */
8540                                 } /* else: "while... do... { we are here (innermost list is not a loop!) };...done" */
8541                                 if (G.depth_break_continue != 0 || fbc == BC_BREAK) {
8542                                         checkjobs(NULL, 0 /*(no pid to wait for)*/);
8543                                         break;
8544                                 }
8545                                 /* "continue": simulate end of loop */
8546                                 rword = RES_DONE;
8547                                 continue;
8548                         }
8549 #endif
8550                         if (G_flag_return_in_progress == 1) {
8551                                 checkjobs(NULL, 0 /*(no pid to wait for)*/);
8552                                 break;
8553                         }
8554                 } else if (pi->followup == PIPE_BG) {
8555                         /* What does bash do with attempts to background builtins? */
8556                         /* even bash 3.2 doesn't do that well with nested bg:
8557                          * try "{ { sleep 10; echo DEEP; } & echo HERE; } &".
8558                          * I'm NOT treating inner &'s as jobs */
8559 #if ENABLE_HUSH_JOB
8560                         if (G.run_list_level == 1)
8561                                 insert_job_into_table(pi);
8562 #endif
8563                         /* Last command's pid goes to $! */
8564                         G.last_bg_pid = pi->cmds[pi->num_cmds - 1].pid;
8565                         G.last_bg_pid_exitcode = 0;
8566                         debug_printf_exec(": cmd&: exitcode EXIT_SUCCESS\n");
8567 /* Check pi->pi_inverted? "! sleep 1 & echo $?": bash says 1. dash and ash say 0 */
8568                         rcode = EXIT_SUCCESS;
8569                         goto check_traps;
8570                 } else {
8571 #if ENABLE_HUSH_JOB
8572                         if (G.run_list_level == 1 && G_interactive_fd) {
8573                                 /* Waits for completion, then fg's main shell */
8574                                 rcode = checkjobs_and_fg_shell(pi);
8575                                 debug_printf_exec(": checkjobs_and_fg_shell exitcode %d\n", rcode);
8576                                 goto check_traps;
8577                         }
8578 #endif
8579                         /* This one just waits for completion */
8580                         rcode = checkjobs(pi, 0 /*(no pid to wait for)*/);
8581                         debug_printf_exec(": checkjobs exitcode %d\n", rcode);
8582  check_traps:
8583                         G.last_exitcode = rcode;
8584                         check_and_run_traps();
8585                 }
8586
8587                 /* Handle "set -e" */
8588                 if (rcode != 0 && G.o_opt[OPT_O_ERREXIT]) {
8589                         debug_printf_exec("ERREXIT:1 errexit_depth:%d\n", G.errexit_depth);
8590                         if (G.errexit_depth == 0)
8591                                 hush_exit(rcode);
8592                 }
8593                 G.errexit_depth = sv_errexit_depth;
8594
8595                 /* Analyze how result affects subsequent commands */
8596 #if ENABLE_HUSH_IF
8597                 if (rword == RES_IF || rword == RES_ELIF)
8598                         cond_code = rcode;
8599 #endif
8600  check_jobs_and_continue:
8601                 checkjobs(NULL, 0 /*(no pid to wait for)*/);
8602  dont_check_jobs_but_continue: ;
8603 #if ENABLE_HUSH_LOOPS
8604                 /* Beware of "while false; true; do ..."! */
8605                 if (pi->next
8606                  && (pi->next->res_word == RES_DO || pi->next->res_word == RES_DONE)
8607                  /* check for RES_DONE is needed for "while ...; do \n done" case */
8608                 ) {
8609                         if (rword == RES_WHILE) {
8610                                 if (rcode) {
8611                                         /* "while false; do...done" - exitcode 0 */
8612                                         G.last_exitcode = rcode = EXIT_SUCCESS;
8613                                         debug_printf_exec(": while expr is false: breaking (exitcode:EXIT_SUCCESS)\n");
8614                                         break;
8615                                 }
8616                         }
8617                         if (rword == RES_UNTIL) {
8618                                 if (!rcode) {
8619                                         debug_printf_exec(": until expr is true: breaking\n");
8620                                         break;
8621                                 }
8622                         }
8623                 }
8624 #endif
8625         } /* for (pi) */
8626
8627 #if ENABLE_HUSH_JOB
8628         G.run_list_level--;
8629 #endif
8630 #if ENABLE_HUSH_LOOPS
8631         if (loop_top)
8632                 G.depth_of_loop--;
8633         free(for_list);
8634 #endif
8635 #if ENABLE_HUSH_CASE
8636         free(case_word);
8637 #endif
8638         debug_leave();
8639         debug_printf_exec("run_list lvl %d return %d\n", G.run_list_level + 1, rcode);
8640         return rcode;
8641 }
8642
8643 /* Select which version we will use */
8644 static int run_and_free_list(struct pipe *pi)
8645 {
8646         int rcode = 0;
8647         debug_printf_exec("run_and_free_list entered\n");
8648         if (!G.o_opt[OPT_O_NOEXEC]) {
8649                 debug_printf_exec(": run_list: 1st pipe with %d cmds\n", pi->num_cmds);
8650                 rcode = run_list(pi);
8651         }
8652         /* free_pipe_list has the side effect of clearing memory.
8653          * In the long run that function can be merged with run_list,
8654          * but doing that now would hobble the debugging effort. */
8655         free_pipe_list(pi);
8656         debug_printf_exec("run_and_free_list return %d\n", rcode);
8657         return rcode;
8658 }
8659
8660
8661 static void install_sighandlers(unsigned mask)
8662 {
8663         sighandler_t old_handler;
8664         unsigned sig = 0;
8665         while ((mask >>= 1) != 0) {
8666                 sig++;
8667                 if (!(mask & 1))
8668                         continue;
8669                 old_handler = install_sighandler(sig, pick_sighandler(sig));
8670                 /* POSIX allows shell to re-enable SIGCHLD
8671                  * even if it was SIG_IGN on entry.
8672                  * Therefore we skip IGN check for it:
8673                  */
8674                 if (sig == SIGCHLD)
8675                         continue;
8676                 /* bash re-enables SIGHUP which is SIG_IGNed on entry.
8677                  * Try: "trap '' HUP; bash; echo RET" and type "kill -HUP $$"
8678                  */
8679                 //if (sig == SIGHUP) continue; - TODO?
8680                 if (old_handler == SIG_IGN) {
8681                         /* oops... restore back to IGN, and record this fact */
8682                         install_sighandler(sig, old_handler);
8683 #if ENABLE_HUSH_TRAP
8684                         if (!G_traps)
8685                                 G_traps = xzalloc(sizeof(G_traps[0]) * NSIG);
8686                         free(G_traps[sig]);
8687                         G_traps[sig] = xzalloc(1); /* == xstrdup(""); */
8688 #endif
8689                 }
8690         }
8691 }
8692
8693 /* Called a few times only (or even once if "sh -c") */
8694 static void install_special_sighandlers(void)
8695 {
8696         unsigned mask;
8697
8698         /* Which signals are shell-special? */
8699         mask = (1 << SIGQUIT) | (1 << SIGCHLD);
8700         if (G_interactive_fd) {
8701                 mask |= SPECIAL_INTERACTIVE_SIGS;
8702                 if (G_saved_tty_pgrp) /* we have ctty, job control sigs work */
8703                         mask |= SPECIAL_JOBSTOP_SIGS;
8704         }
8705         /* Careful, do not re-install handlers we already installed */
8706         if (G.special_sig_mask != mask) {
8707                 unsigned diff = mask & ~G.special_sig_mask;
8708                 G.special_sig_mask = mask;
8709                 install_sighandlers(diff);
8710         }
8711 }
8712
8713 #if ENABLE_HUSH_JOB
8714 /* helper */
8715 /* Set handlers to restore tty pgrp and exit */
8716 static void install_fatal_sighandlers(void)
8717 {
8718         unsigned mask;
8719
8720         /* We will restore tty pgrp on these signals */
8721         mask = 0
8722                 /*+ (1 << SIGILL ) * HUSH_DEBUG*/
8723                 /*+ (1 << SIGFPE ) * HUSH_DEBUG*/
8724                 + (1 << SIGBUS ) * HUSH_DEBUG
8725                 + (1 << SIGSEGV) * HUSH_DEBUG
8726                 /*+ (1 << SIGTRAP) * HUSH_DEBUG*/
8727                 + (1 << SIGABRT)
8728         /* bash 3.2 seems to handle these just like 'fatal' ones */
8729                 + (1 << SIGPIPE)
8730                 + (1 << SIGALRM)
8731         /* if we are interactive, SIGHUP, SIGTERM and SIGINT are special sigs.
8732          * if we aren't interactive... but in this case
8733          * we never want to restore pgrp on exit, and this fn is not called
8734          */
8735                 /*+ (1 << SIGHUP )*/
8736                 /*+ (1 << SIGTERM)*/
8737                 /*+ (1 << SIGINT )*/
8738         ;
8739         G_fatal_sig_mask = mask;
8740
8741         install_sighandlers(mask);
8742 }
8743 #endif
8744
8745 static int set_mode(int state, char mode, const char *o_opt)
8746 {
8747         int idx;
8748         switch (mode) {
8749         case 'n':
8750                 G.o_opt[OPT_O_NOEXEC] = state;
8751                 break;
8752         case 'x':
8753                 IF_HUSH_MODE_X(G_x_mode = state;)
8754                 break;
8755         case 'o':
8756                 if (!o_opt) {
8757                         /* "set -+o" without parameter.
8758                          * in bash, set -o produces this output:
8759                          *  pipefail        off
8760                          * and set +o:
8761                          *  set +o pipefail
8762                          * We always use the second form.
8763                          */
8764                         const char *p = o_opt_strings;
8765                         idx = 0;
8766                         while (*p) {
8767                                 printf("set %co %s\n", (G.o_opt[idx] ? '-' : '+'), p);
8768                                 idx++;
8769                                 p += strlen(p) + 1;
8770                         }
8771                         break;
8772                 }
8773                 idx = index_in_strings(o_opt_strings, o_opt);
8774                 if (idx >= 0) {
8775                         G.o_opt[idx] = state;
8776                         break;
8777                 }
8778         case 'e':
8779                 G.o_opt[OPT_O_ERREXIT] = state;
8780                 break;
8781         default:
8782                 return EXIT_FAILURE;
8783         }
8784         return EXIT_SUCCESS;
8785 }
8786
8787 int hush_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
8788 int hush_main(int argc, char **argv)
8789 {
8790         enum {
8791                 OPT_login = (1 << 0),
8792         };
8793         unsigned flags;
8794         int opt;
8795         unsigned builtin_argc;
8796         char **e;
8797         struct variable *cur_var;
8798         struct variable *shell_ver;
8799
8800         INIT_G();
8801         if (EXIT_SUCCESS != 0) /* if EXIT_SUCCESS == 0, it is already done */
8802                 G.last_exitcode = EXIT_SUCCESS;
8803
8804 #if ENABLE_HUSH_FAST
8805         G.count_SIGCHLD++; /* ensure it is != G.handled_SIGCHLD */
8806 #endif
8807 #if !BB_MMU
8808         G.argv0_for_re_execing = argv[0];
8809 #endif
8810         /* Deal with HUSH_VERSION */
8811         shell_ver = xzalloc(sizeof(*shell_ver));
8812         shell_ver->flg_export = 1;
8813         shell_ver->flg_read_only = 1;
8814         /* Code which handles ${var<op>...} needs writable values for all variables,
8815          * therefore we xstrdup: */
8816         shell_ver->varstr = xstrdup(hush_version_str);
8817         /* Create shell local variables from the values
8818          * currently living in the environment */
8819         debug_printf_env("unsetenv '%s'\n", "HUSH_VERSION");
8820         unsetenv("HUSH_VERSION"); /* in case it exists in initial env */
8821         G.top_var = shell_ver;
8822         cur_var = G.top_var;
8823         e = environ;
8824         if (e) while (*e) {
8825                 char *value = strchr(*e, '=');
8826                 if (value) { /* paranoia */
8827                         cur_var->next = xzalloc(sizeof(*cur_var));
8828                         cur_var = cur_var->next;
8829                         cur_var->varstr = *e;
8830                         cur_var->max_len = strlen(*e);
8831                         cur_var->flg_export = 1;
8832                 }
8833                 e++;
8834         }
8835         /* (Re)insert HUSH_VERSION into env (AFTER we scanned the env!) */
8836         debug_printf_env("putenv '%s'\n", shell_ver->varstr);
8837         putenv(shell_ver->varstr);
8838
8839         /* Export PWD */
8840         set_pwd_var(SETFLAG_EXPORT);
8841
8842 #if BASH_HOSTNAME_VAR
8843         /* Set (but not export) HOSTNAME unless already set */
8844         if (!get_local_var_value("HOSTNAME")) {
8845                 struct utsname uts;
8846                 uname(&uts);
8847                 set_local_var_from_halves("HOSTNAME", uts.nodename);
8848         }
8849         /* bash also exports SHLVL and _,
8850          * and sets (but doesn't export) the following variables:
8851          * BASH=/bin/bash
8852          * BASH_VERSINFO=([0]="3" [1]="2" [2]="0" [3]="1" [4]="release" [5]="i386-pc-linux-gnu")
8853          * BASH_VERSION='3.2.0(1)-release'
8854          * HOSTTYPE=i386
8855          * MACHTYPE=i386-pc-linux-gnu
8856          * OSTYPE=linux-gnu
8857          * PPID=<NNNNN> - we also do it elsewhere
8858          * EUID=<NNNNN>
8859          * UID=<NNNNN>
8860          * GROUPS=()
8861          * LINES=<NNN>
8862          * COLUMNS=<NNN>
8863          * BASH_ARGC=()
8864          * BASH_ARGV=()
8865          * BASH_LINENO=()
8866          * BASH_SOURCE=()
8867          * DIRSTACK=()
8868          * PIPESTATUS=([0]="0")
8869          * HISTFILE=/<xxx>/.bash_history
8870          * HISTFILESIZE=500
8871          * HISTSIZE=500
8872          * MAILCHECK=60
8873          * PATH=/usr/gnu/bin:/usr/local/bin:/bin:/usr/bin:.
8874          * SHELL=/bin/bash
8875          * SHELLOPTS=braceexpand:emacs:hashall:histexpand:history:interactive-comments:monitor
8876          * TERM=dumb
8877          * OPTERR=1
8878          * OPTIND=1
8879          * IFS=$' \t\n'
8880          * PS1='\s-\v\$ '
8881          * PS2='> '
8882          * PS4='+ '
8883          */
8884 #endif
8885
8886 #if ENABLE_FEATURE_EDITING
8887         G.line_input_state = new_line_input_t(FOR_SHELL);
8888 #endif
8889
8890         /* Initialize some more globals to non-zero values */
8891         cmdedit_update_prompt();
8892
8893         die_func = restore_ttypgrp_and__exit;
8894
8895         /* Shell is non-interactive at first. We need to call
8896          * install_special_sighandlers() if we are going to execute "sh <script>",
8897          * "sh -c <cmds>" or login shell's /etc/profile and friends.
8898          * If we later decide that we are interactive, we run install_special_sighandlers()
8899          * in order to intercept (more) signals.
8900          */
8901
8902         /* Parse options */
8903         /* http://www.opengroup.org/onlinepubs/9699919799/utilities/sh.html */
8904         flags = (argv[0] && argv[0][0] == '-') ? OPT_login : 0;
8905         builtin_argc = 0;
8906         while (1) {
8907                 opt = getopt(argc, argv, "+c:exinsl"
8908 #if !BB_MMU
8909                                 "<:$:R:V:"
8910 # if ENABLE_HUSH_FUNCTIONS
8911                                 "F:"
8912 # endif
8913 #endif
8914                 );
8915                 if (opt <= 0)
8916                         break;
8917                 switch (opt) {
8918                 case 'c':
8919                         /* Possibilities:
8920                          * sh ... -c 'script'
8921                          * sh ... -c 'script' ARG0 [ARG1...]
8922                          * On NOMMU, if builtin_argc != 0,
8923                          * sh ... -c 'builtin' BARGV... "" ARG0 [ARG1...]
8924                          * "" needs to be replaced with NULL
8925                          * and BARGV vector fed to builtin function.
8926                          * Note: the form without ARG0 never happens:
8927                          * sh ... -c 'builtin' BARGV... ""
8928                          */
8929                         if (!G.root_pid) {
8930                                 G.root_pid = getpid();
8931                                 G.root_ppid = getppid();
8932                         }
8933                         G.global_argv = argv + optind;
8934                         G.global_argc = argc - optind;
8935                         if (builtin_argc) {
8936                                 /* -c 'builtin' [BARGV...] "" ARG0 [ARG1...] */
8937                                 const struct built_in_command *x;
8938
8939                                 install_special_sighandlers();
8940                                 x = find_builtin(optarg);
8941                                 if (x) { /* paranoia */
8942                                         G.global_argc -= builtin_argc; /* skip [BARGV...] "" */
8943                                         G.global_argv += builtin_argc;
8944                                         G.global_argv[-1] = NULL; /* replace "" */
8945                                         fflush_all();
8946                                         G.last_exitcode = x->b_function(argv + optind - 1);
8947                                 }
8948                                 goto final_return;
8949                         }
8950                         if (!G.global_argv[0]) {
8951                                 /* -c 'script' (no params): prevent empty $0 */
8952                                 G.global_argv--; /* points to argv[i] of 'script' */
8953                                 G.global_argv[0] = argv[0];
8954                                 G.global_argc++;
8955                         } /* else -c 'script' ARG0 [ARG1...]: $0 is ARG0 */
8956                         install_special_sighandlers();
8957                         parse_and_run_string(optarg);
8958                         goto final_return;
8959                 case 'i':
8960                         /* Well, we cannot just declare interactiveness,
8961                          * we have to have some stuff (ctty, etc) */
8962                         /* G_interactive_fd++; */
8963                         break;
8964                 case 's':
8965                         /* "-s" means "read from stdin", but this is how we always
8966                          * operate, so simply do nothing here. */
8967                         break;
8968                 case 'l':
8969                         flags |= OPT_login;
8970                         break;
8971 #if !BB_MMU
8972                 case '<': /* "big heredoc" support */
8973                         full_write1_str(optarg);
8974                         _exit(0);
8975                 case '$': {
8976                         unsigned long long empty_trap_mask;
8977
8978                         G.root_pid = bb_strtou(optarg, &optarg, 16);
8979                         optarg++;
8980                         G.root_ppid = bb_strtou(optarg, &optarg, 16);
8981                         optarg++;
8982                         G.last_bg_pid = bb_strtou(optarg, &optarg, 16);
8983                         optarg++;
8984                         G.last_exitcode = bb_strtou(optarg, &optarg, 16);
8985                         optarg++;
8986                         builtin_argc = bb_strtou(optarg, &optarg, 16);
8987                         optarg++;
8988                         empty_trap_mask = bb_strtoull(optarg, &optarg, 16);
8989                         if (empty_trap_mask != 0) {
8990                                 IF_HUSH_TRAP(int sig;)
8991                                 install_special_sighandlers();
8992 # if ENABLE_HUSH_TRAP
8993                                 G_traps = xzalloc(sizeof(G_traps[0]) * NSIG);
8994                                 for (sig = 1; sig < NSIG; sig++) {
8995                                         if (empty_trap_mask & (1LL << sig)) {
8996                                                 G_traps[sig] = xzalloc(1); /* == xstrdup(""); */
8997                                                 install_sighandler(sig, SIG_IGN);
8998                                         }
8999                                 }
9000 # endif
9001                         }
9002 # if ENABLE_HUSH_LOOPS
9003                         optarg++;
9004                         G.depth_of_loop = bb_strtou(optarg, &optarg, 16);
9005 # endif
9006                         break;
9007                 }
9008                 case 'R':
9009                 case 'V':
9010                         set_local_var(xstrdup(optarg), opt == 'R' ? SETFLAG_MAKE_RO : 0);
9011                         break;
9012 # if ENABLE_HUSH_FUNCTIONS
9013                 case 'F': {
9014                         struct function *funcp = new_function(optarg);
9015                         /* funcp->name is already set to optarg */
9016                         /* funcp->body is set to NULL. It's a special case. */
9017                         funcp->body_as_string = argv[optind];
9018                         optind++;
9019                         break;
9020                 }
9021 # endif
9022 #endif
9023                 case 'n':
9024                 case 'x':
9025                 case 'e':
9026                         if (set_mode(1, opt, NULL) == 0) /* no error */
9027                                 break;
9028                 default:
9029 #ifndef BB_VER
9030                         fprintf(stderr, "Usage: sh [FILE]...\n"
9031                                         "   or: sh -c command [args]...\n\n");
9032                         exit(EXIT_FAILURE);
9033 #else
9034                         bb_show_usage();
9035 #endif
9036                 }
9037         } /* option parsing loop */
9038
9039         /* Skip options. Try "hush -l": $1 should not be "-l"! */
9040         G.global_argc = argc - (optind - 1);
9041         G.global_argv = argv + (optind - 1);
9042         G.global_argv[0] = argv[0];
9043
9044         if (!G.root_pid) {
9045                 G.root_pid = getpid();
9046                 G.root_ppid = getppid();
9047         }
9048
9049         /* If we are login shell... */
9050         if (flags & OPT_login) {
9051                 FILE *input;
9052                 debug_printf("sourcing /etc/profile\n");
9053                 input = fopen_for_read("/etc/profile");
9054                 if (input != NULL) {
9055                         remember_FILE(input);
9056                         install_special_sighandlers();
9057                         parse_and_run_file(input);
9058                         fclose_and_forget(input);
9059                 }
9060                 /* bash: after sourcing /etc/profile,
9061                  * tries to source (in the given order):
9062                  * ~/.bash_profile, ~/.bash_login, ~/.profile,
9063                  * stopping on first found. --noprofile turns this off.
9064                  * bash also sources ~/.bash_logout on exit.
9065                  * If called as sh, skips .bash_XXX files.
9066                  */
9067         }
9068
9069         if (G.global_argv[1]) {
9070                 FILE *input;
9071                 /*
9072                  * "bash <script>" (which is never interactive (unless -i?))
9073                  * sources $BASH_ENV here (without scanning $PATH).
9074                  * If called as sh, does the same but with $ENV.
9075                  * Also NB, per POSIX, $ENV should undergo parameter expansion.
9076                  */
9077                 G.global_argc--;
9078                 G.global_argv++;
9079                 debug_printf("running script '%s'\n", G.global_argv[0]);
9080                 xfunc_error_retval = 127; /* for "hush /does/not/exist" case */
9081                 input = xfopen_for_read(G.global_argv[0]);
9082                 xfunc_error_retval = 1;
9083                 remember_FILE(input);
9084                 install_special_sighandlers();
9085                 parse_and_run_file(input);
9086 #if ENABLE_FEATURE_CLEAN_UP
9087                 fclose_and_forget(input);
9088 #endif
9089                 goto final_return;
9090         }
9091
9092         /* Up to here, shell was non-interactive. Now it may become one.
9093          * NB: don't forget to (re)run install_special_sighandlers() as needed.
9094          */
9095
9096         /* A shell is interactive if the '-i' flag was given,
9097          * or if all of the following conditions are met:
9098          *    no -c command
9099          *    no arguments remaining or the -s flag given
9100          *    standard input is a terminal
9101          *    standard output is a terminal
9102          * Refer to Posix.2, the description of the 'sh' utility.
9103          */
9104 #if ENABLE_HUSH_JOB
9105         if (isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)) {
9106                 G_saved_tty_pgrp = tcgetpgrp(STDIN_FILENO);
9107                 debug_printf("saved_tty_pgrp:%d\n", G_saved_tty_pgrp);
9108                 if (G_saved_tty_pgrp < 0)
9109                         G_saved_tty_pgrp = 0;
9110
9111                 /* try to dup stdin to high fd#, >= 255 */
9112                 G_interactive_fd = fcntl_F_DUPFD(STDIN_FILENO, 254);
9113                 if (G_interactive_fd < 0) {
9114                         /* try to dup to any fd */
9115                         G_interactive_fd = dup(STDIN_FILENO);
9116                         if (G_interactive_fd < 0) {
9117                                 /* give up */
9118                                 G_interactive_fd = 0;
9119                                 G_saved_tty_pgrp = 0;
9120                         }
9121                 }
9122 // TODO: track & disallow any attempts of user
9123 // to (inadvertently) close/redirect G_interactive_fd
9124         }
9125         debug_printf("interactive_fd:%d\n", G_interactive_fd);
9126         if (G_interactive_fd) {
9127                 close_on_exec_on(G_interactive_fd);
9128
9129                 if (G_saved_tty_pgrp) {
9130                         /* If we were run as 'hush &', sleep until we are
9131                          * in the foreground (tty pgrp == our pgrp).
9132                          * If we get started under a job aware app (like bash),
9133                          * make sure we are now in charge so we don't fight over
9134                          * who gets the foreground */
9135                         while (1) {
9136                                 pid_t shell_pgrp = getpgrp();
9137                                 G_saved_tty_pgrp = tcgetpgrp(G_interactive_fd);
9138                                 if (G_saved_tty_pgrp == shell_pgrp)
9139                                         break;
9140                                 /* send TTIN to ourself (should stop us) */
9141                                 kill(- shell_pgrp, SIGTTIN);
9142                         }
9143                 }
9144
9145                 /* Install more signal handlers */
9146                 install_special_sighandlers();
9147
9148                 if (G_saved_tty_pgrp) {
9149                         /* Set other signals to restore saved_tty_pgrp */
9150                         install_fatal_sighandlers();
9151                         /* Put ourselves in our own process group
9152                          * (bash, too, does this only if ctty is available) */
9153                         bb_setpgrp(); /* is the same as setpgid(our_pid, our_pid); */
9154                         /* Grab control of the terminal */
9155                         tcsetpgrp(G_interactive_fd, getpid());
9156                 }
9157                 enable_restore_tty_pgrp_on_exit();
9158
9159 # if ENABLE_HUSH_SAVEHISTORY && MAX_HISTORY > 0
9160                 {
9161                         const char *hp = get_local_var_value("HISTFILE");
9162                         if (!hp) {
9163                                 hp = get_local_var_value("HOME");
9164                                 if (hp)
9165                                         hp = concat_path_file(hp, ".hush_history");
9166                         } else {
9167                                 hp = xstrdup(hp);
9168                         }
9169                         if (hp) {
9170                                 G.line_input_state->hist_file = hp;
9171                                 //set_local_var(xasprintf("HISTFILE=%s", ...));
9172                         }
9173 #  if ENABLE_FEATURE_SH_HISTFILESIZE
9174                         hp = get_local_var_value("HISTFILESIZE");
9175                         G.line_input_state->max_history = size_from_HISTFILESIZE(hp);
9176 #  endif
9177                 }
9178 # endif
9179         } else {
9180                 install_special_sighandlers();
9181         }
9182 #elif ENABLE_HUSH_INTERACTIVE
9183         /* No job control compiled in, only prompt/line editing */
9184         if (isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)) {
9185                 G_interactive_fd = fcntl_F_DUPFD(STDIN_FILENO, 254);
9186                 if (G_interactive_fd < 0) {
9187                         /* try to dup to any fd */
9188                         G_interactive_fd = dup(STDIN_FILENO);
9189                         if (G_interactive_fd < 0)
9190                                 /* give up */
9191                                 G_interactive_fd = 0;
9192                 }
9193         }
9194         if (G_interactive_fd) {
9195                 close_on_exec_on(G_interactive_fd);
9196         }
9197         install_special_sighandlers();
9198 #else
9199         /* We have interactiveness code disabled */
9200         install_special_sighandlers();
9201 #endif
9202         /* bash:
9203          * if interactive but not a login shell, sources ~/.bashrc
9204          * (--norc turns this off, --rcfile <file> overrides)
9205          */
9206
9207         if (!ENABLE_FEATURE_SH_EXTRA_QUIET && G_interactive_fd) {
9208                 /* note: ash and hush share this string */
9209                 printf("\n\n%s %s\n"
9210                         IF_HUSH_HELP("Enter 'help' for a list of built-in commands.\n")
9211                         "\n",
9212                         bb_banner,
9213                         "hush - the humble shell"
9214                 );
9215         }
9216
9217         parse_and_run_file(stdin);
9218
9219  final_return:
9220         hush_exit(G.last_exitcode);
9221 }
9222
9223
9224 /*
9225  * Built-ins
9226  */
9227 static int FAST_FUNC builtin_true(char **argv UNUSED_PARAM)
9228 {
9229         return 0;
9230 }
9231
9232 #if ENABLE_HUSH_TEST || ENABLE_HUSH_ECHO || ENABLE_HUSH_PRINTF || ENABLE_HUSH_KILL
9233 static int run_applet_main(char **argv, int (*applet_main_func)(int argc, char **argv))
9234 {
9235         int argc = string_array_len(argv);
9236         return applet_main_func(argc, argv);
9237 }
9238 #endif
9239 #if ENABLE_HUSH_TEST || BASH_TEST2
9240 static int FAST_FUNC builtin_test(char **argv)
9241 {
9242         return run_applet_main(argv, test_main);
9243 }
9244 #endif
9245 #if ENABLE_HUSH_ECHO
9246 static int FAST_FUNC builtin_echo(char **argv)
9247 {
9248         return run_applet_main(argv, echo_main);
9249 }
9250 #endif
9251 #if ENABLE_HUSH_PRINTF
9252 static int FAST_FUNC builtin_printf(char **argv)
9253 {
9254         return run_applet_main(argv, printf_main);
9255 }
9256 #endif
9257
9258 #if ENABLE_HUSH_HELP
9259 static int FAST_FUNC builtin_help(char **argv UNUSED_PARAM)
9260 {
9261         const struct built_in_command *x;
9262
9263         printf(
9264                 "Built-in commands:\n"
9265                 "------------------\n");
9266         for (x = bltins1; x != &bltins1[ARRAY_SIZE(bltins1)]; x++) {
9267                 if (x->b_descr)
9268                         printf("%-10s%s\n", x->b_cmd, x->b_descr);
9269         }
9270         return EXIT_SUCCESS;
9271 }
9272 #endif
9273
9274 #if MAX_HISTORY && ENABLE_FEATURE_EDITING
9275 static int FAST_FUNC builtin_history(char **argv UNUSED_PARAM)
9276 {
9277         show_history(G.line_input_state);
9278         return EXIT_SUCCESS;
9279 }
9280 #endif
9281
9282 static char **skip_dash_dash(char **argv)
9283 {
9284         argv++;
9285         if (argv[0] && argv[0][0] == '-' && argv[0][1] == '-' && argv[0][2] == '\0')
9286                 argv++;
9287         return argv;
9288 }
9289
9290 static int FAST_FUNC builtin_cd(char **argv)
9291 {
9292         const char *newdir;
9293
9294         argv = skip_dash_dash(argv);
9295         newdir = argv[0];
9296         if (newdir == NULL) {
9297                 /* bash does nothing (exitcode 0) if HOME is ""; if it's unset,
9298                  * bash says "bash: cd: HOME not set" and does nothing
9299                  * (exitcode 1)
9300                  */
9301                 const char *home = get_local_var_value("HOME");
9302                 newdir = home ? home : "/";
9303         }
9304         if (chdir(newdir)) {
9305                 /* Mimic bash message exactly */
9306                 bb_perror_msg("cd: %s", newdir);
9307                 return EXIT_FAILURE;
9308         }
9309         /* Read current dir (get_cwd(1) is inside) and set PWD.
9310          * Note: do not enforce exporting. If PWD was unset or unexported,
9311          * set it again, but do not export. bash does the same.
9312          */
9313         set_pwd_var(/*flag:*/ 0);
9314         return EXIT_SUCCESS;
9315 }
9316
9317 static int FAST_FUNC builtin_pwd(char **argv UNUSED_PARAM)
9318 {
9319         puts(get_cwd(0));
9320         return EXIT_SUCCESS;
9321 }
9322
9323 static int FAST_FUNC builtin_eval(char **argv)
9324 {
9325         int rcode = EXIT_SUCCESS;
9326
9327         argv = skip_dash_dash(argv);
9328         if (*argv) {
9329                 char *str = expand_strvec_to_string(argv);
9330                 /* bash:
9331                  * eval "echo Hi; done" ("done" is syntax error):
9332                  * "echo Hi" will not execute too.
9333                  */
9334                 parse_and_run_string(str);
9335                 free(str);
9336                 rcode = G.last_exitcode;
9337         }
9338         return rcode;
9339 }
9340
9341 static int FAST_FUNC builtin_exec(char **argv)
9342 {
9343         argv = skip_dash_dash(argv);
9344         if (argv[0] == NULL)
9345                 return EXIT_SUCCESS; /* bash does this */
9346
9347         /* Careful: we can end up here after [v]fork. Do not restore
9348          * tty pgrp then, only top-level shell process does that */
9349         if (G_saved_tty_pgrp && getpid() == G.root_pid)
9350                 tcsetpgrp(G_interactive_fd, G_saved_tty_pgrp);
9351
9352         /* Saved-redirect fds, script fds and G_interactive_fd are still
9353          * open here. However, they are all CLOEXEC, and execv below
9354          * closes them. Try interactive "exec ls -l /proc/self/fd",
9355          * it should show no extra open fds in the "ls" process.
9356          * If we'd try to run builtins/NOEXECs, this would need improving.
9357          */
9358         //close_saved_fds_and_FILE_fds();
9359
9360         /* TODO: if exec fails, bash does NOT exit! We do.
9361          * We'll need to undo trap cleanup (it's inside execvp_or_die)
9362          * and tcsetpgrp, and this is inherently racy.
9363          */
9364         execvp_or_die(argv);
9365 }
9366
9367 static int FAST_FUNC builtin_exit(char **argv)
9368 {
9369         debug_printf_exec("%s()\n", __func__);
9370
9371         /* interactive bash:
9372          * # trap "echo EEE" EXIT
9373          * # exit
9374          * exit
9375          * There are stopped jobs.
9376          * (if there are _stopped_ jobs, running ones don't count)
9377          * # exit
9378          * exit
9379          * EEE (then bash exits)
9380          *
9381          * TODO: we can use G.exiting = -1 as indicator "last cmd was exit"
9382          */
9383
9384         /* note: EXIT trap is run by hush_exit */
9385         argv = skip_dash_dash(argv);
9386         if (argv[0] == NULL)
9387                 hush_exit(G.last_exitcode);
9388         /* mimic bash: exit 123abc == exit 255 + error msg */
9389         xfunc_error_retval = 255;
9390         /* bash: exit -2 == exit 254, no error msg */
9391         hush_exit(xatoi(argv[0]) & 0xff);
9392 }
9393
9394 #if ENABLE_HUSH_TYPE
9395 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/type.html */
9396 static int FAST_FUNC builtin_type(char **argv)
9397 {
9398         int ret = EXIT_SUCCESS;
9399
9400         while (*++argv) {
9401                 const char *type;
9402                 char *path = NULL;
9403
9404                 if (0) {} /* make conditional compile easier below */
9405                 /*else if (find_alias(*argv))
9406                         type = "an alias";*/
9407 #if ENABLE_HUSH_FUNCTIONS
9408                 else if (find_function(*argv))
9409                         type = "a function";
9410 #endif
9411                 else if (find_builtin(*argv))
9412                         type = "a shell builtin";
9413                 else if ((path = find_in_path(*argv)) != NULL)
9414                         type = path;
9415                 else {
9416                         bb_error_msg("type: %s: not found", *argv);
9417                         ret = EXIT_FAILURE;
9418                         continue;
9419                 }
9420
9421                 printf("%s is %s\n", *argv, type);
9422                 free(path);
9423         }
9424
9425         return ret;
9426 }
9427 #endif
9428
9429 #if ENABLE_HUSH_READ
9430 /* Interruptibility of read builtin in bash
9431  * (tested on bash-4.2.8 by sending signals (not by ^C)):
9432  *
9433  * Empty trap makes read ignore corresponding signal, for any signal.
9434  *
9435  * SIGINT:
9436  * - terminates non-interactive shell;
9437  * - interrupts read in interactive shell;
9438  * if it has non-empty trap:
9439  * - executes trap and returns to command prompt in interactive shell;
9440  * - executes trap and returns to read in non-interactive shell;
9441  * SIGTERM:
9442  * - is ignored (does not interrupt) read in interactive shell;
9443  * - terminates non-interactive shell;
9444  * if it has non-empty trap:
9445  * - executes trap and returns to read;
9446  * SIGHUP:
9447  * - terminates shell (regardless of interactivity);
9448  * if it has non-empty trap:
9449  * - executes trap and returns to read;
9450  * SIGCHLD from children:
9451  * - does not interrupt read regardless of interactivity:
9452  *   try: sleep 1 & read x; echo $x
9453  */
9454 static int FAST_FUNC builtin_read(char **argv)
9455 {
9456         const char *r;
9457         char *opt_n = NULL;
9458         char *opt_p = NULL;
9459         char *opt_t = NULL;
9460         char *opt_u = NULL;
9461         char *opt_d = NULL; /* optimized out if !BASH */
9462         const char *ifs;
9463         int read_flags;
9464
9465         /* "!": do not abort on errors.
9466          * Option string must start with "sr" to match BUILTIN_READ_xxx
9467          */
9468         read_flags = getopt32(argv,
9469 #if BASH_READ_D
9470                 "!srn:p:t:u:d:", &opt_n, &opt_p, &opt_t, &opt_u, &opt_d
9471 #else
9472                 "!srn:p:t:u:", &opt_n, &opt_p, &opt_t, &opt_u
9473 #endif
9474         );
9475         if (read_flags == (uint32_t)-1)
9476                 return EXIT_FAILURE;
9477         argv += optind;
9478         ifs = get_local_var_value("IFS"); /* can be NULL */
9479
9480  again:
9481         r = shell_builtin_read(set_local_var_from_halves,
9482                 argv,
9483                 ifs,
9484                 read_flags,
9485                 opt_n,
9486                 opt_p,
9487                 opt_t,
9488                 opt_u,
9489                 opt_d
9490         );
9491
9492         if ((uintptr_t)r == 1 && errno == EINTR) {
9493                 unsigned sig = check_and_run_traps();
9494                 if (sig != SIGINT)
9495                         goto again;
9496         }
9497
9498         if ((uintptr_t)r > 1) {
9499                 bb_error_msg("%s", r);
9500                 r = (char*)(uintptr_t)1;
9501         }
9502
9503         return (uintptr_t)r;
9504 }
9505 #endif
9506
9507 #if ENABLE_HUSH_UMASK
9508 static int FAST_FUNC builtin_umask(char **argv)
9509 {
9510         int rc;
9511         mode_t mask;
9512
9513         rc = 1;
9514         mask = umask(0);
9515         argv = skip_dash_dash(argv);
9516         if (argv[0]) {
9517                 mode_t old_mask = mask;
9518
9519                 /* numeric umasks are taken as-is */
9520                 /* symbolic umasks are inverted: "umask a=rx" calls umask(222) */
9521                 if (!isdigit(argv[0][0]))
9522                         mask ^= 0777;
9523                 mask = bb_parse_mode(argv[0], mask);
9524                 if (!isdigit(argv[0][0]))
9525                         mask ^= 0777;
9526                 if ((unsigned)mask > 0777) {
9527                         mask = old_mask;
9528                         /* bash messages:
9529                          * bash: umask: 'q': invalid symbolic mode operator
9530                          * bash: umask: 999: octal number out of range
9531                          */
9532                         bb_error_msg("%s: invalid mode '%s'", "umask", argv[0]);
9533                         rc = 0;
9534                 }
9535         } else {
9536                 /* Mimic bash */
9537                 printf("%04o\n", (unsigned) mask);
9538                 /* fall through and restore mask which we set to 0 */
9539         }
9540         umask(mask);
9541
9542         return !rc; /* rc != 0 - success */
9543 }
9544 #endif
9545
9546 #if ENABLE_HUSH_EXPORT || ENABLE_HUSH_TRAP
9547 static void print_escaped(const char *s)
9548 {
9549         if (*s == '\'')
9550                 goto squote;
9551         do {
9552                 const char *p = strchrnul(s, '\'');
9553                 /* print 'xxxx', possibly just '' */
9554                 printf("'%.*s'", (int)(p - s), s);
9555                 if (*p == '\0')
9556                         break;
9557                 s = p;
9558  squote:
9559                 /* s points to '; print "'''...'''" */
9560                 putchar('"');
9561                 do putchar('\''); while (*++s == '\'');
9562                 putchar('"');
9563         } while (*s);
9564 }
9565 #endif
9566
9567 #if ENABLE_HUSH_EXPORT || ENABLE_HUSH_LOCAL || ENABLE_HUSH_READONLY
9568 static int helper_export_local(char **argv, unsigned flags)
9569 {
9570         do {
9571                 char *name = *argv;
9572                 char *name_end = strchrnul(name, '=');
9573
9574                 /* So far we do not check that name is valid (TODO?) */
9575
9576                 if (*name_end == '\0') {
9577                         struct variable *var, **vpp;
9578
9579                         vpp = get_ptr_to_local_var(name, name_end - name);
9580                         var = vpp ? *vpp : NULL;
9581
9582                         if (flags & SETFLAG_UNEXPORT) {
9583                                 /* export -n NAME (without =VALUE) */
9584                                 if (var) {
9585                                         var->flg_export = 0;
9586                                         debug_printf_env("%s: unsetenv '%s'\n", __func__, name);
9587                                         unsetenv(name);
9588                                 } /* else: export -n NOT_EXISTING_VAR: no-op */
9589                                 continue;
9590                         }
9591                         if (flags & SETFLAG_EXPORT) {
9592                                 /* export NAME (without =VALUE) */
9593                                 if (var) {
9594                                         var->flg_export = 1;
9595                                         debug_printf_env("%s: putenv '%s'\n", __func__, var->varstr);
9596                                         putenv(var->varstr);
9597                                         continue;
9598                                 }
9599                         }
9600                         if (flags & SETFLAG_MAKE_RO) {
9601                                 /* readonly NAME (without =VALUE) */
9602                                 if (var) {
9603                                         var->flg_read_only = 1;
9604                                         continue;
9605                                 }
9606                         }
9607 # if ENABLE_HUSH_LOCAL
9608                         /* Is this "local" bltin? */
9609                         if (!(flags & (SETFLAG_EXPORT|SETFLAG_UNEXPORT|SETFLAG_MAKE_RO))) {
9610                                 unsigned lvl = flags >> SETFLAG_LOCAL_SHIFT;
9611                                 if (var && var->func_nest_level == lvl) {
9612                                         /* "local x=abc; ...; local x" - ignore second local decl */
9613                                         continue;
9614                                 }
9615                         }
9616 # endif
9617                         /* Exporting non-existing variable.
9618                          * bash does not put it in environment,
9619                          * but remembers that it is exported,
9620                          * and does put it in env when it is set later.
9621                          * We just set it to "" and export.
9622                          */
9623                         /* Or, it's "local NAME" (without =VALUE).
9624                          * bash sets the value to "".
9625                          */
9626                         /* Or, it's "readonly NAME" (without =VALUE).
9627                          * bash remembers NAME and disallows its creation
9628                          * in the future.
9629                          */
9630                         name = xasprintf("%s=", name);
9631                 } else {
9632                         /* (Un)exporting/making local NAME=VALUE */
9633                         name = xstrdup(name);
9634                 }
9635                 if (set_local_var(name, flags))
9636                         return EXIT_FAILURE;
9637         } while (*++argv);
9638         return EXIT_SUCCESS;
9639 }
9640 #endif
9641
9642 #if ENABLE_HUSH_EXPORT
9643 static int FAST_FUNC builtin_export(char **argv)
9644 {
9645         unsigned opt_unexport;
9646
9647 #if ENABLE_HUSH_EXPORT_N
9648         /* "!": do not abort on errors */
9649         opt_unexport = getopt32(argv, "!n");
9650         if (opt_unexport == (uint32_t)-1)
9651                 return EXIT_FAILURE;
9652         argv += optind;
9653 #else
9654         opt_unexport = 0;
9655         argv++;
9656 #endif
9657
9658         if (argv[0] == NULL) {
9659                 char **e = environ;
9660                 if (e) {
9661                         while (*e) {
9662 #if 0
9663                                 puts(*e++);
9664 #else
9665                                 /* ash emits: export VAR='VAL'
9666                                  * bash: declare -x VAR="VAL"
9667                                  * we follow ash example */
9668                                 const char *s = *e++;
9669                                 const char *p = strchr(s, '=');
9670
9671                                 if (!p) /* wtf? take next variable */
9672                                         continue;
9673                                 /* export var= */
9674                                 printf("export %.*s", (int)(p - s) + 1, s);
9675                                 print_escaped(p + 1);
9676                                 putchar('\n');
9677 #endif
9678                         }
9679                         /*fflush_all(); - done after each builtin anyway */
9680                 }
9681                 return EXIT_SUCCESS;
9682         }
9683
9684         return helper_export_local(argv, opt_unexport ? SETFLAG_UNEXPORT : SETFLAG_EXPORT);
9685 }
9686 #endif
9687
9688 #if ENABLE_HUSH_LOCAL
9689 static int FAST_FUNC builtin_local(char **argv)
9690 {
9691         if (G.func_nest_level == 0) {
9692                 bb_error_msg("%s: not in a function", argv[0]);
9693                 return EXIT_FAILURE; /* bash compat */
9694         }
9695         argv++;
9696         return helper_export_local(argv, G.func_nest_level << SETFLAG_LOCAL_SHIFT);
9697 }
9698 #endif
9699
9700 #if ENABLE_HUSH_READONLY
9701 static int FAST_FUNC builtin_readonly(char **argv)
9702 {
9703         argv++;
9704         if (*argv == NULL) {
9705                 /* bash: readonly [-p]: list all readonly VARs
9706                  * (-p has no effect in bash)
9707                  */
9708                 struct variable *e;
9709                 for (e = G.top_var; e; e = e->next) {
9710                         if (e->flg_read_only) {
9711 //TODO: quote value: readonly VAR='VAL'
9712                                 printf("readonly %s\n", e->varstr);
9713                         }
9714                 }
9715                 return EXIT_SUCCESS;
9716         }
9717         return helper_export_local(argv, SETFLAG_MAKE_RO);
9718 }
9719 #endif
9720
9721 #if ENABLE_HUSH_UNSET
9722 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#unset */
9723 static int FAST_FUNC builtin_unset(char **argv)
9724 {
9725         int ret;
9726         unsigned opts;
9727
9728         /* "!": do not abort on errors */
9729         /* "+": stop at 1st non-option */
9730         opts = getopt32(argv, "!+vf");
9731         if (opts == (unsigned)-1)
9732                 return EXIT_FAILURE;
9733         if (opts == 3) {
9734                 bb_error_msg("unset: -v and -f are exclusive");
9735                 return EXIT_FAILURE;
9736         }
9737         argv += optind;
9738
9739         ret = EXIT_SUCCESS;
9740         while (*argv) {
9741                 if (!(opts & 2)) { /* not -f */
9742                         if (unset_local_var(*argv)) {
9743                                 /* unset <nonexistent_var> doesn't fail.
9744                                  * Error is when one tries to unset RO var.
9745                                  * Message was printed by unset_local_var. */
9746                                 ret = EXIT_FAILURE;
9747                         }
9748                 }
9749 # if ENABLE_HUSH_FUNCTIONS
9750                 else {
9751                         unset_func(*argv);
9752                 }
9753 # endif
9754                 argv++;
9755         }
9756         return ret;
9757 }
9758 #endif
9759
9760 #if ENABLE_HUSH_SET
9761 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#set
9762  * built-in 'set' handler
9763  * SUSv3 says:
9764  * set [-abCefhmnuvx] [-o option] [argument...]
9765  * set [+abCefhmnuvx] [+o option] [argument...]
9766  * set -- [argument...]
9767  * set -o
9768  * set +o
9769  * Implementations shall support the options in both their hyphen and
9770  * plus-sign forms. These options can also be specified as options to sh.
9771  * Examples:
9772  * Write out all variables and their values: set
9773  * Set $1, $2, and $3 and set "$#" to 3: set c a b
9774  * Turn on the -x and -v options: set -xv
9775  * Unset all positional parameters: set --
9776  * Set $1 to the value of x, even if it begins with '-' or '+': set -- "$x"
9777  * Set the positional parameters to the expansion of x, even if x expands
9778  * with a leading '-' or '+': set -- $x
9779  *
9780  * So far, we only support "set -- [argument...]" and some of the short names.
9781  */
9782 static int FAST_FUNC builtin_set(char **argv)
9783 {
9784         int n;
9785         char **pp, **g_argv;
9786         char *arg = *++argv;
9787
9788         if (arg == NULL) {
9789                 struct variable *e;
9790                 for (e = G.top_var; e; e = e->next)
9791                         puts(e->varstr);
9792                 return EXIT_SUCCESS;
9793         }
9794
9795         do {
9796                 if (strcmp(arg, "--") == 0) {
9797                         ++argv;
9798                         goto set_argv;
9799                 }
9800                 if (arg[0] != '+' && arg[0] != '-')
9801                         break;
9802                 for (n = 1; arg[n]; ++n) {
9803                         if (set_mode((arg[0] == '-'), arg[n], argv[1]))
9804                                 goto error;
9805                         if (arg[n] == 'o' && argv[1])
9806                                 argv++;
9807                 }
9808         } while ((arg = *++argv) != NULL);
9809         /* Now argv[0] is 1st argument */
9810
9811         if (arg == NULL)
9812                 return EXIT_SUCCESS;
9813  set_argv:
9814
9815         /* NB: G.global_argv[0] ($0) is never freed/changed */
9816         g_argv = G.global_argv;
9817         if (G.global_args_malloced) {
9818                 pp = g_argv;
9819                 while (*++pp)
9820                         free(*pp);
9821                 g_argv[1] = NULL;
9822         } else {
9823                 G.global_args_malloced = 1;
9824                 pp = xzalloc(sizeof(pp[0]) * 2);
9825                 pp[0] = g_argv[0]; /* retain $0 */
9826                 g_argv = pp;
9827         }
9828         /* This realloc's G.global_argv */
9829         G.global_argv = pp = add_strings_to_strings(g_argv, argv, /*dup:*/ 1);
9830
9831         G.global_argc = 1 + string_array_len(pp + 1);
9832
9833         return EXIT_SUCCESS;
9834
9835         /* Nothing known, so abort */
9836  error:
9837         bb_error_msg("set: %s: invalid option", arg);
9838         return EXIT_FAILURE;
9839 }
9840 #endif
9841
9842 static int FAST_FUNC builtin_shift(char **argv)
9843 {
9844         int n = 1;
9845         argv = skip_dash_dash(argv);
9846         if (argv[0]) {
9847                 n = bb_strtou(argv[0], NULL, 10);
9848                 if (errno || n < 0) {
9849                         /* shared string with ash.c */
9850                         bb_error_msg("Illegal number: %s", argv[0]);
9851                         /*
9852                          * ash aborts in this case.
9853                          * bash prints error message and set $? to 1.
9854                          * Interestingly, for "shift 99999" bash does not
9855                          * print error message, but does set $? to 1
9856                          * (and does no shifting at all).
9857                          */
9858                 }
9859         }
9860         if (n >= 0 && n < G.global_argc) {
9861                 if (G_global_args_malloced) {
9862                         int m = 1;
9863                         while (m <= n)
9864                                 free(G.global_argv[m++]);
9865                 }
9866                 G.global_argc -= n;
9867                 memmove(&G.global_argv[1], &G.global_argv[n+1],
9868                                 G.global_argc * sizeof(G.global_argv[0]));
9869                 return EXIT_SUCCESS;
9870         }
9871         return EXIT_FAILURE;
9872 }
9873
9874 #if ENABLE_HUSH_GETOPTS
9875 static int FAST_FUNC builtin_getopts(char **argv)
9876 {
9877 /* http://pubs.opengroup.org/onlinepubs/9699919799/utilities/getopts.html
9878
9879 TODO:
9880 If an invalid option is seen, getopts places ? into VAR and, if
9881 not silent, prints an error message and unsets OPTARG. If
9882 getopts is silent, the option character found is placed in
9883 OPTARG and no diagnostic message is printed.
9884
9885 If a required argument is not found, and getopts is not silent,
9886 a question mark (?) is placed in VAR, OPTARG is unset, and a
9887 diagnostic message is printed.  If getopts is silent, then a
9888 colon (:) is placed in VAR and OPTARG is set to the option
9889 character found.
9890
9891 Test that VAR is a valid variable name?
9892
9893 "Whenever the shell is invoked, OPTIND shall be initialized to 1"
9894 */
9895         char cbuf[2];
9896         const char *cp, *optstring, *var;
9897         int c, exitcode;
9898
9899         optstring = *++argv;
9900         if (!optstring || !(var = *++argv)) {
9901                 bb_error_msg("usage: getopts OPTSTRING VAR [ARGS]");
9902                 return EXIT_FAILURE;
9903         }
9904
9905         cp = get_local_var_value("OPTERR");
9906         opterr = cp ? atoi(cp) : 1;
9907         cp = get_local_var_value("OPTIND");
9908         optind = cp ? atoi(cp) : 0;
9909         optarg = NULL;
9910
9911         /* getopts stops on first non-option. Add "+" to force that */
9912         /*if (optstring[0] != '+')*/ {
9913                 char *s = alloca(strlen(optstring) + 2);
9914                 sprintf(s, "+%s", optstring);
9915                 optstring = s;
9916         }
9917
9918         if (argv[1])
9919                 argv[0] = G.global_argv[0]; /* for error messages */
9920         else
9921                 argv = G.global_argv;
9922         c = getopt(string_array_len(argv), argv, optstring);
9923         exitcode = EXIT_SUCCESS;
9924         if (c < 0) { /* -1: end of options */
9925                 exitcode = EXIT_FAILURE;
9926                 c = '?';
9927         }
9928         cbuf[0] = c;
9929         cbuf[1] = '\0';
9930         set_local_var_from_halves(var, cbuf);
9931         set_local_var_from_halves("OPTIND", utoa(optind));
9932
9933         /* Always set or unset, never left as-is, even on exit/error:
9934          * "If no option was found, or if the option that was found
9935          * does not have an option-argument, OPTARG shall be unset."
9936          */
9937         if (optarg)
9938                 set_local_var_from_halves("OPTARG", optarg);
9939         else
9940                 unset_local_var("OPTARG");
9941
9942         return exitcode;
9943 }
9944 #endif
9945
9946 static int FAST_FUNC builtin_source(char **argv)
9947 {
9948         char *arg_path, *filename;
9949         FILE *input;
9950         save_arg_t sv;
9951         char *args_need_save;
9952 #if ENABLE_HUSH_FUNCTIONS
9953         smallint sv_flg;
9954 #endif
9955
9956         argv = skip_dash_dash(argv);
9957         filename = argv[0];
9958         if (!filename) {
9959                 /* bash says: "bash: .: filename argument required" */
9960                 return 2; /* bash compat */
9961         }
9962         arg_path = NULL;
9963         if (!strchr(filename, '/')) {
9964                 arg_path = find_in_path(filename);
9965                 if (arg_path)
9966                         filename = arg_path;
9967         }
9968         input = remember_FILE(fopen_or_warn(filename, "r"));
9969         free(arg_path);
9970         if (!input) {
9971                 /* bb_perror_msg("%s", *argv); - done by fopen_or_warn */
9972                 /* POSIX: non-interactive shell should abort here,
9973                  * not merely fail. So far no one complained :)
9974                  */
9975                 return EXIT_FAILURE;
9976         }
9977
9978 #if ENABLE_HUSH_FUNCTIONS
9979         sv_flg = G_flag_return_in_progress;
9980         /* "we are inside sourced file, ok to use return" */
9981         G_flag_return_in_progress = -1;
9982 #endif
9983         args_need_save = argv[1]; /* used as a boolean variable */
9984         if (args_need_save)
9985                 save_and_replace_G_args(&sv, argv);
9986
9987         /* "false; . ./empty_line; echo Zero:$?" should print 0 */
9988         G.last_exitcode = 0;
9989         parse_and_run_file(input);
9990         fclose_and_forget(input);
9991
9992         if (args_need_save) /* can't use argv[1] instead: "shift" can mangle it */
9993                 restore_G_args(&sv, argv);
9994 #if ENABLE_HUSH_FUNCTIONS
9995         G_flag_return_in_progress = sv_flg;
9996 #endif
9997
9998         return G.last_exitcode;
9999 }
10000
10001 #if ENABLE_HUSH_TRAP
10002 static int FAST_FUNC builtin_trap(char **argv)
10003 {
10004         int sig;
10005         char *new_cmd;
10006
10007         if (!G_traps)
10008                 G_traps = xzalloc(sizeof(G_traps[0]) * NSIG);
10009
10010         argv++;
10011         if (!*argv) {
10012                 int i;
10013                 /* No args: print all trapped */
10014                 for (i = 0; i < NSIG; ++i) {
10015                         if (G_traps[i]) {
10016                                 printf("trap -- ");
10017                                 print_escaped(G_traps[i]);
10018                                 /* note: bash adds "SIG", but only if invoked
10019                                  * as "bash". If called as "sh", or if set -o posix,
10020                                  * then it prints short signal names.
10021                                  * We are printing short names: */
10022                                 printf(" %s\n", get_signame(i));
10023                         }
10024                 }
10025                 /*fflush_all(); - done after each builtin anyway */
10026                 return EXIT_SUCCESS;
10027         }
10028
10029         new_cmd = NULL;
10030         /* If first arg is a number: reset all specified signals */
10031         sig = bb_strtou(*argv, NULL, 10);
10032         if (errno == 0) {
10033                 int ret;
10034  process_sig_list:
10035                 ret = EXIT_SUCCESS;
10036                 while (*argv) {
10037                         sighandler_t handler;
10038
10039                         sig = get_signum(*argv++);
10040                         if (sig < 0) {
10041                                 ret = EXIT_FAILURE;
10042                                 /* Mimic bash message exactly */
10043                                 bb_error_msg("trap: %s: invalid signal specification", argv[-1]);
10044                                 continue;
10045                         }
10046
10047                         free(G_traps[sig]);
10048                         G_traps[sig] = xstrdup(new_cmd);
10049
10050                         debug_printf("trap: setting SIG%s (%i) to '%s'\n",
10051                                 get_signame(sig), sig, G_traps[sig]);
10052
10053                         /* There is no signal for 0 (EXIT) */
10054                         if (sig == 0)
10055                                 continue;
10056
10057                         if (new_cmd)
10058                                 handler = (new_cmd[0] ? record_pending_signo : SIG_IGN);
10059                         else
10060                                 /* We are removing trap handler */
10061                                 handler = pick_sighandler(sig);
10062                         install_sighandler(sig, handler);
10063                 }
10064                 return ret;
10065         }
10066
10067         if (!argv[1]) { /* no second arg */
10068                 bb_error_msg("trap: invalid arguments");
10069                 return EXIT_FAILURE;
10070         }
10071
10072         /* First arg is "-": reset all specified to default */
10073         /* First arg is "--": skip it, the rest is "handler SIGs..." */
10074         /* Everything else: set arg as signal handler
10075          * (includes "" case, which ignores signal) */
10076         if (argv[0][0] == '-') {
10077                 if (argv[0][1] == '\0') { /* "-" */
10078                         /* new_cmd remains NULL: "reset these sigs" */
10079                         goto reset_traps;
10080                 }
10081                 if (argv[0][1] == '-' && argv[0][2] == '\0') { /* "--" */
10082                         argv++;
10083                 }
10084                 /* else: "-something", no special meaning */
10085         }
10086         new_cmd = *argv;
10087  reset_traps:
10088         argv++;
10089         goto process_sig_list;
10090 }
10091 #endif
10092
10093 #if ENABLE_HUSH_JOB
10094 static struct pipe *parse_jobspec(const char *str)
10095 {
10096         struct pipe *pi;
10097         unsigned jobnum;
10098
10099         if (sscanf(str, "%%%u", &jobnum) != 1) {
10100                 if (str[0] != '%'
10101                  || (str[1] != '%' && str[1] != '+' && str[1] != '\0')
10102                 ) {
10103                         bb_error_msg("bad argument '%s'", str);
10104                         return NULL;
10105                 }
10106                 /* It is "%%", "%+" or "%" - current job */
10107                 jobnum = G.last_jobid;
10108                 if (jobnum == 0) {
10109                         bb_error_msg("no current job");
10110                         return NULL;
10111                 }
10112         }
10113         for (pi = G.job_list; pi; pi = pi->next) {
10114                 if (pi->jobid == jobnum) {
10115                         return pi;
10116                 }
10117         }
10118         bb_error_msg("%u: no such job", jobnum);
10119         return NULL;
10120 }
10121
10122 static int FAST_FUNC builtin_jobs(char **argv UNUSED_PARAM)
10123 {
10124         struct pipe *job;
10125         const char *status_string;
10126
10127         checkjobs(NULL, 0 /*(no pid to wait for)*/);
10128         for (job = G.job_list; job; job = job->next) {
10129                 if (job->alive_cmds == job->stopped_cmds)
10130                         status_string = "Stopped";
10131                 else
10132                         status_string = "Running";
10133
10134                 printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->cmdtext);
10135         }
10136
10137         clean_up_last_dead_job();
10138
10139         return EXIT_SUCCESS;
10140 }
10141
10142 /* built-in 'fg' and 'bg' handler */
10143 static int FAST_FUNC builtin_fg_bg(char **argv)
10144 {
10145         int i;
10146         struct pipe *pi;
10147
10148         if (!G_interactive_fd)
10149                 return EXIT_FAILURE;
10150
10151         /* If they gave us no args, assume they want the last backgrounded task */
10152         if (!argv[1]) {
10153                 for (pi = G.job_list; pi; pi = pi->next) {
10154                         if (pi->jobid == G.last_jobid) {
10155                                 goto found;
10156                         }
10157                 }
10158                 bb_error_msg("%s: no current job", argv[0]);
10159                 return EXIT_FAILURE;
10160         }
10161
10162         pi = parse_jobspec(argv[1]);
10163         if (!pi)
10164                 return EXIT_FAILURE;
10165  found:
10166         /* TODO: bash prints a string representation
10167          * of job being foregrounded (like "sleep 1 | cat") */
10168         if (argv[0][0] == 'f' && G_saved_tty_pgrp) {
10169                 /* Put the job into the foreground.  */
10170                 tcsetpgrp(G_interactive_fd, pi->pgrp);
10171         }
10172
10173         /* Restart the processes in the job */
10174         debug_printf_jobs("reviving %d procs, pgrp %d\n", pi->num_cmds, pi->pgrp);
10175         for (i = 0; i < pi->num_cmds; i++) {
10176                 debug_printf_jobs("reviving pid %d\n", pi->cmds[i].pid);
10177         }
10178         pi->stopped_cmds = 0;
10179
10180         i = kill(- pi->pgrp, SIGCONT);
10181         if (i < 0) {
10182                 if (errno == ESRCH) {
10183                         delete_finished_job(pi);
10184                         return EXIT_SUCCESS;
10185                 }
10186                 bb_perror_msg("kill (SIGCONT)");
10187         }
10188
10189         if (argv[0][0] == 'f') {
10190                 remove_job_from_table(pi); /* FG job shouldn't be in job table */
10191                 return checkjobs_and_fg_shell(pi);
10192         }
10193         return EXIT_SUCCESS;
10194 }
10195 #endif
10196
10197 #if ENABLE_HUSH_KILL
10198 static int FAST_FUNC builtin_kill(char **argv)
10199 {
10200         int ret = 0;
10201
10202 # if ENABLE_HUSH_JOB
10203         if (argv[1] && strcmp(argv[1], "-l") != 0) {
10204                 int i = 1;
10205
10206                 do {
10207                         struct pipe *pi;
10208                         char *dst;
10209                         int j, n;
10210
10211                         if (argv[i][0] != '%')
10212                                 continue;
10213                         /*
10214                          * "kill %N" - job kill
10215                          * Converting to pgrp / pid kill
10216                          */
10217                         pi = parse_jobspec(argv[i]);
10218                         if (!pi) {
10219                                 /* Eat bad jobspec */
10220                                 j = i;
10221                                 do {
10222                                         j++;
10223                                         argv[j - 1] = argv[j];
10224                                 } while (argv[j]);
10225                                 ret = 1;
10226                                 i--;
10227                                 continue;
10228                         }
10229                         /*
10230                          * In jobs started under job control, we signal
10231                          * entire process group by kill -PGRP_ID.
10232                          * This happens, f.e., in interactive shell.
10233                          *
10234                          * Otherwise, we signal each child via
10235                          * kill PID1 PID2 PID3.
10236                          * Testcases:
10237                          * sh -c 'sleep 1|sleep 1 & kill %1'
10238                          * sh -c 'true|sleep 2 & sleep 1; kill %1'
10239                          * sh -c 'true|sleep 1 & sleep 2; kill %1'
10240                          */
10241                         n = G_interactive_fd ? 1 : pi->num_cmds;
10242                         dst = alloca(n * sizeof(int)*4);
10243                         argv[i] = dst;
10244                         if (G_interactive_fd)
10245                                 dst += sprintf(dst, " -%u", (int)pi->pgrp);
10246                         else for (j = 0; j < n; j++) {
10247                                 struct command *cmd = &pi->cmds[j];
10248                                 /* Skip exited members of the job */
10249                                 if (cmd->pid == 0)
10250                                         continue;
10251                                 /*
10252                                  * kill_main has matching code to expect
10253                                  * leading space. Needed to not confuse
10254                                  * negative pids with "kill -SIGNAL_NO" syntax
10255                                  */
10256                                 dst += sprintf(dst, " %u", (int)cmd->pid);
10257                         }
10258                         *dst = '\0';
10259                 } while (argv[++i]);
10260         }
10261 # endif
10262
10263         if (argv[1] || ret == 0) {
10264                 ret = run_applet_main(argv, kill_main);
10265         }
10266         /* else: ret = 1, "kill %bad_jobspec" case */
10267         return ret;
10268 }
10269 #endif
10270
10271 #if ENABLE_HUSH_WAIT
10272 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/wait.html */
10273 #if !ENABLE_HUSH_JOB
10274 # define wait_for_child_or_signal(pipe,pid) wait_for_child_or_signal(pid)
10275 #endif
10276 static int wait_for_child_or_signal(struct pipe *waitfor_pipe, pid_t waitfor_pid)
10277 {
10278         int ret = 0;
10279         for (;;) {
10280                 int sig;
10281                 sigset_t oldset;
10282
10283                 if (!sigisemptyset(&G.pending_set))
10284                         goto check_sig;
10285
10286                 /* waitpid is not interruptible by SA_RESTARTed
10287                  * signals which we use. Thus, this ugly dance:
10288                  */
10289
10290                 /* Make sure possible SIGCHLD is stored in kernel's
10291                  * pending signal mask before we call waitpid.
10292                  * Or else we may race with SIGCHLD, lose it,
10293                  * and get stuck in sigsuspend...
10294                  */
10295                 sigfillset(&oldset); /* block all signals, remember old set */
10296                 sigprocmask(SIG_SETMASK, &oldset, &oldset);
10297
10298                 if (!sigisemptyset(&G.pending_set)) {
10299                         /* Crap! we raced with some signal! */
10300                         goto restore;
10301                 }
10302
10303                 /*errno = 0; - checkjobs does this */
10304 /* Can't pass waitfor_pipe into checkjobs(): it won't be interruptible */
10305                 ret = checkjobs(NULL, waitfor_pid); /* waitpid(WNOHANG) inside */
10306                 debug_printf_exec("checkjobs:%d\n", ret);
10307 #if ENABLE_HUSH_JOB
10308                 if (waitfor_pipe) {
10309                         int rcode = job_exited_or_stopped(waitfor_pipe);
10310                         debug_printf_exec("job_exited_or_stopped:%d\n", rcode);
10311                         if (rcode >= 0) {
10312                                 ret = rcode;
10313                                 sigprocmask(SIG_SETMASK, &oldset, NULL);
10314                                 break;
10315                         }
10316                 }
10317 #endif
10318                 /* if ECHILD, there are no children (ret is -1 or 0) */
10319                 /* if ret == 0, no children changed state */
10320                 /* if ret != 0, it's exitcode+1 of exited waitfor_pid child */
10321                 if (errno == ECHILD || ret) {
10322                         ret--;
10323                         if (ret < 0) /* if ECHILD, may need to fix "ret" */
10324                                 ret = 0;
10325                         sigprocmask(SIG_SETMASK, &oldset, NULL);
10326                         break;
10327                 }
10328                 /* Wait for SIGCHLD or any other signal */
10329                 /* It is vitally important for sigsuspend that SIGCHLD has non-DFL handler! */
10330                 /* Note: sigsuspend invokes signal handler */
10331                 sigsuspend(&oldset);
10332  restore:
10333                 sigprocmask(SIG_SETMASK, &oldset, NULL);
10334  check_sig:
10335                 /* So, did we get a signal? */
10336                 sig = check_and_run_traps();
10337                 if (sig /*&& sig != SIGCHLD - always true */) {
10338                         /* Do this for any (non-ignored) signal, not only for ^C */
10339                         ret = 128 + sig;
10340                         break;
10341                 }
10342                 /* SIGCHLD, or no signal, or ignored one, such as SIGQUIT. Repeat */
10343         }
10344         return ret;
10345 }
10346
10347 static int FAST_FUNC builtin_wait(char **argv)
10348 {
10349         int ret;
10350         int status;
10351
10352         argv = skip_dash_dash(argv);
10353         if (argv[0] == NULL) {
10354                 /* Don't care about wait results */
10355                 /* Note 1: must wait until there are no more children */
10356                 /* Note 2: must be interruptible */
10357                 /* Examples:
10358                  * $ sleep 3 & sleep 6 & wait
10359                  * [1] 30934 sleep 3
10360                  * [2] 30935 sleep 6
10361                  * [1] Done                   sleep 3
10362                  * [2] Done                   sleep 6
10363                  * $ sleep 3 & sleep 6 & wait
10364                  * [1] 30936 sleep 3
10365                  * [2] 30937 sleep 6
10366                  * [1] Done                   sleep 3
10367                  * ^C <-- after ~4 sec from keyboard
10368                  * $
10369                  */
10370                 return wait_for_child_or_signal(NULL, 0 /*(no job and no pid to wait for)*/);
10371         }
10372
10373         do {
10374                 pid_t pid = bb_strtou(*argv, NULL, 10);
10375                 if (errno || pid <= 0) {
10376 #if ENABLE_HUSH_JOB
10377                         if (argv[0][0] == '%') {
10378                                 struct pipe *wait_pipe;
10379                                 ret = 127; /* bash compat for bad jobspecs */
10380                                 wait_pipe = parse_jobspec(*argv);
10381                                 if (wait_pipe) {
10382                                         ret = job_exited_or_stopped(wait_pipe);
10383                                         if (ret < 0) {
10384                                                 ret = wait_for_child_or_signal(wait_pipe, 0);
10385                                         } else {
10386                                                 /* waiting on "last dead job" removes it */
10387                                                 clean_up_last_dead_job();
10388                                         }
10389                                 }
10390                                 /* else: parse_jobspec() already emitted error msg */
10391                                 continue;
10392                         }
10393 #endif
10394                         /* mimic bash message */
10395                         bb_error_msg("wait: '%s': not a pid or valid job spec", *argv);
10396                         ret = EXIT_FAILURE;
10397                         continue; /* bash checks all argv[] */
10398                 }
10399
10400                 /* Do we have such child? */
10401                 ret = waitpid(pid, &status, WNOHANG);
10402                 if (ret < 0) {
10403                         /* No */
10404                         ret = 127;
10405                         if (errno == ECHILD) {
10406                                 if (pid == G.last_bg_pid) {
10407                                         /* "wait $!" but last bg task has already exited. Try:
10408                                          * (sleep 1; exit 3) & sleep 2; echo $?; wait $!; echo $?
10409                                          * In bash it prints exitcode 0, then 3.
10410                                          * In dash, it is 127.
10411                                          */
10412                                         ret = G.last_bg_pid_exitcode;
10413                                 } else {
10414                                         /* Example: "wait 1". mimic bash message */
10415                                         bb_error_msg("wait: pid %d is not a child of this shell", (int)pid);
10416                                 }
10417                         } else {
10418                                 /* ??? */
10419                                 bb_perror_msg("wait %s", *argv);
10420                         }
10421                         continue; /* bash checks all argv[] */
10422                 }
10423                 if (ret == 0) {
10424                         /* Yes, and it still runs */
10425                         ret = wait_for_child_or_signal(NULL, pid);
10426                 } else {
10427                         /* Yes, and it just exited */
10428                         process_wait_result(NULL, pid, status);
10429                         ret = WEXITSTATUS(status);
10430                         if (WIFSIGNALED(status))
10431                                 ret = 128 + WTERMSIG(status);
10432                 }
10433         } while (*++argv);
10434
10435         return ret;
10436 }
10437 #endif
10438
10439 #if ENABLE_HUSH_LOOPS || ENABLE_HUSH_FUNCTIONS
10440 static unsigned parse_numeric_argv1(char **argv, unsigned def, unsigned def_min)
10441 {
10442         if (argv[1]) {
10443                 def = bb_strtou(argv[1], NULL, 10);
10444                 if (errno || def < def_min || argv[2]) {
10445                         bb_error_msg("%s: bad arguments", argv[0]);
10446                         def = UINT_MAX;
10447                 }
10448         }
10449         return def;
10450 }
10451 #endif
10452
10453 #if ENABLE_HUSH_LOOPS
10454 static int FAST_FUNC builtin_break(char **argv)
10455 {
10456         unsigned depth;
10457         if (G.depth_of_loop == 0) {
10458                 bb_error_msg("%s: only meaningful in a loop", argv[0]);
10459                 /* if we came from builtin_continue(), need to undo "= 1" */
10460                 G.flag_break_continue = 0;
10461                 return EXIT_SUCCESS; /* bash compat */
10462         }
10463         G.flag_break_continue++; /* BC_BREAK = 1, or BC_CONTINUE = 2 */
10464
10465         G.depth_break_continue = depth = parse_numeric_argv1(argv, 1, 1);
10466         if (depth == UINT_MAX)
10467                 G.flag_break_continue = BC_BREAK;
10468         if (G.depth_of_loop < depth)
10469                 G.depth_break_continue = G.depth_of_loop;
10470
10471         return EXIT_SUCCESS;
10472 }
10473
10474 static int FAST_FUNC builtin_continue(char **argv)
10475 {
10476         G.flag_break_continue = 1; /* BC_CONTINUE = 2 = 1+1 */
10477         return builtin_break(argv);
10478 }
10479 #endif
10480
10481 #if ENABLE_HUSH_FUNCTIONS
10482 static int FAST_FUNC builtin_return(char **argv)
10483 {
10484         int rc;
10485
10486         if (G_flag_return_in_progress != -1) {
10487                 bb_error_msg("%s: not in a function or sourced script", argv[0]);
10488                 return EXIT_FAILURE; /* bash compat */
10489         }
10490
10491         G_flag_return_in_progress = 1;
10492
10493         /* bash:
10494          * out of range: wraps around at 256, does not error out
10495          * non-numeric param:
10496          * f() { false; return qwe; }; f; echo $?
10497          * bash: return: qwe: numeric argument required  <== we do this
10498          * 255  <== we also do this
10499          */
10500         rc = parse_numeric_argv1(argv, G.last_exitcode, 0);
10501         return rc;
10502 }
10503 #endif
10504
10505 #if ENABLE_HUSH_TIMES
10506 static int FAST_FUNC builtin_times(char **argv UNUSED_PARAM)
10507 {
10508         static const uint8_t times_tbl[] ALIGN1 = {
10509                 ' ',  offsetof(struct tms, tms_utime),
10510                 '\n', offsetof(struct tms, tms_stime),
10511                 ' ',  offsetof(struct tms, tms_cutime),
10512                 '\n', offsetof(struct tms, tms_cstime),
10513                 0
10514         };
10515         const uint8_t *p;
10516         unsigned clk_tck;
10517         struct tms buf;
10518
10519         clk_tck = bb_clk_tck();
10520
10521         times(&buf);
10522         p = times_tbl;
10523         do {
10524                 unsigned sec, frac;
10525                 unsigned long t;
10526                 t = *(clock_t *)(((char *) &buf) + p[1]);
10527                 sec = t / clk_tck;
10528                 frac = t % clk_tck;
10529                 printf("%um%u.%03us%c",
10530                         sec / 60, sec % 60,
10531                         (frac * 1000) / clk_tck,
10532                         p[0]);
10533                 p += 2;
10534         } while (*p);
10535
10536         return EXIT_SUCCESS;
10537 }
10538 #endif
10539
10540 #if ENABLE_HUSH_MEMLEAK
10541 static int FAST_FUNC builtin_memleak(char **argv UNUSED_PARAM)
10542 {
10543         void *p;
10544         unsigned long l;
10545
10546 # ifdef M_TRIM_THRESHOLD
10547         /* Optional. Reduces probability of false positives */
10548         malloc_trim(0);
10549 # endif
10550         /* Crude attempt to find where "free memory" starts,
10551          * sans fragmentation. */
10552         p = malloc(240);
10553         l = (unsigned long)p;
10554         free(p);
10555         p = malloc(3400);
10556         if (l < (unsigned long)p) l = (unsigned long)p;
10557         free(p);
10558
10559
10560 # if 0  /* debug */
10561         {
10562                 struct mallinfo mi = mallinfo();
10563                 printf("top alloc:0x%lx malloced:%d+%d=%d\n", l,
10564                         mi.arena, mi.hblkhd, mi.arena + mi.hblkhd);
10565         }
10566 # endif
10567
10568         if (!G.memleak_value)
10569                 G.memleak_value = l;
10570
10571         l -= G.memleak_value;
10572         if ((long)l < 0)
10573                 l = 0;
10574         l /= 1024;
10575         if (l > 127)
10576                 l = 127;
10577
10578         /* Exitcode is "how many kilobytes we leaked since 1st call" */
10579         return l;
10580 }
10581 #endif