hush: get rid of charmap[]
[oweals/busybox.git] / shell / hush.c
1 /* vi: set sw=4 ts=4: */
2 /*
3  * A prototype Bourne shell grammar parser.
4  * Intended to follow the original Thompson and Ritchie
5  * "small and simple is beautiful" philosophy, which
6  * incidentally is a good match to today's BusyBox.
7  *
8  * Copyright (C) 2000,2001  Larry Doolittle  <larry@doolittle.boa.org>
9  *
10  * Credits:
11  *      The parser routines proper are all original material, first
12  *      written Dec 2000 and Jan 2001 by Larry Doolittle.  The
13  *      execution engine, the builtins, and much of the underlying
14  *      support has been adapted from busybox-0.49pre's lash, which is
15  *      Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
16  *      written by Erik Andersen <andersen@codepoet.org>.  That, in turn,
17  *      is based in part on ladsh.c, by Michael K. Johnson and Erik W.
18  *      Troan, which they placed in the public domain.  I don't know
19  *      how much of the Johnson/Troan code has survived the repeated
20  *      rewrites.
21  *
22  * Other credits:
23  *      o_addchr() derived from similar w_addchar function in glibc-2.2.
24  *      setup_redirect(), redirect_opt_num(), and big chunks of main()
25  *      and many builtins derived from contributions by Erik Andersen.
26  *      Miscellaneous bugfixes from Matt Kraai.
27  *
28  * There are two big (and related) architecture differences between
29  * this parser and the lash parser.  One is that this version is
30  * actually designed from the ground up to understand nearly all
31  * of the Bourne grammar.  The second, consequential change is that
32  * the parser and input reader have been turned inside out.  Now,
33  * the parser is in control, and asks for input as needed.  The old
34  * way had the input reader in control, and it asked for parsing to
35  * take place as needed.  The new way makes it much easier to properly
36  * handle the recursion implicit in the various substitutions, especially
37  * across continuation lines.
38  *
39  * POSIX syntax not implemented:
40  *      aliases
41  *      <(list) and >(list) Process Substitution
42  *      Here Documents ( << word )
43  *      Functions
44  *      Tilde Expansion
45  *      Parameter Expansion for substring processing ${var#word} ${var%word}
46  *
47  * Bash stuff maybe optional enable:
48  *      &> and >& redirection of stdout+stderr
49  *      Brace expansion
50  *      reserved words: [[ ]] function select
51  *      substrings ${var:1:5}
52  *
53  * Major bugs:
54  *      job handling woefully incomplete and buggy (improved --vda)
55  * to-do:
56  *      port selected bugfixes from post-0.49 busybox lash - done?
57  *      change { and } from special chars to reserved words
58  *      builtins: return, trap, ulimit
59  *      test magic exec with redirection only
60  *      follow IFS rules more precisely, including update semantics
61  *      figure out what to do with backslash-newline
62  *      propagate syntax errors, die on resource errors?
63  *      continuation lines, both explicit and implicit - done?
64  *
65  * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
66  */
67
68 #include "busybox.h" /* for APPLET_IS_NOFORK/NOEXEC */
69 //TODO: pull in some .h and find out whether we have SINGLE_APPLET_MAIN?
70 //#include "applet_tables.h" doesn't work
71 #include <glob.h>
72 /* #include <dmalloc.h> */
73 #if ENABLE_HUSH_CASE
74 #include <fnmatch.h>
75 #endif
76
77 #include "math.h"
78
79 #define HUSH_VER_STR "0.92"
80
81 #if defined SINGLE_APPLET_MAIN
82 /* STANDALONE does not make sense, and won't compile */
83 #undef CONFIG_FEATURE_SH_STANDALONE
84 #undef ENABLE_FEATURE_SH_STANDALONE
85 #undef USE_FEATURE_SH_STANDALONE
86 #define SKIP_FEATURE_SH_STANDALONE(...) __VA_ARGS__
87 #define ENABLE_FEATURE_SH_STANDALONE 0
88 #define USE_FEATURE_SH_STANDALONE(...)
89 #define SKIP_FEATURE_SH_STANDALONE(...) __VA_ARGS__
90 #endif
91
92 #if !ENABLE_HUSH_INTERACTIVE
93 #undef ENABLE_FEATURE_EDITING
94 #define ENABLE_FEATURE_EDITING 0
95 #undef ENABLE_FEATURE_EDITING_FANCY_PROMPT
96 #define ENABLE_FEATURE_EDITING_FANCY_PROMPT 0
97 #endif
98
99 /* Do we support ANY keywords? */
100 #if ENABLE_HUSH_IF || ENABLE_HUSH_LOOPS || ENABLE_HUSH_CASE
101 #define HAS_KEYWORDS 1
102 #define IF_HAS_KEYWORDS(...) __VA_ARGS__
103 #define IF_HAS_NO_KEYWORDS(...)
104 #else
105 #define HAS_KEYWORDS 0
106 #define IF_HAS_KEYWORDS(...)
107 #define IF_HAS_NO_KEYWORDS(...) __VA_ARGS__
108 #endif
109
110 /* Keep unconditionally on for now */
111 #define HUSH_DEBUG 1
112 /* In progress... */
113 #define ENABLE_HUSH_FUNCTIONS 0
114
115
116 /* If you comment out one of these below, it will be #defined later
117  * to perform debug printfs to stderr: */
118 #define debug_printf(...)        do {} while (0)
119 /* Finer-grained debug switches */
120 #define debug_printf_parse(...)  do {} while (0)
121 #define debug_print_tree(a, b)   do {} while (0)
122 #define debug_printf_exec(...)   do {} while (0)
123 #define debug_printf_env(...)    do {} while (0)
124 #define debug_printf_jobs(...)   do {} while (0)
125 #define debug_printf_expand(...) do {} while (0)
126 #define debug_printf_glob(...)   do {} while (0)
127 #define debug_printf_list(...)   do {} while (0)
128 #define debug_printf_subst(...)  do {} while (0)
129 #define debug_printf_clean(...)  do {} while (0)
130
131 #ifndef debug_printf
132 #define debug_printf(...) fprintf(stderr, __VA_ARGS__)
133 #endif
134
135 #ifndef debug_printf_parse
136 #define debug_printf_parse(...) fprintf(stderr, __VA_ARGS__)
137 #endif
138
139 #ifndef debug_printf_exec
140 #define debug_printf_exec(...) fprintf(stderr, __VA_ARGS__)
141 #endif
142
143 #ifndef debug_printf_env
144 #define debug_printf_env(...) fprintf(stderr, __VA_ARGS__)
145 #endif
146
147 #ifndef debug_printf_jobs
148 #define debug_printf_jobs(...) fprintf(stderr, __VA_ARGS__)
149 #define DEBUG_JOBS 1
150 #else
151 #define DEBUG_JOBS 0
152 #endif
153
154 #ifndef debug_printf_expand
155 #define debug_printf_expand(...) fprintf(stderr, __VA_ARGS__)
156 #define DEBUG_EXPAND 1
157 #else
158 #define DEBUG_EXPAND 0
159 #endif
160
161 #ifndef debug_printf_glob
162 #define debug_printf_glob(...) fprintf(stderr, __VA_ARGS__)
163 #define DEBUG_GLOB 1
164 #else
165 #define DEBUG_GLOB 0
166 #endif
167
168 #ifndef debug_printf_list
169 #define debug_printf_list(...) fprintf(stderr, __VA_ARGS__)
170 #endif
171
172 #ifndef debug_printf_subst
173 #define debug_printf_subst(...) fprintf(stderr, __VA_ARGS__)
174 #endif
175
176 #ifndef debug_printf_clean
177 /* broken, of course, but OK for testing */
178 static const char *indenter(int i)
179 {
180         static const char blanks[] ALIGN1 =
181                 "                                    ";
182         return &blanks[sizeof(blanks) - i - 1];
183 }
184 #define debug_printf_clean(...) fprintf(stderr, __VA_ARGS__)
185 #define DEBUG_CLEAN 1
186 #endif
187
188 #if DEBUG_EXPAND
189 static void debug_print_strings(const char *prefix, char **vv)
190 {
191         fprintf(stderr, "%s:\n", prefix);
192         while (*vv)
193                 fprintf(stderr, " '%s'\n", *vv++);
194 }
195 #else
196 #define debug_print_strings(prefix, vv) ((void)0)
197 #endif
198
199 /*
200  * Leak hunting. Use hush_leaktool.sh for post-processing.
201  */
202 #ifdef FOR_HUSH_LEAKTOOL
203 static void *xxmalloc(int lineno, size_t size)
204 {
205         void *ptr = xmalloc((size + 0xff) & ~0xff);
206         fdprintf(2, "line %d: malloc %p\n", lineno, ptr);
207         return ptr;
208 }
209 static void *xxrealloc(int lineno, void *ptr, size_t size)
210 {
211         ptr = xrealloc(ptr, (size + 0xff) & ~0xff);
212         fdprintf(2, "line %d: realloc %p\n", lineno, ptr);
213         return ptr;
214 }
215 static char *xxstrdup(int lineno, const char *str)
216 {
217         char *ptr = xstrdup(str);
218         fdprintf(2, "line %d: strdup %p\n", lineno, ptr);
219         return ptr;
220 }
221 static void xxfree(void *ptr)
222 {
223         fdprintf(2, "free %p\n", ptr);
224         free(ptr);
225 }
226 #define xmalloc(s)     xxmalloc(__LINE__, s)
227 #define xrealloc(p, s) xxrealloc(__LINE__, p, s)
228 #define xstrdup(s)     xxstrdup(__LINE__, s)
229 #define free(p)        xxfree(p)
230 #endif
231
232
233 #define ERR_PTR ((void*)(long)1)
234
235 static const char hush_version_str[] ALIGN1 = "HUSH_VERSION="HUSH_VER_STR;
236
237 #define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
238
239 #define SPECIAL_VAR_SYMBOL 3
240
241 typedef enum redir_type {
242         REDIRECT_INPUT     = 1,
243         REDIRECT_OVERWRITE = 2,
244         REDIRECT_APPEND    = 3,
245         REDIRECT_HEREIS    = 4,
246         REDIRECT_IO        = 5
247 } redir_type;
248
249 /* The descrip member of this structure is only used to make
250  * debugging output pretty */
251 static const struct {
252         int mode;
253         signed char default_fd;
254         char descrip[3];
255 } redir_table[] = {
256         { 0,                         0, "()" },
257         { O_RDONLY,                  0, "<"  },
258         { O_CREAT|O_TRUNC|O_WRONLY,  1, ">"  },
259         { O_CREAT|O_APPEND|O_WRONLY, 1, ">>" },
260         { O_RDONLY,                 -1, "<<" },
261         { O_RDWR,                    1, "<>" }
262 };
263
264 typedef enum pipe_style {
265         PIPE_SEQ = 1,
266         PIPE_AND = 2,
267         PIPE_OR  = 3,
268         PIPE_BG  = 4,
269 } pipe_style;
270
271 typedef enum reserved_style {
272         RES_NONE  = 0,
273 #if ENABLE_HUSH_IF
274         RES_IF    ,
275         RES_THEN  ,
276         RES_ELIF  ,
277         RES_ELSE  ,
278         RES_FI    ,
279 #endif
280 #if ENABLE_HUSH_LOOPS
281         RES_FOR   ,
282         RES_WHILE ,
283         RES_UNTIL ,
284         RES_DO    ,
285         RES_DONE  ,
286 #endif
287 #if ENABLE_HUSH_LOOPS || ENABLE_HUSH_CASE
288         RES_IN    ,
289 #endif
290 #if ENABLE_HUSH_CASE
291         RES_CASE  ,
292         /* two pseudo-keywords support contrived "case" syntax: */
293         RES_MATCH , /* "word)" */
294         RES_CASEI , /* "this command is inside CASE" */
295         RES_ESAC  ,
296 #endif
297         RES_XXXX  ,
298         RES_SNTX
299 } reserved_style;
300
301 struct redir_struct {
302         struct redir_struct *next;
303         char *rd_filename;          /* filename */
304         int fd;                     /* file descriptor being redirected */
305         int dup;                    /* -1, or file descriptor being duplicated */
306         smallint /*enum redir_type*/ rd_type;
307 };
308
309 struct command {
310         pid_t pid;                  /* 0 if exited */
311         int assignment_cnt;         /* how many argv[i] are assignments? */
312         smallint is_stopped;        /* is the command currently running? */
313         smallint grp_type;          /* GRP_xxx */
314         struct pipe *group;         /* if non-NULL, this "prog" is {} group,
315                                      * subshell, or a compound statement */
316         char **argv;                /* command name and arguments */
317         struct redir_struct *redirects; /* I/O redirections */
318 };
319 /* argv vector may contain variable references (^Cvar^C, ^C0^C etc)
320  * and on execution these are substituted with their values.
321  * Substitution can make _several_ words out of one argv[n]!
322  * Example: argv[0]=='.^C*^C.' here: echo .$*.
323  * References of the form ^C`cmd arg^C are `cmd arg` substitutions.
324  */
325 #define GRP_NORMAL   0
326 #define GRP_SUBSHELL 1
327 #if ENABLE_HUSH_FUNCTIONS
328 #define GRP_FUNCTION 2
329 #endif
330
331 struct pipe {
332         struct pipe *next;
333         int num_cmds;               /* total number of commands in job */
334         int alive_cmds;             /* number of commands running (not exited) */
335         int stopped_cmds;           /* number of commands alive, but stopped */
336 #if ENABLE_HUSH_JOB
337         int jobid;                  /* job number */
338         pid_t pgrp;                 /* process group ID for the job */
339         char *cmdtext;              /* name of job */
340 #endif
341         struct command *cmds;       /* array of commands in pipe */
342         smallint followup;          /* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */
343         IF_HAS_KEYWORDS(smallint pi_inverted;) /* "! cmd | cmd" */
344         IF_HAS_KEYWORDS(smallint res_word;) /* needed for if, for, while, until... */
345 };
346
347 /* This holds pointers to the various results of parsing */
348 struct parse_context {
349         /* linked list of pipes */
350         struct pipe *list_head;
351         /* last pipe (being constructed right now) */
352         struct pipe *pipe;
353         /* last command in pipe (being constructed right now) */
354         struct command *command;
355         /* last redirect in command->redirects list */
356         struct redir_struct *pending_redirect;
357 #if HAS_KEYWORDS
358         smallint ctx_res_w;
359         smallint ctx_inverted; /* "! cmd | cmd" */
360 #if ENABLE_HUSH_CASE
361         smallint ctx_dsemicolon; /* ";;" seen */
362 #endif
363         /* bitmask of FLAG_xxx, for figuring out valid reserved words */
364         int old_flag;
365         /* group we are enclosed in:
366          * example 1: "{ { false; ..."
367          * example 2: "if true; then { false; ..."
368          * example 3: "if true; then if false; ..."
369          * when we find closing "}" / "fi" / whatever, we move list_head
370          * into stack->command->group and delete ourself.
371          */
372         struct parse_context *stack;
373 #endif
374 };
375
376 /* On program start, environ points to initial environment.
377  * putenv adds new pointers into it, unsetenv removes them.
378  * Neither of these (de)allocates the strings.
379  * setenv allocates new strings in malloc space and does putenv,
380  * and thus setenv is unusable (leaky) for shell's purposes */
381 #define setenv(...) setenv_is_leaky_dont_use()
382 struct variable {
383         struct variable *next;
384         char *varstr;        /* points to "name=" portion */
385         int max_len;         /* if > 0, name is part of initial env; else name is malloced */
386         smallint flg_export; /* putenv should be done on this var */
387         smallint flg_read_only;
388 };
389
390 typedef struct o_string {
391         char *data;
392         int length; /* position where data is appended */
393         int maxlen;
394         /* Protect newly added chars against globbing
395          * (by prepending \ to *, ?, [, \) */
396         smallint o_escape;
397         smallint o_glob;
398         smallint nonnull;
399         smallint has_empty_slot;
400         smallint o_assignment; /* 0:maybe, 1:yes, 2:no */
401 } o_string;
402 enum {
403         MAYBE_ASSIGNMENT = 0,
404         DEFINITELY_ASSIGNMENT = 1,
405         NOT_ASSIGNMENT = 2,
406         WORD_IS_KEYWORD = 3, /* not assigment, but next word may be: "if v=xyz cmd;" */
407 };
408 /* Used for initialization: o_string foo = NULL_O_STRING; */
409 #define NULL_O_STRING { NULL }
410
411 /* I can almost use ordinary FILE*.  Is open_memstream() universally
412  * available?  Where is it documented? */
413 typedef struct in_str {
414         const char *p;
415         /* eof_flag=1: last char in ->p is really an EOF */
416         char eof_flag; /* meaningless if ->p == NULL */
417         char peek_buf[2];
418 #if ENABLE_HUSH_INTERACTIVE
419         smallint promptme;
420         smallint promptmode; /* 0: PS1, 1: PS2 */
421 #endif
422         FILE *file;
423         int (*get) (struct in_str *);
424         int (*peek) (struct in_str *);
425 } in_str;
426 #define i_getch(input) ((input)->get(input))
427 #define i_peek(input) ((input)->peek(input))
428
429 enum {
430         CHAR_ORDINARY           = 0,
431         CHAR_ORDINARY_IF_QUOTED = 1, /* example: *, # */
432         CHAR_IFS                = 2, /* treated as ordinary if quoted */
433         CHAR_SPECIAL            = 3, /* \, $, ", maybe ` */
434 };
435
436 enum {
437         BC_BREAK = 1,
438         BC_CONTINUE = 2,
439 };
440
441
442 /* "Globals" within this file */
443 /* Sorted roughly by size (smaller offsets == smaller code) */
444 struct globals {
445 #if ENABLE_HUSH_INTERACTIVE
446         /* 'interactive_fd' is a fd# open to ctty, if we have one
447          * _AND_ if we decided to act interactively */
448         int interactive_fd;
449         const char *PS1;
450         const char *PS2;
451 #define G_interactive_fd (G.interactive_fd)
452 #else
453 #define G_interactive_fd 0
454 #endif
455 #if ENABLE_FEATURE_EDITING
456         line_input_t *line_input_state;
457 #endif
458         pid_t root_pid;
459         pid_t last_bg_pid;
460 #if ENABLE_HUSH_JOB
461         int run_list_level;
462         pid_t saved_tty_pgrp;
463         int last_jobid;
464         struct pipe *job_list;
465         struct pipe *toplevel_list;
466 ////    smallint ctrl_z_flag;
467 #endif
468         smallint flag_SIGINT;
469 #if ENABLE_HUSH_LOOPS
470         smallint flag_break_continue;
471 #endif
472         smallint fake_mode;
473         /* These four support $?, $#, and $1 */
474         smalluint last_return_code;
475         /* is global_argv and global_argv[1..n] malloced? (note: not [0]) */
476         smalluint global_args_malloced;
477         /* how many non-NULL argv's we have. NB: $# + 1 */
478         int global_argc;
479         char **global_argv;
480 #if ENABLE_HUSH_LOOPS
481         unsigned depth_break_continue;
482         unsigned depth_of_loop;
483 #endif
484         const char *ifs;
485         const char *cwd;
486         struct variable *top_var; /* = &G.shell_ver (set in main()) */
487         struct variable shell_ver;
488         /* Signal and trap handling */
489 //      unsigned count_SIGCHLD;
490 //      unsigned handled_SIGCHLD;
491         /* which signals have non-DFL handler (even with no traps set)? */
492         unsigned non_DFL_mask;
493         char **traps; /* char *traps[NSIG] */
494         sigset_t blocked_set;
495         sigset_t inherited_set;
496         char user_input_buf[ENABLE_FEATURE_EDITING ? BUFSIZ : 2];
497 #if ENABLE_FEATURE_SH_STANDALONE
498         struct nofork_save_area nofork_save;
499 #endif
500 #if ENABLE_HUSH_JOB
501         sigjmp_buf toplevel_jb;
502 #endif
503 };
504 #define G (*ptr_to_globals)
505 /* Not #defining name to G.name - this quickly gets unwieldy
506  * (too many defines). Also, I actually prefer to see when a variable
507  * is global, thus "G." prefix is a useful hint */
508 #define INIT_G() do { \
509         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
510 } while (0)
511
512
513 /* Function prototypes for builtins */
514 static int builtin_cd(char **argv);
515 static int builtin_echo(char **argv);
516 static int builtin_eval(char **argv);
517 static int builtin_exec(char **argv);
518 static int builtin_exit(char **argv);
519 static int builtin_export(char **argv);
520 #if ENABLE_HUSH_JOB
521 static int builtin_fg_bg(char **argv);
522 static int builtin_jobs(char **argv);
523 #endif
524 #if ENABLE_HUSH_HELP
525 static int builtin_help(char **argv);
526 #endif
527 static int builtin_pwd(char **argv);
528 static int builtin_read(char **argv);
529 static int builtin_test(char **argv);
530 static int builtin_trap(char **argv);
531 static int builtin_true(char **argv);
532 static int builtin_set(char **argv);
533 static int builtin_shift(char **argv);
534 static int builtin_source(char **argv);
535 static int builtin_umask(char **argv);
536 static int builtin_unset(char **argv);
537 static int builtin_wait(char **argv);
538 #if ENABLE_HUSH_LOOPS
539 static int builtin_break(char **argv);
540 static int builtin_continue(char **argv);
541 #endif
542 //static int builtin_not_written(char **argv);
543
544 /* Table of built-in functions.  They can be forked or not, depending on
545  * context: within pipes, they fork.  As simple commands, they do not.
546  * When used in non-forking context, they can change global variables
547  * in the parent shell process.  If forked, of course they cannot.
548  * For example, 'unset foo | whatever' will parse and run, but foo will
549  * still be set at the end. */
550 struct built_in_command {
551         const char *cmd;
552         int (*function)(char **argv);
553 #if ENABLE_HUSH_HELP
554         const char *descr;
555 #define BLTIN(cmd, func, help) { cmd, func, help }
556 #else
557 #define BLTIN(cmd, func, help) { cmd, func }
558 #endif
559 };
560
561 /* For now, echo and test are unconditionally enabled.
562  * Maybe make it configurable? */
563 static const struct built_in_command bltins[] = {
564         BLTIN("."     , builtin_source, "Run commands in a file"),
565         BLTIN(":"     , builtin_true, "No-op"),
566         BLTIN("["     , builtin_test, "Test condition"),
567 #if ENABLE_HUSH_JOB
568         BLTIN("bg"    , builtin_fg_bg, "Resume a job in the background"),
569 #endif
570 #if ENABLE_HUSH_LOOPS
571         BLTIN("break" , builtin_break, "Exit from a loop"),
572 #endif
573         BLTIN("cd"    , builtin_cd, "Change directory"),
574 #if ENABLE_HUSH_LOOPS
575         BLTIN("continue", builtin_continue, "Start new loop iteration"),
576 #endif
577         BLTIN("echo"  , builtin_echo, "Write to stdout"),
578         BLTIN("eval"  , builtin_eval, "Construct and run shell command"),
579         BLTIN("exec"  , builtin_exec, "Execute command, don't return to shell"),
580         BLTIN("exit"  , builtin_exit, "Exit"),
581         BLTIN("export", builtin_export, "Set environment variable"),
582 #if ENABLE_HUSH_JOB
583         BLTIN("fg"    , builtin_fg_bg, "Bring job into the foreground"),
584         BLTIN("jobs"  , builtin_jobs, "List active jobs"),
585 #endif
586         BLTIN("pwd"   , builtin_pwd, "Print current directory"),
587         BLTIN("read"  , builtin_read, "Input environment variable"),
588 //      BLTIN("return", builtin_not_written, "Return from a function"),
589         BLTIN("set"   , builtin_set, "Set/unset shell local variables"),
590         BLTIN("shift" , builtin_shift, "Shift positional parameters"),
591         BLTIN("test"  , builtin_test, "Test condition"),
592         BLTIN("trap"  , builtin_trap, "Trap signals"),
593 //      BLTIN("ulimit", builtin_not_written, "Control resource limits"),
594         BLTIN("umask" , builtin_umask, "Set file creation mask"),
595         BLTIN("unset" , builtin_unset, "Unset environment variable"),
596         BLTIN("wait"  , builtin_wait, "Wait for process"),
597 #if ENABLE_HUSH_HELP
598         BLTIN("help"  , builtin_help, "List shell built-in commands"),
599 #endif
600 };
601
602
603 /* Normal */
604 static void maybe_die(const char *notice, const char *msg)
605 {
606         /* Was using fancy stuff:
607          * (G_interactive_fd ? bb_error_msg : bb_error_msg_and_die)(...params...)
608          * but it SEGVs. ?! Oh well... explicit temp ptr works around that */
609         void FAST_FUNC (*fp)(const char *s, ...) = bb_error_msg_and_die;
610 #if ENABLE_HUSH_INTERACTIVE
611         if (G_interactive_fd)
612                 fp = bb_error_msg;
613 #endif
614         fp(msg ? "%s: %s" : notice, notice, msg);
615 }
616 #if 1
617 #define syntax(msg) maybe_die("syntax error", msg);
618 #else
619 /* Debug -- trick gcc to expand __LINE__ and convert to string */
620 #define __syntax(msg, line) maybe_die("syntax error hush.c:" # line, msg)
621 #define _syntax(msg, line) __syntax(msg, line)
622 #define syntax(msg) _syntax(msg, __LINE__)
623 #endif
624
625 static int glob_needed(const char *s)
626 {
627         while (*s) {
628                 if (*s == '\\')
629                         s++;
630                 if (*s == '*' || *s == '[' || *s == '?')
631                         return 1;
632                 s++;
633         }
634         return 0;
635 }
636
637 static int is_assignment(const char *s)
638 {
639         if (!s || !(isalpha(*s) || *s == '_'))
640                 return 0;
641         s++;
642         while (isalnum(*s) || *s == '_')
643                 s++;
644         return *s == '=';
645 }
646
647 /* Replace each \x with x in place, return ptr past NUL. */
648 static char *unbackslash(char *src)
649 {
650         char *dst = src;
651         while (1) {
652                 if (*src == '\\')
653                         src++;
654                 if ((*dst++ = *src++) == '\0')
655                         break;
656         }
657         return dst;
658 }
659
660 static char **add_strings_to_strings(char **strings, char **add, int need_to_dup)
661 {
662         int i;
663         unsigned count1;
664         unsigned count2;
665         char **v;
666
667         v = strings;
668         count1 = 0;
669         if (v) {
670                 while (*v) {
671                         count1++;
672                         v++;
673                 }
674         }
675         count2 = 0;
676         v = add;
677         while (*v) {
678                 count2++;
679                 v++;
680         }
681         v = xrealloc(strings, (count1 + count2 + 1) * sizeof(char*));
682         v[count1 + count2] = NULL;
683         i = count2;
684         while (--i >= 0)
685                 v[count1 + i] = (need_to_dup ? xstrdup(add[i]) : add[i]);
686         return v;
687 }
688
689 static char **add_string_to_strings(char **strings, char *add)
690 {
691         char *v[2];
692         v[0] = add;
693         v[1] = NULL;
694         return add_strings_to_strings(strings, v, /*dup:*/ 0);
695 }
696
697 static void putenv_all(char **strings)
698 {
699         if (!strings)
700                 return;
701         while (*strings) {
702                 debug_printf_env("putenv '%s'\n", *strings);
703                 putenv(*strings++);
704         }
705 }
706
707 static char **putenv_all_and_save_old(char **strings)
708 {
709         char **old = NULL;
710         char **s = strings;
711
712         if (!strings)
713                 return old;
714         while (*strings) {
715                 char *v, *eq;
716
717                 eq = strchr(*strings, '=');
718                 if (eq) {
719                         *eq = '\0';
720                         v = getenv(*strings);
721                         *eq = '=';
722                         if (v) {
723                                 /* v points to VAL in VAR=VAL, go back to VAR */
724                                 v -= (eq - *strings) + 1;
725                                 old = add_string_to_strings(old, v);
726                         }
727                 }
728                 strings++;
729         }
730         putenv_all(s);
731         return old;
732 }
733
734 static void free_strings_and_unsetenv(char **strings, int unset)
735 {
736         char **v;
737
738         if (!strings)
739                 return;
740
741         v = strings;
742         while (*v) {
743                 if (unset) {
744                         debug_printf_env("unsetenv '%s'\n", *v);
745                         bb_unsetenv(*v);
746                 }
747                 free(*v++);
748         }
749         free(strings);
750 }
751
752 static void free_strings(char **strings)
753 {
754         free_strings_and_unsetenv(strings, 0);
755 }
756
757
758 /* Basic theory of signal handling in shell
759  * ========================================
760  * This does not describe what hush does, rather, it is current understanding
761  * what it _should_ do. If it doesn't, it's a bug.
762  * http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#trap
763  *
764  * Signals are handled only after each pipe ("cmd | cmd | cmd" thing)
765  * is finished or backgrounded. It is the same in interactive and
766  * non-interactive shells, and is the same regardless of whether
767  * a user trap handler is installed or a shell special one is in effect.
768  * ^C or ^Z from keyboard seem to execute "at once" because it usually
769  * backgrounds (i.e. stops) or kills all members of currently running
770  * pipe.
771  *
772  * Wait builtin in interruptible by signals for which user trap is set
773  * or by SIGINT in interactive shell.
774  *
775  * Trap handlers will execute even within trap handlers. (right?)
776  *
777  * User trap handlers are forgotten when subshell ("(cmd)") is entered. [TODO]
778  *
779  * If job control is off, backgrounded commands ("cmd &")
780  * have SIGINT, SIGQUIT set to SIG_IGN.
781  *
782  * Commands run in command substitution ("`cmd`")
783  * have SIGTTIN, SIGTTOU, SIGTSTP set to SIG_IGN.
784  *
785  * Ordinary commands have signals set to SIG_IGN/DFL set as inherited
786  * by the shell from its parent.
787  *
788  * Siganls which differ from SIG_DFL action
789  * (note: child (i.e., [v]forked) shell is not an interactive shell):
790  *
791  * SIGQUIT: ignore
792  * SIGTERM (interactive): ignore
793  * SIGHUP (interactive):
794  *    send SIGCONT to stopped jobs, send SIGHUP to all jobs and exit
795  * SIGTTIN, SIGTTOU, SIGTSTP (if job control is on): ignore
796  *    (note that ^Z is handled not by trapping SIGTSTP, but by seeing
797  *    that all pipe members are stopped) (right?)
798  * SIGINT (interactive): wait for last pipe, ignore the rest
799  *    of the command line, show prompt. NB: ^C does not send SIGINT
800  *    to interactive shell while shell is waiting for a pipe,
801  *    since shell is bg'ed (is not in foreground process group).
802  *    (check/expand this)
803  *    Example 1: this waits 5 sec, but does not execute ls:
804  *    "echo $$; sleep 5; ls -l" + "kill -INT <pid>"
805  *    Example 2: this does not wait and does not execute ls:
806  *    "echo $$; sleep 5 & wait; ls -l" + "kill -INT <pid>"
807  *    Example 3: this does not wait 5 sec, but executes ls:
808  *    "sleep 5; ls -l" + press ^C
809  *
810  * (What happens to signals which are IGN on shell start?)
811  * (What happens with signal mask on shell start?)
812  *
813  * Implementation in hush
814  * ======================
815  * We use in-kernel pending signal mask to determine which signals were sent.
816  * We block all signals which we don't want to take action immediately,
817  * i.e. we block all signals which need to have special handling as described
818  * above, and all signals which have traps set.
819  * After each pipe execution, we extract any pending signals via sigtimedwait()
820  * and act on them.
821  *
822  * unsigned non_DFL_mask: a mask of such "special" signals
823  * sigset_t blocked_set:  current blocked signal set
824  *
825  * "trap - SIGxxx":
826  *    clear bit in blocked_set unless it is also in non_DFL
827  * "trap 'cmd' SIGxxx":
828  *    set bit in blocked_set (even if 'cmd' is '')
829  * after [v]fork, if we plan to be a shell:
830  *    nothing for {} child shell (say, "true | { true; true; } | true")
831  *    unset all traps if () shell. [TODO]
832  * after [v]fork, if we plan to exec:
833  *    POSIX says pending signal mask is cleared in child - no need to clear it.
834  *    Restore blocked signal set to one inherited by shell just prior to exec.
835  *
836  * Note: as a result, we do not use signal handlers much. The only uses
837  * are to count SIGCHLDs [disabled - bug somewhere, + bloat]
838  * and to restore tty pgrp on signal-induced exit.
839  *
840  * TODO: check/fix wait builtin to be interruptible.
841  */
842
843 //static void SIGCHLD_handler(int sig UNUSED_PARAM)
844 //{
845 //      G.count_SIGCHLD++;
846 //}
847
848 /* called once at shell init */
849 static void init_signal_mask(void)
850 {
851         unsigned sig;
852         unsigned mask = (1 << SIGQUIT);
853         if (G_interactive_fd) {
854                 mask = 0
855                         | (1 << SIGQUIT)
856                         | (1 << SIGTERM)
857                         | (1 << SIGHUP)
858 #if ENABLE_HUSH_JOB
859                         | (1 << SIGTTIN) | (1 << SIGTTOU) | (1 << SIGTSTP)
860 #endif
861                         | (1 << SIGINT)
862                 ;
863         }
864         G.non_DFL_mask = mask;
865
866         sigprocmask(SIG_SETMASK, NULL, &G.blocked_set);
867         sig = 0;
868         while (mask) {
869                 if (mask & 1)
870                         sigaddset(&G.blocked_set, sig);
871                 mask >>= 1;
872                 sig++;
873         }
874         sigdelset(&G.blocked_set, SIGCHLD);
875         sigprocmask(SIG_SETMASK, &G.blocked_set, &G.inherited_set);
876 }
877
878 static int check_and_run_traps(int sig)
879 {
880         static const struct timespec zero_timespec = { 0, 0 };
881         smalluint save_rcode;
882         int last_sig = 0;
883
884         if (sig)
885                 goto jump_in;
886         while (1) {
887                 sig = sigtimedwait(&G.blocked_set, NULL, &zero_timespec);
888                 if (sig <= 0)
889                         break;
890  jump_in:
891                 last_sig = sig;
892                 if (G.traps && G.traps[sig]) {
893                         if (G.traps[sig][0]) {
894                                 /* We have user-defined handler */
895                                 char *argv[] = { NULL, xstrdup(G.traps[sig]), NULL };
896                                 save_rcode = G.last_return_code;
897                                 builtin_eval(argv);
898                                 free(argv[1]);
899                                 G.last_return_code = save_rcode;
900                         } /* else: "" trap, ignoring signal */
901                         continue;
902                 }
903                 /* not a trap: special action */
904                 switch (sig) {
905 //              case SIGCHLD:
906 //                      G.count_SIGCHLD++;
907 //                      break;
908                 case SIGINT:
909                         bb_putchar('\n');
910                         G.flag_SIGINT = 1;
911                         break;
912 //TODO
913 //              case SIGHUP: ...
914 //                      break;
915                 default: /* SIGTERM, SIGQUIT, SIGTTIN, SIGTTOU, SIGTSTP */
916                         break;
917                 }
918         }
919         return last_sig;
920 }
921
922 #if ENABLE_HUSH_JOB
923
924 /* Restores tty foreground process group, and exits.
925  * May be called as signal handler for fatal signal
926  * (will faithfully resend signal to itself, producing correct exit state)
927  * or called directly with -EXITCODE.
928  * We also call it if xfunc is exiting. */
929 static void sigexit(int sig) NORETURN;
930 static void sigexit(int sig)
931 {
932         /* Disable all signals: job control, SIGPIPE, etc. */
933         sigprocmask_allsigs(SIG_BLOCK);
934
935         /* Careful: we can end up here after [v]fork. Do not restore
936          * tty pgrp then, only top-level shell process does that */
937         if (G_interactive_fd && getpid() == G.root_pid)
938                 tcsetpgrp(G_interactive_fd, G.saved_tty_pgrp);
939
940         /* Not a signal, just exit */
941         if (sig <= 0)
942                 _exit(- sig);
943
944         kill_myself_with_sig(sig); /* does not return */
945 }
946
947 /* helper */
948 static void maybe_set_sighandler(int sig)
949 {
950         void (*handler)(int);
951         /* non_DFL_mask'ed signals are, well, masked,
952          * no need to set handler for them.
953          */
954         if (!((G.non_DFL_mask >> sig) & 1)) {
955                 handler = signal(sig, sigexit);
956                 if (handler == SIG_IGN) /* oops... restore back to IGN! */
957                         signal(sig, handler);
958         }
959 }
960 /* Used only to set handler to restore pgrp on exit */
961 static void set_fatal_signals_to_sigexit(void)
962 {
963         if (HUSH_DEBUG) {
964                 maybe_set_sighandler(SIGILL );
965                 maybe_set_sighandler(SIGFPE );
966                 maybe_set_sighandler(SIGBUS );
967                 maybe_set_sighandler(SIGSEGV);
968                 maybe_set_sighandler(SIGTRAP);
969         } /* else: hush is perfect. what SEGV? */
970
971         maybe_set_sighandler(SIGABRT);
972
973         /* bash 3.2 seems to handle these just like 'fatal' ones */
974         maybe_set_sighandler(SIGPIPE);
975         maybe_set_sighandler(SIGALRM);
976         maybe_set_sighandler(SIGHUP );
977
978         /* if we aren't interactive... but in this case
979          * we never want to restore pgrp on exit, and this fn is not called */
980         /*maybe_set_sighandler(SIGTERM);*/
981         /*maybe_set_sighandler(SIGINT );*/
982 }
983
984 #else /* !JOB */
985
986 #define set_fatal_signals_to_sigexit(handler) ((void)0)
987
988 #endif
989
990 /* Restores tty foreground process group, and exits. */
991 static void hush_exit(int exitcode) NORETURN;
992 static void hush_exit(int exitcode)
993 {
994         if (G.traps && G.traps[0] && G.traps[0][0]) {
995                 char *argv[] = { NULL, xstrdup(G.traps[0]), NULL };
996                 builtin_eval(argv);
997                 free(argv[1]);
998         }
999
1000 #if ENABLE_HUSH_JOB
1001         fflush(NULL); /* flush all streams */
1002         sigexit(- (exitcode & 0xff));
1003 #else
1004         exit(exitcode);
1005 #endif
1006 }
1007
1008
1009 static const char *set_cwd(void)
1010 {
1011         /* xrealloc_getcwd_or_warn(arg) calls free(arg),
1012          * we must not try to free(bb_msg_unknown) */
1013         if (G.cwd == bb_msg_unknown)
1014                 G.cwd = NULL;
1015         G.cwd = xrealloc_getcwd_or_warn((char *)G.cwd);
1016         if (!G.cwd)
1017                 G.cwd = bb_msg_unknown;
1018         return G.cwd;
1019 }
1020
1021
1022 /* Get/check local shell variables */
1023 static struct variable *get_local_var(const char *name)
1024 {
1025         struct variable *cur;
1026         int len;
1027
1028         if (!name)
1029                 return NULL;
1030         len = strlen(name);
1031         for (cur = G.top_var; cur; cur = cur->next) {
1032                 if (strncmp(cur->varstr, name, len) == 0 && cur->varstr[len] == '=')
1033                         return cur;
1034         }
1035         return NULL;
1036 }
1037
1038 static const char *get_local_var_value(const char *src)
1039 {
1040         struct variable *var = get_local_var(src);
1041         if (var)
1042                 return strchr(var->varstr, '=') + 1;
1043         return NULL;
1044 }
1045
1046 /* str holds "NAME=VAL" and is expected to be malloced.
1047  * We take ownership of it.
1048  * flg_export is used by:
1049  *  0: do not export
1050  *  1: export
1051  * -1: if NAME is set, leave export status alone
1052  *     if NAME is not set, do not export
1053  */
1054 static int set_local_var(char *str, int flg_export)
1055 {
1056         struct variable *cur;
1057         char *value;
1058         int name_len;
1059
1060         value = strchr(str, '=');
1061         if (!value) { /* not expected to ever happen? */
1062                 free(str);
1063                 return -1;
1064         }
1065
1066         name_len = value - str + 1; /* including '=' */
1067         cur = G.top_var; /* cannot be NULL (we have HUSH_VERSION and it's RO) */
1068         while (1) {
1069                 if (strncmp(cur->varstr, str, name_len) != 0) {
1070                         if (!cur->next) {
1071                                 /* Bail out. Note that now cur points
1072                                  * to last var in linked list */
1073                                 break;
1074                         }
1075                         cur = cur->next;
1076                         continue;
1077                 }
1078                 /* We found an existing var with this name */
1079                 *value = '\0';
1080                 if (cur->flg_read_only) {
1081                         bb_error_msg("%s: readonly variable", str);
1082                         free(str);
1083                         return -1;
1084                 }
1085                 debug_printf_env("%s: unsetenv '%s'\n", __func__, str);
1086                 unsetenv(str); /* just in case */
1087                 *value = '=';
1088                 if (strcmp(cur->varstr, str) == 0) {
1089  free_and_exp:
1090                         free(str);
1091                         goto exp;
1092                 }
1093                 if (cur->max_len >= strlen(str)) {
1094                         /* This one is from startup env, reuse space */
1095                         strcpy(cur->varstr, str);
1096                         goto free_and_exp;
1097                 }
1098                 /* max_len == 0 signifies "malloced" var, which we can
1099                  * (and has to) free */
1100                 if (!cur->max_len)
1101                         free(cur->varstr);
1102                 cur->max_len = 0;
1103                 goto set_str_and_exp;
1104         }
1105
1106         /* Not found - create next variable struct */
1107         cur->next = xzalloc(sizeof(*cur));
1108         cur = cur->next;
1109
1110  set_str_and_exp:
1111         cur->varstr = str;
1112  exp:
1113         if (flg_export == 1)
1114                 cur->flg_export = 1;
1115         if (cur->flg_export) {
1116                 debug_printf_env("%s: putenv '%s'\n", __func__, cur->varstr);
1117                 return putenv(cur->varstr);
1118         }
1119         return 0;
1120 }
1121
1122 static int unset_local_var(const char *name)
1123 {
1124         struct variable *cur;
1125         struct variable *prev = prev; /* for gcc */
1126         int name_len;
1127
1128         if (!name)
1129                 return EXIT_SUCCESS;
1130         name_len = strlen(name);
1131         cur = G.top_var;
1132         while (cur) {
1133                 if (strncmp(cur->varstr, name, name_len) == 0 && cur->varstr[name_len] == '=') {
1134                         if (cur->flg_read_only) {
1135                                 bb_error_msg("%s: readonly variable", name);
1136                                 return EXIT_FAILURE;
1137                         }
1138                         /* prev is ok to use here because 1st variable, HUSH_VERSION,
1139                          * is ro, and we cannot reach this code on the 1st pass */
1140                         prev->next = cur->next;
1141                         debug_printf_env("%s: unsetenv '%s'\n", __func__, cur->varstr);
1142                         bb_unsetenv(cur->varstr);
1143                         if (!cur->max_len)
1144                                 free(cur->varstr);
1145                         free(cur);
1146                         return EXIT_SUCCESS;
1147                 }
1148                 prev = cur;
1149                 cur = cur->next;
1150         }
1151         return EXIT_SUCCESS;
1152 }
1153
1154 #if ENABLE_SH_MATH_SUPPORT
1155 #define is_name(c)      ((c) == '_' || isalpha((unsigned char)(c)))
1156 #define is_in_name(c)   ((c) == '_' || isalnum((unsigned char)(c)))
1157 static char *endofname(const char *name)
1158 {
1159         char *p;
1160
1161         p = (char *) name;
1162         if (!is_name(*p))
1163                 return p;
1164         while (*++p) {
1165                 if (!is_in_name(*p))
1166                         break;
1167         }
1168         return p;
1169 }
1170
1171 static void arith_set_local_var(const char *name, const char *val, int flags)
1172 {
1173         /* arith code doesnt malloc space, so do it for it */
1174         char *var = xasprintf("%s=%s", name, val);
1175         set_local_var(var, flags);
1176 }
1177 #endif
1178
1179
1180 /*
1181  * in_str support
1182  */
1183 static int static_get(struct in_str *i)
1184 {
1185         int ch = *i->p++;
1186         if (ch != '\0')
1187                 return ch;
1188         i->p--;
1189         return EOF;
1190 }
1191
1192 static int static_peek(struct in_str *i)
1193 {
1194         return *i->p;
1195 }
1196
1197 #if ENABLE_HUSH_INTERACTIVE
1198
1199 static void cmdedit_set_initial_prompt(void)
1200 {
1201         if (ENABLE_FEATURE_EDITING_FANCY_PROMPT) {
1202                 G.PS1 = getenv("PS1");
1203                 if (G.PS1 == NULL)
1204                         G.PS1 = "\\w \\$ ";
1205         } else
1206                 G.PS1 = NULL;
1207 }
1208
1209 static const char* setup_prompt_string(int promptmode)
1210 {
1211         const char *prompt_str;
1212         debug_printf("setup_prompt_string %d ", promptmode);
1213         if (!ENABLE_FEATURE_EDITING_FANCY_PROMPT) {
1214                 /* Set up the prompt */
1215                 if (promptmode == 0) { /* PS1 */
1216                         free((char*)G.PS1);
1217                         G.PS1 = xasprintf("%s %c ", G.cwd, (geteuid() != 0) ? '$' : '#');
1218                         prompt_str = G.PS1;
1219                 } else
1220                         prompt_str = G.PS2;
1221         } else
1222                 prompt_str = (promptmode == 0) ? G.PS1 : G.PS2;
1223         debug_printf("result '%s'\n", prompt_str);
1224         return prompt_str;
1225 }
1226
1227 static void get_user_input(struct in_str *i)
1228 {
1229         int r;
1230         const char *prompt_str;
1231
1232         prompt_str = setup_prompt_string(i->promptmode);
1233 #if ENABLE_FEATURE_EDITING
1234         /* Enable command line editing only while a command line
1235          * is actually being read */
1236         do {
1237                 G.flag_SIGINT = 0;
1238                 /* buglet: SIGINT will not make new prompt to appear _at once_,
1239                  * only after <Enter>. (^C will work) */
1240                 r = read_line_input(prompt_str, G.user_input_buf, BUFSIZ-1, G.line_input_state);
1241                 /* catch *SIGINT* etc (^C is handled by read_line_input) */
1242                 check_and_run_traps(0);
1243         } while (r == 0 || G.flag_SIGINT); /* repeat if ^C or SIGINT */
1244         i->eof_flag = (r < 0);
1245         if (i->eof_flag) { /* EOF/error detected */
1246                 G.user_input_buf[0] = EOF; /* yes, it will be truncated, it's ok */
1247                 G.user_input_buf[1] = '\0';
1248         }
1249 #else
1250         do {
1251                 G.flag_SIGINT = 0;
1252                 fputs(prompt_str, stdout);
1253                 fflush(stdout);
1254                 G.user_input_buf[0] = r = fgetc(i->file);
1255                 /*G.user_input_buf[1] = '\0'; - already is and never changed */
1256 //do we need check_and_run_traps(0)? (maybe only if stdin)
1257         } while (G.flag_SIGINT);
1258         i->eof_flag = (r == EOF);
1259 #endif
1260         i->p = G.user_input_buf;
1261 }
1262
1263 #endif  /* INTERACTIVE */
1264
1265 /* This is the magic location that prints prompts
1266  * and gets data back from the user */
1267 static int file_get(struct in_str *i)
1268 {
1269         int ch;
1270
1271         /* If there is data waiting, eat it up */
1272         if (i->p && *i->p) {
1273 #if ENABLE_HUSH_INTERACTIVE
1274  take_cached:
1275 #endif
1276                 ch = *i->p++;
1277                 if (i->eof_flag && !*i->p)
1278                         ch = EOF;
1279         } else {
1280                 /* need to double check i->file because we might be doing something
1281                  * more complicated by now, like sourcing or substituting. */
1282 #if ENABLE_HUSH_INTERACTIVE
1283                 if (G_interactive_fd && i->promptme && i->file == stdin) {
1284                         do {
1285                                 get_user_input(i);
1286                         } while (!*i->p); /* need non-empty line */
1287                         i->promptmode = 1; /* PS2 */
1288                         i->promptme = 0;
1289                         goto take_cached;
1290                 }
1291 #endif
1292                 ch = fgetc(i->file);
1293         }
1294         debug_printf("file_get: got a '%c' %d\n", ch, ch);
1295 #if ENABLE_HUSH_INTERACTIVE
1296         if (ch == '\n')
1297                 i->promptme = 1;
1298 #endif
1299         return ch;
1300 }
1301
1302 /* All the callers guarantee this routine will never be
1303  * used right after a newline, so prompting is not needed.
1304  */
1305 static int file_peek(struct in_str *i)
1306 {
1307         int ch;
1308         if (i->p && *i->p) {
1309                 if (i->eof_flag && !i->p[1])
1310                         return EOF;
1311                 return *i->p;
1312         }
1313         ch = fgetc(i->file);
1314         i->eof_flag = (ch == EOF);
1315         i->peek_buf[0] = ch;
1316         i->peek_buf[1] = '\0';
1317         i->p = i->peek_buf;
1318         debug_printf("file_peek: got a '%c' %d\n", *i->p, *i->p);
1319         return ch;
1320 }
1321
1322 static void setup_file_in_str(struct in_str *i, FILE *f)
1323 {
1324         i->peek = file_peek;
1325         i->get = file_get;
1326 #if ENABLE_HUSH_INTERACTIVE
1327         i->promptme = 1;
1328         i->promptmode = 0; /* PS1 */
1329 #endif
1330         i->file = f;
1331         i->p = NULL;
1332 }
1333
1334 static void setup_string_in_str(struct in_str *i, const char *s)
1335 {
1336         i->peek = static_peek;
1337         i->get = static_get;
1338 #if ENABLE_HUSH_INTERACTIVE
1339         i->promptme = 1;
1340         i->promptmode = 0; /* PS1 */
1341 #endif
1342         i->p = s;
1343         i->eof_flag = 0;
1344 }
1345
1346
1347 /*
1348  * o_string support
1349  */
1350 #define B_CHUNK  (32 * sizeof(char*))
1351
1352 static void o_reset(o_string *o)
1353 {
1354         o->length = 0;
1355         o->nonnull = 0;
1356         if (o->data)
1357                 o->data[0] = '\0';
1358 }
1359
1360 static void o_free(o_string *o)
1361 {
1362         free(o->data);
1363         memset(o, 0, sizeof(*o));
1364 }
1365
1366 static void o_grow_by(o_string *o, int len)
1367 {
1368         if (o->length + len > o->maxlen) {
1369                 o->maxlen += (2*len > B_CHUNK ? 2*len : B_CHUNK);
1370                 o->data = xrealloc(o->data, 1 + o->maxlen);
1371         }
1372 }
1373
1374 static void o_addchr(o_string *o, int ch)
1375 {
1376         debug_printf("o_addchr: '%c' o->length=%d o=%p\n", ch, o->length, o);
1377         o_grow_by(o, 1);
1378         o->data[o->length] = ch;
1379         o->length++;
1380         o->data[o->length] = '\0';
1381 }
1382
1383 static void o_addstr(o_string *o, const char *str, int len)
1384 {
1385         o_grow_by(o, len);
1386         memcpy(&o->data[o->length], str, len);
1387         o->length += len;
1388         o->data[o->length] = '\0';
1389 }
1390
1391 static void o_addstrauto(o_string *o, const char *str)
1392 {
1393         o_addstr(o, str, strlen(str) + 1);
1394 }
1395
1396 static void o_addstr_duplicate_backslash(o_string *o, const char *str, int len)
1397 {
1398         while (len) {
1399                 o_addchr(o, *str);
1400                 if (*str++ == '\\'
1401                  && (*str != '*' && *str != '?' && *str != '[')
1402                 ) {
1403                         o_addchr(o, '\\');
1404                 }
1405                 len--;
1406         }
1407 }
1408
1409 /* My analysis of quoting semantics tells me that state information
1410  * is associated with a destination, not a source.
1411  */
1412 static void o_addqchr(o_string *o, int ch)
1413 {
1414         int sz = 1;
1415         char *found = strchr("*?[\\", ch);
1416         if (found)
1417                 sz++;
1418         o_grow_by(o, sz);
1419         if (found) {
1420                 o->data[o->length] = '\\';
1421                 o->length++;
1422         }
1423         o->data[o->length] = ch;
1424         o->length++;
1425         o->data[o->length] = '\0';
1426 }
1427
1428 static void o_addQchr(o_string *o, int ch)
1429 {
1430         int sz = 1;
1431         if (o->o_escape && strchr("*?[\\", ch)) {
1432                 sz++;
1433                 o->data[o->length] = '\\';
1434                 o->length++;
1435         }
1436         o_grow_by(o, sz);
1437         o->data[o->length] = ch;
1438         o->length++;
1439         o->data[o->length] = '\0';
1440 }
1441
1442 static void o_addQstr(o_string *o, const char *str, int len)
1443 {
1444         if (!o->o_escape) {
1445                 o_addstr(o, str, len);
1446                 return;
1447         }
1448         while (len) {
1449                 char ch;
1450                 int sz;
1451                 int ordinary_cnt = strcspn(str, "*?[\\");
1452                 if (ordinary_cnt > len) /* paranoia */
1453                         ordinary_cnt = len;
1454                 o_addstr(o, str, ordinary_cnt);
1455                 if (ordinary_cnt == len)
1456                         return;
1457                 str += ordinary_cnt;
1458                 len -= ordinary_cnt + 1; /* we are processing + 1 char below */
1459
1460                 ch = *str++;
1461                 sz = 1;
1462                 if (ch) { /* it is necessarily one of "*?[\\" */
1463                         sz++;
1464                         o->data[o->length] = '\\';
1465                         o->length++;
1466                 }
1467                 o_grow_by(o, sz);
1468                 o->data[o->length] = ch;
1469                 o->length++;
1470                 o->data[o->length] = '\0';
1471         }
1472 }
1473
1474 /* A special kind of o_string for $VAR and `cmd` expansion.
1475  * It contains char* list[] at the beginning, which is grown in 16 element
1476  * increments. Actual string data starts at the next multiple of 16 * (char*).
1477  * list[i] contains an INDEX (int!) into this string data.
1478  * It means that if list[] needs to grow, data needs to be moved higher up
1479  * but list[i]'s need not be modified.
1480  * NB: remembering how many list[i]'s you have there is crucial.
1481  * o_finalize_list() operation post-processes this structure - calculates
1482  * and stores actual char* ptrs in list[]. Oh, it NULL terminates it as well.
1483  */
1484 #if DEBUG_EXPAND || DEBUG_GLOB
1485 static void debug_print_list(const char *prefix, o_string *o, int n)
1486 {
1487         char **list = (char**)o->data;
1488         int string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
1489         int i = 0;
1490         fprintf(stderr, "%s: list:%p n:%d string_start:%d length:%d maxlen:%d\n",
1491                         prefix, list, n, string_start, o->length, o->maxlen);
1492         while (i < n) {
1493                 fprintf(stderr, " list[%d]=%d '%s' %p\n", i, (int)list[i],
1494                                 o->data + (int)list[i] + string_start,
1495                                 o->data + (int)list[i] + string_start);
1496                 i++;
1497         }
1498         if (n) {
1499                 const char *p = o->data + (int)list[n - 1] + string_start;
1500                 fprintf(stderr, " total_sz:%ld\n", (long)((p + strlen(p) + 1) - o->data));
1501         }
1502 }
1503 #else
1504 #define debug_print_list(prefix, o, n) ((void)0)
1505 #endif
1506
1507 /* n = o_save_ptr_helper(str, n) "starts new string" by storing an index value
1508  * in list[n] so that it points past last stored byte so far.
1509  * It returns n+1. */
1510 static int o_save_ptr_helper(o_string *o, int n)
1511 {
1512         char **list = (char**)o->data;
1513         int string_start;
1514         int string_len;
1515
1516         if (!o->has_empty_slot) {
1517                 string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
1518                 string_len = o->length - string_start;
1519                 if (!(n & 0xf)) { /* 0, 0x10, 0x20...? */
1520                         debug_printf_list("list[%d]=%d string_start=%d (growing)\n", n, string_len, string_start);
1521                         /* list[n] points to string_start, make space for 16 more pointers */
1522                         o->maxlen += 0x10 * sizeof(list[0]);
1523                         o->data = xrealloc(o->data, o->maxlen + 1);
1524                         list = (char**)o->data;
1525                         memmove(list + n + 0x10, list + n, string_len);
1526                         o->length += 0x10 * sizeof(list[0]);
1527                 } else
1528                         debug_printf_list("list[%d]=%d string_start=%d\n", n, string_len, string_start);
1529         } else {
1530                 /* We have empty slot at list[n], reuse without growth */
1531                 string_start = ((n+1 + 0xf) & ~0xf) * sizeof(list[0]); /* NB: n+1! */
1532                 string_len = o->length - string_start;
1533                 debug_printf_list("list[%d]=%d string_start=%d (empty slot)\n", n, string_len, string_start);
1534                 o->has_empty_slot = 0;
1535         }
1536         list[n] = (char*)(ptrdiff_t)string_len;
1537         return n + 1;
1538 }
1539
1540 /* "What was our last o_save_ptr'ed position (byte offset relative o->data)?" */
1541 static int o_get_last_ptr(o_string *o, int n)
1542 {
1543         char **list = (char**)o->data;
1544         int string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
1545
1546         return ((int)(ptrdiff_t)list[n-1]) + string_start;
1547 }
1548
1549 /* o_glob performs globbing on last list[], saving each result
1550  * as a new list[]. */
1551 static int o_glob(o_string *o, int n)
1552 {
1553         glob_t globdata;
1554         int gr;
1555         char *pattern;
1556
1557         debug_printf_glob("start o_glob: n:%d o->data:%p\n", n, o->data);
1558         if (!o->data)
1559                 return o_save_ptr_helper(o, n);
1560         pattern = o->data + o_get_last_ptr(o, n);
1561         debug_printf_glob("glob pattern '%s'\n", pattern);
1562         if (!glob_needed(pattern)) {
1563  literal:
1564                 o->length = unbackslash(pattern) - o->data;
1565                 debug_printf_glob("glob pattern '%s' is literal\n", pattern);
1566                 return o_save_ptr_helper(o, n);
1567         }
1568
1569         memset(&globdata, 0, sizeof(globdata));
1570         gr = glob(pattern, 0, NULL, &globdata);
1571         debug_printf_glob("glob('%s'):%d\n", pattern, gr);
1572         if (gr == GLOB_NOSPACE)
1573                 bb_error_msg_and_die("out of memory during glob");
1574         if (gr == GLOB_NOMATCH) {
1575                 globfree(&globdata);
1576                 goto literal;
1577         }
1578         if (gr != 0) { /* GLOB_ABORTED ? */
1579 //TODO: testcase for bad glob pattern behavior
1580                 bb_error_msg("glob(3) error %d on '%s'", gr, pattern);
1581         }
1582         if (globdata.gl_pathv && globdata.gl_pathv[0]) {
1583                 char **argv = globdata.gl_pathv;
1584                 o->length = pattern - o->data; /* "forget" pattern */
1585                 while (1) {
1586                         o_addstrauto(o, *argv);
1587                         n = o_save_ptr_helper(o, n);
1588                         argv++;
1589                         if (!*argv)
1590                                 break;
1591                 }
1592         }
1593         globfree(&globdata);
1594         if (DEBUG_GLOB)
1595                 debug_print_list("o_glob returning", o, n);
1596         return n;
1597 }
1598
1599 /* If o->o_glob == 1, glob the string so far remembered.
1600  * Otherwise, just finish current list[] and start new */
1601 static int o_save_ptr(o_string *o, int n)
1602 {
1603         if (o->o_glob) { /* if globbing is requested */
1604                 /* If o->has_empty_slot, list[n] was already globbed
1605                  * (if it was requested back then when it was filled)
1606                  * so don't do that again! */
1607                 if (!o->has_empty_slot)
1608                         return o_glob(o, n); /* o_save_ptr_helper is inside */
1609         }
1610         return o_save_ptr_helper(o, n);
1611 }
1612
1613 /* "Please convert list[n] to real char* ptrs, and NULL terminate it." */
1614 static char **o_finalize_list(o_string *o, int n)
1615 {
1616         char **list;
1617         int string_start;
1618
1619         n = o_save_ptr(o, n); /* force growth for list[n] if necessary */
1620         if (DEBUG_EXPAND)
1621                 debug_print_list("finalized", o, n);
1622         debug_printf_expand("finalized n:%d\n", n);
1623         list = (char**)o->data;
1624         string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
1625         list[--n] = NULL;
1626         while (n) {
1627                 n--;
1628                 list[n] = o->data + (int)(ptrdiff_t)list[n] + string_start;
1629         }
1630         return list;
1631 }
1632
1633
1634 /* Expansion can recurse */
1635 #if ENABLE_HUSH_TICK
1636 static int process_command_subs(o_string *dest, const char *s);
1637 #endif
1638 static char *expand_string_to_string(const char *str);
1639 static int parse_stream_dquoted(o_string *dest, struct in_str *input, int dquote_end);
1640
1641 /* expand_strvec_to_strvec() takes a list of strings, expands
1642  * all variable references within and returns a pointer to
1643  * a list of expanded strings, possibly with larger number
1644  * of strings. (Think VAR="a b"; echo $VAR).
1645  * This new list is allocated as a single malloc block.
1646  * NULL-terminated list of char* pointers is at the beginning of it,
1647  * followed by strings themself.
1648  * Caller can deallocate entire list by single free(list). */
1649
1650 /* Store given string, finalizing the word and starting new one whenever
1651  * we encounter IFS char(s). This is used for expanding variable values.
1652  * End-of-string does NOT finalize word: think about 'echo -$VAR-' */
1653 static int expand_on_ifs(o_string *output, int n, const char *str)
1654 {
1655         while (1) {
1656                 int word_len = strcspn(str, G.ifs);
1657                 if (word_len) {
1658                         if (output->o_escape || !output->o_glob)
1659                                 o_addQstr(output, str, word_len);
1660                         else /* protect backslashes against globbing up :) */
1661                                 o_addstr_duplicate_backslash(output, str, word_len);
1662                         str += word_len;
1663                 }
1664                 if (!*str)  /* EOL - do not finalize word */
1665                         break;
1666                 o_addchr(output, '\0');
1667                 debug_print_list("expand_on_ifs", output, n);
1668                 n = o_save_ptr(output, n);
1669                 str += strspn(str, G.ifs); /* skip ifs chars */
1670         }
1671         debug_print_list("expand_on_ifs[1]", output, n);
1672         return n;
1673 }
1674
1675 /* Expand all variable references in given string, adding words to list[]
1676  * at n, n+1,... positions. Return updated n (so that list[n] is next one
1677  * to be filled). This routine is extremely tricky: has to deal with
1678  * variables/parameters with whitespace, $* and $@, and constructs like
1679  * 'echo -$*-'. If you play here, you must run testsuite afterwards! */
1680 static int expand_vars_to_list(o_string *output, int n, char *arg, char or_mask)
1681 {
1682         /* or_mask is either 0 (normal case) or 0x80
1683          * (expansion of right-hand side of assignment == 1-element expand.
1684          * It will also do no globbing, and thus we must not backslash-quote!) */
1685
1686         char first_ch, ored_ch;
1687         int i;
1688         const char *val;
1689         char *p;
1690
1691         ored_ch = 0;
1692
1693         debug_printf_expand("expand_vars_to_list: arg '%s'\n", arg);
1694         debug_print_list("expand_vars_to_list", output, n);
1695         n = o_save_ptr(output, n);
1696         debug_print_list("expand_vars_to_list[0]", output, n);
1697
1698         while ((p = strchr(arg, SPECIAL_VAR_SYMBOL)) != NULL) {
1699 #if ENABLE_HUSH_TICK
1700                 o_string subst_result = NULL_O_STRING;
1701 #endif
1702 #if ENABLE_SH_MATH_SUPPORT
1703                 char arith_buf[sizeof(arith_t)*3 + 2];
1704 #endif
1705                 o_addstr(output, arg, p - arg);
1706                 debug_print_list("expand_vars_to_list[1]", output, n);
1707                 arg = ++p;
1708                 p = strchr(p, SPECIAL_VAR_SYMBOL);
1709
1710                 first_ch = arg[0] | or_mask; /* forced to "quoted" if or_mask = 0x80 */
1711                 /* "$@" is special. Even if quoted, it can still
1712                  * expand to nothing (not even an empty string) */
1713                 if ((first_ch & 0x7f) != '@')
1714                         ored_ch |= first_ch;
1715
1716                 val = NULL;
1717                 switch (first_ch & 0x7f) {
1718                 /* Highest bit in first_ch indicates that var is double-quoted */
1719                 case '$': /* pid */
1720                         val = utoa(G.root_pid);
1721                         break;
1722                 case '!': /* bg pid */
1723                         val = G.last_bg_pid ? utoa(G.last_bg_pid) : (char*)"";
1724                         break;
1725                 case '?': /* exitcode */
1726                         val = utoa(G.last_return_code);
1727                         break;
1728                 case '#': /* argc */
1729                         if (arg[1] != SPECIAL_VAR_SYMBOL)
1730                                 /* actually, it's a ${#var} */
1731                                 goto case_default;
1732                         val = utoa(G.global_argc ? G.global_argc-1 : 0);
1733                         break;
1734                 case '*':
1735                 case '@':
1736                         i = 1;
1737                         if (!G.global_argv[i])
1738                                 break;
1739                         ored_ch |= first_ch; /* do it for "$@" _now_, when we know it's not empty */
1740                         if (!(first_ch & 0x80)) { /* unquoted $* or $@ */
1741                                 smallint sv = output->o_escape;
1742                                 /* unquoted var's contents should be globbed, so don't escape */
1743                                 output->o_escape = 0;
1744                                 while (G.global_argv[i]) {
1745                                         n = expand_on_ifs(output, n, G.global_argv[i]);
1746                                         debug_printf_expand("expand_vars_to_list: argv %d (last %d)\n", i, G.global_argc - 1);
1747                                         if (G.global_argv[i++][0] && G.global_argv[i]) {
1748                                                 /* this argv[] is not empty and not last:
1749                                                  * put terminating NUL, start new word */
1750                                                 o_addchr(output, '\0');
1751                                                 debug_print_list("expand_vars_to_list[2]", output, n);
1752                                                 n = o_save_ptr(output, n);
1753                                                 debug_print_list("expand_vars_to_list[3]", output, n);
1754                                         }
1755                                 }
1756                                 output->o_escape = sv;
1757                         } else
1758                         /* If or_mask is nonzero, we handle assignment 'a=....$@.....'
1759                          * and in this case should treat it like '$*' - see 'else...' below */
1760                         if (first_ch == ('@'|0x80) && !or_mask) { /* quoted $@ */
1761                                 while (1) {
1762                                         o_addQstr(output, G.global_argv[i], strlen(G.global_argv[i]));
1763                                         if (++i >= G.global_argc)
1764                                                 break;
1765                                         o_addchr(output, '\0');
1766                                         debug_print_list("expand_vars_to_list[4]", output, n);
1767                                         n = o_save_ptr(output, n);
1768                                 }
1769                         } else { /* quoted $*: add as one word */
1770                                 while (1) {
1771                                         o_addQstr(output, G.global_argv[i], strlen(G.global_argv[i]));
1772                                         if (!G.global_argv[++i])
1773                                                 break;
1774                                         if (G.ifs[0])
1775                                                 o_addchr(output, G.ifs[0]);
1776                                 }
1777                         }
1778                         break;
1779                 case SPECIAL_VAR_SYMBOL: /* <SPECIAL_VAR_SYMBOL><SPECIAL_VAR_SYMBOL> */
1780                         /* "Empty variable", used to make "" etc to not disappear */
1781                         arg++;
1782                         ored_ch = 0x80;
1783                         break;
1784 #if ENABLE_HUSH_TICK
1785                 case '`': /* <SPECIAL_VAR_SYMBOL>`cmd<SPECIAL_VAR_SYMBOL> */
1786                         *p = '\0';
1787                         arg++;
1788 //TODO: can we just stuff it into "output" directly?
1789                         debug_printf_subst("SUBST '%s' first_ch %x\n", arg, first_ch);
1790                         process_command_subs(&subst_result, arg);
1791                         debug_printf_subst("SUBST RES '%s'\n", subst_result.data);
1792                         val = subst_result.data;
1793                         goto store_val;
1794 #endif
1795 #if ENABLE_SH_MATH_SUPPORT
1796                 case '+': { /* <SPECIAL_VAR_SYMBOL>+cmd<SPECIAL_VAR_SYMBOL> */
1797                         arith_eval_hooks_t hooks;
1798                         arith_t res;
1799                         int errcode;
1800                         char *exp_str;
1801
1802                         arg++; /* skip '+' */
1803                         *p = '\0'; /* replace trailing <SPECIAL_VAR_SYMBOL> */
1804                         debug_printf_subst("ARITH '%s' first_ch %x\n", arg, first_ch);
1805
1806                         /* Optional: skip expansion if expr is simple ("a + 3", "i++" etc) */
1807                         exp_str = arg;
1808                         while (1) {
1809                                 unsigned char c = *exp_str++;
1810                                 if (c == '\0') {
1811                                         exp_str = NULL;
1812                                         goto skip_expand;
1813                                 }
1814                                 if (isdigit(c))
1815                                         continue;
1816                                 if (strchr(" \t+-*/%_", c) != NULL)
1817                                         continue;
1818                                 c |= 0x20; /* tolower */
1819                                 if (c >= 'a' && c <= 'z')
1820                                         continue;
1821                                 break;
1822                         }
1823                         /* We need to expand. Example: "echo $(($a + 1)) $((1 + $((2)) ))" */
1824                         {
1825                                 struct in_str input;
1826                                 o_string dest = NULL_O_STRING;
1827
1828                                 setup_string_in_str(&input, arg);
1829                                 parse_stream_dquoted(&dest, &input, EOF);
1830                                 //bb_error_msg("'%s' -> '%s'", arg, dest.data);
1831                                 exp_str = expand_string_to_string(dest.data);
1832                                 //bb_error_msg("'%s' -> '%s'", dest.data, exp_str);
1833                                 o_free(&dest);
1834                         }
1835  skip_expand:
1836                         hooks.lookupvar = get_local_var_value;
1837                         hooks.setvar = arith_set_local_var;
1838                         hooks.endofname = endofname;
1839                         res = arith(exp_str ? exp_str : arg, &errcode, &hooks);
1840                         free(exp_str);
1841
1842                         if (errcode < 0) {
1843                                 switch (errcode) {
1844                                 case -3: maybe_die("arith", "exponent less than 0"); break;
1845                                 case -2: maybe_die("arith", "divide by zero"); break;
1846                                 case -5: maybe_die("arith", "expression recursion loop detected"); break;
1847                                 default: maybe_die("arith", "syntax error"); break;
1848                                 }
1849                         }
1850                         debug_printf_subst("ARITH RES '"arith_t_fmt"'\n", res);
1851                         sprintf(arith_buf, arith_t_fmt, res);
1852                         val = arith_buf;
1853                         break;
1854                 }
1855 #endif
1856                 default: /* <SPECIAL_VAR_SYMBOL>varname<SPECIAL_VAR_SYMBOL> */
1857                 case_default: {
1858                         bool exp_len = false, exp_null = false;
1859                         char *var = arg, exp_save, exp_op, *exp_word;
1860                         size_t exp_off = 0;
1861                         *p = '\0';
1862                         arg[0] = first_ch & 0x7f;
1863
1864                         /* prepare for expansions */
1865                         if (var[0] == '#') {
1866                                 /* handle length expansion ${#var} */
1867                                 exp_len = true;
1868                                 ++var;
1869                         } else {
1870                                 /* maybe handle parameter expansion */
1871                                 exp_off = strcspn(var, ":-=+?");
1872                                 if (!var[exp_off])
1873                                         exp_off = 0;
1874                                 if (exp_off) {
1875                                         exp_save = var[exp_off];
1876                                         exp_null = exp_save == ':';
1877                                         exp_word = var + exp_off;
1878                                         if (exp_null) ++exp_word;
1879                                         exp_op = *exp_word++;
1880                                         var[exp_off] = '\0';
1881                                 }
1882                         }
1883
1884                         /* lookup the variable in question */
1885                         if (isdigit(var[0])) {
1886                                 /* handle_dollar() should have vetted var for us */
1887                                 i = xatoi_u(var);
1888                                 if (i < G.global_argc)
1889                                         val = G.global_argv[i];
1890                                 /* else val remains NULL: $N with too big N */
1891                         } else
1892                                 val = get_local_var_value(var);
1893
1894                         /* handle any expansions */
1895                         if (exp_len) {
1896                                 debug_printf_expand("expand: length of '%s' = ", val);
1897                                 val = utoa(val ? strlen(val) : 0);
1898                                 debug_printf_expand("%s\n", val);
1899                         } else if (exp_off) {
1900                                 /* we need to do an expansion */
1901                                 int exp_test = (!val || (exp_null && !val[0]));
1902                                 if (exp_op == '+')
1903                                         exp_test = !exp_test;
1904                                 debug_printf_expand("expand: op:%c (null:%s) test:%i\n", exp_op,
1905                                         exp_null ? "true" : "false", exp_test);
1906                                 if (exp_test) {
1907                                         if (exp_op == '?')
1908                                                 maybe_die(var, *exp_word ? exp_word : "parameter null or not set");
1909                                         else
1910                                                 val = exp_word;
1911
1912                                         if (exp_op == '=') {
1913                                                 if (isdigit(var[0]) || var[0] == '#') {
1914                                                         maybe_die(var, "special vars cannot assign in this way");
1915                                                         val = NULL;
1916                                                 } else {
1917                                                         char *new_var = xmalloc(strlen(var) + strlen(val) + 2);
1918                                                         sprintf(new_var, "%s=%s", var, val);
1919                                                         set_local_var(new_var, -1);
1920                                                 }
1921                                         }
1922                                 }
1923                                 var[exp_off] = exp_save;
1924                         }
1925
1926                         arg[0] = first_ch;
1927
1928 #if ENABLE_HUSH_TICK
1929  store_val:
1930 #endif
1931                         if (!(first_ch & 0x80)) { /* unquoted $VAR */
1932                                 debug_printf_expand("unquoted '%s', output->o_escape:%d\n", val, output->o_escape);
1933                                 if (val) {
1934                                         /* unquoted var's contents should be globbed, so don't escape */
1935                                         smallint sv = output->o_escape;
1936                                         output->o_escape = 0;
1937                                         n = expand_on_ifs(output, n, val);
1938                                         val = NULL;
1939                                         output->o_escape = sv;
1940                                 }
1941                         } else { /* quoted $VAR, val will be appended below */
1942                                 debug_printf_expand("quoted '%s', output->o_escape:%d\n", val, output->o_escape);
1943                         }
1944                 } /* default: */
1945                 } /* switch (char after <SPECIAL_VAR_SYMBOL>) */
1946                 if (val) {
1947                         o_addQstr(output, val, strlen(val));
1948                 }
1949                 /* Do the check to avoid writing to a const string */
1950                 if (*p != SPECIAL_VAR_SYMBOL)
1951                         *p = SPECIAL_VAR_SYMBOL;
1952
1953 #if ENABLE_HUSH_TICK
1954                 o_free(&subst_result);
1955 #endif
1956                 arg = ++p;
1957         } /* end of "while (SPECIAL_VAR_SYMBOL is found) ..." */
1958
1959         if (arg[0]) {
1960                 debug_print_list("expand_vars_to_list[a]", output, n);
1961                 /* this part is literal, and it was already pre-quoted
1962                  * if needed (much earlier), do not use o_addQstr here! */
1963                 o_addstrauto(output, arg);
1964                 debug_print_list("expand_vars_to_list[b]", output, n);
1965         } else if (output->length == o_get_last_ptr(output, n) /* expansion is empty */
1966          && !(ored_ch & 0x80) /* and all vars were not quoted. */
1967         ) {
1968                 n--;
1969                 /* allow to reuse list[n] later without re-growth */
1970                 output->has_empty_slot = 1;
1971         } else {
1972                 o_addchr(output, '\0');
1973         }
1974         return n;
1975 }
1976
1977 static char **expand_variables(char **argv, int or_mask)
1978 {
1979         int n;
1980         char **list;
1981         char **v;
1982         o_string output = NULL_O_STRING;
1983
1984         if (or_mask & 0x100) {
1985                 output.o_escape = 1; /* protect against globbing for "$var" */
1986                 /* (unquoted $var will temporarily switch it off) */
1987                 output.o_glob = 1;
1988         }
1989
1990         n = 0;
1991         v = argv;
1992         while (*v) {
1993                 n = expand_vars_to_list(&output, n, *v, (char)or_mask);
1994                 v++;
1995         }
1996         debug_print_list("expand_variables", &output, n);
1997
1998         /* output.data (malloced in one block) gets returned in "list" */
1999         list = o_finalize_list(&output, n);
2000         debug_print_strings("expand_variables[1]", list);
2001         return list;
2002 }
2003
2004 static char **expand_strvec_to_strvec(char **argv)
2005 {
2006         return expand_variables(argv, 0x100);
2007 }
2008
2009 /* Used for expansion of right hand of assignments */
2010 /* NB: should NOT do globbing! "export v=/bin/c*; env | grep ^v=" outputs
2011  * "v=/bin/c*" */
2012 static char *expand_string_to_string(const char *str)
2013 {
2014         char *argv[2], **list;
2015
2016         argv[0] = (char*)str;
2017         argv[1] = NULL;
2018         list = expand_variables(argv, 0x80); /* 0x80: make one-element expansion */
2019         if (HUSH_DEBUG)
2020                 if (!list[0] || list[1])
2021                         bb_error_msg_and_die("BUG in varexp2");
2022         /* actually, just move string 2*sizeof(char*) bytes back */
2023         overlapping_strcpy((char*)list, list[0]);
2024         debug_printf_expand("string_to_string='%s'\n", (char*)list);
2025         return (char*)list;
2026 }
2027
2028 /* Used for "eval" builtin */
2029 static char* expand_strvec_to_string(char **argv)
2030 {
2031         char **list;
2032
2033         list = expand_variables(argv, 0x80);
2034         /* Convert all NULs to spaces */
2035         if (list[0]) {
2036                 int n = 1;
2037                 while (list[n]) {
2038                         if (HUSH_DEBUG)
2039                                 if (list[n-1] + strlen(list[n-1]) + 1 != list[n])
2040                                         bb_error_msg_and_die("BUG in varexp3");
2041                         list[n][-1] = ' '; /* TODO: or to G.ifs[0]? */
2042                         n++;
2043                 }
2044         }
2045         overlapping_strcpy((char*)list, list[0]);
2046         debug_printf_expand("strvec_to_string='%s'\n", (char*)list);
2047         return (char*)list;
2048 }
2049
2050 static char **expand_assignments(char **argv, int count)
2051 {
2052         int i;
2053         char **p = NULL;
2054         /* Expand assignments into one string each */
2055         for (i = 0; i < count; i++) {
2056                 p = add_string_to_strings(p, expand_string_to_string(argv[i]));
2057         }
2058         return p;
2059 }
2060
2061
2062 /* squirrel != NULL means we squirrel away copies of stdin, stdout,
2063  * and stderr if they are redirected. */
2064 static int setup_redirects(struct command *prog, int squirrel[])
2065 {
2066         int openfd, mode;
2067         struct redir_struct *redir;
2068
2069         for (redir = prog->redirects; redir; redir = redir->next) {
2070                 if (redir->dup == -1 && redir->rd_filename == NULL) {
2071                         /* something went wrong in the parse.  Pretend it didn't happen */
2072                         continue;
2073                 }
2074                 if (redir->dup == -1) {
2075                         char *p;
2076                         mode = redir_table[redir->rd_type].mode;
2077 //TODO: check redir for names like '\\'
2078                         p = expand_string_to_string(redir->rd_filename);
2079                         openfd = open_or_warn(p, mode);
2080                         free(p);
2081                         if (openfd < 0) {
2082                         /* this could get lost if stderr has been redirected, but
2083                            bash and ash both lose it as well (though zsh doesn't!) */
2084                                 return 1;
2085                         }
2086                 } else {
2087                         openfd = redir->dup;
2088                 }
2089
2090                 if (openfd != redir->fd) {
2091                         if (squirrel && redir->fd < 3) {
2092                                 squirrel[redir->fd] = dup(redir->fd);
2093                         }
2094                         if (openfd == -3) {
2095                                 //close(openfd); // close(-3) ??!
2096                         } else {
2097                                 dup2(openfd, redir->fd);
2098                                 if (redir->dup == -1)
2099                                         close(openfd);
2100                         }
2101                 }
2102         }
2103         return 0;
2104 }
2105
2106 static void restore_redirects(int squirrel[])
2107 {
2108         int i, fd;
2109         for (i = 0; i < 3; i++) {
2110                 fd = squirrel[i];
2111                 if (fd != -1) {
2112                         /* We simply die on error */
2113                         xmove_fd(fd, i);
2114                 }
2115         }
2116 }
2117
2118
2119 #if !defined(DEBUG_CLEAN)
2120 #define free_pipe_list(head, indent) free_pipe_list(head)
2121 #define free_pipe(pi, indent)        free_pipe(pi)
2122 #endif
2123 static void free_pipe_list(struct pipe *head, int indent);
2124
2125 /* return code is the exit status of the pipe */
2126 static void free_pipe(struct pipe *pi, int indent)
2127 {
2128         char **p;
2129         struct command *command;
2130         struct redir_struct *r, *rnext;
2131         int a, i;
2132
2133         if (pi->stopped_cmds > 0)
2134                 return;
2135         debug_printf_clean("%s run pipe: (pid %d)\n", indenter(indent), getpid());
2136         for (i = 0; i < pi->num_cmds; i++) {
2137                 command = &pi->cmds[i];
2138                 debug_printf_clean("%s  command %d:\n", indenter(indent), i);
2139                 if (command->argv) {
2140                         for (a = 0, p = command->argv; *p; a++, p++) {
2141                                 debug_printf_clean("%s   argv[%d] = %s\n", indenter(indent), a, *p);
2142                         }
2143                         free_strings(command->argv);
2144                         command->argv = NULL;
2145                 }
2146                 /* not "else if": on syntax error, we may have both! */
2147                 if (command->group) {
2148                         debug_printf_clean("%s   begin group (grp_type:%d)\n", indenter(indent), command->grp_type);
2149                         free_pipe_list(command->group, indent+3);
2150                         debug_printf_clean("%s   end group\n", indenter(indent));
2151                         command->group = NULL;
2152                 }
2153                 for (r = command->redirects; r; r = rnext) {
2154                         debug_printf_clean("%s   redirect %d%s", indenter(indent), r->fd, redir_table[r->rd_type].descrip);
2155                         if (r->dup == -1) {
2156                                 /* guard against the case >$FOO, where foo is unset or blank */
2157                                 if (r->rd_filename) {
2158                                         debug_printf_clean(" %s\n", r->rd_filename);
2159                                         free(r->rd_filename);
2160                                         r->rd_filename = NULL;
2161                                 }
2162                         } else {
2163                                 debug_printf_clean("&%d\n", r->dup);
2164                         }
2165                         rnext = r->next;
2166                         free(r);
2167                 }
2168                 command->redirects = NULL;
2169         }
2170         free(pi->cmds);   /* children are an array, they get freed all at once */
2171         pi->cmds = NULL;
2172 #if ENABLE_HUSH_JOB
2173         free(pi->cmdtext);
2174         pi->cmdtext = NULL;
2175 #endif
2176 }
2177
2178 static void free_pipe_list(struct pipe *head, int indent)
2179 {
2180         struct pipe *pi, *next;
2181
2182         for (pi = head; pi; pi = next) {
2183 #if HAS_KEYWORDS
2184                 debug_printf_clean("%s pipe reserved mode %d\n", indenter(indent), pi->res_word);
2185 #endif
2186                 free_pipe(pi, indent);
2187                 debug_printf_clean("%s pipe followup code %d\n", indenter(indent), pi->followup);
2188                 next = pi->next;
2189                 /*pi->next = NULL;*/
2190                 free(pi);
2191         }
2192 }
2193
2194
2195 #if !BB_MMU
2196 typedef struct nommu_save_t {
2197         char **new_env;
2198         char **old_env;
2199         char **argv;
2200 } nommu_save_t;
2201 #else
2202 #define pseudo_exec_argv(nommu_save, argv, assignment_cnt, argv_expanded) \
2203         pseudo_exec_argv(argv, assignment_cnt, argv_expanded)
2204 #define pseudo_exec(nommu_save, command, argv_expanded) \
2205         pseudo_exec(command, argv_expanded)
2206 #endif
2207
2208 /* Called after [v]fork() in run_pipe(), or from builtin_exec().
2209  * Never returns.
2210  * XXX no exit() here.  If you don't exec, use _exit instead.
2211  * The at_exit handlers apparently confuse the calling process,
2212  * in particular stdin handling.  Not sure why? -- because of vfork! (vda) */
2213 static void pseudo_exec_argv(nommu_save_t *nommu_save, char **argv, int assignment_cnt, char **argv_expanded) NORETURN;
2214 static void pseudo_exec_argv(nommu_save_t *nommu_save, char **argv, int assignment_cnt, char **argv_expanded)
2215 {
2216         int rcode;
2217         char **new_env;
2218         const struct built_in_command *x;
2219
2220         /* If a variable is assigned in a forest, and nobody listens,
2221          * was it ever really set?
2222          */
2223         if (!argv[assignment_cnt])
2224                 _exit(EXIT_SUCCESS);
2225
2226         new_env = expand_assignments(argv, assignment_cnt);
2227 #if BB_MMU
2228         putenv_all(new_env);
2229         free(new_env); /* optional */
2230 #else
2231         nommu_save->new_env = new_env;
2232         nommu_save->old_env = putenv_all_and_save_old(new_env);
2233 #endif
2234         if (argv_expanded) {
2235                 argv = argv_expanded;
2236         } else {
2237                 argv = expand_strvec_to_strvec(argv + assignment_cnt);
2238 #if !BB_MMU
2239                 nommu_save->argv = argv;
2240 #endif
2241         }
2242
2243         /*
2244          * Check if the command matches any of the builtins.
2245          * Depending on context, this might be redundant.  But it's
2246          * easier to waste a few CPU cycles than it is to figure out
2247          * if this is one of those cases.
2248          */
2249         for (x = bltins; x != &bltins[ARRAY_SIZE(bltins)]; x++) {
2250                 if (strcmp(argv[0], x->cmd) == 0) {
2251                         debug_printf_exec("running builtin '%s'\n", argv[0]);
2252                         rcode = x->function(argv);
2253                         fflush(stdout);
2254                         _exit(rcode);
2255                 }
2256         }
2257
2258         /* Check if the command matches any busybox applets */
2259 #if ENABLE_FEATURE_SH_STANDALONE
2260         if (strchr(argv[0], '/') == NULL) {
2261                 int a = find_applet_by_name(argv[0]);
2262                 if (a >= 0) {
2263                         if (APPLET_IS_NOEXEC(a)) {
2264                                 debug_printf_exec("running applet '%s'\n", argv[0]);
2265 // is it ok that run_applet_no_and_exit() does exit(), not _exit()?
2266                                 run_applet_no_and_exit(a, argv);
2267                         }
2268                         /* re-exec ourselves with the new arguments */
2269                         debug_printf_exec("re-execing applet '%s'\n", argv[0]);
2270                         execvp(bb_busybox_exec_path, argv);
2271                         /* If they called chroot or otherwise made the binary no longer
2272                          * executable, fall through */
2273                 }
2274         }
2275 #endif
2276
2277         sigprocmask(SIG_SETMASK, &G.inherited_set, NULL);
2278
2279         debug_printf_exec("execing '%s'\n", argv[0]);
2280         execvp(argv[0], argv);
2281         bb_perror_msg("can't exec '%s'", argv[0]);
2282         _exit(EXIT_FAILURE);
2283 }
2284
2285 static int run_list(struct pipe *pi);
2286
2287 /* Called after [v]fork() in run_pipe()
2288  */
2289 static void pseudo_exec(nommu_save_t *nommu_save, struct command *command, char **argv_expanded) NORETURN;
2290 static void pseudo_exec(nommu_save_t *nommu_save, struct command *command, char **argv_expanded)
2291 {
2292         if (command->argv)
2293                 pseudo_exec_argv(nommu_save, command->argv, command->assignment_cnt, argv_expanded);
2294
2295         if (command->group) {
2296 #if !BB_MMU
2297                 bb_error_msg_and_die("nested lists are not supported on NOMMU");
2298 #else
2299                 int rcode;
2300                 debug_printf_exec("pseudo_exec: run_list\n");
2301                 rcode = run_list(command->group);
2302                 /* OK to leak memory by not calling free_pipe_list,
2303                  * since this process is about to exit */
2304                 _exit(rcode);
2305 #endif
2306         }
2307
2308         /* Can happen.  See what bash does with ">foo" by itself. */
2309         debug_printf("trying to pseudo_exec null command\n");
2310         _exit(EXIT_SUCCESS);
2311 }
2312
2313 #if ENABLE_HUSH_JOB
2314 static const char *get_cmdtext(struct pipe *pi)
2315 {
2316         char **argv;
2317         char *p;
2318         int len;
2319
2320         /* This is subtle. ->cmdtext is created only on first backgrounding.
2321          * (Think "cat, <ctrl-z>, fg, <ctrl-z>, fg, <ctrl-z>...." here...)
2322          * On subsequent bg argv is trashed, but we won't use it */
2323         if (pi->cmdtext)
2324                 return pi->cmdtext;
2325         argv = pi->cmds[0].argv;
2326         if (!argv || !argv[0]) {
2327                 pi->cmdtext = xzalloc(1);
2328                 return pi->cmdtext;
2329         }
2330
2331         len = 0;
2332         do len += strlen(*argv) + 1; while (*++argv);
2333         pi->cmdtext = p = xmalloc(len);
2334         argv = pi->cmds[0].argv;
2335         do {
2336                 len = strlen(*argv);
2337                 memcpy(p, *argv, len);
2338                 p += len;
2339                 *p++ = ' ';
2340         } while (*++argv);
2341         p[-1] = '\0';
2342         return pi->cmdtext;
2343 }
2344
2345 static void insert_bg_job(struct pipe *pi)
2346 {
2347         struct pipe *thejob;
2348         int i;
2349
2350         /* Linear search for the ID of the job to use */
2351         pi->jobid = 1;
2352         for (thejob = G.job_list; thejob; thejob = thejob->next)
2353                 if (thejob->jobid >= pi->jobid)
2354                         pi->jobid = thejob->jobid + 1;
2355
2356         /* Add thejob to the list of running jobs */
2357         if (!G.job_list) {
2358                 thejob = G.job_list = xmalloc(sizeof(*thejob));
2359         } else {
2360                 for (thejob = G.job_list; thejob->next; thejob = thejob->next)
2361                         continue;
2362                 thejob->next = xmalloc(sizeof(*thejob));
2363                 thejob = thejob->next;
2364         }
2365
2366         /* Physically copy the struct job */
2367         memcpy(thejob, pi, sizeof(struct pipe));
2368         thejob->cmds = xzalloc(sizeof(pi->cmds[0]) * pi->num_cmds);
2369         /* We cannot copy entire pi->cmds[] vector! Double free()s will happen */
2370         for (i = 0; i < pi->num_cmds; i++) {
2371 // TODO: do we really need to have so many fields which are just dead weight
2372 // at execution stage?
2373                 thejob->cmds[i].pid = pi->cmds[i].pid;
2374                 /* all other fields are not used and stay zero */
2375         }
2376         thejob->next = NULL;
2377         thejob->cmdtext = xstrdup(get_cmdtext(pi));
2378
2379         /* We don't wait for background thejobs to return -- append it
2380            to the list of backgrounded thejobs and leave it alone */
2381         if (G_interactive_fd)
2382                 printf("[%d] %d %s\n", thejob->jobid, thejob->cmds[0].pid, thejob->cmdtext);
2383         G.last_bg_pid = thejob->cmds[0].pid;
2384         G.last_jobid = thejob->jobid;
2385 }
2386
2387 static void remove_bg_job(struct pipe *pi)
2388 {
2389         struct pipe *prev_pipe;
2390
2391         if (pi == G.job_list) {
2392                 G.job_list = pi->next;
2393         } else {
2394                 prev_pipe = G.job_list;
2395                 while (prev_pipe->next != pi)
2396                         prev_pipe = prev_pipe->next;
2397                 prev_pipe->next = pi->next;
2398         }
2399         if (G.job_list)
2400                 G.last_jobid = G.job_list->jobid;
2401         else
2402                 G.last_jobid = 0;
2403 }
2404
2405 /* Remove a backgrounded job */
2406 static void delete_finished_bg_job(struct pipe *pi)
2407 {
2408         remove_bg_job(pi);
2409         pi->stopped_cmds = 0;
2410         free_pipe(pi, 0);
2411         free(pi);
2412 }
2413 #endif /* JOB */
2414
2415 /* Check to see if any processes have exited -- if they
2416  * have, figure out why and see if a job has completed */
2417 static int checkjobs(struct pipe* fg_pipe)
2418 {
2419         int attributes;
2420         int status;
2421 #if ENABLE_HUSH_JOB
2422         struct pipe *pi;
2423 #endif
2424         pid_t childpid;
2425         int rcode = 0;
2426
2427         debug_printf_jobs("checkjobs %p\n", fg_pipe);
2428
2429         errno = 0;
2430 //      if (G.handled_SIGCHLD == G.count_SIGCHLD)
2431 //              /* avoid doing syscall, nothing there anyway */
2432 //              return rcode;
2433
2434         attributes = WUNTRACED;
2435         if (fg_pipe == NULL)
2436                 attributes |= WNOHANG;
2437
2438 /* Do we do this right?
2439  * bash-3.00# sleep 20 | false
2440  * <ctrl-Z pressed>
2441  * [3]+  Stopped          sleep 20 | false
2442  * bash-3.00# echo $?
2443  * 1   <========== bg pipe is not fully done, but exitcode is already known!
2444  */
2445
2446 //FIXME: non-interactive bash does not continue even if all processes in fg pipe
2447 //are stopped. Testcase: "cat | cat" in a script (not on command line)
2448 // + killall -STOP cat
2449
2450  wait_more:
2451         while (1) {
2452                 int i;
2453                 int dead;
2454
2455 //              i = G.count_SIGCHLD;
2456                 childpid = waitpid(-1, &status, attributes);
2457                 if (childpid <= 0) {
2458                         if (childpid && errno != ECHILD)
2459                                 bb_perror_msg("waitpid");
2460 //                      else /* Until next SIGCHLD, waitpid's are useless */
2461 //                              G.handled_SIGCHLD = i;
2462                         break;
2463                 }
2464                 dead = WIFEXITED(status) || WIFSIGNALED(status);
2465
2466 #if DEBUG_JOBS
2467                 if (WIFSTOPPED(status))
2468                         debug_printf_jobs("pid %d stopped by sig %d (exitcode %d)\n",
2469                                         childpid, WSTOPSIG(status), WEXITSTATUS(status));
2470                 if (WIFSIGNALED(status))
2471                         debug_printf_jobs("pid %d killed by sig %d (exitcode %d)\n",
2472                                         childpid, WTERMSIG(status), WEXITSTATUS(status));
2473                 if (WIFEXITED(status))
2474                         debug_printf_jobs("pid %d exited, exitcode %d\n",
2475                                         childpid, WEXITSTATUS(status));
2476 #endif
2477                 /* Were we asked to wait for fg pipe? */
2478                 if (fg_pipe) {
2479                         for (i = 0; i < fg_pipe->num_cmds; i++) {
2480                                 debug_printf_jobs("check pid %d\n", fg_pipe->cmds[i].pid);
2481                                 if (fg_pipe->cmds[i].pid != childpid)
2482                                         continue;
2483                                 /* printf("process %d exit %d\n", i, WEXITSTATUS(status)); */
2484                                 if (dead) {
2485                                         fg_pipe->cmds[i].pid = 0;
2486                                         fg_pipe->alive_cmds--;
2487                                         if (i == fg_pipe->num_cmds - 1) {
2488                                                 /* last process gives overall exitstatus */
2489                                                 rcode = WEXITSTATUS(status);
2490                                                 IF_HAS_KEYWORDS(if (fg_pipe->pi_inverted) rcode = !rcode;)
2491                                         }
2492                                 } else {
2493                                         fg_pipe->cmds[i].is_stopped = 1;
2494                                         fg_pipe->stopped_cmds++;
2495                                 }
2496                                 debug_printf_jobs("fg_pipe: alive_cmds %d stopped_cmds %d\n",
2497                                                 fg_pipe->alive_cmds, fg_pipe->stopped_cmds);
2498                                 if (fg_pipe->alive_cmds - fg_pipe->stopped_cmds <= 0) {
2499                                         /* All processes in fg pipe have exited/stopped */
2500 #if ENABLE_HUSH_JOB
2501                                         if (fg_pipe->alive_cmds)
2502                                                 insert_bg_job(fg_pipe);
2503 #endif
2504                                         return rcode;
2505                                 }
2506                                 /* There are still running processes in the fg pipe */
2507                                 goto wait_more; /* do waitpid again */
2508                         }
2509                         /* it wasnt fg_pipe, look for process in bg pipes */
2510                 }
2511
2512 #if ENABLE_HUSH_JOB
2513                 /* We asked to wait for bg or orphaned children */
2514                 /* No need to remember exitcode in this case */
2515                 for (pi = G.job_list; pi; pi = pi->next) {
2516                         for (i = 0; i < pi->num_cmds; i++) {
2517                                 if (pi->cmds[i].pid == childpid)
2518                                         goto found_pi_and_prognum;
2519                         }
2520                 }
2521                 /* Happens when shell is used as init process (init=/bin/sh) */
2522                 debug_printf("checkjobs: pid %d was not in our list!\n", childpid);
2523                 continue; /* do waitpid again */
2524
2525  found_pi_and_prognum:
2526                 if (dead) {
2527                         /* child exited */
2528                         pi->cmds[i].pid = 0;
2529                         pi->alive_cmds--;
2530                         if (!pi->alive_cmds) {
2531                                 if (G_interactive_fd)
2532                                         printf(JOB_STATUS_FORMAT, pi->jobid,
2533                                                         "Done", pi->cmdtext);
2534                                 delete_finished_bg_job(pi);
2535                         }
2536                 } else {
2537                         /* child stopped */
2538                         pi->cmds[i].is_stopped = 1;
2539                         pi->stopped_cmds++;
2540                 }
2541 #endif
2542         } /* while (waitpid succeeds)... */
2543
2544         return rcode;
2545 }
2546
2547 #if ENABLE_HUSH_JOB
2548 static int checkjobs_and_fg_shell(struct pipe* fg_pipe)
2549 {
2550         pid_t p;
2551         int rcode = checkjobs(fg_pipe);
2552         /* Job finished, move the shell to the foreground */
2553         p = getpgid(0); /* pgid of our process */
2554         debug_printf_jobs("fg'ing ourself: getpgid(0)=%d\n", (int)p);
2555         tcsetpgrp(G_interactive_fd, p);
2556         return rcode;
2557 }
2558 #endif
2559
2560 /* run_pipe() starts all the jobs, but doesn't wait for anything
2561  * to finish.  See checkjobs().
2562  *
2563  * return code is normally -1, when the caller has to wait for children
2564  * to finish to determine the exit status of the pipe.  If the pipe
2565  * is a simple builtin command, however, the action is done by the
2566  * time run_pipe returns, and the exit code is provided as the
2567  * return value.
2568  *
2569  * The input of the pipe is always stdin, the output is always
2570  * stdout.  The outpipe[] mechanism in BusyBox-0.48 lash is bogus,
2571  * because it tries to avoid running the command substitution in
2572  * subshell, when that is in fact necessary.  The subshell process
2573  * now has its stdout directed to the input of the appropriate pipe,
2574  * so this routine is noticeably simpler.
2575  *
2576  * Returns -1 only if started some children. IOW: we have to
2577  * mask out retvals of builtins etc with 0xff!
2578  */
2579 static int run_pipe(struct pipe *pi)
2580 {
2581         int i;
2582         int nextin;
2583         int pipefds[2];         /* pipefds[0] is for reading */
2584         struct command *command;
2585         char **argv_expanded;
2586         char **argv;
2587         const struct built_in_command *x;
2588         char *p;
2589         /* it is not always needed, but we aim to smaller code */
2590         int squirrel[] = { -1, -1, -1 };
2591         int rcode;
2592         const int single_and_fg = (pi->num_cmds == 1 && pi->followup != PIPE_BG);
2593
2594         debug_printf_exec("run_pipe start: single_and_fg=%d\n", single_and_fg);
2595
2596 #if ENABLE_HUSH_JOB
2597         pi->pgrp = -1;
2598 #endif
2599         pi->alive_cmds = 1;
2600         pi->stopped_cmds = 0;
2601
2602         /* Check if this is a simple builtin (not part of a pipe).
2603          * Builtins within pipes have to fork anyway, and are handled in
2604          * pseudo_exec.  "echo foo | read bar" doesn't work on bash, either.
2605          */
2606         command = &(pi->cmds[0]);
2607
2608 #if ENABLE_HUSH_FUNCTIONS
2609         if (single_and_fg && command->group && command->grp_type == GRP_FUNCTION) {
2610                 /* We "execute" function definition */
2611                 bb_error_msg("here we ought to remember function definition, and go on");
2612                 return EXIT_SUCCESS;
2613         }
2614 #endif
2615
2616         if (single_and_fg && command->group && command->grp_type == GRP_NORMAL) {
2617                 debug_printf("non-subshell grouping\n");
2618                 setup_redirects(command, squirrel);
2619                 debug_printf_exec(": run_list\n");
2620                 rcode = run_list(command->group) & 0xff;
2621                 restore_redirects(squirrel);
2622                 debug_printf_exec("run_pipe return %d\n", rcode);
2623                 IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
2624                 return rcode;
2625         }
2626
2627         argv = command->argv;
2628         argv_expanded = NULL;
2629
2630         if (single_and_fg && argv != NULL) {
2631                 char **new_env = NULL;
2632                 char **old_env = NULL;
2633
2634                 i = command->assignment_cnt;
2635                 if (i != 0 && argv[i] == NULL) {
2636                         /* assignments, but no command: set local environment */
2637                         for (i = 0; argv[i] != NULL; i++) {
2638                                 debug_printf("local environment set: %s\n", argv[i]);
2639                                 p = expand_string_to_string(argv[i]);
2640                                 set_local_var(p, 0);
2641                         }
2642                         return EXIT_SUCCESS; /* don't worry about errors in set_local_var() yet */
2643                 }
2644
2645                 /* Expand the rest into (possibly) many strings each */
2646                 argv_expanded = expand_strvec_to_strvec(argv + i);
2647
2648                 for (x = bltins; x != &bltins[ARRAY_SIZE(bltins)]; x++) {
2649                         if (strcmp(argv_expanded[0], x->cmd) != 0)
2650                                 continue;
2651                         if (x->function == builtin_exec && argv_expanded[1] == NULL) {
2652                                 debug_printf("exec with redirects only\n");
2653                                 setup_redirects(command, NULL);
2654                                 rcode = EXIT_SUCCESS;
2655                                 goto clean_up_and_ret1;
2656                         }
2657                         debug_printf("builtin inline %s\n", argv_expanded[0]);
2658                         /* XXX setup_redirects acts on file descriptors, not FILEs.
2659                          * This is perfect for work that comes after exec().
2660                          * Is it really safe for inline use?  Experimentally,
2661                          * things seem to work with glibc. */
2662                         setup_redirects(command, squirrel);
2663                         new_env = expand_assignments(argv, command->assignment_cnt);
2664                         old_env = putenv_all_and_save_old(new_env);
2665                         debug_printf_exec(": builtin '%s' '%s'...\n", x->cmd, argv_expanded[1]);
2666                         rcode = x->function(argv_expanded) & 0xff;
2667 #if ENABLE_FEATURE_SH_STANDALONE
2668  clean_up_and_ret:
2669 #endif
2670                         restore_redirects(squirrel);
2671                         free_strings_and_unsetenv(new_env, 1);
2672                         putenv_all(old_env);
2673                         free(old_env); /* not free_strings()! */
2674  clean_up_and_ret1:
2675                         free(argv_expanded);
2676                         IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
2677                         debug_printf_exec("run_pipe return %d\n", rcode);
2678                         return rcode;
2679                 }
2680 #if ENABLE_FEATURE_SH_STANDALONE
2681                 i = find_applet_by_name(argv_expanded[0]);
2682                 if (i >= 0 && APPLET_IS_NOFORK(i)) {
2683                         setup_redirects(command, squirrel);
2684                         save_nofork_data(&G.nofork_save);
2685                         new_env = expand_assignments(argv, command->assignment_cnt);
2686                         old_env = putenv_all_and_save_old(new_env);
2687                         debug_printf_exec(": run_nofork_applet '%s' '%s'...\n", argv_expanded[0], argv_expanded[1]);
2688                         rcode = run_nofork_applet_prime(&G.nofork_save, i, argv_expanded);
2689                         goto clean_up_and_ret;
2690                 }
2691 #endif
2692         }
2693
2694         /* NB: argv_expanded may already be created, and that
2695          * might include `cmd` runs! Do not rerun it! We *must*
2696          * use argv_expanded if it's non-NULL */
2697
2698         /* Going to fork a child per each pipe member */
2699         pi->alive_cmds = 0;
2700         nextin = 0;
2701
2702         for (i = 0; i < pi->num_cmds; i++) {
2703 #if !BB_MMU
2704                 volatile nommu_save_t nommu_save;
2705                 nommu_save.new_env = NULL;
2706                 nommu_save.old_env = NULL;
2707                 nommu_save.argv = NULL;
2708 #endif
2709                 command = &(pi->cmds[i]);
2710                 if (command->argv) {
2711                         debug_printf_exec(": pipe member '%s' '%s'...\n", command->argv[0], command->argv[1]);
2712                 } else
2713                         debug_printf_exec(": pipe member with no argv\n");
2714
2715                 /* pipes are inserted between pairs of commands */
2716                 pipefds[0] = 0;
2717                 pipefds[1] = 1;
2718                 if ((i + 1) < pi->num_cmds)
2719                         xpipe(pipefds);
2720
2721                 command->pid = BB_MMU ? fork() : vfork();
2722                 if (!command->pid) { /* child */
2723 #if ENABLE_HUSH_JOB
2724                         die_sleep = 0; /* let nofork's xfuncs die */
2725
2726                         /* Every child adds itself to new process group
2727                          * with pgid == pid_of_first_child_in_pipe */
2728                         if (G.run_list_level == 1 && G_interactive_fd) {
2729                                 pid_t pgrp;
2730                                 pgrp = pi->pgrp;
2731                                 if (pgrp < 0) /* true for 1st process only */
2732                                         pgrp = getpid();
2733                                 if (setpgid(0, pgrp) == 0 && pi->followup != PIPE_BG) {
2734                                         /* We do it in *every* child, not just first,
2735                                          * to avoid races */
2736                                         tcsetpgrp(G_interactive_fd, pgrp);
2737                                 }
2738                         }
2739 #endif
2740                         xmove_fd(nextin, 0);
2741                         xmove_fd(pipefds[1], 1); /* write end */
2742                         if (pipefds[0] > 1)
2743                                 close(pipefds[0]); /* read end */
2744                         /* Like bash, explicit redirects override pipes,
2745                          * and the pipe fd is available for dup'ing. */
2746                         setup_redirects(command, NULL);
2747
2748                         /* Restore default handlers just prior to exec */
2749                         /*signal(SIGCHLD, SIG_DFL); - so far we don't have any handlers */
2750
2751                         /* Stores to nommu_save list of env vars putenv'ed
2752                          * (NOMMU, on MMU we don't need that) */
2753                         /* cast away volatility... */
2754                         pseudo_exec((nommu_save_t*) &nommu_save, command, argv_expanded);
2755                         /* pseudo_exec() does not return */
2756                 }
2757                 /* parent */
2758 #if !BB_MMU
2759                 /* Clean up after vforked child */
2760                 free(nommu_save.argv);
2761                 free_strings_and_unsetenv(nommu_save.new_env, 1);
2762                 putenv_all(nommu_save.old_env);
2763 #endif
2764                 free(argv_expanded);
2765                 argv_expanded = NULL;
2766                 if (command->pid < 0) { /* [v]fork failed */
2767                         /* Clearly indicate, was it fork or vfork */
2768                         bb_perror_msg(BB_MMU ? "fork" : "vfork");
2769                 } else {
2770                         pi->alive_cmds++;
2771 #if ENABLE_HUSH_JOB
2772                         /* Second and next children need to know pid of first one */
2773                         if (pi->pgrp < 0)
2774                                 pi->pgrp = command->pid;
2775 #endif
2776                 }
2777
2778                 if (i)
2779                         close(nextin);
2780                 if ((i + 1) < pi->num_cmds)
2781                         close(pipefds[1]); /* write end */
2782                 /* Pass read (output) pipe end to next iteration */
2783                 nextin = pipefds[0];
2784         }
2785
2786         if (!pi->alive_cmds) {
2787                 debug_printf_exec("run_pipe return 1 (all forks failed, no children)\n");
2788                 return 1;
2789         }
2790
2791         debug_printf_exec("run_pipe return -1 (%u children started)\n", pi->alive_cmds);
2792         return -1;
2793 }
2794
2795 #ifndef debug_print_tree
2796 static void debug_print_tree(struct pipe *pi, int lvl)
2797 {
2798         static const char *const PIPE[] = {
2799                 [PIPE_SEQ] = "SEQ",
2800                 [PIPE_AND] = "AND",
2801                 [PIPE_OR ] = "OR" ,
2802                 [PIPE_BG ] = "BG" ,
2803         };
2804         static const char *RES[] = {
2805                 [RES_NONE ] = "NONE" ,
2806 #if ENABLE_HUSH_IF
2807                 [RES_IF   ] = "IF"   ,
2808                 [RES_THEN ] = "THEN" ,
2809                 [RES_ELIF ] = "ELIF" ,
2810                 [RES_ELSE ] = "ELSE" ,
2811                 [RES_FI   ] = "FI"   ,
2812 #endif
2813 #if ENABLE_HUSH_LOOPS
2814                 [RES_FOR  ] = "FOR"  ,
2815                 [RES_WHILE] = "WHILE",
2816                 [RES_UNTIL] = "UNTIL",
2817                 [RES_DO   ] = "DO"   ,
2818                 [RES_DONE ] = "DONE" ,
2819 #endif
2820 #if ENABLE_HUSH_LOOPS || ENABLE_HUSH_CASE
2821                 [RES_IN   ] = "IN"   ,
2822 #endif
2823 #if ENABLE_HUSH_CASE
2824                 [RES_CASE ] = "CASE" ,
2825                 [RES_MATCH] = "MATCH",
2826                 [RES_CASEI] = "CASEI",
2827                 [RES_ESAC ] = "ESAC" ,
2828 #endif
2829                 [RES_XXXX ] = "XXXX" ,
2830                 [RES_SNTX ] = "SNTX" ,
2831         };
2832         static const char *const GRPTYPE[] = {
2833                 "()",
2834                 "{}",
2835 #if ENABLE_HUSH_FUNCTIONS
2836                 "func()",
2837 #endif
2838         };
2839
2840         int pin, prn;
2841
2842         pin = 0;
2843         while (pi) {
2844                 fprintf(stderr, "%*spipe %d res_word=%s followup=%d %s\n", lvl*2, "",
2845                                 pin, RES[pi->res_word], pi->followup, PIPE[pi->followup]);
2846                 prn = 0;
2847                 while (prn < pi->num_cmds) {
2848                         struct command *command = &pi->cmds[prn];
2849                         char **argv = command->argv;
2850
2851                         fprintf(stderr, "%*s prog %d assignment_cnt:%d", lvl*2, "", prn, command->assignment_cnt);
2852                         if (command->group) {
2853                                 fprintf(stderr, " group %s: (argv=%p)\n",
2854                                                 GRPTYPE[command->grp_type],
2855                                                 argv);
2856                                 debug_print_tree(command->group, lvl+1);
2857                                 prn++;
2858                                 continue;
2859                         }
2860                         if (argv) while (*argv) {
2861                                 fprintf(stderr, " '%s'", *argv);
2862                                 argv++;
2863                         }
2864                         fprintf(stderr, "\n");
2865                         prn++;
2866                 }
2867                 pi = pi->next;
2868                 pin++;
2869         }
2870 }
2871 #endif
2872
2873 /* NB: called by pseudo_exec, and therefore must not modify any
2874  * global data until exec/_exit (we can be a child after vfork!) */
2875 static int run_list(struct pipe *pi)
2876 {
2877 #if ENABLE_HUSH_CASE
2878         char *case_word = NULL;
2879 #endif
2880 #if ENABLE_HUSH_LOOPS
2881         struct pipe *loop_top = NULL;
2882         char *for_varname = NULL;
2883         char **for_lcur = NULL;
2884         char **for_list = NULL;
2885 #endif
2886         smallint flag_skip = 1;
2887         smalluint rcode = 0; /* probably just for compiler */
2888 #if ENABLE_HUSH_IF || ENABLE_HUSH_CASE
2889         smalluint cond_code = 0;
2890 #else
2891         enum { cond_code = 0, };
2892 #endif
2893         /*enum reserved_style*/ smallint rword = RES_NONE;
2894         /*enum reserved_style*/ smallint skip_more_for_this_rword = RES_XXXX;
2895
2896         debug_printf_exec("run_list start lvl %d\n", G.run_list_level + 1);
2897
2898 #if ENABLE_HUSH_LOOPS
2899         /* Check syntax for "for" */
2900         for (struct pipe *cpipe = pi; cpipe; cpipe = cpipe->next) {
2901                 if (cpipe->res_word != RES_FOR && cpipe->res_word != RES_IN)
2902                         continue;
2903                 /* current word is FOR or IN (BOLD in comments below) */
2904                 if (cpipe->next == NULL) {
2905                         syntax("malformed for");
2906                         debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
2907                         return 1;
2908                 }
2909                 /* "FOR v; do ..." and "for v IN a b; do..." are ok */
2910                 if (cpipe->next->res_word == RES_DO)
2911                         continue;
2912                 /* next word is not "do". It must be "in" then ("FOR v in ...") */
2913                 if (cpipe->res_word == RES_IN /* "for v IN a b; not_do..."? */
2914                  || cpipe->next->res_word != RES_IN /* FOR v not_do_and_not_in..."? */
2915                 ) {
2916                         syntax("malformed for");
2917                         debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
2918                         return 1;
2919                 }
2920         }
2921 #endif
2922
2923         /* Past this point, all code paths should jump to ret: label
2924          * in order to return, no direct "return" statements please.
2925          * This helps to ensure that no memory is leaked. */
2926
2927 ////TODO: ctrl-Z handling needs re-thinking and re-testing
2928
2929 #if ENABLE_HUSH_JOB
2930         /* Example of nested list: "while true; do { sleep 1 | exit 2; } done".
2931          * We are saving state before entering outermost list ("while...done")
2932          * so that ctrl-Z will correctly background _entire_ outermost list,
2933          * not just a part of it (like "sleep 1 | exit 2") */
2934         if (++G.run_list_level == 1 && G_interactive_fd) {
2935                 if (sigsetjmp(G.toplevel_jb, 1)) {
2936                         /* ctrl-Z forked and we are parent; or ctrl-C.
2937                          * Sighandler has longjmped us here */
2938                         signal(SIGINT, SIG_IGN);
2939                         signal(SIGTSTP, SIG_IGN);
2940                         /* Restore level (we can be coming from deep inside
2941                          * nested levels) */
2942                         G.run_list_level = 1;
2943 #if ENABLE_FEATURE_SH_STANDALONE
2944                         if (G.nofork_save.saved) { /* if save area is valid */
2945                                 debug_printf_jobs("exiting nofork early\n");
2946                                 restore_nofork_data(&G.nofork_save);
2947                         }
2948 #endif
2949 ////                    if (G.ctrl_z_flag) {
2950 ////                            /* ctrl-Z has forked and stored pid of the child in pi->pid.
2951 ////                             * Remember this child as background job */
2952 ////                            insert_bg_job(pi);
2953 ////                    } else {
2954                                 /* ctrl-C. We just stop doing whatever we were doing */
2955                                 bb_putchar('\n');
2956 ////                    }
2957                         USE_HUSH_LOOPS(loop_top = NULL;)
2958                         USE_HUSH_LOOPS(G.depth_of_loop = 0;)
2959                         rcode = 0;
2960                         goto ret;
2961                 }
2962 ////            /* ctrl-Z handler will store pid etc in pi */
2963 ////            G.toplevel_list = pi;
2964 ////            G.ctrl_z_flag = 0;
2965 ////#if ENABLE_FEATURE_SH_STANDALONE
2966 ////            G.nofork_save.saved = 0; /* in case we will run a nofork later */
2967 ////#endif
2968 ////            signal_SA_RESTART_empty_mask(SIGTSTP, handler_ctrl_z);
2969 ////            signal(SIGINT, handler_ctrl_c);
2970         }
2971 #endif /* JOB */
2972
2973         /* Go through list of pipes, (maybe) executing them. */
2974         for (; pi; pi = USE_HUSH_LOOPS(rword == RES_DONE ? loop_top : ) pi->next) {
2975                 if (G.flag_SIGINT)
2976                         break;
2977
2978                 IF_HAS_KEYWORDS(rword = pi->res_word;)
2979                 IF_HAS_NO_KEYWORDS(rword = RES_NONE;)
2980                 debug_printf_exec(": rword=%d cond_code=%d skip_more=%d\n",
2981                                 rword, cond_code, skip_more_for_this_rword);
2982 #if ENABLE_HUSH_LOOPS
2983                 if ((rword == RES_WHILE || rword == RES_UNTIL || rword == RES_FOR)
2984                  && loop_top == NULL /* avoid bumping G.depth_of_loop twice */
2985                 ) {
2986                         /* start of a loop: remember where loop starts */
2987                         loop_top = pi;
2988                         G.depth_of_loop++;
2989                 }
2990 #endif
2991                 if (rword == skip_more_for_this_rword && flag_skip) {
2992                         if (pi->followup == PIPE_SEQ)
2993                                 flag_skip = 0;
2994                         /* it is "<false> && CMD" or "<true> || CMD"
2995                          * and we should not execute CMD */
2996                         continue;
2997                 }
2998                 flag_skip = 1;
2999                 skip_more_for_this_rword = RES_XXXX;
3000 #if ENABLE_HUSH_IF
3001                 if (cond_code) {
3002                         if (rword == RES_THEN) {
3003                                 /* "if <false> THEN cmd": skip cmd */
3004                                 continue;
3005                         }
3006                 } else {
3007                         if (rword == RES_ELSE || rword == RES_ELIF) {
3008                                 /* "if <true> then ... ELSE/ELIF cmd":
3009                                  * skip cmd and all following ones */
3010                                 break;
3011                         }
3012                 }
3013 #endif
3014 #if ENABLE_HUSH_LOOPS
3015                 if (rword == RES_FOR) { /* && pi->num_cmds - always == 1 */
3016                         if (!for_lcur) {
3017                                 /* first loop through for */
3018
3019                                 static const char encoded_dollar_at[] ALIGN1 = {
3020                                         SPECIAL_VAR_SYMBOL, '@' | 0x80, SPECIAL_VAR_SYMBOL, '\0'
3021                                 }; /* encoded representation of "$@" */
3022                                 static const char *const encoded_dollar_at_argv[] = {
3023                                         encoded_dollar_at, NULL
3024                                 }; /* argv list with one element: "$@" */
3025                                 char **vals;
3026
3027                                 vals = (char**)encoded_dollar_at_argv;
3028                                 if (pi->next->res_word == RES_IN) {
3029                                         /* if no variable values after "in" we skip "for" */
3030                                         if (!pi->next->cmds[0].argv)
3031                                                 break;
3032                                         vals = pi->next->cmds[0].argv;
3033                                 } /* else: "for var; do..." -> assume "$@" list */
3034                                 /* create list of variable values */
3035                                 debug_print_strings("for_list made from", vals);
3036                                 for_list = expand_strvec_to_strvec(vals);
3037                                 for_lcur = for_list;
3038                                 debug_print_strings("for_list", for_list);
3039                                 for_varname = pi->cmds[0].argv[0];
3040                                 pi->cmds[0].argv[0] = NULL;
3041                         }
3042                         free(pi->cmds[0].argv[0]);
3043                         if (!*for_lcur) {
3044                                 /* "for" loop is over, clean up */
3045                                 free(for_list);
3046                                 for_list = NULL;
3047                                 for_lcur = NULL;
3048                                 pi->cmds[0].argv[0] = for_varname;
3049                                 break;
3050                         }
3051                         /* insert next value from for_lcur */
3052 //TODO: does it need escaping?
3053                         pi->cmds[0].argv[0] = xasprintf("%s=%s", for_varname, *for_lcur++);
3054                         pi->cmds[0].assignment_cnt = 1;
3055                 }
3056                 if (rword == RES_IN) /* "for v IN list;..." - "in" has no cmds anyway */
3057                         continue;
3058                 if (rword == RES_DONE) {
3059                         continue; /* "done" has no cmds too */
3060                 }
3061 #endif
3062 #if ENABLE_HUSH_CASE
3063                 if (rword == RES_CASE) {
3064                         case_word = expand_strvec_to_string(pi->cmds->argv);
3065                         continue;
3066                 }
3067                 if (rword == RES_MATCH) {
3068                         char **argv;
3069
3070                         if (!case_word) /* "case ... matched_word) ... WORD)": we executed selected branch, stop */
3071                                 break;
3072                         /* all prev words didn't match, does this one match? */
3073                         argv = pi->cmds->argv;
3074                         while (*argv) {
3075                                 char *pattern = expand_string_to_string(*argv);
3076                                 /* TODO: which FNM_xxx flags to use? */
3077                                 cond_code = (fnmatch(pattern, case_word, /*flags:*/ 0) != 0);
3078                                 free(pattern);
3079                                 if (cond_code == 0) { /* match! we will execute this branch */
3080                                         free(case_word); /* make future "word)" stop */
3081                                         case_word = NULL;
3082                                         break;
3083                                 }
3084                                 argv++;
3085                         }
3086                         continue;
3087                 }
3088                 if (rword == RES_CASEI) { /* inside of a case branch */
3089                         if (cond_code != 0)
3090                                 continue; /* not matched yet, skip this pipe */
3091                 }
3092 #endif
3093                 /* Just pressing <enter> in shell should check for jobs.
3094                  * OTOH, in non-interactive shell this is useless
3095                  * and only leads to extra job checks */
3096                 if (pi->num_cmds == 0) {
3097                         if (G_interactive_fd)
3098                                 goto check_jobs_and_continue;
3099                         continue;
3100                 }
3101
3102                 /* After analyzing all keywords and conditions, we decided
3103                  * to execute this pipe. NB: have to do checkjobs(NULL)
3104                  * after run_pipe() to collect any background children,
3105                  * even if list execution is to be stopped. */
3106                 debug_printf_exec(": run_pipe with %d members\n", pi->num_cmds);
3107                 {
3108                         int r;
3109 #if ENABLE_HUSH_LOOPS
3110                         G.flag_break_continue = 0;
3111 #endif
3112                         rcode = r = run_pipe(pi); /* NB: rcode is a smallint */
3113                         if (r != -1) {
3114                                 /* we only ran a builtin: rcode is already known
3115                                  * and we don't need to wait for anything. */
3116                                 check_and_run_traps(0);
3117 #if ENABLE_HUSH_LOOPS
3118                                 /* was it "break" or "continue"? */
3119                                 if (G.flag_break_continue) {
3120                                         smallint fbc = G.flag_break_continue;
3121                                         /* we might fall into outer *loop*,
3122                                          * don't want to break it too */
3123                                         if (loop_top) {
3124                                                 G.depth_break_continue--;
3125                                                 if (G.depth_break_continue == 0)
3126                                                         G.flag_break_continue = 0;
3127                                                 /* else: e.g. "continue 2" should *break* once, *then* continue */
3128                                         } /* else: "while... do... { we are here (innermost list is not a loop!) };...done" */
3129                                         if (G.depth_break_continue != 0 || fbc == BC_BREAK)
3130                                                 goto check_jobs_and_break;
3131                                         /* "continue": simulate end of loop */
3132                                         rword = RES_DONE;
3133                                         continue;
3134                                 }
3135 #endif
3136                         } else if (pi->followup == PIPE_BG) {
3137                                 /* what does bash do with attempts to background builtins? */
3138                                 /* even bash 3.2 doesn't do that well with nested bg:
3139                                  * try "{ { sleep 10; echo DEEP; } & echo HERE; } &".
3140                                  * I'm NOT treating inner &'s as jobs */
3141                                 check_and_run_traps(0);
3142 #if ENABLE_HUSH_JOB
3143                                 if (G.run_list_level == 1)
3144                                         insert_bg_job(pi);
3145 #endif
3146                                 rcode = 0; /* EXIT_SUCCESS */
3147                         } else {
3148 #if ENABLE_HUSH_JOB
3149                                 if (G.run_list_level == 1 && G_interactive_fd) {
3150                                         /* waits for completion, then fg's main shell */
3151                                         rcode = checkjobs_and_fg_shell(pi);
3152                                         check_and_run_traps(0);
3153                                         debug_printf_exec(": checkjobs_and_fg_shell returned %d\n", rcode);
3154                                 } else
3155 #endif
3156                                 { /* this one just waits for completion */
3157                                         rcode = checkjobs(pi);
3158                                         check_and_run_traps(0);
3159                                         debug_printf_exec(": checkjobs returned %d\n", rcode);
3160                                 }
3161                         }
3162                 }
3163                 debug_printf_exec(": setting last_return_code=%d\n", rcode);
3164                 G.last_return_code = rcode;
3165
3166                 /* Analyze how result affects subsequent commands */
3167 #if ENABLE_HUSH_IF
3168                 if (rword == RES_IF || rword == RES_ELIF)
3169                         cond_code = rcode;
3170 #endif
3171 #if ENABLE_HUSH_LOOPS
3172                 if (rword == RES_WHILE) {
3173                         if (rcode) {
3174                                 rcode = 0; /* "while false; do...done" - exitcode 0 */
3175                                 goto check_jobs_and_break;
3176                         }
3177                 }
3178                 if (rword == RES_UNTIL) {
3179                         if (!rcode) {
3180  check_jobs_and_break:
3181                                 checkjobs(NULL);
3182                                 break;
3183                         }
3184                 }
3185 #endif
3186                 if ((rcode == 0 && pi->followup == PIPE_OR)
3187                  || (rcode != 0 && pi->followup == PIPE_AND)
3188                 ) {
3189                         skip_more_for_this_rword = rword;
3190                 }
3191
3192  check_jobs_and_continue:
3193                 checkjobs(NULL);
3194         } /* for (pi) */
3195
3196 #if ENABLE_HUSH_JOB
3197 ////    if (G.ctrl_z_flag) {
3198 ////            /* ctrl-Z forked somewhere in the past, we are the child,
3199 ////             * and now we completed running the list. Exit. */
3200 //////TODO: _exit?
3201 ////            exit(rcode);
3202 ////    }
3203  ret:
3204         G.run_list_level--;
3205 ////    if (!G.run_list_level && G_interactive_fd) {
3206 ////            signal(SIGTSTP, SIG_IGN);
3207 ////            signal(SIGINT, SIG_IGN);
3208 ////    }
3209 #endif
3210         debug_printf_exec("run_list lvl %d return %d\n", G.run_list_level + 1, rcode);
3211 #if ENABLE_HUSH_LOOPS
3212         if (loop_top)
3213                 G.depth_of_loop--;
3214         free(for_list);
3215 #endif
3216 #if ENABLE_HUSH_CASE
3217         free(case_word);
3218 #endif
3219         return rcode;
3220 }
3221
3222 /* Select which version we will use */
3223 static int run_and_free_list(struct pipe *pi)
3224 {
3225         int rcode = 0;
3226         debug_printf_exec("run_and_free_list entered\n");
3227         if (!G.fake_mode) {
3228                 debug_printf_exec(": run_list with %d members\n", pi->num_cmds);
3229                 rcode = run_list(pi);
3230         }
3231         /* free_pipe_list has the side effect of clearing memory.
3232          * In the long run that function can be merged with run_list,
3233          * but doing that now would hobble the debugging effort. */
3234         free_pipe_list(pi, /* indent: */ 0);
3235         debug_printf_exec("run_and_free_list return %d\n", rcode);
3236         return rcode;
3237 }
3238
3239
3240 /* Peek ahead in the in_str to find out if we have a "&n" construct,
3241  * as in "2>&1", that represents duplicating a file descriptor.
3242  * Return either -2 (syntax error), -1 (no &), or the number found.
3243  */
3244 static int redirect_dup_num(struct in_str *input)
3245 {
3246         int ch, d = 0, ok = 0;
3247         ch = i_peek(input);
3248         if (ch != '&') return -1;
3249
3250         i_getch(input);  /* get the & */
3251         ch = i_peek(input);
3252         if (ch == '-') {
3253                 i_getch(input);
3254                 return -3;  /* "-" represents "close me" */
3255         }
3256         while (isdigit(ch)) {
3257                 d = d*10 + (ch-'0');
3258                 ok = 1;
3259                 i_getch(input);
3260                 ch = i_peek(input);
3261         }
3262         if (ok) return d;
3263
3264         bb_error_msg("ambiguous redirect");
3265         return -2;
3266 }
3267
3268 /* The src parameter allows us to peek forward to a possible &n syntax
3269  * for file descriptor duplication, e.g., "2>&1".
3270  * Return code is 0 normally, 1 if a syntax error is detected in src.
3271  * Resource errors (in xmalloc) cause the process to exit */
3272 static int setup_redirect(struct parse_context *ctx,
3273                 int fd,
3274                 redir_type style,
3275                 struct in_str *input)
3276 {
3277         struct command *command = ctx->command;
3278         struct redir_struct *redir;
3279         struct redir_struct **redirp;
3280         int dup_num;
3281
3282         /* Check for a '2>&1' type redirect */
3283         dup_num = redirect_dup_num(input);
3284         if (dup_num == -2)
3285                 return 1;  /* syntax error */
3286
3287         /* Create a new redir_struct and drop it onto the end of the linked list */
3288         redirp = &command->redirects;
3289         while ((redir = *redirp) != NULL) {
3290                 redirp = &(redir->next);
3291         }
3292         *redirp = redir = xzalloc(sizeof(*redir));
3293         /* redir->next = NULL; */
3294         /* redir->rd_filename = NULL; */
3295         redir->rd_type = style;
3296         redir->fd = (fd == -1) ? redir_table[style].default_fd : fd;
3297
3298         debug_printf("Redirect type %d%s\n", redir->fd, redir_table[style].descrip);
3299
3300         redir->dup = dup_num;
3301         if (dup_num != -1) {
3302                 /* Erik had a check here that the file descriptor in question
3303                  * is legit; I postpone that to "run time"
3304                  * A "-" representation of "close me" shows up as a -3 here */
3305                 debug_printf("Duplicating redirect '%d>&%d'\n", redir->fd, redir->dup);
3306         } else {
3307                 /* We do _not_ try to open the file that src points to,
3308                  * since we need to return and let src be expanded first.
3309                  * Set ctx->pending_redirect, so we know what to do at the
3310                  * end of the next parsed word. */
3311                 ctx->pending_redirect = redir;
3312         }
3313         return 0;
3314 }
3315
3316
3317 static struct pipe *new_pipe(void)
3318 {
3319         struct pipe *pi;
3320         pi = xzalloc(sizeof(struct pipe));
3321         /*pi->followup = 0; - deliberately invalid value */
3322         /*pi->res_word = RES_NONE; - RES_NONE is 0 anyway */
3323         return pi;
3324 }
3325
3326 /* Command (member of a pipe) is complete. The only possible error here
3327  * is out of memory, in which case xmalloc exits. */
3328 static int done_command(struct parse_context *ctx)
3329 {
3330         /* The command is really already in the pipe structure, so
3331          * advance the pipe counter and make a new, null command. */
3332         struct pipe *pi = ctx->pipe;
3333         struct command *command = ctx->command;
3334
3335         if (command) {
3336                 if (command->group == NULL
3337                  && command->argv == NULL
3338                  && command->redirects == NULL
3339                 ) {
3340                         debug_printf_parse("done_command: skipping null cmd, num_cmds=%d\n", pi->num_cmds);
3341                         return pi->num_cmds;
3342                 }
3343                 pi->num_cmds++;
3344                 debug_printf_parse("done_command: ++num_cmds=%d\n", pi->num_cmds);
3345         } else {
3346                 debug_printf_parse("done_command: initializing, num_cmds=%d\n", pi->num_cmds);
3347         }
3348
3349         /* Only real trickiness here is that the uncommitted
3350          * command structure is not counted in pi->num_cmds. */
3351         pi->cmds = xrealloc(pi->cmds, sizeof(*pi->cmds) * (pi->num_cmds+1));
3352         command = &pi->cmds[pi->num_cmds];
3353         memset(command, 0, sizeof(*command));
3354
3355         ctx->command = command;
3356         /* but ctx->pipe and ctx->list_head remain unchanged */
3357
3358         return pi->num_cmds; /* used only for 0/nonzero check */
3359 }
3360
3361 static void done_pipe(struct parse_context *ctx, pipe_style type)
3362 {
3363         int not_null;
3364
3365         debug_printf_parse("done_pipe entered, followup %d\n", type);
3366         /* Close previous command */
3367         not_null = done_command(ctx);
3368         ctx->pipe->followup = type;
3369         IF_HAS_KEYWORDS(ctx->pipe->pi_inverted = ctx->ctx_inverted;)
3370         IF_HAS_KEYWORDS(ctx->ctx_inverted = 0;)
3371         IF_HAS_KEYWORDS(ctx->pipe->res_word = ctx->ctx_res_w;)
3372
3373         /* Without this check, even just <enter> on command line generates
3374          * tree of three NOPs (!). Which is harmless but annoying.
3375          * IOW: it is safe to do it unconditionally.
3376          * RES_NONE case is for "for a in; do ..." (empty IN set)
3377          * to work, possibly other cases too. */
3378         if (not_null IF_HAS_KEYWORDS(|| ctx->ctx_res_w != RES_NONE)) {
3379                 struct pipe *new_p;
3380                 debug_printf_parse("done_pipe: adding new pipe: "
3381                                 "not_null:%d ctx->ctx_res_w:%d\n",
3382                                 not_null, ctx->ctx_res_w);
3383                 new_p = new_pipe();
3384                 ctx->pipe->next = new_p;
3385                 ctx->pipe = new_p;
3386                 /* RES_THEN, RES_DO etc are "sticky" -
3387                  * they remain set for commands inside if/while.
3388                  * This is used to control execution.
3389                  * RES_FOR and RES_IN are NOT sticky (needed to support
3390                  * cases where variable or value happens to match a keyword):
3391                  */
3392 #if ENABLE_HUSH_LOOPS
3393                 if (ctx->ctx_res_w == RES_FOR
3394                  || ctx->ctx_res_w == RES_IN)
3395                         ctx->ctx_res_w = RES_NONE;
3396 #endif
3397 #if ENABLE_HUSH_CASE
3398                 if (ctx->ctx_res_w == RES_MATCH)
3399                         ctx->ctx_res_w = RES_CASEI;
3400 #endif
3401                 ctx->command = NULL; /* trick done_command below */
3402                 /* Create the memory for command, roughly:
3403                  * ctx->pipe->cmds = new struct command;
3404                  * ctx->command = &ctx->pipe->cmds[0];
3405                  */
3406                 done_command(ctx);
3407         }
3408         debug_printf_parse("done_pipe return\n");
3409 }
3410
3411 static void initialize_context(struct parse_context *ctx)
3412 {
3413         memset(ctx, 0, sizeof(*ctx));
3414         ctx->pipe = ctx->list_head = new_pipe();
3415         /* Create the memory for command, roughly:
3416          * ctx->pipe->cmds = new struct command;
3417          * ctx->command = &ctx->pipe->cmds[0];
3418          */
3419         done_command(ctx);
3420 }
3421
3422
3423 /* If a reserved word is found and processed, parse context is modified
3424  * and 1 is returned.
3425  */
3426 #if HAS_KEYWORDS
3427 struct reserved_combo {
3428         char literal[6];
3429         unsigned char res;
3430         unsigned char assignment_flag;
3431         int flag;
3432 };
3433 enum {
3434         FLAG_END   = (1 << RES_NONE ),
3435 #if ENABLE_HUSH_IF
3436         FLAG_IF    = (1 << RES_IF   ),
3437         FLAG_THEN  = (1 << RES_THEN ),
3438         FLAG_ELIF  = (1 << RES_ELIF ),
3439         FLAG_ELSE  = (1 << RES_ELSE ),
3440         FLAG_FI    = (1 << RES_FI   ),
3441 #endif
3442 #if ENABLE_HUSH_LOOPS
3443         FLAG_FOR   = (1 << RES_FOR  ),
3444         FLAG_WHILE = (1 << RES_WHILE),
3445         FLAG_UNTIL = (1 << RES_UNTIL),
3446         FLAG_DO    = (1 << RES_DO   ),
3447         FLAG_DONE  = (1 << RES_DONE ),
3448         FLAG_IN    = (1 << RES_IN   ),
3449 #endif
3450 #if ENABLE_HUSH_CASE
3451         FLAG_MATCH = (1 << RES_MATCH),
3452         FLAG_ESAC  = (1 << RES_ESAC ),
3453 #endif
3454         FLAG_START = (1 << RES_XXXX ),
3455 };
3456
3457 static const struct reserved_combo* match_reserved_word(o_string *word)
3458 {
3459         /* Mostly a list of accepted follow-up reserved words.
3460          * FLAG_END means we are done with the sequence, and are ready
3461          * to turn the compound list into a command.
3462          * FLAG_START means the word must start a new compound list.
3463          */
3464         static const struct reserved_combo reserved_list[] = {
3465 #if ENABLE_HUSH_IF
3466                 { "!",     RES_NONE,  NOT_ASSIGNMENT , 0 },
3467                 { "if",    RES_IF,    WORD_IS_KEYWORD, FLAG_THEN | FLAG_START },
3468                 { "then",  RES_THEN,  WORD_IS_KEYWORD, FLAG_ELIF | FLAG_ELSE | FLAG_FI },
3469                 { "elif",  RES_ELIF,  WORD_IS_KEYWORD, FLAG_THEN },
3470                 { "else",  RES_ELSE,  WORD_IS_KEYWORD, FLAG_FI   },
3471                 { "fi",    RES_FI,    NOT_ASSIGNMENT , FLAG_END  },
3472 #endif
3473 #if ENABLE_HUSH_LOOPS
3474                 { "for",   RES_FOR,   NOT_ASSIGNMENT , FLAG_IN | FLAG_DO | FLAG_START },
3475                 { "while", RES_WHILE, WORD_IS_KEYWORD, FLAG_DO | FLAG_START },
3476                 { "until", RES_UNTIL, WORD_IS_KEYWORD, FLAG_DO | FLAG_START },
3477                 { "in",    RES_IN,    NOT_ASSIGNMENT , FLAG_DO   },
3478                 { "do",    RES_DO,    WORD_IS_KEYWORD, FLAG_DONE },
3479                 { "done",  RES_DONE,  NOT_ASSIGNMENT , FLAG_END  },
3480 #endif
3481 #if ENABLE_HUSH_CASE
3482                 { "case",  RES_CASE,  NOT_ASSIGNMENT , FLAG_MATCH | FLAG_START },
3483                 { "esac",  RES_ESAC,  NOT_ASSIGNMENT , FLAG_END  },
3484 #endif
3485         };
3486         const struct reserved_combo *r;
3487
3488         for (r = reserved_list; r < reserved_list + ARRAY_SIZE(reserved_list); r++) {
3489                 if (strcmp(word->data, r->literal) == 0)
3490                         return r;
3491         }
3492         return NULL;
3493 }
3494 static int reserved_word(o_string *word, struct parse_context *ctx)
3495 {
3496 #if ENABLE_HUSH_CASE
3497         static const struct reserved_combo reserved_match = {
3498                 "",        RES_MATCH, NOT_ASSIGNMENT , FLAG_MATCH | FLAG_ESAC
3499         };
3500 #endif
3501         const struct reserved_combo *r;
3502
3503         r = match_reserved_word(word);
3504         if (!r)
3505                 return 0;
3506
3507         debug_printf("found reserved word %s, res %d\n", r->literal, r->res);
3508 #if ENABLE_HUSH_CASE
3509         if (r->res == RES_IN && ctx->ctx_res_w == RES_CASE)
3510                 /* "case word IN ..." - IN part starts first match part */
3511                 r = &reserved_match;
3512         else
3513 #endif
3514         if (r->flag == 0) { /* '!' */
3515                 if (ctx->ctx_inverted) { /* bash doesn't accept '! ! true' */
3516                         syntax("! ! command");
3517                         IF_HAS_KEYWORDS(ctx->ctx_res_w = RES_SNTX;)
3518                 }
3519                 ctx->ctx_inverted = 1;
3520                 return 1;
3521         }
3522         if (r->flag & FLAG_START) {
3523                 struct parse_context *old;
3524                 old = xmalloc(sizeof(*old));
3525                 debug_printf_parse("push stack %p\n", old);
3526                 *old = *ctx;   /* physical copy */
3527                 initialize_context(ctx);
3528                 ctx->stack = old;
3529         } else if (/*ctx->ctx_res_w == RES_NONE ||*/ !(ctx->old_flag & (1 << r->res))) {
3530                 syntax(word->data);
3531                 ctx->ctx_res_w = RES_SNTX;
3532                 return 1;
3533         }
3534         ctx->ctx_res_w = r->res;
3535         ctx->old_flag = r->flag;
3536         if (ctx->old_flag & FLAG_END) {
3537                 struct parse_context *old;
3538                 done_pipe(ctx, PIPE_SEQ);
3539                 debug_printf_parse("pop stack %p\n", ctx->stack);
3540                 old = ctx->stack;
3541                 old->command->group = ctx->list_head;
3542                 old->command->grp_type = GRP_NORMAL;
3543                 *ctx = *old;   /* physical copy */
3544                 free(old);
3545         }
3546         word->o_assignment = r->assignment_flag;
3547         return 1;
3548 }
3549 #endif
3550
3551 /* Word is complete, look at it and update parsing context.
3552  * Normal return is 0. Syntax errors return 1.
3553  * Note: on return, word is reset, but not o_free'd!
3554  */
3555 static int done_word(o_string *word, struct parse_context *ctx)
3556 {
3557         struct command *command = ctx->command;
3558
3559         debug_printf_parse("done_word entered: '%s' %p\n", word->data, command);
3560         if (word->length == 0 && word->nonnull == 0) {
3561                 debug_printf_parse("done_word return 0: true null, ignored\n");
3562                 return 0;
3563         }
3564         /* If this word wasn't an assignment, next ones definitely
3565          * can't be assignments. Even if they look like ones. */
3566         if (word->o_assignment != DEFINITELY_ASSIGNMENT
3567          && word->o_assignment != WORD_IS_KEYWORD
3568         ) {
3569                 word->o_assignment = NOT_ASSIGNMENT;
3570         } else {
3571                 if (word->o_assignment == DEFINITELY_ASSIGNMENT)
3572                         command->assignment_cnt++;
3573                 word->o_assignment = MAYBE_ASSIGNMENT;
3574         }
3575
3576         if (ctx->pending_redirect) {
3577                 /* We do not glob in e.g. >*.tmp case. bash seems to glob here
3578                  * only if run as "bash", not "sh" */
3579                 ctx->pending_redirect->rd_filename = xstrdup(word->data);
3580                 word->o_assignment = NOT_ASSIGNMENT;
3581                 debug_printf("word stored in rd_filename: '%s'\n", word->data);
3582         } else {
3583                 /* "{ echo foo; } echo bar" - bad */
3584                 /* NB: bash allows e.g.:
3585                  * if true; then { echo foo; } fi
3586                  * while if false; then false; fi do break; done
3587                  * TODO? */
3588                 if (command->group) {
3589                         syntax(word->data);
3590                         debug_printf_parse("done_word return 1: syntax error, "
3591                                         "groups and arglists don't mix\n");
3592                         return 1;
3593                 }
3594 #if HAS_KEYWORDS
3595 #if ENABLE_HUSH_CASE
3596                 if (ctx->ctx_dsemicolon
3597                  && strcmp(word->data, "esac") != 0 /* not "... pattern) cmd;; esac" */
3598                 ) {
3599                         /* already done when ctx_dsemicolon was set to 1: */
3600                         /* ctx->ctx_res_w = RES_MATCH; */
3601                         ctx->ctx_dsemicolon = 0;
3602                 } else
3603 #endif
3604                 if (!command->argv /* if it's the first word... */
3605 #if ENABLE_HUSH_LOOPS
3606                  && ctx->ctx_res_w != RES_FOR /* ...not after FOR or IN */
3607                  && ctx->ctx_res_w != RES_IN
3608 #endif
3609                 ) {
3610                         debug_printf_parse(": checking '%s' for reserved-ness\n", word->data);
3611                         if (reserved_word(word, ctx)) {
3612                                 o_reset(word);
3613                                 debug_printf_parse("done_word return %d\n", (ctx->ctx_res_w == RES_SNTX));
3614                                 return (ctx->ctx_res_w == RES_SNTX);
3615                         }
3616                 }
3617 #endif
3618                 if (word->nonnull /* word had "xx" or 'xx' at least as part of it. */
3619                  /* optimization: and if it's ("" or '') or ($v... or `cmd`...): */
3620                  && (word->data[0] == '\0' || word->data[0] == SPECIAL_VAR_SYMBOL)
3621                  /* (otherwise it's known to be not empty and is already safe) */
3622                 ) {
3623                         /* exclude "$@" - it can expand to no word despite "" */
3624                         char *p = word->data;
3625                         while (p[0] == SPECIAL_VAR_SYMBOL
3626                             && (p[1] & 0x7f) == '@'
3627                             && p[2] == SPECIAL_VAR_SYMBOL
3628                         ) {
3629                                 p += 3;
3630                         }
3631                         if (p == word->data || p[0] != '\0') {
3632                                 /* saw no "$@", or not only "$@" but some
3633                                  * real text is there too */
3634                                 /* insert "empty variable" reference, this makes
3635                                  * e.g. "", $empty"" etc to not disappear */
3636                                 o_addchr(word, SPECIAL_VAR_SYMBOL);
3637                                 o_addchr(word, SPECIAL_VAR_SYMBOL);
3638                         }
3639                 }
3640                 command->argv = add_string_to_strings(command->argv, xstrdup(word->data));
3641                 debug_print_strings("word appended to argv", command->argv);
3642         }
3643
3644         o_reset(word);
3645         ctx->pending_redirect = NULL;
3646
3647 #if ENABLE_HUSH_LOOPS
3648         /* Force FOR to have just one word (variable name) */
3649         /* NB: basically, this makes hush see "for v in ..." syntax as if
3650          * as it is "for v; in ...". FOR and IN become two pipe structs
3651          * in parse tree. */
3652         if (ctx->ctx_res_w == RES_FOR) {
3653 //TODO: check that command->argv[0] is a valid variable name!
3654                 done_pipe(ctx, PIPE_SEQ);
3655         }
3656 #endif
3657 #if ENABLE_HUSH_CASE
3658         /* Force CASE to have just one word */
3659         if (ctx->ctx_res_w == RES_CASE) {
3660                 done_pipe(ctx, PIPE_SEQ);
3661         }
3662 #endif
3663         debug_printf_parse("done_word return 0\n");
3664         return 0;
3665 }
3666
3667 /* If a redirect is immediately preceded by a number, that number is
3668  * supposed to tell which file descriptor to redirect.  This routine
3669  * looks for such preceding numbers.  In an ideal world this routine
3670  * needs to handle all the following classes of redirects...
3671  *     echo 2>foo     # redirects fd  2 to file "foo", nothing passed to echo
3672  *     echo 49>foo    # redirects fd 49 to file "foo", nothing passed to echo
3673  *     echo -2>foo    # redirects fd  1 to file "foo",    "-2" passed to echo
3674  *     echo 49x>foo   # redirects fd  1 to file "foo",   "49x" passed to echo
3675  * A -1 output from this program means no valid number was found, so the
3676  * caller should use the appropriate default for this redirection.
3677  */
3678 static int redirect_opt_num(o_string *o)
3679 {
3680         int num;
3681
3682         if (o->length == 0)
3683                 return -1;
3684         for (num = 0; num < o->length; num++) {
3685                 if (!isdigit(o->data[num])) {
3686                         return -1;
3687                 }
3688         }
3689         num = atoi(o->data);
3690         o_reset(o);
3691         return num;
3692 }
3693
3694 static struct pipe *parse_stream(struct in_str *input, int end_trigger);
3695 static void parse_and_run_string(const char *s);
3696
3697 #if ENABLE_HUSH_TICK
3698 static FILE *generate_stream_from_string(const char *s)
3699 {
3700         FILE *pf;
3701         int pid, channel[2];
3702
3703         xpipe(channel);
3704         pid = BB_MMU ? fork() : vfork();
3705         if (pid < 0)
3706                 bb_perror_msg_and_die(BB_MMU ? "fork" : "vfork");
3707
3708         if (pid == 0) { /* child */
3709                 /* Process substitution is not considered to be usual
3710                  * 'command execution'.
3711                  * SUSv3 says ctrl-Z should be ignored, ctrl-C should not.
3712                  */
3713                 bb_signals(0
3714                         + (1 << SIGTSTP)
3715                         + (1 << SIGTTIN)
3716                         + (1 << SIGTTOU)
3717                         , SIG_IGN);
3718                 if (ENABLE_HUSH_JOB)
3719                         die_sleep = 0; /* let nofork's xfuncs die */
3720                 close(channel[0]); /* NB: close _first_, then move fd! */
3721                 xmove_fd(channel[1], 1);
3722                 /* Prevent it from trying to handle ctrl-z etc */
3723                 USE_HUSH_JOB(G.run_list_level = 1;)
3724 #if BB_MMU
3725                 parse_and_run_string(s);
3726                 _exit(G.last_return_code);
3727 #else
3728         /* We re-execute after vfork on NOMMU. This makes this script safe:
3729          * yes "0123456789012345678901234567890" | dd bs=32 count=64k >TESTFILE
3730          * huge=`cat TESTFILE` # was blocking here forever
3731          * echo OK
3732          */
3733 //TODO: pass non-exported variables, traps, and functions
3734                 execl(CONFIG_BUSYBOX_EXEC_PATH, "hush", "-c", s, NULL);
3735                 _exit(127);
3736 #endif
3737         }
3738
3739         /* parent */
3740         close(channel[1]);
3741         pf = fdopen(channel[0], "r");
3742         return pf;
3743 }
3744
3745 /* Return code is exit status of the process that is run. */
3746 static int process_command_subs(o_string *dest, const char *s)
3747 {
3748         FILE *pf;
3749         struct in_str pipe_str;
3750         int ch, eol_cnt;
3751
3752         pf = generate_stream_from_string(s);
3753         if (pf == NULL)
3754                 return 1;
3755         close_on_exec_on(fileno(pf));
3756
3757         /* Now send results of command back into original context */
3758         setup_file_in_str(&pipe_str, pf);
3759         eol_cnt = 0;
3760         while ((ch = i_getch(&pipe_str)) != EOF) {
3761                 if (ch == '\n') {
3762                         eol_cnt++;
3763                         continue;
3764                 }
3765                 while (eol_cnt) {
3766                         o_addchr(dest, '\n');
3767                         eol_cnt--;
3768                 }
3769                 o_addQchr(dest, ch);
3770         }
3771
3772         debug_printf("done reading from pipe, pclose()ing\n");
3773         /* Note: we got EOF, and we just close the read end of the pipe.
3774          * We do not wait for the `cmd` child to terminate. bash and ash do.
3775          * Try these:
3776          * echo `echo Hi; exec 1>&-; sleep 2` - bash waits 2 sec
3777          * `false`; echo $? - bash outputs "1"
3778          */
3779         fclose(pf);
3780         debug_printf("closed FILE from child. return 0\n");
3781         return 0;
3782 }
3783 #endif
3784
3785 static int parse_group(o_string *dest, struct parse_context *ctx,
3786         struct in_str *input, int ch)
3787 {
3788         /* dest contains characters seen prior to ( or {.
3789          * Typically it's empty, but for function defs,
3790          * it contains function name (without '()'). */
3791         struct pipe *pipe_list;
3792         int endch;
3793         struct command *command = ctx->command;
3794
3795         debug_printf_parse("parse_group entered\n");
3796 #if ENABLE_HUSH_FUNCTIONS
3797         if (ch == 'F') { /* function definition? */
3798                 bb_error_msg("aha '%s' is a function, parsing it...", dest->data);
3799                 //command->fname = dest->data;
3800                 command->grp_type = GRP_FUNCTION;
3801 //TODO: review every o_reset() location... do they handle all o_string fields correctly?
3802                 memset(dest, 0, sizeof(*dest));
3803         }
3804 #endif
3805         if (command->argv /* word [word](... */
3806          || dest->length /* word(... */
3807          || dest->nonnull /* ""(... */
3808         ) {
3809                 syntax(NULL);
3810                 debug_printf_parse("parse_group return 1: syntax error, groups and arglists don't mix\n");
3811                 return 1;
3812         }
3813         endch = '}';
3814         if (ch == '(') {
3815                 endch = ')';
3816                 command->grp_type = GRP_SUBSHELL;
3817         }
3818         pipe_list = parse_stream(input, endch);
3819         /* empty ()/{} or parse error? */
3820         if (!pipe_list || pipe_list == ERR_PTR) {
3821                 syntax(NULL);
3822                 debug_printf_parse("parse_group return 1: parse_stream returned %p\n", pipe_list);
3823                 return 1;
3824         }
3825         command->group = pipe_list;
3826         debug_printf_parse("parse_group return 0\n");
3827         return 0;
3828         /* command remains "open", available for possible redirects */
3829 }
3830
3831 #if ENABLE_HUSH_TICK || ENABLE_SH_MATH_SUPPORT
3832 /* Subroutines for copying $(...) and `...` things */
3833 static void add_till_backquote(o_string *dest, struct in_str *input);
3834 /* '...' */
3835 static void add_till_single_quote(o_string *dest, struct in_str *input)
3836 {
3837         while (1) {
3838                 int ch = i_getch(input);
3839                 if (ch == EOF)
3840                         break;
3841                 if (ch == '\'')
3842                         break;
3843                 o_addchr(dest, ch);
3844         }
3845 }
3846 /* "...\"...`..`...." - do we need to handle "...$(..)..." too? */
3847 static void add_till_double_quote(o_string *dest, struct in_str *input)
3848 {
3849         while (1) {
3850                 int ch = i_getch(input);
3851                 if (ch == '"')
3852                         break;
3853                 if (ch == '\\') {  /* \x. Copy both chars. */
3854                         o_addchr(dest, ch);
3855                         ch = i_getch(input);
3856                 }
3857                 if (ch == EOF)
3858                         break;
3859                 o_addchr(dest, ch);
3860                 if (ch == '`') {
3861                         add_till_backquote(dest, input);
3862                         o_addchr(dest, ch);
3863                         continue;
3864                 }
3865                 //if (ch == '$') ...
3866         }
3867 }
3868 /* Process `cmd` - copy contents until "`" is seen. Complicated by
3869  * \` quoting.
3870  * "Within the backquoted style of command substitution, backslash
3871  * shall retain its literal meaning, except when followed by: '$', '`', or '\'.
3872  * The search for the matching backquote shall be satisfied by the first
3873  * backquote found without a preceding backslash; during this search,
3874  * if a non-escaped backquote is encountered within a shell comment,
3875  * a here-document, an embedded command substitution of the $(command)
3876  * form, or a quoted string, undefined results occur. A single-quoted
3877  * or double-quoted string that begins, but does not end, within the
3878  * "`...`" sequence produces undefined results."
3879  * Example                               Output
3880  * echo `echo '\'TEST\`echo ZZ\`BEST`    \TESTZZBEST
3881  */
3882 static void add_till_backquote(o_string *dest, struct in_str *input)
3883 {
3884         while (1) {
3885                 int ch = i_getch(input);
3886                 if (ch == '`')
3887                         break;
3888                 if (ch == '\\') {  /* \x. Copy both chars unless it is \` */
3889                         int ch2 = i_getch(input);
3890                         if (ch2 != '`' && ch2 != '$' && ch2 != '\\')
3891                                 o_addchr(dest, ch);
3892                         ch = ch2;
3893                 }
3894                 if (ch == EOF)
3895                         break;
3896                 o_addchr(dest, ch);
3897         }
3898 }
3899 /* Process $(cmd) - copy contents until ")" is seen. Complicated by
3900  * quoting and nested ()s.
3901  * "With the $(command) style of command substitution, all characters
3902  * following the open parenthesis to the matching closing parenthesis
3903  * constitute the command. Any valid shell script can be used for command,
3904  * except a script consisting solely of redirections which produces
3905  * unspecified results."
3906  * Example                              Output
3907  * echo $(echo '(TEST)' BEST)           (TEST) BEST
3908  * echo $(echo 'TEST)' BEST)            TEST) BEST
3909  * echo $(echo \(\(TEST\) BEST)         ((TEST) BEST
3910  */
3911 static void add_till_closing_paren(o_string *dest, struct in_str *input, bool dbl)
3912 {
3913         int count = 0;
3914         while (1) {
3915                 int ch = i_getch(input);
3916                 if (ch == EOF)
3917                         break;
3918                 if (ch == '(')
3919                         count++;
3920                 if (ch == ')')
3921                         if (--count < 0) {
3922                                 if (!dbl)
3923                                         break;
3924                                 if (i_peek(input) == ')') {
3925                                         i_getch(input);
3926                                         break;
3927                                 }
3928                         }
3929                 o_addchr(dest, ch);
3930                 if (ch == '\'') {
3931                         add_till_single_quote(dest, input);
3932                         o_addchr(dest, ch);
3933                         continue;
3934                 }
3935                 if (ch == '"') {
3936                         add_till_double_quote(dest, input);
3937                         o_addchr(dest, ch);
3938                         continue;
3939                 }
3940                 if (ch == '\\') { /* \x. Copy verbatim. Important for  \(, \) */
3941                         ch = i_getch(input);
3942                         if (ch == EOF)
3943                                 break;
3944                         o_addchr(dest, ch);
3945                         continue;
3946                 }
3947         }
3948 }
3949 #endif /* ENABLE_HUSH_TICK || ENABLE_SH_MATH_SUPPORT */
3950
3951 /* Return code: 0 for OK, 1 for syntax error */
3952 static int handle_dollar(o_string *dest, struct in_str *input)
3953 {
3954         int expansion;
3955         int ch = i_peek(input);  /* first character after the $ */
3956         unsigned char quote_mask = dest->o_escape ? 0x80 : 0;
3957
3958         debug_printf_parse("handle_dollar entered: ch='%c'\n", ch);
3959         if (isalpha(ch)) {
3960                 i_getch(input);
3961  make_var:
3962                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
3963                 while (1) {
3964                         debug_printf_parse(": '%c'\n", ch);
3965                         o_addchr(dest, ch | quote_mask);
3966                         quote_mask = 0;
3967                         ch = i_peek(input);
3968                         if (!isalnum(ch) && ch != '_')
3969                                 break;
3970                         i_getch(input);
3971                 }
3972                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
3973         } else if (isdigit(ch)) {
3974  make_one_char_var:
3975                 i_getch(input);
3976                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
3977                 debug_printf_parse(": '%c'\n", ch);
3978                 o_addchr(dest, ch | quote_mask);
3979                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
3980         } else switch (ch) {
3981                 case '$': /* pid */
3982                 case '!': /* last bg pid */
3983                 case '?': /* last exit code */
3984                 case '#': /* number of args */
3985                 case '*': /* args */
3986                 case '@': /* args */
3987                         goto make_one_char_var;
3988                 case '{': {
3989                         bool first_char, all_digits;
3990
3991                         o_addchr(dest, SPECIAL_VAR_SYMBOL);
3992                         i_getch(input);
3993                         /* XXX maybe someone will try to escape the '}' */
3994                         expansion = 0;
3995                         first_char = true;
3996                         all_digits = false;
3997                         while (1) {
3998                                 ch = i_getch(input);
3999                                 if (ch == '}')
4000                                         break;
4001
4002                                 if (first_char) {
4003                                         if (ch == '#')
4004                                                 /* ${#var}: length of var contents */
4005                                                 goto char_ok;
4006                                         else if (isdigit(ch)) {
4007                                                 all_digits = true;
4008                                                 goto char_ok;
4009                                         }
4010                                 }
4011
4012                                 if (expansion < 2 &&
4013                                     ((all_digits && !isdigit(ch)) ||
4014                                      (!all_digits && !isalnum(ch) && ch != '_')))
4015                                 {
4016                                         /* handle parameter expansions
4017                                          * http://www.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html#tag_02_06_02
4018                                          */
4019                                         if (first_char)
4020                                                 goto case_default;
4021                                         switch (ch) {
4022                                                 case ':': /* null modifier */
4023                                                         if (expansion == 0) {
4024                                                                 debug_printf_parse(": null modifier\n");
4025                                                                 ++expansion;
4026                                                                 break;
4027                                                         }
4028                                                         goto case_default;
4029
4030 #if 0 /* not implemented yet :( */
4031                                                 case '#': /* remove prefix */
4032                                                 case '%': /* remove suffix */
4033                                                         if (expansion == 0) {
4034                                                                 debug_printf_parse(": remove suffix/prefix\n");
4035                                                                 expansion = 2;
4036                                                                 break;
4037                                                         }
4038                                                         goto case_default;
4039 #endif
4040
4041                                                 case '-': /* default value */
4042                                                 case '=': /* assign default */
4043                                                 case '+': /* alternative */
4044                                                 case '?': /* error indicate */
4045                                                         debug_printf_parse(": parameter expansion\n");
4046                                                         expansion = 2;
4047                                                         break;
4048
4049                                                 default:
4050                                                 case_default:
4051                                                         syntax("unterminated ${name}");
4052                                                         debug_printf_parse("handle_dollar return 1: unterminated ${name}\n");
4053                                                         return 1;
4054                                                 }
4055                                 }
4056
4057  char_ok:
4058                                 debug_printf_parse(": '%c'\n", ch);
4059                                 o_addchr(dest, ch | quote_mask);
4060                                 quote_mask = 0;
4061                                 first_char = false;
4062                         }
4063                         o_addchr(dest, SPECIAL_VAR_SYMBOL);
4064                         break;
4065                 }
4066                 case '(': {
4067                         i_getch(input);
4068
4069 #if ENABLE_SH_MATH_SUPPORT
4070                         if (i_peek(input) == '(') {
4071                                 i_getch(input);
4072                                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4073                                 o_addchr(dest, /*quote_mask |*/ '+');
4074                                 add_till_closing_paren(dest, input, true);
4075                                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4076                                 break;
4077                         }
4078 #endif
4079
4080 #if ENABLE_HUSH_TICK
4081                         //int pos = dest->length;
4082                         o_addchr(dest, SPECIAL_VAR_SYMBOL);
4083                         o_addchr(dest, quote_mask | '`');
4084                         add_till_closing_paren(dest, input, false);
4085                         //debug_printf_subst("SUBST RES2 '%s'\n", dest->data + pos);
4086                         o_addchr(dest, SPECIAL_VAR_SYMBOL);
4087 #endif
4088                         break;
4089                 }
4090                 case '_':
4091                         i_getch(input);
4092                         ch = i_peek(input);
4093                         if (isalnum(ch)) { /* it's $_name or $_123 */
4094                                 ch = '_';
4095                                 goto make_var;
4096                         }
4097                         /* else: it's $_ */
4098                 case '-':
4099                         /* still unhandled, but should be eventually */
4100                         bb_error_msg("unhandled syntax: $%c", ch);
4101                         return 1;
4102                         break;
4103                 default:
4104                         o_addQchr(dest, '$');
4105         }
4106         debug_printf_parse("handle_dollar return 0\n");
4107         return 0;
4108 }
4109
4110 static int parse_stream_dquoted(o_string *dest, struct in_str *input, int dquote_end)
4111 {
4112         int ch;
4113         int next;
4114
4115  again:
4116         ch = i_getch(input);
4117         if (ch == dquote_end) { /* may be only '"' or EOF */
4118                 dest->nonnull = 1;
4119                 if (dest->o_assignment == NOT_ASSIGNMENT)
4120                         dest->o_escape ^= 1;
4121                 debug_printf_parse("parse_stream_dquoted return 0\n");
4122                 return 0;
4123         }
4124         if (ch == EOF) {
4125                 syntax("unterminated \"");
4126                 debug_printf_parse("parse_stream_dquoted return 1: unterminated \"\n");
4127                 return 1;
4128         }
4129         next = '\0';
4130         if (ch != '\n') {
4131                 next = i_peek(input);
4132         }
4133         debug_printf_parse(": ch=%c (%d) m=%d escape=%d\n",
4134                                         ch, ch, m, dest->o_escape);
4135         /* Basically, checking every CHAR_SPECIAL char except '"' */
4136         if (ch == '\\') {
4137                 if (next == EOF) {
4138                         syntax("\\<eof>");
4139                         debug_printf_parse("parse_stream_dquoted return 1: \\<eof>\n");
4140                         return 1;
4141                 }
4142                 /* bash:
4143                  * "The backslash retains its special meaning [in "..."]
4144                  * only when followed by one of the following characters:
4145                  * $, `, ", \, or <newline>.  A double quote may be quoted
4146                  * within double quotes by preceding it with a backslash.
4147                  * If enabled, history expansion will be performed unless
4148                  * an ! appearing in double quotes is escaped using
4149                  * a backslash. The backslash preceding the ! is not removed."
4150                  */
4151                 if (strchr("$`\"\\", next) != NULL) {
4152                         o_addqchr(dest, i_getch(input));
4153                 } else {
4154                         o_addqchr(dest, '\\');
4155                 }
4156                 goto again;
4157         }
4158         if (ch == '$') {
4159                 if (handle_dollar(dest, input) != 0) {
4160                         debug_printf_parse("parse_stream_dquoted return 1: handle_dollar returned non-0\n");
4161                         return 1;
4162                 }
4163                 goto again;
4164         }
4165 #if ENABLE_HUSH_TICK
4166         if (ch == '`') {
4167                 //int pos = dest->length;
4168                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4169                 o_addchr(dest, 0x80 | '`');
4170                 add_till_backquote(dest, input);
4171                 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4172                 //debug_printf_subst("SUBST RES3 '%s'\n", dest->data + pos);
4173                 goto again;
4174         }
4175 #endif
4176         o_addQchr(dest, ch);
4177         if (ch == '='
4178          && (dest->o_assignment == MAYBE_ASSIGNMENT
4179             || dest->o_assignment == WORD_IS_KEYWORD)
4180          && is_assignment(dest->data)
4181         ) {
4182                 dest->o_assignment = DEFINITELY_ASSIGNMENT;
4183         }
4184         goto again;
4185 }
4186
4187 /*
4188  * Scan input until EOF or end_trigger char.
4189  * Return a list of pipes to execute, or NULL on EOF
4190  * or if end_trigger character is met.
4191  * On syntax error, exit is shell is not interactive,
4192  * reset parsing machinery and start parsing anew,
4193  * or return ERR_PTR.
4194  */
4195 static struct pipe *parse_stream(struct in_str *input, int end_trigger)
4196 {
4197         struct parse_context ctx;
4198         o_string dest = NULL_O_STRING;
4199         int redir_fd;
4200         int next;
4201         int is_in_dquote;
4202         int ch;
4203         redir_type redir_style;
4204
4205         /* Double-quote state is handled in the state variable is_in_dquote.
4206          * A single-quote triggers a bypass of the main loop until its mate is
4207          * found.  When recursing, quote state is passed in via dest->o_escape. */
4208
4209         debug_printf_parse("parse_stream entered, end_trigger='%c'\n",
4210                         end_trigger ? : 'X');
4211
4212         G.ifs = get_local_var_value("IFS");
4213         if (G.ifs == NULL)
4214                 G.ifs = " \t\n";
4215
4216  reset:
4217 #if ENABLE_HUSH_INTERACTIVE
4218         input->promptmode = 0; /* PS1 */
4219 #endif
4220         /* dest.o_assignment = MAYBE_ASSIGNMENT; - already is */
4221         initialize_context(&ctx);
4222         is_in_dquote = 0;
4223         while (1) {
4224                 const char *is_ifs;
4225                 const char *is_special;
4226
4227                 if (is_in_dquote) {
4228                         if (parse_stream_dquoted(&dest, input, '"')) {
4229                                 goto parse_error;
4230                         }
4231                         /* We reached closing '"' */
4232                         is_in_dquote = 0;
4233                 }
4234                 next = '\0';
4235                 ch = i_getch(input);
4236                 debug_printf_parse(": ch=%c (%d) escape=%d\n",
4237                                                 ch, ch, dest.o_escape);
4238                 if (ch == EOF) {
4239                         struct pipe *pi;
4240                         if (done_word(&dest, &ctx)) {
4241                                 goto parse_error;
4242                         }
4243                         o_free(&dest);
4244                         done_pipe(&ctx, PIPE_SEQ);
4245                         /* If we got nothing... */
4246                         pi = ctx.list_head;
4247                         if (pi->num_cmds == 0
4248                             IF_HAS_KEYWORDS( && pi->res_word == RES_NONE)
4249                         ) {
4250                                 free_pipe_list(pi, 0);
4251                                 pi = NULL;
4252                         }
4253                         debug_printf_parse("parse_stream return %p\n", pi);
4254                         return pi;
4255                 }
4256                 if (ch != '\n') {
4257                         next = i_peek(input);
4258                 }
4259
4260                 is_ifs = strchr(G.ifs, ch);
4261                 is_special = strchr("<>;&|(){}#'" /* special outside of "str" */
4262                                 "\\$\"" USE_HUSH_TICK("`") /* always special */
4263                                 , ch);
4264
4265                 if (!is_special && !is_ifs) { /* ordinary char */
4266                         o_addQchr(&dest, ch);
4267                         if ((dest.o_assignment == MAYBE_ASSIGNMENT
4268                             || dest.o_assignment == WORD_IS_KEYWORD)
4269                          && ch == '='
4270                          && is_assignment(dest.data)
4271                         ) {
4272                                 dest.o_assignment = DEFINITELY_ASSIGNMENT;
4273                         }
4274                         continue;
4275                 }
4276
4277                 if (is_ifs) {
4278                         if (done_word(&dest, &ctx)) {
4279                                 goto parse_error;
4280                         }
4281                         if (ch == '\n') {
4282 #if ENABLE_HUSH_CASE
4283                                 /* "case ... in <newline> word) ..." -
4284                                  * newlines are ignored (but ';' wouldn't be) */
4285                                 if (ctx.command->argv == NULL
4286                                  && ctx.ctx_res_w == RES_MATCH
4287                                 ) {
4288                                         continue;
4289                                 }
4290 #endif
4291                                 /* Treat newline as a command separator. */
4292                                 done_pipe(&ctx, PIPE_SEQ);
4293                                 dest.o_assignment = MAYBE_ASSIGNMENT;
4294                                 ch = ';';
4295                                 /* note: if (m == CHAR_IFS) continue;
4296                                  * will still trigger for us */
4297                         }
4298                 }
4299                 if (end_trigger && end_trigger == ch) {
4300 //TODO: disallow "{ cmd }" without semicolon
4301                         if (done_word(&dest, &ctx)) {
4302                                 goto parse_error;
4303                         }
4304                         done_pipe(&ctx, PIPE_SEQ);
4305                         dest.o_assignment = MAYBE_ASSIGNMENT;
4306                         /* Do we sit outside of any if's, loops or case's? */
4307                         if (!HAS_KEYWORDS
4308                          IF_HAS_KEYWORDS(|| (ctx.ctx_res_w == RES_NONE && ctx.old_flag == 0))
4309                         ) {
4310                                 debug_printf_parse("parse_stream return %p: "
4311                                                 "end_trigger char found\n",
4312                                                 ctx.list_head);
4313                                 o_free(&dest);
4314                                 return ctx.list_head;
4315                         }
4316                 }
4317                 if (is_ifs)
4318                         continue;
4319
4320                 if (dest.o_assignment == MAYBE_ASSIGNMENT) {
4321                         /* ch is a special char and thus this word
4322                          * cannot be an assignment */
4323                         dest.o_assignment = NOT_ASSIGNMENT;
4324                 }
4325
4326                 switch (ch) {
4327                 case '#':
4328                         if (dest.length == 0) {
4329                                 while (1) {
4330                                         ch = i_peek(input);
4331                                         if (ch == EOF || ch == '\n')
4332                                                 break;
4333                                         i_getch(input);
4334                                 }
4335                         } else {
4336                                 o_addQchr(&dest, ch);
4337                         }
4338                         break;
4339                 case '\\':
4340                         if (next == EOF) {
4341                                 syntax("\\<eof>");
4342                                 goto parse_error;
4343                         }
4344                         o_addchr(&dest, '\\');
4345                         o_addchr(&dest, i_getch(input));
4346                         break;
4347                 case '$':
4348                         if (handle_dollar(&dest, input) != 0) {
4349                                 debug_printf_parse("parse_stream parse error: handle_dollar returned non-0\n");
4350                                 goto parse_error;
4351                         }
4352                         break;
4353                 case '\'':
4354                         dest.nonnull = 1;
4355                         while (1) {
4356                                 ch = i_getch(input);
4357                                 if (ch == EOF) {
4358                                         syntax("unterminated '");
4359                                         goto parse_error;
4360                                 }
4361                                 if (ch == '\'')
4362                                         break;
4363                                 if (dest.o_assignment == NOT_ASSIGNMENT)
4364                                         o_addqchr(&dest, ch);
4365                                 else
4366                                         o_addchr(&dest, ch);
4367                         }
4368                         break;
4369                 case '"':
4370                         dest.nonnull = 1;
4371                         is_in_dquote ^= 1; /* invert */
4372                         if (dest.o_assignment == NOT_ASSIGNMENT)
4373                                 dest.o_escape ^= 1;
4374                         break;
4375 #if ENABLE_HUSH_TICK
4376                 case '`': {
4377                         //int pos = dest.length;
4378                         o_addchr(&dest, SPECIAL_VAR_SYMBOL);
4379                         o_addchr(&dest, '`');
4380                         add_till_backquote(&dest, input);
4381                         o_addchr(&dest, SPECIAL_VAR_SYMBOL);
4382                         //debug_printf_subst("SUBST RES3 '%s'\n", dest.data + pos);
4383                         break;
4384                 }
4385 #endif
4386                 case '>':
4387                         redir_fd = redirect_opt_num(&dest);
4388                         if (done_word(&dest, &ctx)) {
4389                                 goto parse_error;
4390                         }
4391                         redir_style = REDIRECT_OVERWRITE;
4392                         if (next == '>') {
4393                                 redir_style = REDIRECT_APPEND;
4394                                 i_getch(input);
4395                         }
4396 #if 0
4397                         else if (next == '(') {
4398                                 syntax(">(process) not supported");
4399                                 goto parse_error;
4400                         }
4401 #endif
4402                         setup_redirect(&ctx, redir_fd, redir_style, input);
4403                         break;
4404                 case '<':
4405                         redir_fd = redirect_opt_num(&dest);
4406                         if (done_word(&dest, &ctx)) {
4407                                 goto parse_error;
4408                         }
4409                         redir_style = REDIRECT_INPUT;
4410                         if (next == '<') {
4411                                 redir_style = REDIRECT_HEREIS;
4412                                 i_getch(input);
4413                         } else if (next == '>') {
4414                                 redir_style = REDIRECT_IO;
4415                                 i_getch(input);
4416                         }
4417 #if 0
4418                         else if (next == '(') {
4419                                 syntax("<(process) not supported");
4420                                 goto parse_error;
4421                         }
4422 #endif
4423                         setup_redirect(&ctx, redir_fd, redir_style, input);
4424                         break;
4425                 case ';':
4426 #if ENABLE_HUSH_CASE
4427  case_semi:
4428 #endif
4429                         if (done_word(&dest, &ctx)) {
4430                                 goto parse_error;
4431                         }
4432                         done_pipe(&ctx, PIPE_SEQ);
4433 #if ENABLE_HUSH_CASE
4434                         /* Eat multiple semicolons, detect
4435                          * whether it means something special */
4436                         while (1) {
4437                                 ch = i_peek(input);
4438                                 if (ch != ';')
4439                                         break;
4440                                 i_getch(input);
4441                                 if (ctx.ctx_res_w == RES_CASEI) {
4442                                         ctx.ctx_dsemicolon = 1;
4443                                         ctx.ctx_res_w = RES_MATCH;
4444                                         break;
4445                                 }
4446                         }
4447 #endif
4448  new_cmd:
4449                         /* We just finished a cmd. New one may start
4450                          * with an assignment */
4451                         dest.o_assignment = MAYBE_ASSIGNMENT;
4452                         break;
4453                 case '&':
4454                         if (done_word(&dest, &ctx)) {
4455                                 goto parse_error;
4456                         }
4457                         if (next == '&') {
4458                                 i_getch(input);
4459                                 done_pipe(&ctx, PIPE_AND);
4460                         } else {
4461                                 done_pipe(&ctx, PIPE_BG);
4462                         }
4463                         goto new_cmd;
4464                 case '|':
4465                         if (done_word(&dest, &ctx)) {
4466                                 goto parse_error;
4467                         }
4468 #if ENABLE_HUSH_CASE
4469                         if (ctx.ctx_res_w == RES_MATCH)
4470                                 break; /* we are in case's "word | word)" */
4471 #endif
4472                         if (next == '|') { /* || */
4473                                 i_getch(input);
4474                                 done_pipe(&ctx, PIPE_OR);
4475                         } else {
4476                                 /* we could pick up a file descriptor choice here
4477                                  * with redirect_opt_num(), but bash doesn't do it.
4478                                  * "echo foo 2| cat" yields "foo 2". */
4479                                 done_command(&ctx);
4480                         }
4481                         goto new_cmd;
4482                 case '(':
4483 #if ENABLE_HUSH_CASE
4484                         /* "case... in [(]word)..." - skip '(' */
4485                         if (ctx.ctx_res_w == RES_MATCH
4486                          && ctx.command->argv == NULL /* not (word|(... */
4487                          && dest.length == 0 /* not word(... */
4488                          && dest.nonnull == 0 /* not ""(... */
4489                         ) {
4490                                 continue;
4491                         }
4492 #endif
4493 #if ENABLE_HUSH_FUNCTIONS
4494                         if (dest.length != 0 /* not just () but word() */
4495                          && dest.nonnull == 0 /* not a"b"c() */
4496                          && ctx.command->argv == NULL /* it's the first word */
4497 //TODO: "func ( ) {...}" - note spaces - is valid format too in bash
4498                          && i_peek(input) == ')'
4499                          && !match_reserved_word(&dest)
4500                         ) {
4501                                 bb_error_msg("seems like a function definition");
4502                                 i_getch(input);
4503                                 do {
4504 //TODO: do it properly.
4505                                         ch = i_getch(input);
4506                                 } while (ch == ' ' || ch == '\n');
4507                                 if (ch != '{') {
4508                                         syntax("was expecting {");
4509                                         goto parse_error;
4510                                 }
4511                                 ch = 'F'; /* magic value */
4512                         }
4513 #endif
4514                 case '{':
4515                         if (parse_group(&dest, &ctx, input, ch) != 0) {
4516                                 goto parse_error;
4517                         }
4518                         goto new_cmd;
4519                 case ')':
4520 #if ENABLE_HUSH_CASE
4521                         if (ctx.ctx_res_w == RES_MATCH)
4522                                 goto case_semi;
4523 #endif
4524                 case '}':
4525                         /* proper use of this character is caught by end_trigger:
4526                          * if we see {, we call parse_group(..., end_trigger='}')
4527                          * and it will match } earlier (not here). */
4528                         syntax("unexpected } or )");
4529                         goto parse_error;
4530                 default:
4531                         if (HUSH_DEBUG)
4532                                 bb_error_msg_and_die("BUG: unexpected %c\n", ch);
4533                 }
4534         } /* while (1) */
4535
4536  parse_error:
4537         {
4538                 struct parse_context *pctx;
4539                 IF_HAS_KEYWORDS(struct parse_context *p2;)
4540
4541                 /* Clean up allocated tree.
4542                  * Samples for finding leaks on syntax error recovery path.
4543                  * Execute them from interactive shell and watch pmap `pidof hush`.
4544                  * while if false; then false; fi do break; done (bash accepts it)
4545                  * while if false; then false; fi; do break; fi
4546                  */
4547                 pctx = &ctx;
4548                 do {
4549                         /* Update pipe/command counts,
4550                          * otherwise freeing may miss some */
4551                         done_pipe(pctx, PIPE_SEQ);
4552                         debug_printf_clean("freeing list %p from ctx %p\n",
4553                                         pctx->list_head, pctx);
4554                         debug_print_tree(pctx->list_head, 0);
4555                         free_pipe_list(pctx->list_head, 0);
4556                         debug_printf_clean("freed list %p\n", pctx->list_head);
4557                         IF_HAS_KEYWORDS(p2 = pctx->stack;)
4558                         if (pctx != &ctx) {
4559                                 free(pctx);
4560                         }
4561                         IF_HAS_KEYWORDS(pctx = p2;)
4562                 } while (HAS_KEYWORDS && pctx);
4563                 /* Free text, clear all dest fields */
4564                 o_free(&dest);
4565                 /* If we are not in top-level parse, we return,
4566                  * our caller will propagate error.
4567                  */
4568                 if (end_trigger != ';')
4569                         return ERR_PTR;
4570                 /* Discard cached input, force prompt */
4571                 input->p = NULL;
4572                 USE_HUSH_INTERACTIVE(input->promptme = 1;)
4573                 goto reset;
4574         }
4575 }
4576
4577 /* Execiting from string: eval, sh -c '...'
4578  *          or from file: /etc/profile, . file, sh <script>, sh (intereactive)
4579  * end_trigger controls how often we stop parsing
4580  * NUL: parse all, execute, return
4581  * ';': parse till ';' or newline, execute, repeat till EOF
4582  */
4583 static void parse_and_run_stream(struct in_str *inp, int end_trigger)
4584 {
4585         while (1) {
4586                 struct pipe *pipe_list;
4587
4588                 pipe_list = parse_stream(inp, end_trigger);
4589                 if (!pipe_list) /* EOF */
4590                         break;
4591                 debug_print_tree(pipe_list, 0);
4592                 debug_printf_exec("parse_and_run_stream: run_and_free_list\n");
4593                 run_and_free_list(pipe_list);
4594         }
4595 }
4596
4597 static void parse_and_run_string(const char *s)
4598 {
4599         struct in_str input;
4600         setup_string_in_str(&input, s);
4601         parse_and_run_stream(&input, '\0');
4602 }
4603
4604 static void parse_and_run_file(FILE *f)
4605 {
4606         struct in_str input;
4607         setup_file_in_str(&input, f);
4608         parse_and_run_stream(&input, ';');
4609 }
4610
4611 #if ENABLE_HUSH_JOB
4612 /* Make sure we have a controlling tty.  If we get started under a job
4613  * aware app (like bash for example), make sure we are now in charge so
4614  * we don't fight over who gets the foreground */
4615 static void setup_job_control(void)
4616 {
4617         pid_t shell_pgrp;
4618
4619         shell_pgrp = getpgrp();
4620
4621         /* If we were ran as 'hush &',
4622          * sleep until we are in the foreground.  */
4623         while (tcgetpgrp(G_interactive_fd) != shell_pgrp) {
4624                 /* Send TTIN to ourself (should stop us) */
4625                 kill(- shell_pgrp, SIGTTIN);
4626                 shell_pgrp = getpgrp();
4627         }
4628
4629         /* We _must_ restore tty pgrp on fatal signals */
4630         set_fatal_signals_to_sigexit();
4631
4632         /* Put ourselves in our own process group.  */
4633         bb_setpgrp(); /* is the same as setpgid(our_pid, our_pid); */
4634         /* Grab control of the terminal.  */
4635         tcsetpgrp(G_interactive_fd, getpid());
4636 }
4637 #endif
4638
4639 static int set_mode(const char cstate, const char mode)
4640 {
4641         int state = (cstate == '-' ? 1 : 0);
4642         switch (mode) {
4643                 case 'n': G.fake_mode = state; break;
4644                 case 'x': /*G.debug_mode = state;*/ break;
4645                 default:  return EXIT_FAILURE;
4646         }
4647         return EXIT_SUCCESS;
4648 }
4649
4650 int hush_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
4651 int hush_main(int argc, char **argv)
4652 {
4653         static const struct variable const_shell_ver = {
4654                 .next = NULL,
4655                 .varstr = (char*)hush_version_str,
4656                 .max_len = 1, /* 0 can provoke free(name) */
4657                 .flg_export = 1,
4658                 .flg_read_only = 1,
4659         };
4660
4661         int opt;
4662         FILE *input;
4663         char **e;
4664         struct variable *cur_var;
4665
4666         INIT_G();
4667
4668         G.root_pid = getpid();
4669
4670         /* Deal with HUSH_VERSION */
4671         G.shell_ver = const_shell_ver; /* copying struct here */
4672         G.top_var = &G.shell_ver;
4673         debug_printf_env("unsetenv '%s'\n", "HUSH_VERSION");
4674         unsetenv("HUSH_VERSION"); /* in case it exists in initial env */
4675         /* Initialize our shell local variables with the values
4676          * currently living in the environment */
4677         cur_var = G.top_var;
4678         e = environ;
4679         if (e) while (*e) {
4680                 char *value = strchr(*e, '=');
4681                 if (value) { /* paranoia */
4682                         cur_var->next = xzalloc(sizeof(*cur_var));
4683                         cur_var = cur_var->next;
4684                         cur_var->varstr = *e;
4685                         cur_var->max_len = strlen(*e);
4686                         cur_var->flg_export = 1;
4687                 }
4688                 e++;
4689         }
4690         debug_printf_env("putenv '%s'\n", hush_version_str);
4691         putenv((char *)hush_version_str); /* reinstate HUSH_VERSION */
4692
4693 #if ENABLE_FEATURE_EDITING
4694         G.line_input_state = new_line_input_t(FOR_SHELL);
4695 #endif
4696         /* XXX what should these be while sourcing /etc/profile? */
4697         G.global_argc = argc;
4698         G.global_argv = argv;
4699         /* Initialize some more globals to non-zero values */
4700         set_cwd();
4701 #if ENABLE_HUSH_INTERACTIVE
4702         if (ENABLE_FEATURE_EDITING)
4703                 cmdedit_set_initial_prompt();
4704         G.PS2 = "> ";
4705 #endif
4706
4707         if (EXIT_SUCCESS) /* otherwise is already done */
4708                 G.last_return_code = EXIT_SUCCESS;
4709
4710         if (argv[0] && argv[0][0] == '-') {
4711                 debug_printf("sourcing /etc/profile\n");
4712                 input = fopen_for_read("/etc/profile");
4713                 if (input != NULL) {
4714                         close_on_exec_on(fileno(input));
4715                         parse_and_run_file(input);
4716                         fclose(input);
4717                 }
4718         }
4719         input = stdin;
4720
4721         /* http://www.opengroup.org/onlinepubs/9699919799/utilities/sh.html */
4722         while ((opt = getopt(argc, argv, "c:xins")) > 0) {
4723                 switch (opt) {
4724                 case 'c':
4725                         G.global_argv = argv + optind;
4726                         if (!argv[optind]) {
4727                                 /* -c 'script' (no params): prevent empty $0 */
4728                                 *--G.global_argv = argv[0];
4729                                 optind--;
4730                         } /* else -c 'script' PAR0 PAR1: $0 is PAR0 */
4731                         G.global_argc = argc - optind;
4732                         parse_and_run_string(optarg);
4733                         goto final_return;
4734                 case 'i':
4735                         /* Well, we cannot just declare interactiveness,
4736                          * we have to have some stuff (ctty, etc) */
4737                         /* G_interactive_fd++; */
4738                         break;
4739                 case 's':
4740                         /* "-s" means "read from stdin", but this is how we always
4741                          * operate, so simply do nothing here. */
4742                         break;
4743                 case 'n':
4744                 case 'x':
4745                         if (!set_mode('-', opt))
4746                                 break;
4747                 default:
4748 #ifndef BB_VER
4749                         fprintf(stderr, "Usage: sh [FILE]...\n"
4750                                         "   or: sh -c command [args]...\n\n");
4751                         exit(EXIT_FAILURE);
4752 #else
4753                         bb_show_usage();
4754 #endif
4755                 }
4756         }
4757 #if ENABLE_HUSH_JOB
4758         /* A shell is interactive if the '-i' flag was given, or if all of
4759          * the following conditions are met:
4760          *    no -c command
4761          *    no arguments remaining or the -s flag given
4762          *    standard input is a terminal
4763          *    standard output is a terminal
4764          *    Refer to Posix.2, the description of the 'sh' utility. */
4765         if (argv[optind] == NULL && input == stdin
4766          && isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)
4767         ) {
4768                 G.saved_tty_pgrp = tcgetpgrp(STDIN_FILENO);
4769                 debug_printf("saved_tty_pgrp=%d\n", G.saved_tty_pgrp);
4770                 if (G.saved_tty_pgrp >= 0) {
4771                         /* try to dup to high fd#, >= 255 */
4772                         G_interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
4773                         if (G_interactive_fd < 0) {
4774                                 /* try to dup to any fd */
4775                                 G_interactive_fd = dup(STDIN_FILENO);
4776                                 if (G_interactive_fd < 0)
4777                                         /* give up */
4778                                         G_interactive_fd = 0;
4779                         }
4780                         // TODO: track & disallow any attempts of user
4781                         // to (inadvertently) close/redirect it
4782                 }
4783         }
4784         init_signal_mask(); /* note: ensures SIGCHLD is not masked */
4785         debug_printf("interactive_fd=%d\n", G_interactive_fd);
4786         if (G_interactive_fd) {
4787                 fcntl(G_interactive_fd, F_SETFD, FD_CLOEXEC);
4788                 /* Looks like they want an interactive shell */
4789                 setup_job_control();
4790                 /* -1 is special - makes xfuncs longjmp, not exit
4791                  * (we reset die_sleep = 0 whereever we [v]fork) */
4792                 die_sleep = -1;
4793                 if (setjmp(die_jmp)) {
4794                         /* xfunc has failed! die die die */
4795                         hush_exit(xfunc_error_retval);
4796                 }
4797         }
4798 #elif ENABLE_HUSH_INTERACTIVE
4799 /* no job control compiled, only prompt/line editing */
4800         if (argv[optind] == NULL && input == stdin
4801          && isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)
4802         ) {
4803                 G_interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
4804                 if (G_interactive_fd < 0) {
4805                         /* try to dup to any fd */
4806                         G_interactive_fd = dup(STDIN_FILENO);
4807                         if (G_interactive_fd < 0)
4808                                 /* give up */
4809                                 G_interactive_fd = 0;
4810                 }
4811                 if (G_interactive_fd) {
4812                         fcntl(G_interactive_fd, F_SETFD, FD_CLOEXEC);
4813                 }
4814         }
4815         init_signal_mask(); /* note: ensures SIGCHLD is not masked */
4816 #else
4817         init_signal_mask();
4818 #endif
4819         /* POSIX allows shell to re-enable SIGCHLD
4820          * even if it was SIG_IGN on entry */
4821 //      G.count_SIGCHLD++; /* ensure it is != G.handled_SIGCHLD */
4822         signal(SIGCHLD, SIG_DFL); // SIGCHLD_handler);
4823
4824 #if ENABLE_HUSH_INTERACTIVE && !ENABLE_FEATURE_SH_EXTRA_QUIET
4825         if (G_interactive_fd) {
4826                 printf("\n\n%s hush - the humble shell v"HUSH_VER_STR"\n", bb_banner);
4827                 printf("Enter 'help' for a list of built-in commands.\n\n");
4828         }
4829 #endif
4830
4831         if (argv[optind] == NULL) {
4832                 parse_and_run_file(stdin);
4833         } else {
4834                 debug_printf("\nrunning script '%s'\n", argv[optind]);
4835                 G.global_argv = argv + optind;
4836                 G.global_argc = argc - optind;
4837                 input = xfopen_for_read(argv[optind]);
4838                 fcntl(fileno(input), F_SETFD, FD_CLOEXEC);
4839                 parse_and_run_file(input);
4840         }
4841
4842  final_return:
4843
4844 #if ENABLE_FEATURE_CLEAN_UP
4845         fclose(input);
4846         if (G.cwd != bb_msg_unknown)
4847                 free((char*)G.cwd);
4848         cur_var = G.top_var->next;
4849         while (cur_var) {
4850                 struct variable *tmp = cur_var;
4851                 if (!cur_var->max_len)
4852                         free(cur_var->varstr);
4853                 cur_var = cur_var->next;
4854                 free(tmp);
4855         }
4856 #endif
4857         hush_exit(G.last_return_code);
4858 }
4859
4860
4861 #if ENABLE_LASH
4862 int lash_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
4863 int lash_main(int argc, char **argv)
4864 {
4865         //bb_error_msg("lash is deprecated, please use hush instead");
4866         return hush_main(argc, argv);
4867 }
4868 #endif
4869
4870
4871 /*
4872  * Built-ins
4873  */
4874 static int builtin_trap(char **argv)
4875 {
4876         int i;
4877         int sig;
4878         char *new_cmd;
4879
4880         if (!G.traps)
4881                 G.traps = xzalloc(sizeof(G.traps[0]) * NSIG);
4882
4883         if (!argv[1]) {
4884                 /* No args: print all trapped.  This isn't 100% correct as we should
4885                  * be escaping the cmd so that it can be pasted back in ...
4886                  */
4887                 for (i = 0; i < NSIG; ++i)
4888                         if (G.traps[i])
4889                                 printf("trap -- '%s' %s\n", G.traps[i], get_signame(i));
4890                 return EXIT_SUCCESS;
4891         }
4892
4893         new_cmd = NULL;
4894         i = 0;
4895         /* if first arg is decimal: reset all specified */
4896         sig = bb_strtou(*++argv, NULL, 10);
4897         if (errno == 0) {
4898                 int ret;
4899  set_all:
4900                 ret = EXIT_SUCCESS;
4901                 while (*argv) {
4902                         sig = get_signum(*argv++);
4903                         if (sig < 0 || sig >= NSIG) {
4904                                 ret = EXIT_FAILURE;
4905                                 /* mimic bash message exactly */
4906                                 bb_perror_msg("trap: %s: invalid signal specification", argv[i]);
4907                                 continue;
4908                         }
4909
4910                         free(G.traps[sig]);
4911                         G.traps[sig] = xstrdup(new_cmd);
4912
4913                         debug_printf("trap: setting SIG%s (%i) to '%s'",
4914                                 get_signame(sig), sig, G.traps[sig]);
4915
4916                         /* There is no signal for 0 (EXIT) */
4917                         if (sig == 0)
4918                                 continue;
4919
4920                         if (new_cmd) {
4921                                 sigaddset(&G.blocked_set, sig);
4922                         } else {
4923                                 /* there was a trap handler, we are removing it
4924                                  * (if sig has non-DFL handling,
4925                                  * we don't need to do anything) */
4926                                 if (sig < 32 && (G.non_DFL_mask & (1 << sig)))
4927                                         continue;
4928                                 sigdelset(&G.blocked_set, sig);
4929                         }
4930                         sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
4931                 }
4932                 return ret;
4933         }
4934
4935         /* first arg is "-": reset all specified to default */
4936         /* first arg is "": ignore all specified */
4937         /* everything else: execute first arg upon signal */
4938         if (!argv[1]) {
4939                 bb_error_msg("trap: invalid arguments");
4940                 return EXIT_FAILURE;
4941         }
4942         if (LONE_DASH(*argv))
4943                 /* nothing! */;
4944         else
4945                 new_cmd = *argv;
4946         argv++;
4947         goto set_all;
4948 }
4949
4950 static int builtin_true(char **argv UNUSED_PARAM)
4951 {
4952         return 0;
4953 }
4954
4955 static int builtin_test(char **argv)
4956 {
4957         int argc = 0;
4958         while (*argv) {
4959                 argc++;
4960                 argv++;
4961         }
4962         return test_main(argc, argv - argc);
4963 }
4964
4965 static int builtin_echo(char **argv)
4966 {
4967         int argc = 0;
4968         while (*argv) {
4969                 argc++;
4970                 argv++;
4971         }
4972         return echo_main(argc, argv - argc);
4973 }
4974
4975 static int builtin_eval(char **argv)
4976 {
4977         int rcode = EXIT_SUCCESS;
4978
4979         if (argv[1]) {
4980                 char *str = expand_strvec_to_string(argv + 1);
4981                 /* bash:
4982                  * eval "echo Hi; done" ("done" is syntax error):
4983                  * "echo Hi" will not execute too.
4984                  */
4985                 parse_and_run_string(str);
4986                 free(str);
4987                 rcode = G.last_return_code;
4988         }
4989         return rcode;
4990 }
4991
4992 static int builtin_cd(char **argv)
4993 {
4994         const char *newdir;
4995         if (argv[1] == NULL) {
4996                 /* bash does nothing (exitcode 0) if HOME is ""; if it's unset,
4997                  * bash says "bash: cd: HOME not set" and does nothing (exitcode 1)
4998                  */
4999                 newdir = getenv("HOME") ? : "/";
5000         } else
5001                 newdir = argv[1];
5002         if (chdir(newdir)) {
5003                 printf("cd: %s: %s\n", newdir, strerror(errno));
5004                 return EXIT_FAILURE;
5005         }
5006         set_cwd();
5007         return EXIT_SUCCESS;
5008 }
5009
5010 static int builtin_exec(char **argv)
5011 {
5012         if (argv[1] == NULL)
5013                 return EXIT_SUCCESS; /* bash does this */
5014         {
5015 #if !BB_MMU
5016                 nommu_save_t dummy;
5017 #endif
5018 // FIXME: if exec fails, bash does NOT exit! We do...
5019                 pseudo_exec_argv(&dummy, argv + 1, 0, NULL);
5020                 /* never returns */
5021         }
5022 }
5023
5024 static int builtin_exit(char **argv)
5025 {
5026 // TODO: bash does it ONLY on top-level sh exit (+interacive only?)
5027         //puts("exit"); /* bash does it */
5028 // TODO: warn if we have background jobs: "There are stopped jobs"
5029 // On second consecutive 'exit', exit anyway.
5030         if (argv[1] == NULL)
5031                 hush_exit(G.last_return_code);
5032         /* mimic bash: exit 123abc == exit 255 + error msg */
5033         xfunc_error_retval = 255;
5034         /* bash: exit -2 == exit 254, no error msg */
5035         hush_exit(xatoi(argv[1]) & 0xff);
5036 }
5037
5038 static int builtin_export(char **argv)
5039 {
5040         const char *value;
5041         char *name = argv[1];
5042
5043         if (name == NULL) {
5044                 // TODO:
5045                 // ash emits: export VAR='VAL'
5046                 // bash: declare -x VAR="VAL"
5047                 // (both also escape as needed (quotes, $, etc))
5048                 char **e = environ;
5049                 if (e)
5050                         while (*e)
5051                                 puts(*e++);
5052                 return EXIT_SUCCESS;
5053         }
5054
5055         value = strchr(name, '=');
5056         if (!value) {
5057                 /* They are exporting something without a =VALUE */
5058                 struct variable *var;
5059
5060                 var = get_local_var(name);
5061                 if (var) {
5062                         var->flg_export = 1;
5063                         debug_printf_env("%s: putenv '%s'\n", __func__, var->varstr);
5064                         putenv(var->varstr);
5065                 }
5066                 /* bash does not return an error when trying to export
5067                  * an undefined variable.  Do likewise. */
5068                 return EXIT_SUCCESS;
5069         }
5070
5071         set_local_var(xstrdup(name), 1);
5072         return EXIT_SUCCESS;
5073 }
5074
5075 #if ENABLE_HUSH_JOB
5076 /* built-in 'fg' and 'bg' handler */
5077 static int builtin_fg_bg(char **argv)
5078 {
5079         int i, jobnum;
5080         struct pipe *pi;
5081
5082         if (!G_interactive_fd)
5083                 return EXIT_FAILURE;
5084         /* If they gave us no args, assume they want the last backgrounded task */
5085         if (!argv[1]) {
5086                 for (pi = G.job_list; pi; pi = pi->next) {
5087                         if (pi->jobid == G.last_jobid) {
5088                                 goto found;
5089                         }
5090                 }
5091                 bb_error_msg("%s: no current job", argv[0]);
5092                 return EXIT_FAILURE;
5093         }
5094         if (sscanf(argv[1], "%%%d", &jobnum) != 1) {
5095                 bb_error_msg("%s: bad argument '%s'", argv[0], argv[1]);
5096                 return EXIT_FAILURE;
5097         }
5098         for (pi = G.job_list; pi; pi = pi->next) {
5099                 if (pi->jobid == jobnum) {
5100                         goto found;
5101                 }
5102         }
5103         bb_error_msg("%s: %d: no such job", argv[0], jobnum);
5104         return EXIT_FAILURE;
5105  found:
5106         // TODO: bash prints a string representation
5107         // of job being foregrounded (like "sleep 1 | cat")
5108         if (*argv[0] == 'f') {
5109                 /* Put the job into the foreground.  */
5110                 tcsetpgrp(G_interactive_fd, pi->pgrp);
5111         }
5112
5113         /* Restart the processes in the job */
5114         debug_printf_jobs("reviving %d procs, pgrp %d\n", pi->num_cmds, pi->pgrp);
5115         for (i = 0; i < pi->num_cmds; i++) {
5116                 debug_printf_jobs("reviving pid %d\n", pi->cmds[i].pid);
5117                 pi->cmds[i].is_stopped = 0;
5118         }
5119         pi->stopped_cmds = 0;
5120
5121         i = kill(- pi->pgrp, SIGCONT);
5122         if (i < 0) {
5123                 if (errno == ESRCH) {
5124                         delete_finished_bg_job(pi);
5125                         return EXIT_SUCCESS;
5126                 } else {
5127                         bb_perror_msg("kill (SIGCONT)");
5128                 }
5129         }
5130
5131         if (*argv[0] == 'f') {
5132                 remove_bg_job(pi);
5133                 return checkjobs_and_fg_shell(pi);
5134         }
5135         return EXIT_SUCCESS;
5136 }
5137 #endif
5138
5139 #if ENABLE_HUSH_HELP
5140 static int builtin_help(char **argv UNUSED_PARAM)
5141 {
5142         const struct built_in_command *x;
5143
5144         printf("\nBuilt-in commands:\n");
5145         printf("-------------------\n");
5146         for (x = bltins; x != &bltins[ARRAY_SIZE(bltins)]; x++) {
5147                 printf("%s\t%s\n", x->cmd, x->descr);
5148         }
5149         printf("\n\n");
5150         return EXIT_SUCCESS;
5151 }
5152 #endif
5153
5154 #if ENABLE_HUSH_JOB
5155 static int builtin_jobs(char **argv UNUSED_PARAM)
5156 {
5157         struct pipe *job;
5158         const char *status_string;
5159
5160         for (job = G.job_list; job; job = job->next) {
5161                 if (job->alive_cmds == job->stopped_cmds)
5162                         status_string = "Stopped";
5163                 else
5164                         status_string = "Running";
5165
5166                 printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->cmdtext);
5167         }
5168         return EXIT_SUCCESS;
5169 }
5170 #endif
5171
5172 static int builtin_pwd(char **argv UNUSED_PARAM)
5173 {
5174         puts(set_cwd());
5175         return EXIT_SUCCESS;
5176 }
5177
5178 static int builtin_read(char **argv)
5179 {
5180         char *string;
5181         const char *name = argv[1] ? argv[1] : "REPLY";
5182
5183         string = xmalloc_reads(STDIN_FILENO, xasprintf("%s=", name), NULL);
5184         return set_local_var(string, 0);
5185 }
5186
5187 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#set
5188  * built-in 'set' handler
5189  * SUSv3 says:
5190  * set [-abCefhmnuvx] [-o option] [argument...]
5191  * set [+abCefhmnuvx] [+o option] [argument...]
5192  * set -- [argument...]
5193  * set -o
5194  * set +o
5195  * Implementations shall support the options in both their hyphen and
5196  * plus-sign forms. These options can also be specified as options to sh.
5197  * Examples:
5198  * Write out all variables and their values: set
5199  * Set $1, $2, and $3 and set "$#" to 3: set c a b
5200  * Turn on the -x and -v options: set -xv
5201  * Unset all positional parameters: set --
5202  * Set $1 to the value of x, even if it begins with '-' or '+': set -- "$x"
5203  * Set the positional parameters to the expansion of x, even if x expands
5204  * with a leading '-' or '+': set -- $x
5205  *
5206  * So far, we only support "set -- [argument...]" and some of the short names.
5207  */
5208 static int builtin_set(char **argv)
5209 {
5210         int n;
5211         char **pp, **g_argv;
5212         char *arg = *++argv;
5213
5214         if (arg == NULL) {
5215                 struct variable *e;
5216                 for (e = G.top_var; e; e = e->next)
5217                         puts(e->varstr);
5218                 return EXIT_SUCCESS;
5219         }
5220
5221         do {
5222                 if (!strcmp(arg, "--")) {
5223                         ++argv;
5224                         goto set_argv;
5225                 }
5226
5227                 if (arg[0] == '+' || arg[0] == '-') {
5228                         for (n = 1; arg[n]; ++n)
5229                                 if (set_mode(arg[0], arg[n]))
5230                                         goto error;
5231                         continue;
5232                 }
5233
5234                 break;
5235         } while ((arg = *++argv) != NULL);
5236         /* Now argv[0] is 1st argument */
5237
5238         /* Only reset global_argv if we didn't process anything */
5239         if (arg == NULL)
5240                 return EXIT_SUCCESS;
5241  set_argv:
5242
5243         /* NB: G.global_argv[0] ($0) is never freed/changed */
5244         g_argv = G.global_argv;
5245         if (G.global_args_malloced) {
5246                 pp = g_argv;
5247                 while (*++pp)
5248                         free(*pp);
5249                 g_argv[1] = NULL;
5250         } else {
5251                 G.global_args_malloced = 1;
5252                 pp = xzalloc(sizeof(pp[0]) * 2);
5253                 pp[0] = g_argv[0]; /* retain $0 */
5254                 g_argv = pp;
5255         }
5256         /* This realloc's G.global_argv */
5257         G.global_argv = pp = add_strings_to_strings(g_argv, argv, /*dup:*/ 1);
5258
5259         n = 1;
5260         while (*++pp)
5261                 n++;
5262         G.global_argc = n;
5263
5264         return EXIT_SUCCESS;
5265
5266         /* Nothing known, so abort */
5267  error:
5268         bb_error_msg("set: %s: invalid option", arg);
5269         return EXIT_FAILURE;
5270 }
5271
5272 static int builtin_shift(char **argv)
5273 {
5274         int n = 1;
5275         if (argv[1]) {
5276                 n = atoi(argv[1]);
5277         }
5278         if (n >= 0 && n < G.global_argc) {
5279                 if (G.global_args_malloced) {
5280                         int m = 1;
5281                         while (m <= n)
5282                                 free(G.global_argv[m++]);
5283                 }
5284                 G.global_argc -= n;
5285                 memmove(&G.global_argv[1], &G.global_argv[n+1],
5286                                 G.global_argc * sizeof(G.global_argv[0]));
5287                 return EXIT_SUCCESS;
5288         }
5289         return EXIT_FAILURE;
5290 }
5291
5292 static int builtin_source(char **argv)
5293 {
5294         FILE *input;
5295
5296         if (argv[1] == NULL)
5297                 return EXIT_FAILURE;
5298
5299         /* XXX search through $PATH is missing */
5300         input = fopen_for_read(argv[1]);
5301         if (!input) {
5302                 bb_error_msg("can't open '%s'", argv[1]);
5303                 return EXIT_FAILURE;
5304         }
5305         close_on_exec_on(fileno(input));
5306
5307         /* Now run the file */
5308         /* XXX argv and argc are broken; need to save old G.global_argv
5309          * (pointer only is OK!) on this stack frame,
5310          * set G.global_argv=argv+1, recurse, and restore. */
5311         parse_and_run_file(input);
5312         fclose(input);
5313         return G.last_return_code;
5314 }
5315
5316 static int builtin_umask(char **argv)
5317 {
5318         mode_t new_umask;
5319         const char *arg = argv[1];
5320         if (arg) {
5321                 new_umask = bb_strtou(arg, NULL, 8);
5322                 if (errno)
5323                         return EXIT_FAILURE;
5324         } else {
5325                 new_umask = umask(0);
5326                 printf("%.3o\n", (unsigned) new_umask);
5327         }
5328         umask(new_umask);
5329         return EXIT_SUCCESS;
5330 }
5331
5332 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#unset */
5333 static int builtin_unset(char **argv)
5334 {
5335         size_t i;
5336         int ret;
5337         bool var = true;
5338
5339         if (!argv[1])
5340                 return EXIT_SUCCESS;
5341
5342         i = 0;
5343         if (argv[1][0] == '-') {
5344                 switch (argv[1][1]) {
5345                 case 'v': break;
5346                 case 'f': if (ENABLE_HUSH_FUNCTIONS) { var = false; break; }
5347                 default:
5348                         bb_error_msg("unset: %s: invalid option", argv[1]);
5349                         return EXIT_FAILURE;
5350                 }
5351                 ++i;
5352         }
5353
5354         ret = EXIT_SUCCESS;
5355         while (argv[++i]) {
5356                 if (var) {
5357                         if (unset_local_var(argv[i]))
5358                                 ret = EXIT_FAILURE;
5359                 }
5360 #if ENABLE_HUSH_FUNCTIONS
5361                 else
5362                         unset_local_func(argv[i]);
5363 #endif
5364         }
5365         return ret;
5366 }
5367
5368 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/wait.html */
5369 static int builtin_wait(char **argv)
5370 {
5371         int ret = EXIT_SUCCESS;
5372         int status, sig;
5373
5374         if (*++argv == NULL) {
5375                 /* Don't care about wait results */
5376                 /* Note 1: must wait until there are no more children */
5377                 /* Note 2: must be interruptible */
5378                 /* Examples:
5379                  * $ sleep 3 & sleep 6 & wait
5380                  * [1] 30934 sleep 3
5381                  * [2] 30935 sleep 6
5382                  * [1] Done                   sleep 3
5383                  * [2] Done                   sleep 6
5384                  * $ sleep 3 & sleep 6 & wait
5385                  * [1] 30936 sleep 3
5386                  * [2] 30937 sleep 6
5387                  * [1] Done                   sleep 3
5388                  * ^C <-- after ~4 sec from keyboard
5389                  * $
5390                  */
5391                 sigaddset(&G.blocked_set, SIGCHLD);
5392                 sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
5393                 while (1) {
5394                         checkjobs(NULL);
5395                         if (errno == ECHILD)
5396                                 break;
5397                         /* Wait for SIGCHLD or any other signal of interest */
5398                         /* sigtimedwait with infinite timeout: */
5399                         sig = sigwaitinfo(&G.blocked_set, NULL);
5400                         if (sig > 0) {
5401                                 sig = check_and_run_traps(sig);
5402                                 if (sig && sig != SIGCHLD) { /* see note 2 */
5403                                         ret = 128 + sig;
5404                                         break;
5405                                 }
5406                         }
5407                 }
5408                 sigdelset(&G.blocked_set, SIGCHLD);
5409                 sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
5410                 return ret;
5411         }
5412
5413         /* This is probably buggy wrt interruptible-ness */
5414         while (*argv) {
5415                 pid_t pid = bb_strtou(*argv, NULL, 10);
5416                 if (errno) {
5417                         /* mimic bash message */
5418                         bb_error_msg("wait: '%s': not a pid or valid job spec", *argv);
5419                         return EXIT_FAILURE;
5420                 }
5421                 if (waitpid(pid, &status, 0) == pid) {
5422                         if (WIFSIGNALED(status))
5423                                 ret = 128 + WTERMSIG(status);
5424                         else if (WIFEXITED(status))
5425                                 ret = WEXITSTATUS(status);
5426                         else /* wtf? */
5427                                 ret = EXIT_FAILURE;
5428                 } else {
5429                         bb_perror_msg("wait %s", *argv);
5430                         ret = 127;
5431                 }
5432                 argv++;
5433         }
5434
5435         return ret;
5436 }
5437
5438 #if ENABLE_HUSH_LOOPS
5439 static int builtin_break(char **argv)
5440 {
5441         if (G.depth_of_loop == 0) {
5442                 bb_error_msg("%s: only meaningful in a loop", argv[0]);
5443                 return EXIT_SUCCESS; /* bash compat */
5444         }
5445         G.flag_break_continue++; /* BC_BREAK = 1 */
5446         G.depth_break_continue = 1;
5447         if (argv[1]) {
5448                 G.depth_break_continue = bb_strtou(argv[1], NULL, 10);
5449                 if (errno || !G.depth_break_continue || argv[2]) {
5450                         bb_error_msg("%s: bad arguments", argv[0]);
5451                         G.flag_break_continue = BC_BREAK;
5452                         G.depth_break_continue = UINT_MAX;
5453                 }
5454         }
5455         if (G.depth_of_loop < G.depth_break_continue)
5456                 G.depth_break_continue = G.depth_of_loop;
5457         return EXIT_SUCCESS;
5458 }
5459
5460 static int builtin_continue(char **argv)
5461 {
5462         G.flag_break_continue = 1; /* BC_CONTINUE = 2 = 1+1 */
5463         return builtin_break(argv);
5464 }
5465 #endif