shell/ash.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * ash shell port for busybox
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Kenneth Almquist.
   7  *
   8  * Original BSD copyright notice is retained at the end of this file.
   9  *
  10  * Copyright (c) 1989, 1991, 1993, 1994
  11  *      The Regents of the University of California.  All rights reserved.
  12  *
  13  * Copyright (c) 1997-2005 Herbert Xu <herbert@gondor.apana.org.au>
  14  * was re-ported from NetBSD and debianized.
  15  *
  16  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  17  */
  18 //config:config ASH
  19 //config:       bool "ash"
  20 //config:       default y
  21 //config:       depends on !NOMMU
  22 //config:       help
  23 //config:         Tha 'ash' shell adds about 60k in the default configuration and is
  24 //config:         the most complete and most pedantically correct shell included with
  25 //config:         busybox. This shell is actually a derivative of the Debian 'dash'
  26 //config:         shell (by Herbert Xu), which was created by porting the 'ash' shell
  27 //config:         (written by Kenneth Almquist) from NetBSD.
  28 //config:
  29 //config:# ash options
  30 //config:# note: Don't remove !NOMMU part in the next line; it would break
  31 //config:# menuconfig's indenting.
  32 //config:if !NOMMU && (ASH || SH_IS_ASH || BASH_IS_ASH)
  33 //config:
  34 //config:config ASH_OPTIMIZE_FOR_SIZE
  35 //config:       bool "Optimize for size instead of speed"
  36 //config:       default y
  37 //config:       depends on ASH || SH_IS_ASH || BASH_IS_ASH
  38 //config:
  39 //config:config ASH_INTERNAL_GLOB
  40 //config:       bool "Use internal glob() implementation"
  41 //config:       default y       # Y is bigger, but because of uclibc glob() bug, let Y be default for now
  42 //config:       depends on ASH || SH_IS_ASH || BASH_IS_ASH
  43 //config:       help
  44 //config:         Do not use glob() function from libc, use internal implementation.
  45 //config:         Use this if you are getting "glob.h: No such file or directory"
  46 //config:         or similar build errors.
  47 //config:         Note that as of now (2017-01), uclibc and musl glob() both have bugs
  48 //config:         which would break ash if you select N here.
  49 //config:
  50 //config:config ASH_BASH_COMPAT
  51 //config:       bool "bash-compatible extensions"
  52 //config:       default y
  53 //config:       depends on ASH || SH_IS_ASH || BASH_IS_ASH
  54 //config:
  55 //config:config ASH_JOB_CONTROL
  56 //config:       bool "Job control"
  57 //config:       default y
  58 //config:       depends on ASH || SH_IS_ASH || BASH_IS_ASH
  59 //config:
  60 //config:config ASH_ALIAS
  61 //config:       bool "Alias support"
  62 //config:       default y
  63 //config:       depends on ASH || SH_IS_ASH || BASH_IS_ASH
  64 //config:
  65 //config:config ASH_RANDOM_SUPPORT
  66 //config:       bool "Pseudorandom generator and $RANDOM variable"
  67 //config:       default y
  68 //config:       depends on ASH || SH_IS_ASH || BASH_IS_ASH
  69 //config:       help
  70 //config:         Enable pseudorandom generator and dynamic variable "$RANDOM".
  71 //config:         Each read of "$RANDOM" will generate a new pseudorandom value.
  72 //config:         You can reset the generator by using a specified start value.
  73 //config:         After "unset RANDOM" the generator will switch off and this
  74 //config:         variable will no longer have special treatment.
  75 //config:
  76 //config:config ASH_EXPAND_PRMT
  77 //config:       bool "Expand prompt string"
  78 //config:       default y
  79 //config:       depends on ASH || SH_IS_ASH || BASH_IS_ASH
  80 //config:       help
  81 //config:         $PS# may contain volatile content, such as backquote commands.
  82 //config:         This option recreates the prompt string from the environment
  83 //config:         variable each time it is displayed.
  84 //config:
  85 //config:config ASH_IDLE_TIMEOUT
  86 //config:       bool "Idle timeout variable $TMOUT"
  87 //config:       default y
  88 //config:       depends on ASH || SH_IS_ASH || BASH_IS_ASH
  89 //config:       help
  90 //config:         Enable bash-like auto-logout after $TMOUT seconds of idle time.
  91 //config:
  92 //config:config ASH_MAIL
  93 //config:       bool "Check for new mail in interactive shell"
  94 //config:       default y
  95 //config:       depends on ASH || SH_IS_ASH || BASH_IS_ASH
  96 //config:       help
  97 //config:         Enable "check for new mail" function:
  98 //config:         if set, $MAIL file and $MAILPATH list of files
  99 //config:         are checked for mtime changes, and "you have mail"
 100 //config:         message is printed if change is detected.
 101 //config:
 102 //config:config ASH_ECHO
 103 //config:       bool "echo builtin"
 104 //config:       default y
 105 //config:       depends on ASH || SH_IS_ASH || BASH_IS_ASH
 106 //config:
 107 //config:config ASH_PRINTF
 108 //config:       bool "printf builtin"
 109 //config:       default y
 110 //config:       depends on ASH || SH_IS_ASH || BASH_IS_ASH
 111 //config:
 112 //config:config ASH_TEST
 113 //config:       bool "test builtin"
 114 //config:       default y
 115 //config:       depends on ASH || SH_IS_ASH || BASH_IS_ASH
 116 //config:
 117 //config:config ASH_HELP
 118 //config:       bool "help builtin"
 119 //config:       default y
 120 //config:       depends on ASH || SH_IS_ASH || BASH_IS_ASH
 121 //config:
 122 //config:config ASH_GETOPTS
 123 //config:       bool "getopts builtin"
 124 //config:       default y
 125 //config:       depends on ASH || SH_IS_ASH || BASH_IS_ASH
 126 //config:
 127 //config:config ASH_CMDCMD
 128 //config:       bool "command builtin"
 129 //config:       default y
 130 //config:       depends on ASH || SH_IS_ASH || BASH_IS_ASH
 131 //config:       help
 132 //config:         Enable support for the 'command' builtin, which allows
 133 //config:         you to run the specified command or builtin,
 134 //config:         even when there is a function with the same name.
 135 //config:
 136 //config:endif # ash options
 137
 138 //applet:IF_ASH(APPLET(ash, BB_DIR_BIN, BB_SUID_DROP))
 139 //                      APPLET_ODDNAME:name  main location    suid_type     help
 140 //applet:IF_SH_IS_ASH(  APPLET_ODDNAME(sh,   ash, BB_DIR_BIN, BB_SUID_DROP, ash))
 141 //applet:IF_BASH_IS_ASH(APPLET_ODDNAME(bash, ash, BB_DIR_BIN, BB_SUID_DROP, ash))
 142
 143 //kbuild:lib-$(CONFIG_ASH) += ash.o ash_ptr_hack.o shell_common.o
 144 //kbuild:lib-$(CONFIG_SH_IS_ASH) += ash.o ash_ptr_hack.o shell_common.o
 145 //kbuild:lib-$(CONFIG_BASH_IS_ASH) += ash.o ash_ptr_hack.o shell_common.o
 146 //kbuild:lib-$(CONFIG_ASH_RANDOM_SUPPORT) += random.o
 147
 148 /*
 149  * DEBUG=1 to compile in debugging ('set -o debug' turns on)
 150  * DEBUG=2 to compile in and turn on debugging.
 151  * When debugging is on ("set -o debug" was executed, or DEBUG=2),
 152  * debugging info is written to ./trace, quit signal generates core dump.
 153  */
 154 #define DEBUG 0
 155 /* Tweak debug output verbosity here */
 156 #define DEBUG_TIME 0
 157 #define DEBUG_PID 1
 158 #define DEBUG_SIG 1
 159 #define DEBUG_INTONOFF 0
 160
 161 #define PROFILE 0
 162
 163 #define JOBS ENABLE_ASH_JOB_CONTROL
 164
 165 #include <setjmp.h>
 166 #include <fnmatch.h>
 167 #include <sys/times.h>
 168 #include <sys/utsname.h> /* for setting $HOSTNAME */
 169 #include "busybox.h" /* for applet_names */
 170
 171 /* So far, all bash compat is controlled by one config option */
 172 /* Separate defines document which part of code implements what */
 173 /* function keyword */
 174 #define    BASH_FUNCTION        ENABLE_ASH_BASH_COMPAT
 175 #define IF_BASH_FUNCTION            IF_ASH_BASH_COMPAT
 176 /* &>file */
 177 #define    BASH_REDIR_OUTPUT    ENABLE_ASH_BASH_COMPAT
 178 #define IF_BASH_REDIR_OUTPUT        IF_ASH_BASH_COMPAT
 179 /* $'...' */
 180 #define    BASH_DOLLAR_SQUOTE   ENABLE_ASH_BASH_COMPAT
 181 #define IF_BASH_DOLLAR_SQUOTE       IF_ASH_BASH_COMPAT
 182 #define    BASH_PATTERN_SUBST   ENABLE_ASH_BASH_COMPAT
 183 #define IF_BASH_PATTERN_SUBST       IF_ASH_BASH_COMPAT
 184 #define    BASH_SUBSTR          ENABLE_ASH_BASH_COMPAT
 185 #define IF_BASH_SUBSTR              IF_ASH_BASH_COMPAT
 186 /* [[ EXPR ]] */
 187 #define    BASH_TEST2           (ENABLE_ASH_BASH_COMPAT * ENABLE_ASH_TEST)
 188 #define    BASH_SOURCE          ENABLE_ASH_BASH_COMPAT
 189 #define    BASH_PIPEFAIL        ENABLE_ASH_BASH_COMPAT
 190 #define    BASH_HOSTNAME_VAR    ENABLE_ASH_BASH_COMPAT
 191 #define    BASH_SHLVL_VAR       ENABLE_ASH_BASH_COMPAT
 192
 193 #if defined(__ANDROID_API__) && __ANDROID_API__ <= 24
 194 /* Bionic at least up to version 24 has no glob() */
 195 # undef  ENABLE_ASH_INTERNAL_GLOB
 196 # define ENABLE_ASH_INTERNAL_GLOB 1
 197 #endif
 198
 199 #if !ENABLE_ASH_INTERNAL_GLOB && defined(__UCLIBC__)
 200 # error uClibc glob() is buggy, use ASH_INTERNAL_GLOB.
 201 # error The bug is: for "$PWD"/<pattern> ash will escape e.g. dashes in "$PWD"
 202 # error with backslash, even ones which do not need to be: "/a-b" -> "/a\-b"
 203 # error glob() should unbackslash them and match. uClibc does not unbackslash,
 204 # error fails to match dirname, subsequently not expanding <pattern> in it.
 205 // Testcase:
 206 // if (glob("/etc/polkit\\-1", 0, NULL, &pglob)) - this returns 0 on uclibc, no bug
 207 // if (glob("/etc/polkit\\-1/*", 0, NULL, &pglob)) printf("uclibc bug!\n");
 208 #endif
 209
 210 #if !ENABLE_ASH_INTERNAL_GLOB
 211 # include <glob.h>
 212 #endif
 213
 214 #include "unicode.h"
 215 #include "shell_common.h"
 216 #if ENABLE_FEATURE_SH_MATH
 217 # include "math.h"
 218 #endif
 219 #if ENABLE_ASH_RANDOM_SUPPORT
 220 # include "random.h"
 221 #else
 222 # define CLEAR_RANDOM_T(rnd) ((void)0)
 223 #endif
 224
 225 #include "NUM_APPLETS.h"
 226 #if NUM_APPLETS == 1
 227 /* STANDALONE does not make sense, and won't compile */
 228 # undef CONFIG_FEATURE_SH_STANDALONE
 229 # undef ENABLE_FEATURE_SH_STANDALONE
 230 # undef IF_FEATURE_SH_STANDALONE
 231 # undef IF_NOT_FEATURE_SH_STANDALONE
 232 # define ENABLE_FEATURE_SH_STANDALONE 0
 233 # define IF_FEATURE_SH_STANDALONE(...)
 234 # define IF_NOT_FEATURE_SH_STANDALONE(...) __VA_ARGS__
 235 #endif
 236
 237 #ifndef PIPE_BUF
 238 # define PIPE_BUF 4096           /* amount of buffering in a pipe */
 239 #endif
 240
 241 #if !BB_MMU
 242 # error "Do not even bother, ash will not run on NOMMU machine"
 243 #endif
 244
 245
 246 /* ============ Hash table sizes. Configurable. */
 247
 248 #define VTABSIZE 39
 249 #define ATABSIZE 39
 250 #define CMDTABLESIZE 31         /* should be prime */
 251
 252
 253 /* ============ Shell options */
 254
 255 static const char *const optletters_optnames[] = {
 256         "e"   "errexit",
 257         "f"   "noglob",
 258         "I"   "ignoreeof",
 259         "i"   "interactive",
 260         "m"   "monitor",
 261         "n"   "noexec",
 262         "s"   "stdin",
 263         "x"   "xtrace",
 264         "v"   "verbose",
 265         "C"   "noclobber",
 266         "a"   "allexport",
 267         "b"   "notify",
 268         "u"   "nounset",
 269         "\0"  "vi"
 270 #if BASH_PIPEFAIL
 271         ,"\0"  "pipefail"
 272 #endif
 273 #if DEBUG
 274         ,"\0"  "nolog"
 275         ,"\0"  "debug"
 276 #endif
 277 };
 278
 279 #define optletters(n)  optletters_optnames[n][0]
 280 #define optnames(n)   (optletters_optnames[n] + 1)
 281
 282 enum { NOPTS = ARRAY_SIZE(optletters_optnames) };
 283
 284
 285 /* ============ Misc data */
 286
 287 #define msg_illnum "Illegal number: %s"
 288
 289 /*
 290  * We enclose jmp_buf in a structure so that we can declare pointers to
 291  * jump locations.  The global variable handler contains the location to
 292  * jump to when an exception occurs, and the global variable exception_type
 293  * contains a code identifying the exception.  To implement nested
 294  * exception handlers, the user should save the value of handler on entry
 295  * to an inner scope, set handler to point to a jmploc structure for the
 296  * inner scope, and restore handler on exit from the scope.
 297  */
 298 struct jmploc {
 299         jmp_buf loc;
 300 };
 301
 302 struct globals_misc {
 303         uint8_t exitstatus;     /* exit status of last command */
 304         uint8_t back_exitstatus;/* exit status of backquoted command */
 305         smallint job_warning;   /* user was warned about stopped jobs (can be 2, 1 or 0). */
 306         int rootpid;            /* pid of main shell */
 307         /* shell level: 0 for the main shell, 1 for its children, and so on */
 308         int shlvl;
 309 #define rootshell (!shlvl)
 310         char *minusc;  /* argument to -c option */
 311
 312         char *curdir; // = nullstr;     /* current working directory */
 313         char *physdir; // = nullstr;    /* physical working directory */
 314
 315         char *arg0; /* value of $0 */
 316
 317         struct jmploc *exception_handler;
 318
 319         volatile int suppress_int; /* counter */
 320         volatile /*sig_atomic_t*/ smallint pending_int; /* 1 = got SIGINT */
 321         volatile /*sig_atomic_t*/ smallint got_sigchld; /* 1 = got SIGCHLD */
 322         volatile /*sig_atomic_t*/ smallint pending_sig; /* last pending signal */
 323         smallint exception_type; /* kind of exception (0..5) */
 324         /* exceptions */
 325 #define EXINT 0         /* SIGINT received */
 326 #define EXERROR 1       /* a generic error */
 327 #define EXEXIT 4        /* exit the shell */
 328
 329         smallint isloginsh;
 330         char nullstr[1];        /* zero length string */
 331
 332         char optlist[NOPTS];
 333 #define eflag optlist[0]
 334 #define fflag optlist[1]
 335 #define Iflag optlist[2]
 336 #define iflag optlist[3]
 337 #define mflag optlist[4]
 338 #define nflag optlist[5]
 339 #define sflag optlist[6]
 340 #define xflag optlist[7]
 341 #define vflag optlist[8]
 342 #define Cflag optlist[9]
 343 #define aflag optlist[10]
 344 #define bflag optlist[11]
 345 #define uflag optlist[12]
 346 #define viflag optlist[13]
 347 #if BASH_PIPEFAIL
 348 # define pipefail optlist[14]
 349 #else
 350 # define pipefail 0
 351 #endif
 352 #if DEBUG
 353 # define nolog optlist[14 + BASH_PIPEFAIL]
 354 # define debug optlist[15 + BASH_PIPEFAIL]
 355 #endif
 356
 357         /* trap handler commands */
 358         /*
 359          * Sigmode records the current value of the signal handlers for the various
 360          * modes.  A value of zero means that the current handler is not known.
 361          * S_HARD_IGN indicates that the signal was ignored on entry to the shell.
 362          */
 363         char sigmode[NSIG - 1];
 364 #define S_DFL      1            /* default signal handling (SIG_DFL) */
 365 #define S_CATCH    2            /* signal is caught */
 366 #define S_IGN      3            /* signal is ignored (SIG_IGN) */
 367 #define S_HARD_IGN 4            /* signal is ignored permanently */
 368
 369         /* indicates specified signal received */
 370         uint8_t gotsig[NSIG - 1]; /* offset by 1: "signal" 0 is meaningless */
 371         uint8_t may_have_traps; /* 0: definitely no traps are set, 1: some traps may be set */
 372         char *trap[NSIG];
 373         char **trap_ptr;        /* used only by "trap hack" */
 374
 375         /* Rarely referenced stuff */
 376 #if ENABLE_ASH_RANDOM_SUPPORT
 377         random_t random_gen;
 378 #endif
 379         pid_t backgndpid;        /* pid of last background process */
 380 };
 381 extern struct globals_misc *const ash_ptr_to_globals_misc;
 382 #define G_misc (*ash_ptr_to_globals_misc)
 383 #define exitstatus        (G_misc.exitstatus )
 384 #define back_exitstatus   (G_misc.back_exitstatus )
 385 #define job_warning       (G_misc.job_warning)
 386 #define rootpid     (G_misc.rootpid    )
 387 #define shlvl       (G_misc.shlvl      )
 388 #define minusc      (G_misc.minusc     )
 389 #define curdir      (G_misc.curdir     )
 390 #define physdir     (G_misc.physdir    )
 391 #define arg0        (G_misc.arg0       )
 392 #define exception_handler (G_misc.exception_handler)
 393 #define exception_type    (G_misc.exception_type   )
 394 #define suppress_int      (G_misc.suppress_int     )
 395 #define pending_int       (G_misc.pending_int      )
 396 #define got_sigchld       (G_misc.got_sigchld      )
 397 #define pending_sig       (G_misc.pending_sig      )
 398 #define isloginsh   (G_misc.isloginsh  )
 399 #define nullstr     (G_misc.nullstr    )
 400 #define optlist     (G_misc.optlist    )
 401 #define sigmode     (G_misc.sigmode    )
 402 #define gotsig      (G_misc.gotsig     )
 403 #define may_have_traps    (G_misc.may_have_traps   )
 404 #define trap        (G_misc.trap       )
 405 #define trap_ptr    (G_misc.trap_ptr   )
 406 #define random_gen  (G_misc.random_gen )
 407 #define backgndpid  (G_misc.backgndpid )
 408 #define INIT_G_misc() do { \
 409         (*(struct globals_misc**)&ash_ptr_to_globals_misc) = xzalloc(sizeof(G_misc)); \
 410         barrier(); \
 411         curdir = nullstr; \
 412         physdir = nullstr; \
 413         trap_ptr = trap; \
 414 } while (0)
 415
 416
 417 /* ============ DEBUG */
 418 #if DEBUG
 419 static void trace_printf(const char *fmt, ...);
 420 static void trace_vprintf(const char *fmt, va_list va);
 421 # define TRACE(param)    trace_printf param
 422 # define TRACEV(param)   trace_vprintf param
 423 # define close(fd) do { \
 424         int dfd = (fd); \
 425         if (close(dfd) < 0) \
 426                 bb_error_msg("bug on %d: closing %d(0x%x)", \
 427                         __LINE__, dfd, dfd); \
 428 } while (0)
 429 #else
 430 # define TRACE(param)
 431 # define TRACEV(param)
 432 #endif
 433
 434
 435 /* ============ Utility functions */
 436 #define is_name(c)      ((c) == '_' || isalpha((unsigned char)(c)))
 437 #define is_in_name(c)   ((c) == '_' || isalnum((unsigned char)(c)))
 438
 439 static int
 440 isdigit_str9(const char *str)
 441 {
 442         int maxlen = 9 + 1; /* max 9 digits: 999999999 */
 443         while (--maxlen && isdigit(*str))
 444                 str++;
 445         return (*str == '\0');
 446 }
 447
 448 static const char *
 449 var_end(const char *var)
 450 {
 451         while (*var)
 452                 if (*var++ == '=')
 453                         break;
 454         return var;
 455 }
 456
 457
 458 /* ============ Interrupts / exceptions */
 459
 460 static void exitshell(void) NORETURN;
 461
 462 /*
 463  * These macros allow the user to suspend the handling of interrupt signals
 464  * over a period of time.  This is similar to SIGHOLD or to sigblock, but
 465  * much more efficient and portable.  (But hacking the kernel is so much
 466  * more fun than worrying about efficiency and portability. :-))
 467  */
 468 #if DEBUG_INTONOFF
 469 # define INT_OFF do { \
 470         TRACE(("%s:%d INT_OFF(%d)\n", __func__, __LINE__, suppress_int)); \
 471         suppress_int++; \
 472         barrier(); \
 473 } while (0)
 474 #else
 475 # define INT_OFF do { \
 476         suppress_int++; \
 477         barrier(); \
 478 } while (0)
 479 #endif
 480
 481 /*
 482  * Called to raise an exception.  Since C doesn't include exceptions, we
 483  * just do a longjmp to the exception handler.  The type of exception is
 484  * stored in the global variable "exception_type".
 485  */
 486 static void raise_exception(int) NORETURN;
 487 static void
 488 raise_exception(int e)
 489 {
 490 #if DEBUG
 491         if (exception_handler == NULL)
 492                 abort();
 493 #endif
 494         INT_OFF;
 495         exception_type = e;
 496         longjmp(exception_handler->loc, 1);
 497 }
 498 #if DEBUG
 499 #define raise_exception(e) do { \
 500         TRACE(("raising exception %d on line %d\n", (e), __LINE__)); \
 501         raise_exception(e); \
 502 } while (0)
 503 #endif
 504
 505 /*
 506  * Called when a SIGINT is received.  (If the user specifies
 507  * that SIGINT is to be trapped or ignored using the trap builtin, then
 508  * this routine is not called.)  Suppressint is nonzero when interrupts
 509  * are held using the INT_OFF macro.  (The test for iflag is just
 510  * defensive programming.)
 511  */
 512 static void raise_interrupt(void) NORETURN;
 513 static void
 514 raise_interrupt(void)
 515 {
 516         pending_int = 0;
 517         /* Signal is not automatically unmasked after it is raised,
 518          * do it ourself - unmask all signals */
 519         sigprocmask_allsigs(SIG_UNBLOCK);
 520         /* pending_sig = 0; - now done in signal_handler() */
 521
 522         if (!(rootshell && iflag)) {
 523                 /* Kill ourself with SIGINT */
 524                 signal(SIGINT, SIG_DFL);
 525                 raise(SIGINT);
 526         }
 527         /* bash: ^C even on empty command line sets $? */
 528         exitstatus = SIGINT + 128;
 529         raise_exception(EXINT);
 530         /* NOTREACHED */
 531 }
 532 #if DEBUG
 533 #define raise_interrupt() do { \
 534         TRACE(("raising interrupt on line %d\n", __LINE__)); \
 535         raise_interrupt(); \
 536 } while (0)
 537 #endif
 538
 539 static IF_ASH_OPTIMIZE_FOR_SIZE(inline) void
 540 int_on(void)
 541 {
 542         barrier();
 543         if (--suppress_int == 0 && pending_int) {
 544                 raise_interrupt();
 545         }
 546 }
 547 #if DEBUG_INTONOFF
 548 # define INT_ON do { \
 549         TRACE(("%s:%d INT_ON(%d)\n", __func__, __LINE__, suppress_int-1)); \
 550         int_on(); \
 551 } while (0)
 552 #else
 553 # define INT_ON int_on()
 554 #endif
 555 static IF_ASH_OPTIMIZE_FOR_SIZE(inline) void
 556 force_int_on(void)
 557 {
 558         barrier();
 559         suppress_int = 0;
 560         if (pending_int)
 561                 raise_interrupt();
 562 }
 563 #define FORCE_INT_ON force_int_on()
 564
 565 #define SAVE_INT(v) ((v) = suppress_int)
 566
 567 #define RESTORE_INT(v) do { \
 568         barrier(); \
 569         suppress_int = (v); \
 570         if (suppress_int == 0 && pending_int) \
 571                 raise_interrupt(); \
 572 } while (0)
 573
 574
 575 /* ============ Stdout/stderr output */
 576
 577 static void
 578 outstr(const char *p, FILE *file)
 579 {
 580         INT_OFF;
 581         fputs(p, file);
 582         INT_ON;
 583 }
 584
 585 static void
 586 flush_stdout_stderr(void)
 587 {
 588         INT_OFF;
 589         fflush_all();
 590         INT_ON;
 591 }
 592
 593 /* Was called outcslow(c,FILE*), but c was always '\n' */
 594 static void
 595 newline_and_flush(FILE *dest)
 596 {
 597         INT_OFF;
 598         putc('\n', dest);
 599         fflush(dest);
 600         INT_ON;
 601 }
 602
 603 static int out1fmt(const char *, ...) __attribute__((__format__(__printf__,1,2)));
 604 static int
 605 out1fmt(const char *fmt, ...)
 606 {
 607         va_list ap;
 608         int r;
 609
 610         INT_OFF;
 611         va_start(ap, fmt);
 612         r = vprintf(fmt, ap);
 613         va_end(ap);
 614         INT_ON;
 615         return r;
 616 }
 617
 618 static int fmtstr(char *, size_t, const char *, ...) __attribute__((__format__(__printf__,3,4)));
 619 static int
 620 fmtstr(char *outbuf, size_t length, const char *fmt, ...)
 621 {
 622         va_list ap;
 623         int ret;
 624
 625         va_start(ap, fmt);
 626         INT_OFF;
 627         ret = vsnprintf(outbuf, length, fmt, ap);
 628         va_end(ap);
 629         INT_ON;
 630         return ret;
 631 }
 632
 633 static void
 634 out1str(const char *p)
 635 {
 636         outstr(p, stdout);
 637 }
 638
 639 static void
 640 out2str(const char *p)
 641 {
 642         outstr(p, stderr);
 643         flush_stdout_stderr();
 644 }
 645
 646
 647 /* ============ Parser structures */
 648
 649 /* control characters in argument strings */
 650 #define CTL_FIRST CTLESC
 651 #define CTLESC       ((unsigned char)'\201')    /* escape next character */
 652 #define CTLVAR       ((unsigned char)'\202')    /* variable defn */
 653 #define CTLENDVAR    ((unsigned char)'\203')
 654 #define CTLBACKQ     ((unsigned char)'\204')
 655 #define CTLARI       ((unsigned char)'\206')    /* arithmetic expression */
 656 #define CTLENDARI    ((unsigned char)'\207')
 657 #define CTLQUOTEMARK ((unsigned char)'\210')
 658 #define CTL_LAST CTLQUOTEMARK
 659
 660 /* variable substitution byte (follows CTLVAR) */
 661 #define VSTYPE  0x0f            /* type of variable substitution */
 662 #define VSNUL   0x10            /* colon--treat the empty string as unset */
 663
 664 /* values of VSTYPE field */
 665 #define VSNORMAL        0x1     /* normal variable:  $var or ${var} */
 666 #define VSMINUS         0x2     /* ${var-text} */
 667 #define VSPLUS          0x3     /* ${var+text} */
 668 #define VSQUESTION      0x4     /* ${var?message} */
 669 #define VSASSIGN        0x5     /* ${var=text} */
 670 #define VSTRIMRIGHT     0x6     /* ${var%pattern} */
 671 #define VSTRIMRIGHTMAX  0x7     /* ${var%%pattern} */
 672 #define VSTRIMLEFT      0x8     /* ${var#pattern} */
 673 #define VSTRIMLEFTMAX   0x9     /* ${var##pattern} */
 674 #define VSLENGTH        0xa     /* ${#var} */
 675 #if BASH_SUBSTR
 676 #define VSSUBSTR        0xc     /* ${var:position:length} */
 677 #endif
 678 #if BASH_PATTERN_SUBST
 679 #define VSREPLACE       0xd     /* ${var/pattern/replacement} */
 680 #define VSREPLACEALL    0xe     /* ${var//pattern/replacement} */
 681 #endif
 682
 683 static const char dolatstr[] ALIGN1 = {
 684         CTLQUOTEMARK, CTLVAR, VSNORMAL, '@', '=', CTLQUOTEMARK, '\0'
 685 };
 686 #define DOLATSTRLEN 6
 687
 688 #define NCMD      0
 689 #define NPIPE     1
 690 #define NREDIR    2
 691 #define NBACKGND  3
 692 #define NSUBSHELL 4
 693 #define NAND      5
 694 #define NOR       6
 695 #define NSEMI     7
 696 #define NIF       8
 697 #define NWHILE    9
 698 #define NUNTIL   10
 699 #define NFOR     11
 700 #define NCASE    12
 701 #define NCLIST   13
 702 #define NDEFUN   14
 703 #define NARG     15
 704 #define NTO      16
 705 #if BASH_REDIR_OUTPUT
 706 #define NTO2     17
 707 #endif
 708 #define NCLOBBER 18
 709 #define NFROM    19
 710 #define NFROMTO  20
 711 #define NAPPEND  21
 712 #define NTOFD    22
 713 #define NFROMFD  23
 714 #define NHERE    24
 715 #define NXHERE   25
 716 #define NNOT     26
 717 #define N_NUMBER 27
 718
 719 union node;
 720
 721 struct ncmd {
 722         smallint type; /* Nxxxx */
 723         union node *assign;
 724         union node *args;
 725         union node *redirect;
 726 };
 727
 728 struct npipe {
 729         smallint type;
 730         smallint pipe_backgnd;
 731         struct nodelist *cmdlist;
 732 };
 733
 734 struct nredir {
 735         smallint type;
 736         union node *n;
 737         union node *redirect;
 738 };
 739
 740 struct nbinary {
 741         smallint type;
 742         union node *ch1;
 743         union node *ch2;
 744 };
 745
 746 struct nif {
 747         smallint type;
 748         union node *test;
 749         union node *ifpart;
 750         union node *elsepart;
 751 };
 752
 753 struct nfor {
 754         smallint type;
 755         union node *args;
 756         union node *body;
 757         char *var;
 758 };
 759
 760 struct ncase {
 761         smallint type;
 762         union node *expr;
 763         union node *cases;
 764 };
 765
 766 struct nclist {
 767         smallint type;
 768         union node *next;
 769         union node *pattern;
 770         union node *body;
 771 };
 772
 773 struct narg {
 774         smallint type;
 775         union node *next;
 776         char *text;
 777         struct nodelist *backquote;
 778 };
 779
 780 /* nfile and ndup layout must match!
 781  * NTOFD (>&fdnum) uses ndup structure, but we may discover mid-flight
 782  * that it is actually NTO2 (>&file), and change its type.
 783  */
 784 struct nfile {
 785         smallint type;
 786         union node *next;
 787         int fd;
 788         int _unused_dupfd;
 789         union node *fname;
 790         char *expfname;
 791 };
 792
 793 struct ndup {
 794         smallint type;
 795         union node *next;
 796         int fd;
 797         int dupfd;
 798         union node *vname;
 799         char *_unused_expfname;
 800 };
 801
 802 struct nhere {
 803         smallint type;
 804         union node *next;
 805         int fd;
 806         union node *doc;
 807 };
 808
 809 struct nnot {
 810         smallint type;
 811         union node *com;
 812 };
 813
 814 union node {
 815         smallint type;
 816         struct ncmd ncmd;
 817         struct npipe npipe;
 818         struct nredir nredir;
 819         struct nbinary nbinary;
 820         struct nif nif;
 821         struct nfor nfor;
 822         struct ncase ncase;
 823         struct nclist nclist;
 824         struct narg narg;
 825         struct nfile nfile;
 826         struct ndup ndup;
 827         struct nhere nhere;
 828         struct nnot nnot;
 829 };
 830
 831 /*
 832  * NODE_EOF is returned by parsecmd when it encounters an end of file.
 833  * It must be distinct from NULL.
 834  */
 835 #define NODE_EOF ((union node *) -1L)
 836
 837 struct nodelist {
 838         struct nodelist *next;
 839         union node *n;
 840 };
 841
 842 struct funcnode {
 843         int count;
 844         union node n;
 845 };
 846
 847 /*
 848  * Free a parse tree.
 849  */
 850 static void
 851 freefunc(struct funcnode *f)
 852 {
 853         if (f && --f->count < 0)
 854                 free(f);
 855 }
 856
 857
 858 /* ============ Debugging output */
 859
 860 #if DEBUG
 861
 862 static FILE *tracefile;
 863
 864 static void
 865 trace_printf(const char *fmt, ...)
 866 {
 867         va_list va;
 868
 869         if (debug != 1)
 870                 return;
 871         if (DEBUG_TIME)
 872                 fprintf(tracefile, "%u ", (int) time(NULL));
 873         if (DEBUG_PID)
 874                 fprintf(tracefile, "[%u] ", (int) getpid());
 875         if (DEBUG_SIG)
 876                 fprintf(tracefile, "pending s:%d i:%d(supp:%d) ", pending_sig, pending_int, suppress_int);
 877         va_start(va, fmt);
 878         vfprintf(tracefile, fmt, va);
 879         va_end(va);
 880 }
 881
 882 static void
 883 trace_vprintf(const char *fmt, va_list va)
 884 {
 885         if (debug != 1)
 886                 return;
 887         vfprintf(tracefile, fmt, va);
 888         fprintf(tracefile, "\n");
 889 }
 890
 891 static void
 892 trace_puts(const char *s)
 893 {
 894         if (debug != 1)
 895                 return;
 896         fputs(s, tracefile);
 897 }
 898
 899 static void
 900 trace_puts_quoted(char *s)
 901 {
 902         char *p;
 903         char c;
 904
 905         if (debug != 1)
 906                 return;
 907         putc('"', tracefile);
 908         for (p = s; *p; p++) {
 909                 switch ((unsigned char)*p) {
 910                 case '\n': c = 'n'; goto backslash;
 911                 case '\t': c = 't'; goto backslash;
 912                 case '\r': c = 'r'; goto backslash;
 913                 case '\"': c = '\"'; goto backslash;
 914                 case '\\': c = '\\'; goto backslash;
 915                 case CTLESC: c = 'e'; goto backslash;
 916                 case CTLVAR: c = 'v'; goto backslash;
 917                 case CTLBACKQ: c = 'q'; goto backslash;
 918  backslash:
 919                         putc('\\', tracefile);
 920                         putc(c, tracefile);
 921                         break;
 922                 default:
 923                         if (*p >= ' ' && *p <= '~')
 924                                 putc(*p, tracefile);
 925                         else {
 926                                 putc('\\', tracefile);
 927                                 putc((*p >> 6) & 03, tracefile);
 928                                 putc((*p >> 3) & 07, tracefile);
 929                                 putc(*p & 07, tracefile);
 930                         }
 931                         break;
 932                 }
 933         }
 934         putc('"', tracefile);
 935 }
 936
 937 static void
 938 trace_puts_args(char **ap)
 939 {
 940         if (debug != 1)
 941                 return;
 942         if (!*ap)
 943                 return;
 944         while (1) {
 945                 trace_puts_quoted(*ap);
 946                 if (!*++ap) {
 947                         putc('\n', tracefile);
 948                         break;
 949                 }
 950                 putc(' ', tracefile);
 951         }
 952 }
 953
 954 static void
 955 opentrace(void)
 956 {
 957         char s[100];
 958 #ifdef O_APPEND
 959         int flags;
 960 #endif
 961
 962         if (debug != 1) {
 963                 if (tracefile)
 964                         fflush(tracefile);
 965                 /* leave open because libedit might be using it */
 966                 return;
 967         }
 968         strcpy(s, "./trace");
 969         if (tracefile) {
 970                 if (!freopen(s, "a", tracefile)) {
 971                         fprintf(stderr, "Can't re-open %s\n", s);
 972                         debug = 0;
 973                         return;
 974                 }
 975         } else {
 976                 tracefile = fopen(s, "a");
 977                 if (tracefile == NULL) {
 978                         fprintf(stderr, "Can't open %s\n", s);
 979                         debug = 0;
 980                         return;
 981                 }
 982         }
 983 #ifdef O_APPEND
 984         flags = fcntl(fileno(tracefile), F_GETFL);
 985         if (flags >= 0)
 986                 fcntl(fileno(tracefile), F_SETFL, flags | O_APPEND);
 987 #endif
 988         setlinebuf(tracefile);
 989         fputs("\nTracing started.\n", tracefile);
 990 }
 991
 992 static void
 993 indent(int amount, char *pfx, FILE *fp)
 994 {
 995         int i;
 996
 997         for (i = 0; i < amount; i++) {
 998                 if (pfx && i == amount - 1)
 999                         fputs(pfx, fp);
1000                 putc('\t', fp);
1001         }
1002 }
1003
1004 /* little circular references here... */
1005 static void shtree(union node *n, int ind, char *pfx, FILE *fp);
1006
1007 static void
1008 sharg(union node *arg, FILE *fp)
1009 {
1010         char *p;
1011         struct nodelist *bqlist;
1012         unsigned char subtype;
1013
1014         if (arg->type != NARG) {
1015                 out1fmt("<node type %d>\n", arg->type);
1016                 abort();
1017         }
1018         bqlist = arg->narg.backquote;
1019         for (p = arg->narg.text; *p; p++) {
1020                 switch ((unsigned char)*p) {
1021                 case CTLESC:
1022                         p++;
1023                         putc(*p, fp);
1024                         break;
1025                 case CTLVAR:
1026                         putc('$', fp);
1027                         putc('{', fp);
1028                         subtype = *++p;
1029                         if (subtype == VSLENGTH)
1030                                 putc('#', fp);
1031
1032                         while (*p != '=') {
1033                                 putc(*p, fp);
1034                                 p++;
1035                         }
1036
1037                         if (subtype & VSNUL)
1038                                 putc(':', fp);
1039
1040                         switch (subtype & VSTYPE) {
1041                         case VSNORMAL:
1042                                 putc('}', fp);
1043                                 break;
1044                         case VSMINUS:
1045                                 putc('-', fp);
1046                                 break;
1047                         case VSPLUS:
1048                                 putc('+', fp);
1049                                 break;
1050                         case VSQUESTION:
1051                                 putc('?', fp);
1052                                 break;
1053                         case VSASSIGN:
1054                                 putc('=', fp);
1055                                 break;
1056                         case VSTRIMLEFT:
1057                                 putc('#', fp);
1058                                 break;
1059                         case VSTRIMLEFTMAX:
1060                                 putc('#', fp);
1061                                 putc('#', fp);
1062                                 break;
1063                         case VSTRIMRIGHT:
1064                                 putc('%', fp);
1065                                 break;
1066                         case VSTRIMRIGHTMAX:
1067                                 putc('%', fp);
1068                                 putc('%', fp);
1069                                 break;
1070                         case VSLENGTH:
1071                                 break;
1072                         default:
1073                                 out1fmt("<subtype %d>", subtype);
1074                         }
1075                         break;
1076                 case CTLENDVAR:
1077                         putc('}', fp);
1078                         break;
1079                 case CTLBACKQ:
1080                         putc('$', fp);
1081                         putc('(', fp);
1082                         shtree(bqlist->n, -1, NULL, fp);
1083                         putc(')', fp);
1084                         break;
1085                 default:
1086                         putc(*p, fp);
1087                         break;
1088                 }
1089         }
1090 }
1091
1092 static void
1093 shcmd(union node *cmd, FILE *fp)
1094 {
1095         union node *np;
1096         int first;
1097         const char *s;
1098         int dftfd;
1099
1100         first = 1;
1101         for (np = cmd->ncmd.args; np; np = np->narg.next) {
1102                 if (!first)
1103                         putc(' ', fp);
1104                 sharg(np, fp);
1105                 first = 0;
1106         }
1107         for (np = cmd->ncmd.redirect; np; np = np->nfile.next) {
1108                 if (!first)
1109                         putc(' ', fp);
1110                 dftfd = 0;
1111                 switch (np->nfile.type) {
1112                 case NTO:      s = ">>"+1; dftfd = 1; break;
1113                 case NCLOBBER: s = ">|"; dftfd = 1; break;
1114                 case NAPPEND:  s = ">>"; dftfd = 1; break;
1115 #if BASH_REDIR_OUTPUT
1116                 case NTO2:
1117 #endif
1118                 case NTOFD:    s = ">&"; dftfd = 1; break;
1119                 case NFROM:    s = "<"; break;
1120                 case NFROMFD:  s = "<&"; break;
1121                 case NFROMTO:  s = "<>"; break;
1122                 default:       s = "*error*"; break;
1123                 }
1124                 if (np->nfile.fd != dftfd)
1125                         fprintf(fp, "%d", np->nfile.fd);
1126                 fputs(s, fp);
1127                 if (np->nfile.type == NTOFD || np->nfile.type == NFROMFD) {
1128                         fprintf(fp, "%d", np->ndup.dupfd);
1129                 } else {
1130                         sharg(np->nfile.fname, fp);
1131                 }
1132                 first = 0;
1133         }
1134 }
1135
1136 static void
1137 shtree(union node *n, int ind, char *pfx, FILE *fp)
1138 {
1139         struct nodelist *lp;
1140         const char *s;
1141
1142         if (n == NULL)
1143                 return;
1144
1145         indent(ind, pfx, fp);
1146
1147         if (n == NODE_EOF) {
1148                 fputs("<EOF>", fp);
1149                 return;
1150         }
1151
1152         switch (n->type) {
1153         case NSEMI:
1154                 s = "; ";
1155                 goto binop;
1156         case NAND:
1157                 s = " && ";
1158                 goto binop;
1159         case NOR:
1160                 s = " || ";
1161  binop:
1162                 shtree(n->nbinary.ch1, ind, NULL, fp);
1163                 /* if (ind < 0) */
1164                         fputs(s, fp);
1165                 shtree(n->nbinary.ch2, ind, NULL, fp);
1166                 break;
1167         case NCMD:
1168                 shcmd(n, fp);
1169                 if (ind >= 0)
1170                         putc('\n', fp);
1171                 break;
1172         case NPIPE:
1173                 for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
1174                         shtree(lp->n, 0, NULL, fp);
1175                         if (lp->next)
1176                                 fputs(" | ", fp);
1177                 }
1178                 if (n->npipe.pipe_backgnd)
1179                         fputs(" &", fp);
1180                 if (ind >= 0)
1181                         putc('\n', fp);
1182                 break;
1183         default:
1184                 fprintf(fp, "<node type %d>", n->type);
1185                 if (ind >= 0)
1186                         putc('\n', fp);
1187                 break;
1188         }
1189 }
1190
1191 static void
1192 showtree(union node *n)
1193 {
1194         trace_puts("showtree called\n");
1195         shtree(n, 1, NULL, stderr);
1196 }
1197
1198 #endif /* DEBUG */
1199
1200
1201 /* ============ Parser data */
1202
1203 /*
1204  * ash_vmsg() needs parsefile->fd, hence parsefile definition is moved up.
1205  */
1206 struct strlist {
1207         struct strlist *next;
1208         char *text;
1209 };
1210
1211 struct alias;
1212
1213 struct strpush {
1214         struct strpush *prev;   /* preceding string on stack */
1215         char *prev_string;
1216         int prev_left_in_line;
1217 #if ENABLE_ASH_ALIAS
1218         struct alias *ap;       /* if push was associated with an alias */
1219 #endif
1220         char *string;           /* remember the string since it may change */
1221
1222         /* Remember last two characters for pungetc. */
1223         int lastc[2];
1224
1225         /* Number of outstanding calls to pungetc. */
1226         int unget;
1227 };
1228
1229 struct parsefile {
1230         struct parsefile *prev; /* preceding file on stack */
1231         int linno;              /* current line */
1232         int pf_fd;              /* file descriptor (or -1 if string) */
1233         int left_in_line;       /* number of chars left in this line */
1234         int left_in_buffer;     /* number of chars left in this buffer past the line */
1235         char *next_to_pgetc;    /* next char in buffer */
1236         char *buf;              /* input buffer */
1237         struct strpush *strpush; /* for pushing strings at this level */
1238         struct strpush basestrpush; /* so pushing one is fast */
1239
1240         /* Remember last two characters for pungetc. */
1241         int lastc[2];
1242
1243         /* Number of outstanding calls to pungetc. */
1244         int unget;
1245 };
1246
1247 static struct parsefile basepf;        /* top level input file */
1248 static struct parsefile *g_parsefile = &basepf;  /* current input file */
1249 static int startlinno;                 /* line # where last token started */
1250 static char *commandname;              /* currently executing command */
1251 static struct strlist *cmdenviron;     /* environment for builtin command */
1252
1253
1254 /* ============ Message printing */
1255
1256 static void
1257 ash_vmsg(const char *msg, va_list ap)
1258 {
1259         fprintf(stderr, "%s: ", arg0);
1260         if (commandname) {
1261                 if (strcmp(arg0, commandname))
1262                         fprintf(stderr, "%s: ", commandname);
1263                 if (!iflag || g_parsefile->pf_fd > 0)
1264                         fprintf(stderr, "line %d: ", startlinno);
1265         }
1266         vfprintf(stderr, msg, ap);
1267         newline_and_flush(stderr);
1268 }
1269
1270 /*
1271  * Exverror is called to raise the error exception.  If the second argument
1272  * is not NULL then error prints an error message using printf style
1273  * formatting.  It then raises the error exception.
1274  */
1275 static void ash_vmsg_and_raise(int, const char *, va_list) NORETURN;
1276 static void
1277 ash_vmsg_and_raise(int cond, const char *msg, va_list ap)
1278 {
1279 #if DEBUG
1280         if (msg) {
1281                 TRACE(("ash_vmsg_and_raise(%d):", cond));
1282                 TRACEV((msg, ap));
1283         } else
1284                 TRACE(("ash_vmsg_and_raise(%d):NULL\n", cond));
1285         if (msg)
1286 #endif
1287                 ash_vmsg(msg, ap);
1288
1289         flush_stdout_stderr();
1290         raise_exception(cond);
1291         /* NOTREACHED */
1292 }
1293
1294 static void ash_msg_and_raise_error(const char *, ...) NORETURN;
1295 static void
1296 ash_msg_and_raise_error(const char *msg, ...)
1297 {
1298         va_list ap;
1299
1300         exitstatus = 2;
1301
1302         va_start(ap, msg);
1303         ash_vmsg_and_raise(EXERROR, msg, ap);
1304         /* NOTREACHED */
1305         va_end(ap);
1306 }
1307
1308 static void raise_error_syntax(const char *) NORETURN;
1309 static void
1310 raise_error_syntax(const char *msg)
1311 {
1312         ash_msg_and_raise_error("syntax error: %s", msg);
1313         /* NOTREACHED */
1314 }
1315
1316 static void ash_msg_and_raise(int, const char *, ...) NORETURN;
1317 static void
1318 ash_msg_and_raise(int cond, const char *msg, ...)
1319 {
1320         va_list ap;
1321
1322         va_start(ap, msg);
1323         ash_vmsg_and_raise(cond, msg, ap);
1324         /* NOTREACHED */
1325         va_end(ap);
1326 }
1327
1328 /*
1329  * error/warning routines for external builtins
1330  */
1331 static void
1332 ash_msg(const char *fmt, ...)
1333 {
1334         va_list ap;
1335
1336         va_start(ap, fmt);
1337         ash_vmsg(fmt, ap);
1338         va_end(ap);
1339 }
1340
1341 /*
1342  * Return a string describing an error.  The returned string may be a
1343  * pointer to a static buffer that will be overwritten on the next call.
1344  * Action describes the operation that got the error.
1345  */
1346 static const char *
1347 errmsg(int e, const char *em)
1348 {
1349         if (e == ENOENT || e == ENOTDIR) {
1350                 return em;
1351         }
1352         return strerror(e);
1353 }
1354
1355
1356 /* ============ Memory allocation */
1357
1358 #if 0
1359 /* I consider these wrappers nearly useless:
1360  * ok, they return you to nearest exception handler, but
1361  * how much memory do you leak in the process, making
1362  * memory starvation worse?
1363  */
1364 static void *
1365 ckrealloc(void * p, size_t nbytes)
1366 {
1367         p = realloc(p, nbytes);
1368         if (!p)
1369                 ash_msg_and_raise_error(bb_msg_memory_exhausted);
1370         return p;
1371 }
1372
1373 static void *
1374 ckmalloc(size_t nbytes)
1375 {
1376         return ckrealloc(NULL, nbytes);
1377 }
1378
1379 static void *
1380 ckzalloc(size_t nbytes)
1381 {
1382         return memset(ckmalloc(nbytes), 0, nbytes);
1383 }
1384
1385 static char *
1386 ckstrdup(const char *s)
1387 {
1388         char *p = strdup(s);
1389         if (!p)
1390                 ash_msg_and_raise_error(bb_msg_memory_exhausted);
1391         return p;
1392 }
1393 #else
1394 /* Using bbox equivalents. They exit if out of memory */
1395 # define ckrealloc xrealloc
1396 # define ckmalloc  xmalloc
1397 # define ckzalloc  xzalloc
1398 # define ckstrdup  xstrdup
1399 #endif
1400
1401 /*
1402  * It appears that grabstackstr() will barf with such alignments
1403  * because stalloc() will return a string allocated in a new stackblock.
1404  */
1405 #define SHELL_ALIGN(nbytes) (((nbytes) + SHELL_SIZE) & ~SHELL_SIZE)
1406 enum {
1407         /* Most machines require the value returned from malloc to be aligned
1408          * in some way.  The following macro will get this right
1409          * on many machines.  */
1410         SHELL_SIZE = sizeof(union { int i; char *cp; double d; }) - 1,
1411         /* Minimum size of a block */
1412         MINSIZE = SHELL_ALIGN(504),
1413 };
1414
1415 struct stack_block {
1416         struct stack_block *prev;
1417         char space[MINSIZE];
1418 };
1419
1420 struct stackmark {
1421         struct stack_block *stackp;
1422         char *stacknxt;
1423         size_t stacknleft;
1424 };
1425
1426
1427 struct globals_memstack {
1428         struct stack_block *g_stackp; // = &stackbase;
1429         char *g_stacknxt; // = stackbase.space;
1430         char *sstrend; // = stackbase.space + MINSIZE;
1431         size_t g_stacknleft; // = MINSIZE;
1432         struct stack_block stackbase;
1433 };
1434 extern struct globals_memstack *const ash_ptr_to_globals_memstack;
1435 #define G_memstack (*ash_ptr_to_globals_memstack)
1436 #define g_stackp     (G_memstack.g_stackp    )
1437 #define g_stacknxt   (G_memstack.g_stacknxt  )
1438 #define sstrend      (G_memstack.sstrend     )
1439 #define g_stacknleft (G_memstack.g_stacknleft)
1440 #define stackbase    (G_memstack.stackbase   )
1441 #define INIT_G_memstack() do { \
1442         (*(struct globals_memstack**)&ash_ptr_to_globals_memstack) = xzalloc(sizeof(G_memstack)); \
1443         barrier(); \
1444         g_stackp = &stackbase; \
1445         g_stacknxt = stackbase.space; \
1446         g_stacknleft = MINSIZE; \
1447         sstrend = stackbase.space + MINSIZE; \
1448 } while (0)
1449
1450
1451 #define stackblock()     ((void *)g_stacknxt)
1452 #define stackblocksize() g_stacknleft
1453
1454 /*
1455  * Parse trees for commands are allocated in lifo order, so we use a stack
1456  * to make this more efficient, and also to avoid all sorts of exception
1457  * handling code to handle interrupts in the middle of a parse.
1458  *
1459  * The size 504 was chosen because the Ultrix malloc handles that size
1460  * well.
1461  */
1462 static void *
1463 stalloc(size_t nbytes)
1464 {
1465         char *p;
1466         size_t aligned;
1467
1468         aligned = SHELL_ALIGN(nbytes);
1469         if (aligned > g_stacknleft) {
1470                 size_t len;
1471                 size_t blocksize;
1472                 struct stack_block *sp;
1473
1474                 blocksize = aligned;
1475                 if (blocksize < MINSIZE)
1476                         blocksize = MINSIZE;
1477                 len = sizeof(struct stack_block) - MINSIZE + blocksize;
1478                 if (len < blocksize)
1479                         ash_msg_and_raise_error(bb_msg_memory_exhausted);
1480                 INT_OFF;
1481                 sp = ckmalloc(len);
1482                 sp->prev = g_stackp;
1483                 g_stacknxt = sp->space;
1484                 g_stacknleft = blocksize;
1485                 sstrend = g_stacknxt + blocksize;
1486                 g_stackp = sp;
1487                 INT_ON;
1488         }
1489         p = g_stacknxt;
1490         g_stacknxt += aligned;
1491         g_stacknleft -= aligned;
1492         return p;
1493 }
1494
1495 static void *
1496 stzalloc(size_t nbytes)
1497 {
1498         return memset(stalloc(nbytes), 0, nbytes);
1499 }
1500
1501 static void
1502 stunalloc(void *p)
1503 {
1504 #if DEBUG
1505         if (!p || (g_stacknxt < (char *)p) || ((char *)p < g_stackp->space)) {
1506                 write(STDERR_FILENO, "stunalloc\n", 10);
1507                 abort();
1508         }
1509 #endif
1510         g_stacknleft += g_stacknxt - (char *)p;
1511         g_stacknxt = p;
1512 }
1513
1514 /*
1515  * Like strdup but works with the ash stack.
1516  */
1517 static char *
1518 sstrdup(const char *p)
1519 {
1520         size_t len = strlen(p) + 1;
1521         return memcpy(stalloc(len), p, len);
1522 }
1523
1524 static inline void
1525 grabstackblock(size_t len)
1526 {
1527         stalloc(len);
1528 }
1529
1530 static void
1531 pushstackmark(struct stackmark *mark, size_t len)
1532 {
1533         mark->stackp = g_stackp;
1534         mark->stacknxt = g_stacknxt;
1535         mark->stacknleft = g_stacknleft;
1536         grabstackblock(len);
1537 }
1538
1539 static void
1540 setstackmark(struct stackmark *mark)
1541 {
1542         pushstackmark(mark, g_stacknxt == g_stackp->space && g_stackp != &stackbase);
1543 }
1544
1545 static void
1546 popstackmark(struct stackmark *mark)
1547 {
1548         struct stack_block *sp;
1549
1550         if (!mark->stackp)
1551                 return;
1552
1553         INT_OFF;
1554         while (g_stackp != mark->stackp) {
1555                 sp = g_stackp;
1556                 g_stackp = sp->prev;
1557                 free(sp);
1558         }
1559         g_stacknxt = mark->stacknxt;
1560         g_stacknleft = mark->stacknleft;
1561         sstrend = mark->stacknxt + mark->stacknleft;
1562         INT_ON;
1563 }
1564
1565 /*
1566  * When the parser reads in a string, it wants to stick the string on the
1567  * stack and only adjust the stack pointer when it knows how big the
1568  * string is.  Stackblock (defined in stack.h) returns a pointer to a block
1569  * of space on top of the stack and stackblocklen returns the length of
1570  * this block.  Growstackblock will grow this space by at least one byte,
1571  * possibly moving it (like realloc).  Grabstackblock actually allocates the
1572  * part of the block that has been used.
1573  */
1574 static void
1575 growstackblock(void)
1576 {
1577         size_t newlen;
1578
1579         newlen = g_stacknleft * 2;
1580         if (newlen < g_stacknleft)
1581                 ash_msg_and_raise_error(bb_msg_memory_exhausted);
1582         if (newlen < 128)
1583                 newlen += 128;
1584
1585         if (g_stacknxt == g_stackp->space && g_stackp != &stackbase) {
1586                 struct stack_block *sp;
1587                 struct stack_block *prevstackp;
1588                 size_t grosslen;
1589
1590                 INT_OFF;
1591                 sp = g_stackp;
1592                 prevstackp = sp->prev;
1593                 grosslen = newlen + sizeof(struct stack_block) - MINSIZE;
1594                 sp = ckrealloc(sp, grosslen);
1595                 sp->prev = prevstackp;
1596                 g_stackp = sp;
1597                 g_stacknxt = sp->space;
1598                 g_stacknleft = newlen;
1599                 sstrend = sp->space + newlen;
1600                 INT_ON;
1601         } else {
1602                 char *oldspace = g_stacknxt;
1603                 size_t oldlen = g_stacknleft;
1604                 char *p = stalloc(newlen);
1605
1606                 /* free the space we just allocated */
1607                 g_stacknxt = memcpy(p, oldspace, oldlen);
1608                 g_stacknleft += newlen;
1609         }
1610 }
1611
1612 /*
1613  * The following routines are somewhat easier to use than the above.
1614  * The user declares a variable of type STACKSTR, which may be declared
1615  * to be a register.  The macro STARTSTACKSTR initializes things.  Then
1616  * the user uses the macro STPUTC to add characters to the string.  In
1617  * effect, STPUTC(c, p) is the same as *p++ = c except that the stack is
1618  * grown as necessary.  When the user is done, she can just leave the
1619  * string there and refer to it using stackblock().  Or she can allocate
1620  * the space for it using grabstackstr().  If it is necessary to allow
1621  * someone else to use the stack temporarily and then continue to grow
1622  * the string, the user should use grabstack to allocate the space, and
1623  * then call ungrabstr(p) to return to the previous mode of operation.
1624  *
1625  * USTPUTC is like STPUTC except that it doesn't check for overflow.
1626  * CHECKSTACKSPACE can be called before USTPUTC to ensure that there
1627  * is space for at least one character.
1628  */
1629 static void *
1630 growstackstr(void)
1631 {
1632         size_t len = stackblocksize();
1633         growstackblock();
1634         return (char *)stackblock() + len;
1635 }
1636
1637 /*
1638  * Called from CHECKSTRSPACE.
1639  */
1640 static char *
1641 makestrspace(size_t newlen, char *p)
1642 {
1643         size_t len = p - g_stacknxt;
1644         size_t size;
1645
1646         for (;;) {
1647                 size_t nleft;
1648
1649                 size = stackblocksize();
1650                 nleft = size - len;
1651                 if (nleft >= newlen)
1652                         break;
1653                 growstackblock();
1654         }
1655         return (char *)stackblock() + len;
1656 }
1657
1658 static char *
1659 stack_nputstr(const char *s, size_t n, char *p)
1660 {
1661         p = makestrspace(n, p);
1662         p = (char *)memcpy(p, s, n) + n;
1663         return p;
1664 }
1665
1666 static char *
1667 stack_putstr(const char *s, char *p)
1668 {
1669         return stack_nputstr(s, strlen(s), p);
1670 }
1671
1672 static char *
1673 _STPUTC(int c, char *p)
1674 {
1675         if (p == sstrend)
1676                 p = growstackstr();
1677         *p++ = c;
1678         return p;
1679 }
1680
1681 #define STARTSTACKSTR(p)        ((p) = stackblock())
1682 #define STPUTC(c, p)            ((p) = _STPUTC((c), (p)))
1683 #define CHECKSTRSPACE(n, p) do { \
1684         char *q = (p); \
1685         size_t l = (n); \
1686         size_t m = sstrend - q; \
1687         if (l > m) \
1688                 (p) = makestrspace(l, q); \
1689 } while (0)
1690 #define USTPUTC(c, p)           (*(p)++ = (c))
1691 #define STACKSTRNUL(p) do { \
1692         if ((p) == sstrend) \
1693                 (p) = growstackstr(); \
1694         *(p) = '\0'; \
1695 } while (0)
1696 #define STUNPUTC(p)             (--(p))
1697 #define STTOPC(p)               ((p)[-1])
1698 #define STADJUST(amount, p)     ((p) += (amount))
1699
1700 #define grabstackstr(p)         stalloc((char *)(p) - (char *)stackblock())
1701 #define ungrabstackstr(s, p)    stunalloc(s)
1702 #define stackstrend()           ((void *)sstrend)
1703
1704
1705 /* ============ String helpers */
1706
1707 /*
1708  * prefix -- see if pfx is a prefix of string.
1709  */
1710 static char *
1711 prefix(const char *string, const char *pfx)
1712 {
1713         while (*pfx) {
1714                 if (*pfx++ != *string++)
1715                         return NULL;
1716         }
1717         return (char *) string;
1718 }
1719
1720 /*
1721  * Check for a valid number.  This should be elsewhere.
1722  */
1723 static int
1724 is_number(const char *p)
1725 {
1726         do {
1727                 if (!isdigit(*p))
1728                         return 0;
1729         } while (*++p != '\0');
1730         return 1;
1731 }
1732
1733 /*
1734  * Convert a string of digits to an integer, printing an error message on
1735  * failure.
1736  */
1737 static int
1738 number(const char *s)
1739 {
1740         if (!is_number(s))
1741                 ash_msg_and_raise_error(msg_illnum, s);
1742         return atoi(s);
1743 }
1744
1745 /*
1746  * Produce a possibly single quoted string suitable as input to the shell.
1747  * The return string is allocated on the stack.
1748  */
1749 static char *
1750 single_quote(const char *s)
1751 {
1752         char *p;
1753
1754         STARTSTACKSTR(p);
1755
1756         do {
1757                 char *q;
1758                 size_t len;
1759
1760                 len = strchrnul(s, '\'') - s;
1761
1762                 q = p = makestrspace(len + 3, p);
1763
1764                 *q++ = '\'';
1765                 q = (char *)memcpy(q, s, len) + len;
1766                 *q++ = '\'';
1767                 s += len;
1768
1769                 STADJUST(q - p, p);
1770
1771                 if (*s != '\'')
1772                         break;
1773                 len = 0;
1774                 do len++; while (*++s == '\'');
1775
1776                 q = p = makestrspace(len + 3, p);
1777
1778                 *q++ = '"';
1779                 q = (char *)memcpy(q, s - len, len) + len;
1780                 *q++ = '"';
1781
1782                 STADJUST(q - p, p);
1783         } while (*s);
1784
1785         USTPUTC('\0', p);
1786
1787         return stackblock();
1788 }
1789
1790
1791 /* ============ nextopt */
1792
1793 static char **argptr;                  /* argument list for builtin commands */
1794 static char *optionarg;                /* set by nextopt (like getopt) */
1795 static char *optptr;                   /* used by nextopt */
1796
1797 /*
1798  * XXX - should get rid of. Have all builtins use getopt(3).
1799  * The library getopt must have the BSD extension static variable
1800  * "optreset", otherwise it can't be used within the shell safely.
1801  *
1802  * Standard option processing (a la getopt) for builtin routines.
1803  * The only argument that is passed to nextopt is the option string;
1804  * the other arguments are unnecessary. It returns the character,
1805  * or '\0' on end of input.
1806  */
1807 static int
1808 nextopt(const char *optstring)
1809 {
1810         char *p;
1811         const char *q;
1812         char c;
1813
1814         p = optptr;
1815         if (p == NULL || *p == '\0') {
1816                 /* We ate entire "-param", take next one */
1817                 p = *argptr;
1818                 if (p == NULL)
1819                         return '\0';
1820                 if (*p != '-')
1821                         return '\0';
1822                 if (*++p == '\0') /* just "-" ? */
1823                         return '\0';
1824                 argptr++;
1825                 if (LONE_DASH(p)) /* "--" ? */
1826                         return '\0';
1827                 /* p => next "-param" */
1828         }
1829         /* p => some option char in the middle of a "-param" */
1830         c = *p++;
1831         for (q = optstring; *q != c;) {
1832                 if (*q == '\0')
1833                         ash_msg_and_raise_error("illegal option -%c", c);
1834                 if (*++q == ':')
1835                         q++;
1836         }
1837         if (*++q == ':') {
1838                 if (*p == '\0') {
1839                         p = *argptr++;
1840                         if (p == NULL)
1841                                 ash_msg_and_raise_error("no arg for -%c option", c);
1842                 }
1843                 optionarg = p;
1844                 p = NULL;
1845         }
1846         optptr = p;
1847         return c;
1848 }
1849
1850
1851 /* ============ Shell variables */
1852
1853 /*
1854  * The parsefile structure pointed to by the global variable parsefile
1855  * contains information about the current file being read.
1856  */
1857 struct shparam {
1858         int nparam;             /* # of positional parameters (without $0) */
1859 #if ENABLE_ASH_GETOPTS
1860         int optind;             /* next parameter to be processed by getopts */
1861         int optoff;             /* used by getopts */
1862 #endif
1863         unsigned char malloced; /* if parameter list dynamically allocated */
1864         char **p;               /* parameter list */
1865 };
1866
1867 /*
1868  * Free the list of positional parameters.
1869  */
1870 static void
1871 freeparam(volatile struct shparam *param)
1872 {
1873         if (param->malloced) {
1874                 char **ap, **ap1;
1875                 ap = ap1 = param->p;
1876                 while (*ap)
1877                         free(*ap++);
1878                 free(ap1);
1879         }
1880 }
1881
1882 #if ENABLE_ASH_GETOPTS
1883 static void FAST_FUNC getoptsreset(const char *value);
1884 #endif
1885
1886 struct var {
1887         struct var *next;               /* next entry in hash list */
1888         int flags;                      /* flags are defined above */
1889         const char *var_text;           /* name=value */
1890         void (*var_func)(const char *) FAST_FUNC; /* function to be called when  */
1891                                         /* the variable gets set/unset */
1892 };
1893
1894 struct localvar {
1895         struct localvar *next;          /* next local variable in list */
1896         struct var *vp;                 /* the variable that was made local */
1897         int flags;                      /* saved flags */
1898         const char *text;               /* saved text */
1899 };
1900
1901 /* flags */
1902 #define VEXPORT         0x01    /* variable is exported */
1903 #define VREADONLY       0x02    /* variable cannot be modified */
1904 #define VSTRFIXED       0x04    /* variable struct is statically allocated */
1905 #define VTEXTFIXED      0x08    /* text is statically allocated */
1906 #define VSTACK          0x10    /* text is allocated on the stack */
1907 #define VUNSET          0x20    /* the variable is not set */
1908 #define VNOFUNC         0x40    /* don't call the callback function */
1909 #define VNOSET          0x80    /* do not set variable - just readonly test */
1910 #define VNOSAVE         0x100   /* when text is on the heap before setvareq */
1911 #if ENABLE_ASH_RANDOM_SUPPORT
1912 # define VDYNAMIC       0x200   /* dynamic variable */
1913 #else
1914 # define VDYNAMIC       0
1915 #endif
1916
1917
1918 /* Need to be before varinit_data[] */
1919 #if ENABLE_LOCALE_SUPPORT
1920 static void FAST_FUNC
1921 change_lc_all(const char *value)
1922 {
1923         if (value && *value != '\0')
1924                 setlocale(LC_ALL, value);
1925 }
1926 static void FAST_FUNC
1927 change_lc_ctype(const char *value)
1928 {
1929         if (value && *value != '\0')
1930                 setlocale(LC_CTYPE, value);
1931 }
1932 #endif
1933 #if ENABLE_ASH_MAIL
1934 static void chkmail(void);
1935 static void changemail(const char *var_value) FAST_FUNC;
1936 #else
1937 # define chkmail()  ((void)0)
1938 #endif
1939 static void changepath(const char *) FAST_FUNC;
1940 #if ENABLE_ASH_RANDOM_SUPPORT
1941 static void change_random(const char *) FAST_FUNC;
1942 #endif
1943
1944 static const struct {
1945         int flags;
1946         const char *var_text;
1947         void (*var_func)(const char *) FAST_FUNC;
1948 } varinit_data[] = {
1949         /*
1950          * Note: VEXPORT would not work correctly here for NOFORK applets:
1951          * some environment strings may be constant.
1952          */
1953         { VSTRFIXED|VTEXTFIXED       , defifsvar   , NULL            },
1954 #if ENABLE_ASH_MAIL
1955         { VSTRFIXED|VTEXTFIXED|VUNSET, "MAIL"      , changemail      },
1956         { VSTRFIXED|VTEXTFIXED|VUNSET, "MAILPATH"  , changemail      },
1957 #endif
1958         { VSTRFIXED|VTEXTFIXED       , bb_PATH_root_path, changepath },
1959         { VSTRFIXED|VTEXTFIXED       , "PS1=$ "    , NULL            },
1960         { VSTRFIXED|VTEXTFIXED       , "PS2=> "    , NULL            },
1961         { VSTRFIXED|VTEXTFIXED       , "PS4=+ "    , NULL            },
1962 #if ENABLE_ASH_GETOPTS
1963         { VSTRFIXED|VTEXTFIXED       , defoptindvar, getoptsreset    },
1964 #endif
1965 #if ENABLE_ASH_RANDOM_SUPPORT
1966         { VSTRFIXED|VTEXTFIXED|VUNSET|VDYNAMIC, "RANDOM", change_random },
1967 #endif
1968 #if ENABLE_LOCALE_SUPPORT
1969         { VSTRFIXED|VTEXTFIXED|VUNSET, "LC_ALL"    , change_lc_all   },
1970         { VSTRFIXED|VTEXTFIXED|VUNSET, "LC_CTYPE"  , change_lc_ctype },
1971 #endif
1972 #if ENABLE_FEATURE_EDITING_SAVEHISTORY
1973         { VSTRFIXED|VTEXTFIXED|VUNSET, "HISTFILE"  , NULL            },
1974 #endif
1975 };
1976
1977 struct redirtab;
1978
1979 struct globals_var {
1980         struct shparam shellparam;      /* $@ current positional parameters */
1981         struct redirtab *redirlist;
1982         int preverrout_fd;   /* save fd2 before print debug if xflag is set. */
1983         struct var *vartab[VTABSIZE];
1984         struct var varinit[ARRAY_SIZE(varinit_data)];
1985 };
1986 extern struct globals_var *const ash_ptr_to_globals_var;
1987 #define G_var (*ash_ptr_to_globals_var)
1988 #define shellparam    (G_var.shellparam   )
1989 //#define redirlist     (G_var.redirlist    )
1990 #define preverrout_fd (G_var.preverrout_fd)
1991 #define vartab        (G_var.vartab       )
1992 #define varinit       (G_var.varinit      )
1993 #define INIT_G_var() do { \
1994         unsigned i; \
1995         (*(struct globals_var**)&ash_ptr_to_globals_var) = xzalloc(sizeof(G_var)); \
1996         barrier(); \
1997         for (i = 0; i < ARRAY_SIZE(varinit_data); i++) { \
1998                 varinit[i].flags    = varinit_data[i].flags; \
1999                 varinit[i].var_text = varinit_data[i].var_text; \
2000                 varinit[i].var_func = varinit_data[i].var_func; \
2001         } \
2002 } while (0)
2003
2004 #define vifs      varinit[0]
2005 #if ENABLE_ASH_MAIL
2006 # define vmail    (&vifs)[1]
2007 # define vmpath   (&vmail)[1]
2008 # define vpath    (&vmpath)[1]
2009 #else
2010 # define vpath    (&vifs)[1]
2011 #endif
2012 #define vps1      (&vpath)[1]
2013 #define vps2      (&vps1)[1]
2014 #define vps4      (&vps2)[1]
2015 #if ENABLE_ASH_GETOPTS
2016 # define voptind  (&vps4)[1]
2017 # if ENABLE_ASH_RANDOM_SUPPORT
2018 #  define vrandom (&voptind)[1]
2019 # endif
2020 #else
2021 # if ENABLE_ASH_RANDOM_SUPPORT
2022 #  define vrandom (&vps4)[1]
2023 # endif
2024 #endif
2025
2026 /*
2027  * The following macros access the values of the above variables.
2028  * They have to skip over the name.  They return the null string
2029  * for unset variables.
2030  */
2031 #define ifsval()        (vifs.var_text + 4)
2032 #define ifsset()        ((vifs.flags & VUNSET) == 0)
2033 #if ENABLE_ASH_MAIL
2034 # define mailval()      (vmail.var_text + 5)
2035 # define mpathval()     (vmpath.var_text + 9)
2036 # define mpathset()     ((vmpath.flags & VUNSET) == 0)
2037 #endif
2038 #define pathval()       (vpath.var_text + 5)
2039 #define ps1val()        (vps1.var_text + 4)
2040 #define ps2val()        (vps2.var_text + 4)
2041 #define ps4val()        (vps4.var_text + 4)
2042 #if ENABLE_ASH_GETOPTS
2043 # define optindval()    (voptind.var_text + 7)
2044 #endif
2045
2046 #if ENABLE_ASH_GETOPTS
2047 static void FAST_FUNC
2048 getoptsreset(const char *value)
2049 {
2050         shellparam.optind = number(value) ?: 1;
2051         shellparam.optoff = -1;
2052 }
2053 #endif
2054
2055 /*
2056  * Compares two strings up to the first = or '\0'.  The first
2057  * string must be terminated by '='; the second may be terminated by
2058  * either '=' or '\0'.
2059  */
2060 static int
2061 varcmp(const char *p, const char *q)
2062 {
2063         int c, d;
2064
2065         while ((c = *p) == (d = *q)) {
2066                 if (c == '\0' || c == '=')
2067                         goto out;
2068                 p++;
2069                 q++;
2070         }
2071         if (c == '=')
2072                 c = '\0';
2073         if (d == '=')
2074                 d = '\0';
2075  out:
2076         return c - d;
2077 }
2078
2079 /*
2080  * Find the appropriate entry in the hash table from the name.
2081  */
2082 static struct var **
2083 hashvar(const char *p)
2084 {
2085         unsigned hashval;
2086
2087         hashval = ((unsigned char) *p) << 4;
2088         while (*p && *p != '=')
2089                 hashval += (unsigned char) *p++;
2090         return &vartab[hashval % VTABSIZE];
2091 }
2092
2093 static int
2094 vpcmp(const void *a, const void *b)
2095 {
2096         return varcmp(*(const char **)a, *(const char **)b);
2097 }
2098
2099 /*
2100  * This routine initializes the builtin variables.
2101  */
2102 static void
2103 initvar(void)
2104 {
2105         struct var *vp;
2106         struct var *end;
2107         struct var **vpp;
2108
2109         /*
2110          * PS1 depends on uid
2111          */
2112 #if ENABLE_FEATURE_EDITING && ENABLE_FEATURE_EDITING_FANCY_PROMPT
2113         vps1.var_text = "PS1=\\w \\$ ";
2114 #else
2115         if (!geteuid())
2116                 vps1.var_text = "PS1=# ";
2117 #endif
2118         vp = varinit;
2119         end = vp + ARRAY_SIZE(varinit);
2120         do {
2121                 vpp = hashvar(vp->var_text);
2122                 vp->next = *vpp;
2123                 *vpp = vp;
2124         } while (++vp < end);
2125 }
2126
2127 static struct var **
2128 findvar(struct var **vpp, const char *name)
2129 {
2130         for (; *vpp; vpp = &(*vpp)->next) {
2131                 if (varcmp((*vpp)->var_text, name) == 0) {
2132                         break;
2133                 }
2134         }
2135         return vpp;
2136 }
2137
2138 /*
2139  * Find the value of a variable.  Returns NULL if not set.
2140  */
2141 static const char* FAST_FUNC
2142 lookupvar(const char *name)
2143 {
2144         struct var *v;
2145
2146         v = *findvar(hashvar(name), name);
2147         if (v) {
2148 #if ENABLE_ASH_RANDOM_SUPPORT
2149         /*
2150          * Dynamic variables are implemented roughly the same way they are
2151          * in bash. Namely, they're "special" so long as they aren't unset.
2152          * As soon as they're unset, they're no longer dynamic, and dynamic
2153          * lookup will no longer happen at that point. -- PFM.
2154          */
2155                 if (v->flags & VDYNAMIC)
2156                         v->var_func(NULL);
2157 #endif
2158                 if (!(v->flags & VUNSET))
2159                         return var_end(v->var_text);
2160         }
2161         return NULL;
2162 }
2163
2164 #if ENABLE_UNICODE_SUPPORT
2165 static void
2166 reinit_unicode_for_ash(void)
2167 {
2168         /* Unicode support should be activated even if LANG is set
2169          * _during_ shell execution, not only if it was set when
2170          * shell was started. Therefore, re-check LANG every time:
2171          */
2172         if (ENABLE_FEATURE_CHECK_UNICODE_IN_ENV
2173          || ENABLE_UNICODE_USING_LOCALE
2174         ) {
2175                 const char *s = lookupvar("LC_ALL");
2176                 if (!s) s = lookupvar("LC_CTYPE");
2177                 if (!s) s = lookupvar("LANG");
2178                 reinit_unicode(s);
2179         }
2180 }
2181 #else
2182 # define reinit_unicode_for_ash() ((void)0)
2183 #endif
2184
2185 /*
2186  * Search the environment of a builtin command.
2187  */
2188 static const char *
2189 bltinlookup(const char *name)
2190 {
2191         struct strlist *sp;
2192
2193         for (sp = cmdenviron; sp; sp = sp->next) {
2194                 if (varcmp(sp->text, name) == 0)
2195                         return var_end(sp->text);
2196         }
2197         return lookupvar(name);
2198 }
2199
2200 /*
2201  * Same as setvar except that the variable and value are passed in
2202  * the first argument as name=value.  Since the first argument will
2203  * be actually stored in the table, it should not be a string that
2204  * will go away.
2205  * Called with interrupts off.
2206  */
2207 static void
2208 setvareq(char *s, int flags)
2209 {
2210         struct var *vp, **vpp;
2211
2212         vpp = hashvar(s);
2213         flags |= (VEXPORT & (((unsigned) (1 - aflag)) - 1));
2214         vp = *findvar(vpp, s);
2215         if (vp) {
2216                 if ((vp->flags & (VREADONLY|VDYNAMIC)) == VREADONLY) {
2217                         const char *n;
2218
2219                         if (flags & VNOSAVE)
2220                                 free(s);
2221                         n = vp->var_text;
2222                         exitstatus = 1;
2223                         ash_msg_and_raise_error("%.*s: is read only", strchrnul(n, '=') - n, n);
2224                 }
2225
2226                 if (flags & VNOSET)
2227                         return;
2228
2229                 if (vp->var_func && !(flags & VNOFUNC))
2230                         vp->var_func(var_end(s));
2231
2232                 if (!(vp->flags & (VTEXTFIXED|VSTACK)))
2233                         free((char*)vp->var_text);
2234
2235                 flags |= vp->flags & ~(VTEXTFIXED|VSTACK|VNOSAVE|VUNSET);
2236         } else {
2237                 /* variable s is not found */
2238                 if (flags & VNOSET)
2239                         return;
2240                 vp = ckzalloc(sizeof(*vp));
2241                 vp->next = *vpp;
2242                 /*vp->func = NULL; - ckzalloc did it */
2243                 *vpp = vp;
2244         }
2245         if (!(flags & (VTEXTFIXED|VSTACK|VNOSAVE)))
2246                 s = ckstrdup(s);
2247         vp->var_text = s;
2248         vp->flags = flags;
2249 }
2250
2251 /*
2252  * Set the value of a variable.  The flags argument is ored with the
2253  * flags of the variable.  If val is NULL, the variable is unset.
2254  */
2255 static void
2256 setvar(const char *name, const char *val, int flags)
2257 {
2258         const char *q;
2259         char *p;
2260         char *nameeq;
2261         size_t namelen;
2262         size_t vallen;
2263
2264         q = endofname(name);
2265         p = strchrnul(q, '=');
2266         namelen = p - name;
2267         if (!namelen || p != q)
2268                 ash_msg_and_raise_error("%.*s: bad variable name", namelen, name);
2269         vallen = 0;
2270         if (val == NULL) {
2271                 flags |= VUNSET;
2272         } else {
2273                 vallen = strlen(val);
2274         }
2275
2276         INT_OFF;
2277         nameeq = ckmalloc(namelen + vallen + 2);
2278         p = memcpy(nameeq, name, namelen) + namelen;
2279         if (val) {
2280                 *p++ = '=';
2281                 p = memcpy(p, val, vallen) + vallen;
2282         }
2283         *p = '\0';
2284         setvareq(nameeq, flags | VNOSAVE);
2285         INT_ON;
2286 }
2287
2288 static void FAST_FUNC
2289 setvar0(const char *name, const char *val)
2290 {
2291         setvar(name, val, 0);
2292 }
2293
2294 /*
2295  * Unset the specified variable.
2296  */
2297 static int
2298 unsetvar(const char *s)
2299 {
2300         struct var **vpp;
2301         struct var *vp;
2302         int retval;
2303
2304         vpp = findvar(hashvar(s), s);
2305         vp = *vpp;
2306         retval = 2;
2307         if (vp) {
2308                 int flags = vp->flags;
2309
2310                 retval = 1;
2311                 if (flags & VREADONLY)
2312                         goto out;
2313 #if ENABLE_ASH_RANDOM_SUPPORT
2314                 vp->flags &= ~VDYNAMIC;
2315 #endif
2316                 if (flags & VUNSET)
2317                         goto ok;
2318                 if ((flags & VSTRFIXED) == 0) {
2319                         INT_OFF;
2320                         if ((flags & (VTEXTFIXED|VSTACK)) == 0)
2321                                 free((char*)vp->var_text);
2322                         *vpp = vp->next;
2323                         free(vp);
2324                         INT_ON;
2325                 } else {
2326                         setvar0(s, NULL);
2327                         vp->flags &= ~VEXPORT;
2328                 }
2329  ok:
2330                 retval = 0;
2331         }
2332  out:
2333         return retval;
2334 }
2335
2336 /*
2337  * Process a linked list of variable assignments.
2338  */
2339 static void
2340 listsetvar(struct strlist *list_set_var, int flags)
2341 {
2342         struct strlist *lp = list_set_var;
2343
2344         if (!lp)
2345                 return;
2346         INT_OFF;
2347         do {
2348                 setvareq(lp->text, flags);
2349                 lp = lp->next;
2350         } while (lp);
2351         INT_ON;
2352 }
2353
2354 /*
2355  * Generate a list of variables satisfying the given conditions.
2356  */
2357 static char **
2358 listvars(int on, int off, char ***end)
2359 {
2360         struct var **vpp;
2361         struct var *vp;
2362         char **ep;
2363         int mask;
2364
2365         STARTSTACKSTR(ep);
2366         vpp = vartab;
2367         mask = on | off;
2368         do {
2369                 for (vp = *vpp; vp; vp = vp->next) {
2370                         if ((vp->flags & mask) == on) {
2371                                 if (ep == stackstrend())
2372                                         ep = growstackstr();
2373                                 *ep++ = (char*)vp->var_text;
2374                         }
2375                 }
2376         } while (++vpp < vartab + VTABSIZE);
2377         if (ep == stackstrend())
2378                 ep = growstackstr();
2379         if (end)
2380                 *end = ep;
2381         *ep++ = NULL;
2382         return grabstackstr(ep);
2383 }
2384
2385
2386 /* ============ Path search helper
2387  *
2388  * The variable path (passed by reference) should be set to the start
2389  * of the path before the first call; path_advance will update
2390  * this value as it proceeds.  Successive calls to path_advance will return
2391  * the possible path expansions in sequence.  If an option (indicated by
2392  * a percent sign) appears in the path entry then the global variable
2393  * pathopt will be set to point to it; otherwise pathopt will be set to
2394  * NULL.
2395  */
2396 static const char *pathopt;     /* set by path_advance */
2397
2398 static char *
2399 path_advance(const char **path, const char *name)
2400 {
2401         const char *p;
2402         char *q;
2403         const char *start;
2404         size_t len;
2405
2406         if (*path == NULL)
2407                 return NULL;
2408         start = *path;
2409         for (p = start; *p && *p != ':' && *p != '%'; p++)
2410                 continue;
2411         len = p - start + strlen(name) + 2;     /* "2" is for '/' and '\0' */
2412         while (stackblocksize() < len)
2413                 growstackblock();
2414         q = stackblock();
2415         if (p != start) {
2416                 memcpy(q, start, p - start);
2417                 q += p - start;
2418                 *q++ = '/';
2419         }
2420         strcpy(q, name);
2421         pathopt = NULL;
2422         if (*p == '%') {
2423                 pathopt = ++p;
2424                 while (*p && *p != ':')
2425                         p++;
2426         }
2427         if (*p == ':')
2428                 *path = p + 1;
2429         else
2430                 *path = NULL;
2431         return stalloc(len);
2432 }
2433
2434
2435 /* ============ Prompt */
2436
2437 static smallint doprompt;                   /* if set, prompt the user */
2438 static smallint needprompt;                 /* true if interactive and at start of line */
2439
2440 #if ENABLE_FEATURE_EDITING
2441 static line_input_t *line_input_state;
2442 static const char *cmdedit_prompt;
2443 static void
2444 putprompt(const char *s)
2445 {
2446         if (ENABLE_ASH_EXPAND_PRMT) {
2447                 free((char*)cmdedit_prompt);
2448                 cmdedit_prompt = ckstrdup(s);
2449                 return;
2450         }
2451         cmdedit_prompt = s;
2452 }
2453 #else
2454 static void
2455 putprompt(const char *s)
2456 {
2457         out2str(s);
2458 }
2459 #endif
2460
2461 /* expandstr() needs parsing machinery, so it is far away ahead... */
2462 static const char *expandstr(const char *ps);
2463
2464 static void
2465 setprompt_if(smallint do_set, int whichprompt)
2466 {
2467         const char *prompt;
2468         IF_ASH_EXPAND_PRMT(struct stackmark smark;)
2469
2470         if (!do_set)
2471                 return;
2472
2473         needprompt = 0;
2474
2475         switch (whichprompt) {
2476         case 1:
2477                 prompt = ps1val();
2478                 break;
2479         case 2:
2480                 prompt = ps2val();
2481                 break;
2482         default:                        /* 0 */
2483                 prompt = nullstr;
2484         }
2485 #if ENABLE_ASH_EXPAND_PRMT
2486         pushstackmark(&smark, stackblocksize());
2487 #endif
2488         putprompt(expandstr(prompt));
2489 #if ENABLE_ASH_EXPAND_PRMT
2490         popstackmark(&smark);
2491 #endif
2492 }
2493
2494
2495 /* ============ The cd and pwd commands */
2496
2497 #define CD_PHYSICAL 1
2498 #define CD_PRINT 2
2499
2500 static int
2501 cdopt(void)
2502 {
2503         int flags = 0;
2504         int i, j;
2505
2506         j = 'L';
2507         while ((i = nextopt("LP")) != '\0') {
2508                 if (i != j) {
2509                         flags ^= CD_PHYSICAL;
2510                         j = i;
2511                 }
2512         }
2513
2514         return flags;
2515 }
2516
2517 /*
2518  * Update curdir (the name of the current directory) in response to a
2519  * cd command.
2520  */
2521 static const char *
2522 updatepwd(const char *dir)
2523 {
2524         char *new;
2525         char *p;
2526         char *cdcomppath;
2527         const char *lim;
2528
2529         cdcomppath = sstrdup(dir);
2530         STARTSTACKSTR(new);
2531         if (*dir != '/') {
2532                 if (curdir == nullstr)
2533                         return 0;
2534                 new = stack_putstr(curdir, new);
2535         }
2536         new = makestrspace(strlen(dir) + 2, new);
2537         lim = (char *)stackblock() + 1;
2538         if (*dir != '/') {
2539                 if (new[-1] != '/')
2540                         USTPUTC('/', new);
2541                 if (new > lim && *lim == '/')
2542                         lim++;
2543         } else {
2544                 USTPUTC('/', new);
2545                 cdcomppath++;
2546                 if (dir[1] == '/' && dir[2] != '/') {
2547                         USTPUTC('/', new);
2548                         cdcomppath++;
2549                         lim++;
2550                 }
2551         }
2552         p = strtok(cdcomppath, "/");
2553         while (p) {
2554                 switch (*p) {
2555                 case '.':
2556                         if (p[1] == '.' && p[2] == '\0') {
2557                                 while (new > lim) {
2558                                         STUNPUTC(new);
2559                                         if (new[-1] == '/')
2560                                                 break;
2561                                 }
2562                                 break;
2563                         }
2564                         if (p[1] == '\0')
2565                                 break;
2566                         /* fall through */
2567                 default:
2568                         new = stack_putstr(p, new);
2569                         USTPUTC('/', new);
2570                 }
2571                 p = strtok(NULL, "/");
2572         }
2573         if (new > lim)
2574                 STUNPUTC(new);
2575         *new = 0;
2576         return stackblock();
2577 }
2578
2579 /*
2580  * Find out what the current directory is. If we already know the current
2581  * directory, this routine returns immediately.
2582  */
2583 static char *
2584 getpwd(void)
2585 {
2586         char *dir = getcwd(NULL, 0); /* huh, using glibc extension? */
2587         return dir ? dir : nullstr;
2588 }
2589
2590 static void
2591 setpwd(const char *val, int setold)
2592 {
2593         char *oldcur, *dir;
2594
2595         oldcur = dir = curdir;
2596
2597         if (setold) {
2598                 setvar("OLDPWD", oldcur, VEXPORT);
2599         }
2600         INT_OFF;
2601         if (physdir != nullstr) {
2602                 if (physdir != oldcur)
2603                         free(physdir);
2604                 physdir = nullstr;
2605         }
2606         if (oldcur == val || !val) {
2607                 char *s = getpwd();
2608                 physdir = s;
2609                 if (!val)
2610                         dir = s;
2611         } else
2612                 dir = ckstrdup(val);
2613         if (oldcur != dir && oldcur != nullstr) {
2614                 free(oldcur);
2615         }
2616         curdir = dir;
2617         INT_ON;
2618         setvar("PWD", dir, VEXPORT);
2619 }
2620
2621 static void hashcd(void);
2622
2623 /*
2624  * Actually do the chdir.  We also call hashcd to let other routines
2625  * know that the current directory has changed.
2626  */
2627 static int
2628 docd(const char *dest, int flags)
2629 {
2630         const char *dir = NULL;
2631         int err;
2632
2633         TRACE(("docd(\"%s\", %d) called\n", dest, flags));
2634
2635         INT_OFF;
2636         if (!(flags & CD_PHYSICAL)) {
2637                 dir = updatepwd(dest);
2638                 if (dir)
2639                         dest = dir;
2640         }
2641         err = chdir(dest);
2642         if (err)
2643                 goto out;
2644         setpwd(dir, 1);
2645         hashcd();
2646  out:
2647         INT_ON;
2648         return err;
2649 }
2650
2651 static int FAST_FUNC
2652 cdcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
2653 {
2654         const char *dest;
2655         const char *path;
2656         const char *p;
2657         char c;
2658         struct stat statb;
2659         int flags;
2660
2661         flags = cdopt();
2662         dest = *argptr;
2663         if (!dest)
2664                 dest = bltinlookup("HOME");
2665         else if (LONE_DASH(dest)) {
2666                 dest = bltinlookup("OLDPWD");
2667                 flags |= CD_PRINT;
2668         }
2669         if (!dest)
2670                 dest = nullstr;
2671         if (*dest == '/')
2672                 goto step6;
2673         if (*dest == '.') {
2674                 c = dest[1];
2675  dotdot:
2676                 switch (c) {
2677                 case '\0':
2678                 case '/':
2679                         goto step6;
2680                 case '.':
2681                         c = dest[2];
2682                         if (c != '.')
2683                                 goto dotdot;
2684                 }
2685         }
2686         if (!*dest)
2687                 dest = ".";
2688         path = bltinlookup("CDPATH");
2689         while (path) {
2690                 c = *path;
2691                 p = path_advance(&path, dest);
2692                 if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) {
2693                         if (c && c != ':')
2694                                 flags |= CD_PRINT;
2695  docd:
2696                         if (!docd(p, flags))
2697                                 goto out;
2698                         goto err;
2699                 }
2700         }
2701
2702  step6:
2703         p = dest;
2704         goto docd;
2705
2706  err:
2707         ash_msg_and_raise_error("can't cd to %s", dest);
2708         /* NOTREACHED */
2709  out:
2710         if (flags & CD_PRINT)
2711                 out1fmt("%s\n", curdir);
2712         return 0;
2713 }
2714
2715 static int FAST_FUNC
2716 pwdcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
2717 {
2718         int flags;
2719         const char *dir = curdir;
2720
2721         flags = cdopt();
2722         if (flags) {
2723                 if (physdir == nullstr)
2724                         setpwd(dir, 0);
2725                 dir = physdir;
2726         }
2727         out1fmt("%s\n", dir);
2728         return 0;
2729 }
2730
2731
2732 /* ============ ... */
2733
2734
2735 #define IBUFSIZ (ENABLE_FEATURE_EDITING ? CONFIG_FEATURE_EDITING_MAX_LEN : 1024)
2736
2737 /* Syntax classes */
2738 #define CWORD     0             /* character is nothing special */
2739 #define CNL       1             /* newline character */
2740 #define CBACK     2             /* a backslash character */
2741 #define CSQUOTE   3             /* single quote */
2742 #define CDQUOTE   4             /* double quote */
2743 #define CENDQUOTE 5             /* a terminating quote */
2744 #define CBQUOTE   6             /* backwards single quote */
2745 #define CVAR      7             /* a dollar sign */
2746 #define CENDVAR   8             /* a '}' character */
2747 #define CLP       9             /* a left paren in arithmetic */
2748 #define CRP      10             /* a right paren in arithmetic */
2749 #define CENDFILE 11             /* end of file */
2750 #define CCTL     12             /* like CWORD, except it must be escaped */
2751 #define CSPCL    13             /* these terminate a word */
2752 #define CIGN     14             /* character should be ignored */
2753
2754 #define PEOF     256
2755 #if ENABLE_ASH_ALIAS
2756 # define PEOA    257
2757 #endif
2758
2759 #define USE_SIT_FUNCTION ENABLE_ASH_OPTIMIZE_FOR_SIZE
2760
2761 #if ENABLE_FEATURE_SH_MATH
2762 # define SIT_ITEM(a,b,c,d) (a | (b << 4) | (c << 8) | (d << 12))
2763 #else
2764 # define SIT_ITEM(a,b,c,d) (a | (b << 4) | (c << 8))
2765 #endif
2766 static const uint16_t S_I_T[] ALIGN2 = {
2767 #if ENABLE_ASH_ALIAS
2768         SIT_ITEM(CSPCL   , CIGN     , CIGN , CIGN   ),    /* 0, PEOA */
2769 #endif
2770         SIT_ITEM(CSPCL   , CWORD    , CWORD, CWORD  ),    /* 1, ' ' */
2771         SIT_ITEM(CNL     , CNL      , CNL  , CNL    ),    /* 2, \n */
2772         SIT_ITEM(CWORD   , CCTL     , CCTL , CWORD  ),    /* 3, !*-/:=?[]~ */
2773         SIT_ITEM(CDQUOTE , CENDQUOTE, CWORD, CWORD  ),    /* 4, '"' */
2774         SIT_ITEM(CVAR    , CVAR     , CWORD, CVAR   ),    /* 5, $ */
2775         SIT_ITEM(CSQUOTE , CWORD    , CENDQUOTE, CWORD),  /* 6, "'" */
2776         SIT_ITEM(CSPCL   , CWORD    , CWORD, CLP    ),    /* 7, ( */
2777         SIT_ITEM(CSPCL   , CWORD    , CWORD, CRP    ),    /* 8, ) */
2778         SIT_ITEM(CBACK   , CBACK    , CCTL , CBACK  ),    /* 9, \ */
2779         SIT_ITEM(CBQUOTE , CBQUOTE  , CWORD, CBQUOTE),    /* 10, ` */
2780         SIT_ITEM(CENDVAR , CENDVAR  , CWORD, CENDVAR),    /* 11, } */
2781 #if !USE_SIT_FUNCTION
2782         SIT_ITEM(CENDFILE, CENDFILE , CENDFILE, CENDFILE),/* 12, PEOF */
2783         SIT_ITEM(CWORD   , CWORD    , CWORD, CWORD  ),    /* 13, 0-9A-Za-z */
2784         SIT_ITEM(CCTL    , CCTL     , CCTL , CCTL   )     /* 14, CTLESC ... */
2785 #endif
2786 #undef SIT_ITEM
2787 };
2788 /* Constants below must match table above */
2789 enum {
2790 #if ENABLE_ASH_ALIAS
2791         CSPCL_CIGN_CIGN_CIGN               , /*  0 */
2792 #endif
2793         CSPCL_CWORD_CWORD_CWORD            , /*  1 */
2794         CNL_CNL_CNL_CNL                    , /*  2 */
2795         CWORD_CCTL_CCTL_CWORD              , /*  3 */
2796         CDQUOTE_CENDQUOTE_CWORD_CWORD      , /*  4 */
2797         CVAR_CVAR_CWORD_CVAR               , /*  5 */
2798         CSQUOTE_CWORD_CENDQUOTE_CWORD      , /*  6 */
2799         CSPCL_CWORD_CWORD_CLP              , /*  7 */
2800         CSPCL_CWORD_CWORD_CRP              , /*  8 */
2801         CBACK_CBACK_CCTL_CBACK             , /*  9 */
2802         CBQUOTE_CBQUOTE_CWORD_CBQUOTE      , /* 10 */
2803         CENDVAR_CENDVAR_CWORD_CENDVAR      , /* 11 */
2804         CENDFILE_CENDFILE_CENDFILE_CENDFILE, /* 12 */
2805         CWORD_CWORD_CWORD_CWORD            , /* 13 */
2806         CCTL_CCTL_CCTL_CCTL                , /* 14 */
2807 };
2808
2809 /* c in SIT(c, syntax) must be an *unsigned char* or PEOA or PEOF,
2810  * caller must ensure proper cast on it if c is *char_ptr!
2811  */
2812 /* Values for syntax param */
2813 #define BASESYNTAX 0    /* not in quotes */
2814 #define DQSYNTAX   1    /* in double quotes */
2815 #define SQSYNTAX   2    /* in single quotes */
2816 #define ARISYNTAX  3    /* in arithmetic */
2817 #define PSSYNTAX   4    /* prompt. never passed to SIT() */
2818
2819 #if USE_SIT_FUNCTION
2820
2821 static int
2822 SIT(int c, int syntax)
2823 {
2824         /* Used to also have '/' in this string: "\t\n !\"$&'()*-/:;<=>?[\\]`|}~" */
2825         static const char spec_symbls[] ALIGN1 = "\t\n !\"$&'()*-:;<=>?[\\]`|}~";
2826         /*
2827          * This causes '/' to be prepended with CTLESC in dquoted string,
2828          * making "./file"* treated incorrectly because we feed
2829          * ".\/file*" string to glob(), confusing it (see expandmeta func).
2830          * The "homegrown" glob implementation is okay with that,
2831          * but glibc one isn't. With '/' always treated as CWORD,
2832          * both work fine.
2833          */
2834 # if ENABLE_ASH_ALIAS
2835         static const uint8_t syntax_index_table[] ALIGN1 = {
2836                 1, 2, 1, 3, 4, 5, 1, 6,         /* "\t\n !\"$&'" */
2837                 7, 8, 3, 3,/*3,*/3, 1, 1,       /* "()*-/:;<" */
2838                 3, 1, 3, 3, 9, 3, 10, 1,        /* "=>?[\\]`|" */
2839                 11, 3                           /* "}~" */
2840         };
2841 # else
2842         static const uint8_t syntax_index_table[] ALIGN1 = {
2843                 0, 1, 0, 2, 3, 4, 0, 5,         /* "\t\n !\"$&'" */
2844                 6, 7, 2, 2,/*2,*/2, 0, 0,       /* "()*-/:;<" */
2845                 2, 0, 2, 2, 8, 2, 9, 0,         /* "=>?[\\]`|" */
2846                 10, 2                           /* "}~" */
2847         };
2848 # endif
2849         const char *s;
2850         int indx;
2851
2852         if (c == PEOF)
2853                 return CENDFILE;
2854 # if ENABLE_ASH_ALIAS
2855         if (c == PEOA)
2856                 indx = 0;
2857         else
2858 # endif
2859         {
2860                 /* Cast is purely for paranoia here,
2861                  * just in case someone passed signed char to us */
2862                 if ((unsigned char)c >= CTL_FIRST
2863                  && (unsigned char)c <= CTL_LAST
2864                 ) {
2865                         return CCTL;
2866                 }
2867                 s = strchrnul(spec_symbls, c);
2868                 if (*s == '\0')
2869                         return CWORD;
2870                 indx = syntax_index_table[s - spec_symbls];
2871         }
2872         return (S_I_T[indx] >> (syntax*4)) & 0xf;
2873 }
2874
2875 #else   /* !USE_SIT_FUNCTION */
2876
2877 static const uint8_t syntax_index_table[] ALIGN1 = {
2878         /* BASESYNTAX_DQSYNTAX_SQSYNTAX_ARISYNTAX */
2879         /*   0      */ CWORD_CWORD_CWORD_CWORD,
2880         /*   1      */ CWORD_CWORD_CWORD_CWORD,
2881         /*   2      */ CWORD_CWORD_CWORD_CWORD,
2882         /*   3      */ CWORD_CWORD_CWORD_CWORD,
2883         /*   4      */ CWORD_CWORD_CWORD_CWORD,
2884         /*   5      */ CWORD_CWORD_CWORD_CWORD,
2885         /*   6      */ CWORD_CWORD_CWORD_CWORD,
2886         /*   7      */ CWORD_CWORD_CWORD_CWORD,
2887         /*   8      */ CWORD_CWORD_CWORD_CWORD,
2888         /*   9 "\t" */ CSPCL_CWORD_CWORD_CWORD,
2889         /*  10 "\n" */ CNL_CNL_CNL_CNL,
2890         /*  11      */ CWORD_CWORD_CWORD_CWORD,
2891         /*  12      */ CWORD_CWORD_CWORD_CWORD,
2892         /*  13      */ CWORD_CWORD_CWORD_CWORD,
2893         /*  14      */ CWORD_CWORD_CWORD_CWORD,
2894         /*  15      */ CWORD_CWORD_CWORD_CWORD,
2895         /*  16      */ CWORD_CWORD_CWORD_CWORD,
2896         /*  17      */ CWORD_CWORD_CWORD_CWORD,
2897         /*  18      */ CWORD_CWORD_CWORD_CWORD,
2898         /*  19      */ CWORD_CWORD_CWORD_CWORD,
2899         /*  20      */ CWORD_CWORD_CWORD_CWORD,
2900         /*  21      */ CWORD_CWORD_CWORD_CWORD,
2901         /*  22      */ CWORD_CWORD_CWORD_CWORD,
2902         /*  23      */ CWORD_CWORD_CWORD_CWORD,
2903         /*  24      */ CWORD_CWORD_CWORD_CWORD,
2904         /*  25      */ CWORD_CWORD_CWORD_CWORD,
2905         /*  26      */ CWORD_CWORD_CWORD_CWORD,
2906         /*  27      */ CWORD_CWORD_CWORD_CWORD,
2907         /*  28      */ CWORD_CWORD_CWORD_CWORD,
2908         /*  29      */ CWORD_CWORD_CWORD_CWORD,
2909         /*  30      */ CWORD_CWORD_CWORD_CWORD,
2910         /*  31      */ CWORD_CWORD_CWORD_CWORD,
2911         /*  32  " " */ CSPCL_CWORD_CWORD_CWORD,
2912         /*  33  "!" */ CWORD_CCTL_CCTL_CWORD,
2913         /*  34  """ */ CDQUOTE_CENDQUOTE_CWORD_CWORD,
2914         /*  35  "#" */ CWORD_CWORD_CWORD_CWORD,
2915         /*  36  "$" */ CVAR_CVAR_CWORD_CVAR,
2916         /*  37  "%" */ CWORD_CWORD_CWORD_CWORD,
2917         /*  38  "&" */ CSPCL_CWORD_CWORD_CWORD,
2918         /*  39  "'" */ CSQUOTE_CWORD_CENDQUOTE_CWORD,
2919         /*  40  "(" */ CSPCL_CWORD_CWORD_CLP,
2920         /*  41  ")" */ CSPCL_CWORD_CWORD_CRP,
2921         /*  42  "*" */ CWORD_CCTL_CCTL_CWORD,
2922         /*  43  "+" */ CWORD_CWORD_CWORD_CWORD,
2923         /*  44  "," */ CWORD_CWORD_CWORD_CWORD,
2924         /*  45  "-" */ CWORD_CCTL_CCTL_CWORD,
2925         /*  46  "." */ CWORD_CWORD_CWORD_CWORD,
2926 /* "/" was CWORD_CCTL_CCTL_CWORD, see comment in SIT() function why this is changed: */
2927         /*  47  "/" */ CWORD_CWORD_CWORD_CWORD,
2928         /*  48  "0" */ CWORD_CWORD_CWORD_CWORD,
2929         /*  49  "1" */ CWORD_CWORD_CWORD_CWORD,
2930         /*  50  "2" */ CWORD_CWORD_CWORD_CWORD,
2931         /*  51  "3" */ CWORD_CWORD_CWORD_CWORD,
2932         /*  52  "4" */ CWORD_CWORD_CWORD_CWORD,
2933         /*  53  "5" */ CWORD_CWORD_CWORD_CWORD,
2934         /*  54  "6" */ CWORD_CWORD_CWORD_CWORD,
2935         /*  55  "7" */ CWORD_CWORD_CWORD_CWORD,
2936         /*  56  "8" */ CWORD_CWORD_CWORD_CWORD,
2937         /*  57  "9" */ CWORD_CWORD_CWORD_CWORD,
2938         /*  58  ":" */ CWORD_CCTL_CCTL_CWORD,
2939         /*  59  ";" */ CSPCL_CWORD_CWORD_CWORD,
2940         /*  60  "<" */ CSPCL_CWORD_CWORD_CWORD,
2941         /*  61  "=" */ CWORD_CCTL_CCTL_CWORD,
2942         /*  62  ">" */ CSPCL_CWORD_CWORD_CWORD,
2943         /*  63  "?" */ CWORD_CCTL_CCTL_CWORD,
2944         /*  64  "@" */ CWORD_CWORD_CWORD_CWORD,
2945         /*  65  "A" */ CWORD_CWORD_CWORD_CWORD,
2946         /*  66  "B" */ CWORD_CWORD_CWORD_CWORD,
2947         /*  67  "C" */ CWORD_CWORD_CWORD_CWORD,
2948         /*  68  "D" */ CWORD_CWORD_CWORD_CWORD,
2949         /*  69  "E" */ CWORD_CWORD_CWORD_CWORD,
2950         /*  70  "F" */ CWORD_CWORD_CWORD_CWORD,
2951         /*  71  "G" */ CWORD_CWORD_CWORD_CWORD,
2952         /*  72  "H" */ CWORD_CWORD_CWORD_CWORD,
2953         /*  73  "I" */ CWORD_CWORD_CWORD_CWORD,
2954         /*  74  "J" */ CWORD_CWORD_CWORD_CWORD,
2955         /*  75  "K" */ CWORD_CWORD_CWORD_CWORD,
2956         /*  76  "L" */ CWORD_CWORD_CWORD_CWORD,
2957         /*  77  "M" */ CWORD_CWORD_CWORD_CWORD,
2958         /*  78  "N" */ CWORD_CWORD_CWORD_CWORD,
2959         /*  79  "O" */ CWORD_CWORD_CWORD_CWORD,
2960         /*  80  "P" */ CWORD_CWORD_CWORD_CWORD,
2961         /*  81  "Q" */ CWORD_CWORD_CWORD_CWORD,
2962         /*  82  "R" */ CWORD_CWORD_CWORD_CWORD,
2963         /*  83  "S" */ CWORD_CWORD_CWORD_CWORD,
2964         /*  84  "T" */ CWORD_CWORD_CWORD_CWORD,
2965         /*  85  "U" */ CWORD_CWORD_CWORD_CWORD,
2966         /*  86  "V" */ CWORD_CWORD_CWORD_CWORD,
2967         /*  87  "W" */ CWORD_CWORD_CWORD_CWORD,
2968         /*  88  "X" */ CWORD_CWORD_CWORD_CWORD,
2969         /*  89  "Y" */ CWORD_CWORD_CWORD_CWORD,
2970         /*  90  "Z" */ CWORD_CWORD_CWORD_CWORD,
2971         /*  91  "[" */ CWORD_CCTL_CCTL_CWORD,
2972         /*  92  "\" */ CBACK_CBACK_CCTL_CBACK,
2973         /*  93  "]" */ CWORD_CCTL_CCTL_CWORD,
2974         /*  94  "^" */ CWORD_CWORD_CWORD_CWORD,
2975         /*  95  "_" */ CWORD_CWORD_CWORD_CWORD,
2976         /*  96  "`" */ CBQUOTE_CBQUOTE_CWORD_CBQUOTE,
2977         /*  97  "a" */ CWORD_CWORD_CWORD_CWORD,
2978         /*  98  "b" */ CWORD_CWORD_CWORD_CWORD,
2979         /*  99  "c" */ CWORD_CWORD_CWORD_CWORD,
2980         /* 100  "d" */ CWORD_CWORD_CWORD_CWORD,
2981         /* 101  "e" */ CWORD_CWORD_CWORD_CWORD,
2982         /* 102  "f" */ CWORD_CWORD_CWORD_CWORD,
2983         /* 103  "g" */ CWORD_CWORD_CWORD_CWORD,
2984         /* 104  "h" */ CWORD_CWORD_CWORD_CWORD,
2985         /* 105  "i" */ CWORD_CWORD_CWORD_CWORD,
2986         /* 106  "j" */ CWORD_CWORD_CWORD_CWORD,
2987         /* 107  "k" */ CWORD_CWORD_CWORD_CWORD,
2988         /* 108  "l" */ CWORD_CWORD_CWORD_CWORD,
2989         /* 109  "m" */ CWORD_CWORD_CWORD_CWORD,
2990         /* 110  "n" */ CWORD_CWORD_CWORD_CWORD,
2991         /* 111  "o" */ CWORD_CWORD_CWORD_CWORD,
2992         /* 112  "p" */ CWORD_CWORD_CWORD_CWORD,
2993         /* 113  "q" */ CWORD_CWORD_CWORD_CWORD,
2994         /* 114  "r" */ CWORD_CWORD_CWORD_CWORD,
2995         /* 115  "s" */ CWORD_CWORD_CWORD_CWORD,
2996         /* 116  "t" */ CWORD_CWORD_CWORD_CWORD,
2997         /* 117  "u" */ CWORD_CWORD_CWORD_CWORD,
2998         /* 118  "v" */ CWORD_CWORD_CWORD_CWORD,
2999         /* 119  "w" */ CWORD_CWORD_CWORD_CWORD,
3000         /* 120  "x" */ CWORD_CWORD_CWORD_CWORD,
3001         /* 121  "y" */ CWORD_CWORD_CWORD_CWORD,
3002         /* 122  "z" */ CWORD_CWORD_CWORD_CWORD,
3003         /* 123  "{" */ CWORD_CWORD_CWORD_CWORD,
3004         /* 124  "|" */ CSPCL_CWORD_CWORD_CWORD,
3005         /* 125  "}" */ CENDVAR_CENDVAR_CWORD_CENDVAR,
3006         /* 126  "~" */ CWORD_CCTL_CCTL_CWORD,
3007         /* 127  del */ CWORD_CWORD_CWORD_CWORD,
3008         /* 128 0x80 */ CWORD_CWORD_CWORD_CWORD,
3009         /* 129 CTLESC       */ CCTL_CCTL_CCTL_CCTL,
3010         /* 130 CTLVAR       */ CCTL_CCTL_CCTL_CCTL,
3011         /* 131 CTLENDVAR    */ CCTL_CCTL_CCTL_CCTL,
3012         /* 132 CTLBACKQ     */ CCTL_CCTL_CCTL_CCTL,
3013         /* 133 CTLQUOTE     */ CCTL_CCTL_CCTL_CCTL,
3014         /* 134 CTLARI       */ CCTL_CCTL_CCTL_CCTL,
3015         /* 135 CTLENDARI    */ CCTL_CCTL_CCTL_CCTL,
3016         /* 136 CTLQUOTEMARK */ CCTL_CCTL_CCTL_CCTL,
3017         /* 137      */ CWORD_CWORD_CWORD_CWORD,
3018         /* 138      */ CWORD_CWORD_CWORD_CWORD,
3019         /* 139      */ CWORD_CWORD_CWORD_CWORD,
3020         /* 140      */ CWORD_CWORD_CWORD_CWORD,
3021         /* 141      */ CWORD_CWORD_CWORD_CWORD,
3022         /* 142      */ CWORD_CWORD_CWORD_CWORD,
3023         /* 143      */ CWORD_CWORD_CWORD_CWORD,
3024         /* 144      */ CWORD_CWORD_CWORD_CWORD,
3025         /* 145      */ CWORD_CWORD_CWORD_CWORD,
3026         /* 146      */ CWORD_CWORD_CWORD_CWORD,
3027         /* 147      */ CWORD_CWORD_CWORD_CWORD,
3028         /* 148      */ CWORD_CWORD_CWORD_CWORD,
3029         /* 149      */ CWORD_CWORD_CWORD_CWORD,
3030         /* 150      */ CWORD_CWORD_CWORD_CWORD,
3031         /* 151      */ CWORD_CWORD_CWORD_CWORD,
3032         /* 152      */ CWORD_CWORD_CWORD_CWORD,
3033         /* 153      */ CWORD_CWORD_CWORD_CWORD,
3034         /* 154      */ CWORD_CWORD_CWORD_CWORD,
3035         /* 155      */ CWORD_CWORD_CWORD_CWORD,
3036         /* 156      */ CWORD_CWORD_CWORD_CWORD,
3037         /* 157      */ CWORD_CWORD_CWORD_CWORD,
3038         /* 158      */ CWORD_CWORD_CWORD_CWORD,
3039         /* 159      */ CWORD_CWORD_CWORD_CWORD,
3040         /* 160      */ CWORD_CWORD_CWORD_CWORD,
3041         /* 161      */ CWORD_CWORD_CWORD_CWORD,
3042         /* 162      */ CWORD_CWORD_CWORD_CWORD,
3043         /* 163      */ CWORD_CWORD_CWORD_CWORD,
3044         /* 164      */ CWORD_CWORD_CWORD_CWORD,
3045         /* 165      */ CWORD_CWORD_CWORD_CWORD,
3046         /* 166      */ CWORD_CWORD_CWORD_CWORD,
3047         /* 167      */ CWORD_CWORD_CWORD_CWORD,
3048         /* 168      */ CWORD_CWORD_CWORD_CWORD,
3049         /* 169      */ CWORD_CWORD_CWORD_CWORD,
3050         /* 170      */ CWORD_CWORD_CWORD_CWORD,
3051         /* 171      */ CWORD_CWORD_CWORD_CWORD,
3052         /* 172      */ CWORD_CWORD_CWORD_CWORD,
3053         /* 173      */ CWORD_CWORD_CWORD_CWORD,
3054         /* 174      */ CWORD_CWORD_CWORD_CWORD,
3055         /* 175      */ CWORD_CWORD_CWORD_CWORD,
3056         /* 176      */ CWORD_CWORD_CWORD_CWORD,
3057         /* 177      */ CWORD_CWORD_CWORD_CWORD,
3058         /* 178      */ CWORD_CWORD_CWORD_CWORD,
3059         /* 179      */ CWORD_CWORD_CWORD_CWORD,
3060         /* 180      */ CWORD_CWORD_CWORD_CWORD,
3061         /* 181      */ CWORD_CWORD_CWORD_CWORD,
3062         /* 182      */ CWORD_CWORD_CWORD_CWORD,
3063         /* 183      */ CWORD_CWORD_CWORD_CWORD,
3064         /* 184      */ CWORD_CWORD_CWORD_CWORD,
3065         /* 185      */ CWORD_CWORD_CWORD_CWORD,
3066         /* 186      */ CWORD_CWORD_CWORD_CWORD,
3067         /* 187      */ CWORD_CWORD_CWORD_CWORD,
3068         /* 188      */ CWORD_CWORD_CWORD_CWORD,
3069         /* 189      */ CWORD_CWORD_CWORD_CWORD,
3070         /* 190      */ CWORD_CWORD_CWORD_CWORD,
3071         /* 191      */ CWORD_CWORD_CWORD_CWORD,
3072         /* 192      */ CWORD_CWORD_CWORD_CWORD,
3073         /* 193      */ CWORD_CWORD_CWORD_CWORD,
3074         /* 194      */ CWORD_CWORD_CWORD_CWORD,
3075         /* 195      */ CWORD_CWORD_CWORD_CWORD,
3076         /* 196      */ CWORD_CWORD_CWORD_CWORD,
3077         /* 197      */ CWORD_CWORD_CWORD_CWORD,
3078         /* 198      */ CWORD_CWORD_CWORD_CWORD,
3079         /* 199      */ CWORD_CWORD_CWORD_CWORD,
3080         /* 200      */ CWORD_CWORD_CWORD_CWORD,
3081         /* 201      */ CWORD_CWORD_CWORD_CWORD,
3082         /* 202      */ CWORD_CWORD_CWORD_CWORD,
3083         /* 203      */ CWORD_CWORD_CWORD_CWORD,
3084         /* 204      */ CWORD_CWORD_CWORD_CWORD,
3085         /* 205      */ CWORD_CWORD_CWORD_CWORD,
3086         /* 206      */ CWORD_CWORD_CWORD_CWORD,
3087         /* 207      */ CWORD_CWORD_CWORD_CWORD,
3088         /* 208      */ CWORD_CWORD_CWORD_CWORD,
3089         /* 209      */ CWORD_CWORD_CWORD_CWORD,
3090         /* 210      */ CWORD_CWORD_CWORD_CWORD,
3091         /* 211      */ CWORD_CWORD_CWORD_CWORD,
3092         /* 212      */ CWORD_CWORD_CWORD_CWORD,
3093         /* 213      */ CWORD_CWORD_CWORD_CWORD,
3094         /* 214      */ CWORD_CWORD_CWORD_CWORD,
3095         /* 215      */ CWORD_CWORD_CWORD_CWORD,
3096         /* 216      */ CWORD_CWORD_CWORD_CWORD,
3097         /* 217      */ CWORD_CWORD_CWORD_CWORD,
3098         /* 218      */ CWORD_CWORD_CWORD_CWORD,
3099         /* 219      */ CWORD_CWORD_CWORD_CWORD,
3100         /* 220      */ CWORD_CWORD_CWORD_CWORD,
3101         /* 221      */ CWORD_CWORD_CWORD_CWORD,
3102         /* 222      */ CWORD_CWORD_CWORD_CWORD,
3103         /* 223      */ CWORD_CWORD_CWORD_CWORD,
3104         /* 224      */ CWORD_CWORD_CWORD_CWORD,
3105         /* 225      */ CWORD_CWORD_CWORD_CWORD,
3106         /* 226      */ CWORD_CWORD_CWORD_CWORD,
3107         /* 227      */ CWORD_CWORD_CWORD_CWORD,
3108         /* 228      */ CWORD_CWORD_CWORD_CWORD,
3109         /* 229      */ CWORD_CWORD_CWORD_CWORD,
3110         /* 230      */ CWORD_CWORD_CWORD_CWORD,
3111         /* 231      */ CWORD_CWORD_CWORD_CWORD,
3112         /* 232      */ CWORD_CWORD_CWORD_CWORD,
3113         /* 233      */ CWORD_CWORD_CWORD_CWORD,
3114         /* 234      */ CWORD_CWORD_CWORD_CWORD,
3115         /* 235      */ CWORD_CWORD_CWORD_CWORD,
3116         /* 236      */ CWORD_CWORD_CWORD_CWORD,
3117         /* 237      */ CWORD_CWORD_CWORD_CWORD,
3118         /* 238      */ CWORD_CWORD_CWORD_CWORD,
3119         /* 239      */ CWORD_CWORD_CWORD_CWORD,
3120         /* 230      */ CWORD_CWORD_CWORD_CWORD,
3121         /* 241      */ CWORD_CWORD_CWORD_CWORD,
3122         /* 242      */ CWORD_CWORD_CWORD_CWORD,
3123         /* 243      */ CWORD_CWORD_CWORD_CWORD,
3124         /* 244      */ CWORD_CWORD_CWORD_CWORD,
3125         /* 245      */ CWORD_CWORD_CWORD_CWORD,
3126         /* 246      */ CWORD_CWORD_CWORD_CWORD,
3127         /* 247      */ CWORD_CWORD_CWORD_CWORD,
3128         /* 248      */ CWORD_CWORD_CWORD_CWORD,
3129         /* 249      */ CWORD_CWORD_CWORD_CWORD,
3130         /* 250      */ CWORD_CWORD_CWORD_CWORD,
3131         /* 251      */ CWORD_CWORD_CWORD_CWORD,
3132         /* 252      */ CWORD_CWORD_CWORD_CWORD,
3133         /* 253      */ CWORD_CWORD_CWORD_CWORD,
3134         /* 254      */ CWORD_CWORD_CWORD_CWORD,
3135         /* 255      */ CWORD_CWORD_CWORD_CWORD,
3136         /* PEOF */     CENDFILE_CENDFILE_CENDFILE_CENDFILE,
3137 # if ENABLE_ASH_ALIAS
3138         /* PEOA */     CSPCL_CIGN_CIGN_CIGN,
3139 # endif
3140 };
3141
3142 #if 1
3143 # define SIT(c, syntax) ((S_I_T[syntax_index_table[c]] >> ((syntax)*4)) & 0xf)
3144 #else /* debug version, caught one signed char bug */
3145 # define SIT(c, syntax) \
3146         ({ \
3147                 if ((c) < 0 || (c) > (PEOF + ENABLE_ASH_ALIAS)) \
3148                         bb_error_msg_and_die("line:%d c:%d", __LINE__, (c)); \
3149                 if ((syntax) < 0 || (syntax) > (2 + ENABLE_FEATURE_SH_MATH)) \
3150                         bb_error_msg_and_die("line:%d c:%d", __LINE__, (c)); \
3151                 ((S_I_T[syntax_index_table[c]] >> ((syntax)*4)) & 0xf); \
3152         })
3153 #endif
3154
3155 #endif  /* !USE_SIT_FUNCTION */
3156
3157
3158 /* ============ Alias handling */
3159
3160 #if ENABLE_ASH_ALIAS
3161
3162 #define ALIASINUSE 1
3163 #define ALIASDEAD  2
3164
3165 struct alias {
3166         struct alias *next;
3167         char *name;
3168         char *val;
3169         int flag;
3170 };
3171
3172
3173 static struct alias **atab; // [ATABSIZE];
3174 #define INIT_G_alias() do { \
3175         atab = xzalloc(ATABSIZE * sizeof(atab[0])); \
3176 } while (0)
3177
3178
3179 static struct alias **
3180 __lookupalias(const char *name)
3181 {
3182         unsigned int hashval;
3183         struct alias **app;
3184         const char *p;
3185         unsigned int ch;
3186
3187         p = name;
3188
3189         ch = (unsigned char)*p;
3190         hashval = ch << 4;
3191         while (ch) {
3192                 hashval += ch;
3193                 ch = (unsigned char)*++p;
3194         }
3195         app = &atab[hashval % ATABSIZE];
3196
3197         for (; *app; app = &(*app)->next) {
3198                 if (strcmp(name, (*app)->name) == 0) {
3199                         break;
3200                 }
3201         }
3202
3203         return app;
3204 }
3205
3206 static struct alias *
3207 lookupalias(const char *name, int check)
3208 {
3209         struct alias *ap = *__lookupalias(name);
3210
3211         if (check && ap && (ap->flag & ALIASINUSE))
3212                 return NULL;
3213         return ap;
3214 }
3215
3216 static struct alias *
3217 freealias(struct alias *ap)
3218 {
3219         struct alias *next;
3220
3221         if (ap->flag & ALIASINUSE) {
3222                 ap->flag |= ALIASDEAD;
3223                 return ap;
3224         }
3225
3226         next = ap->next;
3227         free(ap->name);
3228         free(ap->val);
3229         free(ap);
3230         return next;
3231 }
3232
3233 static void
3234 setalias(const char *name, const char *val)
3235 {
3236         struct alias *ap, **app;
3237
3238         app = __lookupalias(name);
3239         ap = *app;
3240         INT_OFF;
3241         if (ap) {
3242                 if (!(ap->flag & ALIASINUSE)) {
3243                         free(ap->val);
3244                 }
3245                 ap->val = ckstrdup(val);
3246                 ap->flag &= ~ALIASDEAD;
3247         } else {
3248                 /* not found */
3249                 ap = ckzalloc(sizeof(struct alias));
3250                 ap->name = ckstrdup(name);
3251                 ap->val = ckstrdup(val);
3252                 /*ap->flag = 0; - ckzalloc did it */
3253                 /*ap->next = NULL;*/
3254                 *app = ap;
3255         }
3256         INT_ON;
3257 }
3258
3259 static int
3260 unalias(const char *name)
3261 {
3262         struct alias **app;
3263
3264         app = __lookupalias(name);
3265
3266         if (*app) {
3267                 INT_OFF;
3268                 *app = freealias(*app);
3269                 INT_ON;
3270                 return 0;
3271         }
3272
3273         return 1;
3274 }
3275
3276 static void
3277 rmaliases(void)
3278 {
3279         struct alias *ap, **app;
3280         int i;
3281
3282         INT_OFF;
3283         for (i = 0; i < ATABSIZE; i++) {
3284                 app = &atab[i];
3285                 for (ap = *app; ap; ap = *app) {
3286                         *app = freealias(*app);
3287                         if (ap == *app) {
3288                                 app = &ap->next;
3289                         }
3290                 }
3291         }
3292         INT_ON;
3293 }
3294
3295 static void
3296 printalias(const struct alias *ap)
3297 {
3298         out1fmt("%s=%s\n", ap->name, single_quote(ap->val));
3299 }
3300
3301 /*
3302  * TODO - sort output
3303  */
3304 static int FAST_FUNC
3305 aliascmd(int argc UNUSED_PARAM, char **argv)
3306 {
3307         char *n, *v;
3308         int ret = 0;
3309         struct alias *ap;
3310
3311         if (!argv[1]) {
3312                 int i;
3313
3314                 for (i = 0; i < ATABSIZE; i++) {
3315                         for (ap = atab[i]; ap; ap = ap->next) {
3316                                 printalias(ap);
3317                         }
3318                 }
3319                 return 0;
3320         }
3321         while ((n = *++argv) != NULL) {
3322                 v = strchr(n+1, '=');
3323                 if (v == NULL) { /* n+1: funny ksh stuff */
3324                         ap = *__lookupalias(n);
3325                         if (ap == NULL) {
3326                                 fprintf(stderr, "%s: %s not found\n", "alias", n);
3327                                 ret = 1;
3328                         } else
3329                                 printalias(ap);
3330                 } else {
3331                         *v++ = '\0';
3332                         setalias(n, v);
3333                 }
3334         }
3335
3336         return ret;
3337 }
3338
3339 static int FAST_FUNC
3340 unaliascmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
3341 {
3342         int i;
3343
3344         while (nextopt("a") != '\0') {
3345                 rmaliases();
3346                 return 0;
3347         }
3348         for (i = 0; *argptr; argptr++) {
3349                 if (unalias(*argptr)) {
3350                         fprintf(stderr, "%s: %s not found\n", "unalias", *argptr);
3351                         i = 1;
3352                 }
3353         }
3354
3355         return i;
3356 }
3357
3358 #endif /* ASH_ALIAS */
3359
3360
3361 /* Mode argument to forkshell.  Don't change FORK_FG or FORK_BG. */
3362 #define FORK_FG    0
3363 #define FORK_BG    1
3364 #define FORK_NOJOB 2
3365
3366 /* mode flags for showjob(s) */
3367 #define SHOW_ONLY_PGID  0x01    /* show only pgid (jobs -p) */
3368 #define SHOW_PIDS       0x02    /* show individual pids, not just one line per job */
3369 #define SHOW_CHANGED    0x04    /* only jobs whose state has changed */
3370 #define SHOW_STDERR     0x08    /* print to stderr (else stdout) */
3371
3372 /*
3373  * A job structure contains information about a job.  A job is either a
3374  * single process or a set of processes contained in a pipeline.  In the
3375  * latter case, pidlist will be non-NULL, and will point to a -1 terminated
3376  * array of pids.
3377  */
3378 struct procstat {
3379         pid_t   ps_pid;         /* process id */
3380         int     ps_status;      /* last process status from wait() */
3381         char    *ps_cmd;        /* text of command being run */
3382 };
3383
3384 struct job {
3385         struct procstat ps0;    /* status of process */
3386         struct procstat *ps;    /* status or processes when more than one */
3387 #if JOBS
3388         int stopstatus;         /* status of a stopped job */
3389 #endif
3390         unsigned nprocs;        /* number of processes */
3391
3392 #define JOBRUNNING      0       /* at least one proc running */
3393 #define JOBSTOPPED      1       /* all procs are stopped */
3394 #define JOBDONE         2       /* all procs are completed */
3395         unsigned
3396                 state: 8,
3397 #if JOBS
3398                 sigint: 1,      /* job was killed by SIGINT */
3399                 jobctl: 1,      /* job running under job control */
3400 #endif
3401                 waited: 1,      /* true if this entry has been waited for */
3402                 used: 1,        /* true if this entry is in used */
3403                 changed: 1;     /* true if status has changed */
3404         struct job *prev_job;   /* previous job */
3405 };
3406
3407 static struct job *makejob(/*union node *,*/ int);
3408 static int forkshell(struct job *, union node *, int);
3409 static int waitforjob(struct job *);
3410
3411 #if !JOBS
3412 enum { doing_jobctl = 0 };
3413 #define setjobctl(on) do {} while (0)
3414 #else
3415 static smallint doing_jobctl; //references:8
3416 static void setjobctl(int);
3417 #endif
3418
3419 /*
3420  * Ignore a signal.
3421  */
3422 static void
3423 ignoresig(int signo)
3424 {
3425         /* Avoid unnecessary system calls. Is it already SIG_IGNed? */
3426         if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {
3427                 /* No, need to do it */
3428                 signal(signo, SIG_IGN);
3429         }
3430         sigmode[signo - 1] = S_HARD_IGN;
3431 }
3432
3433 /*
3434  * Only one usage site - in setsignal()
3435  */
3436 static void
3437 signal_handler(int signo)
3438 {
3439         if (signo == SIGCHLD) {
3440                 got_sigchld = 1;
3441                 if (!trap[SIGCHLD])
3442                         return;
3443         }
3444
3445         gotsig[signo - 1] = 1;
3446         pending_sig = signo;
3447
3448         if (signo == SIGINT && !trap[SIGINT]) {
3449                 if (!suppress_int) {
3450                         pending_sig = 0;
3451                         raise_interrupt(); /* does not return */
3452                 }
3453                 pending_int = 1;
3454         }
3455 }
3456
3457 /*
3458  * Set the signal handler for the specified signal.  The routine figures
3459  * out what it should be set to.
3460  */
3461 static void
3462 setsignal(int signo)
3463 {
3464         char *t;
3465         char cur_act, new_act;
3466         struct sigaction act;
3467
3468         t = trap[signo];
3469         new_act = S_DFL;
3470         if (t != NULL) { /* trap for this sig is set */
3471                 new_act = S_CATCH;
3472                 if (t[0] == '\0') /* trap is "": ignore this sig */
3473                         new_act = S_IGN;
3474         }
3475
3476         if (rootshell && new_act == S_DFL) {
3477                 switch (signo) {
3478                 case SIGINT:
3479                         if (iflag || minusc || sflag == 0)
3480                                 new_act = S_CATCH;
3481                         break;
3482                 case SIGQUIT:
3483 #if DEBUG
3484                         if (debug)
3485                                 break;
3486 #endif
3487                         /* man bash:
3488                          * "In all cases, bash ignores SIGQUIT. Non-builtin
3489                          * commands run by bash have signal handlers
3490                          * set to the values inherited by the shell
3491                          * from its parent". */
3492                         new_act = S_IGN;
3493                         break;
3494                 case SIGTERM:
3495                         if (iflag)
3496                                 new_act = S_IGN;
3497                         break;
3498 #if JOBS
3499                 case SIGTSTP:
3500                 case SIGTTOU:
3501                         if (mflag)
3502                                 new_act = S_IGN;
3503                         break;
3504 #endif
3505                 }
3506         }
3507 //TODO: if !rootshell, we reset SIGQUIT to DFL,
3508 //whereas we have to restore it to what shell got on entry
3509 //from the parent. See comment above
3510
3511         if (signo == SIGCHLD)
3512                 new_act = S_CATCH;
3513
3514         t = &sigmode[signo - 1];
3515         cur_act = *t;
3516         if (cur_act == 0) {
3517                 /* current setting is not yet known */
3518                 if (sigaction(signo, NULL, &act)) {
3519                         /* pretend it worked; maybe we should give a warning,
3520                          * but other shells don't. We don't alter sigmode,
3521                          * so we retry every time.
3522                          * btw, in Linux it never fails. --vda */
3523                         return;
3524                 }
3525                 if (act.sa_handler == SIG_IGN) {
3526                         cur_act = S_HARD_IGN;
3527                         if (mflag
3528                          && (signo == SIGTSTP || signo == SIGTTIN || signo == SIGTTOU)
3529                         ) {
3530                                 cur_act = S_IGN;   /* don't hard ignore these */
3531                         }
3532                 }
3533         }
3534         if (cur_act == S_HARD_IGN || cur_act == new_act)
3535                 return;
3536
3537         act.sa_handler = SIG_DFL;
3538         switch (new_act) {
3539         case S_CATCH:
3540                 act.sa_handler = signal_handler;
3541                 break;
3542         case S_IGN:
3543                 act.sa_handler = SIG_IGN;
3544                 break;
3545         }
3546
3547         /* flags and mask matter only if !DFL and !IGN, but we do it
3548          * for all cases for more deterministic behavior:
3549          */
3550         act.sa_flags = 0;
3551         sigfillset(&act.sa_mask);
3552
3553         sigaction_set(signo, &act);
3554
3555         *t = new_act;
3556 }
3557
3558 /* mode flags for set_curjob */
3559 #define CUR_DELETE 2
3560 #define CUR_RUNNING 1
3561 #define CUR_STOPPED 0
3562
3563 #if JOBS
3564 /* pgrp of shell on invocation */
3565 static int initialpgrp; //references:2
3566 static int ttyfd = -1; //5
3567 #endif
3568 /* array of jobs */
3569 static struct job *jobtab; //5
3570 /* size of array */
3571 static unsigned njobs; //4
3572 /* current job */
3573 static struct job *curjob; //lots
3574 /* number of presumed living untracked jobs */
3575 static int jobless; //4
3576
3577 #if 0
3578 /* Bash has a feature: it restores termios after a successful wait for
3579  * a foreground job which had at least one stopped or sigkilled member.
3580  * The probable rationale is that SIGSTOP and SIGKILL can preclude task from
3581  * properly restoring tty state. Should we do this too?
3582  * A reproducer: ^Z an interactive python:
3583  *
3584  * # python
3585  * Python 2.7.12 (...)
3586  * >>> ^Z
3587  *      { python leaves tty in -icanon -echo state. We do survive that... }
3588  *  [1]+  Stopped                    python
3589  *      { ...however, next program (python #2) does not survive it well: }
3590  * # python
3591  * Python 2.7.12 (...)
3592  * >>> Traceback (most recent call last):
3593  *      { above, I typed "qwerty<CR>", but -echo state is still in effect }
3594  *   File "<stdin>", line 1, in <module>
3595  * NameError: name 'qwerty' is not defined
3596  *
3597  * The implementation below is modeled on bash code and seems to work.
3598  * However, I'm not sure we should do this. For one: what if I'd fg
3599  * the stopped python instead? It'll be confused by "restored" tty state.
3600  */
3601 static struct termios shell_tty_info;
3602 static void
3603 get_tty_state(void)
3604 {
3605         if (rootshell && ttyfd >= 0)
3606                 tcgetattr(ttyfd, &shell_tty_info);
3607 }
3608 static void
3609 set_tty_state(void)
3610 {
3611         /* if (rootshell) - caller ensures this */
3612         if (ttyfd >= 0)
3613                 tcsetattr(ttyfd, TCSADRAIN, &shell_tty_info);
3614 }
3615 static int
3616 job_signal_status(struct job *jp)
3617 {
3618         int status;
3619         unsigned i;
3620         struct procstat *ps = jp->ps;
3621         for (i = 0; i < jp->nprocs; i++) {
3622                 status = ps[i].ps_status;
3623                 if (WIFSIGNALED(status) || WIFSTOPPED(status))
3624                         return status;
3625         }
3626         return 0;
3627 }
3628 static void
3629 restore_tty_if_stopped_or_signaled(struct job *jp)
3630 {
3631 //TODO: check what happens if we come from waitforjob() in expbackq()
3632         if (rootshell) {
3633                 int s = job_signal_status(jp);
3634                 if (s) /* WIFSIGNALED(s) || WIFSTOPPED(s) */
3635                         set_tty_state();
3636         }
3637 }
3638 #else
3639 # define get_tty_state() ((void)0)
3640 # define restore_tty_if_stopped_or_signaled(jp) ((void)0)
3641 #endif
3642
3643 static void
3644 set_curjob(struct job *jp, unsigned mode)
3645 {
3646         struct job *jp1;
3647         struct job **jpp, **curp;
3648
3649         /* first remove from list */
3650         jpp = curp = &curjob;
3651         while (1) {
3652                 jp1 = *jpp;
3653                 if (jp1 == jp)
3654                         break;
3655                 jpp = &jp1->prev_job;
3656         }
3657         *jpp = jp1->prev_job;
3658
3659         /* Then re-insert in correct position */
3660         jpp = curp;
3661         switch (mode) {
3662         default:
3663 #if DEBUG
3664                 abort();
3665 #endif
3666         case CUR_DELETE:
3667                 /* job being deleted */
3668                 break;
3669         case CUR_RUNNING:
3670                 /* newly created job or backgrounded job,
3671                  * put after all stopped jobs.
3672                  */
3673                 while (1) {
3674                         jp1 = *jpp;
3675 #if JOBS
3676                         if (!jp1 || jp1->state != JOBSTOPPED)
3677 #endif
3678                                 break;
3679                         jpp = &jp1->prev_job;
3680                 }
3681                 /* FALLTHROUGH */
3682 #if JOBS
3683         case CUR_STOPPED:
3684 #endif
3685                 /* newly stopped job - becomes curjob */
3686                 jp->prev_job = *jpp;
3687                 *jpp = jp;
3688                 break;
3689         }
3690 }
3691
3692 #if JOBS || DEBUG
3693 static int
3694 jobno(const struct job *jp)
3695 {
3696         return jp - jobtab + 1;
3697 }
3698 #endif
3699
3700 /*
3701  * Convert a job name to a job structure.
3702  */
3703 #if !JOBS
3704 #define getjob(name, getctl) getjob(name)
3705 #endif
3706 static struct job *
3707 getjob(const char *name, int getctl)
3708 {
3709         struct job *jp;
3710         struct job *found;
3711         const char *err_msg = "%s: no such job";
3712         unsigned num;
3713         int c;
3714         const char *p;
3715         char *(*match)(const char *, const char *);
3716
3717         jp = curjob;
3718         p = name;
3719         if (!p)
3720                 goto currentjob;
3721
3722         if (*p != '%')
3723                 goto err;
3724
3725         c = *++p;
3726         if (!c)
3727                 goto currentjob;
3728
3729         if (!p[1]) {
3730                 if (c == '+' || c == '%') {
3731  currentjob:
3732                         err_msg = "No current job";
3733                         goto check;
3734                 }
3735                 if (c == '-') {
3736                         if (jp)
3737                                 jp = jp->prev_job;
3738                         err_msg = "No previous job";
3739  check:
3740                         if (!jp)
3741                                 goto err;
3742                         goto gotit;
3743                 }
3744         }
3745
3746         if (is_number(p)) {
3747                 num = atoi(p);
3748                 if (num > 0 && num <= njobs) {
3749                         jp = jobtab + num - 1;
3750                         if (jp->used)
3751                                 goto gotit;
3752                         goto err;
3753                 }
3754         }
3755
3756         match = prefix;
3757         if (*p == '?') {
3758                 match = strstr;
3759                 p++;
3760         }
3761
3762         found = NULL;
3763         while (jp) {
3764                 if (match(jp->ps[0].ps_cmd, p)) {
3765                         if (found)
3766                                 goto err;
3767                         found = jp;
3768                         err_msg = "%s: ambiguous";
3769                 }
3770                 jp = jp->prev_job;
3771         }
3772         if (!found)
3773                 goto err;
3774         jp = found;
3775
3776  gotit:
3777 #if JOBS
3778         err_msg = "job %s not created under job control";
3779         if (getctl && jp->jobctl == 0)
3780                 goto err;
3781 #endif
3782         return jp;
3783  err:
3784         ash_msg_and_raise_error(err_msg, name);
3785 }
3786
3787 /*
3788  * Mark a job structure as unused.
3789  */
3790 static void
3791 freejob(struct job *jp)
3792 {
3793         struct procstat *ps;
3794         int i;
3795
3796         INT_OFF;
3797         for (i = jp->nprocs, ps = jp->ps; --i >= 0; ps++) {
3798                 if (ps->ps_cmd != nullstr)
3799                         free(ps->ps_cmd);
3800         }
3801         if (jp->ps != &jp->ps0)
3802                 free(jp->ps);
3803         jp->used = 0;
3804         set_curjob(jp, CUR_DELETE);
3805         INT_ON;
3806 }
3807
3808 #if JOBS
3809 static void
3810 xtcsetpgrp(int fd, pid_t pgrp)
3811 {
3812         if (tcsetpgrp(fd, pgrp))
3813                 ash_msg_and_raise_error("can't set tty process group (%m)");
3814 }
3815
3816 /*
3817  * Turn job control on and off.
3818  *
3819  * Note:  This code assumes that the third arg to ioctl is a character
3820  * pointer, which is true on Berkeley systems but not System V.  Since
3821  * System V doesn't have job control yet, this isn't a problem now.
3822  *
3823  * Called with interrupts off.
3824  */
3825 static void
3826 setjobctl(int on)
3827 {
3828         int fd;
3829         int pgrp;
3830
3831         if (on == doing_jobctl || rootshell == 0)
3832                 return;
3833         if (on) {
3834                 int ofd;
3835                 ofd = fd = open(_PATH_TTY, O_RDWR);
3836                 if (fd < 0) {
3837         /* BTW, bash will try to open(ttyname(0)) if open("/dev/tty") fails.
3838          * That sometimes helps to acquire controlling tty.
3839          * Obviously, a workaround for bugs when someone
3840          * failed to provide a controlling tty to bash! :) */
3841                         fd = 2;
3842                         while (!isatty(fd))
3843                                 if (--fd < 0)
3844                                         goto out;
3845                 }
3846                 /* fd is a tty at this point */
3847                 fd = fcntl(fd, F_DUPFD, 10);
3848                 if (ofd >= 0) /* if it is "/dev/tty", close. If 0/1/2, don't */
3849                         close(ofd);
3850                 if (fd < 0)
3851                         goto out; /* F_DUPFD failed */
3852                 close_on_exec_on(fd);
3853                 while (1) { /* while we are in the background */
3854                         pgrp = tcgetpgrp(fd);
3855                         if (pgrp < 0) {
3856  out:
3857                                 ash_msg("can't access tty; job control turned off");
3858                                 mflag = on = 0;
3859                                 goto close;
3860                         }
3861                         if (pgrp == getpgrp())
3862                                 break;
3863                         killpg(0, SIGTTIN);
3864                 }
3865                 initialpgrp = pgrp;
3866
3867                 setsignal(SIGTSTP);
3868                 setsignal(SIGTTOU);
3869                 setsignal(SIGTTIN);
3870                 pgrp = rootpid;
3871                 setpgid(0, pgrp);
3872                 xtcsetpgrp(fd, pgrp);
3873         } else {
3874                 /* turning job control off */
3875                 fd = ttyfd;
3876                 pgrp = initialpgrp;
3877                 /* was xtcsetpgrp, but this can make exiting ash
3878                  * loop forever if pty is already deleted */
3879                 tcsetpgrp(fd, pgrp);
3880                 setpgid(0, pgrp);
3881                 setsignal(SIGTSTP);
3882                 setsignal(SIGTTOU);
3883                 setsignal(SIGTTIN);
3884  close:
3885                 if (fd >= 0)
3886                         close(fd);
3887                 fd = -1;
3888         }
3889         ttyfd = fd;
3890         doing_jobctl = on;
3891 }
3892
3893 static int FAST_FUNC
3894 killcmd(int argc, char **argv)
3895 {
3896         if (argv[1] && strcmp(argv[1], "-l") != 0) {
3897                 int i = 1;
3898                 do {
3899                         if (argv[i][0] == '%') {
3900                                 /*
3901                                  * "kill %N" - job kill
3902                                  * Converting to pgrp / pid kill
3903                                  */
3904                                 struct job *jp;
3905                                 char *dst;
3906                                 int j, n;
3907
3908                                 jp = getjob(argv[i], 0);
3909                                 /*
3910                                  * In jobs started under job control, we signal
3911                                  * entire process group by kill -PGRP_ID.
3912                                  * This happens, f.e., in interactive shell.
3913                                  *
3914                                  * Otherwise, we signal each child via
3915                                  * kill PID1 PID2 PID3.
3916                                  * Testcases:
3917                                  * sh -c 'sleep 1|sleep 1 & kill %1'
3918                                  * sh -c 'true|sleep 2 & sleep 1; kill %1'
3919                                  * sh -c 'true|sleep 1 & sleep 2; kill %1'
3920                                  */
3921                                 n = jp->nprocs; /* can't be 0 (I hope) */
3922                                 if (jp->jobctl)
3923                                         n = 1;
3924                                 dst = alloca(n * sizeof(int)*4);
3925                                 argv[i] = dst;
3926                                 for (j = 0; j < n; j++) {
3927                                         struct procstat *ps = &jp->ps[j];
3928                                         /* Skip non-running and not-stopped members
3929                                          * (i.e. dead members) of the job
3930                                          */
3931                                         if (ps->ps_status != -1 && !WIFSTOPPED(ps->ps_status))
3932                                                 continue;
3933                                         /*
3934                                          * kill_main has matching code to expect
3935                                          * leading space. Needed to not confuse
3936                                          * negative pids with "kill -SIGNAL_NO" syntax
3937                                          */
3938                                         dst += sprintf(dst, jp->jobctl ? " -%u" : " %u", (int)ps->ps_pid);
3939                                 }
3940                                 *dst = '\0';
3941                         }
3942                 } while (argv[++i]);
3943         }
3944         return kill_main(argc, argv);
3945 }
3946
3947 static void
3948 showpipe(struct job *jp /*, FILE *out*/)
3949 {
3950         struct procstat *ps;
3951         struct procstat *psend;
3952
3953         psend = jp->ps + jp->nprocs;
3954         for (ps = jp->ps + 1; ps < psend; ps++)
3955                 printf(" | %s", ps->ps_cmd);
3956         newline_and_flush(stdout);
3957         flush_stdout_stderr();
3958 }
3959
3960
3961 static int
3962 restartjob(struct job *jp, int mode)
3963 {
3964         struct procstat *ps;
3965         int i;
3966         int status;
3967         pid_t pgid;
3968
3969         INT_OFF;
3970         if (jp->state == JOBDONE)
3971                 goto out;
3972         jp->state = JOBRUNNING;
3973         pgid = jp->ps[0].ps_pid;
3974         if (mode == FORK_FG) {
3975                 get_tty_state();
3976                 xtcsetpgrp(ttyfd, pgid);
3977         }
3978         killpg(pgid, SIGCONT);
3979         ps = jp->ps;
3980         i = jp->nprocs;
3981         do {
3982                 if (WIFSTOPPED(ps->ps_status)) {
3983                         ps->ps_status = -1;
3984                 }
3985                 ps++;
3986         } while (--i);
3987  out:
3988         status = (mode == FORK_FG) ? waitforjob(jp) : 0;
3989         INT_ON;
3990         return status;
3991 }
3992
3993 static int FAST_FUNC
3994 fg_bgcmd(int argc UNUSED_PARAM, char **argv)
3995 {
3996         struct job *jp;
3997         int mode;
3998         int retval;
3999
4000         mode = (**argv == 'f') ? FORK_FG : FORK_BG;
4001         nextopt(nullstr);
4002         argv = argptr;
4003         do {
4004                 jp = getjob(*argv, 1);
4005                 if (mode == FORK_BG) {
4006                         set_curjob(jp, CUR_RUNNING);
4007                         printf("[%d] ", jobno(jp));
4008                 }
4009                 out1str(jp->ps[0].ps_cmd);
4010                 showpipe(jp /*, stdout*/);
4011                 retval = restartjob(jp, mode);
4012         } while (*argv && *++argv);
4013         return retval;
4014 }
4015 #endif
4016
4017 static int
4018 sprint_status48(char *s, int status, int sigonly)
4019 {
4020         int col;
4021         int st;
4022
4023         col = 0;
4024         if (!WIFEXITED(status)) {
4025                 if (JOBS && WIFSTOPPED(status))
4026                         st = WSTOPSIG(status);
4027                 else
4028                         st = WTERMSIG(status);
4029                 if (sigonly) {
4030                         if (st == SIGINT || st == SIGPIPE)
4031                                 goto out;
4032                         if (JOBS && WIFSTOPPED(status))
4033                                 goto out;
4034                 }
4035                 st &= 0x7f;
4036 //TODO: use bbox's get_signame? strsignal adds ~600 bytes to text+rodata
4037                 col = fmtstr(s, 32, strsignal(st));
4038                 if (WCOREDUMP(status)) {
4039                         strcpy(s + col, " (core dumped)");
4040                         col += sizeof(" (core dumped)")-1;
4041                 }
4042         } else if (!sigonly) {
4043                 st = WEXITSTATUS(status);
4044                 col = fmtstr(s, 16, (st ? "Done(%d)" : "Done"), st);
4045         }
4046  out:
4047         return col;
4048 }
4049
4050 static int
4051 wait_block_or_sig(int *status)
4052 {
4053         int pid;
4054
4055         do {
4056                 sigset_t mask;
4057
4058                 /* Poll all children for changes in their state */
4059                 got_sigchld = 0;
4060                 /* if job control is active, accept stopped processes too */
4061                 pid = waitpid(-1, status, doing_jobctl ? (WNOHANG|WUNTRACED) : WNOHANG);
4062                 if (pid != 0)
4063                         break; /* Error (e.g. EINTR, ECHILD) or pid */
4064
4065                 /* Children exist, but none are ready. Sleep until interesting signal */
4066 #if 1
4067                 sigfillset(&mask);
4068                 sigprocmask(SIG_SETMASK, &mask, &mask);
4069                 while (!got_sigchld && !pending_sig)
4070                         sigsuspend(&mask);
4071                 sigprocmask(SIG_SETMASK, &mask, NULL);
4072 #else /* unsafe: a signal can set pending_sig after check, but before pause() */
4073                 while (!got_sigchld && !pending_sig)
4074                         pause();
4075 #endif
4076
4077                 /* If it was SIGCHLD, poll children again */
4078         } while (got_sigchld);
4079
4080         return pid;
4081 }
4082
4083 #define DOWAIT_NONBLOCK 0
4084 #define DOWAIT_BLOCK    1
4085 #define DOWAIT_BLOCK_OR_SIG 2
4086
4087 static int
4088 dowait(int block, struct job *job)
4089 {
4090         int pid;
4091         int status;
4092         struct job *jp;
4093         struct job *thisjob = NULL;
4094
4095         TRACE(("dowait(0x%x) called\n", block));
4096
4097         /* It's wrong to call waitpid() outside of INT_OFF region:
4098          * signal can arrive just after syscall return and handler can
4099          * longjmp away, losing stop/exit notification processing.
4100          * Thus, for "jobs" builtin, and for waiting for a fg job,
4101          * we call waitpid() (blocking or non-blocking) inside INT_OFF.
4102          *
4103          * However, for "wait" builtin it is wrong to simply call waitpid()
4104          * in INT_OFF region: "wait" needs to wait for any running job
4105          * to change state, but should exit on any trap too.
4106          * In INT_OFF region, a signal just before syscall entry can set
4107          * pending_sig variables, but we can't check them, and we would
4108          * either enter a sleeping waitpid() (BUG), or need to busy-loop.
4109          *
4110          * Because of this, we run inside INT_OFF, but use a special routine
4111          * which combines waitpid() and sigsuspend().
4112          * This is the reason why we need to have a handler for SIGCHLD:
4113          * SIG_DFL handler does not wake sigsuspend().
4114          */
4115         INT_OFF;
4116         if (block == DOWAIT_BLOCK_OR_SIG) {
4117                 pid = wait_block_or_sig(&status);
4118         } else {
4119                 int wait_flags = 0;
4120                 if (block == DOWAIT_NONBLOCK)
4121                         wait_flags = WNOHANG;
4122                 /* if job control is active, accept stopped processes too */
4123                 if (doing_jobctl)
4124                         wait_flags |= WUNTRACED;
4125                 /* NB: _not_ safe_waitpid, we need to detect EINTR */
4126                 pid = waitpid(-1, &status, wait_flags);
4127         }
4128         TRACE(("wait returns pid=%d, status=0x%x, errno=%d(%s)\n",
4129                                 pid, status, errno, strerror(errno)));
4130         if (pid <= 0)
4131                 goto out;
4132
4133         thisjob = NULL;
4134         for (jp = curjob; jp; jp = jp->prev_job) {
4135                 int jobstate;
4136                 struct procstat *ps;
4137                 struct procstat *psend;
4138                 if (jp->state == JOBDONE)
4139                         continue;
4140                 jobstate = JOBDONE;
4141                 ps = jp->ps;
4142                 psend = ps + jp->nprocs;
4143                 do {
4144                         if (ps->ps_pid == pid) {
4145                                 TRACE(("Job %d: changing status of proc %d "
4146                                         "from 0x%x to 0x%x\n",
4147                                         jobno(jp), pid, ps->ps_status, status));
4148                                 ps->ps_status = status;
4149                                 thisjob = jp;
4150                         }
4151                         if (ps->ps_status == -1)
4152                                 jobstate = JOBRUNNING;
4153 #if JOBS
4154                         if (jobstate == JOBRUNNING)
4155                                 continue;
4156                         if (WIFSTOPPED(ps->ps_status)) {
4157                                 jp->stopstatus = ps->ps_status;
4158                                 jobstate = JOBSTOPPED;
4159                         }
4160 #endif
4161                 } while (++ps < psend);
4162                 if (!thisjob)
4163                         continue;
4164
4165                 /* Found the job where one of its processes changed its state.
4166                  * Is there at least one live and running process in this job? */
4167                 if (jobstate != JOBRUNNING) {
4168                         /* No. All live processes in the job are stopped
4169                          * (JOBSTOPPED) or there are no live processes (JOBDONE)
4170                          */
4171                         thisjob->changed = 1;
4172                         if (thisjob->state != jobstate) {
4173                                 TRACE(("Job %d: changing state from %d to %d\n",
4174                                         jobno(thisjob), thisjob->state, jobstate));
4175                                 thisjob->state = jobstate;
4176 #if JOBS
4177                                 if (jobstate == JOBSTOPPED)
4178                                         set_curjob(thisjob, CUR_STOPPED);
4179 #endif
4180                         }
4181                 }
4182                 goto out;
4183         }
4184         /* The process wasn't found in job list */
4185         if (JOBS && !WIFSTOPPED(status))
4186                 jobless--;
4187  out:
4188         INT_ON;
4189
4190         if (thisjob && thisjob == job) {
4191                 char s[48 + 1];
4192                 int len;
4193
4194                 len = sprint_status48(s, status, 1);
4195                 if (len) {
4196                         s[len] = '\n';
4197                         s[len + 1] = '\0';
4198                         out2str(s);
4199                 }
4200         }
4201         return pid;
4202 }
4203
4204 #if JOBS
4205 static void
4206 showjob(struct job *jp, int mode)
4207 {
4208         struct procstat *ps;
4209         struct procstat *psend;
4210         int col;
4211         int indent_col;
4212         char s[16 + 16 + 48];
4213         FILE *out = (mode & SHOW_STDERR ? stderr : stdout);
4214
4215         ps = jp->ps;
4216
4217         if (mode & SHOW_ONLY_PGID) { /* jobs -p */
4218                 /* just output process (group) id of pipeline */
4219                 fprintf(out, "%d\n", ps->ps_pid);
4220                 return;
4221         }
4222
4223         col = fmtstr(s, 16, "[%d]   ", jobno(jp));
4224         indent_col = col;
4225
4226         if (jp == curjob)
4227                 s[col - 3] = '+';
4228         else if (curjob && jp == curjob->prev_job)
4229                 s[col - 3] = '-';
4230
4231         if (mode & SHOW_PIDS)
4232                 col += fmtstr(s + col, 16, "%d ", ps->ps_pid);
4233
4234         psend = ps + jp->nprocs;
4235
4236         if (jp->state == JOBRUNNING) {
4237                 strcpy(s + col, "Running");
4238                 col += sizeof("Running") - 1;
4239         } else {
4240                 int status = psend[-1].ps_status;
4241                 if (jp->state == JOBSTOPPED)
4242                         status = jp->stopstatus;
4243                 col += sprint_status48(s + col, status, 0);
4244         }
4245         /* By now, "[JOBID]*  [maybe PID] STATUS" is printed */
4246
4247         /* This loop either prints "<cmd1> | <cmd2> | <cmd3>" line
4248          * or prints several "PID             | <cmdN>" lines,
4249          * depending on SHOW_PIDS bit.
4250          * We do not print status of individual processes
4251          * between PID and <cmdN>. bash does it, but not very well:
4252          * first line shows overall job status, not process status,
4253          * making it impossible to know 1st process status.
4254          */
4255         goto start;
4256         do {
4257                 /* for each process */
4258                 s[0] = '\0';
4259                 col = 33;
4260                 if (mode & SHOW_PIDS)
4261                         col = fmtstr(s, 48, "\n%*c%d ", indent_col, ' ', ps->ps_pid) - 1;
4262  start:
4263                 fprintf(out, "%s%*c%s%s",
4264                                 s,
4265                                 33 - col >= 0 ? 33 - col : 0, ' ',
4266                                 ps == jp->ps ? "" : "| ",
4267                                 ps->ps_cmd
4268                 );
4269         } while (++ps != psend);
4270         newline_and_flush(out);
4271
4272         jp->changed = 0;
4273
4274         if (jp->state == JOBDONE) {
4275                 TRACE(("showjob: freeing job %d\n", jobno(jp)));
4276                 freejob(jp);
4277         }
4278 }
4279
4280 /*
4281  * Print a list of jobs.  If "change" is nonzero, only print jobs whose
4282  * statuses have changed since the last call to showjobs.
4283  */
4284 static void
4285 showjobs(int mode)
4286 {
4287         struct job *jp;
4288
4289         TRACE(("showjobs(0x%x) called\n", mode));
4290
4291         /* Handle all finished jobs */
4292         while (dowait(DOWAIT_NONBLOCK, NULL) > 0)
4293                 continue;
4294
4295         for (jp = curjob; jp; jp = jp->prev_job) {
4296                 if (!(mode & SHOW_CHANGED) || jp->changed) {
4297                         showjob(jp, mode);
4298                 }
4299         }
4300 }
4301
4302 static int FAST_FUNC
4303 jobscmd(int argc UNUSED_PARAM, char **argv)
4304 {
4305         int mode, m;
4306
4307         mode = 0;
4308         while ((m = nextopt("lp")) != '\0') {
4309                 if (m == 'l')
4310                         mode |= SHOW_PIDS;
4311                 else
4312                         mode |= SHOW_ONLY_PGID;
4313         }
4314
4315         argv = argptr;
4316         if (*argv) {
4317                 do
4318                         showjob(getjob(*argv, 0), mode);
4319                 while (*++argv);
4320         } else {
4321                 showjobs(mode);
4322         }
4323
4324         return 0;
4325 }
4326 #endif /* JOBS */
4327
4328 /* Called only on finished or stopped jobs (no members are running) */
4329 static int
4330 getstatus(struct job *job)
4331 {
4332         int status;
4333         int retval;
4334         struct procstat *ps;
4335
4336         /* Fetch last member's status */
4337         ps = job->ps + job->nprocs - 1;
4338         status = ps->ps_status;
4339         if (pipefail) {
4340                 /* "set -o pipefail" mode: use last _nonzero_ status */
4341                 while (status == 0 && --ps >= job->ps)
4342                         status = ps->ps_status;
4343         }
4344
4345         retval = WEXITSTATUS(status);
4346         if (!WIFEXITED(status)) {
4347 #if JOBS
4348                 retval = WSTOPSIG(status);
4349                 if (!WIFSTOPPED(status))
4350 #endif
4351                 {
4352                         /* XXX: limits number of signals */
4353                         retval = WTERMSIG(status);
4354 #if JOBS
4355                         if (retval == SIGINT)
4356                                 job->sigint = 1;
4357 #endif
4358                 }
4359                 retval += 128;
4360         }
4361         TRACE(("getstatus: job %d, nproc %d, status 0x%x, retval 0x%x\n",
4362                 jobno(job), job->nprocs, status, retval));
4363         return retval;
4364 }
4365
4366 static int FAST_FUNC
4367 waitcmd(int argc UNUSED_PARAM, char **argv)
4368 {
4369         struct job *job;
4370         int retval;
4371         struct job *jp;
4372
4373         nextopt(nullstr);
4374         retval = 0;
4375
4376         argv = argptr;
4377         if (!*argv) {
4378                 /* wait for all jobs */
4379                 for (;;) {
4380                         jp = curjob;
4381                         while (1) {
4382                                 if (!jp) /* no running procs */
4383                                         goto ret;
4384                                 if (jp->state == JOBRUNNING)
4385                                         break;
4386                                 jp->waited = 1;
4387                                 jp = jp->prev_job;
4388                         }
4389         /* man bash:
4390          * "When bash is waiting for an asynchronous command via
4391          * the wait builtin, the reception of a signal for which a trap
4392          * has been set will cause the wait builtin to return immediately
4393          * with an exit status greater than 128, immediately after which
4394          * the trap is executed."
4395          */
4396                         dowait(DOWAIT_BLOCK_OR_SIG, NULL);
4397         /* if child sends us a signal *and immediately exits*,
4398          * dowait() returns pid > 0. Check this case,
4399          * not "if (dowait() < 0)"!
4400          */
4401                         if (pending_sig)
4402                                 goto sigout;
4403                 }
4404         }
4405
4406         retval = 127;
4407         do {
4408                 if (**argv != '%') {
4409                         pid_t pid = number(*argv);
4410                         job = curjob;
4411                         while (1) {
4412                                 if (!job)
4413                                         goto repeat;
4414                                 if (job->ps[job->nprocs - 1].ps_pid == pid)
4415                                         break;
4416                                 job = job->prev_job;
4417                         }
4418                 } else {
4419                         job = getjob(*argv, 0);
4420                 }
4421                 /* loop until process terminated or stopped */
4422                 while (job->state == JOBRUNNING) {
4423                         dowait(DOWAIT_BLOCK_OR_SIG, NULL);
4424                         if (pending_sig)
4425                                 goto sigout;
4426                 }
4427                 job->waited = 1;
4428                 retval = getstatus(job);
4429  repeat: ;
4430         } while (*++argv);
4431
4432  ret:
4433         return retval;
4434  sigout:
4435         retval = 128 + pending_sig;
4436         return retval;
4437 }
4438
4439 static struct job *
4440 growjobtab(void)
4441 {
4442         size_t len;
4443         ptrdiff_t offset;
4444         struct job *jp, *jq;
4445
4446         len = njobs * sizeof(*jp);
4447         jq = jobtab;
4448         jp = ckrealloc(jq, len + 4 * sizeof(*jp));
4449
4450         offset = (char *)jp - (char *)jq;
4451         if (offset) {
4452                 /* Relocate pointers */
4453                 size_t l = len;
4454
4455                 jq = (struct job *)((char *)jq + l);
4456                 while (l) {
4457                         l -= sizeof(*jp);
4458                         jq--;
4459 #define joff(p) ((struct job *)((char *)(p) + l))
4460 #define jmove(p) (p) = (void *)((char *)(p) + offset)
4461                         if (joff(jp)->ps == &jq->ps0)
4462                                 jmove(joff(jp)->ps);
4463                         if (joff(jp)->prev_job)
4464                                 jmove(joff(jp)->prev_job);
4465                 }
4466                 if (curjob)
4467                         jmove(curjob);
4468 #undef joff
4469 #undef jmove
4470         }
4471
4472         njobs += 4;
4473         jobtab = jp;
4474         jp = (struct job *)((char *)jp + len);
4475         jq = jp + 3;
4476         do {
4477                 jq->used = 0;
4478         } while (--jq >= jp);
4479         return jp;
4480 }
4481
4482 /*
4483  * Return a new job structure.
4484  * Called with interrupts off.
4485  */
4486 static struct job *
4487 makejob(/*union node *node,*/ int nprocs)
4488 {
4489         int i;
4490         struct job *jp;
4491
4492         for (i = njobs, jp = jobtab; ; jp++) {
4493                 if (--i < 0) {
4494                         jp = growjobtab();
4495                         break;
4496                 }
4497                 if (jp->used == 0)
4498                         break;
4499                 if (jp->state != JOBDONE || !jp->waited)
4500                         continue;
4501 #if JOBS
4502                 if (doing_jobctl)
4503                         continue;
4504 #endif
4505                 freejob(jp);
4506                 break;
4507         }
4508         memset(jp, 0, sizeof(*jp));
4509 #if JOBS
4510         /* jp->jobctl is a bitfield.
4511          * "jp->jobctl |= doing_jobctl" likely to give awful code */
4512         if (doing_jobctl)
4513                 jp->jobctl = 1;
4514 #endif
4515         jp->prev_job = curjob;
4516         curjob = jp;
4517         jp->used = 1;
4518         jp->ps = &jp->ps0;
4519         if (nprocs > 1) {
4520                 jp->ps = ckmalloc(nprocs * sizeof(struct procstat));
4521         }
4522         TRACE(("makejob(%d) returns %%%d\n", nprocs,
4523                                 jobno(jp)));
4524         return jp;
4525 }
4526
4527 #if JOBS
4528 /*
4529  * Return a string identifying a command (to be printed by the
4530  * jobs command).
4531  */
4532 static char *cmdnextc;
4533
4534 static void
4535 cmdputs(const char *s)
4536 {
4537         static const char vstype[VSTYPE + 1][3] = {
4538                 "", "}", "-", "+", "?", "=",
4539                 "%", "%%", "#", "##"
4540                 IF_BASH_SUBSTR(, ":")
4541                 IF_BASH_PATTERN_SUBST(, "/", "//")
4542         };
4543
4544         const char *p, *str;
4545         char cc[2];
4546         char *nextc;
4547         unsigned char c;
4548         unsigned char subtype = 0;
4549         int quoted = 0;
4550
4551         cc[1] = '\0';
4552         nextc = makestrspace((strlen(s) + 1) * 8, cmdnextc);
4553         p = s;
4554         while ((c = *p++) != '\0') {
4555                 str = NULL;
4556                 switch (c) {
4557                 case CTLESC:
4558                         c = *p++;
4559                         break;
4560                 case CTLVAR:
4561                         subtype = *p++;
4562                         if ((subtype & VSTYPE) == VSLENGTH)
4563                                 str = "${#";
4564                         else
4565                                 str = "${";
4566                         goto dostr;
4567                 case CTLENDVAR:
4568                         str = "\"}" + !(quoted & 1);
4569                         quoted >>= 1;
4570                         subtype = 0;
4571                         goto dostr;
4572                 case CTLBACKQ:
4573                         str = "$(...)";
4574                         goto dostr;
4575 #if ENABLE_FEATURE_SH_MATH
4576                 case CTLARI:
4577                         str = "$((";
4578                         goto dostr;
4579                 case CTLENDARI:
4580                         str = "))";
4581                         goto dostr;
4582 #endif
4583                 case CTLQUOTEMARK:
4584                         quoted ^= 1;
4585                         c = '"';
4586                         break;
4587                 case '=':
4588                         if (subtype == 0)
4589                                 break;
4590                         if ((subtype & VSTYPE) != VSNORMAL)
4591                                 quoted <<= 1;
4592                         str = vstype[subtype & VSTYPE];
4593                         if (subtype & VSNUL)
4594                                 c = ':';
4595                         else
4596                                 goto checkstr;
4597                         break;
4598                 case '\'':
4599                 case '\\':
4600                 case '"':
4601                 case '$':
4602                         /* These can only happen inside quotes */
4603                         cc[0] = c;
4604                         str = cc;
4605                         c = '\\';
4606                         break;
4607                 default:
4608                         break;
4609                 }
4610                 USTPUTC(c, nextc);
4611  checkstr:
4612                 if (!str)
4613                         continue;
4614  dostr:
4615                 while ((c = *str++) != '\0') {
4616                         USTPUTC(c, nextc);
4617                 }
4618         } /* while *p++ not NUL */
4619
4620         if (quoted & 1) {
4621                 USTPUTC('"', nextc);
4622         }
4623         *nextc = 0;
4624         cmdnextc = nextc;
4625 }
4626
4627 /* cmdtxt() and cmdlist() call each other */
4628 static void cmdtxt(union node *n);
4629
4630 static void
4631 cmdlist(union node *np, int sep)
4632 {
4633         for (; np; np = np->narg.next) {
4634                 if (!sep)
4635                         cmdputs(" ");
4636                 cmdtxt(np);
4637                 if (sep && np->narg.next)
4638                         cmdputs(" ");
4639         }
4640 }
4641
4642 static void
4643 cmdtxt(union node *n)
4644 {
4645         union node *np;
4646         struct nodelist *lp;
4647         const char *p;
4648
4649         if (!n)
4650                 return;
4651         switch (n->type) {
4652         default:
4653 #if DEBUG
4654                 abort();
4655 #endif
4656         case NPIPE:
4657                 lp = n->npipe.cmdlist;
4658                 for (;;) {
4659                         cmdtxt(lp->n);
4660                         lp = lp->next;
4661                         if (!lp)
4662                                 break;
4663                         cmdputs(" | ");
4664                 }
4665                 break;
4666         case NSEMI:
4667                 p = "; ";
4668                 goto binop;
4669         case NAND:
4670                 p = " && ";
4671                 goto binop;
4672         case NOR:
4673                 p = " || ";
4674  binop:
4675                 cmdtxt(n->nbinary.ch1);
4676                 cmdputs(p);
4677                 n = n->nbinary.ch2;
4678                 goto donode;
4679         case NREDIR:
4680         case NBACKGND:
4681                 n = n->nredir.n;
4682                 goto donode;
4683         case NNOT:
4684                 cmdputs("!");
4685                 n = n->nnot.com;
4686  donode:
4687                 cmdtxt(n);
4688                 break;
4689         case NIF:
4690                 cmdputs("if ");
4691                 cmdtxt(n->nif.test);
4692                 cmdputs("; then ");
4693                 if (n->nif.elsepart) {
4694                         cmdtxt(n->nif.ifpart);
4695                         cmdputs("; else ");
4696                         n = n->nif.elsepart;
4697                 } else {
4698                         n = n->nif.ifpart;
4699                 }
4700                 p = "; fi";
4701                 goto dotail;
4702         case NSUBSHELL:
4703                 cmdputs("(");
4704                 n = n->nredir.n;
4705                 p = ")";
4706                 goto dotail;
4707         case NWHILE:
4708                 p = "while ";
4709                 goto until;
4710         case NUNTIL:
4711                 p = "until ";
4712  until:
4713                 cmdputs(p);
4714                 cmdtxt(n->nbinary.ch1);
4715                 n = n->nbinary.ch2;
4716                 p = "; done";
4717  dodo:
4718                 cmdputs("; do ");
4719  dotail:
4720                 cmdtxt(n);
4721                 goto dotail2;
4722         case NFOR:
4723                 cmdputs("for ");
4724                 cmdputs(n->nfor.var);
4725                 cmdputs(" in ");
4726                 cmdlist(n->nfor.args, 1);
4727                 n = n->nfor.body;
4728                 p = "; done";
4729                 goto dodo;
4730         case NDEFUN:
4731                 cmdputs(n->narg.text);
4732                 p = "() { ... }";
4733                 goto dotail2;
4734         case NCMD:
4735                 cmdlist(n->ncmd.args, 1);
4736                 cmdlist(n->ncmd.redirect, 0);
4737                 break;
4738         case NARG:
4739                 p = n->narg.text;
4740  dotail2:
4741                 cmdputs(p);
4742                 break;
4743         case NHERE:
4744         case NXHERE:
4745                 p = "<<...";
4746                 goto dotail2;
4747         case NCASE:
4748                 cmdputs("case ");
4749                 cmdputs(n->ncase.expr->narg.text);
4750                 cmdputs(" in ");
4751                 for (np = n->ncase.cases; np; np = np->nclist.next) {
4752                         cmdtxt(np->nclist.pattern);
4753                         cmdputs(") ");
4754                         cmdtxt(np->nclist.body);
4755                         cmdputs(";; ");
4756                 }
4757                 p = "esac";
4758                 goto dotail2;
4759         case NTO:
4760                 p = ">";
4761                 goto redir;
4762         case NCLOBBER:
4763                 p = ">|";
4764                 goto redir;
4765         case NAPPEND:
4766                 p = ">>";
4767                 goto redir;
4768 #if BASH_REDIR_OUTPUT
4769         case NTO2:
4770 #endif
4771         case NTOFD:
4772                 p = ">&";
4773                 goto redir;
4774         case NFROM:
4775                 p = "<";
4776                 goto redir;
4777         case NFROMFD:
4778                 p = "<&";
4779                 goto redir;
4780         case NFROMTO:
4781                 p = "<>";
4782  redir:
4783                 cmdputs(utoa(n->nfile.fd));
4784                 cmdputs(p);
4785                 if (n->type == NTOFD || n->type == NFROMFD) {
4786                         cmdputs(utoa(n->ndup.dupfd));
4787                         break;
4788                 }
4789                 n = n->nfile.fname;
4790                 goto donode;
4791         }
4792 }
4793
4794 static char *
4795 commandtext(union node *n)
4796 {
4797         char *name;
4798
4799         STARTSTACKSTR(cmdnextc);
4800         cmdtxt(n);
4801         name = stackblock();
4802         TRACE(("commandtext: name %p, end %p\n", name, cmdnextc));
4803         return ckstrdup(name);
4804 }
4805 #endif /* JOBS */
4806
4807 /*
4808  * Fork off a subshell.  If we are doing job control, give the subshell its
4809  * own process group.  Jp is a job structure that the job is to be added to.
4810  * N is the command that will be evaluated by the child.  Both jp and n may
4811  * be NULL.  The mode parameter can be one of the following:
4812  *      FORK_FG - Fork off a foreground process.
4813  *      FORK_BG - Fork off a background process.
4814  *      FORK_NOJOB - Like FORK_FG, but don't give the process its own
4815  *                   process group even if job control is on.
4816  *
4817  * When job control is turned off, background processes have their standard
4818  * input redirected to /dev/null (except for the second and later processes
4819  * in a pipeline).
4820  *
4821  * Called with interrupts off.
4822  */
4823 /*
4824  * Clear traps on a fork.
4825  */
4826 static void
4827 clear_traps(void)
4828 {
4829         char **tp;
4830
4831         INT_OFF;
4832         for (tp = trap; tp < &trap[NSIG]; tp++) {
4833                 if (*tp && **tp) {      /* trap not NULL or "" (SIG_IGN) */
4834                         if (trap_ptr == trap)
4835                                 free(*tp);
4836                         /* else: it "belongs" to trap_ptr vector, don't free */
4837                         *tp = NULL;
4838                         if ((tp - trap) != 0)
4839                                 setsignal(tp - trap);
4840                 }
4841         }
4842         may_have_traps = 0;
4843         INT_ON;
4844 }
4845
4846 /* Lives far away from here, needed for forkchild */
4847 static void closescript(void);
4848
4849 /* Called after fork(), in child */
4850 /* jp and n are NULL when called by openhere() for heredoc support */
4851 static NOINLINE void
4852 forkchild(struct job *jp, union node *n, int mode)
4853 {
4854         int oldlvl;
4855
4856         TRACE(("Child shell %d\n", getpid()));
4857         oldlvl = shlvl;
4858         shlvl++;
4859
4860         /* man bash: "Non-builtin commands run by bash have signal handlers
4861          * set to the values inherited by the shell from its parent".
4862          * Do we do it correctly? */
4863
4864         closescript();
4865
4866         if (mode == FORK_NOJOB          /* is it `xxx` ? */
4867          && n && n->type == NCMD        /* is it single cmd? */
4868         /* && n->ncmd.args->type == NARG - always true? */
4869          && n->ncmd.args && strcmp(n->ncmd.args->narg.text, "trap") == 0
4870          && n->ncmd.args->narg.next == NULL /* "trap" with no arguments */
4871         /* && n->ncmd.args->narg.backquote == NULL - do we need to check this? */
4872         ) {
4873                 TRACE(("Trap hack\n"));
4874                 /* Awful hack for `trap` or $(trap).
4875                  *
4876                  * http://www.opengroup.org/onlinepubs/009695399/utilities/trap.html
4877                  * contains an example where "trap" is executed in a subshell:
4878                  *
4879                  * save_traps=$(trap)
4880                  * ...
4881                  * eval "$save_traps"
4882                  *
4883                  * Standard does not say that "trap" in subshell shall print
4884                  * parent shell's traps. It only says that its output
4885                  * must have suitable form, but then, in the above example
4886                  * (which is not supposed to be normative), it implies that.
4887                  *
4888                  * bash (and probably other shell) does implement it
4889                  * (traps are reset to defaults, but "trap" still shows them),
4890                  * but as a result, "trap" logic is hopelessly messed up:
4891                  *
4892                  * # trap
4893                  * trap -- 'echo Ho' SIGWINCH  <--- we have a handler
4894                  * # (trap)        <--- trap is in subshell - no output (correct, traps are reset)
4895                  * # true | trap   <--- trap is in subshell - no output (ditto)
4896                  * # echo `true | trap`    <--- in subshell - output (but traps are reset!)
4897                  * trap -- 'echo Ho' SIGWINCH
4898                  * # echo `(trap)`         <--- in subshell in subshell - output
4899                  * trap -- 'echo Ho' SIGWINCH
4900                  * # echo `true | (trap)`  <--- in subshell in subshell in subshell - output!
4901                  * trap -- 'echo Ho' SIGWINCH
4902                  *
4903                  * The rules when to forget and when to not forget traps
4904                  * get really complex and nonsensical.
4905                  *
4906                  * Our solution: ONLY bare $(trap) or `trap` is special.
4907                  */
4908                 /* Save trap handler strings for trap builtin to print */
4909                 trap_ptr = xmemdup(trap, sizeof(trap));
4910                 /* Fall through into clearing traps */
4911         }
4912         clear_traps();
4913 #if JOBS
4914         /* do job control only in root shell */
4915         doing_jobctl = 0;
4916         if (mode != FORK_NOJOB && jp->jobctl && oldlvl == 0) {
4917                 pid_t pgrp;
4918
4919                 if (jp->nprocs == 0)
4920                         pgrp = getpid();
4921                 else
4922                         pgrp = jp->ps[0].ps_pid;
4923                 /* this can fail because we are doing it in the parent also */
4924                 setpgid(0, pgrp);
4925                 if (mode == FORK_FG)
4926                         xtcsetpgrp(ttyfd, pgrp);
4927                 setsignal(SIGTSTP);
4928                 setsignal(SIGTTOU);
4929         } else
4930 #endif
4931         if (mode == FORK_BG) {
4932                 /* man bash: "When job control is not in effect,
4933                  * asynchronous commands ignore SIGINT and SIGQUIT" */
4934                 ignoresig(SIGINT);
4935                 ignoresig(SIGQUIT);
4936                 if (jp->nprocs == 0) {
4937                         close(0);
4938                         if (open(bb_dev_null, O_RDONLY) != 0)
4939                                 ash_msg_and_raise_error("can't open '%s'", bb_dev_null);
4940                 }
4941         }
4942         if (oldlvl == 0) {
4943                 if (iflag) { /* why if iflag only? */
4944                         setsignal(SIGINT);
4945                         setsignal(SIGTERM);
4946                 }
4947                 /* man bash:
4948                  * "In all cases, bash ignores SIGQUIT. Non-builtin
4949                  * commands run by bash have signal handlers
4950                  * set to the values inherited by the shell
4951                  * from its parent".
4952                  * Take care of the second rule: */
4953                 setsignal(SIGQUIT);
4954         }
4955 #if JOBS
4956         if (n && n->type == NCMD
4957          && n->ncmd.args && strcmp(n->ncmd.args->narg.text, "jobs") == 0
4958         ) {
4959                 TRACE(("Job hack\n"));
4960                 /* "jobs": we do not want to clear job list for it,
4961                  * instead we remove only _its_ own_ job from job list.
4962                  * This makes "jobs .... | cat" more useful.
4963                  */
4964                 freejob(curjob);
4965                 return;
4966         }
4967 #endif
4968         for (jp = curjob; jp; jp = jp->prev_job)
4969                 freejob(jp);
4970         jobless = 0;
4971 }
4972
4973 /* Called after fork(), in parent */
4974 #if !JOBS
4975 #define forkparent(jp, n, mode, pid) forkparent(jp, mode, pid)
4976 #endif
4977 static void
4978 forkparent(struct job *jp, union node *n, int mode, pid_t pid)
4979 {
4980         TRACE(("In parent shell: child = %d\n", pid));
4981         if (!jp) {
4982                 /* jp is NULL when called by openhere() for heredoc support */
4983                 while (jobless && dowait(DOWAIT_NONBLOCK, NULL) > 0)
4984                         continue;
4985                 jobless++;
4986                 return;
4987         }
4988 #if JOBS
4989         if (mode != FORK_NOJOB && jp->jobctl) {
4990                 int pgrp;
4991
4992                 if (jp->nprocs == 0)
4993                         pgrp = pid;
4994                 else
4995                         pgrp = jp->ps[0].ps_pid;
4996                 /* This can fail because we are doing it in the child also */
4997                 setpgid(pid, pgrp);
4998         }
4999 #endif
5000         if (mode == FORK_BG) {
5001                 backgndpid = pid;               /* set $! */
5002                 set_curjob(jp, CUR_RUNNING);
5003         }
5004         if (jp) {
5005                 struct procstat *ps = &jp->ps[jp->nprocs++];
5006                 ps->ps_pid = pid;
5007                 ps->ps_status = -1;
5008                 ps->ps_cmd = nullstr;
5009 #if JOBS
5010                 if (doing_jobctl && n)
5011                         ps->ps_cmd = commandtext(n);
5012 #endif
5013         }
5014 }
5015
5016 /* jp and n are NULL when called by openhere() for heredoc support */
5017 static int
5018 forkshell(struct job *jp, union node *n, int mode)
5019 {
5020         int pid;
5021
5022         TRACE(("forkshell(%%%d, %p, %d) called\n", jobno(jp), n, mode));
5023         pid = fork();
5024         if (pid < 0) {
5025                 TRACE(("Fork failed, errno=%d", errno));
5026                 if (jp)
5027                         freejob(jp);
5028                 ash_msg_and_raise_error("can't fork");
5029         }
5030         if (pid == 0) {
5031                 CLEAR_RANDOM_T(&random_gen); /* or else $RANDOM repeats in child */
5032                 forkchild(jp, n, mode);
5033         } else {
5034                 forkparent(jp, n, mode, pid);
5035         }
5036         return pid;
5037 }
5038
5039 /*
5040  * Wait for job to finish.
5041  *
5042  * Under job control we have the problem that while a child process
5043  * is running interrupts generated by the user are sent to the child
5044  * but not to the shell.  This means that an infinite loop started by
5045  * an interactive user may be hard to kill.  With job control turned off,
5046  * an interactive user may place an interactive program inside a loop.
5047  * If the interactive program catches interrupts, the user doesn't want
5048  * these interrupts to also abort the loop.  The approach we take here
5049  * is to have the shell ignore interrupt signals while waiting for a
5050  * foreground process to terminate, and then send itself an interrupt
5051  * signal if the child process was terminated by an interrupt signal.
5052  * Unfortunately, some programs want to do a bit of cleanup and then
5053  * exit on interrupt; unless these processes terminate themselves by
5054  * sending a signal to themselves (instead of calling exit) they will
5055  * confuse this approach.
5056  *
5057  * Called with interrupts off.
5058  */
5059 static int
5060 waitforjob(struct job *jp)
5061 {
5062         int st;
5063
5064         TRACE(("waitforjob(%%%d) called\n", jobno(jp)));
5065
5066         INT_OFF;
5067         while (jp->state == JOBRUNNING) {
5068                 /* In non-interactive shells, we _can_ get
5069                  * a keyboard signal here and be EINTRed,
5070                  * but we just loop back, waiting for command to complete.
5071                  *
5072                  * man bash:
5073                  * "If bash is waiting for a command to complete and receives
5074                  * a signal for which a trap has been set, the trap
5075                  * will not be executed until the command completes."
5076                  *
5077                  * Reality is that even if trap is not set, bash
5078                  * will not act on the signal until command completes.
5079                  * Try this. sleep5intoff.c:
5080                  * #include <signal.h>
5081                  * #include <unistd.h>
5082                  * int main() {
5083                  *         sigset_t set;
5084                  *         sigemptyset(&set);
5085                  *         sigaddset(&set, SIGINT);
5086                  *         sigaddset(&set, SIGQUIT);
5087                  *         sigprocmask(SIG_BLOCK, &set, NULL);
5088                  *         sleep(5);
5089                  *         return 0;
5090                  * }
5091                  * $ bash -c './sleep5intoff; echo hi'
5092                  * ^C^C^C^C <--- pressing ^C once a second
5093                  * $ _
5094                  * $ bash -c './sleep5intoff; echo hi'
5095                  * ^\^\^\^\hi <--- pressing ^\ (SIGQUIT)
5096                  * $ _
5097                  */
5098                 dowait(DOWAIT_BLOCK, jp);
5099         }
5100         INT_ON;
5101
5102         st = getstatus(jp);
5103 #if JOBS
5104         if (jp->jobctl) {
5105                 xtcsetpgrp(ttyfd, rootpid);
5106                 restore_tty_if_stopped_or_signaled(jp);
5107
5108                 /*
5109                  * This is truly gross.
5110                  * If we're doing job control, then we did a TIOCSPGRP which
5111                  * caused us (the shell) to no longer be in the controlling
5112                  * session -- so we wouldn't have seen any ^C/SIGINT.  So, we
5113                  * intuit from the subprocess exit status whether a SIGINT
5114                  * occurred, and if so interrupt ourselves.  Yuck.  - mycroft
5115                  */
5116                 if (jp->sigint) /* TODO: do the same with all signals */
5117                         raise(SIGINT); /* ... by raise(jp->sig) instead? */
5118         }
5119         if (jp->state == JOBDONE)
5120 #endif
5121                 freejob(jp);
5122         return st;
5123 }
5124
5125 /*
5126  * return 1 if there are stopped jobs, otherwise 0
5127  */
5128 static int
5129 stoppedjobs(void)
5130 {
5131         struct job *jp;
5132         int retval;
5133
5134         retval = 0;
5135         if (job_warning)
5136                 goto out;
5137         jp = curjob;
5138         if (jp && jp->state == JOBSTOPPED) {
5139                 out2str("You have stopped jobs.\n");
5140                 job_warning = 2;
5141                 retval++;
5142         }
5143  out:
5144         return retval;
5145 }
5146
5147
5148 /*
5149  * Code for dealing with input/output redirection.
5150  */
5151
5152 #undef EMPTY
5153 #undef CLOSED
5154 #define EMPTY -2                /* marks an unused slot in redirtab */
5155 #define CLOSED -3               /* marks a slot of previously-closed fd */
5156
5157 /*
5158  * Open a file in noclobber mode.
5159  * The code was copied from bash.
5160  */
5161 static int
5162 noclobberopen(const char *fname)
5163 {
5164         int r, fd;
5165         struct stat finfo, finfo2;
5166
5167         /*
5168          * If the file exists and is a regular file, return an error
5169          * immediately.
5170          */
5171         r = stat(fname, &finfo);
5172         if (r == 0 && S_ISREG(finfo.st_mode)) {
5173                 errno = EEXIST;
5174                 return -1;
5175         }
5176
5177         /*
5178          * If the file was not present (r != 0), make sure we open it
5179          * exclusively so that if it is created before we open it, our open
5180          * will fail.  Make sure that we do not truncate an existing file.
5181          * Note that we don't turn on O_EXCL unless the stat failed -- if the
5182          * file was not a regular file, we leave O_EXCL off.
5183          */
5184         if (r != 0)
5185                 return open(fname, O_WRONLY|O_CREAT|O_EXCL, 0666);
5186         fd = open(fname, O_WRONLY|O_CREAT, 0666);
5187
5188         /* If the open failed, return the file descriptor right away. */
5189         if (fd < 0)
5190                 return fd;
5191
5192         /*
5193          * OK, the open succeeded, but the file may have been changed from a
5194          * non-regular file to a regular file between the stat and the open.
5195          * We are assuming that the O_EXCL open handles the case where FILENAME
5196          * did not exist and is symlinked to an existing file between the stat
5197          * and open.
5198          */
5199
5200         /*
5201          * If we can open it and fstat the file descriptor, and neither check
5202          * revealed that it was a regular file, and the file has not been
5203          * replaced, return the file descriptor.
5204          */
5205         if (fstat(fd, &finfo2) == 0
5206          && !S_ISREG(finfo2.st_mode)
5207          && finfo.st_dev == finfo2.st_dev
5208          && finfo.st_ino == finfo2.st_ino
5209         ) {
5210                 return fd;
5211         }
5212
5213         /* The file has been replaced.  badness. */
5214         close(fd);
5215         errno = EEXIST;
5216         return -1;
5217 }
5218
5219 /*
5220  * Handle here documents.  Normally we fork off a process to write the
5221  * data to a pipe.  If the document is short, we can stuff the data in
5222  * the pipe without forking.
5223  */
5224 /* openhere needs this forward reference */
5225 static void expandhere(union node *arg, int fd);
5226 static int
5227 openhere(union node *redir)
5228 {
5229         int pip[2];
5230         size_t len = 0;
5231
5232         if (pipe(pip) < 0)
5233                 ash_msg_and_raise_error("pipe call failed");
5234         if (redir->type == NHERE) {
5235                 len = strlen(redir->nhere.doc->narg.text);
5236                 if (len <= PIPE_BUF) {
5237                         full_write(pip[1], redir->nhere.doc->narg.text, len);
5238                         goto out;
5239                 }
5240         }
5241         if (forkshell((struct job *)NULL, (union node *)NULL, FORK_NOJOB) == 0) {
5242                 /* child */
5243                 close(pip[0]);
5244                 ignoresig(SIGINT);  //signal(SIGINT, SIG_IGN);
5245                 ignoresig(SIGQUIT); //signal(SIGQUIT, SIG_IGN);
5246                 ignoresig(SIGHUP);  //signal(SIGHUP, SIG_IGN);
5247                 ignoresig(SIGTSTP); //signal(SIGTSTP, SIG_IGN);
5248                 signal(SIGPIPE, SIG_DFL);
5249                 if (redir->type == NHERE)
5250                         full_write(pip[1], redir->nhere.doc->narg.text, len);
5251                 else /* NXHERE */
5252                         expandhere(redir->nhere.doc, pip[1]);
5253                 _exit(EXIT_SUCCESS);
5254         }
5255  out:
5256         close(pip[1]);
5257         return pip[0];
5258 }
5259
5260 static int
5261 openredirect(union node *redir)
5262 {
5263         char *fname;
5264         int f;
5265
5266         switch (redir->nfile.type) {
5267 /* Can't happen, our single caller does this itself */
5268 //      case NTOFD:
5269 //      case NFROMFD:
5270 //              return -1;
5271         case NHERE:
5272         case NXHERE:
5273                 return openhere(redir);
5274         }
5275
5276         /* For N[X]HERE, reading redir->nfile.expfname would touch beyond
5277          * allocated space. Do it only when we know it is safe.
5278          */
5279         fname = redir->nfile.expfname;
5280
5281         switch (redir->nfile.type) {
5282         default:
5283 #if DEBUG
5284                 abort();
5285 #endif
5286         case NFROM:
5287                 f = open(fname, O_RDONLY);
5288                 if (f < 0)
5289                         goto eopen;
5290                 break;
5291         case NFROMTO:
5292                 f = open(fname, O_RDWR|O_CREAT, 0666);
5293                 if (f < 0)
5294                         goto ecreate;
5295                 break;
5296         case NTO:
5297 #if BASH_REDIR_OUTPUT
5298         case NTO2:
5299 #endif
5300                 /* Take care of noclobber mode. */
5301                 if (Cflag) {
5302                         f = noclobberopen(fname);
5303                         if (f < 0)
5304                                 goto ecreate;
5305                         break;
5306                 }
5307                 /* FALLTHROUGH */
5308         case NCLOBBER:
5309                 f = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666);
5310                 if (f < 0)
5311                         goto ecreate;
5312                 break;
5313         case NAPPEND:
5314                 f = open(fname, O_WRONLY|O_CREAT|O_APPEND, 0666);
5315                 if (f < 0)
5316                         goto ecreate;
5317                 break;
5318         }
5319
5320         return f;
5321  ecreate:
5322         ash_msg_and_raise_error("can't create %s: %s", fname, errmsg(errno, "nonexistent directory"));
5323  eopen:
5324         ash_msg_and_raise_error("can't open %s: %s", fname, errmsg(errno, "no such file"));
5325 }
5326
5327 /*
5328  * Copy a file descriptor to be >= 10. Throws exception on error.
5329  */
5330 static int
5331 savefd(int from)
5332 {
5333         int newfd;
5334         int err;
5335
5336         newfd = fcntl(from, F_DUPFD, 10);
5337         err = newfd < 0 ? errno : 0;
5338         if (err != EBADF) {
5339                 if (err)
5340                         ash_msg_and_raise_error("%d: %m", from);
5341                 close(from);
5342                 fcntl(newfd, F_SETFD, FD_CLOEXEC);
5343         }
5344
5345         return newfd;
5346 }
5347 static int
5348 dup2_or_raise(int from, int to)
5349 {
5350         int newfd;
5351
5352         newfd = (from != to) ? dup2(from, to) : to;
5353         if (newfd < 0) {
5354                 /* Happens when source fd is not open: try "echo >&99" */
5355                 ash_msg_and_raise_error("%d: %m", from);
5356         }
5357         return newfd;
5358 }
5359
5360 /* Struct def and variable are moved down to the first usage site */
5361 struct two_fd_t {
5362         int orig, copy;
5363 };
5364 struct redirtab {
5365         struct redirtab *next;
5366         int pair_count;
5367         struct two_fd_t two_fd[];
5368 };
5369 #define redirlist (G_var.redirlist)
5370 enum {
5371         COPYFD_RESTORE = (int)~(INT_MAX),
5372 };
5373
5374 static int
5375 need_to_remember(struct redirtab *rp, int fd)
5376 {
5377         int i;
5378
5379         if (!rp) /* remembering was not requested */
5380                 return 0;
5381
5382         for (i = 0; i < rp->pair_count; i++) {
5383                 if (rp->two_fd[i].orig == fd) {
5384                         /* already remembered */
5385                         return 0;
5386                 }
5387         }
5388         return 1;
5389 }
5390
5391 /* "hidden" fd is a fd used to read scripts, or a copy of such */
5392 static int
5393 is_hidden_fd(struct redirtab *rp, int fd)
5394 {
5395         int i;
5396         struct parsefile *pf;
5397
5398         if (fd == -1)
5399                 return 0;
5400         /* Check open scripts' fds */
5401         pf = g_parsefile;
5402         while (pf) {
5403                 /* We skip pf_fd == 0 case because of the following case:
5404                  * $ ash  # running ash interactively
5405                  * $ . ./script.sh
5406                  * and in script.sh: "exec 9>&0".
5407                  * Even though top-level pf_fd _is_ 0,
5408                  * it's still ok to use it: "read" builtin uses it,
5409                  * why should we cripple "exec" builtin?
5410                  */
5411                 if (pf->pf_fd > 0 && fd == pf->pf_fd) {
5412                         return 1;
5413                 }
5414                 pf = pf->prev;
5415         }
5416
5417         if (!rp)
5418                 return 0;
5419         /* Check saved fds of redirects */
5420         fd |= COPYFD_RESTORE;
5421         for (i = 0; i < rp->pair_count; i++) {
5422                 if (rp->two_fd[i].copy == fd) {
5423                         return 1;
5424                 }
5425         }
5426         return 0;
5427 }
5428
5429 /*
5430  * Process a list of redirection commands.  If the REDIR_PUSH flag is set,
5431  * old file descriptors are stashed away so that the redirection can be
5432  * undone by calling popredir.
5433  */
5434 /* flags passed to redirect */
5435 #define REDIR_PUSH    01        /* save previous values of file descriptors */
5436 #define REDIR_SAVEFD2 03        /* set preverrout */
5437 static void
5438 redirect(union node *redir, int flags)
5439 {
5440         struct redirtab *sv;
5441         int sv_pos;
5442         int i;
5443         int fd;
5444         int newfd;
5445         int copied_fd2 = -1;
5446
5447         if (!redir) {
5448                 return;
5449         }
5450
5451         sv = NULL;
5452         sv_pos = 0;
5453         INT_OFF;
5454         if (flags & REDIR_PUSH) {
5455                 union node *tmp = redir;
5456                 do {
5457                         sv_pos++;
5458 #if BASH_REDIR_OUTPUT
5459                         if (tmp->nfile.type == NTO2)
5460                                 sv_pos++;
5461 #endif
5462                         tmp = tmp->nfile.next;
5463                 } while (tmp);
5464                 sv = ckmalloc(sizeof(*sv) + sv_pos * sizeof(sv->two_fd[0]));
5465                 sv->next = redirlist;
5466                 sv->pair_count = sv_pos;
5467                 redirlist = sv;
5468                 while (sv_pos > 0) {
5469                         sv_pos--;
5470                         sv->two_fd[sv_pos].orig = sv->two_fd[sv_pos].copy = EMPTY;
5471                 }
5472         }
5473
5474         do {
5475                 int right_fd = -1;
5476                 fd = redir->nfile.fd;
5477                 if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) {
5478                         right_fd = redir->ndup.dupfd;
5479                         //bb_error_msg("doing %d > %d", fd, right_fd);
5480                         /* redirect from/to same file descriptor? */
5481                         if (right_fd == fd)
5482                                 continue;
5483                         /* "echo >&10" and 10 is a fd opened to a sh script? */
5484                         if (is_hidden_fd(sv, right_fd)) {
5485                                 errno = EBADF; /* as if it is closed */
5486                                 ash_msg_and_raise_error("%d: %m", right_fd);
5487                         }
5488                         newfd = -1;
5489                 } else {
5490                         newfd = openredirect(redir); /* always >= 0 */
5491                         if (fd == newfd) {
5492                                 /* Descriptor wasn't open before redirect.
5493                                  * Mark it for close in the future */
5494                                 if (need_to_remember(sv, fd)) {
5495                                         goto remember_to_close;
5496                                 }
5497                                 continue;
5498                         }
5499                 }
5500 #if BASH_REDIR_OUTPUT
5501  redirect_more:
5502 #endif
5503                 if (need_to_remember(sv, fd)) {
5504                         /* Copy old descriptor */
5505                         /* Careful to not accidentally "save"
5506                          * to the same fd as right side fd in N>&M */
5507                         int minfd = right_fd < 10 ? 10 : right_fd + 1;
5508 #if defined(F_DUPFD_CLOEXEC)
5509                         i = fcntl(fd, F_DUPFD_CLOEXEC, minfd);
5510 #else
5511                         i = fcntl(fd, F_DUPFD, minfd);
5512 #endif
5513                         if (i == -1) {
5514                                 i = errno;
5515                                 if (i != EBADF) {
5516                                         /* Strange error (e.g. "too many files" EMFILE?) */
5517                                         if (newfd >= 0)
5518                                                 close(newfd);
5519                                         errno = i;
5520                                         ash_msg_and_raise_error("%d: %m", fd);
5521                                         /* NOTREACHED */
5522                                 }
5523                                 /* EBADF: it is not open - good, remember to close it */
5524  remember_to_close:
5525                                 i = CLOSED;
5526                         } else { /* fd is open, save its copy */
5527 #if !defined(F_DUPFD_CLOEXEC)
5528                                 fcntl(i, F_SETFD, FD_CLOEXEC);
5529 #endif
5530                                 /* "exec fd>&-" should not close fds
5531                                  * which point to script file(s).
5532                                  * Force them to be restored afterwards */
5533                                 if (is_hidden_fd(sv, fd))
5534                                         i |= COPYFD_RESTORE;
5535                         }
5536                         if (fd == 2)
5537                                 copied_fd2 = i;
5538                         sv->two_fd[sv_pos].orig = fd;
5539                         sv->two_fd[sv_pos].copy = i;
5540                         sv_pos++;
5541                 }
5542                 if (newfd < 0) {
5543                         /* NTOFD/NFROMFD: copy redir->ndup.dupfd to fd */
5544                         if (redir->ndup.dupfd < 0) { /* "fd>&-" */
5545                                 /* Don't want to trigger debugging */
5546                                 if (fd != -1)
5547                                         close(fd);
5548                         } else {
5549                                 dup2_or_raise(redir->ndup.dupfd, fd);
5550                         }
5551                 } else if (fd != newfd) { /* move newfd to fd */
5552                         dup2_or_raise(newfd, fd);
5553 #if BASH_REDIR_OUTPUT
5554                         if (!(redir->nfile.type == NTO2 && fd == 2))
5555 #endif
5556                                 close(newfd);
5557                 }
5558 #if BASH_REDIR_OUTPUT
5559                 if (redir->nfile.type == NTO2 && fd == 1) {
5560                         /* We already redirected it to fd 1, now copy it to 2 */
5561                         newfd = 1;
5562                         fd = 2;
5563                         goto redirect_more;
5564                 }
5565 #endif
5566         } while ((redir = redir->nfile.next) != NULL);
5567
5568         INT_ON;
5569         if ((flags & REDIR_SAVEFD2) && copied_fd2 >= 0)
5570                 preverrout_fd = copied_fd2;
5571 }
5572
5573 /*
5574  * Undo the effects of the last redirection.
5575  */
5576 static void
5577 popredir(int drop, int restore)
5578 {
5579         struct redirtab *rp;
5580         int i;
5581
5582         if (redirlist == NULL)
5583                 return;
5584         INT_OFF;
5585         rp = redirlist;
5586         for (i = 0; i < rp->pair_count; i++) {
5587                 int fd = rp->two_fd[i].orig;
5588                 int copy = rp->two_fd[i].copy;
5589                 if (copy == CLOSED) {
5590                         if (!drop)
5591                                 close(fd);
5592                         continue;
5593                 }
5594                 if (copy != EMPTY) {
5595                         if (!drop || (restore && (copy & COPYFD_RESTORE))) {
5596                                 copy &= ~COPYFD_RESTORE;
5597                                 /*close(fd);*/
5598                                 dup2_or_raise(copy, fd);
5599                         }
5600                         close(copy & ~COPYFD_RESTORE);
5601                 }
5602         }
5603         redirlist = rp->next;
5604         free(rp);
5605         INT_ON;
5606 }
5607
5608 /*
5609  * Undo all redirections.  Called on error or interrupt.
5610  */
5611
5612 static int
5613 redirectsafe(union node *redir, int flags)
5614 {
5615         int err;
5616         volatile int saveint;
5617         struct jmploc *volatile savehandler = exception_handler;
5618         struct jmploc jmploc;
5619
5620         SAVE_INT(saveint);
5621         /* "echo 9>/dev/null; echo >&9; echo result: $?" - result should be 1, not 2! */
5622         err = setjmp(jmploc.loc); // huh?? was = setjmp(jmploc.loc) * 2;
5623         if (!err) {
5624                 exception_handler = &jmploc;
5625                 redirect(redir, flags);
5626         }
5627         exception_handler = savehandler;
5628         if (err && exception_type != EXERROR)
5629                 longjmp(exception_handler->loc, 1);
5630         RESTORE_INT(saveint);
5631         return err;
5632 }
5633
5634
5635 /* ============ Routines to expand arguments to commands
5636  *
5637  * We have to deal with backquotes, shell variables, and file metacharacters.
5638  */
5639
5640 #if ENABLE_FEATURE_SH_MATH
5641 static arith_t
5642 ash_arith(const char *s)
5643 {
5644         arith_state_t math_state;
5645         arith_t result;
5646
5647         math_state.lookupvar = lookupvar;
5648         math_state.setvar    = setvar0;
5649         //math_state.endofname = endofname;
5650
5651         INT_OFF;
5652         result = arith(&math_state, s);
5653         if (math_state.errmsg)
5654                 ash_msg_and_raise_error(math_state.errmsg);
5655         INT_ON;
5656
5657         return result;
5658 }
5659 #endif
5660
5661 /*
5662  * expandarg flags
5663  */
5664 #define EXP_FULL        0x1     /* perform word splitting & file globbing */
5665 #define EXP_TILDE       0x2     /* do normal tilde expansion */
5666 #define EXP_VARTILDE    0x4     /* expand tildes in an assignment */
5667 #define EXP_REDIR       0x8     /* file glob for a redirection (1 match only) */
5668 /* ^^^^^^^^^^^^^^ this is meant to support constructs such as "cmd >file*.txt"
5669  * POSIX says for this case:
5670  *  Pathname expansion shall not be performed on the word by a
5671  *  non-interactive shell; an interactive shell may perform it, but shall
5672  *  do so only when the expansion would result in one word.
5673  * Currently, our code complies to the above rule by never globbing
5674  * redirection filenames.
5675  * Bash performs globbing, unless it is non-interactive and in POSIX mode.
5676  * (this means that on a typical Linux distro, bash almost always
5677  * performs globbing, and thus diverges from what we do).
5678  */
5679 #define EXP_CASE        0x10    /* keeps quotes around for CASE pattern */
5680 #define EXP_QPAT        0x20    /* pattern in quoted parameter expansion */
5681 #define EXP_VARTILDE2   0x40    /* expand tildes after colons only */
5682 #define EXP_WORD        0x80    /* expand word in parameter expansion */
5683 #define EXP_QUOTED      0x100   /* expand word in double quotes */
5684 /*
5685  * rmescape() flags
5686  */
5687 #define RMESCAPE_ALLOC  0x1     /* Allocate a new string */
5688 #define RMESCAPE_GLOB   0x2     /* Add backslashes for glob */
5689 #define RMESCAPE_GROW   0x8     /* Grow strings instead of stalloc */
5690 #define RMESCAPE_HEAP   0x10    /* Malloc strings instead of stalloc */
5691 #define RMESCAPE_SLASH  0x20    /* Stop globbing after slash */
5692
5693 /* Add CTLESC when necessary. */
5694 #define QUOTES_ESC     (EXP_FULL | EXP_CASE | EXP_QPAT | EXP_REDIR)
5695 /* Do not skip NUL characters. */
5696 #define QUOTES_KEEPNUL EXP_TILDE
5697
5698 /*
5699  * Structure specifying which parts of the string should be searched
5700  * for IFS characters.
5701  */
5702 struct ifsregion {
5703         struct ifsregion *next; /* next region in list */
5704         int begoff;             /* offset of start of region */
5705         int endoff;             /* offset of end of region */
5706         int nulonly;            /* search for nul bytes only */
5707 };
5708
5709 struct arglist {
5710         struct strlist *list;
5711         struct strlist **lastp;
5712 };
5713
5714 /* output of current string */
5715 static char *expdest;
5716 /* list of back quote expressions */
5717 static struct nodelist *argbackq;
5718 /* first struct in list of ifs regions */
5719 static struct ifsregion ifsfirst;
5720 /* last struct in list */
5721 static struct ifsregion *ifslastp;
5722 /* holds expanded arg list */
5723 static struct arglist exparg;
5724
5725 /*
5726  * Our own itoa().
5727  */
5728 #if !ENABLE_FEATURE_SH_MATH
5729 /* cvtnum() is used even if math support is off (to prepare $? values and such) */
5730 typedef long arith_t;
5731 # define ARITH_FMT "%ld"
5732 #endif
5733 static int
5734 cvtnum(arith_t num)
5735 {
5736         int len;
5737
5738         expdest = makestrspace(sizeof(arith_t)*3 + 2, expdest);
5739         len = fmtstr(expdest, sizeof(arith_t)*3 + 2, ARITH_FMT, num);
5740         STADJUST(len, expdest);
5741         return len;
5742 }
5743
5744 /*
5745  * Break the argument string into pieces based upon IFS and add the
5746  * strings to the argument list.  The regions of the string to be
5747  * searched for IFS characters have been stored by recordregion.
5748  */
5749 static void
5750 ifsbreakup(char *string, struct arglist *arglist)
5751 {
5752         struct ifsregion *ifsp;
5753         struct strlist *sp;
5754         char *start;
5755         char *p;
5756         char *q;
5757         const char *ifs, *realifs;
5758         int ifsspc;
5759         int nulonly;
5760
5761         start = string;
5762         if (ifslastp != NULL) {
5763                 ifsspc = 0;
5764                 nulonly = 0;
5765                 realifs = ifsset() ? ifsval() : defifs;
5766                 ifsp = &ifsfirst;
5767                 do {
5768                         p = string + ifsp->begoff;
5769                         nulonly = ifsp->nulonly;
5770                         ifs = nulonly ? nullstr : realifs;
5771                         ifsspc = 0;
5772                         while (p < string + ifsp->endoff) {
5773                                 q = p;
5774                                 if ((unsigned char)*p == CTLESC)
5775                                         p++;
5776                                 if (!strchr(ifs, *p)) {
5777                                         p++;
5778                                         continue;
5779                                 }
5780                                 if (!nulonly)
5781                                         ifsspc = (strchr(defifs, *p) != NULL);
5782                                 /* Ignore IFS whitespace at start */
5783                                 if (q == start && ifsspc) {
5784                                         p++;
5785                                         start = p;
5786                                         continue;
5787                                 }
5788                                 *q = '\0';
5789                                 sp = stzalloc(sizeof(*sp));
5790                                 sp->text = start;
5791                                 *arglist->lastp = sp;
5792                                 arglist->lastp = &sp->next;
5793                                 p++;
5794                                 if (!nulonly) {
5795                                         for (;;) {
5796                                                 if (p >= string + ifsp->endoff) {
5797                                                         break;
5798                                                 }
5799                                                 q = p;
5800                                                 if ((unsigned char)*p == CTLESC)
5801                                                         p++;
5802                                                 if (strchr(ifs, *p) == NULL) {
5803                                                         p = q;
5804                                                         break;
5805                                                 }
5806                                                 if (strchr(defifs, *p) == NULL) {
5807                                                         if (ifsspc) {
5808                                                                 p++;
5809                                                                 ifsspc = 0;
5810                                                         } else {
5811                                                                 p = q;
5812                                                                 break;
5813                                                         }
5814                                                 } else
5815                                                         p++;
5816                                         }
5817                                 }
5818                                 start = p;
5819                         } /* while */
5820                         ifsp = ifsp->next;
5821                 } while (ifsp != NULL);
5822                 if (nulonly)
5823                         goto add;
5824         }
5825
5826         if (!*start)
5827                 return;
5828
5829  add:
5830         sp = stzalloc(sizeof(*sp));
5831         sp->text = start;
5832         *arglist->lastp = sp;
5833         arglist->lastp = &sp->next;
5834 }
5835
5836 static void
5837 ifsfree(void)
5838 {
5839         struct ifsregion *p = ifsfirst.next;
5840
5841         if (!p)
5842                 goto out;
5843
5844         INT_OFF;
5845         do {
5846                 struct ifsregion *ifsp;
5847                 ifsp = p->next;
5848                 free(p);
5849                 p = ifsp;
5850         } while (p);
5851         ifsfirst.next = NULL;
5852         INT_ON;
5853  out:
5854         ifslastp = NULL;
5855 }
5856
5857 static size_t
5858 esclen(const char *start, const char *p)
5859 {
5860         size_t esc = 0;
5861
5862         while (p > start && (unsigned char)*--p == CTLESC) {
5863                 esc++;
5864         }
5865         return esc;
5866 }
5867
5868 /*
5869  * Remove any CTLESC characters from a string.
5870  */
5871 static char *
5872 rmescapes(char *str, int flag)
5873 {
5874         static const char qchars[] ALIGN1 = {
5875                 IF_BASH_PATTERN_SUBST('/',) CTLESC, CTLQUOTEMARK, '\0' };
5876
5877         char *p, *q, *r;
5878         unsigned inquotes;
5879         unsigned protect_against_glob;
5880         unsigned globbing;
5881         IF_BASH_PATTERN_SUBST(unsigned slash = flag & RMESCAPE_SLASH;)
5882
5883         p = strpbrk(str, qchars IF_BASH_PATTERN_SUBST(+ !slash));
5884         if (!p)
5885                 return str;
5886
5887         q = p;
5888         r = str;
5889         if (flag & RMESCAPE_ALLOC) {
5890                 size_t len = p - str;
5891                 size_t fulllen = len + strlen(p) + 1;
5892
5893                 if (flag & RMESCAPE_GROW) {
5894                         int strloc = str - (char *)stackblock();
5895                         r = makestrspace(fulllen, expdest);
5896                         /* p and str may be invalidated by makestrspace */
5897                         str = (char *)stackblock() + strloc;
5898                         p = str + len;
5899                 } else if (flag & RMESCAPE_HEAP) {
5900                         r = ckmalloc(fulllen);
5901                 } else {
5902                         r = stalloc(fulllen);
5903                 }
5904                 q = r;
5905                 if (len > 0) {
5906                         q = (char *)memcpy(q, str, len) + len;
5907                 }
5908         }
5909
5910         inquotes = 0;
5911         globbing = flag & RMESCAPE_GLOB;
5912         protect_against_glob = globbing;
5913         while (*p) {
5914                 if ((unsigned char)*p == CTLQUOTEMARK) {
5915 // Note: both inquotes and protect_against_glob only affect whether
5916                         inquotes = ~inquotes;
5917                         p++;
5918                         protect_against_glob = globbing;
5919                         continue;
5920                 }
5921                 if ((unsigned char)*p == CTLESC) {
5922                         p++;
5923 #if DEBUG
5924                         if (*p == '\0')
5925                                 ash_msg_and_raise_error("CTLESC at EOL (shouldn't happen)");
5926 #endif
5927                         if (protect_against_glob) {
5928                                 *q++ = '\\';
5929                         }
5930                 } else if (*p == '\\' && !inquotes) {
5931                         /* naked back slash */
5932                         protect_against_glob = 0;
5933                         goto copy;
5934                 }
5935 #if BASH_PATTERN_SUBST
5936                 else if (*p == '/' && slash) {
5937                         /* stop handling globbing and mark location of slash */
5938                         globbing = slash = 0;
5939                         *p = CTLESC;
5940                 }
5941 #endif
5942                 protect_against_glob = globbing;
5943  copy:
5944                 *q++ = *p++;
5945         }
5946         *q = '\0';
5947         if (flag & RMESCAPE_GROW) {
5948                 expdest = r;
5949                 STADJUST(q - r + 1, expdest);
5950         }
5951         return r;
5952 }
5953 #define pmatch(a, b) !fnmatch((a), (b), 0)
5954
5955 /*
5956  * Prepare a pattern for a expmeta (internal glob(3)) call.
5957  *
5958  * Returns an stalloced string.
5959  */
5960 static char *
5961 preglob(const char *pattern, int flag)
5962 {
5963         return rmescapes((char *)pattern, flag | RMESCAPE_GLOB);
5964 }
5965
5966 /*
5967  * Put a string on the stack.
5968  */
5969 static void
5970 memtodest(const char *p, size_t len, int syntax, int quotes)
5971 {
5972         char *q;
5973
5974         if (!len)
5975                 return;
5976
5977         q = makestrspace((quotes & QUOTES_ESC) ? len * 2 : len, expdest);
5978
5979         do {
5980                 unsigned char c = *p++;
5981                 if (c) {
5982                         if (quotes & QUOTES_ESC) {
5983                                 int n = SIT(c, syntax);
5984                                 if (n == CCTL
5985                                  || (((quotes & EXP_FULL) || syntax != BASESYNTAX)
5986                                      && n == CBACK
5987                                     )
5988                                 ) {
5989                                         USTPUTC(CTLESC, q);
5990                                 }
5991                         }
5992                 } else if (!(quotes & QUOTES_KEEPNUL))
5993                         continue;
5994                 USTPUTC(c, q);
5995         } while (--len);
5996
5997         expdest = q;
5998 }
5999
6000 static size_t
6001 strtodest(const char *p, int syntax, int quotes)
6002 {
6003         size_t len = strlen(p);
6004         memtodest(p, len, syntax, quotes);
6005         return len;
6006 }
6007
6008 /*
6009  * Record the fact that we have to scan this region of the
6010  * string for IFS characters.
6011  */
6012 static void
6013 recordregion(int start, int end, int nulonly)
6014 {
6015         struct ifsregion *ifsp;
6016
6017         if (ifslastp == NULL) {
6018                 ifsp = &ifsfirst;
6019         } else {
6020                 INT_OFF;
6021                 ifsp = ckzalloc(sizeof(*ifsp));
6022                 /*ifsp->next = NULL; - ckzalloc did it */
6023                 ifslastp->next = ifsp;
6024                 INT_ON;
6025         }
6026         ifslastp = ifsp;
6027         ifslastp->begoff = start;
6028         ifslastp->endoff = end;
6029         ifslastp->nulonly = nulonly;
6030 }
6031
6032 static void
6033 removerecordregions(int endoff)
6034 {
6035         if (ifslastp == NULL)
6036                 return;
6037
6038         if (ifsfirst.endoff > endoff) {
6039                 while (ifsfirst.next) {
6040                         struct ifsregion *ifsp;
6041                         INT_OFF;
6042                         ifsp = ifsfirst.next->next;
6043                         free(ifsfirst.next);
6044                         ifsfirst.next = ifsp;
6045                         INT_ON;
6046                 }
6047                 if (ifsfirst.begoff > endoff) {
6048                         ifslastp = NULL;
6049                 } else {
6050                         ifslastp = &ifsfirst;
6051                         ifsfirst.endoff = endoff;
6052                 }
6053                 return;
6054         }
6055
6056         ifslastp = &ifsfirst;
6057         while (ifslastp->next && ifslastp->next->begoff < endoff)
6058                 ifslastp = ifslastp->next;
6059         while (ifslastp->next) {
6060                 struct ifsregion *ifsp;
6061                 INT_OFF;
6062                 ifsp = ifslastp->next->next;
6063                 free(ifslastp->next);
6064                 ifslastp->next = ifsp;
6065                 INT_ON;
6066         }
6067         if (ifslastp->endoff > endoff)
6068                 ifslastp->endoff = endoff;
6069 }
6070
6071 static char *
6072 exptilde(char *startp, char *p, int flags)
6073 {
6074         unsigned char c;
6075         char *name;
6076         struct passwd *pw;
6077         const char *home;
6078         int quotes = flags & QUOTES_ESC;
6079
6080         name = p + 1;
6081
6082         while ((c = *++p) != '\0') {
6083                 switch (c) {
6084                 case CTLESC:
6085                         return startp;
6086                 case CTLQUOTEMARK:
6087                         return startp;
6088                 case ':':
6089                         if (flags & EXP_VARTILDE)
6090                                 goto done;
6091                         break;
6092                 case '/':
6093                 case CTLENDVAR:
6094                         goto done;
6095                 }
6096         }
6097  done:
6098         *p = '\0';
6099         if (*name == '\0') {
6100                 home = lookupvar("HOME");
6101         } else {
6102                 pw = getpwnam(name);
6103                 if (pw == NULL)
6104                         goto lose;
6105                 home = pw->pw_dir;
6106         }
6107         if (!home || !*home)
6108                 goto lose;
6109         *p = c;
6110         strtodest(home, SQSYNTAX, quotes);
6111         return p;
6112  lose:
6113         *p = c;
6114         return startp;
6115 }
6116
6117 /*
6118  * Execute a command inside back quotes.  If it's a builtin command, we
6119  * want to save its output in a block obtained from malloc.  Otherwise
6120  * we fork off a subprocess and get the output of the command via a pipe.
6121  * Should be called with interrupts off.
6122  */
6123 struct backcmd {                /* result of evalbackcmd */
6124         int fd;                 /* file descriptor to read from */
6125         int nleft;              /* number of chars in buffer */
6126         char *buf;              /* buffer */
6127         struct job *jp;         /* job structure for command */
6128 };
6129
6130 /* These forward decls are needed to use "eval" code for backticks handling: */
6131 #define EV_EXIT 01              /* exit after evaluating tree */
6132 static int evaltree(union node *, int);
6133
6134 static void FAST_FUNC
6135 evalbackcmd(union node *n, struct backcmd *result)
6136 {
6137         int pip[2];
6138         struct job *jp;
6139
6140         result->fd = -1;
6141         result->buf = NULL;
6142         result->nleft = 0;
6143         result->jp = NULL;
6144         if (n == NULL) {
6145                 goto out;
6146         }
6147
6148         if (pipe(pip) < 0)
6149                 ash_msg_and_raise_error("pipe call failed");
6150         jp = makejob(/*n,*/ 1);
6151         if (forkshell(jp, n, FORK_NOJOB) == 0) {
6152                 /* child */
6153                 FORCE_INT_ON;
6154                 close(pip[0]);
6155                 if (pip[1] != 1) {
6156                         /*close(1);*/
6157                         dup2_or_raise(pip[1], 1);
6158                         close(pip[1]);
6159                 }
6160 /* TODO: eflag clearing makes the following not abort:
6161  *  ash -c 'set -e; z=$(false;echo foo); echo $z'
6162  * which is what bash does (unless it is in POSIX mode).
6163  * dash deleted "eflag = 0" line in the commit
6164  *  Date: Mon, 28 Jun 2010 17:11:58 +1000
6165  *  [EVAL] Don't clear eflag in evalbackcmd
6166  * For now, preserve bash-like behavior, it seems to be somewhat more useful:
6167  */
6168                 eflag = 0;
6169                 ifsfree();
6170                 evaltree(n, EV_EXIT); /* actually evaltreenr... */
6171                 /* NOTREACHED */
6172         }
6173         /* parent */
6174         close(pip[1]);
6175         result->fd = pip[0];
6176         result->jp = jp;
6177
6178  out:
6179         TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
6180                 result->fd, result->buf, result->nleft, result->jp));
6181 }
6182
6183 /*
6184  * Expand stuff in backwards quotes.
6185  */
6186 static void
6187 expbackq(union node *cmd, int flag)
6188 {
6189         struct backcmd in;
6190         int i;
6191         char buf[128];
6192         char *p;
6193         char *dest;
6194         int startloc;
6195         int syntax = flag & EXP_QUOTED ? DQSYNTAX : BASESYNTAX;
6196         struct stackmark smark;
6197
6198         INT_OFF;
6199         startloc = expdest - (char *)stackblock();
6200         pushstackmark(&smark, startloc);
6201         evalbackcmd(cmd, &in);
6202         popstackmark(&smark);
6203
6204         p = in.buf;
6205         i = in.nleft;
6206         if (i == 0)
6207                 goto read;
6208         for (;;) {
6209                 memtodest(p, i, syntax, flag & QUOTES_ESC);
6210  read:
6211                 if (in.fd < 0)
6212                         break;
6213                 i = nonblock_immune_read(in.fd, buf, sizeof(buf));
6214                 TRACE(("expbackq: read returns %d\n", i));
6215                 if (i <= 0)
6216                         break;
6217                 p = buf;
6218         }
6219
6220         free(in.buf);
6221         if (in.fd >= 0) {
6222                 close(in.fd);
6223                 back_exitstatus = waitforjob(in.jp);
6224         }
6225         INT_ON;
6226
6227         /* Eat all trailing newlines */
6228         dest = expdest;
6229         for (; dest > (char *)stackblock() && dest[-1] == '\n';)
6230                 STUNPUTC(dest);
6231         expdest = dest;
6232
6233         if (!(flag & EXP_QUOTED))
6234                 recordregion(startloc, dest - (char *)stackblock(), 0);
6235         TRACE(("evalbackq: size:%d:'%.*s'\n",
6236                 (int)((dest - (char *)stackblock()) - startloc),
6237                 (int)((dest - (char *)stackblock()) - startloc),
6238                 stackblock() + startloc));
6239 }
6240
6241 #if ENABLE_FEATURE_SH_MATH
6242 /*
6243  * Expand arithmetic expression.  Backup to start of expression,
6244  * evaluate, place result in (backed up) result, adjust string position.
6245  */
6246 static void
6247 expari(int flag)
6248 {
6249         char *p, *start;
6250         int begoff;
6251         int len;
6252
6253         /* ifsfree(); */
6254
6255         /*
6256          * This routine is slightly over-complicated for
6257          * efficiency.  Next we scan backwards looking for the
6258          * start of arithmetic.
6259          */
6260         start = stackblock();
6261         p = expdest - 1;
6262         *p = '\0';
6263         p--;
6264         while (1) {
6265                 int esc;
6266
6267                 while ((unsigned char)*p != CTLARI) {
6268                         p--;
6269 #if DEBUG
6270                         if (p < start) {
6271                                 ash_msg_and_raise_error("missing CTLARI (shouldn't happen)");
6272                         }
6273 #endif
6274                 }
6275
6276                 esc = esclen(start, p);
6277                 if (!(esc % 2)) {
6278                         break;
6279                 }
6280
6281                 p -= esc + 1;
6282         }
6283
6284         begoff = p - start;
6285
6286         removerecordregions(begoff);
6287
6288         expdest = p;
6289
6290         if (flag & QUOTES_ESC)
6291                 rmescapes(p + 1, 0);
6292
6293         len = cvtnum(ash_arith(p + 1));
6294
6295         if (!(flag & EXP_QUOTED))
6296                 recordregion(begoff, begoff + len, 0);
6297 }
6298 #endif
6299
6300 /* argstr needs it */
6301 static char *evalvar(char *p, int flags, struct strlist *var_str_list);
6302
6303 /*
6304  * Perform variable and command substitution.  If EXP_FULL is set, output CTLESC
6305  * characters to allow for further processing.  Otherwise treat
6306  * $@ like $* since no splitting will be performed.
6307  *
6308  * var_str_list (can be NULL) is a list of "VAR=val" strings which take precedence
6309  * over shell variables. Needed for "A=a B=$A; echo $B" case - we use it
6310  * for correct expansion of "B=$A" word.
6311  */
6312 static void
6313 argstr(char *p, int flags, struct strlist *var_str_list)
6314 {
6315         static const char spclchars[] ALIGN1 = {
6316                 '=',
6317                 ':',
6318                 CTLQUOTEMARK,
6319                 CTLENDVAR,
6320                 CTLESC,
6321                 CTLVAR,
6322                 CTLBACKQ,
6323 #if ENABLE_FEATURE_SH_MATH
6324                 CTLENDARI,
6325 #endif
6326                 '\0'
6327         };
6328         const char *reject = spclchars;
6329         int breakall = (flags & (EXP_WORD | EXP_QUOTED)) == EXP_WORD;
6330         int inquotes;
6331         size_t length;
6332         int startloc;
6333
6334         if (!(flags & EXP_VARTILDE)) {
6335                 reject += 2;
6336         } else if (flags & EXP_VARTILDE2) {
6337                 reject++;
6338         }
6339         inquotes = 0;
6340         length = 0;
6341         if (flags & EXP_TILDE) {
6342                 char *q;
6343
6344                 flags &= ~EXP_TILDE;
6345  tilde:
6346                 q = p;
6347                 if (*q == '~')
6348                         p = exptilde(p, q, flags);
6349         }
6350  start:
6351         startloc = expdest - (char *)stackblock();
6352         for (;;) {
6353                 unsigned char c;
6354
6355                 length += strcspn(p + length, reject);
6356                 c = p[length];
6357                 if (c) {
6358                         if (!(c & 0x80)
6359                         IF_FEATURE_SH_MATH(|| c == CTLENDARI)
6360                         ) {
6361                                 /* c == '=' || c == ':' || c == CTLENDARI */
6362                                 length++;
6363                         }
6364                 }
6365                 if (length > 0) {
6366                         int newloc;
6367                         expdest = stack_nputstr(p, length, expdest);
6368                         newloc = expdest - (char *)stackblock();
6369                         if (breakall && !inquotes && newloc > startloc) {
6370                                 recordregion(startloc, newloc, 0);
6371                         }
6372                         startloc = newloc;
6373                 }
6374                 p += length + 1;
6375                 length = 0;
6376
6377                 switch (c) {
6378                 case '\0':
6379                         goto breakloop;
6380                 case '=':
6381                         if (flags & EXP_VARTILDE2) {
6382                                 p--;
6383                                 continue;
6384                         }
6385                         flags |= EXP_VARTILDE2;
6386                         reject++;
6387                         /* fall through */
6388                 case ':':
6389                         /*
6390                          * sort of a hack - expand tildes in variable
6391                          * assignments (after the first '=' and after ':'s).
6392                          */
6393                         if (*--p == '~') {
6394                                 goto tilde;
6395                         }
6396                         continue;
6397                 }
6398
6399                 switch (c) {
6400                 case CTLENDVAR: /* ??? */
6401                         goto breakloop;
6402                 case CTLQUOTEMARK:
6403                         inquotes ^= EXP_QUOTED;
6404                         /* "$@" syntax adherence hack */
6405                         if (inquotes && !memcmp(p, dolatstr + 1, DOLATSTRLEN - 1)) {
6406                                 p = evalvar(p + 1, flags | inquotes, /* var_str_list: */ NULL) + 1;
6407                                 goto start;
6408                         }
6409  addquote:
6410                         if (flags & QUOTES_ESC) {
6411                                 p--;
6412                                 length++;
6413                                 startloc++;
6414                         }
6415                         break;
6416                 case CTLESC:
6417                         startloc++;
6418                         length++;
6419
6420                         /*
6421                          * Quoted parameter expansion pattern: remove quote
6422                          * unless inside inner quotes or we have a literal
6423                          * backslash.
6424                          */
6425                         if (((flags | inquotes) & (EXP_QPAT | EXP_QUOTED)) ==
6426                             EXP_QPAT && *p != '\\')
6427                                 break;
6428
6429                         goto addquote;
6430                 case CTLVAR:
6431                         TRACE(("argstr: evalvar('%s')\n", p));
6432                         p = evalvar(p, flags | inquotes, var_str_list);
6433                         TRACE(("argstr: evalvar:'%s'\n", (char *)stackblock()));
6434                         goto start;
6435                 case CTLBACKQ:
6436                         expbackq(argbackq->n, flags | inquotes);
6437                         argbackq = argbackq->next;
6438                         goto start;
6439 #if ENABLE_FEATURE_SH_MATH
6440                 case CTLENDARI:
6441                         p--;
6442                         expari(flags | inquotes);
6443                         goto start;
6444 #endif
6445                 }
6446         }
6447  breakloop: ;
6448 }
6449
6450 static char *
6451 scanleft(char *startp, char *rmesc, char *rmescend UNUSED_PARAM,
6452                 char *pattern, int quotes, int zero)
6453 {
6454         char *loc, *loc2;
6455         char c;
6456
6457         loc = startp;
6458         loc2 = rmesc;
6459         do {
6460                 int match;
6461                 const char *s = loc2;
6462
6463                 c = *loc2;
6464                 if (zero) {
6465                         *loc2 = '\0';
6466                         s = rmesc;
6467                 }
6468                 match = pmatch(pattern, s);
6469
6470                 *loc2 = c;
6471                 if (match)
6472                         return loc;
6473                 if (quotes && (unsigned char)*loc == CTLESC)
6474                         loc++;
6475                 loc++;
6476                 loc2++;
6477         } while (c);
6478         return NULL;
6479 }
6480
6481 static char *
6482 scanright(char *startp, char *rmesc, char *rmescend,
6483                 char *pattern, int quotes, int match_at_start)
6484 {
6485 #if !ENABLE_ASH_OPTIMIZE_FOR_SIZE
6486         int try2optimize = match_at_start;
6487 #endif
6488         int esc = 0;
6489         char *loc;
6490         char *loc2;
6491
6492         /* If we called by "${v/pattern/repl}" or "${v//pattern/repl}":
6493          * startp="escaped_value_of_v" rmesc="raw_value_of_v"
6494          * rmescend=""(ptr to NUL in rmesc) pattern="pattern" quotes=match_at_start=1
6495          * Logic:
6496          * loc starts at NUL at the end of startp, loc2 starts at the end of rmesc,
6497          * and on each iteration they go back two/one char until they reach the beginning.
6498          * We try to find a match in "raw_value_of_v", "raw_value_of_", "raw_value_of" etc.
6499          */
6500         /* TODO: document in what other circumstances we are called. */
6501
6502         for (loc = pattern - 1, loc2 = rmescend; loc >= startp; loc2--) {
6503                 int match;
6504                 char c = *loc2;
6505                 const char *s = loc2;
6506                 if (match_at_start) {
6507                         *loc2 = '\0';
6508                         s = rmesc;
6509                 }
6510                 match = pmatch(pattern, s);
6511                 //bb_error_msg("pmatch(pattern:'%s',s:'%s'):%d", pattern, s, match);
6512                 *loc2 = c;
6513                 if (match)
6514                         return loc;
6515 #if !ENABLE_ASH_OPTIMIZE_FOR_SIZE
6516                 if (try2optimize) {
6517                         /* Maybe we can optimize this:
6518                          * if pattern ends with unescaped *, we can avoid checking
6519                          * shorter strings: if "foo*" doesn't match "raw_value_of_v",
6520                          * it won't match truncated "raw_value_of_" strings too.
6521                          */
6522                         unsigned plen = strlen(pattern);
6523                         /* Does it end with "*"? */
6524                         if (plen != 0 && pattern[--plen] == '*') {
6525                                 /* "xxxx*" is not escaped */
6526                                 /* "xxx\*" is escaped */
6527                                 /* "xx\\*" is not escaped */
6528                                 /* "x\\\*" is escaped */
6529                                 int slashes = 0;
6530                                 while (plen != 0 && pattern[--plen] == '\\')
6531                                         slashes++;
6532                                 if (!(slashes & 1))
6533                                         break; /* ends with unescaped "*" */
6534                         }
6535                         try2optimize = 0;
6536                 }
6537 #endif
6538                 loc--;
6539                 if (quotes) {
6540                         if (--esc < 0) {
6541                                 esc = esclen(startp, loc);
6542                         }
6543                         if (esc % 2) {
6544                                 esc--;
6545                                 loc--;
6546                         }
6547                 }
6548         }
6549         return NULL;
6550 }
6551
6552 static void varunset(const char *, const char *, const char *, int) NORETURN;
6553 static void
6554 varunset(const char *end, const char *var, const char *umsg, int varflags)
6555 {
6556         const char *msg;
6557         const char *tail;
6558
6559         tail = nullstr;
6560         msg = "parameter not set";
6561         if (umsg) {
6562                 if ((unsigned char)*end == CTLENDVAR) {
6563                         if (varflags & VSNUL)
6564                                 tail = " or null";
6565                 } else {
6566                         msg = umsg;
6567                 }
6568         }
6569         ash_msg_and_raise_error("%.*s: %s%s", (int)(end - var - 1), var, msg, tail);
6570 }
6571
6572 static const char *
6573 subevalvar(char *p, char *varname, int strloc, int subtype,
6574                 int startloc, int varflags, int flag, struct strlist *var_str_list)
6575 {
6576         struct nodelist *saveargbackq = argbackq;
6577         int quotes = flag & QUOTES_ESC;
6578         char *startp;
6579         char *loc;
6580         char *rmesc, *rmescend;
6581         char *str;
6582         IF_BASH_SUBSTR(int pos, len, orig_len;)
6583         int amount, resetloc;
6584         IF_BASH_PATTERN_SUBST(int workloc;)
6585         IF_BASH_PATTERN_SUBST(char *repl = NULL;)
6586         int zero;
6587         char *(*scan)(char*, char*, char*, char*, int, int);
6588
6589         //bb_error_msg("subevalvar(p:'%s',varname:'%s',strloc:%d,subtype:%d,startloc:%d,varflags:%x,quotes:%d)",
6590         //              p, varname, strloc, subtype, startloc, varflags, quotes);
6591
6592         argstr(p, EXP_TILDE | (subtype != VSASSIGN && subtype != VSQUESTION ?
6593                         (flag & (EXP_QUOTED | EXP_QPAT) ? EXP_QPAT : EXP_CASE) : 0),
6594                         var_str_list);
6595         STPUTC('\0', expdest);
6596         argbackq = saveargbackq;
6597         startp = (char *)stackblock() + startloc;
6598
6599         switch (subtype) {
6600         case VSASSIGN:
6601                 setvar0(varname, startp);
6602                 amount = startp - expdest;
6603                 STADJUST(amount, expdest);
6604                 return startp;
6605
6606         case VSQUESTION:
6607                 varunset(p, varname, startp, varflags);
6608                 /* NOTREACHED */
6609
6610 #if BASH_SUBSTR
6611         case VSSUBSTR:
6612 //TODO: support more general format ${v:EXPR:EXPR},
6613 // where EXPR follows $(()) rules
6614                 loc = str = stackblock() + strloc;
6615                 /* Read POS in ${var:POS:LEN} */
6616                 pos = atoi(loc); /* number(loc) errors out on "1:4" */
6617                 len = str - startp - 1;
6618
6619                 /* *loc != '\0', guaranteed by parser */
6620                 if (quotes) {
6621                         char *ptr;
6622
6623                         /* Adjust the length by the number of escapes */
6624                         for (ptr = startp; ptr < (str - 1); ptr++) {
6625                                 if ((unsigned char)*ptr == CTLESC) {
6626                                         len--;
6627                                         ptr++;
6628                                 }
6629                         }
6630                 }
6631                 orig_len = len;
6632
6633                 if (*loc++ == ':') {
6634                         /* ${var::LEN} */
6635                         len = number(loc);
6636                 } else {
6637                         /* Skip POS in ${var:POS:LEN} */
6638                         len = orig_len;
6639                         while (*loc && *loc != ':') {
6640                                 /* TODO?
6641                                  * bash complains on: var=qwe; echo ${var:1a:123}
6642                                 if (!isdigit(*loc))
6643                                         ash_msg_and_raise_error(msg_illnum, str);
6644                                  */
6645                                 loc++;
6646                         }
6647                         if (*loc++ == ':') {
6648                                 len = number(loc);
6649                         }
6650                 }
6651                 if (pos < 0) {
6652                         /* ${VAR:$((-n)):l} starts n chars from the end */
6653                         pos = orig_len + pos;
6654                 }
6655                 if ((unsigned)pos >= orig_len) {
6656                         /* apart from obvious ${VAR:999999:l},
6657                          * covers ${VAR:$((-9999999)):l} - result is ""
6658                          * (bash-compat)
6659                          */
6660                         pos = 0;
6661                         len = 0;
6662                 }
6663                 if (len > (orig_len - pos))
6664                         len = orig_len - pos;
6665
6666                 for (str = startp; pos; str++, pos--) {
6667                         if (quotes && (unsigned char)*str == CTLESC)
6668                                 str++;
6669                 }
6670                 for (loc = startp; len; len--) {
6671                         if (quotes && (unsigned char)*str == CTLESC)
6672                                 *loc++ = *str++;
6673                         *loc++ = *str++;
6674                 }
6675                 *loc = '\0';
6676                 amount = loc - expdest;
6677                 STADJUST(amount, expdest);
6678                 return loc;
6679 #endif /* BASH_SUBSTR */
6680         }
6681
6682         resetloc = expdest - (char *)stackblock();
6683
6684 #if BASH_PATTERN_SUBST
6685         /* We'll comeback here if we grow the stack while handling
6686          * a VSREPLACE or VSREPLACEALL, since our pointers into the
6687          * stack will need rebasing, and we'll need to remove our work
6688          * areas each time
6689          */
6690  restart:
6691 #endif
6692
6693         amount = expdest - ((char *)stackblock() + resetloc);
6694         STADJUST(-amount, expdest);
6695         startp = (char *)stackblock() + startloc;
6696
6697         rmesc = startp;
6698         rmescend = (char *)stackblock() + strloc;
6699         if (quotes) {
6700                 rmesc = rmescapes(startp, RMESCAPE_ALLOC | RMESCAPE_GROW);
6701                 if (rmesc != startp) {
6702                         rmescend = expdest;
6703                         startp = (char *)stackblock() + startloc;
6704                 }
6705         }
6706         rmescend--;
6707         str = (char *)stackblock() + strloc;
6708         /*
6709          * Example: v='a\bc'; echo ${v/\\b/_\\_\z_}
6710          * The result is a_\_z_c (not a\_\_z_c)!
6711          *
6712          * The search pattern and replace string treat backslashes differently!
6713          * RMESCAPE_SLASH causes preglob to work differently on the pattern
6714          * and string.  It's only used on the first call.
6715          */
6716         preglob(str, IF_BASH_PATTERN_SUBST(
6717                 (subtype == VSREPLACE || subtype == VSREPLACEALL) && !repl ?
6718                         RMESCAPE_SLASH : ) 0);
6719
6720 #if BASH_PATTERN_SUBST
6721         workloc = expdest - (char *)stackblock();
6722         if (subtype == VSREPLACE || subtype == VSREPLACEALL) {
6723                 char *idx, *end;
6724
6725                 if (!repl) {
6726                         repl = strchr(str, CTLESC);
6727                         if (repl)
6728                                 *repl++ = '\0';
6729                         else
6730                                 repl = nullstr;
6731                 }
6732                 //bb_error_msg("str:'%s' repl:'%s'", str, repl);
6733
6734                 /* If there's no pattern to match, return the expansion unmolested */
6735                 if (str[0] == '\0')
6736                         return NULL;
6737
6738                 len = 0;
6739                 idx = startp;
6740                 end = str - 1;
6741                 while (idx < end) {
6742  try_to_match:
6743                         loc = scanright(idx, rmesc, rmescend, str, quotes, 1);
6744                         //bb_error_msg("scanright('%s'):'%s'", str, loc);
6745                         if (!loc) {
6746                                 /* No match, advance */
6747                                 char *restart_detect = stackblock();
6748  skip_matching:
6749                                 STPUTC(*idx, expdest);
6750                                 if (quotes && (unsigned char)*idx == CTLESC) {
6751                                         idx++;
6752                                         len++;
6753                                         STPUTC(*idx, expdest);
6754                                 }
6755                                 if (stackblock() != restart_detect)
6756                                         goto restart;
6757                                 idx++;
6758                                 len++;
6759                                 rmesc++;
6760                                 /* continue; - prone to quadratic behavior, smarter code: */
6761                                 if (idx >= end)
6762                                         break;
6763                                 if (str[0] == '*') {
6764                                         /* Pattern is "*foo". If "*foo" does not match "long_string",
6765                                          * it would never match "ong_string" etc, no point in trying.
6766                                          */
6767                                         goto skip_matching;
6768                                 }
6769                                 goto try_to_match;
6770                         }
6771
6772                         if (subtype == VSREPLACEALL) {
6773                                 while (idx < loc) {
6774                                         if (quotes && (unsigned char)*idx == CTLESC)
6775                                                 idx++;
6776                                         idx++;
6777                                         rmesc++;
6778                                 }
6779                         } else {
6780                                 idx = loc;
6781                         }
6782
6783                         //bb_error_msg("repl:'%s'", repl);
6784                         for (loc = (char*)repl; *loc; loc++) {
6785                                 char *restart_detect = stackblock();
6786                                 if (quotes && *loc == '\\') {
6787                                         STPUTC(CTLESC, expdest);
6788                                         len++;
6789                                 }
6790                                 STPUTC(*loc, expdest);
6791                                 if (stackblock() != restart_detect)
6792                                         goto restart;
6793                                 len++;
6794                         }
6795
6796                         if (subtype == VSREPLACE) {
6797                                 //bb_error_msg("tail:'%s', quotes:%x", idx, quotes);
6798                                 while (*idx) {
6799                                         char *restart_detect = stackblock();
6800                                         STPUTC(*idx, expdest);
6801                                         if (stackblock() != restart_detect)
6802                                                 goto restart;
6803                                         len++;
6804                                         idx++;
6805                                 }
6806                                 break;
6807                         }
6808                 }
6809
6810                 /* We've put the replaced text into a buffer at workloc, now
6811                  * move it to the right place and adjust the stack.
6812                  */
6813                 STPUTC('\0', expdest);
6814                 startp = (char *)stackblock() + startloc;
6815                 memmove(startp, (char *)stackblock() + workloc, len + 1);
6816                 //bb_error_msg("startp:'%s'", startp);
6817                 amount = expdest - (startp + len);
6818                 STADJUST(-amount, expdest);
6819                 return startp;
6820         }
6821 #endif /* BASH_PATTERN_SUBST */
6822
6823         subtype -= VSTRIMRIGHT;
6824 #if DEBUG
6825         if (subtype < 0 || subtype > 7)
6826                 abort();
6827 #endif
6828         /* zero = (subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX) */
6829         zero = subtype >> 1;
6830         /* VSTRIMLEFT/VSTRIMRIGHTMAX -> scanleft */
6831         scan = (subtype & 1) ^ zero ? scanleft : scanright;
6832
6833         loc = scan(startp, rmesc, rmescend, str, quotes, zero);
6834         if (loc) {
6835                 if (zero) {
6836                         memmove(startp, loc, str - loc);
6837                         loc = startp + (str - loc) - 1;
6838                 }
6839                 *loc = '\0';
6840                 amount = loc - expdest;
6841                 STADJUST(amount, expdest);
6842         }
6843         return loc;
6844 }
6845
6846 /*
6847  * Add the value of a specialized variable to the stack string.
6848  * name parameter (examples):
6849  * ash -c 'echo $1'      name:'1='
6850  * ash -c 'echo $qwe'    name:'qwe='
6851  * ash -c 'echo $$'      name:'$='
6852  * ash -c 'echo ${$}'    name:'$='
6853  * ash -c 'echo ${$##q}' name:'$=q'
6854  * ash -c 'echo ${#$}'   name:'$='
6855  * note: examples with bad shell syntax:
6856  * ash -c 'echo ${#$1}'  name:'$=1'
6857  * ash -c 'echo ${#1#}'  name:'1=#'
6858  */
6859 static NOINLINE ssize_t
6860 varvalue(char *name, int varflags, int flags, struct strlist *var_str_list, int *quotedp)
6861 {
6862         const char *p;
6863         int num;
6864         int i;
6865         ssize_t len = 0;
6866         int sep;
6867         int quoted = *quotedp;
6868         int subtype = varflags & VSTYPE;
6869         int discard = subtype == VSPLUS || subtype == VSLENGTH;
6870         int quotes = (discard ? 0 : (flags & QUOTES_ESC)) | QUOTES_KEEPNUL;
6871         int syntax;
6872
6873         sep = (flags & EXP_FULL) << CHAR_BIT;
6874         syntax = quoted ? DQSYNTAX : BASESYNTAX;
6875
6876         switch (*name) {
6877         case '$':
6878                 num = rootpid;
6879                 goto numvar;
6880         case '?':
6881                 num = exitstatus;
6882                 goto numvar;
6883         case '#':
6884                 num = shellparam.nparam;
6885                 goto numvar;
6886         case '!':
6887                 num = backgndpid;
6888                 if (num == 0)
6889                         return -1;
6890  numvar:
6891                 len = cvtnum(num);
6892                 goto check_1char_name;
6893         case '-':
6894                 expdest = makestrspace(NOPTS, expdest);
6895                 for (i = NOPTS - 1; i >= 0; i--) {
6896                         if (optlist[i]) {
6897                                 USTPUTC(optletters(i), expdest);
6898                                 len++;
6899                         }
6900                 }
6901  check_1char_name:
6902 #if 0
6903                 /* handles cases similar to ${#$1} */
6904                 if (name[2] != '\0')
6905                         raise_error_syntax("bad substitution");
6906 #endif
6907                 break;
6908         case '@':
6909                 if (quoted && sep)
6910                         goto param;
6911                 /* fall through */
6912         case '*': {
6913                 char **ap;
6914                 char sepc;
6915
6916                 if (quoted)
6917                         sep = 0;
6918                 sep |= ifsset() ? ifsval()[0] : ' ';
6919  param:
6920                 sepc = sep;
6921                 *quotedp = !sepc;
6922                 ap = shellparam.p;
6923                 if (!ap)
6924                         return -1;
6925                 while ((p = *ap++) != NULL) {
6926                         len += strtodest(p, syntax, quotes);
6927
6928                         if (*ap && sep) {
6929                                 len++;
6930                                 memtodest(&sepc, 1, syntax, quotes);
6931                         }
6932                 }
6933                 break;
6934         } /* case '*' */
6935         case '0':
6936         case '1':
6937         case '2':
6938         case '3':
6939         case '4':
6940         case '5':
6941         case '6':
6942         case '7':
6943         case '8':
6944         case '9':
6945                 num = atoi(name); /* number(name) fails on ${N#str} etc */
6946                 if (num < 0 || num > shellparam.nparam)
6947                         return -1;
6948                 p = num ? shellparam.p[num - 1] : arg0;
6949                 goto value;
6950         default:
6951                 /* NB: name has form "VAR=..." */
6952
6953                 /* "A=a B=$A" case: var_str_list is a list of "A=a" strings
6954                  * which should be considered before we check variables. */
6955                 if (var_str_list) {
6956                         unsigned name_len = (strchrnul(name, '=') - name) + 1;
6957                         p = NULL;
6958                         do {
6959                                 char *str, *eq;
6960                                 str = var_str_list->text;
6961                                 eq = strchr(str, '=');
6962                                 if (!eq) /* stop at first non-assignment */
6963                                         break;
6964                                 eq++;
6965                                 if (name_len == (unsigned)(eq - str)
6966                                  && strncmp(str, name, name_len) == 0
6967                                 ) {
6968                                         p = eq;
6969                                         /* goto value; - WRONG! */
6970                                         /* think "A=1 A=2 B=$A" */
6971                                 }
6972                                 var_str_list = var_str_list->next;
6973                         } while (var_str_list);
6974                         if (p)
6975                                 goto value;
6976                 }
6977                 p = lookupvar(name);
6978  value:
6979                 if (!p)
6980                         return -1;
6981
6982                 len = strtodest(p, syntax, quotes);
6983 #if ENABLE_UNICODE_SUPPORT
6984                 if (subtype == VSLENGTH && len > 0) {
6985                         reinit_unicode_for_ash();
6986                         if (unicode_status == UNICODE_ON) {
6987                                 STADJUST(-len, expdest);
6988                                 discard = 0;
6989                                 len = unicode_strlen(p);
6990                         }
6991                 }
6992 #endif
6993                 break;
6994         }
6995
6996         if (discard)
6997                 STADJUST(-len, expdest);
6998         return len;
6999 }
7000
7001 /*
7002  * Expand a variable, and return a pointer to the next character in the
7003  * input string.
7004  */
7005 static char *
7006 evalvar(char *p, int flag, struct strlist *var_str_list)
7007 {
7008         char varflags;
7009         char subtype;
7010         int quoted;
7011         char easy;
7012         char *var;
7013         int patloc;
7014         int startloc;
7015         ssize_t varlen;
7016
7017         varflags = (unsigned char) *p++;
7018         subtype = varflags & VSTYPE;
7019
7020         if (!subtype)
7021                 raise_error_syntax("bad substitution");
7022
7023         quoted = flag & EXP_QUOTED;
7024         var = p;
7025         easy = (!quoted || (*var == '@' && shellparam.nparam));
7026         startloc = expdest - (char *)stackblock();
7027         p = strchr(p, '=') + 1; //TODO: use var_end(p)?
7028
7029  again:
7030         varlen = varvalue(var, varflags, flag, var_str_list, &quoted);
7031         if (varflags & VSNUL)
7032                 varlen--;
7033
7034         if (subtype == VSPLUS) {
7035                 varlen = -1 - varlen;
7036                 goto vsplus;
7037         }
7038
7039         if (subtype == VSMINUS) {
7040  vsplus:
7041                 if (varlen < 0) {
7042                         argstr(
7043                                 p,
7044                                 flag | EXP_TILDE | EXP_WORD,
7045                                 var_str_list
7046                         );
7047                         goto end;
7048                 }
7049                 goto record;
7050         }
7051
7052         if (subtype == VSASSIGN || subtype == VSQUESTION) {
7053                 if (varlen >= 0)
7054                         goto record;
7055
7056                 subevalvar(p, var, 0, subtype, startloc, varflags,
7057                            flag & ~QUOTES_ESC, var_str_list);
7058                 varflags &= ~VSNUL;
7059                 /*
7060                  * Remove any recorded regions beyond
7061                  * start of variable
7062                  */
7063                 removerecordregions(startloc);
7064                 goto again;
7065         }
7066
7067         if (varlen < 0 && uflag)
7068                 varunset(p, var, 0, 0);
7069
7070         if (subtype == VSLENGTH) {
7071                 cvtnum(varlen > 0 ? varlen : 0);
7072                 goto record;
7073         }
7074
7075         if (subtype == VSNORMAL) {
7076  record:
7077                 if (!easy)
7078                         goto end;
7079                 recordregion(startloc, expdest - (char *)stackblock(), quoted);
7080                 goto end;
7081         }
7082
7083 #if DEBUG
7084         switch (subtype) {
7085         case VSTRIMLEFT:
7086         case VSTRIMLEFTMAX:
7087         case VSTRIMRIGHT:
7088         case VSTRIMRIGHTMAX:
7089 #if BASH_SUBSTR
7090         case VSSUBSTR:
7091 #endif
7092 #if BASH_PATTERN_SUBST
7093         case VSREPLACE:
7094         case VSREPLACEALL:
7095 #endif
7096                 break;
7097         default:
7098                 abort();
7099         }
7100 #endif
7101
7102         if (varlen >= 0) {
7103                 /*
7104                  * Terminate the string and start recording the pattern
7105                  * right after it
7106                  */
7107                 STPUTC('\0', expdest);
7108                 patloc = expdest - (char *)stackblock();
7109                 if (NULL == subevalvar(p, /* varname: */ NULL, patloc, subtype,
7110                                 startloc, varflags, flag, var_str_list)) {
7111                         int amount = expdest - (
7112                                 (char *)stackblock() + patloc - 1
7113                         );
7114                         STADJUST(-amount, expdest);
7115                 }
7116                 /* Remove any recorded regions beyond start of variable */
7117                 removerecordregions(startloc);
7118                 goto record;
7119         }
7120
7121  end:
7122         if (subtype != VSNORMAL) {      /* skip to end of alternative */
7123                 int nesting = 1;
7124                 for (;;) {
7125                         unsigned char c = *p++;
7126                         if (c == CTLESC)
7127                                 p++;
7128                         else if (c == CTLBACKQ) {
7129                                 if (varlen >= 0)
7130                                         argbackq = argbackq->next;
7131                         } else if (c == CTLVAR) {
7132                                 if ((*p++ & VSTYPE) != VSNORMAL)
7133                                         nesting++;
7134                         } else if (c == CTLENDVAR) {
7135                                 if (--nesting == 0)
7136                                         break;
7137                         }
7138                 }
7139         }
7140         return p;
7141 }
7142
7143 /*
7144  * Add a file name to the list.
7145  */
7146 static void
7147 addfname(const char *name)
7148 {
7149         struct strlist *sp;
7150
7151         sp = stzalloc(sizeof(*sp));
7152         sp->text = sstrdup(name);
7153         *exparg.lastp = sp;
7154         exparg.lastp = &sp->next;
7155 }
7156
7157 /* Avoid glob() (and thus, stat() et al) for words like "echo" */
7158 static int
7159 hasmeta(const char *p)
7160 {
7161         static const char chars[] ALIGN1 = {
7162                 '*', '?', '[', '\\', CTLQUOTEMARK, CTLESC, 0
7163         };
7164
7165         for (;;) {
7166                 p = strpbrk(p, chars);
7167                 if (!p)
7168                         break;
7169                 switch ((unsigned char) *p) {
7170                 case CTLQUOTEMARK:
7171                         for (;;) {
7172                                 p++;
7173                                 if (*p == CTLQUOTEMARK)
7174                                         break;
7175                                 if (*p == CTLESC)
7176                                         p++;
7177                                 if (*p == '\0') /* huh? */
7178                                         return 0;
7179                         }
7180                         break;
7181                 case '\\':
7182                 case CTLESC:
7183                         p++;
7184                         if (*p == '\0')
7185                                 return 0;
7186                         break;
7187                 case '[':
7188                         if (!strchr(p + 1, ']')) {
7189                                 /* It's not a properly closed [] pattern,
7190                                  * but other metas may follow. Continue checking.
7191                                  * my[file* _is_ globbed by bash
7192                                  * and matches filenames like "my[file1".
7193                                  */
7194                                 break;
7195                         }
7196                         /* fallthrough */
7197                 default:
7198                 /* case '*': */
7199                 /* case '?': */
7200                         return 1;
7201                 }
7202                 p++;
7203         }
7204
7205         return 0;
7206 }
7207
7208 /* If we want to use glob() from libc... */
7209 #if !ENABLE_ASH_INTERNAL_GLOB
7210
7211 /* Add the result of glob() to the list */
7212 static void
7213 addglob(const glob_t *pglob)
7214 {
7215         char **p = pglob->gl_pathv;
7216
7217         do {
7218                 addfname(*p);
7219         } while (*++p);
7220 }
7221 static void
7222 expandmeta(struct strlist *str /*, int flag*/)
7223 {
7224         /* TODO - EXP_REDIR */
7225
7226         while (str) {
7227                 char *p;
7228                 glob_t pglob;
7229                 int i;
7230
7231                 if (fflag)
7232                         goto nometa;
7233
7234                 if (!hasmeta(str->text))
7235                         goto nometa;
7236
7237                 INT_OFF;
7238                 p = preglob(str->text, RMESCAPE_ALLOC | RMESCAPE_HEAP);
7239 // GLOB_NOMAGIC (GNU): if no *?[ chars in pattern, return it even if no match
7240 // GLOB_NOCHECK: if no match, return unchanged pattern (sans \* escapes?)
7241 //
7242 // glibc 2.24.90 glob(GLOB_NOMAGIC) does not remove backslashes used for escaping:
7243 // if you pass it "file\?", it returns "file\?", not "file?", if no match.
7244 // Which means you need to unescape the string, right? Not so fast:
7245 // if there _is_ a file named "file\?" (with backslash), it is returned
7246 // as "file\?" too (whichever pattern you used to find it, say, "file*").
7247 // You DON'T KNOW by looking at the result whether you need to unescape it.
7248 //
7249 // Worse, globbing of "file\?" in a directory with two files, "file?" and "file\?",
7250 // returns "file\?" - which is WRONG: "file\?" pattern matches "file?" file.
7251 // Without GLOB_NOMAGIC, this works correctly ("file?" is returned as a match).
7252 // With GLOB_NOMAGIC | GLOB_NOCHECK, this also works correctly.
7253 //              i = glob(p, GLOB_NOMAGIC | GLOB_NOCHECK, NULL, &pglob);
7254 //              i = glob(p, GLOB_NOMAGIC, NULL, &pglob);
7255                 i = glob(p, 0, NULL, &pglob);
7256                 //bb_error_msg("glob('%s'):%d '%s'...", p, i, pglob.gl_pathv ? pglob.gl_pathv[0] : "-");
7257                 if (p != str->text)
7258                         free(p);
7259                 switch (i) {
7260                 case 0:
7261 #if 0 // glibc 2.24.90 bug? Patterns like "*/file", when match, don't set GLOB_MAGCHAR
7262                         /* GLOB_MAGCHAR is set if *?[ chars were seen (GNU) */
7263                         if (!(pglob.gl_flags & GLOB_MAGCHAR))
7264                                 goto nometa2;
7265 #endif
7266                         addglob(&pglob);
7267                         globfree(&pglob);
7268                         INT_ON;
7269                         break;
7270                 case GLOB_NOMATCH:
7271  //nometa2:
7272                         globfree(&pglob);
7273                         INT_ON;
7274  nometa:
7275                         *exparg.lastp = str;
7276                         rmescapes(str->text, 0);
7277                         exparg.lastp = &str->next;
7278                         break;
7279                 default:        /* GLOB_NOSPACE */
7280                         globfree(&pglob);
7281                         INT_ON;
7282                         ash_msg_and_raise_error(bb_msg_memory_exhausted);
7283                 }
7284                 str = str->next;
7285         }
7286 }
7287
7288 #else
7289 /* ENABLE_ASH_INTERNAL_GLOB: Homegrown globbing code. (dash also has both, uses homegrown one.) */
7290
7291 /*
7292  * Do metacharacter (i.e. *, ?, [...]) expansion.
7293  */
7294 static void
7295 expmeta(char *expdir, char *enddir, char *name)
7296 {
7297         char *p;
7298         const char *cp;
7299         char *start;
7300         char *endname;
7301         int metaflag;
7302         struct stat statb;
7303         DIR *dirp;
7304         struct dirent *dp;
7305         int atend;
7306         int matchdot;
7307         int esc;
7308
7309         metaflag = 0;
7310         start = name;
7311         for (p = name; esc = 0, *p; p += esc + 1) {
7312                 if (*p == '*' || *p == '?')
7313                         metaflag = 1;
7314                 else if (*p == '[') {
7315                         char *q = p + 1;
7316                         if (*q == '!')
7317                                 q++;
7318                         for (;;) {
7319                                 if (*q == '\\')
7320                                         q++;
7321                                 if (*q == '/' || *q == '\0')
7322                                         break;
7323                                 if (*++q == ']') {
7324                                         metaflag = 1;
7325                                         break;
7326                                 }
7327                         }
7328                 } else {
7329                         if (*p == '\\')
7330                                 esc++;
7331                         if (p[esc] == '/') {
7332                                 if (metaflag)
7333                                         break;
7334                                 start = p + esc + 1;
7335                         }
7336                 }
7337         }
7338         if (metaflag == 0) {    /* we've reached the end of the file name */
7339                 if (enddir != expdir)
7340                         metaflag++;
7341                 p = name;
7342                 do {
7343                         if (*p == '\\')
7344                                 p++;
7345                         *enddir++ = *p;
7346                 } while (*p++);
7347                 if (metaflag == 0 || lstat(expdir, &statb) >= 0)
7348                         addfname(expdir);
7349                 return;
7350         }
7351         endname = p;
7352         if (name < start) {
7353                 p = name;
7354                 do {
7355                         if (*p == '\\')
7356                                 p++;
7357                         *enddir++ = *p++;
7358                 } while (p < start);
7359         }
7360         if (enddir == expdir) {
7361                 cp = ".";
7362         } else if (enddir == expdir + 1 && *expdir == '/') {
7363                 cp = "/";
7364         } else {
7365                 cp = expdir;
7366                 enddir[-1] = '\0';
7367         }
7368         dirp = opendir(cp);
7369         if (dirp == NULL)
7370                 return;
7371         if (enddir != expdir)
7372                 enddir[-1] = '/';
7373         if (*endname == 0) {
7374                 atend = 1;
7375         } else {
7376                 atend = 0;
7377                 *endname = '\0';
7378                 endname += esc + 1;
7379         }
7380         matchdot = 0;
7381         p = start;
7382         if (*p == '\\')
7383                 p++;
7384         if (*p == '.')
7385                 matchdot++;
7386         while (!pending_int && (dp = readdir(dirp)) != NULL) {
7387                 if (dp->d_name[0] == '.' && !matchdot)
7388                         continue;
7389                 if (pmatch(start, dp->d_name)) {
7390                         if (atend) {
7391                                 strcpy(enddir, dp->d_name);
7392                                 addfname(expdir);
7393                         } else {
7394                                 for (p = enddir, cp = dp->d_name; (*p++ = *cp++) != '\0';)
7395                                         continue;
7396                                 p[-1] = '/';
7397                                 expmeta(expdir, p, endname);
7398                         }
7399                 }
7400         }
7401         closedir(dirp);
7402         if (!atend)
7403                 endname[-esc - 1] = esc ? '\\' : '/';
7404 }
7405
7406 static struct strlist *
7407 msort(struct strlist *list, int len)
7408 {
7409         struct strlist *p, *q = NULL;
7410         struct strlist **lpp;
7411         int half;
7412         int n;
7413
7414         if (len <= 1)
7415                 return list;
7416         half = len >> 1;
7417         p = list;
7418         for (n = half; --n >= 0;) {
7419                 q = p;
7420                 p = p->next;
7421         }
7422         q->next = NULL;                 /* terminate first half of list */
7423         q = msort(list, half);          /* sort first half of list */
7424         p = msort(p, len - half);               /* sort second half */
7425         lpp = &list;
7426         for (;;) {
7427 #if ENABLE_LOCALE_SUPPORT
7428                 if (strcoll(p->text, q->text) < 0)
7429 #else
7430                 if (strcmp(p->text, q->text) < 0)
7431 #endif
7432                                                 {
7433                         *lpp = p;
7434                         lpp = &p->next;
7435                         p = *lpp;
7436                         if (p == NULL) {
7437                                 *lpp = q;
7438                                 break;
7439                         }
7440                 } else {
7441                         *lpp = q;
7442                         lpp = &q->next;
7443                         q = *lpp;
7444                         if (q == NULL) {
7445                                 *lpp = p;
7446                                 break;
7447                         }
7448                 }
7449         }
7450         return list;
7451 }
7452
7453 /*
7454  * Sort the results of file name expansion.  It calculates the number of
7455  * strings to sort and then calls msort (short for merge sort) to do the
7456  * work.
7457  */
7458 static struct strlist *
7459 expsort(struct strlist *str)
7460 {
7461         int len;
7462         struct strlist *sp;
7463
7464         len = 0;
7465         for (sp = str; sp; sp = sp->next)
7466                 len++;
7467         return msort(str, len);
7468 }
7469
7470 static void
7471 expandmeta(struct strlist *str /*, int flag*/)
7472 {
7473         /* TODO - EXP_REDIR */
7474
7475         while (str) {
7476                 char *expdir;
7477                 struct strlist **savelastp;
7478                 struct strlist *sp;
7479                 char *p;
7480
7481                 if (fflag)
7482                         goto nometa;
7483                 if (!hasmeta(str->text))
7484                         goto nometa;
7485                 savelastp = exparg.lastp;
7486
7487                 INT_OFF;
7488                 p = preglob(str->text, RMESCAPE_ALLOC | RMESCAPE_HEAP);
7489                 {
7490                         int i = strlen(str->text);
7491 //BUGGY estimation of how long expanded name can be
7492                         expdir = ckmalloc(i < 2048 ? 2048 : i+1);
7493                 }
7494                 expmeta(expdir, expdir, p);
7495                 free(expdir);
7496                 if (p != str->text)
7497                         free(p);
7498                 INT_ON;
7499                 if (exparg.lastp == savelastp) {
7500                         /*
7501                          * no matches
7502                          */
7503  nometa:
7504                         *exparg.lastp = str;
7505                         rmescapes(str->text, 0);
7506                         exparg.lastp = &str->next;
7507                 } else {
7508                         *exparg.lastp = NULL;
7509                         *savelastp = sp = expsort(*savelastp);
7510                         while (sp->next != NULL)
7511                                 sp = sp->next;
7512                         exparg.lastp = &sp->next;
7513                 }
7514                 str = str->next;
7515         }
7516 }
7517 #endif /* ENABLE_ASH_INTERNAL_GLOB */
7518
7519 /*
7520  * Perform variable substitution and command substitution on an argument,
7521  * placing the resulting list of arguments in arglist.  If EXP_FULL is true,
7522  * perform splitting and file name expansion.  When arglist is NULL, perform
7523  * here document expansion.
7524  */
7525 static void
7526 expandarg(union node *arg, struct arglist *arglist, int flag)
7527 {
7528         struct strlist *sp;
7529         char *p;
7530
7531         argbackq = arg->narg.backquote;
7532         STARTSTACKSTR(expdest);
7533         TRACE(("expandarg: argstr('%s',flags:%x)\n", arg->narg.text, flag));
7534         argstr(arg->narg.text, flag,
7535                         /* var_str_list: */ arglist ? arglist->list : NULL);
7536         p = _STPUTC('\0', expdest);
7537         expdest = p - 1;
7538         if (arglist == NULL) {
7539                 /* here document expanded */
7540                 goto out;
7541         }
7542         p = grabstackstr(p);
7543         TRACE(("expandarg: p:'%s'\n", p));
7544         exparg.lastp = &exparg.list;
7545         /*
7546          * TODO - EXP_REDIR
7547          */
7548         if (flag & EXP_FULL) {
7549                 ifsbreakup(p, &exparg);
7550                 *exparg.lastp = NULL;
7551                 exparg.lastp = &exparg.list;
7552                 expandmeta(exparg.list /*, flag*/);
7553         } else {
7554                 if (flag & EXP_REDIR) { /*XXX - for now, just remove escapes */
7555                         rmescapes(p, 0);
7556                         TRACE(("expandarg: rmescapes:'%s'\n", p));
7557                 }
7558                 sp = stzalloc(sizeof(*sp));
7559                 sp->text = p;
7560                 *exparg.lastp = sp;
7561                 exparg.lastp = &sp->next;
7562         }
7563         *exparg.lastp = NULL;
7564         if (exparg.list) {
7565                 *arglist->lastp = exparg.list;
7566                 arglist->lastp = exparg.lastp;
7567         }
7568
7569  out:
7570         ifsfree();
7571 }
7572
7573 /*
7574  * Expand shell variables and backquotes inside a here document.
7575  */
7576 static void
7577 expandhere(union node *arg, int fd)
7578 {
7579         expandarg(arg, (struct arglist *)NULL, EXP_QUOTED);
7580         full_write(fd, stackblock(), expdest - (char *)stackblock());
7581 }
7582
7583 /*
7584  * Returns true if the pattern matches the string.
7585  */
7586 static int
7587 patmatch(char *pattern, const char *string)
7588 {
7589         return pmatch(preglob(pattern, 0), string);
7590 }
7591
7592 /*
7593  * See if a pattern matches in a case statement.
7594  */
7595 static int
7596 casematch(union node *pattern, char *val)
7597 {
7598         struct stackmark smark;
7599         int result;
7600
7601         setstackmark(&smark);
7602         argbackq = pattern->narg.backquote;
7603         STARTSTACKSTR(expdest);
7604         argstr(pattern->narg.text, EXP_TILDE | EXP_CASE,
7605                         /* var_str_list: */ NULL);
7606         STACKSTRNUL(expdest);
7607         ifsfree();
7608         result = patmatch(stackblock(), val);
7609         popstackmark(&smark);
7610         return result;
7611 }
7612
7613
7614 /* ============ find_command */
7615
7616 struct builtincmd {
7617         const char *name;
7618         int (*builtin)(int, char **) FAST_FUNC;
7619         /* unsigned flags; */
7620 };
7621 #define IS_BUILTIN_SPECIAL(b) ((b)->name[0] & 1)
7622 /* "regular" builtins always take precedence over commands,
7623  * regardless of PATH=....%builtin... position */
7624 #define IS_BUILTIN_REGULAR(b) ((b)->name[0] & 2)
7625 #define IS_BUILTIN_ASSIGN(b)  ((b)->name[0] & 4)
7626
7627 struct cmdentry {
7628         smallint cmdtype;       /* CMDxxx */
7629         union param {
7630                 int index;
7631                 /* index >= 0 for commands without path (slashes) */
7632                 /* (TODO: what exactly does the value mean? PATH position?) */
7633                 /* index == -1 for commands with slashes */
7634                 /* index == (-2 - applet_no) for NOFORK applets */
7635                 const struct builtincmd *cmd;
7636                 struct funcnode *func;
7637         } u;
7638 };
7639 /* values of cmdtype */
7640 #define CMDUNKNOWN      -1      /* no entry in table for command */
7641 #define CMDNORMAL       0       /* command is an executable program */
7642 #define CMDFUNCTION     1       /* command is a shell function */
7643 #define CMDBUILTIN      2       /* command is a shell builtin */
7644
7645 /* action to find_command() */
7646 #define DO_ERR          0x01    /* prints errors */
7647 #define DO_ABS          0x02    /* checks absolute paths */
7648 #define DO_NOFUNC       0x04    /* don't return shell functions, for command */
7649 #define DO_ALTPATH      0x08    /* using alternate path */
7650 #define DO_ALTBLTIN     0x20    /* %builtin in alt. path */
7651
7652 static void find_command(char *, struct cmdentry *, int, const char *);
7653
7654
7655 /* ============ Hashing commands */
7656
7657 /*
7658  * When commands are first encountered, they are entered in a hash table.
7659  * This ensures that a full path search will not have to be done for them
7660  * on each invocation.
7661  *
7662  * We should investigate converting to a linear search, even though that
7663  * would make the command name "hash" a misnomer.
7664  */
7665
7666 struct tblentry {
7667         struct tblentry *next;  /* next entry in hash chain */
7668         union param param;      /* definition of builtin function */
7669         smallint cmdtype;       /* CMDxxx */
7670         char rehash;            /* if set, cd done since entry created */
7671         char cmdname[1];        /* name of command */
7672 };
7673
7674 static struct tblentry **cmdtable;
7675 #define INIT_G_cmdtable() do { \
7676         cmdtable = xzalloc(CMDTABLESIZE * sizeof(cmdtable[0])); \
7677 } while (0)
7678
7679 static int builtinloc = -1;     /* index in path of %builtin, or -1 */
7680
7681
7682 static void
7683 tryexec(IF_FEATURE_SH_STANDALONE(int applet_no,) char *cmd, char **argv, char **envp)
7684 {
7685 #if ENABLE_FEATURE_SH_STANDALONE
7686         if (applet_no >= 0) {
7687                 if (APPLET_IS_NOEXEC(applet_no)) {
7688                         clearenv();
7689                         while (*envp)
7690                                 putenv(*envp++);
7691                         run_applet_no_and_exit(applet_no, argv);
7692                 }
7693                 /* re-exec ourselves with the new arguments */
7694                 execve(bb_busybox_exec_path, argv, envp);
7695                 /* If they called chroot or otherwise made the binary no longer
7696                  * executable, fall through */
7697         }
7698 #endif
7699
7700  repeat:
7701 #ifdef SYSV
7702         do {
7703                 execve(cmd, argv, envp);
7704         } while (errno == EINTR);
7705 #else
7706         execve(cmd, argv, envp);
7707 #endif
7708         if (cmd != (char*) bb_busybox_exec_path && errno == ENOEXEC) {
7709                 /* Run "cmd" as a shell script:
7710                  * http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html
7711                  * "If the execve() function fails with ENOEXEC, the shell
7712                  * shall execute a command equivalent to having a shell invoked
7713                  * with the command name as its first operand,
7714                  * with any remaining arguments passed to the new shell"
7715                  *
7716                  * That is, do not use $SHELL, user's shell, or /bin/sh;
7717                  * just call ourselves.
7718                  *
7719                  * Note that bash reads ~80 chars of the file, and if it sees
7720                  * a zero byte before it sees newline, it doesn't try to
7721                  * interpret it, but fails with "cannot execute binary file"
7722                  * message and exit code 126. For one, this prevents attempts
7723                  * to interpret foreign ELF binaries as shell scripts.
7724                  */
7725                 argv[0] = cmd;
7726                 cmd = (char*) bb_busybox_exec_path;
7727                 /* NB: this is only possible because all callers of shellexec()
7728                  * ensure that the argv[-1] slot exists!
7729                  */
7730                 argv--;
7731                 argv[0] = (char*) "ash";
7732                 goto repeat;
7733         }
7734 }
7735
7736 /*
7737  * Exec a program.  Never returns.  If you change this routine, you may
7738  * have to change the find_command routine as well.
7739  * argv[-1] must exist and be writable! See tryexec() for why.
7740  */
7741 static void shellexec(char *prog, char **argv, const char *path, int idx) NORETURN;
7742 static void shellexec(char *prog, char **argv, const char *path, int idx)
7743 {
7744         char *cmdname;
7745         int e;
7746         char **envp;
7747         int exerrno;
7748         int applet_no = -1; /* used only by FEATURE_SH_STANDALONE */
7749
7750         envp = listvars(VEXPORT, VUNSET, /*end:*/ NULL);
7751         if (strchr(prog, '/') != NULL
7752 #if ENABLE_FEATURE_SH_STANDALONE
7753          || (applet_no = find_applet_by_name(prog)) >= 0
7754 #endif
7755         ) {
7756                 tryexec(IF_FEATURE_SH_STANDALONE(applet_no,) prog, argv, envp);
7757                 if (applet_no >= 0) {
7758                         /* We tried execing ourself, but it didn't work.
7759                          * Maybe /proc/self/exe doesn't exist?
7760                          * Try $PATH search.
7761                          */
7762                         goto try_PATH;
7763                 }
7764                 e = errno;
7765         } else {
7766  try_PATH:
7767                 e = ENOENT;
7768                 while ((cmdname = path_advance(&path, prog)) != NULL) {
7769                         if (--idx < 0 && pathopt == NULL) {
7770                                 tryexec(IF_FEATURE_SH_STANDALONE(-1,) cmdname, argv, envp);
7771                                 if (errno != ENOENT && errno != ENOTDIR)
7772                                         e = errno;
7773                         }
7774                         stunalloc(cmdname);
7775                 }
7776         }
7777
7778         /* Map to POSIX errors */
7779         switch (e) {
7780         case EACCES:
7781                 exerrno = 126;
7782                 break;
7783         case ENOENT:
7784                 exerrno = 127;
7785                 break;
7786         default:
7787                 exerrno = 2;
7788                 break;
7789         }
7790         exitstatus = exerrno;
7791         TRACE(("shellexec failed for %s, errno %d, suppress_int %d\n",
7792                 prog, e, suppress_int));
7793         ash_msg_and_raise(EXEXIT, "%s: %s", prog, errmsg(e, "not found"));
7794         /* NOTREACHED */
7795 }
7796
7797 static void
7798 printentry(struct tblentry *cmdp)
7799 {
7800         int idx;
7801         const char *path;
7802         char *name;
7803
7804         idx = cmdp->param.index;
7805         path = pathval();
7806         do {
7807                 name = path_advance(&path, cmdp->cmdname);
7808                 stunalloc(name);
7809         } while (--idx >= 0);
7810         out1fmt("%s%s\n", name, (cmdp->rehash ? "*" : nullstr));
7811 }
7812
7813 /*
7814  * Clear out command entries.  The argument specifies the first entry in
7815  * PATH which has changed.
7816  */
7817 static void
7818 clearcmdentry(int firstchange)
7819 {
7820         struct tblentry **tblp;
7821         struct tblentry **pp;
7822         struct tblentry *cmdp;
7823
7824         INT_OFF;
7825         for (tblp = cmdtable; tblp < &cmdtable[CMDTABLESIZE]; tblp++) {
7826                 pp = tblp;
7827                 while ((cmdp = *pp) != NULL) {
7828                         if ((cmdp->cmdtype == CMDNORMAL &&
7829                              cmdp->param.index >= firstchange)
7830                          || (cmdp->cmdtype == CMDBUILTIN &&
7831                              builtinloc >= firstchange)
7832                         ) {
7833                                 *pp = cmdp->next;
7834                                 free(cmdp);
7835                         } else {
7836                                 pp = &cmdp->next;
7837                         }
7838                 }
7839         }
7840         INT_ON;
7841 }
7842
7843 /*
7844  * Locate a command in the command hash table.  If "add" is nonzero,
7845  * add the command to the table if it is not already present.  The
7846  * variable "lastcmdentry" is set to point to the address of the link
7847  * pointing to the entry, so that delete_cmd_entry can delete the
7848  * entry.
7849  *
7850  * Interrupts must be off if called with add != 0.
7851  */
7852 static struct tblentry **lastcmdentry;
7853
7854 static struct tblentry *
7855 cmdlookup(const char *name, int add)
7856 {
7857         unsigned int hashval;
7858         const char *p;
7859         struct tblentry *cmdp;
7860         struct tblentry **pp;
7861
7862         p = name;
7863         hashval = (unsigned char)*p << 4;
7864         while (*p)
7865                 hashval += (unsigned char)*p++;
7866         hashval &= 0x7FFF;
7867         pp = &cmdtable[hashval % CMDTABLESIZE];
7868         for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
7869                 if (strcmp(cmdp->cmdname, name) == 0)
7870                         break;
7871                 pp = &cmdp->next;
7872         }
7873         if (add && cmdp == NULL) {
7874                 cmdp = *pp = ckzalloc(sizeof(struct tblentry)
7875                                 + strlen(name)
7876                                 /* + 1 - already done because
7877                                  * tblentry::cmdname is char[1] */);
7878                 /*cmdp->next = NULL; - ckzalloc did it */
7879                 cmdp->cmdtype = CMDUNKNOWN;
7880                 strcpy(cmdp->cmdname, name);
7881         }
7882         lastcmdentry = pp;
7883         return cmdp;
7884 }
7885
7886 /*
7887  * Delete the command entry returned on the last lookup.
7888  */
7889 static void
7890 delete_cmd_entry(void)
7891 {
7892         struct tblentry *cmdp;
7893
7894         INT_OFF;
7895         cmdp = *lastcmdentry;
7896         *lastcmdentry = cmdp->next;
7897         if (cmdp->cmdtype == CMDFUNCTION)
7898                 freefunc(cmdp->param.func);
7899         free(cmdp);
7900         INT_ON;
7901 }
7902
7903 /*
7904  * Add a new command entry, replacing any existing command entry for
7905  * the same name - except special builtins.
7906  */
7907 static void
7908 addcmdentry(char *name, struct cmdentry *entry)
7909 {
7910         struct tblentry *cmdp;
7911
7912         cmdp = cmdlookup(name, 1);
7913         if (cmdp->cmdtype == CMDFUNCTION) {
7914                 freefunc(cmdp->param.func);
7915         }
7916         cmdp->cmdtype = entry->cmdtype;
7917         cmdp->param = entry->u;
7918         cmdp->rehash = 0;
7919 }
7920
7921 static int FAST_FUNC
7922 hashcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
7923 {
7924         struct tblentry **pp;
7925         struct tblentry *cmdp;
7926         int c;
7927         struct cmdentry entry;
7928         char *name;
7929
7930         if (nextopt("r") != '\0') {
7931                 clearcmdentry(0);
7932                 return 0;
7933         }
7934
7935         if (*argptr == NULL) {
7936                 for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
7937                         for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
7938                                 if (cmdp->cmdtype == CMDNORMAL)
7939                                         printentry(cmdp);
7940                         }
7941                 }
7942                 return 0;
7943         }
7944
7945         c = 0;
7946         while ((name = *argptr) != NULL) {
7947                 cmdp = cmdlookup(name, 0);
7948                 if (cmdp != NULL
7949                  && (cmdp->cmdtype == CMDNORMAL
7950                      || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))
7951                 ) {
7952                         delete_cmd_entry();
7953                 }
7954                 find_command(name, &entry, DO_ERR, pathval());
7955                 if (entry.cmdtype == CMDUNKNOWN)
7956                         c = 1;
7957                 argptr++;
7958         }
7959         return c;
7960 }
7961
7962 /*
7963  * Called when a cd is done.  Marks all commands so the next time they
7964  * are executed they will be rehashed.
7965  */
7966 static void
7967 hashcd(void)
7968 {
7969         struct tblentry **pp;
7970         struct tblentry *cmdp;
7971
7972         for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
7973                 for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
7974                         if (cmdp->cmdtype == CMDNORMAL
7975                          || (cmdp->cmdtype == CMDBUILTIN
7976                              && !IS_BUILTIN_REGULAR(cmdp->param.cmd)
7977                              && builtinloc > 0)
7978                         ) {
7979                                 cmdp->rehash = 1;
7980                         }
7981                 }
7982         }
7983 }
7984
7985 /*
7986  * Fix command hash table when PATH changed.
7987  * Called before PATH is changed.  The argument is the new value of PATH;
7988  * pathval() still returns the old value at this point.
7989  * Called with interrupts off.
7990  */
7991 static void FAST_FUNC
7992 changepath(const char *new)
7993 {
7994         const char *old;
7995         int firstchange;
7996         int idx;
7997         int idx_bltin;
7998
7999         old = pathval();
8000         firstchange = 9999;     /* assume no change */
8001         idx = 0;
8002         idx_bltin = -1;
8003         for (;;) {
8004                 if (*old != *new) {
8005                         firstchange = idx;
8006                         if ((*old == '\0' && *new == ':')
8007                          || (*old == ':' && *new == '\0')
8008                         ) {
8009                                 firstchange++;
8010                         }
8011                         old = new;      /* ignore subsequent differences */
8012                 }
8013                 if (*new == '\0')
8014                         break;
8015                 if (*new == '%' && idx_bltin < 0 && prefix(new + 1, "builtin"))
8016                         idx_bltin = idx;
8017                 if (*new == ':')
8018                         idx++;
8019                 new++;
8020                 old++;
8021         }
8022         if (builtinloc < 0 && idx_bltin >= 0)
8023                 builtinloc = idx_bltin;             /* zap builtins */
8024         if (builtinloc >= 0 && idx_bltin < 0)
8025                 firstchange = 0;
8026         clearcmdentry(firstchange);
8027         builtinloc = idx_bltin;
8028 }
8029 enum {
8030         TEOF,
8031         TNL,
8032         TREDIR,
8033         TWORD,
8034         TSEMI,
8035         TBACKGND,
8036         TAND,
8037         TOR,
8038         TPIPE,
8039         TLP,
8040         TRP,
8041         TENDCASE,
8042         TENDBQUOTE,
8043         TNOT,
8044         TCASE,
8045         TDO,
8046         TDONE,
8047         TELIF,
8048         TELSE,
8049         TESAC,
8050         TFI,
8051         TFOR,
8052 #if BASH_FUNCTION
8053         TFUNCTION,
8054 #endif
8055         TIF,
8056         TIN,
8057         TTHEN,
8058         TUNTIL,
8059         TWHILE,
8060         TBEGIN,
8061         TEND
8062 };
8063 typedef smallint token_id_t;
8064
8065 /* Nth bit indicates if token marks the end of a list */
8066 enum {
8067         tokendlist = 0
8068         /*  0 */ | (1u << TEOF)
8069         /*  1 */ | (0u << TNL)
8070         /*  2 */ | (0u << TREDIR)
8071         /*  3 */ | (0u << TWORD)
8072         /*  4 */ | (0u << TSEMI)
8073         /*  5 */ | (0u << TBACKGND)
8074         /*  6 */ | (0u << TAND)
8075         /*  7 */ | (0u << TOR)
8076         /*  8 */ | (0u << TPIPE)
8077         /*  9 */ | (0u << TLP)
8078         /* 10 */ | (1u << TRP)
8079         /* 11 */ | (1u << TENDCASE)
8080         /* 12 */ | (1u << TENDBQUOTE)
8081         /* 13 */ | (0u << TNOT)
8082         /* 14 */ | (0u << TCASE)
8083         /* 15 */ | (1u << TDO)
8084         /* 16 */ | (1u << TDONE)
8085         /* 17 */ | (1u << TELIF)
8086         /* 18 */ | (1u << TELSE)
8087         /* 19 */ | (1u << TESAC)
8088         /* 20 */ | (1u << TFI)
8089         /* 21 */ | (0u << TFOR)
8090 #if BASH_FUNCTION
8091         /* 22 */ | (0u << TFUNCTION)
8092 #endif
8093         /* 23 */ | (0u << TIF)
8094         /* 24 */ | (0u << TIN)
8095         /* 25 */ | (1u << TTHEN)
8096         /* 26 */ | (0u << TUNTIL)
8097         /* 27 */ | (0u << TWHILE)
8098         /* 28 */ | (0u << TBEGIN)
8099         /* 29 */ | (1u << TEND)
8100         , /* thus far 29 bits used */
8101 };
8102
8103 static const char *const tokname_array[] = {
8104         "end of file",
8105         "newline",
8106         "redirection",
8107         "word",
8108         ";",
8109         "&",
8110         "&&",
8111         "||",
8112         "|",
8113         "(",
8114         ")",
8115         ";;",
8116         "`",
8117 #define KWDOFFSET 13
8118         /* the following are keywords */
8119         "!",
8120         "case",
8121         "do",
8122         "done",
8123         "elif",
8124         "else",
8125         "esac",
8126         "fi",
8127         "for",
8128 #if BASH_FUNCTION
8129         "function",
8130 #endif
8131         "if",
8132         "in",
8133         "then",
8134         "until",
8135         "while",
8136         "{",
8137         "}",
8138 };
8139
8140 /* Wrapper around strcmp for qsort/bsearch/... */
8141 static int
8142 pstrcmp(const void *a, const void *b)
8143 {
8144         return strcmp((char*)a, *(char**)b);
8145 }
8146
8147 static const char *const *
8148 findkwd(const char *s)
8149 {
8150         return bsearch(s, tokname_array + KWDOFFSET,
8151                         ARRAY_SIZE(tokname_array) - KWDOFFSET,
8152                         sizeof(tokname_array[0]), pstrcmp);
8153 }
8154
8155 /*
8156  * Locate and print what a word is...
8157  */
8158 static int
8159 describe_command(char *command, const char *path, int describe_command_verbose)
8160 {
8161         struct cmdentry entry;
8162 #if ENABLE_ASH_ALIAS
8163         const struct alias *ap;
8164 #endif
8165
8166         path = path ? path : pathval();
8167
8168         if (describe_command_verbose) {
8169                 out1str(command);
8170         }
8171
8172         /* First look at the keywords */
8173         if (findkwd(command)) {
8174                 out1str(describe_command_verbose ? " is a shell keyword" : command);
8175                 goto out;
8176         }
8177
8178 #if ENABLE_ASH_ALIAS
8179         /* Then look at the aliases */
8180         ap = lookupalias(command, 0);
8181         if (ap != NULL) {
8182                 if (!describe_command_verbose) {
8183                         out1str("alias ");
8184                         printalias(ap);
8185                         return 0;
8186                 }
8187                 out1fmt(" is an alias for %s", ap->val);
8188                 goto out;
8189         }
8190 #endif
8191         /* Brute force */
8192         find_command(command, &entry, DO_ABS, path);
8193
8194         switch (entry.cmdtype) {
8195         case CMDNORMAL: {
8196                 int j = entry.u.index;
8197                 char *p;
8198                 if (j < 0) {
8199                         p = command;
8200                 } else {
8201                         do {
8202                                 p = path_advance(&path, command);
8203                                 stunalloc(p);
8204                         } while (--j >= 0);
8205                 }
8206                 if (describe_command_verbose) {
8207                         out1fmt(" is %s", p);
8208                 } else {
8209                         out1str(p);
8210                 }
8211                 break;
8212         }
8213
8214         case CMDFUNCTION:
8215                 if (describe_command_verbose) {
8216                         out1str(" is a shell function");
8217                 } else {
8218                         out1str(command);
8219                 }
8220                 break;
8221
8222         case CMDBUILTIN:
8223                 if (describe_command_verbose) {
8224                         out1fmt(" is a %sshell builtin",
8225                                 IS_BUILTIN_SPECIAL(entry.u.cmd) ?
8226                                         "special " : nullstr
8227                         );
8228                 } else {
8229                         out1str(command);
8230                 }
8231                 break;
8232
8233         default:
8234                 if (describe_command_verbose) {
8235                         out1str(": not found\n");
8236                 }
8237                 return 127;
8238         }
8239  out:
8240         out1str("\n");
8241         return 0;
8242 }
8243
8244 static int FAST_FUNC
8245 typecmd(int argc UNUSED_PARAM, char **argv)
8246 {
8247         int i = 1;
8248         int err = 0;
8249         int verbose = 1;
8250
8251         /* type -p ... ? (we don't bother checking for 'p') */
8252         if (argv[1] && argv[1][0] == '-') {
8253                 i++;
8254                 verbose = 0;
8255         }
8256         while (argv[i]) {
8257                 err |= describe_command(argv[i++], NULL, verbose);
8258         }
8259         return err;
8260 }
8261
8262 #if ENABLE_ASH_CMDCMD
8263 /* Is it "command [-p] PROG ARGS" bltin, no other opts? Return ptr to "PROG" if yes */
8264 static char **
8265 parse_command_args(char **argv, const char **path)
8266 {
8267         char *cp, c;
8268
8269         for (;;) {
8270                 cp = *++argv;
8271                 if (!cp)
8272                         return NULL;
8273                 if (*cp++ != '-')
8274                         break;
8275                 c = *cp++;
8276                 if (!c)
8277                         break;
8278                 if (c == '-' && !*cp) {
8279                         if (!*++argv)
8280                                 return NULL;
8281                         break;
8282                 }
8283                 do {
8284                         switch (c) {
8285                         case 'p':
8286                                 *path = bb_default_path;
8287                                 break;
8288                         default:
8289                                 /* run 'typecmd' for other options */
8290                                 return NULL;
8291                         }
8292                         c = *cp++;
8293                 } while (c);
8294         }
8295         return argv;
8296 }
8297
8298 static int FAST_FUNC
8299 commandcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
8300 {
8301         char *cmd;
8302         int c;
8303         enum {
8304                 VERIFY_BRIEF = 1,
8305                 VERIFY_VERBOSE = 2,
8306         } verify = 0;
8307         const char *path = NULL;
8308
8309         /* "command [-p] PROG ARGS" (that is, without -V or -v)
8310          * never reaches this function.
8311          */
8312
8313         while ((c = nextopt("pvV")) != '\0')
8314                 if (c == 'V')
8315                         verify |= VERIFY_VERBOSE;
8316                 else if (c == 'v')
8317                         /*verify |= VERIFY_BRIEF*/;
8318 #if DEBUG
8319                 else if (c != 'p')
8320                         abort();
8321 #endif
8322                 else
8323                         path = bb_default_path;
8324
8325         /* Mimic bash: just "command -v" doesn't complain, it's a nop */
8326         cmd = *argptr;
8327         if (/*verify && */ cmd)
8328                 return describe_command(cmd, path, verify /* - VERIFY_BRIEF*/);
8329
8330         return 0;
8331 }
8332 #endif
8333
8334
8335 /*static int funcblocksize;     // size of structures in function */
8336 /*static int funcstringsize;    // size of strings in node */
8337 static void *funcblock;         /* block to allocate function from */
8338 static char *funcstring_end;    /* end of block to allocate strings from */
8339
8340 /* flags in argument to evaltree */
8341 #define EV_EXIT    01           /* exit after evaluating tree */
8342 #define EV_TESTED  02           /* exit status is checked; ignore -e flag */
8343
8344 static const uint8_t nodesize[N_NUMBER] ALIGN1 = {
8345         [NCMD     ] = SHELL_ALIGN(sizeof(struct ncmd)),
8346         [NPIPE    ] = SHELL_ALIGN(sizeof(struct npipe)),
8347         [NREDIR   ] = SHELL_ALIGN(sizeof(struct nredir)),
8348         [NBACKGND ] = SHELL_ALIGN(sizeof(struct nredir)),
8349         [NSUBSHELL] = SHELL_ALIGN(sizeof(struct nredir)),
8350         [NAND     ] = SHELL_ALIGN(sizeof(struct nbinary)),
8351         [NOR      ] = SHELL_ALIGN(sizeof(struct nbinary)),
8352         [NSEMI    ] = SHELL_ALIGN(sizeof(struct nbinary)),
8353         [NIF      ] = SHELL_ALIGN(sizeof(struct nif)),
8354         [NWHILE   ] = SHELL_ALIGN(sizeof(struct nbinary)),
8355         [NUNTIL   ] = SHELL_ALIGN(sizeof(struct nbinary)),
8356         [NFOR     ] = SHELL_ALIGN(sizeof(struct nfor)),
8357         [NCASE    ] = SHELL_ALIGN(sizeof(struct ncase)),
8358         [NCLIST   ] = SHELL_ALIGN(sizeof(struct nclist)),
8359         [NDEFUN   ] = SHELL_ALIGN(sizeof(struct narg)),
8360         [NARG     ] = SHELL_ALIGN(sizeof(struct narg)),
8361         [NTO      ] = SHELL_ALIGN(sizeof(struct nfile)),
8362 #if BASH_REDIR_OUTPUT
8363         [NTO2     ] = SHELL_ALIGN(sizeof(struct nfile)),
8364 #endif
8365         [NCLOBBER ] = SHELL_ALIGN(sizeof(struct nfile)),
8366         [NFROM    ] = SHELL_ALIGN(sizeof(struct nfile)),
8367         [NFROMTO  ] = SHELL_ALIGN(sizeof(struct nfile)),
8368         [NAPPEND  ] = SHELL_ALIGN(sizeof(struct nfile)),
8369         [NTOFD    ] = SHELL_ALIGN(sizeof(struct ndup)),
8370         [NFROMFD  ] = SHELL_ALIGN(sizeof(struct ndup)),
8371         [NHERE    ] = SHELL_ALIGN(sizeof(struct nhere)),
8372         [NXHERE   ] = SHELL_ALIGN(sizeof(struct nhere)),
8373         [NNOT     ] = SHELL_ALIGN(sizeof(struct nnot)),
8374 };
8375
8376 static int calcsize(int funcblocksize, union node *n);
8377
8378 static int
8379 sizenodelist(int funcblocksize, struct nodelist *lp)
8380 {
8381         while (lp) {
8382                 funcblocksize += SHELL_ALIGN(sizeof(struct nodelist));
8383                 funcblocksize = calcsize(funcblocksize, lp->n);
8384                 lp = lp->next;
8385         }
8386         return funcblocksize;
8387 }
8388
8389 static int
8390 calcsize(int funcblocksize, union node *n)
8391 {
8392         if (n == NULL)
8393                 return funcblocksize;
8394         funcblocksize += nodesize[n->type];
8395         switch (n->type) {
8396         case NCMD:
8397                 funcblocksize = calcsize(funcblocksize, n->ncmd.redirect);
8398                 funcblocksize = calcsize(funcblocksize, n->ncmd.args);
8399                 funcblocksize = calcsize(funcblocksize, n->ncmd.assign);
8400                 break;
8401         case NPIPE:
8402                 funcblocksize = sizenodelist(funcblocksize, n->npipe.cmdlist);
8403                 break;
8404         case NREDIR:
8405         case NBACKGND:
8406         case NSUBSHELL:
8407                 funcblocksize = calcsize(funcblocksize, n->nredir.redirect);
8408                 funcblocksize = calcsize(funcblocksize, n->nredir.n);
8409                 break;
8410         case NAND:
8411         case NOR:
8412         case NSEMI:
8413         case NWHILE:
8414         case NUNTIL:
8415                 funcblocksize = calcsize(funcblocksize, n->nbinary.ch2);
8416                 funcblocksize = calcsize(funcblocksize, n->nbinary.ch1);
8417                 break;
8418         case NIF:
8419                 funcblocksize = calcsize(funcblocksize, n->nif.elsepart);
8420                 funcblocksize = calcsize(funcblocksize, n->nif.ifpart);
8421                 funcblocksize = calcsize(funcblocksize, n->nif.test);
8422                 break;
8423         case NFOR:
8424                 funcblocksize += SHELL_ALIGN(strlen(n->nfor.var) + 1); /* was funcstringsize += ... */
8425                 funcblocksize = calcsize(funcblocksize, n->nfor.body);
8426                 funcblocksize = calcsize(funcblocksize, n->nfor.args);
8427                 break;
8428         case NCASE:
8429                 funcblocksize = calcsize(funcblocksize, n->ncase.cases);
8430                 funcblocksize = calcsize(funcblocksize, n->ncase.expr);
8431                 break;
8432         case NCLIST:
8433                 funcblocksize = calcsize(funcblocksize, n->nclist.body);
8434                 funcblocksize = calcsize(funcblocksize, n->nclist.pattern);
8435                 funcblocksize = calcsize(funcblocksize, n->nclist.next);
8436                 break;
8437         case NDEFUN:
8438         case NARG:
8439                 funcblocksize = sizenodelist(funcblocksize, n->narg.backquote);
8440                 funcblocksize += SHELL_ALIGN(strlen(n->narg.text) + 1); /* was funcstringsize += ... */
8441                 funcblocksize = calcsize(funcblocksize, n->narg.next);
8442                 break;
8443         case NTO:
8444 #if BASH_REDIR_OUTPUT
8445         case NTO2:
8446 #endif
8447         case NCLOBBER:
8448         case NFROM:
8449         case NFROMTO:
8450         case NAPPEND:
8451                 funcblocksize = calcsize(funcblocksize, n->nfile.fname);
8452                 funcblocksize = calcsize(funcblocksize, n->nfile.next);
8453                 break;
8454         case NTOFD:
8455         case NFROMFD:
8456                 funcblocksize = calcsize(funcblocksize, n->ndup.vname);
8457                 funcblocksize = calcsize(funcblocksize, n->ndup.next);
8458         break;
8459         case NHERE:
8460         case NXHERE:
8461                 funcblocksize = calcsize(funcblocksize, n->nhere.doc);
8462                 funcblocksize = calcsize(funcblocksize, n->nhere.next);
8463                 break;
8464         case NNOT:
8465                 funcblocksize = calcsize(funcblocksize, n->nnot.com);
8466                 break;
8467         };
8468         return funcblocksize;
8469 }
8470
8471 static char *
8472 nodeckstrdup(char *s)
8473 {
8474         funcstring_end -= SHELL_ALIGN(strlen(s) + 1);
8475         return strcpy(funcstring_end, s);
8476 }
8477
8478 static union node *copynode(union node *);
8479
8480 static struct nodelist *
8481 copynodelist(struct nodelist *lp)
8482 {
8483         struct nodelist *start;
8484         struct nodelist **lpp;
8485
8486         lpp = &start;
8487         while (lp) {
8488                 *lpp = funcblock;
8489                 funcblock = (char *) funcblock + SHELL_ALIGN(sizeof(struct nodelist));
8490                 (*lpp)->n = copynode(lp->n);
8491                 lp = lp->next;
8492                 lpp = &(*lpp)->next;
8493         }
8494         *lpp = NULL;
8495         return start;
8496 }
8497
8498 static union node *
8499 copynode(union node *n)
8500 {
8501         union node *new;
8502
8503         if (n == NULL)
8504                 return NULL;
8505         new = funcblock;
8506         funcblock = (char *) funcblock + nodesize[n->type];
8507
8508         switch (n->type) {
8509         case NCMD:
8510                 new->ncmd.redirect = copynode(n->ncmd.redirect);
8511                 new->ncmd.args = copynode(n->ncmd.args);
8512                 new->ncmd.assign = copynode(n->ncmd.assign);
8513                 break;
8514         case NPIPE:
8515                 new->npipe.cmdlist = copynodelist(n->npipe.cmdlist);
8516                 new->npipe.pipe_backgnd = n->npipe.pipe_backgnd;
8517                 break;
8518         case NREDIR:
8519         case NBACKGND:
8520         case NSUBSHELL:
8521                 new->nredir.redirect = copynode(n->nredir.redirect);
8522                 new->nredir.n = copynode(n->nredir.n);
8523                 break;
8524         case NAND:
8525         case NOR:
8526         case NSEMI:
8527         case NWHILE:
8528         case NUNTIL:
8529                 new->nbinary.ch2 = copynode(n->nbinary.ch2);
8530                 new->nbinary.ch1 = copynode(n->nbinary.ch1);
8531                 break;
8532         case NIF:
8533                 new->nif.elsepart = copynode(n->nif.elsepart);
8534                 new->nif.ifpart = copynode(n->nif.ifpart);
8535                 new->nif.test = copynode(n->nif.test);
8536                 break;
8537         case NFOR:
8538                 new->nfor.var = nodeckstrdup(n->nfor.var);
8539                 new->nfor.body = copynode(n->nfor.body);
8540                 new->nfor.args = copynode(n->nfor.args);
8541                 break;
8542         case NCASE:
8543                 new->ncase.cases = copynode(n->ncase.cases);
8544                 new->ncase.expr = copynode(n->ncase.expr);
8545                 break;
8546         case NCLIST:
8547                 new->nclist.body = copynode(n->nclist.body);
8548                 new->nclist.pattern = copynode(n->nclist.pattern);
8549                 new->nclist.next = copynode(n->nclist.next);
8550                 break;
8551         case NDEFUN:
8552         case NARG:
8553                 new->narg.backquote = copynodelist(n->narg.backquote);
8554                 new->narg.text = nodeckstrdup(n->narg.text);
8555                 new->narg.next = copynode(n->narg.next);
8556                 break;
8557         case NTO:
8558 #if BASH_REDIR_OUTPUT
8559         case NTO2:
8560 #endif
8561         case NCLOBBER:
8562         case NFROM:
8563         case NFROMTO:
8564         case NAPPEND:
8565                 new->nfile.fname = copynode(n->nfile.fname);
8566                 new->nfile.fd = n->nfile.fd;
8567                 new->nfile.next = copynode(n->nfile.next);
8568                 break;
8569         case NTOFD:
8570         case NFROMFD:
8571                 new->ndup.vname = copynode(n->ndup.vname);
8572                 new->ndup.dupfd = n->ndup.dupfd;
8573                 new->ndup.fd = n->ndup.fd;
8574                 new->ndup.next = copynode(n->ndup.next);
8575                 break;
8576         case NHERE:
8577         case NXHERE:
8578                 new->nhere.doc = copynode(n->nhere.doc);
8579                 new->nhere.fd = n->nhere.fd;
8580                 new->nhere.next = copynode(n->nhere.next);
8581                 break;
8582         case NNOT:
8583                 new->nnot.com = copynode(n->nnot.com);
8584                 break;
8585         };
8586         new->type = n->type;
8587         return new;
8588 }
8589
8590 /*
8591  * Make a copy of a parse tree.
8592  */
8593 static struct funcnode *
8594 copyfunc(union node *n)
8595 {
8596         struct funcnode *f;
8597         size_t blocksize;
8598
8599         /*funcstringsize = 0;*/
8600         blocksize = offsetof(struct funcnode, n) + calcsize(0, n);
8601         f = ckzalloc(blocksize /* + funcstringsize */);
8602         funcblock = (char *) f + offsetof(struct funcnode, n);
8603         funcstring_end = (char *) f + blocksize;
8604         copynode(n);
8605         /* f->count = 0; - ckzalloc did it */
8606         return f;
8607 }
8608
8609 /*
8610  * Define a shell function.
8611  */
8612 static void
8613 defun(union node *func)
8614 {
8615         struct cmdentry entry;
8616
8617         INT_OFF;
8618         entry.cmdtype = CMDFUNCTION;
8619         entry.u.func = copyfunc(func);
8620         addcmdentry(func->narg.text, &entry);
8621         INT_ON;
8622 }
8623
8624 /* Reasons for skipping commands (see comment on breakcmd routine) */
8625 #define SKIPBREAK      (1 << 0)
8626 #define SKIPCONT       (1 << 1)
8627 #define SKIPFUNC       (1 << 2)
8628 static smallint evalskip;       /* set to SKIPxxx if we are skipping commands */
8629 static int skipcount;           /* number of levels to skip */
8630 static int funcnest;            /* depth of function calls */
8631 static int loopnest;            /* current loop nesting level */
8632
8633 /* Forward decl way out to parsing code - dotrap needs it */
8634 static int evalstring(char *s, int flags);
8635
8636 /* Called to execute a trap.
8637  * Single callsite - at the end of evaltree().
8638  * If we return non-zero, evaltree raises EXEXIT exception.
8639  *
8640  * Perhaps we should avoid entering new trap handlers
8641  * while we are executing a trap handler. [is it a TODO?]
8642  */
8643 static void
8644 dotrap(void)
8645 {
8646         uint8_t *g;
8647         int sig;
8648         uint8_t last_status;
8649
8650         if (!pending_sig)
8651                 return;
8652
8653         last_status = exitstatus;
8654         pending_sig = 0;
8655         barrier();
8656
8657         TRACE(("dotrap entered\n"));
8658         for (sig = 1, g = gotsig; sig < NSIG; sig++, g++) {
8659                 char *p;
8660
8661                 if (!*g)
8662                         continue;
8663
8664                 if (evalskip) {
8665                         pending_sig = sig;
8666                         break;
8667                 }
8668
8669                 p = trap[sig];
8670                 /* non-trapped SIGINT is handled separately by raise_interrupt,
8671                  * don't upset it by resetting gotsig[SIGINT-1] */
8672                 if (sig == SIGINT && !p)
8673                         continue;
8674
8675                 TRACE(("sig %d is active, will run handler '%s'\n", sig, p));
8676                 *g = 0;
8677                 if (!p)
8678                         continue;
8679                 evalstring(p, 0);
8680         }
8681         exitstatus = last_status;
8682         TRACE(("dotrap returns\n"));
8683 }
8684
8685 /* forward declarations - evaluation is fairly recursive business... */
8686 static int evalloop(union node *, int);
8687 static int evalfor(union node *, int);
8688 static int evalcase(union node *, int);
8689 static int evalsubshell(union node *, int);
8690 static void expredir(union node *);
8691 static int evalpipe(union node *, int);
8692 static int evalcommand(union node *, int);
8693 static int evalbltin(const struct builtincmd *, int, char **, int);
8694 static void prehash(union node *);
8695
8696 /*
8697  * Evaluate a parse tree.  The value is left in the global variable
8698  * exitstatus.
8699  */
8700 static int
8701 evaltree(union node *n, int flags)
8702 {
8703         int checkexit = 0;
8704         int (*evalfn)(union node *, int);
8705         int status = 0;
8706
8707         if (n == NULL) {
8708                 TRACE(("evaltree(NULL) called\n"));
8709                 goto out;
8710         }
8711         TRACE(("evaltree(%p: %d, %d) called\n", n, n->type, flags));
8712
8713         dotrap();
8714
8715         switch (n->type) {
8716         default:
8717 #if DEBUG
8718                 out1fmt("Node type = %d\n", n->type);
8719                 fflush_all();
8720                 break;
8721 #endif
8722         case NNOT:
8723                 status = !evaltree(n->nnot.com, EV_TESTED);
8724                 goto setstatus;
8725         case NREDIR:
8726                 expredir(n->nredir.redirect);
8727                 status = redirectsafe(n->nredir.redirect, REDIR_PUSH);
8728                 if (!status) {
8729                         status = evaltree(n->nredir.n, flags & EV_TESTED);
8730                 }
8731                 if (n->nredir.redirect)
8732                         popredir(/*drop:*/ 0, /*restore:*/ 0 /* not sure */);
8733                 goto setstatus;
8734         case NCMD:
8735                 evalfn = evalcommand;
8736  checkexit:
8737                 if (eflag && !(flags & EV_TESTED))
8738                         checkexit = ~0;
8739                 goto calleval;
8740         case NFOR:
8741                 evalfn = evalfor;
8742                 goto calleval;
8743         case NWHILE:
8744         case NUNTIL:
8745                 evalfn = evalloop;
8746                 goto calleval;
8747         case NSUBSHELL:
8748         case NBACKGND:
8749                 evalfn = evalsubshell;
8750                 goto checkexit;
8751         case NPIPE:
8752                 evalfn = evalpipe;
8753                 goto checkexit;
8754         case NCASE:
8755                 evalfn = evalcase;
8756                 goto calleval;
8757         case NAND:
8758         case NOR:
8759         case NSEMI: {
8760
8761 #if NAND + 1 != NOR
8762 #error NAND + 1 != NOR
8763 #endif
8764 #if NOR + 1 != NSEMI
8765 #error NOR + 1 != NSEMI
8766 #endif
8767                 unsigned is_or = n->type - NAND;
8768                 status = evaltree(
8769                         n->nbinary.ch1,
8770                         (flags | ((is_or >> 1) - 1)) & EV_TESTED
8771                 );
8772                 if ((!status) == is_or || evalskip)
8773                         break;
8774                 n = n->nbinary.ch2;
8775  evaln:
8776                 evalfn = evaltree;
8777  calleval:
8778                 status = evalfn(n, flags);
8779                 goto setstatus;
8780         }
8781         case NIF:
8782                 status = evaltree(n->nif.test, EV_TESTED);
8783                 if (evalskip)
8784                         break;
8785                 if (!status) {
8786                         n = n->nif.ifpart;
8787                         goto evaln;
8788                 }
8789                 if (n->nif.elsepart) {
8790                         n = n->nif.elsepart;
8791                         goto evaln;
8792                 }
8793                 status = 0;
8794                 goto setstatus;
8795         case NDEFUN:
8796                 defun(n);
8797                 /* Not necessary. To test it:
8798                  * "false; f() { qwerty; }; echo $?" should print 0.
8799                  */
8800                 /* status = 0; */
8801  setstatus:
8802                 exitstatus = status;
8803                 break;
8804         }
8805  out:
8806         /* Order of checks below is important:
8807          * signal handlers trigger before exit caused by "set -e".
8808          */
8809         dotrap();
8810
8811         if (checkexit & status)
8812                 raise_exception(EXEXIT);
8813         if (flags & EV_EXIT)
8814                 raise_exception(EXEXIT);
8815
8816         TRACE(("leaving evaltree (no interrupts)\n"));
8817         return exitstatus;
8818 }
8819
8820 #if !defined(__alpha__) || (defined(__GNUC__) && __GNUC__ >= 3)
8821 static
8822 #endif
8823 int evaltreenr(union node *, int) __attribute__ ((alias("evaltree"),__noreturn__));
8824
8825 static int
8826 skiploop(void)
8827 {
8828         int skip = evalskip;
8829
8830         switch (skip) {
8831         case 0:
8832                 break;
8833         case SKIPBREAK:
8834         case SKIPCONT:
8835                 if (--skipcount <= 0) {
8836                         evalskip = 0;
8837                         break;
8838                 }
8839                 skip = SKIPBREAK;
8840                 break;
8841         }
8842         return skip;
8843 }
8844
8845 static int
8846 evalloop(union node *n, int flags)
8847 {
8848         int skip;
8849         int status;
8850
8851         loopnest++;
8852         status = 0;
8853         flags &= EV_TESTED;
8854         do {
8855                 int i;
8856
8857                 i = evaltree(n->nbinary.ch1, EV_TESTED);
8858                 skip = skiploop();
8859                 if (skip == SKIPFUNC)
8860                         status = i;
8861                 if (skip)
8862                         continue;
8863                 if (n->type != NWHILE)
8864                         i = !i;
8865                 if (i != 0)
8866                         break;
8867                 status = evaltree(n->nbinary.ch2, flags);
8868                 skip = skiploop();
8869         } while (!(skip & ~SKIPCONT));
8870         loopnest--;
8871
8872         return status;
8873 }
8874
8875 static int
8876 evalfor(union node *n, int flags)
8877 {
8878         struct arglist arglist;
8879         union node *argp;
8880         struct strlist *sp;
8881         struct stackmark smark;
8882         int status = 0;
8883
8884         setstackmark(&smark);
8885         arglist.list = NULL;
8886         arglist.lastp = &arglist.list;
8887         for (argp = n->nfor.args; argp; argp = argp->narg.next) {
8888                 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
8889         }
8890         *arglist.lastp = NULL;
8891
8892         loopnest++;
8893         flags &= EV_TESTED;
8894         for (sp = arglist.list; sp; sp = sp->next) {
8895                 setvar0(n->nfor.var, sp->text);
8896                 status = evaltree(n->nfor.body, flags);
8897                 if (skiploop() & ~SKIPCONT)
8898                         break;
8899         }
8900         loopnest--;
8901         popstackmark(&smark);
8902
8903         return status;
8904 }
8905
8906 static int
8907 evalcase(union node *n, int flags)
8908 {
8909         union node *cp;
8910         union node *patp;
8911         struct arglist arglist;
8912         struct stackmark smark;
8913         int status = 0;
8914
8915         setstackmark(&smark);
8916         arglist.list = NULL;
8917         arglist.lastp = &arglist.list;
8918         expandarg(n->ncase.expr, &arglist, EXP_TILDE);
8919         for (cp = n->ncase.cases; cp && evalskip == 0; cp = cp->nclist.next) {
8920                 for (patp = cp->nclist.pattern; patp; patp = patp->narg.next) {
8921                         if (casematch(patp, arglist.list->text)) {
8922                                 /* Ensure body is non-empty as otherwise
8923                                  * EV_EXIT may prevent us from setting the
8924                                  * exit status.
8925                                  */
8926                                 if (evalskip == 0 && cp->nclist.body) {
8927                                         status = evaltree(cp->nclist.body, flags);
8928                                 }
8929                                 goto out;
8930                         }
8931                 }
8932         }
8933  out:
8934         popstackmark(&smark);
8935
8936         return status;
8937 }
8938
8939 /*
8940  * Kick off a subshell to evaluate a tree.
8941  */
8942 static int
8943 evalsubshell(union node *n, int flags)
8944 {
8945         struct job *jp;
8946         int backgnd = (n->type == NBACKGND); /* FORK_BG(1) if yes, else FORK_FG(0) */
8947         int status;
8948
8949         expredir(n->nredir.redirect);
8950         if (!backgnd && (flags & EV_EXIT) && !may_have_traps)
8951                 goto nofork;
8952         INT_OFF;
8953         if (backgnd == FORK_FG)
8954                 get_tty_state();
8955         jp = makejob(/*n,*/ 1);
8956         if (forkshell(jp, n, backgnd) == 0) {
8957                 /* child */
8958                 INT_ON;
8959                 flags |= EV_EXIT;
8960                 if (backgnd)
8961                         flags &= ~EV_TESTED;
8962  nofork:
8963                 redirect(n->nredir.redirect, 0);
8964                 evaltreenr(n->nredir.n, flags);
8965                 /* never returns */
8966         }
8967         /* parent */
8968         status = 0;
8969         if (backgnd == FORK_FG)
8970                 status = waitforjob(jp);
8971         INT_ON;
8972         return status;
8973 }
8974
8975 /*
8976  * Compute the names of the files in a redirection list.
8977  */
8978 static void fixredir(union node *, const char *, int);
8979 static void
8980 expredir(union node *n)
8981 {
8982         union node *redir;
8983
8984         for (redir = n; redir; redir = redir->nfile.next) {
8985                 struct arglist fn;
8986
8987                 fn.list = NULL;
8988                 fn.lastp = &fn.list;
8989                 switch (redir->type) {
8990                 case NFROMTO:
8991                 case NFROM:
8992                 case NTO:
8993 #if BASH_REDIR_OUTPUT
8994                 case NTO2:
8995 #endif
8996                 case NCLOBBER:
8997                 case NAPPEND:
8998                         expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR);
8999                         TRACE(("expredir expanded to '%s'\n", fn.list->text));
9000 #if BASH_REDIR_OUTPUT
9001  store_expfname:
9002 #endif
9003 #if 0
9004 // By the design of stack allocator, the loop of this kind:
9005 //      while true; do while true; do break; done </dev/null; done
9006 // will look like a memory leak: ash plans to free expfname's
9007 // of "/dev/null" as soon as it finishes running the loop
9008 // (in this case, never).
9009 // This "fix" is wrong:
9010                         if (redir->nfile.expfname)
9011                                 stunalloc(redir->nfile.expfname);
9012 // It results in corrupted state of stacked allocations.
9013 #endif
9014                         redir->nfile.expfname = fn.list->text;
9015                         break;
9016                 case NFROMFD:
9017                 case NTOFD: /* >& */
9018                         if (redir->ndup.vname) {
9019                                 expandarg(redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE);
9020                                 if (fn.list == NULL)
9021                                         ash_msg_and_raise_error("redir error");
9022 #if BASH_REDIR_OUTPUT
9023 //FIXME: we used expandarg with different args!
9024                                 if (!isdigit_str9(fn.list->text)) {
9025                                         /* >&file, not >&fd */
9026                                         if (redir->nfile.fd != 1) /* 123>&file - BAD */
9027                                                 ash_msg_and_raise_error("redir error");
9028                                         redir->type = NTO2;
9029                                         goto store_expfname;
9030                                 }
9031 #endif
9032                                 fixredir(redir, fn.list->text, 1);
9033                         }
9034                         break;
9035                 }
9036         }
9037 }
9038
9039 /*
9040  * Evaluate a pipeline.  All the processes in the pipeline are children
9041  * of the process creating the pipeline.  (This differs from some versions
9042  * of the shell, which make the last process in a pipeline the parent
9043  * of all the rest.)
9044  */
9045 static int
9046 evalpipe(union node *n, int flags)
9047 {
9048         struct job *jp;
9049         struct nodelist *lp;
9050         int pipelen;
9051         int prevfd;
9052         int pip[2];
9053         int status = 0;
9054
9055         TRACE(("evalpipe(0x%lx) called\n", (long)n));
9056         pipelen = 0;
9057         for (lp = n->npipe.cmdlist; lp; lp = lp->next)
9058                 pipelen++;
9059         flags |= EV_EXIT;
9060         INT_OFF;
9061         if (n->npipe.pipe_backgnd == 0)
9062                 get_tty_state();
9063         jp = makejob(/*n,*/ pipelen);
9064         prevfd = -1;
9065         for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
9066                 prehash(lp->n);
9067                 pip[1] = -1;
9068                 if (lp->next) {
9069                         if (pipe(pip) < 0) {
9070                                 close(prevfd);
9071                                 ash_msg_and_raise_error("pipe call failed");
9072                         }
9073                 }
9074                 if (forkshell(jp, lp->n, n->npipe.pipe_backgnd) == 0) {
9075                         /* child */
9076                         INT_ON;
9077                         if (pip[1] >= 0) {
9078                                 close(pip[0]);
9079                         }
9080                         if (prevfd > 0) {
9081                                 dup2(prevfd, 0);
9082                                 close(prevfd);
9083                         }
9084                         if (pip[1] > 1) {
9085                                 dup2(pip[1], 1);
9086                                 close(pip[1]);
9087                         }
9088                         evaltreenr(lp->n, flags);
9089                         /* never returns */
9090                 }
9091                 /* parent */
9092                 if (prevfd >= 0)
9093                         close(prevfd);
9094                 prevfd = pip[0];
9095                 /* Don't want to trigger debugging */
9096                 if (pip[1] != -1)
9097                         close(pip[1]);
9098         }
9099         if (n->npipe.pipe_backgnd == 0) {
9100                 status = waitforjob(jp);
9101                 TRACE(("evalpipe:  job done exit status %d\n", status));
9102         }
9103         INT_ON;
9104
9105         return status;
9106 }
9107
9108 /*
9109  * Controls whether the shell is interactive or not.
9110  */
9111 static void
9112 setinteractive(int on)
9113 {
9114         static smallint is_interactive;
9115
9116         if (++on == is_interactive)
9117                 return;
9118         is_interactive = on;
9119         setsignal(SIGINT);
9120         setsignal(SIGQUIT);
9121         setsignal(SIGTERM);
9122 #if !ENABLE_FEATURE_SH_EXTRA_QUIET
9123         if (is_interactive > 1) {
9124                 /* Looks like they want an interactive shell */
9125                 static smallint did_banner;
9126
9127                 if (!did_banner) {
9128                         /* note: ash and hush share this string */
9129                         out1fmt("\n\n%s %s\n"
9130                                 IF_ASH_HELP("Enter 'help' for a list of built-in commands.\n")
9131                                 "\n",
9132                                 bb_banner,
9133                                 "built-in shell (ash)"
9134                         );
9135                         did_banner = 1;
9136                 }
9137         }
9138 #endif
9139 }
9140
9141 static void
9142 optschanged(void)
9143 {
9144 #if DEBUG
9145         opentrace();
9146 #endif
9147         setinteractive(iflag);
9148         setjobctl(mflag);
9149 #if ENABLE_FEATURE_EDITING_VI
9150         if (viflag)
9151                 line_input_state->flags |= VI_MODE;
9152         else
9153                 line_input_state->flags &= ~VI_MODE;
9154 #else
9155         viflag = 0; /* forcibly keep the option off */
9156 #endif
9157 }
9158
9159 static struct localvar *localvars;
9160
9161 /*
9162  * Called after a function returns.
9163  * Interrupts must be off.
9164  */
9165 static void
9166 poplocalvars(void)
9167 {
9168         struct localvar *lvp;
9169         struct var *vp;
9170
9171         while ((lvp = localvars) != NULL) {
9172                 localvars = lvp->next;
9173                 vp = lvp->vp;
9174                 TRACE(("poplocalvar %s\n", vp ? vp->var_text : "-"));
9175                 if (vp == NULL) {       /* $- saved */
9176                         memcpy(optlist, lvp->text, sizeof(optlist));
9177                         free((char*)lvp->text);
9178                         optschanged();
9179                 } else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) {
9180                         unsetvar(vp->var_text);
9181                 } else {
9182                         if (vp->var_func)
9183                                 vp->var_func(var_end(lvp->text));
9184                         if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
9185                                 free((char*)vp->var_text);
9186                         vp->flags = lvp->flags;
9187                         vp->var_text = lvp->text;
9188                 }
9189                 free(lvp);
9190         }
9191 }
9192
9193 static int
9194 evalfun(struct funcnode *func, int argc, char **argv, int flags)
9195 {
9196         volatile struct shparam saveparam;
9197         struct localvar *volatile savelocalvars;
9198         struct jmploc *volatile savehandler;
9199         struct jmploc jmploc;
9200         int e;
9201
9202         saveparam = shellparam;
9203         savelocalvars = localvars;
9204         savehandler = exception_handler;
9205         e = setjmp(jmploc.loc);
9206         if (e) {
9207                 goto funcdone;
9208         }
9209         INT_OFF;
9210         exception_handler = &jmploc;
9211         localvars = NULL;
9212         shellparam.malloced = 0;
9213         func->count++;
9214         funcnest++;
9215         INT_ON;
9216         shellparam.nparam = argc - 1;
9217         shellparam.p = argv + 1;
9218 #if ENABLE_ASH_GETOPTS
9219         shellparam.optind = 1;
9220         shellparam.optoff = -1;
9221 #endif
9222         evaltree(func->n.narg.next, flags & EV_TESTED);
9223  funcdone:
9224         INT_OFF;
9225         funcnest--;
9226         freefunc(func);
9227         poplocalvars();
9228         localvars = savelocalvars;
9229         freeparam(&shellparam);
9230         shellparam = saveparam;
9231         exception_handler = savehandler;
9232         INT_ON;
9233         evalskip &= ~SKIPFUNC;
9234         return e;
9235 }
9236
9237 /*
9238  * Make a variable a local variable.  When a variable is made local, it's
9239  * value and flags are saved in a localvar structure.  The saved values
9240  * will be restored when the shell function returns.  We handle the name
9241  * "-" as a special case: it makes changes to "set +-options" local
9242  * (options will be restored on return from the function).
9243  */
9244 static void
9245 mklocal(char *name)
9246 {
9247         struct localvar *lvp;
9248         struct var **vpp;
9249         struct var *vp;
9250         char *eq = strchr(name, '=');
9251
9252         INT_OFF;
9253         /* Cater for duplicate "local". Examples:
9254          * x=0; f() { local x=1; echo $x; local x; echo $x; }; f; echo $x
9255          * x=0; f() { local x=1; echo $x; local x=2; echo $x; }; f; echo $x
9256          */
9257         lvp = localvars;
9258         while (lvp) {
9259                 if (lvp->vp && varcmp(lvp->vp->var_text, name) == 0) {
9260                         if (eq)
9261                                 setvareq(name, 0);
9262                         /* else:
9263                          * it's a duplicate "local VAR" declaration, do nothing
9264                          */
9265                         goto ret;
9266                 }
9267                 lvp = lvp->next;
9268         }
9269
9270         lvp = ckzalloc(sizeof(*lvp));
9271         if (LONE_DASH(name)) {
9272                 char *p;
9273                 p = ckmalloc(sizeof(optlist));
9274                 lvp->text = memcpy(p, optlist, sizeof(optlist));
9275                 vp = NULL;
9276         } else {
9277                 vpp = hashvar(name);
9278                 vp = *findvar(vpp, name);
9279                 if (vp == NULL) {
9280                         /* variable did not exist yet */
9281                         if (eq)
9282                                 setvareq(name, VSTRFIXED);
9283                         else
9284                                 setvar(name, NULL, VSTRFIXED);
9285                         vp = *vpp;      /* the new variable */
9286                         lvp->flags = VUNSET;
9287                 } else {
9288                         lvp->text = vp->var_text;
9289                         lvp->flags = vp->flags;
9290                         /* make sure neither "struct var" nor string gets freed
9291                          * during (un)setting:
9292                          */
9293                         vp->flags |= VSTRFIXED|VTEXTFIXED;
9294                         if (eq)
9295                                 setvareq(name, 0);
9296                         else
9297                                 /* "local VAR" unsets VAR: */
9298                                 setvar0(name, NULL);
9299                 }
9300         }
9301         lvp->vp = vp;
9302         lvp->next = localvars;
9303         localvars = lvp;
9304  ret:
9305         INT_ON;
9306 }
9307
9308 /*
9309  * The "local" command.
9310  */
9311 static int FAST_FUNC
9312 localcmd(int argc UNUSED_PARAM, char **argv)
9313 {
9314         char *name;
9315
9316         if (!funcnest)
9317                 ash_msg_and_raise_error("not in a function");
9318
9319         argv = argptr;
9320         while ((name = *argv++) != NULL) {
9321                 mklocal(name);
9322         }
9323         return 0;
9324 }
9325
9326 static int FAST_FUNC
9327 falsecmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
9328 {
9329         return 1;
9330 }
9331
9332 static int FAST_FUNC
9333 truecmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
9334 {
9335         return 0;
9336 }
9337
9338 static int FAST_FUNC
9339 execcmd(int argc UNUSED_PARAM, char **argv)
9340 {
9341         optionarg = NULL;
9342         while (nextopt("a:") != '\0')
9343                 /* nextopt() sets optionarg to "-a ARGV0" */;
9344
9345         argv = argptr;
9346         if (argv[0]) {
9347                 char *prog;
9348
9349                 iflag = 0;              /* exit on error */
9350                 mflag = 0;
9351                 optschanged();
9352                 /* We should set up signals for "exec CMD"
9353                  * the same way as for "CMD" without "exec".
9354                  * But optschanged->setinteractive->setsignal
9355                  * still thought we are a root shell. Therefore, for example,
9356                  * SIGQUIT is still set to IGN. Fix it:
9357                  */
9358                 shlvl++;
9359                 setsignal(SIGQUIT);
9360                 /*setsignal(SIGTERM); - unnecessary because of iflag=0 */
9361                 /*setsignal(SIGTSTP); - unnecessary because of mflag=0 */
9362                 /*setsignal(SIGTTOU); - unnecessary because of mflag=0 */
9363
9364                 prog = argv[0];
9365                 if (optionarg)
9366                         argv[0] = optionarg;
9367                 shellexec(prog, argv, pathval(), 0);
9368                 /* NOTREACHED */
9369         }
9370         return 0;
9371 }
9372
9373 /*
9374  * The return command.
9375  */
9376 static int FAST_FUNC
9377 returncmd(int argc UNUSED_PARAM, char **argv)
9378 {
9379         /*
9380          * If called outside a function, do what ksh does;
9381          * skip the rest of the file.
9382          */
9383         evalskip = SKIPFUNC;
9384         return argv[1] ? number(argv[1]) : exitstatus;
9385 }
9386
9387 /* Forward declarations for builtintab[] */
9388 static int breakcmd(int, char **) FAST_FUNC;
9389 static int dotcmd(int, char **) FAST_FUNC;
9390 static int evalcmd(int, char **, int) FAST_FUNC;
9391 static int exitcmd(int, char **) FAST_FUNC;
9392 static int exportcmd(int, char **) FAST_FUNC;
9393 #if ENABLE_ASH_GETOPTS
9394 static int getoptscmd(int, char **) FAST_FUNC;
9395 #endif
9396 #if ENABLE_ASH_HELP
9397 static int helpcmd(int, char **) FAST_FUNC;
9398 #endif
9399 #if MAX_HISTORY
9400 static int historycmd(int, char **) FAST_FUNC;
9401 #endif
9402 #if ENABLE_FEATURE_SH_MATH
9403 static int letcmd(int, char **) FAST_FUNC;
9404 #endif
9405 static int readcmd(int, char **) FAST_FUNC;
9406 static int setcmd(int, char **) FAST_FUNC;
9407 static int shiftcmd(int, char **) FAST_FUNC;
9408 static int timescmd(int, char **) FAST_FUNC;
9409 static int trapcmd(int, char **) FAST_FUNC;
9410 static int umaskcmd(int, char **) FAST_FUNC;
9411 static int unsetcmd(int, char **) FAST_FUNC;
9412 static int ulimitcmd(int, char **) FAST_FUNC;
9413
9414 #define BUILTIN_NOSPEC          "0"
9415 #define BUILTIN_SPECIAL         "1"
9416 #define BUILTIN_REGULAR         "2"
9417 #define BUILTIN_SPEC_REG        "3"
9418 #define BUILTIN_ASSIGN          "4"
9419 #define BUILTIN_SPEC_ASSG       "5"
9420 #define BUILTIN_REG_ASSG        "6"
9421 #define BUILTIN_SPEC_REG_ASSG   "7"
9422
9423 /* Stubs for calling non-FAST_FUNC's */
9424 #if ENABLE_ASH_ECHO
9425 static int FAST_FUNC echocmd(int argc, char **argv)   { return echo_main(argc, argv); }
9426 #endif
9427 #if ENABLE_ASH_PRINTF
9428 static int FAST_FUNC printfcmd(int argc, char **argv) { return printf_main(argc, argv); }
9429 #endif
9430 #if ENABLE_ASH_TEST || BASH_TEST2
9431 static int FAST_FUNC testcmd(int argc, char **argv)   { return test_main(argc, argv); }
9432 #endif
9433
9434 /* Keep these in proper order since it is searched via bsearch() */
9435 static const struct builtincmd builtintab[] = {
9436         { BUILTIN_SPEC_REG      "."       , dotcmd     },
9437         { BUILTIN_SPEC_REG      ":"       , truecmd    },
9438 #if ENABLE_ASH_TEST
9439         { BUILTIN_REGULAR       "["       , testcmd    },
9440 #endif
9441 #if BASH_TEST2
9442         { BUILTIN_REGULAR       "[["      , testcmd    },
9443 #endif
9444 #if ENABLE_ASH_ALIAS
9445         { BUILTIN_REG_ASSG      "alias"   , aliascmd   },
9446 #endif
9447 #if JOBS
9448         { BUILTIN_REGULAR       "bg"      , fg_bgcmd   },
9449 #endif
9450         { BUILTIN_SPEC_REG      "break"   , breakcmd   },
9451         { BUILTIN_REGULAR       "cd"      , cdcmd      },
9452         { BUILTIN_NOSPEC        "chdir"   , cdcmd      },
9453 #if ENABLE_ASH_CMDCMD
9454         { BUILTIN_REGULAR       "command" , commandcmd },
9455 #endif
9456         { BUILTIN_SPEC_REG      "continue", breakcmd   },
9457 #if ENABLE_ASH_ECHO
9458         { BUILTIN_REGULAR       "echo"    , echocmd    },
9459 #endif
9460         { BUILTIN_SPEC_REG      "eval"    , NULL       }, /*evalcmd() has a differing prototype*/
9461         { BUILTIN_SPEC_REG      "exec"    , execcmd    },
9462         { BUILTIN_SPEC_REG      "exit"    , exitcmd    },
9463         { BUILTIN_SPEC_REG_ASSG "export"  , exportcmd  },
9464         { BUILTIN_REGULAR       "false"   , falsecmd   },
9465 #if JOBS
9466         { BUILTIN_REGULAR       "fg"      , fg_bgcmd   },
9467 #endif
9468 #if ENABLE_ASH_GETOPTS
9469         { BUILTIN_REGULAR       "getopts" , getoptscmd },
9470 #endif
9471         { BUILTIN_NOSPEC        "hash"    , hashcmd    },
9472 #if ENABLE_ASH_HELP
9473         { BUILTIN_NOSPEC        "help"    , helpcmd    },
9474 #endif
9475 #if MAX_HISTORY
9476         { BUILTIN_NOSPEC        "history" , historycmd },
9477 #endif
9478 #if JOBS
9479         { BUILTIN_REGULAR       "jobs"    , jobscmd    },
9480         { BUILTIN_REGULAR       "kill"    , killcmd    },
9481 #endif
9482 #if ENABLE_FEATURE_SH_MATH
9483         { BUILTIN_NOSPEC        "let"     , letcmd     },
9484 #endif
9485         { BUILTIN_ASSIGN        "local"   , localcmd   },
9486 #if ENABLE_ASH_PRINTF
9487         { BUILTIN_REGULAR       "printf"  , printfcmd  },
9488 #endif
9489         { BUILTIN_NOSPEC        "pwd"     , pwdcmd     },
9490         { BUILTIN_REGULAR       "read"    , readcmd    },
9491         { BUILTIN_SPEC_REG_ASSG "readonly", exportcmd  },
9492         { BUILTIN_SPEC_REG      "return"  , returncmd  },
9493         { BUILTIN_SPEC_REG      "set"     , setcmd     },
9494         { BUILTIN_SPEC_REG      "shift"   , shiftcmd   },
9495 #if BASH_SOURCE
9496         { BUILTIN_SPEC_REG      "source"  , dotcmd     },
9497 #endif
9498 #if ENABLE_ASH_TEST
9499         { BUILTIN_REGULAR       "test"    , testcmd    },
9500 #endif
9501         { BUILTIN_SPEC_REG      "times"   , timescmd   },
9502         { BUILTIN_SPEC_REG      "trap"    , trapcmd    },
9503         { BUILTIN_REGULAR       "true"    , truecmd    },
9504         { BUILTIN_NOSPEC        "type"    , typecmd    },
9505         { BUILTIN_NOSPEC        "ulimit"  , ulimitcmd  },
9506         { BUILTIN_REGULAR       "umask"   , umaskcmd   },
9507 #if ENABLE_ASH_ALIAS
9508         { BUILTIN_REGULAR       "unalias" , unaliascmd },
9509 #endif
9510         { BUILTIN_SPEC_REG      "unset"   , unsetcmd   },
9511         { BUILTIN_REGULAR       "wait"    , waitcmd    },
9512 };
9513
9514 /* Should match the above table! */
9515 #define COMMANDCMD (builtintab + \
9516         /* . : */       2 + \
9517         /* [ */         1 * ENABLE_ASH_TEST + \
9518         /* [[ */        1 * BASH_TEST2 + \
9519         /* alias */     1 * ENABLE_ASH_ALIAS + \
9520         /* bg */        1 * ENABLE_ASH_JOB_CONTROL + \
9521         /* break cd cddir  */   3)
9522 #define EVALCMD (COMMANDCMD + \
9523         /* command */   1 * ENABLE_ASH_CMDCMD + \
9524         /* continue */  1 + \
9525         /* echo */      1 * ENABLE_ASH_ECHO + \
9526         0)
9527 #define EXECCMD (EVALCMD + \
9528         /* eval */      1)
9529
9530 /*
9531  * Search the table of builtin commands.
9532  */
9533 static int
9534 pstrcmp1(const void *a, const void *b)
9535 {
9536         return strcmp((char*)a, *(char**)b + 1);
9537 }
9538 static struct builtincmd *
9539 find_builtin(const char *name)
9540 {
9541         struct builtincmd *bp;
9542
9543         bp = bsearch(
9544                 name, builtintab, ARRAY_SIZE(builtintab), sizeof(builtintab[0]),
9545                 pstrcmp1
9546         );
9547         return bp;
9548 }
9549
9550 /*
9551  * Execute a simple command.
9552  */
9553 static int
9554 isassignment(const char *p)
9555 {
9556         const char *q = endofname(p);
9557         if (p == q)
9558                 return 0;
9559         return *q == '=';
9560 }
9561 static int FAST_FUNC
9562 bltincmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
9563 {
9564         /* Preserve exitstatus of a previous possible redirection
9565          * as POSIX mandates */
9566         return back_exitstatus;
9567 }
9568 static int
9569 evalcommand(union node *cmd, int flags)
9570 {
9571         static const struct builtincmd null_bltin = {
9572                 "\0\0", bltincmd /* why three NULs? */
9573         };
9574         struct stackmark smark;
9575         union node *argp;
9576         struct arglist arglist;
9577         struct arglist varlist;
9578         char **argv;
9579         int argc;
9580         const struct strlist *sp;
9581         struct cmdentry cmdentry;
9582         struct job *jp;
9583         char *lastarg;
9584         const char *path;
9585         int spclbltin;
9586         int status;
9587         char **nargv;
9588         struct builtincmd *bcmd;
9589         smallint cmd_is_exec;
9590         smallint pseudovarflag = 0;
9591
9592         /* First expand the arguments. */
9593         TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags));
9594         setstackmark(&smark);
9595         back_exitstatus = 0;
9596
9597         cmdentry.cmdtype = CMDBUILTIN;
9598         cmdentry.u.cmd = &null_bltin;
9599         varlist.lastp = &varlist.list;
9600         *varlist.lastp = NULL;
9601         arglist.lastp = &arglist.list;
9602         *arglist.lastp = NULL;
9603
9604         argc = 0;
9605         if (cmd->ncmd.args) {
9606                 bcmd = find_builtin(cmd->ncmd.args->narg.text);
9607                 pseudovarflag = bcmd && IS_BUILTIN_ASSIGN(bcmd);
9608         }
9609
9610         for (argp = cmd->ncmd.args; argp; argp = argp->narg.next) {
9611                 struct strlist **spp;
9612
9613                 spp = arglist.lastp;
9614                 if (pseudovarflag && isassignment(argp->narg.text))
9615                         expandarg(argp, &arglist, EXP_VARTILDE);
9616                 else
9617                         expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
9618
9619                 for (sp = *spp; sp; sp = sp->next)
9620                         argc++;
9621         }
9622
9623         /* Reserve one extra spot at the front for shellexec. */
9624         nargv = stalloc(sizeof(char *) * (argc + 2));
9625         argv = ++nargv;
9626         for (sp = arglist.list; sp; sp = sp->next) {
9627                 TRACE(("evalcommand arg: %s\n", sp->text));
9628                 *nargv++ = sp->text;
9629         }
9630         *nargv = NULL;
9631
9632         lastarg = NULL;
9633         if (iflag && funcnest == 0 && argc > 0)
9634                 lastarg = nargv[-1];
9635
9636         preverrout_fd = 2;
9637         expredir(cmd->ncmd.redirect);
9638         status = redirectsafe(cmd->ncmd.redirect, REDIR_PUSH | REDIR_SAVEFD2);
9639
9640         path = vpath.var_text;
9641         for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) {
9642                 struct strlist **spp;
9643                 char *p;
9644
9645                 spp = varlist.lastp;
9646                 expandarg(argp, &varlist, EXP_VARTILDE);
9647
9648                 /*
9649                  * Modify the command lookup path, if a PATH= assignment
9650                  * is present
9651                  */
9652                 p = (*spp)->text;
9653                 if (varcmp(p, path) == 0)
9654                         path = p;
9655         }
9656
9657         /* Print the command if xflag is set. */
9658         if (xflag) {
9659                 int n;
9660                 const char *p = " %s" + 1;
9661
9662                 fdprintf(preverrout_fd, p, expandstr(ps4val()));
9663                 sp = varlist.list;
9664                 for (n = 0; n < 2; n++) {
9665                         while (sp) {
9666                                 fdprintf(preverrout_fd, p, sp->text);
9667                                 sp = sp->next;
9668                                 p = " %s";
9669                         }
9670                         sp = arglist.list;
9671                 }
9672                 safe_write(preverrout_fd, "\n", 1);
9673         }
9674
9675         cmd_is_exec = 0;
9676         spclbltin = -1;
9677
9678         /* Now locate the command. */
9679         if (argc) {
9680                 int cmd_flag = DO_ERR;
9681 #if ENABLE_ASH_CMDCMD
9682                 const char *oldpath = path + 5;
9683 #endif
9684                 path += 5;
9685                 for (;;) {
9686                         find_command(argv[0], &cmdentry, cmd_flag, path);
9687                         if (cmdentry.cmdtype == CMDUNKNOWN) {
9688                                 flush_stdout_stderr();
9689                                 status = 127;
9690                                 goto bail;
9691                         }
9692
9693                         /* implement bltin and command here */
9694                         if (cmdentry.cmdtype != CMDBUILTIN)
9695                                 break;
9696                         if (spclbltin < 0)
9697                                 spclbltin = IS_BUILTIN_SPECIAL(cmdentry.u.cmd);
9698                         if (cmdentry.u.cmd == EXECCMD)
9699                                 cmd_is_exec = 1;
9700 #if ENABLE_ASH_CMDCMD
9701                         if (cmdentry.u.cmd == COMMANDCMD) {
9702                                 path = oldpath;
9703                                 nargv = parse_command_args(argv, &path);
9704                                 if (!nargv)
9705                                         break;
9706                                 /* It's "command [-p] PROG ARGS" (that is, no -Vv).
9707                                  * nargv => "PROG". path is updated if -p.
9708                                  */
9709                                 argc -= nargv - argv;
9710                                 argv = nargv;
9711                                 cmd_flag |= DO_NOFUNC;
9712                         } else
9713 #endif
9714                                 break;
9715                 }
9716         }
9717
9718         if (status) {
9719  bail:
9720                 exitstatus = status;
9721
9722                 /* We have a redirection error. */
9723                 if (spclbltin > 0)
9724                         raise_exception(EXERROR);
9725
9726                 goto out;
9727         }
9728
9729         /* Execute the command. */
9730         switch (cmdentry.cmdtype) {
9731         default: {
9732
9733 #if ENABLE_FEATURE_SH_NOFORK
9734 /* (1) BUG: if variables are set, we need to fork, or save/restore them
9735  *     around run_nofork_applet() call.
9736  * (2) Should this check also be done in forkshell()?
9737  *     (perhaps it should, so that "VAR=VAL nofork" at least avoids exec...)
9738  */
9739                 /* find_command() encodes applet_no as (-2 - applet_no) */
9740                 int applet_no = (- cmdentry.u.index - 2);
9741                 if (applet_no >= 0 && APPLET_IS_NOFORK(applet_no)) {
9742                         listsetvar(varlist.list, VEXPORT|VSTACK);
9743                         /* run <applet>_main() */
9744                         status = run_nofork_applet(applet_no, argv);
9745                         break;
9746                 }
9747 #endif
9748                 /* Can we avoid forking off? For example, very last command
9749                  * in a script or a subshell does not need forking,
9750                  * we can just exec it.
9751                  */
9752                 if (!(flags & EV_EXIT) || may_have_traps) {
9753                         /* No, forking off a child is necessary */
9754                         INT_OFF;
9755                         get_tty_state();
9756                         jp = makejob(/*cmd,*/ 1);
9757                         if (forkshell(jp, cmd, FORK_FG) != 0) {
9758                                 /* parent */
9759                                 status = waitforjob(jp);
9760                                 INT_ON;
9761                                 TRACE(("forked child exited with %d\n", status));
9762                                 break;
9763                         }
9764                         /* child */
9765                         FORCE_INT_ON;
9766                         /* fall through to exec'ing external program */
9767                 }
9768                 listsetvar(varlist.list, VEXPORT|VSTACK);
9769                 shellexec(argv[0], argv, path, cmdentry.u.index);
9770                 /* NOTREACHED */
9771         } /* default */
9772         case CMDBUILTIN:
9773                 cmdenviron = varlist.list;
9774                 if (cmdenviron) {
9775                         struct strlist *list = cmdenviron;
9776                         int i = VNOSET;
9777                         if (spclbltin > 0 || argc == 0) {
9778                                 i = 0;
9779                                 if (cmd_is_exec && argc > 1)
9780                                         i = VEXPORT;
9781                         }
9782                         listsetvar(list, i);
9783                 }
9784                 /* Tight loop with builtins only:
9785                  * "while kill -0 $child; do true; done"
9786                  * will never exit even if $child died, unless we do this
9787                  * to reap the zombie and make kill detect that it's gone: */
9788                 dowait(DOWAIT_NONBLOCK, NULL);
9789
9790                 if (evalbltin(cmdentry.u.cmd, argc, argv, flags)) {
9791                         if (exception_type == EXERROR && spclbltin <= 0) {
9792                                 FORCE_INT_ON;
9793                                 goto readstatus;
9794                         }
9795  raise:
9796                         longjmp(exception_handler->loc, 1);
9797                 }
9798                 goto readstatus;
9799
9800         case CMDFUNCTION:
9801                 listsetvar(varlist.list, 0);
9802                 /* See above for the rationale */
9803                 dowait(DOWAIT_NONBLOCK, NULL);
9804                 if (evalfun(cmdentry.u.func, argc, argv, flags))
9805                         goto raise;
9806  readstatus:
9807                 status = exitstatus;
9808                 break;
9809         } /* switch */
9810
9811  out:
9812         if (cmd->ncmd.redirect)
9813                 popredir(/*drop:*/ cmd_is_exec, /*restore:*/ cmd_is_exec);
9814         if (lastarg) {
9815                 /* dsl: I think this is intended to be used to support
9816                  * '_' in 'vi' command mode during line editing...
9817                  * However I implemented that within libedit itself.
9818                  */
9819                 setvar0("_", lastarg);
9820         }
9821         popstackmark(&smark);
9822
9823         return status;
9824 }
9825
9826 static int
9827 evalbltin(const struct builtincmd *cmd, int argc, char **argv, int flags)
9828 {
9829         char *volatile savecmdname;
9830         struct jmploc *volatile savehandler;
9831         struct jmploc jmploc;
9832         int status;
9833         int i;
9834
9835         savecmdname = commandname;
9836         savehandler = exception_handler;
9837         i = setjmp(jmploc.loc);
9838         if (i)
9839                 goto cmddone;
9840         exception_handler = &jmploc;
9841         commandname = argv[0];
9842         argptr = argv + 1;
9843         optptr = NULL;                  /* initialize nextopt */
9844         if (cmd == EVALCMD)
9845                 status = evalcmd(argc, argv, flags);
9846         else
9847                 status = (*cmd->builtin)(argc, argv);
9848         flush_stdout_stderr();
9849         status |= ferror(stdout);
9850         exitstatus = status;
9851  cmddone:
9852         clearerr(stdout);
9853         commandname = savecmdname;
9854         exception_handler = savehandler;
9855
9856         return i;
9857 }
9858
9859 static int
9860 goodname(const char *p)
9861 {
9862         return endofname(p)[0] == '\0';
9863 }
9864
9865
9866 /*
9867  * Search for a command.  This is called before we fork so that the
9868  * location of the command will be available in the parent as well as
9869  * the child.  The check for "goodname" is an overly conservative
9870  * check that the name will not be subject to expansion.
9871  */
9872 static void
9873 prehash(union node *n)
9874 {
9875         struct cmdentry entry;
9876
9877         if (n->type == NCMD && n->ncmd.args && goodname(n->ncmd.args->narg.text))
9878                 find_command(n->ncmd.args->narg.text, &entry, 0, pathval());
9879 }
9880
9881
9882 /* ============ Builtin commands
9883  *
9884  * Builtin commands whose functions are closely tied to evaluation
9885  * are implemented here.
9886  */
9887
9888 /*
9889  * Handle break and continue commands.  Break, continue, and return are
9890  * all handled by setting the evalskip flag.  The evaluation routines
9891  * above all check this flag, and if it is set they start skipping
9892  * commands rather than executing them.  The variable skipcount is
9893  * the number of loops to break/continue, or the number of function
9894  * levels to return.  (The latter is always 1.)  It should probably
9895  * be an error to break out of more loops than exist, but it isn't
9896  * in the standard shell so we don't make it one here.
9897  */
9898 static int FAST_FUNC
9899 breakcmd(int argc UNUSED_PARAM, char **argv)
9900 {
9901         int n = argv[1] ? number(argv[1]) : 1;
9902
9903         if (n <= 0)
9904                 ash_msg_and_raise_error(msg_illnum, argv[1]);
9905         if (n > loopnest)
9906                 n = loopnest;
9907         if (n > 0) {
9908                 evalskip = (**argv == 'c') ? SKIPCONT : SKIPBREAK;
9909                 skipcount = n;
9910         }
9911         return 0;
9912 }
9913
9914
9915 /*
9916  * This implements the input routines used by the parser.
9917  */
9918
9919 enum {
9920         INPUT_PUSH_FILE = 1,
9921         INPUT_NOFILE_OK = 2,
9922 };
9923
9924 static smallint checkkwd;
9925 /* values of checkkwd variable */
9926 #define CHKALIAS        0x1
9927 #define CHKKWD          0x2
9928 #define CHKNL           0x4
9929
9930 /*
9931  * Push a string back onto the input at this current parsefile level.
9932  * We handle aliases this way.
9933  */
9934 #if !ENABLE_ASH_ALIAS
9935 #define pushstring(s, ap) pushstring(s)
9936 #endif
9937 static void
9938 pushstring(char *s, struct alias *ap)
9939 {
9940         struct strpush *sp;
9941         int len;
9942
9943         len = strlen(s);
9944         INT_OFF;
9945         if (g_parsefile->strpush) {
9946                 sp = ckzalloc(sizeof(*sp));
9947                 sp->prev = g_parsefile->strpush;
9948         } else {
9949                 sp = &(g_parsefile->basestrpush);
9950         }
9951         g_parsefile->strpush = sp;
9952         sp->prev_string = g_parsefile->next_to_pgetc;
9953         sp->prev_left_in_line = g_parsefile->left_in_line;
9954         sp->unget = g_parsefile->unget;
9955         memcpy(sp->lastc, g_parsefile->lastc, sizeof(sp->lastc));
9956 #if ENABLE_ASH_ALIAS
9957         sp->ap = ap;
9958         if (ap) {
9959                 ap->flag |= ALIASINUSE;
9960                 sp->string = s;
9961         }
9962 #endif
9963         g_parsefile->next_to_pgetc = s;
9964         g_parsefile->left_in_line = len;
9965         g_parsefile->unget = 0;
9966         INT_ON;
9967 }
9968
9969 static void
9970 popstring(void)
9971 {
9972         struct strpush *sp = g_parsefile->strpush;
9973
9974         INT_OFF;
9975 #if ENABLE_ASH_ALIAS
9976         if (sp->ap) {
9977                 if (g_parsefile->next_to_pgetc[-1] == ' '
9978                  || g_parsefile->next_to_pgetc[-1] == '\t'
9979                 ) {
9980                         checkkwd |= CHKALIAS;
9981                 }
9982                 if (sp->string != sp->ap->val) {
9983                         free(sp->string);
9984                 }
9985                 sp->ap->flag &= ~ALIASINUSE;
9986                 if (sp->ap->flag & ALIASDEAD) {
9987                         unalias(sp->ap->name);
9988                 }
9989         }
9990 #endif
9991         g_parsefile->next_to_pgetc = sp->prev_string;
9992         g_parsefile->left_in_line = sp->prev_left_in_line;
9993         g_parsefile->unget = sp->unget;
9994         memcpy(g_parsefile->lastc, sp->lastc, sizeof(sp->lastc));
9995         g_parsefile->strpush = sp->prev;
9996         if (sp != &(g_parsefile->basestrpush))
9997                 free(sp);
9998         INT_ON;
9999 }
10000
10001 static int
10002 preadfd(void)
10003 {
10004         int nr;
10005         char *buf = g_parsefile->buf;
10006
10007         g_parsefile->next_to_pgetc = buf;
10008 #if ENABLE_FEATURE_EDITING
10009  retry:
10010         if (!iflag || g_parsefile->pf_fd != STDIN_FILENO)
10011                 nr = nonblock_immune_read(g_parsefile->pf_fd, buf, IBUFSIZ - 1);
10012         else {
10013                 int timeout = -1;
10014 # if ENABLE_ASH_IDLE_TIMEOUT
10015                 if (iflag) {
10016                         const char *tmout_var = lookupvar("TMOUT");
10017                         if (tmout_var) {
10018                                 timeout = atoi(tmout_var) * 1000;
10019                                 if (timeout <= 0)
10020                                         timeout = -1;
10021                         }
10022                 }
10023 # endif
10024 # if ENABLE_FEATURE_TAB_COMPLETION
10025                 line_input_state->path_lookup = pathval();
10026 # endif
10027                 reinit_unicode_for_ash();
10028                 nr = read_line_input(line_input_state, cmdedit_prompt, buf, IBUFSIZ, timeout);
10029                 if (nr == 0) {
10030                         /* ^C pressed, "convert" to SIGINT */
10031                         write(STDOUT_FILENO, "^C", 2);
10032                         if (trap[SIGINT]) {
10033                                 buf[0] = '\n';
10034                                 buf[1] = '\0';
10035                                 raise(SIGINT);
10036                                 return 1;
10037                         }
10038                         exitstatus = 128 + SIGINT;
10039                         bb_putchar('\n');
10040                         goto retry;
10041                 }
10042                 if (nr < 0) {
10043                         if (errno == 0) {
10044                                 /* Ctrl+D pressed */
10045                                 nr = 0;
10046                         }
10047 # if ENABLE_ASH_IDLE_TIMEOUT
10048                         else if (errno == EAGAIN && timeout > 0) {
10049                                 puts("\007timed out waiting for input: auto-logout");
10050                                 exitshell();
10051                         }
10052 # endif
10053                 }
10054         }
10055 #else
10056         nr = nonblock_immune_read(g_parsefile->pf_fd, buf, IBUFSIZ - 1);
10057 #endif
10058
10059 #if 0 /* disabled: nonblock_immune_read() handles this problem */
10060         if (nr < 0) {
10061                 if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
10062                         int flags = fcntl(0, F_GETFL);
10063                         if (flags >= 0 && (flags & O_NONBLOCK)) {
10064                                 flags &= ~O_NONBLOCK;
10065                                 if (fcntl(0, F_SETFL, flags) >= 0) {
10066                                         out2str("sh: turning off NDELAY mode\n");
10067                                         goto retry;
10068                                 }
10069                         }
10070                 }
10071         }
10072 #endif
10073         return nr;
10074 }
10075
10076 /*
10077  * Refill the input buffer and return the next input character:
10078  *
10079  * 1) If a string was pushed back on the input, pop it;
10080  * 2) If an EOF was pushed back (g_parsefile->left_in_line < -BIGNUM)
10081  *    or we are reading from a string so we can't refill the buffer,
10082  *    return EOF.
10083  * 3) If there is more stuff in this buffer, use it else call read to fill it.
10084  * 4) Process input up to the next newline, deleting nul characters.
10085  */
10086 //#define pgetc_debug(...) bb_error_msg(__VA_ARGS__)
10087 #define pgetc_debug(...) ((void)0)
10088 static int pgetc(void);
10089 static int
10090 preadbuffer(void)
10091 {
10092         char *q;
10093         int more;
10094
10095         if (g_parsefile->strpush) {
10096 #if ENABLE_ASH_ALIAS
10097                 if (g_parsefile->left_in_line == -1
10098                  && g_parsefile->strpush->ap
10099                  && g_parsefile->next_to_pgetc[-1] != ' '
10100                  && g_parsefile->next_to_pgetc[-1] != '\t'
10101                 ) {
10102                         pgetc_debug("preadbuffer PEOA");
10103                         return PEOA;
10104                 }
10105 #endif
10106                 popstring();
10107                 return pgetc();
10108         }
10109         /* on both branches above g_parsefile->left_in_line < 0.
10110          * "pgetc" needs refilling.
10111          */
10112
10113         /* -90 is our -BIGNUM. Below we use -99 to mark "EOF on read",
10114          * pungetc() may increment it a few times.
10115          * Assuming it won't increment it to less than -90.
10116          */
10117         if (g_parsefile->left_in_line < -90 || g_parsefile->buf == NULL) {
10118                 pgetc_debug("preadbuffer PEOF1");
10119                 /* even in failure keep left_in_line and next_to_pgetc
10120                  * in lock step, for correct multi-layer pungetc.
10121                  * left_in_line was decremented before preadbuffer(),
10122                  * must inc next_to_pgetc: */
10123                 g_parsefile->next_to_pgetc++;
10124                 return PEOF;
10125         }
10126
10127         more = g_parsefile->left_in_buffer;
10128         if (more <= 0) {
10129                 flush_stdout_stderr();
10130  again:
10131                 more = preadfd();
10132                 if (more <= 0) {
10133                         /* don't try reading again */
10134                         g_parsefile->left_in_line = -99;
10135                         pgetc_debug("preadbuffer PEOF2");
10136                         g_parsefile->next_to_pgetc++;
10137                         return PEOF;
10138                 }
10139         }
10140
10141         /* Find out where's the end of line.
10142          * Set g_parsefile->left_in_line
10143          * and g_parsefile->left_in_buffer acordingly.
10144          * NUL chars are deleted.
10145          */
10146         q = g_parsefile->next_to_pgetc;
10147         for (;;) {
10148                 char c;
10149
10150                 more--;
10151
10152                 c = *q;
10153                 if (c == '\0') {
10154                         memmove(q, q + 1, more);
10155                 } else {
10156                         q++;
10157                         if (c == '\n') {
10158                                 g_parsefile->left_in_line = q - g_parsefile->next_to_pgetc - 1;
10159                                 break;
10160                         }
10161                 }
10162
10163                 if (more <= 0) {
10164                         g_parsefile->left_in_line = q - g_parsefile->next_to_pgetc - 1;
10165                         if (g_parsefile->left_in_line < 0)
10166                                 goto again;
10167                         break;
10168                 }
10169         }
10170         g_parsefile->left_in_buffer = more;
10171
10172         if (vflag) {
10173                 char save = *q;
10174                 *q = '\0';
10175                 out2str(g_parsefile->next_to_pgetc);
10176                 *q = save;
10177         }
10178
10179         pgetc_debug("preadbuffer at %d:%p'%s'",
10180                         g_parsefile->left_in_line,
10181                         g_parsefile->next_to_pgetc,
10182                         g_parsefile->next_to_pgetc);
10183         return (unsigned char)*g_parsefile->next_to_pgetc++;
10184 }
10185
10186 static void
10187 nlprompt(void)
10188 {
10189         g_parsefile->linno++;
10190         setprompt_if(doprompt, 2);
10191 }
10192 static void
10193 nlnoprompt(void)
10194 {
10195         g_parsefile->linno++;
10196         needprompt = doprompt;
10197 }
10198
10199 static int
10200 pgetc(void)
10201 {
10202         int c;
10203
10204         pgetc_debug("pgetc at %d:%p'%s'",
10205                         g_parsefile->left_in_line,
10206                         g_parsefile->next_to_pgetc,
10207                         g_parsefile->next_to_pgetc);
10208         if (g_parsefile->unget)
10209                 return g_parsefile->lastc[--g_parsefile->unget];
10210
10211         if (--g_parsefile->left_in_line >= 0)
10212                 c = (unsigned char)*g_parsefile->next_to_pgetc++;
10213         else
10214                 c = preadbuffer();
10215
10216         g_parsefile->lastc[1] = g_parsefile->lastc[0];
10217         g_parsefile->lastc[0] = c;
10218
10219         return c;
10220 }
10221
10222 #if ENABLE_ASH_ALIAS
10223 static int
10224 pgetc_without_PEOA(void)
10225 {
10226         int c;
10227         do {
10228                 pgetc_debug("pgetc at %d:%p'%s'",
10229                                 g_parsefile->left_in_line,
10230                                 g_parsefile->next_to_pgetc,
10231                                 g_parsefile->next_to_pgetc);
10232                 c = pgetc();
10233         } while (c == PEOA);
10234         return c;
10235 }
10236 #else
10237 # define pgetc_without_PEOA() pgetc()
10238 #endif
10239
10240 /*
10241  * Read a line from the script.
10242  */
10243 static char *
10244 pfgets(char *line, int len)
10245 {
10246         char *p = line;
10247         int nleft = len;
10248         int c;
10249
10250         while (--nleft > 0) {
10251                 c = pgetc_without_PEOA();
10252                 if (c == PEOF) {
10253                         if (p == line)
10254                                 return NULL;
10255                         break;
10256                 }
10257                 *p++ = c;
10258                 if (c == '\n')
10259                         break;
10260         }
10261         *p = '\0';
10262         return line;
10263 }
10264
10265 /*
10266  * Undo a call to pgetc.  Only two characters may be pushed back.
10267  * PEOF may be pushed back.
10268  */
10269 static void
10270 pungetc(void)
10271 {
10272         g_parsefile->unget++;
10273 }
10274
10275 /* This one eats backslash+newline */
10276 static int
10277 pgetc_eatbnl(void)
10278 {
10279         int c;
10280
10281         while ((c = pgetc()) == '\\') {
10282                 if (pgetc() != '\n') {
10283                         pungetc();
10284                         break;
10285                 }
10286
10287                 nlprompt();
10288         }
10289
10290         return c;
10291 }
10292
10293 /*
10294  * To handle the "." command, a stack of input files is used.  Pushfile
10295  * adds a new entry to the stack and popfile restores the previous level.
10296  */
10297 static void
10298 pushfile(void)
10299 {
10300         struct parsefile *pf;
10301
10302         pf = ckzalloc(sizeof(*pf));
10303         pf->prev = g_parsefile;
10304         pf->pf_fd = -1;
10305         /*pf->strpush = NULL; - ckzalloc did it */
10306         /*pf->basestrpush.prev = NULL;*/
10307         /*pf->unget = 0;*/
10308         g_parsefile = pf;
10309 }
10310
10311 static void
10312 popfile(void)
10313 {
10314         struct parsefile *pf = g_parsefile;
10315
10316         if (pf == &basepf)
10317                 return;
10318
10319         INT_OFF;
10320         if (pf->pf_fd >= 0)
10321                 close(pf->pf_fd);
10322         free(pf->buf);
10323         while (pf->strpush)
10324                 popstring();
10325         g_parsefile = pf->prev;
10326         free(pf);
10327         INT_ON;
10328 }
10329
10330 /*
10331  * Return to top level.
10332  */
10333 static void
10334 popallfiles(void)
10335 {
10336         while (g_parsefile != &basepf)
10337                 popfile();
10338 }
10339
10340 /*
10341  * Close the file(s) that the shell is reading commands from.  Called
10342  * after a fork is done.
10343  */
10344 static void
10345 closescript(void)
10346 {
10347         popallfiles();
10348         if (g_parsefile->pf_fd > 0) {
10349                 close(g_parsefile->pf_fd);
10350                 g_parsefile->pf_fd = 0;
10351         }
10352 }
10353
10354 /*
10355  * Like setinputfile, but takes an open file descriptor.  Call this with
10356  * interrupts off.
10357  */
10358 static void
10359 setinputfd(int fd, int push)
10360 {
10361         if (push) {
10362                 pushfile();
10363                 g_parsefile->buf = NULL;
10364         }
10365         g_parsefile->pf_fd = fd;
10366         if (g_parsefile->buf == NULL)
10367                 g_parsefile->buf = ckmalloc(IBUFSIZ);
10368         g_parsefile->left_in_buffer = 0;
10369         g_parsefile->left_in_line = 0;
10370         g_parsefile->linno = 1;
10371 }
10372
10373 /*
10374  * Set the input to take input from a file.  If push is set, push the
10375  * old input onto the stack first.
10376  */
10377 static int
10378 setinputfile(const char *fname, int flags)
10379 {
10380         int fd;
10381
10382         INT_OFF;
10383         fd = open(fname, O_RDONLY);
10384         if (fd < 0) {
10385                 if (flags & INPUT_NOFILE_OK)
10386                         goto out;
10387                 exitstatus = 127;
10388                 ash_msg_and_raise_error("can't open '%s'", fname);
10389         }
10390         if (fd < 10)
10391                 fd = savefd(fd);
10392         else
10393                 close_on_exec_on(fd);
10394         setinputfd(fd, flags & INPUT_PUSH_FILE);
10395  out:
10396         INT_ON;
10397         return fd;
10398 }
10399
10400 /*
10401  * Like setinputfile, but takes input from a string.
10402  */
10403 static void
10404 setinputstring(char *string)
10405 {
10406         INT_OFF;
10407         pushfile();
10408         g_parsefile->next_to_pgetc = string;
10409         g_parsefile->left_in_line = strlen(string);
10410         g_parsefile->buf = NULL;
10411         g_parsefile->linno = 1;
10412         INT_ON;
10413 }
10414
10415
10416 /*
10417  * Routines to check for mail.
10418  */
10419
10420 #if ENABLE_ASH_MAIL
10421
10422 /* Hash of mtimes of mailboxes */
10423 static unsigned mailtime_hash;
10424 /* Set if MAIL or MAILPATH is changed. */
10425 static smallint mail_var_path_changed;
10426
10427 /*
10428  * Print appropriate message(s) if mail has arrived.
10429  * If mail_var_path_changed is set,
10430  * then the value of MAIL has mail_var_path_changed,
10431  * so we just update the values.
10432  */
10433 static void
10434 chkmail(void)
10435 {
10436         const char *mpath;
10437         char *p;
10438         char *q;
10439         unsigned new_hash;
10440         struct stackmark smark;
10441         struct stat statb;
10442
10443         setstackmark(&smark);
10444         mpath = mpathset() ? mpathval() : mailval();
10445         new_hash = 0;
10446         for (;;) {
10447                 p = path_advance(&mpath, nullstr);
10448                 if (p == NULL)
10449                         break;
10450                 if (*p == '\0')
10451                         continue;
10452                 for (q = p; *q; q++)
10453                         continue;
10454 #if DEBUG
10455                 if (q[-1] != '/')
10456                         abort();
10457 #endif
10458                 q[-1] = '\0';                   /* delete trailing '/' */
10459                 if (stat(p, &statb) < 0) {
10460                         continue;
10461                 }
10462                 /* Very simplistic "hash": just a sum of all mtimes */
10463                 new_hash += (unsigned)statb.st_mtime;
10464         }
10465         if (!mail_var_path_changed && mailtime_hash != new_hash) {
10466                 if (mailtime_hash != 0)
10467                         out2str("you have mail\n");
10468                 mailtime_hash = new_hash;
10469         }
10470         mail_var_path_changed = 0;
10471         popstackmark(&smark);
10472 }
10473
10474 static void FAST_FUNC
10475 changemail(const char *val UNUSED_PARAM)
10476 {
10477         mail_var_path_changed = 1;
10478 }
10479
10480 #endif /* ASH_MAIL */
10481
10482
10483 /* ============ ??? */
10484
10485 /*
10486  * Set the shell parameters.
10487  */
10488 static void
10489 setparam(char **argv)
10490 {
10491         char **newparam;
10492         char **ap;
10493         int nparam;
10494
10495         for (nparam = 0; argv[nparam]; nparam++)
10496                 continue;
10497         ap = newparam = ckmalloc((nparam + 1) * sizeof(*ap));
10498         while (*argv) {
10499                 *ap++ = ckstrdup(*argv++);
10500         }
10501         *ap = NULL;
10502         freeparam(&shellparam);
10503         shellparam.malloced = 1;
10504         shellparam.nparam = nparam;
10505         shellparam.p = newparam;
10506 #if ENABLE_ASH_GETOPTS
10507         shellparam.optind = 1;
10508         shellparam.optoff = -1;
10509 #endif
10510 }
10511
10512 /*
10513  * Process shell options.  The global variable argptr contains a pointer
10514  * to the argument list; we advance it past the options.
10515  *
10516  * SUSv3 section 2.8.1 "Consequences of Shell Errors" says:
10517  * For a non-interactive shell, an error condition encountered
10518  * by a special built-in ... shall cause the shell to write a diagnostic message
10519  * to standard error and exit as shown in the following table:
10520  * Error                                           Special Built-In
10521  * ...
10522  * Utility syntax error (option or operand error)  Shall exit
10523  * ...
10524  * However, in bug 1142 (http://busybox.net/bugs/view.php?id=1142)
10525  * we see that bash does not do that (set "finishes" with error code 1 instead,
10526  * and shell continues), and people rely on this behavior!
10527  * Testcase:
10528  * set -o barfoo 2>/dev/null
10529  * echo $?
10530  *
10531  * Oh well. Let's mimic that.
10532  */
10533 static int
10534 plus_minus_o(char *name, int val)
10535 {
10536         int i;
10537
10538         if (name) {
10539                 for (i = 0; i < NOPTS; i++) {
10540                         if (strcmp(name, optnames(i)) == 0) {
10541                                 optlist[i] = val;
10542                                 return 0;
10543                         }
10544                 }
10545                 ash_msg("illegal option %co %s", val ? '-' : '+', name);
10546                 return 1;
10547         }
10548         for (i = 0; i < NOPTS; i++) {
10549                 if (val) {
10550                         out1fmt("%-16s%s\n", optnames(i), optlist[i] ? "on" : "off");
10551                 } else {
10552                         out1fmt("set %co %s\n", optlist[i] ? '-' : '+', optnames(i));
10553                 }
10554         }
10555         return 0;
10556 }
10557 static void
10558 setoption(int flag, int val)
10559 {
10560         int i;
10561
10562         for (i = 0; i < NOPTS; i++) {
10563                 if (optletters(i) == flag) {
10564                         optlist[i] = val;
10565                         return;
10566                 }
10567         }
10568         ash_msg_and_raise_error("illegal option %c%c", val ? '-' : '+', flag);
10569         /* NOTREACHED */
10570 }
10571 static int
10572 options(int cmdline)
10573 {
10574         char *p;
10575         int val;
10576         int c;
10577
10578         if (cmdline)
10579                 minusc = NULL;
10580         while ((p = *argptr) != NULL) {
10581                 c = *p++;
10582                 if (c != '-' && c != '+')
10583                         break;
10584                 argptr++;
10585                 val = 0; /* val = 0 if c == '+' */
10586                 if (c == '-') {
10587                         val = 1;
10588                         if (p[0] == '\0' || LONE_DASH(p)) {
10589                                 if (!cmdline) {
10590                                         /* "-" means turn off -x and -v */
10591                                         if (p[0] == '\0')
10592                                                 xflag = vflag = 0;
10593                                         /* "--" means reset params */
10594                                         else if (*argptr == NULL)
10595                                                 setparam(argptr);
10596                                 }
10597                                 break;    /* "-" or "--" terminates options */
10598                         }
10599                 }
10600                 /* first char was + or - */
10601                 while ((c = *p++) != '\0') {
10602                         /* bash 3.2 indeed handles -c CMD and +c CMD the same */
10603                         if (c == 'c' && cmdline) {
10604                                 minusc = p;     /* command is after shell args */
10605                         } else if (c == 'o') {
10606                                 if (plus_minus_o(*argptr, val)) {
10607                                         /* it already printed err message */
10608                                         return 1; /* error */
10609                                 }
10610                                 if (*argptr)
10611                                         argptr++;
10612                         } else if (cmdline && (c == 'l')) { /* -l or +l == --login */
10613                                 isloginsh = 1;
10614                         /* bash does not accept +-login, we also won't */
10615                         } else if (cmdline && val && (c == '-')) { /* long options */
10616                                 if (strcmp(p, "login") == 0)
10617                                         isloginsh = 1;
10618                                 break;
10619                         } else {
10620                                 setoption(c, val);
10621                         }
10622                 }
10623         }
10624         return 0;
10625 }
10626
10627 /*
10628  * The shift builtin command.
10629  */
10630 static int FAST_FUNC
10631 shiftcmd(int argc UNUSED_PARAM, char **argv)
10632 {
10633         int n;
10634         char **ap1, **ap2;
10635
10636         n = 1;
10637         if (argv[1])
10638                 n = number(argv[1]);
10639         if (n > shellparam.nparam)
10640                 n = 0; /* bash compat, was = shellparam.nparam; */
10641         INT_OFF;
10642         shellparam.nparam -= n;
10643         for (ap1 = shellparam.p; --n >= 0; ap1++) {
10644                 if (shellparam.malloced)
10645                         free(*ap1);
10646         }
10647         ap2 = shellparam.p;
10648         while ((*ap2++ = *ap1++) != NULL)
10649                 continue;
10650 #if ENABLE_ASH_GETOPTS
10651         shellparam.optind = 1;
10652         shellparam.optoff = -1;
10653 #endif
10654         INT_ON;
10655         return 0;
10656 }
10657
10658 /*
10659  * POSIX requires that 'set' (but not export or readonly) output the
10660  * variables in lexicographic order - by the locale's collating order (sigh).
10661  * Maybe we could keep them in an ordered balanced binary tree
10662  * instead of hashed lists.
10663  * For now just roll 'em through qsort for printing...
10664  */
10665 static int
10666 showvars(const char *sep_prefix, int on, int off)
10667 {
10668         const char *sep;
10669         char **ep, **epend;
10670
10671         ep = listvars(on, off, &epend);
10672         qsort(ep, epend - ep, sizeof(char *), vpcmp);
10673
10674         sep = *sep_prefix ? " " : sep_prefix;
10675
10676         for (; ep < epend; ep++) {
10677                 const char *p;
10678                 const char *q;
10679
10680                 p = strchrnul(*ep, '=');
10681                 q = nullstr;
10682                 if (*p)
10683                         q = single_quote(++p);
10684                 out1fmt("%s%s%.*s%s\n", sep_prefix, sep, (int)(p - *ep), *ep, q);
10685         }
10686         return 0;
10687 }
10688
10689 /*
10690  * The set command builtin.
10691  */
10692 static int FAST_FUNC
10693 setcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
10694 {
10695         int retval;
10696
10697         if (!argv[1])
10698                 return showvars(nullstr, 0, VUNSET);
10699
10700         INT_OFF;
10701         retval = options(/*cmdline:*/ 0);
10702         if (retval == 0) { /* if no parse error... */
10703                 optschanged();
10704                 if (*argptr != NULL) {
10705                         setparam(argptr);
10706                 }
10707         }
10708         INT_ON;
10709         return retval;
10710 }
10711
10712 #if ENABLE_ASH_RANDOM_SUPPORT
10713 static void FAST_FUNC
10714 change_random(const char *value)
10715 {
10716         uint32_t t;
10717
10718         if (value == NULL) {
10719                 /* "get", generate */
10720                 t = next_random(&random_gen);
10721                 /* set without recursion */
10722                 setvar(vrandom.var_text, utoa(t), VNOFUNC);
10723                 vrandom.flags &= ~VNOFUNC;
10724         } else {
10725                 /* set/reset */
10726                 t = strtoul(value, NULL, 10);
10727                 INIT_RANDOM_T(&random_gen, (t ? t : 1), t);
10728         }
10729 }
10730 #endif
10731
10732 #if ENABLE_ASH_GETOPTS
10733 static int
10734 getopts(char *optstr, char *optvar, char **optfirst)
10735 {
10736         char *p, *q;
10737         char c = '?';
10738         int done = 0;
10739         char sbuf[2];
10740         char **optnext;
10741         int ind = shellparam.optind;
10742         int off = shellparam.optoff;
10743
10744         sbuf[1] = '\0';
10745
10746         shellparam.optind = -1;
10747         optnext = optfirst + ind - 1;
10748
10749         if (ind <= 1 || off < 0 || (int)strlen(optnext[-1]) < off)
10750                 p = NULL;
10751         else
10752                 p = optnext[-1] + off;
10753         if (p == NULL || *p == '\0') {
10754                 /* Current word is done, advance */
10755                 p = *optnext;
10756                 if (p == NULL || *p != '-' || *++p == '\0') {
10757  atend:
10758                         p = NULL;
10759                         done = 1;
10760                         goto out;
10761                 }
10762                 optnext++;
10763                 if (LONE_DASH(p))        /* check for "--" */
10764                         goto atend;
10765         }
10766
10767         c = *p++;
10768         for (q = optstr; *q != c;) {
10769                 if (*q == '\0') {
10770                         if (optstr[0] == ':') {
10771                                 sbuf[0] = c;
10772                                 /*sbuf[1] = '\0'; - already is */
10773                                 setvar0("OPTARG", sbuf);
10774                         } else {
10775                                 fprintf(stderr, "Illegal option -%c\n", c);
10776                                 unsetvar("OPTARG");
10777                         }
10778                         c = '?';
10779                         goto out;
10780                 }
10781                 if (*++q == ':')
10782                         q++;
10783         }
10784
10785         if (*++q == ':') {
10786                 if (*p == '\0' && (p = *optnext) == NULL) {
10787                         if (optstr[0] == ':') {
10788                                 sbuf[0] = c;
10789                                 /*sbuf[1] = '\0'; - already is */
10790                                 setvar0("OPTARG", sbuf);
10791                                 c = ':';
10792                         } else {
10793                                 fprintf(stderr, "No arg for -%c option\n", c);
10794                                 unsetvar("OPTARG");
10795                                 c = '?';
10796                         }
10797                         goto out;
10798                 }
10799
10800                 if (p == *optnext)
10801                         optnext++;
10802                 setvar0("OPTARG", p);
10803                 p = NULL;
10804         } else
10805                 setvar0("OPTARG", nullstr);
10806  out:
10807         ind = optnext - optfirst + 1;
10808         setvar("OPTIND", itoa(ind), VNOFUNC);
10809         sbuf[0] = c;
10810         /*sbuf[1] = '\0'; - already is */
10811         setvar0(optvar, sbuf);
10812
10813         shellparam.optoff = p ? p - *(optnext - 1) : -1;
10814         shellparam.optind = ind;
10815
10816         return done;
10817 }
10818
10819 /*
10820  * The getopts builtin.  Shellparam.optnext points to the next argument
10821  * to be processed.  Shellparam.optptr points to the next character to
10822  * be processed in the current argument.  If shellparam.optnext is NULL,
10823  * then it's the first time getopts has been called.
10824  */
10825 static int FAST_FUNC
10826 getoptscmd(int argc, char **argv)
10827 {
10828         char **optbase;
10829
10830         if (argc < 3)
10831                 ash_msg_and_raise_error("usage: getopts optstring var [arg]");
10832         if (argc == 3) {
10833                 optbase = shellparam.p;
10834                 if ((unsigned)shellparam.optind > shellparam.nparam + 1) {
10835                         shellparam.optind = 1;
10836                         shellparam.optoff = -1;
10837                 }
10838         } else {
10839                 optbase = &argv[3];
10840                 if ((unsigned)shellparam.optind > argc - 2) {
10841                         shellparam.optind = 1;
10842                         shellparam.optoff = -1;
10843                 }
10844         }
10845
10846         return getopts(argv[1], argv[2], optbase);
10847 }
10848 #endif /* ASH_GETOPTS */
10849
10850
10851 /* ============ Shell parser */
10852
10853 struct heredoc {
10854         struct heredoc *next;   /* next here document in list */
10855         union node *here;       /* redirection node */
10856         char *eofmark;          /* string indicating end of input */
10857         smallint striptabs;     /* if set, strip leading tabs */
10858 };
10859
10860 static smallint tokpushback;           /* last token pushed back */
10861 static smallint quoteflag;             /* set if (part of) last token was quoted */
10862 static token_id_t lasttoken;           /* last token read (integer id Txxx) */
10863 static struct heredoc *heredoclist;    /* list of here documents to read */
10864 static char *wordtext;                 /* text of last word returned by readtoken */
10865 static struct nodelist *backquotelist;
10866 static union node *redirnode;
10867 static struct heredoc *heredoc;
10868
10869 static const char *
10870 tokname(char *buf, int tok)
10871 {
10872         if (tok < TSEMI)
10873                 return tokname_array[tok];
10874         sprintf(buf, "\"%s\"", tokname_array[tok]);
10875         return buf;
10876 }
10877
10878 /* raise_error_unexpected_syntax:
10879  * Called when an unexpected token is read during the parse.  The argument
10880  * is the token that is expected, or -1 if more than one type of token can
10881  * occur at this point.
10882  */
10883 static void raise_error_unexpected_syntax(int) NORETURN;
10884 static void
10885 raise_error_unexpected_syntax(int token)
10886 {
10887         char msg[64];
10888         char buf[16];
10889         int l;
10890
10891         l = sprintf(msg, "unexpected %s", tokname(buf, lasttoken));
10892         if (token >= 0)
10893                 sprintf(msg + l, " (expecting %s)", tokname(buf, token));
10894         raise_error_syntax(msg);
10895         /* NOTREACHED */
10896 }
10897
10898 #define EOFMARKLEN 79
10899
10900 /* parsing is heavily cross-recursive, need these forward decls */
10901 static union node *andor(void);
10902 static union node *pipeline(void);
10903 static union node *parse_command(void);
10904 static void parseheredoc(void);
10905 static int peektoken(void);
10906 static int readtoken(void);
10907
10908 static union node *
10909 list(int nlflag)
10910 {
10911         union node *n1, *n2, *n3;
10912         int tok;
10913
10914         n1 = NULL;
10915         for (;;) {
10916                 switch (peektoken()) {
10917                 case TNL:
10918                         if (!(nlflag & 1))
10919                                 break;
10920                         parseheredoc();
10921                         return n1;
10922
10923                 case TEOF:
10924                         if (!n1 && (nlflag & 1))
10925                                 n1 = NODE_EOF;
10926                         parseheredoc();
10927                         return n1;
10928                 }
10929
10930                 checkkwd = CHKNL | CHKKWD | CHKALIAS;
10931                 if (nlflag == 2 && ((1 << peektoken()) & tokendlist))
10932                         return n1;
10933                 nlflag |= 2;
10934
10935                 n2 = andor();
10936                 tok = readtoken();
10937                 if (tok == TBACKGND) {
10938                         if (n2->type == NPIPE) {
10939                                 n2->npipe.pipe_backgnd = 1;
10940                         } else {
10941                                 if (n2->type != NREDIR) {
10942                                         n3 = stzalloc(sizeof(struct nredir));
10943                                         n3->nredir.n = n2;
10944                                         /*n3->nredir.redirect = NULL; - stzalloc did it */
10945                                         n2 = n3;
10946                                 }
10947                                 n2->type = NBACKGND;
10948                         }
10949                 }
10950                 if (n1 == NULL) {
10951                         n1 = n2;
10952                 } else {
10953                         n3 = stzalloc(sizeof(struct nbinary));
10954                         n3->type = NSEMI;
10955                         n3->nbinary.ch1 = n1;
10956                         n3->nbinary.ch2 = n2;
10957                         n1 = n3;
10958                 }
10959                 switch (tok) {
10960                 case TNL:
10961                 case TEOF:
10962                         tokpushback = 1;
10963                         /* fall through */
10964                 case TBACKGND:
10965                 case TSEMI:
10966                         break;
10967                 default:
10968                         if ((nlflag & 1))
10969                                 raise_error_unexpected_syntax(-1);
10970                         tokpushback = 1;
10971                         return n1;
10972                 }
10973         }
10974 }
10975
10976 static union node *
10977 andor(void)
10978 {
10979         union node *n1, *n2, *n3;
10980         int t;
10981
10982         n1 = pipeline();
10983         for (;;) {
10984                 t = readtoken();
10985                 if (t == TAND) {
10986                         t = NAND;
10987                 } else if (t == TOR) {
10988                         t = NOR;
10989                 } else {
10990                         tokpushback = 1;
10991                         return n1;
10992                 }
10993                 checkkwd = CHKNL | CHKKWD | CHKALIAS;
10994                 n2 = pipeline();
10995                 n3 = stzalloc(sizeof(struct nbinary));
10996                 n3->type = t;
10997                 n3->nbinary.ch1 = n1;
10998                 n3->nbinary.ch2 = n2;
10999                 n1 = n3;
11000         }
11001 }
11002
11003 static union node *
11004 pipeline(void)
11005 {
11006         union node *n1, *n2, *pipenode;
11007         struct nodelist *lp, *prev;
11008         int negate;
11009
11010         negate = 0;
11011         TRACE(("pipeline: entered\n"));
11012         if (readtoken() == TNOT) {
11013                 negate = !negate;
11014                 checkkwd = CHKKWD | CHKALIAS;
11015         } else
11016                 tokpushback = 1;
11017         n1 = parse_command();
11018         if (readtoken() == TPIPE) {
11019                 pipenode = stzalloc(sizeof(struct npipe));
11020                 pipenode->type = NPIPE;
11021                 /*pipenode->npipe.pipe_backgnd = 0; - stzalloc did it */
11022                 lp = stzalloc(sizeof(struct nodelist));
11023                 pipenode->npipe.cmdlist = lp;
11024                 lp->n = n1;
11025                 do {
11026                         prev = lp;
11027                         lp = stzalloc(sizeof(struct nodelist));
11028                         checkkwd = CHKNL | CHKKWD | CHKALIAS;
11029                         lp->n = parse_command();
11030                         prev->next = lp;
11031                 } while (readtoken() == TPIPE);
11032                 lp->next = NULL;
11033                 n1 = pipenode;
11034         }
11035         tokpushback = 1;
11036         if (negate) {
11037                 n2 = stzalloc(sizeof(struct nnot));
11038                 n2->type = NNOT;
11039                 n2->nnot.com = n1;
11040                 return n2;
11041         }
11042         return n1;
11043 }
11044
11045 static union node *
11046 makename(void)
11047 {
11048         union node *n;
11049
11050         n = stzalloc(sizeof(struct narg));
11051         n->type = NARG;
11052         /*n->narg.next = NULL; - stzalloc did it */
11053         n->narg.text = wordtext;
11054         n->narg.backquote = backquotelist;
11055         return n;
11056 }
11057
11058 static void
11059 fixredir(union node *n, const char *text, int err)
11060 {
11061         int fd;
11062
11063         TRACE(("Fix redir %s %d\n", text, err));
11064         if (!err)
11065                 n->ndup.vname = NULL;
11066
11067         fd = bb_strtou(text, NULL, 10);
11068         if (!errno && fd >= 0)
11069                 n->ndup.dupfd = fd;
11070         else if (LONE_DASH(text))
11071                 n->ndup.dupfd = -1;
11072         else {
11073                 if (err)
11074                         raise_error_syntax("bad fd number");
11075                 n->ndup.vname = makename();
11076         }
11077 }
11078
11079 /*
11080  * Returns true if the text contains nothing to expand (no dollar signs
11081  * or backquotes).
11082  */
11083 static int
11084 noexpand(const char *text)
11085 {
11086         unsigned char c;
11087
11088         while ((c = *text++) != '\0') {
11089                 if (c == CTLQUOTEMARK)
11090                         continue;
11091                 if (c == CTLESC)
11092                         text++;
11093                 else if (SIT(c, BASESYNTAX) == CCTL)
11094                         return 0;
11095         }
11096         return 1;
11097 }
11098
11099 static void
11100 parsefname(void)
11101 {
11102         union node *n = redirnode;
11103
11104         if (readtoken() != TWORD)
11105                 raise_error_unexpected_syntax(-1);
11106         if (n->type == NHERE) {
11107                 struct heredoc *here = heredoc;
11108                 struct heredoc *p;
11109                 int i;
11110
11111                 if (quoteflag == 0)
11112                         n->type = NXHERE;
11113                 TRACE(("Here document %d\n", n->type));
11114                 if (!noexpand(wordtext) || (i = strlen(wordtext)) == 0 || i > EOFMARKLEN)
11115                         raise_error_syntax("illegal eof marker for << redirection");
11116                 rmescapes(wordtext, 0);
11117                 here->eofmark = wordtext;
11118                 here->next = NULL;
11119                 if (heredoclist == NULL)
11120                         heredoclist = here;
11121                 else {
11122                         for (p = heredoclist; p->next; p = p->next)
11123                                 continue;
11124                         p->next = here;
11125                 }
11126         } else if (n->type == NTOFD || n->type == NFROMFD) {
11127                 fixredir(n, wordtext, 0);
11128         } else {
11129                 n->nfile.fname = makename();
11130         }
11131 }
11132
11133 static union node *
11134 simplecmd(void)
11135 {
11136         union node *args, **app;
11137         union node *n = NULL;
11138         union node *vars, **vpp;
11139         union node **rpp, *redir;
11140         int savecheckkwd;
11141 #if BASH_TEST2
11142         smallint double_brackets_flag = 0;
11143 #endif
11144         IF_BASH_FUNCTION(smallint function_flag = 0;)
11145
11146         args = NULL;
11147         app = &args;
11148         vars = NULL;
11149         vpp = &vars;
11150         redir = NULL;
11151         rpp = &redir;
11152
11153         savecheckkwd = CHKALIAS;
11154         for (;;) {
11155                 int t;
11156                 checkkwd = savecheckkwd;
11157                 t = readtoken();
11158                 switch (t) {
11159 #if BASH_FUNCTION
11160                 case TFUNCTION:
11161                         if (peektoken() != TWORD)
11162                                 raise_error_unexpected_syntax(TWORD);
11163                         function_flag = 1;
11164                         break;
11165 #endif
11166 #if BASH_TEST2
11167                 case TAND: /* "&&" */
11168                 case TOR: /* "||" */
11169                         if (!double_brackets_flag) {
11170                                 tokpushback = 1;
11171                                 goto out;
11172                         }
11173                         wordtext = (char *) (t == TAND ? "-a" : "-o");
11174 #endif
11175                 case TWORD:
11176                         n = stzalloc(sizeof(struct narg));
11177                         n->type = NARG;
11178                         /*n->narg.next = NULL; - stzalloc did it */
11179                         n->narg.text = wordtext;
11180 #if BASH_TEST2
11181                         if (strcmp("[[", wordtext) == 0)
11182                                 double_brackets_flag = 1;
11183                         else if (strcmp("]]", wordtext) == 0)
11184                                 double_brackets_flag = 0;
11185 #endif
11186                         n->narg.backquote = backquotelist;
11187                         if (savecheckkwd && isassignment(wordtext)) {
11188                                 *vpp = n;
11189                                 vpp = &n->narg.next;
11190                         } else {
11191                                 *app = n;
11192                                 app = &n->narg.next;
11193                                 savecheckkwd = 0;
11194                         }
11195 #if BASH_FUNCTION
11196                         if (function_flag) {
11197                                 checkkwd = CHKNL | CHKKWD;
11198                                 switch (peektoken()) {
11199                                 case TBEGIN:
11200                                 case TIF:
11201                                 case TCASE:
11202                                 case TUNTIL:
11203                                 case TWHILE:
11204                                 case TFOR:
11205                                         goto do_func;
11206                                 case TLP:
11207                                         function_flag = 0;
11208                                         break;
11209                                 case TWORD:
11210                                         if (strcmp("[[", wordtext) == 0)
11211                                                 goto do_func;
11212                                         /* fall through */
11213                                 default:
11214                                         raise_error_unexpected_syntax(-1);
11215                                 }
11216                         }
11217 #endif
11218                         break;
11219                 case TREDIR:
11220                         *rpp = n = redirnode;
11221                         rpp = &n->nfile.next;
11222                         parsefname();   /* read name of redirection file */
11223                         break;
11224                 case TLP:
11225  IF_BASH_FUNCTION(do_func:)
11226                         if (args && app == &args->narg.next
11227                          && !vars && !redir
11228                         ) {
11229                                 struct builtincmd *bcmd;
11230                                 const char *name;
11231
11232                                 /* We have a function */
11233                                 if (IF_BASH_FUNCTION(!function_flag &&) readtoken() != TRP)
11234                                         raise_error_unexpected_syntax(TRP);
11235                                 name = n->narg.text;
11236                                 if (!goodname(name)
11237                                  || ((bcmd = find_builtin(name)) && IS_BUILTIN_SPECIAL(bcmd))
11238                                 ) {
11239                                         raise_error_syntax("bad function name");
11240                                 }
11241                                 n->type = NDEFUN;
11242                                 checkkwd = CHKNL | CHKKWD | CHKALIAS;
11243                                 n->narg.next = parse_command();
11244                                 return n;
11245                         }
11246                         IF_BASH_FUNCTION(function_flag = 0;)
11247                         /* fall through */
11248                 default:
11249                         tokpushback = 1;
11250                         goto out;
11251                 }
11252         }
11253  out:
11254         *app = NULL;
11255         *vpp = NULL;
11256         *rpp = NULL;
11257         n = stzalloc(sizeof(struct ncmd));
11258         n->type = NCMD;
11259         n->ncmd.args = args;
11260         n->ncmd.assign = vars;
11261         n->ncmd.redirect = redir;
11262         return n;
11263 }
11264
11265 static union node *
11266 parse_command(void)
11267 {
11268         union node *n1, *n2;
11269         union node *ap, **app;
11270         union node *cp, **cpp;
11271         union node *redir, **rpp;
11272         union node **rpp2;
11273         int t;
11274
11275         redir = NULL;
11276         rpp2 = &redir;
11277
11278         switch (readtoken()) {
11279         default:
11280                 raise_error_unexpected_syntax(-1);
11281                 /* NOTREACHED */
11282         case TIF:
11283                 n1 = stzalloc(sizeof(struct nif));
11284                 n1->type = NIF;
11285                 n1->nif.test = list(0);
11286                 if (readtoken() != TTHEN)
11287                         raise_error_unexpected_syntax(TTHEN);
11288                 n1->nif.ifpart = list(0);
11289                 n2 = n1;
11290                 while (readtoken() == TELIF) {
11291                         n2->nif.elsepart = stzalloc(sizeof(struct nif));
11292                         n2 = n2->nif.elsepart;
11293                         n2->type = NIF;
11294                         n2->nif.test = list(0);
11295                         if (readtoken() != TTHEN)
11296                                 raise_error_unexpected_syntax(TTHEN);
11297                         n2->nif.ifpart = list(0);
11298                 }
11299                 if (lasttoken == TELSE)
11300                         n2->nif.elsepart = list(0);
11301                 else {
11302                         n2->nif.elsepart = NULL;
11303                         tokpushback = 1;
11304                 }
11305                 t = TFI;
11306                 break;
11307         case TWHILE:
11308         case TUNTIL: {
11309                 int got;
11310                 n1 = stzalloc(sizeof(struct nbinary));
11311                 n1->type = (lasttoken == TWHILE) ? NWHILE : NUNTIL;
11312                 n1->nbinary.ch1 = list(0);
11313                 got = readtoken();
11314                 if (got != TDO) {
11315                         TRACE(("expecting DO got '%s' %s\n", tokname_array[got],
11316                                         got == TWORD ? wordtext : ""));
11317                         raise_error_unexpected_syntax(TDO);
11318                 }
11319                 n1->nbinary.ch2 = list(0);
11320                 t = TDONE;
11321                 break;
11322         }
11323         case TFOR:
11324                 if (readtoken() != TWORD || quoteflag || !goodname(wordtext))
11325                         raise_error_syntax("bad for loop variable");
11326                 n1 = stzalloc(sizeof(struct nfor));
11327                 n1->type = NFOR;
11328                 n1->nfor.var = wordtext;
11329                 checkkwd = CHKNL | CHKKWD | CHKALIAS;
11330                 if (readtoken() == TIN) {
11331                         app = &ap;
11332                         while (readtoken() == TWORD) {
11333                                 n2 = stzalloc(sizeof(struct narg));
11334                                 n2->type = NARG;
11335                                 /*n2->narg.next = NULL; - stzalloc did it */
11336                                 n2->narg.text = wordtext;
11337                                 n2->narg.backquote = backquotelist;
11338                                 *app = n2;
11339                                 app = &n2->narg.next;
11340                         }
11341                         *app = NULL;
11342                         n1->nfor.args = ap;
11343                         if (lasttoken != TNL && lasttoken != TSEMI)
11344                                 raise_error_unexpected_syntax(-1);
11345                 } else {
11346                         n2 = stzalloc(sizeof(struct narg));
11347                         n2->type = NARG;
11348                         /*n2->narg.next = NULL; - stzalloc did it */
11349                         n2->narg.text = (char *)dolatstr;
11350                         /*n2->narg.backquote = NULL;*/
11351                         n1->nfor.args = n2;
11352                         /*
11353                          * Newline or semicolon here is optional (but note
11354                          * that the original Bourne shell only allowed NL).
11355                          */
11356                         if (lasttoken != TSEMI)
11357                                 tokpushback = 1;
11358                 }
11359                 checkkwd = CHKNL | CHKKWD | CHKALIAS;
11360                 if (readtoken() != TDO)
11361                         raise_error_unexpected_syntax(TDO);
11362                 n1->nfor.body = list(0);
11363                 t = TDONE;
11364                 break;
11365         case TCASE:
11366                 n1 = stzalloc(sizeof(struct ncase));
11367                 n1->type = NCASE;
11368                 if (readtoken() != TWORD)
11369                         raise_error_unexpected_syntax(TWORD);
11370                 n1->ncase.expr = n2 = stzalloc(sizeof(struct narg));
11371                 n2->type = NARG;
11372                 /*n2->narg.next = NULL; - stzalloc did it */
11373                 n2->narg.text = wordtext;
11374                 n2->narg.backquote = backquotelist;
11375                 checkkwd = CHKNL | CHKKWD | CHKALIAS;
11376                 if (readtoken() != TIN)
11377                         raise_error_unexpected_syntax(TIN);
11378                 cpp = &n1->ncase.cases;
11379  next_case:
11380                 checkkwd = CHKNL | CHKKWD;
11381                 t = readtoken();
11382                 while (t != TESAC) {
11383                         if (lasttoken == TLP)
11384                                 readtoken();
11385                         *cpp = cp = stzalloc(sizeof(struct nclist));
11386                         cp->type = NCLIST;
11387                         app = &cp->nclist.pattern;
11388                         for (;;) {
11389                                 *app = ap = stzalloc(sizeof(struct narg));
11390                                 ap->type = NARG;
11391                                 /*ap->narg.next = NULL; - stzalloc did it */
11392                                 ap->narg.text = wordtext;
11393                                 ap->narg.backquote = backquotelist;
11394                                 if (readtoken() != TPIPE)
11395                                         break;
11396                                 app = &ap->narg.next;
11397                                 readtoken();
11398                         }
11399                         //ap->narg.next = NULL;
11400                         if (lasttoken != TRP)
11401                                 raise_error_unexpected_syntax(TRP);
11402                         cp->nclist.body = list(2);
11403
11404                         cpp = &cp->nclist.next;
11405
11406                         checkkwd = CHKNL | CHKKWD;
11407                         t = readtoken();
11408                         if (t != TESAC) {
11409                                 if (t != TENDCASE)
11410                                         raise_error_unexpected_syntax(TENDCASE);
11411                                 goto next_case;
11412                         }
11413                 }
11414                 *cpp = NULL;
11415                 goto redir;
11416         case TLP:
11417                 n1 = stzalloc(sizeof(struct nredir));
11418                 n1->type = NSUBSHELL;
11419                 n1->nredir.n = list(0);
11420                 /*n1->nredir.redirect = NULL; - stzalloc did it */
11421                 t = TRP;
11422                 break;
11423         case TBEGIN:
11424                 n1 = list(0);
11425                 t = TEND;
11426                 break;
11427         IF_BASH_FUNCTION(case TFUNCTION:)
11428         case TWORD:
11429         case TREDIR:
11430                 tokpushback = 1;
11431                 return simplecmd();
11432         }
11433
11434         if (readtoken() != t)
11435                 raise_error_unexpected_syntax(t);
11436
11437  redir:
11438         /* Now check for redirection which may follow command */
11439         checkkwd = CHKKWD | CHKALIAS;
11440         rpp = rpp2;
11441         while (readtoken() == TREDIR) {
11442                 *rpp = n2 = redirnode;
11443                 rpp = &n2->nfile.next;
11444                 parsefname();
11445         }
11446         tokpushback = 1;
11447         *rpp = NULL;
11448         if (redir) {
11449                 if (n1->type != NSUBSHELL) {
11450                         n2 = stzalloc(sizeof(struct nredir));
11451                         n2->type = NREDIR;
11452                         n2->nredir.n = n1;
11453                         n1 = n2;
11454                 }
11455                 n1->nredir.redirect = redir;
11456         }
11457         return n1;
11458 }
11459
11460 #if BASH_DOLLAR_SQUOTE
11461 static int
11462 decode_dollar_squote(void)
11463 {
11464         static const char C_escapes[] ALIGN1 = "nrbtfav""x\\01234567";
11465         int c, cnt;
11466         char *p;
11467         char buf[4];
11468
11469         c = pgetc();
11470         p = strchr(C_escapes, c);
11471         if (p) {
11472                 buf[0] = c;
11473                 p = buf;
11474                 cnt = 3;
11475                 if ((unsigned char)(c - '0') <= 7) { /* \ooo */
11476                         do {
11477                                 c = pgetc();
11478                                 *++p = c;
11479                         } while ((unsigned char)(c - '0') <= 7 && --cnt);
11480                         pungetc();
11481                 } else if (c == 'x') { /* \xHH */
11482                         do {
11483                                 c = pgetc();
11484                                 *++p = c;
11485                         } while (isxdigit(c) && --cnt);
11486                         pungetc();
11487                         if (cnt == 3) { /* \x but next char is "bad" */
11488                                 c = 'x';
11489                                 goto unrecognized;
11490                         }
11491                 } else { /* simple seq like \\ or \t */
11492                         p++;
11493                 }
11494                 *p = '\0';
11495                 p = buf;
11496                 c = bb_process_escape_sequence((void*)&p);
11497         } else { /* unrecognized "\z": print both chars unless ' or " */
11498                 if (c != '\'' && c != '"') {
11499  unrecognized:
11500                         c |= 0x100; /* "please encode \, then me" */
11501                 }
11502         }
11503         return c;
11504 }
11505 #endif
11506
11507 /*
11508  * If eofmark is NULL, read a word or a redirection symbol.  If eofmark
11509  * is not NULL, read a here document.  In the latter case, eofmark is the
11510  * word which marks the end of the document and striptabs is true if
11511  * leading tabs should be stripped from the document.  The argument c
11512  * is the first character of the input token or document.
11513  *
11514  * Because C does not have internal subroutines, I have simulated them
11515  * using goto's to implement the subroutine linkage.  The following macros
11516  * will run code that appears at the end of readtoken1.
11517  */
11518 #define CHECKEND()      {goto checkend; checkend_return:;}
11519 #define PARSEREDIR()    {goto parseredir; parseredir_return:;}
11520 #define PARSESUB()      {goto parsesub; parsesub_return:;}
11521 #define PARSEBACKQOLD() {oldstyle = 1; goto parsebackq; parsebackq_oldreturn:;}
11522 #define PARSEBACKQNEW() {oldstyle = 0; goto parsebackq; parsebackq_newreturn:;}
11523 #define PARSEARITH()    {goto parsearith; parsearith_return:;}
11524 static int
11525 readtoken1(int c, int syntax, char *eofmark, int striptabs)
11526 {
11527         /* NB: syntax parameter fits into smallint */
11528         /* c parameter is an unsigned char or PEOF or PEOA */
11529         char *out;
11530         size_t len;
11531         char line[EOFMARKLEN + 1];
11532         struct nodelist *bqlist;
11533         smallint quotef;
11534         smallint dblquote;
11535         smallint oldstyle;
11536         IF_FEATURE_SH_MATH(smallint prevsyntax;) /* syntax before arithmetic */
11537 #if ENABLE_ASH_EXPAND_PRMT
11538         smallint pssyntax;   /* we are expanding a prompt string */
11539 #endif
11540         int varnest;         /* levels of variables expansion */
11541         IF_FEATURE_SH_MATH(int arinest;)    /* levels of arithmetic expansion */
11542         IF_FEATURE_SH_MATH(int parenlevel;) /* levels of parens in arithmetic */
11543         int dqvarnest;       /* levels of variables expansion within double quotes */
11544
11545         IF_BASH_DOLLAR_SQUOTE(smallint bash_dollar_squote = 0;)
11546
11547         startlinno = g_parsefile->linno;
11548         bqlist = NULL;
11549         quotef = 0;
11550         IF_FEATURE_SH_MATH(prevsyntax = 0;)
11551 #if ENABLE_ASH_EXPAND_PRMT
11552         pssyntax = (syntax == PSSYNTAX);
11553         if (pssyntax)
11554                 syntax = DQSYNTAX;
11555 #endif
11556         dblquote = (syntax == DQSYNTAX);
11557         varnest = 0;
11558         IF_FEATURE_SH_MATH(arinest = 0;)
11559         IF_FEATURE_SH_MATH(parenlevel = 0;)
11560         dqvarnest = 0;
11561
11562         STARTSTACKSTR(out);
11563  loop:
11564         /* For each line, until end of word */
11565         CHECKEND();     /* set c to PEOF if at end of here document */
11566         for (;;) {      /* until end of line or end of word */
11567                 CHECKSTRSPACE(4, out);  /* permit 4 calls to USTPUTC */
11568                 switch (SIT(c, syntax)) {
11569                 case CNL:       /* '\n' */
11570                         if (syntax == BASESYNTAX)
11571                                 goto endword;   /* exit outer loop */
11572                         USTPUTC(c, out);
11573                         nlprompt();
11574                         c = pgetc();
11575                         goto loop;              /* continue outer loop */
11576                 case CWORD:
11577                         USTPUTC(c, out);
11578                         break;
11579                 case CCTL:
11580 #if BASH_DOLLAR_SQUOTE
11581                         if (c == '\\' && bash_dollar_squote) {
11582                                 c = decode_dollar_squote();
11583                                 if (c == '\0') {
11584                                         /* skip $'\000', $'\x00' (like bash) */
11585                                         break;
11586                                 }
11587                                 if (c & 0x100) {
11588                                         /* Unknown escape. Encode as '\z' */
11589                                         c = (unsigned char)c;
11590                                         if (eofmark == NULL || dblquote)
11591                                                 USTPUTC(CTLESC, out);
11592                                         USTPUTC('\\', out);
11593                                 }
11594                         }
11595 #endif
11596                         if (eofmark == NULL || dblquote)
11597                                 USTPUTC(CTLESC, out);
11598                         USTPUTC(c, out);
11599                         break;
11600                 case CBACK:     /* backslash */
11601                         c = pgetc_without_PEOA();
11602                         if (c == PEOF) {
11603                                 USTPUTC(CTLESC, out);
11604                                 USTPUTC('\\', out);
11605                                 pungetc();
11606                         } else if (c == '\n') {
11607                                 nlprompt();
11608                         } else {
11609 #if ENABLE_ASH_EXPAND_PRMT
11610                                 if (c == '$' && pssyntax) {
11611                                         USTPUTC(CTLESC, out);
11612                                         USTPUTC('\\', out);
11613                                 }
11614 #endif
11615                                 /* Backslash is retained if we are in "str" and next char isn't special */
11616                                 if (dblquote
11617                                  && c != '\\'
11618                                  && c != '`'
11619                                  && c != '$'
11620                                  && (c != '"' || eofmark != NULL)
11621                                 ) {
11622                                         USTPUTC('\\', out);
11623                                 }
11624                                 USTPUTC(CTLESC, out);
11625                                 USTPUTC(c, out);
11626                                 quotef = 1;
11627                         }
11628                         break;
11629                 case CSQUOTE:
11630                         syntax = SQSYNTAX;
11631  quotemark:
11632                         if (eofmark == NULL) {
11633                                 USTPUTC(CTLQUOTEMARK, out);
11634                         }
11635                         break;
11636                 case CDQUOTE:
11637                         syntax = DQSYNTAX;
11638                         dblquote = 1;
11639                         goto quotemark;
11640                 case CENDQUOTE:
11641                         IF_BASH_DOLLAR_SQUOTE(bash_dollar_squote = 0;)
11642                         if (eofmark != NULL && varnest == 0) {
11643                                 USTPUTC(c, out);
11644                         } else {
11645                                 if (dqvarnest == 0) {
11646                                         syntax = BASESYNTAX;
11647                                         dblquote = 0;
11648                                 }
11649                                 quotef = 1;
11650                                 goto quotemark;
11651                         }
11652                         break;
11653                 case CVAR:      /* '$' */
11654                         PARSESUB();             /* parse substitution */
11655                         break;
11656                 case CENDVAR:   /* '}' */
11657                         if (varnest > 0) {
11658                                 varnest--;
11659                                 if (dqvarnest > 0) {
11660                                         dqvarnest--;
11661                                 }
11662                                 c = CTLENDVAR;
11663                         }
11664                         USTPUTC(c, out);
11665                         break;
11666 #if ENABLE_FEATURE_SH_MATH
11667                 case CLP:       /* '(' in arithmetic */
11668                         parenlevel++;
11669                         USTPUTC(c, out);
11670                         break;
11671                 case CRP:       /* ')' in arithmetic */
11672                         if (parenlevel > 0) {
11673                                 parenlevel--;
11674                         } else {
11675                                 if (pgetc_eatbnl() == ')') {
11676                                         c = CTLENDARI;
11677                                         if (--arinest == 0) {
11678                                                 syntax = prevsyntax;
11679                                         }
11680                                 } else {
11681                                         /*
11682                                          * unbalanced parens
11683                                          * (don't 2nd guess - no error)
11684                                          */
11685                                         pungetc();
11686                                 }
11687                         }
11688                         USTPUTC(c, out);
11689                         break;
11690 #endif
11691                 case CBQUOTE:   /* '`' */
11692                         PARSEBACKQOLD();
11693                         break;
11694                 case CENDFILE:
11695                         goto endword;           /* exit outer loop */
11696                 case CIGN:
11697                         break;
11698                 default:
11699                         if (varnest == 0) {
11700 #if BASH_REDIR_OUTPUT
11701                                 if (c == '&') {
11702 //Can't call pgetc_eatbnl() here, this requires three-deep pungetc()
11703                                         if (pgetc() == '>')
11704                                                 c = 0x100 + '>'; /* flag &> */
11705                                         pungetc();
11706                                 }
11707 #endif
11708                                 goto endword;   /* exit outer loop */
11709                         }
11710                         IF_ASH_ALIAS(if (c != PEOA))
11711                                 USTPUTC(c, out);
11712                 }
11713                 c = pgetc();
11714         } /* for (;;) */
11715  endword:
11716
11717 #if ENABLE_FEATURE_SH_MATH
11718         if (syntax == ARISYNTAX)
11719                 raise_error_syntax("missing '))'");
11720 #endif
11721         if (syntax != BASESYNTAX && eofmark == NULL)
11722                 raise_error_syntax("unterminated quoted string");
11723         if (varnest != 0) {
11724                 startlinno = g_parsefile->linno;
11725                 /* { */
11726                 raise_error_syntax("missing '}'");
11727         }
11728         USTPUTC('\0', out);
11729         len = out - (char *)stackblock();
11730         out = stackblock();
11731         if (eofmark == NULL) {
11732                 if ((c == '>' || c == '<' IF_BASH_REDIR_OUTPUT( || c == 0x100 + '>'))
11733                  && quotef == 0
11734                 ) {
11735                         if (isdigit_str9(out)) {
11736                                 PARSEREDIR(); /* passed as params: out, c */
11737                                 lasttoken = TREDIR;
11738                                 return lasttoken;
11739                         }
11740                         /* else: non-number X seen, interpret it
11741                          * as "NNNX>file" = "NNNX >file" */
11742                 }
11743                 pungetc();
11744         }
11745         quoteflag = quotef;
11746         backquotelist = bqlist;
11747         grabstackblock(len);
11748         wordtext = out;
11749         lasttoken = TWORD;
11750         return lasttoken;
11751 /* end of readtoken routine */
11752
11753 /*
11754  * Check to see whether we are at the end of the here document.  When this
11755  * is called, c is set to the first character of the next input line.  If
11756  * we are at the end of the here document, this routine sets the c to PEOF.
11757  */
11758 checkend: {
11759         if (eofmark) {
11760 #if ENABLE_ASH_ALIAS
11761                 if (c == PEOA)
11762                         c = pgetc_without_PEOA();
11763 #endif
11764                 if (striptabs) {
11765                         while (c == '\t') {
11766                                 c = pgetc_without_PEOA();
11767                         }
11768                 }
11769                 if (c == *eofmark) {
11770                         if (pfgets(line, sizeof(line)) != NULL) {
11771                                 char *p, *q;
11772                                 int cc;
11773
11774                                 p = line;
11775                                 for (q = eofmark + 1;; p++, q++) {
11776                                         cc = *p;
11777                                         if (cc == '\n')
11778                                                 cc = 0;
11779                                         if (!*q || cc != *q)
11780                                                 break;
11781                                 }
11782                                 if (cc == *q) {
11783                                         c = PEOF;
11784                                         nlnoprompt();
11785                                 } else {
11786                                         pushstring(line, NULL);
11787                                 }
11788                         }
11789                 }
11790         }
11791         goto checkend_return;
11792 }
11793
11794 /*
11795  * Parse a redirection operator.  The variable "out" points to a string
11796  * specifying the fd to be redirected.  The variable "c" contains the
11797  * first character of the redirection operator.
11798  */
11799 parseredir: {
11800         /* out is already checked to be a valid number or "" */
11801         int fd = (*out == '\0' ? -1 : atoi(out));
11802         union node *np;
11803
11804         np = stzalloc(sizeof(struct nfile));
11805         if (c == '>') {
11806                 np->nfile.fd = 1;
11807                 c = pgetc();
11808                 if (c == '>')
11809                         np->type = NAPPEND;
11810                 else if (c == '|')
11811                         np->type = NCLOBBER;
11812                 else if (c == '&')
11813                         np->type = NTOFD;
11814                         /* it also can be NTO2 (>&file), but we can't figure it out yet */
11815                 else {
11816                         np->type = NTO;
11817                         pungetc();
11818                 }
11819         }
11820 #if BASH_REDIR_OUTPUT
11821         else if (c == 0x100 + '>') { /* this flags &> redirection */
11822                 np->nfile.fd = 1;
11823                 pgetc(); /* this is '>', no need to check */
11824                 np->type = NTO2;
11825         }
11826 #endif
11827         else { /* c == '<' */
11828                 /*np->nfile.fd = 0; - stzalloc did it */
11829                 c = pgetc();
11830                 switch (c) {
11831                 case '<':
11832                         if (sizeof(struct nfile) != sizeof(struct nhere)) {
11833                                 np = stzalloc(sizeof(struct nhere));
11834                                 /*np->nfile.fd = 0; - stzalloc did it */
11835                         }
11836                         np->type = NHERE;
11837                         heredoc = stzalloc(sizeof(struct heredoc));
11838                         heredoc->here = np;
11839                         c = pgetc();
11840                         if (c == '-') {
11841                                 heredoc->striptabs = 1;
11842                         } else {
11843                                 /*heredoc->striptabs = 0; - stzalloc did it */
11844                                 pungetc();
11845                         }
11846                         break;
11847
11848                 case '&':
11849                         np->type = NFROMFD;
11850                         break;
11851
11852                 case '>':
11853                         np->type = NFROMTO;
11854                         break;
11855
11856                 default:
11857                         np->type = NFROM;
11858                         pungetc();
11859                         break;
11860                 }
11861         }
11862         if (fd >= 0)
11863                 np->nfile.fd = fd;
11864         redirnode = np;
11865         goto parseredir_return;
11866 }
11867
11868 /*
11869  * Parse a substitution.  At this point, we have read the dollar sign
11870  * and nothing else.
11871  */
11872
11873 /* is_special(c) evaluates to 1 for c in "!#$*-0123456789?@"; 0 otherwise
11874  * (assuming ascii char codes, as the original implementation did) */
11875 #define is_special(c) \
11876         (((unsigned)(c) - 33 < 32) \
11877                         && ((0xc1ff920dU >> ((unsigned)(c) - 33)) & 1))
11878 parsesub: {
11879         unsigned char subtype;
11880         int typeloc;
11881
11882         c = pgetc_eatbnl();
11883         if (c > 255 /* PEOA or PEOF */
11884          || (c != '(' && c != '{' && !is_name(c) && !is_special(c))
11885         ) {
11886 #if BASH_DOLLAR_SQUOTE
11887                 if (syntax != DQSYNTAX && c == '\'')
11888                         bash_dollar_squote = 1;
11889                 else
11890 #endif
11891                         USTPUTC('$', out);
11892                 pungetc();
11893         } else if (c == '(') {
11894                 /* $(command) or $((arith)) */
11895                 if (pgetc_eatbnl() == '(') {
11896 #if ENABLE_FEATURE_SH_MATH
11897                         PARSEARITH();
11898 #else
11899                         raise_error_syntax("you disabled math support for $((arith)) syntax");
11900 #endif
11901                 } else {
11902                         pungetc();
11903                         PARSEBACKQNEW();
11904                 }
11905         } else {
11906                 /* $VAR, $<specialchar>, ${...}, or PEOA/PEOF */
11907                 USTPUTC(CTLVAR, out);
11908                 typeloc = out - (char *)stackblock();
11909                 STADJUST(1, out);
11910                 subtype = VSNORMAL;
11911                 if (c == '{') {
11912                         c = pgetc_eatbnl();
11913                         subtype = 0;
11914                 }
11915  varname:
11916                 if (is_name(c)) {
11917                         /* $[{[#]]NAME[}] */
11918                         do {
11919                                 STPUTC(c, out);
11920                                 c = pgetc_eatbnl();
11921                         } while (is_in_name(c));
11922                 } else if (isdigit(c)) {
11923                         /* $[{[#]]NUM[}] */
11924                         do {
11925                                 STPUTC(c, out);
11926                                 c = pgetc_eatbnl();
11927                         } while (isdigit(c));
11928                 } else if (is_special(c)) {
11929                         /* $[{[#]]<specialchar>[}] */
11930                         int cc = c;
11931
11932                         c = pgetc_eatbnl();
11933                         if (!subtype && cc == '#') {
11934                                 subtype = VSLENGTH;
11935                                 if (c == '_' || isalnum(c))
11936                                         goto varname;
11937                                 cc = c;
11938                                 c = pgetc_eatbnl();
11939                                 if (cc == '}' || c != '}') {
11940                                         pungetc();
11941                                         subtype = 0;
11942                                         c = cc;
11943                                         cc = '#';
11944                                 }
11945                         }
11946                         USTPUTC(cc, out);
11947                 } else {
11948                         goto badsub;
11949                 }
11950                 if (c != '}' && subtype == VSLENGTH) {
11951                         /* ${#VAR didn't end with } */
11952                         goto badsub;
11953                 }
11954
11955                 if (subtype == 0) {
11956                         static const char types[] ALIGN1 = "}-+?=";
11957                         /* ${VAR...} but not $VAR or ${#VAR} */
11958                         /* c == first char after VAR */
11959                         switch (c) {
11960                         case ':':
11961                                 c = pgetc_eatbnl();
11962 #if BASH_SUBSTR
11963                                 /* This check is only needed to not misinterpret
11964                                  * ${VAR:-WORD}, ${VAR:+WORD}, ${VAR:=WORD}, ${VAR:?WORD}
11965                                  * constructs.
11966                                  */
11967                                 if (!strchr(types, c)) {
11968                                         subtype = VSSUBSTR;
11969                                         pungetc();
11970                                         break; /* "goto badsub" is bigger (!) */
11971                                 }
11972 #endif
11973                                 subtype = VSNUL;
11974                                 /*FALLTHROUGH*/
11975                         default: {
11976                                 const char *p = strchr(types, c);
11977                                 if (p == NULL)
11978                                         break;
11979                                 subtype |= p - types + VSNORMAL;
11980                                 break;
11981                         }
11982                         case '%':
11983                         case '#': {
11984                                 int cc = c;
11985                                 subtype = (c == '#' ? VSTRIMLEFT : VSTRIMRIGHT);
11986                                 c = pgetc_eatbnl();
11987                                 if (c != cc)
11988                                         goto badsub;
11989                                 subtype++;
11990                                 break;
11991                         }
11992 #if BASH_PATTERN_SUBST
11993                         case '/':
11994                                 /* ${v/[/]pattern/repl} */
11995 //TODO: encode pattern and repl separately.
11996 // Currently ${v/$var_with_slash/repl} is horribly broken
11997                                 subtype = VSREPLACE;
11998                                 c = pgetc_eatbnl();
11999                                 if (c != '/')
12000                                         goto badsub;
12001                                 subtype++; /* VSREPLACEALL */
12002                                 break;
12003 #endif
12004                         }
12005                 } else {
12006  badsub:
12007                         pungetc();
12008                 }
12009                 ((unsigned char *)stackblock())[typeloc] = subtype;
12010                 if (subtype != VSNORMAL) {
12011                         varnest++;
12012                         if (dblquote)
12013                                 dqvarnest++;
12014                 }
12015                 STPUTC('=', out);
12016         }
12017         goto parsesub_return;
12018 }
12019
12020 /*
12021  * Called to parse command substitutions.  Newstyle is set if the command
12022  * is enclosed inside $(...); nlpp is a pointer to the head of the linked
12023  * list of commands (passed by reference), and savelen is the number of
12024  * characters on the top of the stack which must be preserved.
12025  */
12026 parsebackq: {
12027         struct nodelist **nlpp;
12028         union node *n;
12029         char *str;
12030         size_t savelen;
12031         smallint saveprompt = 0;
12032
12033         str = NULL;
12034         savelen = out - (char *)stackblock();
12035         if (savelen > 0) {
12036                 /*
12037                  * FIXME: this can allocate very large block on stack and SEGV.
12038                  * Example:
12039                  * echo "..<100kbytes>..`true` $(true) `true` ..."
12040                  * allocates 100kb for every command subst. With about
12041                  * a hundred command substitutions stack overflows.
12042                  * With larger prepended string, SEGV happens sooner.
12043                  */
12044                 str = alloca(savelen);
12045                 memcpy(str, stackblock(), savelen);
12046         }
12047
12048         if (oldstyle) {
12049                 /* We must read until the closing backquote, giving special
12050                  * treatment to some slashes, and then push the string and
12051                  * reread it as input, interpreting it normally.
12052                  */
12053                 char *pout;
12054                 size_t psavelen;
12055                 char *pstr;
12056
12057                 STARTSTACKSTR(pout);
12058                 for (;;) {
12059                         int pc;
12060
12061                         setprompt_if(needprompt, 2);
12062                         pc = pgetc();
12063                         switch (pc) {
12064                         case '`':
12065                                 goto done;
12066
12067                         case '\\':
12068                                 pc = pgetc();
12069                                 if (pc == '\n') {
12070                                         nlprompt();
12071                                         /*
12072                                          * If eating a newline, avoid putting
12073                                          * the newline into the new character
12074                                          * stream (via the STPUTC after the
12075                                          * switch).
12076                                          */
12077                                         continue;
12078                                 }
12079                                 if (pc != '\\' && pc != '`' && pc != '$'
12080                                  && (!dblquote || pc != '"')
12081                                 ) {
12082                                         STPUTC('\\', pout);
12083                                 }
12084                                 if (pc <= 255 /* not PEOA or PEOF */) {
12085                                         break;
12086                                 }
12087                                 /* fall through */
12088
12089                         case PEOF:
12090                         IF_ASH_ALIAS(case PEOA:)
12091                                 startlinno = g_parsefile->linno;
12092                                 raise_error_syntax("EOF in backquote substitution");
12093
12094                         case '\n':
12095                                 nlnoprompt();
12096                                 break;
12097
12098                         default:
12099                                 break;
12100                         }
12101                         STPUTC(pc, pout);
12102                 }
12103  done:
12104                 STPUTC('\0', pout);
12105                 psavelen = pout - (char *)stackblock();
12106                 if (psavelen > 0) {
12107                         pstr = grabstackstr(pout);
12108                         setinputstring(pstr);
12109                 }
12110         }
12111         nlpp = &bqlist;
12112         while (*nlpp)
12113                 nlpp = &(*nlpp)->next;
12114         *nlpp = stzalloc(sizeof(**nlpp));
12115         /* (*nlpp)->next = NULL; - stzalloc did it */
12116
12117         if (oldstyle) {
12118                 saveprompt = doprompt;
12119                 doprompt = 0;
12120         }
12121
12122         n = list(2);
12123
12124         if (oldstyle)
12125                 doprompt = saveprompt;
12126         else if (readtoken() != TRP)
12127                 raise_error_unexpected_syntax(TRP);
12128
12129         (*nlpp)->n = n;
12130         if (oldstyle) {
12131                 /*
12132                  * Start reading from old file again, ignoring any pushed back
12133                  * tokens left from the backquote parsing
12134                  */
12135                 popfile();
12136                 tokpushback = 0;
12137         }
12138         while (stackblocksize() <= savelen)
12139                 growstackblock();
12140         STARTSTACKSTR(out);
12141         if (str) {
12142                 memcpy(out, str, savelen);
12143                 STADJUST(savelen, out);
12144         }
12145         USTPUTC(CTLBACKQ, out);
12146         if (oldstyle)
12147                 goto parsebackq_oldreturn;
12148         goto parsebackq_newreturn;
12149 }
12150
12151 #if ENABLE_FEATURE_SH_MATH
12152 /*
12153  * Parse an arithmetic expansion (indicate start of one and set state)
12154  */
12155 parsearith: {
12156         if (++arinest == 1) {
12157                 prevsyntax = syntax;
12158                 syntax = ARISYNTAX;
12159         }
12160         USTPUTC(CTLARI, out);
12161         goto parsearith_return;
12162 }
12163 #endif
12164 } /* end of readtoken */
12165
12166 /*
12167  * Read the next input token.
12168  * If the token is a word, we set backquotelist to the list of cmds in
12169  *      backquotes.  We set quoteflag to true if any part of the word was
12170  *      quoted.
12171  * If the token is TREDIR, then we set redirnode to a structure containing
12172  *      the redirection.
12173  * In all cases, the variable startlinno is set to the number of the line
12174  *      on which the token starts.
12175  *
12176  * [Change comment:  here documents and internal procedures]
12177  * [Readtoken shouldn't have any arguments.  Perhaps we should make the
12178  *  word parsing code into a separate routine.  In this case, readtoken
12179  *  doesn't need to have any internal procedures, but parseword does.
12180  *  We could also make parseoperator in essence the main routine, and
12181  *  have parseword (readtoken1?) handle both words and redirection.]
12182  */
12183 #define NEW_xxreadtoken
12184 #ifdef NEW_xxreadtoken
12185 /* singles must be first! */
12186 static const char xxreadtoken_chars[7] ALIGN1 = {
12187         '\n', '(', ')', /* singles */
12188         '&', '|', ';',  /* doubles */
12189         0
12190 };
12191
12192 #define xxreadtoken_singles 3
12193 #define xxreadtoken_doubles 3
12194
12195 static const char xxreadtoken_tokens[] ALIGN1 = {
12196         TNL, TLP, TRP,          /* only single occurrence allowed */
12197         TBACKGND, TPIPE, TSEMI, /* if single occurrence */
12198         TEOF,                   /* corresponds to trailing nul */
12199         TAND, TOR, TENDCASE     /* if double occurrence */
12200 };
12201
12202 static int
12203 xxreadtoken(void)
12204 {
12205         int c;
12206
12207         if (tokpushback) {
12208                 tokpushback = 0;
12209                 return lasttoken;
12210         }
12211         setprompt_if(needprompt, 2);
12212         startlinno = g_parsefile->linno;
12213         for (;;) {                      /* until token or start of word found */
12214                 c = pgetc();
12215                 if (c == ' ' || c == '\t' IF_ASH_ALIAS( || c == PEOA))
12216                         continue;
12217
12218                 if (c == '#') {
12219                         while ((c = pgetc()) != '\n' && c != PEOF)
12220                                 continue;
12221                         pungetc();
12222                 } else if (c == '\\') {
12223                         if (pgetc() != '\n') {
12224                                 pungetc();
12225                                 break; /* return readtoken1(...) */
12226                         }
12227                         nlprompt();
12228                 } else {
12229                         const char *p;
12230
12231                         p = xxreadtoken_chars + sizeof(xxreadtoken_chars) - 1;
12232                         if (c != PEOF) {
12233                                 if (c == '\n') {
12234                                         nlnoprompt();
12235                                 }
12236
12237                                 p = strchr(xxreadtoken_chars, c);
12238                                 if (p == NULL)
12239                                         break; /* return readtoken1(...) */
12240
12241                                 if ((int)(p - xxreadtoken_chars) >= xxreadtoken_singles) {
12242                                         int cc = pgetc();
12243                                         if (cc == c) {    /* double occurrence? */
12244                                                 p += xxreadtoken_doubles + 1;
12245                                         } else {
12246                                                 pungetc();
12247 #if BASH_REDIR_OUTPUT
12248                                                 if (c == '&' && cc == '>') /* &> */
12249                                                         break; /* return readtoken1(...) */
12250 #endif
12251                                         }
12252                                 }
12253                         }
12254                         lasttoken = xxreadtoken_tokens[p - xxreadtoken_chars];
12255                         return lasttoken;
12256                 }
12257         } /* for (;;) */
12258
12259         return readtoken1(c, BASESYNTAX, (char *) NULL, 0);
12260 }
12261 #else /* old xxreadtoken */
12262 #define RETURN(token)   return lasttoken = token
12263 static int
12264 xxreadtoken(void)
12265 {
12266         int c;
12267
12268         if (tokpushback) {
12269                 tokpushback = 0;
12270                 return lasttoken;
12271         }
12272         setprompt_if(needprompt, 2);
12273         startlinno = g_parsefile->linno;
12274         for (;;) {      /* until token or start of word found */
12275                 c = pgetc();
12276                 switch (c) {
12277                 case ' ': case '\t':
12278                 IF_ASH_ALIAS(case PEOA:)
12279                         continue;
12280                 case '#':
12281                         while ((c = pgetc()) != '\n' && c != PEOF)
12282                                 continue;
12283                         pungetc();
12284                         continue;
12285                 case '\\':
12286                         if (pgetc() == '\n') {
12287                                 nlprompt();
12288                                 continue;
12289                         }
12290                         pungetc();
12291                         goto breakloop;
12292                 case '\n':
12293                         nlnoprompt();
12294                         RETURN(TNL);
12295                 case PEOF:
12296                         RETURN(TEOF);
12297                 case '&':
12298                         if (pgetc() == '&')
12299                                 RETURN(TAND);
12300                         pungetc();
12301                         RETURN(TBACKGND);
12302                 case '|':
12303                         if (pgetc() == '|')
12304                                 RETURN(TOR);
12305                         pungetc();
12306                         RETURN(TPIPE);
12307                 case ';':
12308                         if (pgetc() == ';')
12309                                 RETURN(TENDCASE);
12310                         pungetc();
12311                         RETURN(TSEMI);
12312                 case '(':
12313                         RETURN(TLP);
12314                 case ')':
12315                         RETURN(TRP);
12316                 default:
12317                         goto breakloop;
12318                 }
12319         }
12320  breakloop:
12321         return readtoken1(c, BASESYNTAX, (char *)NULL, 0);
12322 #undef RETURN
12323 }
12324 #endif /* old xxreadtoken */
12325
12326 static int
12327 readtoken(void)
12328 {
12329         int t;
12330         int kwd = checkkwd;
12331 #if DEBUG
12332         smallint alreadyseen = tokpushback;
12333 #endif
12334
12335 #if ENABLE_ASH_ALIAS
12336  top:
12337 #endif
12338
12339         t = xxreadtoken();
12340
12341         /*
12342          * eat newlines
12343          */
12344         if (kwd & CHKNL) {
12345                 while (t == TNL) {
12346                         parseheredoc();
12347                         t = xxreadtoken();
12348                 }
12349         }
12350
12351         if (t != TWORD || quoteflag) {
12352                 goto out;
12353         }
12354
12355         /*
12356          * check for keywords
12357          */
12358         if (kwd & CHKKWD) {
12359                 const char *const *pp;
12360
12361                 pp = findkwd(wordtext);
12362                 if (pp) {
12363                         lasttoken = t = pp - tokname_array;
12364                         TRACE(("keyword '%s' recognized\n", tokname_array[t]));
12365                         goto out;
12366                 }
12367         }
12368
12369         if (checkkwd & CHKALIAS) {
12370 #if ENABLE_ASH_ALIAS
12371                 struct alias *ap;
12372                 ap = lookupalias(wordtext, 1);
12373                 if (ap != NULL) {
12374                         if (*ap->val) {
12375                                 pushstring(ap->val, ap);
12376                         }
12377                         goto top;
12378                 }
12379 #endif
12380         }
12381  out:
12382         checkkwd = 0;
12383 #if DEBUG
12384         if (!alreadyseen)
12385                 TRACE(("token '%s' %s\n", tokname_array[t], t == TWORD ? wordtext : ""));
12386         else
12387                 TRACE(("reread token '%s' %s\n", tokname_array[t], t == TWORD ? wordtext : ""));
12388 #endif
12389         return t;
12390 }
12391
12392 static int
12393 peektoken(void)
12394 {
12395         int t;
12396
12397         t = readtoken();
12398         tokpushback = 1;
12399         return t;
12400 }
12401
12402 /*
12403  * Read and parse a command.  Returns NODE_EOF on end of file.
12404  * (NULL is a valid parse tree indicating a blank line.)
12405  */
12406 static union node *
12407 parsecmd(int interact)
12408 {
12409         tokpushback = 0;
12410         checkkwd = 0;
12411         heredoclist = 0;
12412         doprompt = interact;
12413         setprompt_if(doprompt, doprompt);
12414         needprompt = 0;
12415         return list(1);
12416 }
12417
12418 /*
12419  * Input any here documents.
12420  */
12421 static void
12422 parseheredoc(void)
12423 {
12424         struct heredoc *here;
12425         union node *n;
12426
12427         here = heredoclist;
12428         heredoclist = NULL;
12429
12430         while (here) {
12431                 setprompt_if(needprompt, 2);
12432                 readtoken1(pgetc(), here->here->type == NHERE ? SQSYNTAX : DQSYNTAX,
12433                                 here->eofmark, here->striptabs);
12434                 n = stzalloc(sizeof(struct narg));
12435                 n->narg.type = NARG;
12436                 /*n->narg.next = NULL; - stzalloc did it */
12437                 n->narg.text = wordtext;
12438                 n->narg.backquote = backquotelist;
12439                 here->here->nhere.doc = n;
12440                 here = here->next;
12441         }
12442 }
12443
12444
12445 /*
12446  * called by editline -- any expansions to the prompt should be added here.
12447  */
12448 static const char *
12449 expandstr(const char *ps)
12450 {
12451         union node n;
12452         int saveprompt;
12453
12454         /* XXX Fix (char *) cast. It _is_ a bug. ps is variable's value,
12455          * and token processing _can_ alter it (delete NULs etc). */
12456         setinputstring((char *)ps);
12457
12458         saveprompt = doprompt;
12459         doprompt = 0;
12460         readtoken1(pgetc(), PSSYNTAX, nullstr, 0);
12461         doprompt = saveprompt;
12462
12463         popfile();
12464
12465         n.narg.type = NARG;
12466         n.narg.next = NULL;
12467         n.narg.text = wordtext;
12468         n.narg.backquote = backquotelist;
12469
12470         expandarg(&n, NULL, EXP_QUOTED);
12471         return stackblock();
12472 }
12473
12474 /*
12475  * Execute a command or commands contained in a string.
12476  */
12477 static int
12478 evalstring(char *s, int flags)
12479 {
12480         struct jmploc *volatile savehandler;
12481         struct jmploc jmploc;
12482         int ex;
12483
12484         union node *n;
12485         struct stackmark smark;
12486         int status;
12487
12488         s = sstrdup(s);
12489         setinputstring(s);
12490         setstackmark(&smark);
12491
12492         status = 0;
12493         /* On exception inside execution loop, we must popfile().
12494          * Try interactively:
12495          *      readonly a=a
12496          *      command eval "a=b"  # throws "is read only" error
12497          * "command BLTIN" is not supposed to abort (even in non-interactive use).
12498          * But if we skip popfile(), we hit EOF in eval's string, and exit.
12499          */
12500         savehandler = exception_handler;
12501         ex = setjmp(jmploc.loc);
12502         if (ex)
12503                 goto out;
12504         exception_handler = &jmploc;
12505
12506         while ((n = parsecmd(0)) != NODE_EOF) {
12507                 int i;
12508
12509                 i = evaltree(n, flags);
12510                 if (n)
12511                         status = i;
12512                 popstackmark(&smark);
12513                 if (evalskip)
12514                         break;
12515         }
12516  out:
12517         popstackmark(&smark);
12518         popfile();
12519         stunalloc(s);
12520
12521         exception_handler = savehandler;
12522         if (ex)
12523                 longjmp(exception_handler->loc, ex);
12524
12525         return status;
12526 }
12527
12528 /*
12529  * The eval command.
12530  */
12531 static int FAST_FUNC
12532 evalcmd(int argc UNUSED_PARAM, char **argv, int flags)
12533 {
12534         char *p;
12535         char *concat;
12536
12537         if (argv[1]) {
12538                 p = argv[1];
12539                 argv += 2;
12540                 if (argv[0]) {
12541                         STARTSTACKSTR(concat);
12542                         for (;;) {
12543                                 concat = stack_putstr(p, concat);
12544                                 p = *argv++;
12545                                 if (p == NULL)
12546                                         break;
12547                                 STPUTC(' ', concat);
12548                         }
12549                         STPUTC('\0', concat);
12550                         p = grabstackstr(concat);
12551                 }
12552                 return evalstring(p, flags & EV_TESTED);
12553         }
12554         return 0;
12555 }
12556
12557 /*
12558  * Read and execute commands.
12559  * "Top" is nonzero for the top level command loop;
12560  * it turns on prompting if the shell is interactive.
12561  */
12562 static int
12563 cmdloop(int top)
12564 {
12565         union node *n;
12566         struct stackmark smark;
12567         int inter;
12568         int status = 0;
12569         int numeof = 0;
12570
12571         TRACE(("cmdloop(%d) called\n", top));
12572         for (;;) {
12573                 int skip;
12574
12575                 setstackmark(&smark);
12576 #if JOBS
12577                 if (doing_jobctl)
12578                         showjobs(SHOW_CHANGED|SHOW_STDERR);
12579 #endif
12580                 inter = 0;
12581                 if (iflag && top) {
12582                         inter++;
12583                         chkmail();
12584                 }
12585                 n = parsecmd(inter);
12586 #if DEBUG
12587                 if (DEBUG > 2 && debug && (n != NODE_EOF))
12588                         showtree(n);
12589 #endif
12590                 if (n == NODE_EOF) {
12591                         if (!top || numeof >= 50)
12592                                 break;
12593                         if (!stoppedjobs()) {
12594                                 if (!Iflag)
12595                                         break;
12596                                 out2str("\nUse \"exit\" to leave shell.\n");
12597                         }
12598                         numeof++;
12599                 } else if (nflag == 0) {
12600                         int i;
12601
12602                         /* job_warning can only be 2,1,0. Here 2->1, 1/0->0 */
12603                         job_warning >>= 1;
12604                         numeof = 0;
12605                         i = evaltree(n, 0);
12606                         if (n)
12607                                 status = i;
12608                 }
12609                 popstackmark(&smark);
12610                 skip = evalskip;
12611
12612                 if (skip) {
12613                         evalskip &= ~SKIPFUNC;
12614                         break;
12615                 }
12616         }
12617         return status;
12618 }
12619
12620 /*
12621  * Take commands from a file.  To be compatible we should do a path
12622  * search for the file, which is necessary to find sub-commands.
12623  */
12624 static char *
12625 find_dot_file(char *name)
12626 {
12627         char *fullname;
12628         const char *path = pathval();
12629         struct stat statb;
12630
12631         /* don't try this for absolute or relative paths */
12632         if (strchr(name, '/'))
12633                 return name;
12634
12635         while ((fullname = path_advance(&path, name)) != NULL) {
12636                 if ((stat(fullname, &statb) == 0) && S_ISREG(statb.st_mode)) {
12637                         /*
12638                          * Don't bother freeing here, since it will
12639                          * be freed by the caller.
12640                          */
12641                         return fullname;
12642                 }
12643                 if (fullname != name)
12644                         stunalloc(fullname);
12645         }
12646
12647         /* not found in the PATH */
12648         ash_msg_and_raise_error("%s: not found", name);
12649         /* NOTREACHED */
12650 }
12651
12652 static int FAST_FUNC
12653 dotcmd(int argc_ UNUSED_PARAM, char **argv_ UNUSED_PARAM)
12654 {
12655         /* "false; . empty_file; echo $?" should print 0, not 1: */
12656         int status = 0;
12657         char *fullname;
12658         char **argv;
12659         char *args_need_save;
12660         struct strlist *sp;
12661         volatile struct shparam saveparam;
12662
12663         for (sp = cmdenviron; sp; sp = sp->next)
12664                 setvareq(ckstrdup(sp->text), VSTRFIXED | VTEXTFIXED);
12665
12666         nextopt(nullstr); /* handle possible "--" */
12667         argv = argptr;
12668
12669         if (!argv[0]) {
12670                 /* bash says: "bash: .: filename argument required" */
12671                 return 2; /* bash compat */
12672         }
12673
12674         /* This aborts if file isn't found, which is POSIXly correct.
12675          * bash returns exitcode 1 instead.
12676          */
12677         fullname = find_dot_file(argv[0]);
12678         argv++;
12679         args_need_save = argv[0];
12680         if (args_need_save) { /* ". FILE ARGS", and ARGS are not empty */
12681                 int argc;
12682                 saveparam = shellparam;
12683                 shellparam.malloced = 0;
12684                 argc = 1;
12685                 while (argv[argc])
12686                         argc++;
12687                 shellparam.nparam = argc;
12688                 shellparam.p = argv;
12689         };
12690
12691         /* This aborts if file can't be opened, which is POSIXly correct.
12692          * bash returns exitcode 1 instead.
12693          */
12694         setinputfile(fullname, INPUT_PUSH_FILE);
12695         commandname = fullname;
12696         status = cmdloop(0);
12697         popfile();
12698
12699         if (args_need_save) {
12700                 freeparam(&shellparam);
12701                 shellparam = saveparam;
12702         };
12703
12704         return status;
12705 }
12706
12707 static int FAST_FUNC
12708 exitcmd(int argc UNUSED_PARAM, char **argv)
12709 {
12710         if (stoppedjobs())
12711                 return 0;
12712         if (argv[1])
12713                 exitstatus = number(argv[1]);
12714         raise_exception(EXEXIT);
12715         /* NOTREACHED */
12716 }
12717
12718 /*
12719  * Read a file containing shell functions.
12720  */
12721 static void
12722 readcmdfile(char *name)
12723 {
12724         setinputfile(name, INPUT_PUSH_FILE);
12725         cmdloop(0);
12726         popfile();
12727 }
12728
12729
12730 /* ============ find_command inplementation */
12731
12732 /*
12733  * Resolve a command name.  If you change this routine, you may have to
12734  * change the shellexec routine as well.
12735  */
12736 static void
12737 find_command(char *name, struct cmdentry *entry, int act, const char *path)
12738 {
12739         struct tblentry *cmdp;
12740         int idx;
12741         int prev;
12742         char *fullname;
12743         struct stat statb;
12744         int e;
12745         int updatetbl;
12746         struct builtincmd *bcmd;
12747
12748         /* If name contains a slash, don't use PATH or hash table */
12749         if (strchr(name, '/') != NULL) {
12750                 entry->u.index = -1;
12751                 if (act & DO_ABS) {
12752                         while (stat(name, &statb) < 0) {
12753 #ifdef SYSV
12754                                 if (errno == EINTR)
12755                                         continue;
12756 #endif
12757                                 entry->cmdtype = CMDUNKNOWN;
12758                                 return;
12759                         }
12760                 }
12761                 entry->cmdtype = CMDNORMAL;
12762                 return;
12763         }
12764
12765 /* #if ENABLE_FEATURE_SH_STANDALONE... moved after builtin check */
12766
12767         updatetbl = (path == pathval());
12768         if (!updatetbl) {
12769                 act |= DO_ALTPATH;
12770                 if (strstr(path, "%builtin") != NULL)
12771                         act |= DO_ALTBLTIN;
12772         }
12773
12774         /* If name is in the table, check answer will be ok */
12775         cmdp = cmdlookup(name, 0);
12776         if (cmdp != NULL) {
12777                 int bit;
12778
12779                 switch (cmdp->cmdtype) {
12780                 default:
12781 #if DEBUG
12782                         abort();
12783 #endif
12784                 case CMDNORMAL:
12785                         bit = DO_ALTPATH;
12786                         break;
12787                 case CMDFUNCTION:
12788                         bit = DO_NOFUNC;
12789                         break;
12790                 case CMDBUILTIN:
12791                         bit = DO_ALTBLTIN;
12792                         break;
12793                 }
12794                 if (act & bit) {
12795                         updatetbl = 0;
12796                         cmdp = NULL;
12797                 } else if (cmdp->rehash == 0)
12798                         /* if not invalidated by cd, we're done */
12799                         goto success;
12800         }
12801
12802         /* If %builtin not in path, check for builtin next */
12803         bcmd = find_builtin(name);
12804         if (bcmd) {
12805                 if (IS_BUILTIN_REGULAR(bcmd))
12806                         goto builtin_success;
12807                 if (act & DO_ALTPATH) {
12808                         if (!(act & DO_ALTBLTIN))
12809                                 goto builtin_success;
12810                 } else if (builtinloc <= 0) {
12811                         goto builtin_success;
12812                 }
12813         }
12814
12815 #if ENABLE_FEATURE_SH_STANDALONE
12816         {
12817                 int applet_no = find_applet_by_name(name);
12818                 if (applet_no >= 0) {
12819                         entry->cmdtype = CMDNORMAL;
12820                         entry->u.index = -2 - applet_no;
12821                         return;
12822                 }
12823         }
12824 #endif
12825
12826         /* We have to search path. */
12827         prev = -1;              /* where to start */
12828         if (cmdp && cmdp->rehash) {     /* doing a rehash */
12829                 if (cmdp->cmdtype == CMDBUILTIN)
12830                         prev = builtinloc;
12831                 else
12832                         prev = cmdp->param.index;
12833         }
12834
12835         e = ENOENT;
12836         idx = -1;
12837  loop:
12838         while ((fullname = path_advance(&path, name)) != NULL) {
12839                 stunalloc(fullname);
12840                 /* NB: code below will still use fullname
12841                  * despite it being "unallocated" */
12842                 idx++;
12843                 if (pathopt) {
12844                         if (prefix(pathopt, "builtin")) {
12845                                 if (bcmd)
12846                                         goto builtin_success;
12847                                 continue;
12848                         }
12849                         if ((act & DO_NOFUNC)
12850                          || !prefix(pathopt, "func")
12851                         ) {     /* ignore unimplemented options */
12852                                 continue;
12853                         }
12854                 }
12855                 /* if rehash, don't redo absolute path names */
12856                 if (fullname[0] == '/' && idx <= prev) {
12857                         if (idx < prev)
12858                                 continue;
12859                         TRACE(("searchexec \"%s\": no change\n", name));
12860                         goto success;
12861                 }
12862                 while (stat(fullname, &statb) < 0) {
12863 #ifdef SYSV
12864                         if (errno == EINTR)
12865                                 continue;
12866 #endif
12867                         if (errno != ENOENT && errno != ENOTDIR)
12868                                 e = errno;
12869                         goto loop;
12870                 }
12871                 e = EACCES;     /* if we fail, this will be the error */
12872                 if (!S_ISREG(statb.st_mode))
12873                         continue;
12874                 if (pathopt) {          /* this is a %func directory */
12875                         stalloc(strlen(fullname) + 1);
12876                         /* NB: stalloc will return space pointed by fullname
12877                          * (because we don't have any intervening allocations
12878                          * between stunalloc above and this stalloc) */
12879                         readcmdfile(fullname);
12880                         cmdp = cmdlookup(name, 0);
12881                         if (cmdp == NULL || cmdp->cmdtype != CMDFUNCTION)
12882                                 ash_msg_and_raise_error("%s not defined in %s", name, fullname);
12883                         stunalloc(fullname);
12884                         goto success;
12885                 }
12886                 TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
12887                 if (!updatetbl) {
12888                         entry->cmdtype = CMDNORMAL;
12889                         entry->u.index = idx;
12890                         return;
12891                 }
12892                 INT_OFF;
12893                 cmdp = cmdlookup(name, 1);
12894                 cmdp->cmdtype = CMDNORMAL;
12895                 cmdp->param.index = idx;
12896                 INT_ON;
12897                 goto success;
12898         }
12899
12900         /* We failed.  If there was an entry for this command, delete it */
12901         if (cmdp && updatetbl)
12902                 delete_cmd_entry();
12903         if (act & DO_ERR)
12904                 ash_msg("%s: %s", name, errmsg(e, "not found"));
12905         entry->cmdtype = CMDUNKNOWN;
12906         return;
12907
12908  builtin_success:
12909         if (!updatetbl) {
12910                 entry->cmdtype = CMDBUILTIN;
12911                 entry->u.cmd = bcmd;
12912                 return;
12913         }
12914         INT_OFF;
12915         cmdp = cmdlookup(name, 1);
12916         cmdp->cmdtype = CMDBUILTIN;
12917         cmdp->param.cmd = bcmd;
12918         INT_ON;
12919  success:
12920         cmdp->rehash = 0;
12921         entry->cmdtype = cmdp->cmdtype;
12922         entry->u = cmdp->param;
12923 }
12924
12925
12926 /*
12927  * The trap builtin.
12928  */
12929 static int FAST_FUNC
12930 trapcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
12931 {
12932         char *action;
12933         char **ap;
12934         int signo, exitcode;
12935
12936         nextopt(nullstr);
12937         ap = argptr;
12938         if (!*ap) {
12939                 for (signo = 0; signo < NSIG; signo++) {
12940                         char *tr = trap_ptr[signo];
12941                         if (tr) {
12942                                 /* note: bash adds "SIG", but only if invoked
12943                                  * as "bash". If called as "sh", or if set -o posix,
12944                                  * then it prints short signal names.
12945                                  * We are printing short names: */
12946                                 out1fmt("trap -- %s %s\n",
12947                                                 single_quote(tr),
12948                                                 get_signame(signo));
12949                 /* trap_ptr != trap only if we are in special-cased `trap` code.
12950                  * In this case, we will exit very soon, no need to free(). */
12951                                 /* if (trap_ptr != trap && tp[0]) */
12952                                 /*      free(tr); */
12953                         }
12954                 }
12955                 /*
12956                 if (trap_ptr != trap) {
12957                         free(trap_ptr);
12958                         trap_ptr = trap;
12959                 }
12960                 */
12961                 return 0;
12962         }
12963
12964         action = NULL;
12965         if (ap[1])
12966                 action = *ap++;
12967         exitcode = 0;
12968         while (*ap) {
12969                 signo = get_signum(*ap);
12970                 if (signo < 0 || signo >= NSIG) {
12971                         /* Mimic bash message exactly */
12972                         ash_msg("%s: invalid signal specification", *ap);
12973                         exitcode = 1;
12974                         goto next;
12975                 }
12976                 INT_OFF;
12977                 if (action) {
12978                         if (LONE_DASH(action))
12979                                 action = NULL;
12980                         else {
12981                                 if (action[0]) /* not NULL and not "" and not "-" */
12982                                         may_have_traps = 1;
12983                                 action = ckstrdup(action);
12984                         }
12985                 }
12986                 free(trap[signo]);
12987                 trap[signo] = action;
12988                 if (signo != 0)
12989                         setsignal(signo);
12990                 INT_ON;
12991  next:
12992                 ap++;
12993         }
12994         return exitcode;
12995 }
12996
12997
12998 /* ============ Builtins */
12999
13000 #if ENABLE_ASH_HELP
13001 static int FAST_FUNC
13002 helpcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
13003 {
13004         unsigned col;
13005         unsigned i;
13006
13007         out1fmt(
13008                 "Built-in commands:\n"
13009                 "------------------\n");
13010         for (col = 0, i = 0; i < ARRAY_SIZE(builtintab); i++) {
13011                 col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '),
13012                                         builtintab[i].name + 1);
13013                 if (col > 60) {
13014                         out1fmt("\n");
13015                         col = 0;
13016                 }
13017         }
13018 # if ENABLE_FEATURE_SH_STANDALONE
13019         {
13020                 const char *a = applet_names;
13021                 while (*a) {
13022                         col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '), a);
13023                         if (col > 60) {
13024                                 out1fmt("\n");
13025                                 col = 0;
13026                         }
13027                         while (*a++ != '\0')
13028                                 continue;
13029                 }
13030         }
13031 # endif
13032         newline_and_flush(stdout);
13033         return EXIT_SUCCESS;
13034 }
13035 #endif
13036
13037 #if MAX_HISTORY
13038 static int FAST_FUNC
13039 historycmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
13040 {
13041         show_history(line_input_state);
13042         return EXIT_SUCCESS;
13043 }
13044 #endif
13045
13046 /*
13047  * The export and readonly commands.
13048  */
13049 static int FAST_FUNC
13050 exportcmd(int argc UNUSED_PARAM, char **argv)
13051 {
13052         struct var *vp;
13053         char *name;
13054         const char *p;
13055         char **aptr;
13056         char opt;
13057         int flag;
13058         int flag_off;
13059
13060         /* "readonly" in bash accepts, but ignores -n.
13061          * We do the same: it saves a conditional in nextopt's param.
13062          */
13063         flag_off = 0;
13064         while ((opt = nextopt("np")) != '\0') {
13065                 if (opt == 'n')
13066                         flag_off = VEXPORT;
13067         }
13068         flag = VEXPORT;
13069         if (argv[0][0] == 'r') {
13070                 flag = VREADONLY;
13071                 flag_off = 0; /* readonly ignores -n */
13072         }
13073         flag_off = ~flag_off;
13074
13075         /*if (opt_p_not_specified) - bash doesn't check this. Try "export -p NAME" */
13076         {
13077                 aptr = argptr;
13078                 name = *aptr;
13079                 if (name) {
13080                         do {
13081                                 p = strchr(name, '=');
13082                                 if (p != NULL) {
13083                                         p++;
13084                                 } else {
13085                                         vp = *findvar(hashvar(name), name);
13086                                         if (vp) {
13087                                                 vp->flags = ((vp->flags | flag) & flag_off);
13088                                                 continue;
13089                                         }
13090                                 }
13091                                 setvar(name, p, (flag & flag_off));
13092                         } while ((name = *++aptr) != NULL);
13093                         return 0;
13094                 }
13095         }
13096
13097         /* No arguments. Show the list of exported or readonly vars.
13098          * -n is ignored.
13099          */
13100         showvars(argv[0], flag, 0);
13101         return 0;
13102 }
13103
13104 /*
13105  * Delete a function if it exists.
13106  */
13107 static void
13108 unsetfunc(const char *name)
13109 {
13110         struct tblentry *cmdp;
13111
13112         cmdp = cmdlookup(name, 0);
13113         if (cmdp != NULL && cmdp->cmdtype == CMDFUNCTION)
13114                 delete_cmd_entry();
13115 }
13116
13117 /*
13118  * The unset builtin command.  We unset the function before we unset the
13119  * variable to allow a function to be unset when there is a readonly variable
13120  * with the same name.
13121  */
13122 static int FAST_FUNC
13123 unsetcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
13124 {
13125         char **ap;
13126         int i;
13127         int flag = 0;
13128         int ret = 0;
13129
13130         while ((i = nextopt("vf")) != 0) {
13131                 flag = i;
13132         }
13133
13134         for (ap = argptr; *ap; ap++) {
13135                 if (flag != 'f') {
13136                         i = unsetvar(*ap);
13137                         ret |= i;
13138                         if (!(i & 2))
13139                                 continue;
13140                 }
13141                 if (flag != 'v')
13142                         unsetfunc(*ap);
13143         }
13144         return ret & 1;
13145 }
13146
13147 static const unsigned char timescmd_str[] ALIGN1 = {
13148         ' ',  offsetof(struct tms, tms_utime),
13149         '\n', offsetof(struct tms, tms_stime),
13150         ' ',  offsetof(struct tms, tms_cutime),
13151         '\n', offsetof(struct tms, tms_cstime),
13152         0
13153 };
13154 static int FAST_FUNC
13155 timescmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
13156 {
13157         unsigned long clk_tck, s, t;
13158         const unsigned char *p;
13159         struct tms buf;
13160
13161         clk_tck = bb_clk_tck();
13162         times(&buf);
13163
13164         p = timescmd_str;
13165         do {
13166                 t = *(clock_t *)(((char *) &buf) + p[1]);
13167                 s = t / clk_tck;
13168                 t = t % clk_tck;
13169                 out1fmt("%lum%lu.%03lus%c",
13170                         s / 60, s % 60,
13171                         (t * 1000) / clk_tck,
13172                         p[0]);
13173                 p += 2;
13174         } while (*p);
13175
13176         return 0;
13177 }
13178
13179 #if ENABLE_FEATURE_SH_MATH
13180 /*
13181  * The let builtin. Partially stolen from GNU Bash, the Bourne Again SHell.
13182  * Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
13183  *
13184  * Copyright (C) 2003 Vladimir Oleynik <dzo@simtreas.ru>
13185  */
13186 static int FAST_FUNC
13187 letcmd(int argc UNUSED_PARAM, char **argv)
13188 {
13189         arith_t i;
13190
13191         argv++;
13192         if (!*argv)
13193                 ash_msg_and_raise_error("expression expected");
13194         do {
13195                 i = ash_arith(*argv);
13196         } while (*++argv);
13197
13198         return !i;
13199 }
13200 #endif
13201
13202 /*
13203  * The read builtin. Options:
13204  *      -r              Do not interpret '\' specially
13205  *      -s              Turn off echo (tty only)
13206  *      -n NCHARS       Read NCHARS max
13207  *      -p PROMPT       Display PROMPT on stderr (if input is from tty)
13208  *      -t SECONDS      Timeout after SECONDS (tty or pipe only)
13209  *      -u FD           Read from given FD instead of fd 0
13210  * This uses unbuffered input, which may be avoidable in some cases.
13211  * TODO: bash also has:
13212  *      -a ARRAY        Read into array[0],[1],etc
13213  *      -d DELIM        End on DELIM char, not newline
13214  *      -e              Use line editing (tty only)
13215  */
13216 static int FAST_FUNC
13217 readcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
13218 {
13219         char *opt_n = NULL;
13220         char *opt_p = NULL;
13221         char *opt_t = NULL;
13222         char *opt_u = NULL;
13223         int read_flags = 0;
13224         const char *r;
13225         int i;
13226
13227         while ((i = nextopt("p:u:rt:n:s")) != '\0') {
13228                 switch (i) {
13229                 case 'p':
13230                         opt_p = optionarg;
13231                         break;
13232                 case 'n':
13233                         opt_n = optionarg;
13234                         break;
13235                 case 's':
13236                         read_flags |= BUILTIN_READ_SILENT;
13237                         break;
13238                 case 't':
13239                         opt_t = optionarg;
13240                         break;
13241                 case 'r':
13242                         read_flags |= BUILTIN_READ_RAW;
13243                         break;
13244                 case 'u':
13245                         opt_u = optionarg;
13246                         break;
13247                 default:
13248                         break;
13249                 }
13250         }
13251
13252         /* "read -s" needs to save/restore termios, can't allow ^C
13253          * to jump out of it.
13254          */
13255  again:
13256         INT_OFF;
13257         r = shell_builtin_read(setvar0,
13258                 argptr,
13259                 bltinlookup("IFS"), /* can be NULL */
13260                 read_flags,
13261                 opt_n,
13262                 opt_p,
13263                 opt_t,
13264                 opt_u
13265         );
13266         INT_ON;
13267
13268         if ((uintptr_t)r == 1 && errno == EINTR) {
13269                 /* to get SIGCHLD: sleep 1 & read x; echo $x */
13270                 if (pending_sig == 0)
13271                         goto again;
13272         }
13273
13274         if ((uintptr_t)r > 1)
13275                 ash_msg_and_raise_error(r);
13276
13277         return (uintptr_t)r;
13278 }
13279
13280 static int FAST_FUNC
13281 umaskcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
13282 {
13283         static const char permuser[3] ALIGN1 = "ogu";
13284
13285         mode_t mask;
13286         int symbolic_mode = 0;
13287
13288         while (nextopt("S") != '\0') {
13289                 symbolic_mode = 1;
13290         }
13291
13292         INT_OFF;
13293         mask = umask(0);
13294         umask(mask);
13295         INT_ON;
13296
13297         if (*argptr == NULL) {
13298                 if (symbolic_mode) {
13299                         char buf[sizeof(",u=rwx,g=rwx,o=rwx")];
13300                         char *p = buf;
13301                         int i;
13302
13303                         i = 2;
13304                         for (;;) {
13305                                 *p++ = ',';
13306                                 *p++ = permuser[i];
13307                                 *p++ = '=';
13308                                 /* mask is 0..0uuugggooo. i=2 selects uuu bits */
13309                                 if (!(mask & 0400)) *p++ = 'r';
13310                                 if (!(mask & 0200)) *p++ = 'w';
13311                                 if (!(mask & 0100)) *p++ = 'x';
13312                                 mask <<= 3;
13313                                 if (--i < 0)
13314                                         break;
13315                         }
13316                         *p = '\0';
13317                         puts(buf + 1);
13318                 } else {
13319                         out1fmt("%04o\n", mask);
13320                 }
13321         } else {
13322                 char *modestr = *argptr;
13323                 /* numeric umasks are taken as-is */
13324                 /* symbolic umasks are inverted: "umask a=rx" calls umask(222) */
13325                 if (!isdigit(modestr[0]))
13326                         mask ^= 0777;
13327                 mask = bb_parse_mode(modestr, mask);
13328                 if ((unsigned)mask > 0777) {
13329                         ash_msg_and_raise_error("illegal mode: %s", modestr);
13330                 }
13331                 if (!isdigit(modestr[0]))
13332                         mask ^= 0777;
13333                 umask(mask);
13334         }
13335         return 0;
13336 }
13337
13338 static int FAST_FUNC
13339 ulimitcmd(int argc UNUSED_PARAM, char **argv)
13340 {
13341         return shell_builtin_ulimit(argv);
13342 }
13343
13344 /* ============ main() and helpers */
13345
13346 /*
13347  * Called to exit the shell.
13348  */
13349 static void
13350 exitshell(void)
13351 {
13352         struct jmploc loc;
13353         char *p;
13354         int status;
13355
13356 #if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
13357         save_history(line_input_state);
13358 #endif
13359         status = exitstatus;
13360         TRACE(("pid %d, exitshell(%d)\n", getpid(), status));
13361         if (setjmp(loc.loc)) {
13362                 if (exception_type == EXEXIT)
13363                         status = exitstatus;
13364                 goto out;
13365         }
13366         exception_handler = &loc;
13367         p = trap[0];
13368         if (p) {
13369                 trap[0] = NULL;
13370                 evalskip = 0;
13371                 evalstring(p, 0);
13372                 /*free(p); - we'll exit soon */
13373         }
13374  out:
13375         /* dash wraps setjobctl(0) in "if (setjmp(loc.loc) == 0) {...}".
13376          * our setjobctl(0) does not panic if tcsetpgrp fails inside it.
13377          */
13378         setjobctl(0);
13379         flush_stdout_stderr();
13380         _exit(status);
13381         /* NOTREACHED */
13382 }
13383
13384 static void
13385 init(void)
13386 {
13387         /* we will never free this */
13388         basepf.next_to_pgetc = basepf.buf = ckmalloc(IBUFSIZ);
13389
13390         sigmode[SIGCHLD - 1] = S_DFL;
13391         setsignal(SIGCHLD);
13392
13393         /* bash re-enables SIGHUP which is SIG_IGNed on entry.
13394          * Try: "trap '' HUP; bash; echo RET" and type "kill -HUP $$"
13395          */
13396         signal(SIGHUP, SIG_DFL);
13397
13398         {
13399                 char **envp;
13400                 const char *p;
13401                 struct stat st1, st2;
13402
13403                 initvar();
13404                 for (envp = environ; envp && *envp; envp++) {
13405                         p = endofname(*envp);
13406                         if (p != *envp && *p == '=') {
13407                                 setvareq(*envp, VEXPORT|VTEXTFIXED);
13408                         }
13409                 }
13410
13411                 setvareq((char*)defoptindvar, VTEXTFIXED);
13412
13413                 setvar0("PPID", utoa(getppid()));
13414 #if BASH_SHLVL_VAR
13415                 p = lookupvar("SHLVL");
13416                 setvar("SHLVL", utoa((p ? atoi(p) : 0) + 1), VEXPORT);
13417 #endif
13418 #if BASH_HOSTNAME_VAR
13419                 if (!lookupvar("HOSTNAME")) {
13420                         struct utsname uts;
13421                         uname(&uts);
13422                         setvar0("HOSTNAME", uts.nodename);
13423                 }
13424 #endif
13425                 p = lookupvar("PWD");
13426                 if (p) {
13427                         if (p[0] != '/' || stat(p, &st1) || stat(".", &st2)
13428                          || st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino
13429                         ) {
13430                                 p = NULL;
13431                         }
13432                 }
13433                 setpwd(p, 0);
13434         }
13435 }
13436
13437
13438 //usage:#define ash_trivial_usage
13439 //usage:        "[-/+OPTIONS] [-/+o OPT]... [-c 'SCRIPT' [ARG0 [ARGS]] / FILE [ARGS]]"
13440 //usage:#define ash_full_usage "\n\n"
13441 //usage:        "Unix shell interpreter"
13442
13443 /*
13444  * Process the shell command line arguments.
13445  */
13446 static void
13447 procargs(char **argv)
13448 {
13449         int i;
13450         const char *xminusc;
13451         char **xargv;
13452
13453         xargv = argv;
13454         arg0 = xargv[0];
13455         /* if (xargv[0]) - mmm, this is always true! */
13456                 xargv++;
13457         for (i = 0; i < NOPTS; i++)
13458                 optlist[i] = 2;
13459         argptr = xargv;
13460         if (options(/*cmdline:*/ 1)) {
13461                 /* it already printed err message */
13462                 raise_exception(EXERROR);
13463         }
13464         xargv = argptr;
13465         xminusc = minusc;
13466         if (*xargv == NULL) {
13467                 if (xminusc)
13468                         ash_msg_and_raise_error(bb_msg_requires_arg, "-c");
13469                 sflag = 1;
13470         }
13471         if (iflag == 2 && sflag == 1 && isatty(0) && isatty(1))
13472                 iflag = 1;
13473         if (mflag == 2)
13474                 mflag = iflag;
13475         for (i = 0; i < NOPTS; i++)
13476                 if (optlist[i] == 2)
13477                         optlist[i] = 0;
13478 #if DEBUG == 2
13479         debug = 1;
13480 #endif
13481         /* POSIX 1003.2: first arg after "-c CMD" is $0, remainder $1... */
13482         if (xminusc) {
13483                 minusc = *xargv++;
13484                 if (*xargv)
13485                         goto setarg0;
13486         } else if (!sflag) {
13487                 setinputfile(*xargv, 0);
13488  setarg0:
13489                 arg0 = *xargv++;
13490                 commandname = arg0;
13491         }
13492
13493         shellparam.p = xargv;
13494 #if ENABLE_ASH_GETOPTS
13495         shellparam.optind = 1;
13496         shellparam.optoff = -1;
13497 #endif
13498         /* assert(shellparam.malloced == 0 && shellparam.nparam == 0); */
13499         while (*xargv) {
13500                 shellparam.nparam++;
13501                 xargv++;
13502         }
13503         optschanged();
13504 }
13505
13506 /*
13507  * Read /etc/profile, ~/.profile, $ENV.
13508  */
13509 static void
13510 read_profile(const char *name)
13511 {
13512         name = expandstr(name);
13513         if (setinputfile(name, INPUT_PUSH_FILE | INPUT_NOFILE_OK) < 0)
13514                 return;
13515         cmdloop(0);
13516         popfile();
13517 }
13518
13519 /*
13520  * This routine is called when an error or an interrupt occurs in an
13521  * interactive shell and control is returned to the main command loop.
13522  * (In dash, this function is auto-generated by build machinery).
13523  */
13524 static void
13525 reset(void)
13526 {
13527         /* from eval.c: */
13528         evalskip = 0;
13529         loopnest = 0;
13530
13531         /* from expand.c: */
13532         ifsfree();
13533
13534         /* from input.c: */
13535         g_parsefile->left_in_buffer = 0;
13536         g_parsefile->left_in_line = 0;      /* clear input buffer */
13537         popallfiles();
13538
13539         /* from redir.c: */
13540         while (redirlist)
13541                 popredir(/*drop:*/ 0, /*restore:*/ 0);
13542 }
13543
13544 #if PROFILE
13545 static short profile_buf[16384];
13546 extern int etext();
13547 #endif
13548
13549 /*
13550  * Main routine.  We initialize things, parse the arguments, execute
13551  * profiles if we're a login shell, and then call cmdloop to execute
13552  * commands.  The setjmp call sets up the location to jump to when an
13553  * exception occurs.  When an exception occurs the variable "state"
13554  * is used to figure out how far we had gotten.
13555  */
13556 int ash_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
13557 int ash_main(int argc UNUSED_PARAM, char **argv)
13558 {
13559         volatile smallint state;
13560         struct jmploc jmploc;
13561         struct stackmark smark;
13562
13563         /* Initialize global data */
13564         INIT_G_misc();
13565         INIT_G_memstack();
13566         INIT_G_var();
13567 #if ENABLE_ASH_ALIAS
13568         INIT_G_alias();
13569 #endif
13570         INIT_G_cmdtable();
13571
13572 #if PROFILE
13573         monitor(4, etext, profile_buf, sizeof(profile_buf), 50);
13574 #endif
13575
13576 #if ENABLE_FEATURE_EDITING
13577         line_input_state = new_line_input_t(FOR_SHELL | WITH_PATH_LOOKUP);
13578 #endif
13579         state = 0;
13580         if (setjmp(jmploc.loc)) {
13581                 smallint e;
13582                 smallint s;
13583
13584                 reset();
13585
13586                 e = exception_type;
13587                 s = state;
13588                 if (e == EXEXIT || s == 0 || iflag == 0 || shlvl) {
13589                         exitshell();
13590                 }
13591                 if (e == EXINT) {
13592                         newline_and_flush(stderr);
13593                 }
13594
13595                 popstackmark(&smark);
13596                 FORCE_INT_ON; /* enable interrupts */
13597                 if (s == 1)
13598                         goto state1;
13599                 if (s == 2)
13600                         goto state2;
13601                 if (s == 3)
13602                         goto state3;
13603                 goto state4;
13604         }
13605         exception_handler = &jmploc;
13606         rootpid = getpid();
13607
13608         init();
13609         setstackmark(&smark);
13610         procargs(argv);
13611 #if DEBUG
13612         TRACE(("Shell args: "));
13613         trace_puts_args(argv);
13614 #endif
13615
13616         if (argv[0] && argv[0][0] == '-')
13617                 isloginsh = 1;
13618         if (isloginsh) {
13619                 const char *hp;
13620
13621                 state = 1;
13622                 read_profile("/etc/profile");
13623  state1:
13624                 state = 2;
13625                 hp = lookupvar("HOME");
13626                 if (hp)
13627                         read_profile("$HOME/.profile");
13628         }
13629  state2:
13630         state = 3;
13631         if (
13632 #ifndef linux
13633          getuid() == geteuid() && getgid() == getegid() &&
13634 #endif
13635          iflag
13636         ) {
13637                 const char *shinit = lookupvar("ENV");
13638                 if (shinit != NULL && *shinit != '\0')
13639                         read_profile(shinit);
13640         }
13641         popstackmark(&smark);
13642  state3:
13643         state = 4;
13644         if (minusc) {
13645                 /* evalstring pushes parsefile stack.
13646                  * Ensure we don't falsely claim that 0 (stdin)
13647                  * is one of stacked source fds.
13648                  * Testcase: ash -c 'exec 1>&0' must not complain. */
13649                 // if (!sflag) g_parsefile->pf_fd = -1;
13650                 // ^^ not necessary since now we special-case fd 0
13651                 // in is_hidden_fd() to not be considered "hidden fd"
13652                 evalstring(minusc, 0);
13653         }
13654
13655         if (sflag || minusc == NULL) {
13656 #if MAX_HISTORY > 0 && ENABLE_FEATURE_EDITING_SAVEHISTORY
13657                 if (iflag) {
13658                         const char *hp = lookupvar("HISTFILE");
13659                         if (!hp) {
13660                                 hp = lookupvar("HOME");
13661                                 if (hp) {
13662                                         INT_OFF;
13663                                         hp = concat_path_file(hp, ".ash_history");
13664                                         setvar0("HISTFILE", hp);
13665                                         free((char*)hp);
13666                                         INT_ON;
13667                                         hp = lookupvar("HISTFILE");
13668                                 }
13669                         }
13670                         if (hp)
13671                                 line_input_state->hist_file = hp;
13672 # if ENABLE_FEATURE_SH_HISTFILESIZE
13673                         hp = lookupvar("HISTFILESIZE");
13674                         line_input_state->max_history = size_from_HISTFILESIZE(hp);
13675 # endif
13676                 }
13677 #endif
13678  state4: /* XXX ??? - why isn't this before the "if" statement */
13679                 cmdloop(1);
13680         }
13681 #if PROFILE
13682         monitor(0);
13683 #endif
13684 #ifdef GPROF
13685         {
13686                 extern void _mcleanup(void);
13687                 _mcleanup();
13688         }
13689 #endif
13690         TRACE(("End of main reached\n"));
13691         exitshell();
13692         /* NOTREACHED */
13693 }
13694
13695
13696 /*-
13697  * Copyright (c) 1989, 1991, 1993, 1994
13698  *      The Regents of the University of California.  All rights reserved.
13699  *
13700  * This code is derived from software contributed to Berkeley by
13701  * Kenneth Almquist.
13702  *
13703  * Redistribution and use in source and binary forms, with or without
13704  * modification, are permitted provided that the following conditions
13705  * are met:
13706  * 1. Redistributions of source code must retain the above copyright
13707  *    notice, this list of conditions and the following disclaimer.
13708  * 2. Redistributions in binary form must reproduce the above copyright
13709  *    notice, this list of conditions and the following disclaimer in the
13710  *    documentation and/or other materials provided with the distribution.
13711  * 3. Neither the name of the University nor the names of its contributors
13712  *    may be used to endorse or promote products derived from this software
13713  *    without specific prior written permission.
13714  *
13715  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
13716  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
13717  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
13718  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
13719  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
13720  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
13721  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
13722  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
13723  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
13724  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
13725  * SUCH DAMAGE.
13726  */