1 /* vi: set sw=4 ts=4: */
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.
8 * Copyright (C) 2000,2001 Larry Doolittle <larry@doolittle.boa.org>
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
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.
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.
39 * POSIX syntax not implemented:
41 * <(list) and >(list) Process Substitution
42 * Here Documents ( << word )
45 * Parameter Expansion for substring processing ${var#word} ${var%word}
47 * Bash stuff maybe optional enable:
48 * &> and >& redirection of stdout+stderr
50 * reserved words: [[ ]] function select
51 * substrings ${var:1:5}
54 * job handling woefully incomplete and buggy (improved --vda)
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 * maybe change charmap[] to use 2-bit entries
66 * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
69 #include "busybox.h" /* for APPLET_IS_NOFORK/NOEXEC */
70 //TODO: pull in some .h and find out whether we have SINGLE_APPLET_MAIN?
71 //#include "applet_tables.h" doesn't work
73 /* #include <dmalloc.h> */
80 #define HUSH_VER_STR "0.92"
82 #if defined SINGLE_APPLET_MAIN
83 /* STANDALONE does not make sense, and won't compile */
84 #undef CONFIG_FEATURE_SH_STANDALONE
85 #undef ENABLE_FEATURE_SH_STANDALONE
86 #undef USE_FEATURE_SH_STANDALONE
87 #define SKIP_FEATURE_SH_STANDALONE(...) __VA_ARGS__
88 #define ENABLE_FEATURE_SH_STANDALONE 0
89 #define USE_FEATURE_SH_STANDALONE(...)
90 #define SKIP_FEATURE_SH_STANDALONE(...) __VA_ARGS__
93 #if !BB_MMU && ENABLE_HUSH_TICK
94 //#undef ENABLE_HUSH_TICK
95 //#define ENABLE_HUSH_TICK 0
96 #warning On NOMMU, hush command substitution is dangerous.
97 #warning Dont use it for commands which produce lots of output.
98 #warning For more info see shell/hush.c, generate_stream_from_list().
101 #if !ENABLE_HUSH_INTERACTIVE
102 #undef ENABLE_FEATURE_EDITING
103 #define ENABLE_FEATURE_EDITING 0
104 #undef ENABLE_FEATURE_EDITING_FANCY_PROMPT
105 #define ENABLE_FEATURE_EDITING_FANCY_PROMPT 0
108 /* Do we support ANY keywords? */
109 #if ENABLE_HUSH_IF || ENABLE_HUSH_LOOPS || ENABLE_HUSH_CASE
110 #define HAS_KEYWORDS 1
111 #define IF_HAS_KEYWORDS(...) __VA_ARGS__
112 #define IF_HAS_NO_KEYWORDS(...)
114 #define HAS_KEYWORDS 0
115 #define IF_HAS_KEYWORDS(...)
116 #define IF_HAS_NO_KEYWORDS(...) __VA_ARGS__
119 /* Keep unconditionally on for now */
122 #define ENABLE_HUSH_FUNCTIONS 0
125 /* If you comment out one of these below, it will be #defined later
126 * to perform debug printfs to stderr: */
127 #define debug_printf(...) do {} while (0)
128 /* Finer-grained debug switches */
129 #define debug_printf_parse(...) do {} while (0)
130 #define debug_print_tree(a, b) do {} while (0)
131 #define debug_printf_exec(...) do {} while (0)
132 #define debug_printf_env(...) do {} while (0)
133 #define debug_printf_jobs(...) do {} while (0)
134 #define debug_printf_expand(...) do {} while (0)
135 #define debug_printf_glob(...) do {} while (0)
136 #define debug_printf_list(...) do {} while (0)
137 #define debug_printf_subst(...) do {} while (0)
138 #define debug_printf_clean(...) do {} while (0)
141 #define debug_printf(...) fprintf(stderr, __VA_ARGS__)
144 #ifndef debug_printf_parse
145 #define debug_printf_parse(...) fprintf(stderr, __VA_ARGS__)
148 #ifndef debug_printf_exec
149 #define debug_printf_exec(...) fprintf(stderr, __VA_ARGS__)
152 #ifndef debug_printf_env
153 #define debug_printf_env(...) fprintf(stderr, __VA_ARGS__)
156 #ifndef debug_printf_jobs
157 #define debug_printf_jobs(...) fprintf(stderr, __VA_ARGS__)
163 #ifndef debug_printf_expand
164 #define debug_printf_expand(...) fprintf(stderr, __VA_ARGS__)
165 #define DEBUG_EXPAND 1
167 #define DEBUG_EXPAND 0
170 #ifndef debug_printf_glob
171 #define debug_printf_glob(...) fprintf(stderr, __VA_ARGS__)
177 #ifndef debug_printf_list
178 #define debug_printf_list(...) fprintf(stderr, __VA_ARGS__)
181 #ifndef debug_printf_subst
182 #define debug_printf_subst(...) fprintf(stderr, __VA_ARGS__)
185 #ifndef debug_printf_clean
186 /* broken, of course, but OK for testing */
187 static const char *indenter(int i)
189 static const char blanks[] ALIGN1 =
191 return &blanks[sizeof(blanks) - i - 1];
193 #define debug_printf_clean(...) fprintf(stderr, __VA_ARGS__)
194 #define DEBUG_CLEAN 1
198 static void debug_print_strings(const char *prefix, char **vv)
200 fprintf(stderr, "%s:\n", prefix);
202 fprintf(stderr, " '%s'\n", *vv++);
205 #define debug_print_strings(prefix, vv) ((void)0)
209 * Leak hunting. Use hush_leaktool.sh for post-processing.
211 #ifdef FOR_HUSH_LEAKTOOL
212 /* suppress "warning: no previous prototype..." */
213 void *xxmalloc(int lineno, size_t size);
214 void *xxrealloc(int lineno, void *ptr, size_t size);
215 char *xxstrdup(int lineno, const char *str);
216 void xxfree(void *ptr);
217 void *xxmalloc(int lineno, size_t size)
219 void *ptr = xmalloc((size + 0xff) & ~0xff);
220 fdprintf(2, "line %d: malloc %p\n", lineno, ptr);
223 void *xxrealloc(int lineno, void *ptr, size_t size)
225 ptr = xrealloc(ptr, (size + 0xff) & ~0xff);
226 fdprintf(2, "line %d: realloc %p\n", lineno, ptr);
229 char *xxstrdup(int lineno, const char *str)
231 char *ptr = xstrdup(str);
232 fdprintf(2, "line %d: strdup %p\n", lineno, ptr);
235 void xxfree(void *ptr)
237 fdprintf(2, "free %p\n", ptr);
240 #define xmalloc(s) xxmalloc(__LINE__, s)
241 #define xrealloc(p, s) xxrealloc(__LINE__, p, s)
242 #define xstrdup(s) xxstrdup(__LINE__, s)
243 #define free(p) xxfree(p)
247 #define ERR_PTR ((void*)(long)1)
249 static const char hush_version_str[] ALIGN1 = "HUSH_VERSION="HUSH_VER_STR;
251 #define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
253 #define SPECIAL_VAR_SYMBOL 3
255 typedef enum redir_type {
257 REDIRECT_OVERWRITE = 2,
263 /* The descrip member of this structure is only used to make
264 * debugging output pretty */
265 static const struct {
267 signed char default_fd;
271 { O_RDONLY, 0, "<" },
272 { O_CREAT|O_TRUNC|O_WRONLY, 1, ">" },
273 { O_CREAT|O_APPEND|O_WRONLY, 1, ">>" },
274 { O_RDONLY, -1, "<<" },
278 typedef enum pipe_style {
285 typedef enum reserved_style {
294 #if ENABLE_HUSH_LOOPS
301 #if ENABLE_HUSH_LOOPS || ENABLE_HUSH_CASE
306 /* two pseudo-keywords support contrived "case" syntax: */
307 RES_MATCH , /* "word)" */
308 RES_CASEI , /* "this command is inside CASE" */
315 struct redir_struct {
316 struct redir_struct *next;
317 char *rd_filename; /* filename */
318 int fd; /* file descriptor being redirected */
319 int dup; /* -1, or file descriptor being duplicated */
320 smallint /*enum redir_type*/ rd_type;
324 pid_t pid; /* 0 if exited */
325 int assignment_cnt; /* how many argv[i] are assignments? */
326 smallint is_stopped; /* is the command currently running? */
327 smallint grp_type; /* GRP_xxx */
328 struct pipe *group; /* if non-NULL, this "prog" is {} group,
329 * subshell, or a compound statement */
330 char **argv; /* command name and arguments */
331 struct redir_struct *redirects; /* I/O redirections */
333 /* argv vector may contain variable references (^Cvar^C, ^C0^C etc)
334 * and on execution these are substituted with their values.
335 * Substitution can make _several_ words out of one argv[n]!
336 * Example: argv[0]=='.^C*^C.' here: echo .$*.
337 * References of the form ^C`cmd arg^C are `cmd arg` substitutions.
340 #define GRP_SUBSHELL 1
341 #if ENABLE_HUSH_FUNCTIONS
342 #define GRP_FUNCTION 2
347 int num_cmds; /* total number of commands in job */
348 int alive_cmds; /* number of commands running (not exited) */
349 int stopped_cmds; /* number of commands alive, but stopped */
351 int jobid; /* job number */
352 pid_t pgrp; /* process group ID for the job */
353 char *cmdtext; /* name of job */
355 struct command *cmds; /* array of commands in pipe */
356 smallint followup; /* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */
357 IF_HAS_KEYWORDS(smallint pi_inverted;) /* "! cmd | cmd" */
358 IF_HAS_KEYWORDS(smallint res_word;) /* needed for if, for, while, until... */
361 /* This holds pointers to the various results of parsing */
362 struct parse_context {
363 /* linked list of pipes */
364 struct pipe *list_head;
365 /* last pipe (being constructed right now) */
367 /* last command in pipe (being constructed right now) */
368 struct command *command;
369 /* last redirect in command->redirects list */
370 struct redir_struct *pending_redirect;
373 smallint ctx_inverted; /* "! cmd | cmd" */
375 smallint ctx_dsemicolon; /* ";;" seen */
377 /* bitmask of FLAG_xxx, for figuring out valid reserved words */
379 /* group we are enclosed in:
380 * example 1: "{ { false; ..."
381 * example 2: "if true; then { false; ..."
382 * example 3: "if true; then if false; ..."
383 * when we find closing "}" / "fi" / whatever, we move list_head
384 * into stack->command->group and delete ourself.
386 struct parse_context *stack;
390 /* On program start, environ points to initial environment.
391 * putenv adds new pointers into it, unsetenv removes them.
392 * Neither of these (de)allocates the strings.
393 * setenv allocates new strings in malloc space and does putenv,
394 * and thus setenv is unusable (leaky) for shell's purposes */
395 #define setenv(...) setenv_is_leaky_dont_use()
397 struct variable *next;
398 char *varstr; /* points to "name=" portion */
399 int max_len; /* if > 0, name is part of initial env; else name is malloced */
400 smallint flg_export; /* putenv should be done on this var */
401 smallint flg_read_only;
404 typedef struct o_string {
406 int length; /* position where data is appended */
408 /* Protect newly added chars against globbing
409 * (by prepending \ to *, ?, [, \) */
413 smallint has_empty_slot;
414 smallint o_assignment; /* 0:maybe, 1:yes, 2:no */
417 MAYBE_ASSIGNMENT = 0,
418 DEFINITELY_ASSIGNMENT = 1,
420 WORD_IS_KEYWORD = 3, /* not assigment, but next word may be: "if v=xyz cmd;" */
422 /* Used for initialization: o_string foo = NULL_O_STRING; */
423 #define NULL_O_STRING { NULL }
425 /* I can almost use ordinary FILE*. Is open_memstream() universally
426 * available? Where is it documented? */
427 typedef struct in_str {
429 /* eof_flag=1: last char in ->p is really an EOF */
430 char eof_flag; /* meaningless if ->p == NULL */
432 #if ENABLE_HUSH_INTERACTIVE
434 smallint promptmode; /* 0: PS1, 1: PS2 */
437 int (*get) (struct in_str *);
438 int (*peek) (struct in_str *);
440 #define i_getch(input) ((input)->get(input))
441 #define i_peek(input) ((input)->peek(input))
445 CHAR_ORDINARY_IF_QUOTED = 1, /* example: *, # */
446 CHAR_IFS = 2, /* treated as ordinary if quoted */
447 CHAR_SPECIAL = 3, /* \, $, ", maybe ` */
456 /* "Globals" within this file */
457 /* Sorted roughly by size (smaller offsets == smaller code) */
459 #if ENABLE_HUSH_INTERACTIVE
460 /* 'interactive_fd' is a fd# open to ctty, if we have one
461 * _AND_ if we decided to act interactively */
465 #define G_interactive_fd (G.interactive_fd)
467 #define G_interactive_fd 0
469 #if ENABLE_FEATURE_EDITING
470 line_input_t *line_input_state;
476 pid_t saved_tty_pgrp;
478 struct pipe *job_list;
479 struct pipe *toplevel_list;
480 //// smallint ctrl_z_flag;
482 smallint flag_SIGINT;
483 #if ENABLE_HUSH_LOOPS
484 smallint flag_break_continue;
487 /* These four support $?, $#, and $1 */
488 smalluint last_return_code;
489 /* is global_argv and global_argv[1..n] malloced? (note: not [0]) */
490 smalluint global_args_malloced;
491 /* how many non-NULL argv's we have. NB: $# + 1 */
494 #if ENABLE_HUSH_LOOPS
495 unsigned depth_break_continue;
496 unsigned depth_of_loop;
500 struct variable *top_var; /* = &G.shell_ver (set in main()) */
501 struct variable shell_ver;
502 #if ENABLE_FEATURE_SH_STANDALONE
503 struct nofork_save_area nofork_save;
506 sigjmp_buf toplevel_jb;
508 unsigned char charmap[256];
509 char user_input_buf[ENABLE_FEATURE_EDITING ? BUFSIZ : 2];
510 /* Signal and trap handling */
511 // unsigned count_SIGCHLD;
512 // unsigned handled_SIGCHLD;
513 /* which signals have non-DFL handler (even with no traps set)? */
514 unsigned non_DFL_mask;
515 char **traps; /* char *traps[NSIG] */
516 sigset_t blocked_set;
517 sigset_t inherited_set;
519 #define G (*ptr_to_globals)
520 /* Not #defining name to G.name - this quickly gets unwieldy
521 * (too many defines). Also, I actually prefer to see when a variable
522 * is global, thus "G." prefix is a useful hint */
523 #define INIT_G() do { \
524 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
528 /* Function prototypes for builtins */
529 static int builtin_cd(char **argv);
530 static int builtin_echo(char **argv);
531 static int builtin_eval(char **argv);
532 static int builtin_exec(char **argv);
533 static int builtin_exit(char **argv);
534 static int builtin_export(char **argv);
536 static int builtin_fg_bg(char **argv);
537 static int builtin_jobs(char **argv);
540 static int builtin_help(char **argv);
542 static int builtin_pwd(char **argv);
543 static int builtin_read(char **argv);
544 static int builtin_test(char **argv);
545 static int builtin_trap(char **argv);
546 static int builtin_true(char **argv);
547 static int builtin_set(char **argv);
548 static int builtin_shift(char **argv);
549 static int builtin_source(char **argv);
550 static int builtin_umask(char **argv);
551 static int builtin_unset(char **argv);
552 static int builtin_wait(char **argv);
553 #if ENABLE_HUSH_LOOPS
554 static int builtin_break(char **argv);
555 static int builtin_continue(char **argv);
557 //static int builtin_not_written(char **argv);
559 /* Table of built-in functions. They can be forked or not, depending on
560 * context: within pipes, they fork. As simple commands, they do not.
561 * When used in non-forking context, they can change global variables
562 * in the parent shell process. If forked, of course they cannot.
563 * For example, 'unset foo | whatever' will parse and run, but foo will
564 * still be set at the end. */
565 struct built_in_command {
567 int (*function)(char **argv);
570 #define BLTIN(cmd, func, help) { cmd, func, help }
572 #define BLTIN(cmd, func, help) { cmd, func }
576 /* For now, echo and test are unconditionally enabled.
577 * Maybe make it configurable? */
578 static const struct built_in_command bltins[] = {
579 BLTIN("." , builtin_source, "Run commands in a file"),
580 BLTIN(":" , builtin_true, "No-op"),
581 BLTIN("[" , builtin_test, "Test condition"),
583 BLTIN("bg" , builtin_fg_bg, "Resume a job in the background"),
585 #if ENABLE_HUSH_LOOPS
586 BLTIN("break" , builtin_break, "Exit from a loop"),
588 BLTIN("cd" , builtin_cd, "Change directory"),
589 #if ENABLE_HUSH_LOOPS
590 BLTIN("continue", builtin_continue, "Start new loop iteration"),
592 BLTIN("echo" , builtin_echo, "Write to stdout"),
593 BLTIN("eval" , builtin_eval, "Construct and run shell command"),
594 BLTIN("exec" , builtin_exec, "Execute command, don't return to shell"),
595 BLTIN("exit" , builtin_exit, "Exit"),
596 BLTIN("export", builtin_export, "Set environment variable"),
598 BLTIN("fg" , builtin_fg_bg, "Bring job into the foreground"),
599 BLTIN("jobs" , builtin_jobs, "List active jobs"),
601 BLTIN("pwd" , builtin_pwd, "Print current directory"),
602 BLTIN("read" , builtin_read, "Input environment variable"),
603 // BLTIN("return", builtin_not_written, "Return from a function"),
604 BLTIN("set" , builtin_set, "Set/unset shell local variables"),
605 BLTIN("shift" , builtin_shift, "Shift positional parameters"),
606 BLTIN("test" , builtin_test, "Test condition"),
607 BLTIN("trap" , builtin_trap, "Trap signals"),
608 // BLTIN("ulimit", builtin_not_written, "Control resource limits"),
609 BLTIN("umask" , builtin_umask, "Set file creation mask"),
610 BLTIN("unset" , builtin_unset, "Unset environment variable"),
611 BLTIN("wait" , builtin_wait, "Wait for process"),
613 BLTIN("help" , builtin_help, "List shell built-in commands"),
619 static void maybe_die(const char *notice, const char *msg)
621 /* Was using fancy stuff:
622 * (G_interactive_fd ? bb_error_msg : bb_error_msg_and_die)(...params...)
623 * but it SEGVs. ?! Oh well... explicit temp ptr works around that */
624 void FAST_FUNC (*fp)(const char *s, ...) = bb_error_msg_and_die;
625 #if ENABLE_HUSH_INTERACTIVE
626 fp = (G_interactive_fd ? bb_error_msg : bb_error_msg_and_die);
628 fp(msg ? "%s: %s" : notice, notice, msg);
631 #define syntax(msg) maybe_die("syntax error", msg);
633 /* Debug -- trick gcc to expand __LINE__ and convert to string */
634 #define __syntax(msg, line) maybe_die("syntax error hush.c:" # line, msg)
635 #define _syntax(msg, line) __syntax(msg, line)
636 #define syntax(msg) _syntax(msg, __LINE__)
639 static int glob_needed(const char *s)
644 if (*s == '*' || *s == '[' || *s == '?')
651 static int is_assignment(const char *s)
653 if (!s || !(isalpha(*s) || *s == '_'))
656 while (isalnum(*s) || *s == '_')
661 /* Replace each \x with x in place, return ptr past NUL. */
662 static char *unbackslash(char *src)
668 if ((*dst++ = *src++) == '\0')
674 static char **add_strings_to_strings(char **strings, char **add, int need_to_dup)
695 v = xrealloc(strings, (count1 + count2 + 1) * sizeof(char*));
696 v[count1 + count2] = NULL;
699 v[count1 + i] = (need_to_dup ? xstrdup(add[i]) : add[i]);
703 static char **add_string_to_strings(char **strings, char *add)
708 return add_strings_to_strings(strings, v, /*dup:*/ 0);
711 static void putenv_all(char **strings)
716 debug_printf_env("putenv '%s'\n", *strings);
721 static char **putenv_all_and_save_old(char **strings)
731 eq = strchr(*strings, '=');
734 v = getenv(*strings);
737 /* v points to VAL in VAR=VAL, go back to VAR */
738 v -= (eq - *strings) + 1;
739 old = add_string_to_strings(old, v);
748 static void free_strings_and_unsetenv(char **strings, int unset)
758 debug_printf_env("unsetenv '%s'\n", *v);
766 static void free_strings(char **strings)
768 free_strings_and_unsetenv(strings, 0);
772 /* Basic theory of signal handling in shell
773 * ========================================
774 * This does not describe what hush does, rather, it is current understanding
775 * what it _should_ do. If it doesn't, it's a bug.
776 * http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#trap
778 * Signals are handled only after each pipe ("cmd | cmd | cmd" thing)
779 * is finished or backgrounded. It is the same in interactive and
780 * non-interactive shells, and is the same regardless of whether
781 * a user trap handler is installed or a shell special one is in effect.
782 * ^C or ^Z from keyboard seem to execute "at once" because it usually
783 * backgrounds (i.e. stops) or kills all members of currently running
786 * Wait builtin in interruptible by signals for which user trap is set
787 * or by SIGINT in interactive shell.
789 * Trap handlers will execute even within trap handlers. (right?)
791 * User trap handlers are forgotten when subshell ("(cmd)") is entered. [TODO]
793 * If job control is off, backgrounded commands ("cmd &")
794 * have SIGINT, SIGQUIT set to SIG_IGN.
796 * Commands run in command substitution ("`cmd`")
797 * have SIGTTIN, SIGTTOU, SIGTSTP set to SIG_IGN.
799 * Ordinary commands have signals set to SIG_IGN/DFL set as inherited
800 * by the shell from its parent.
802 * Siganls which differ from SIG_DFL action
803 * (note: child (i.e., [v]forked) shell is not an interactive shell):
806 * SIGTERM (interactive): ignore
807 * SIGHUP (interactive):
808 * send SIGCONT to stopped jobs, send SIGHUP to all jobs and exit
809 * SIGTTIN, SIGTTOU, SIGTSTP (if job control is on): ignore
810 * (note that ^Z is handled not by trapping SIGTSTP, but by seeing
811 * that all pipe members are stopped) (right?)
812 * SIGINT (interactive): wait for last pipe, ignore the rest
813 * of the command line, show prompt. NB: ^C does not send SIGINT
814 * to interactive shell while shell is waiting for a pipe,
815 * since shell is bg'ed (is not in foreground process group).
816 * (check/expand this)
817 * Example 1: this waits 5 sec, but does not execute ls:
818 * "echo $$; sleep 5; ls -l" + "kill -INT <pid>"
819 * Example 2: this does not wait and does not execute ls:
820 * "echo $$; sleep 5 & wait; ls -l" + "kill -INT <pid>"
821 * Example 3: this does not wait 5 sec, but executes ls:
822 * "sleep 5; ls -l" + press ^C
824 * (What happens to signals which are IGN on shell start?)
825 * (What happens with signal mask on shell start?)
827 * Implementation in hush
828 * ======================
829 * We use in-kernel pending signal mask to determine which signals were sent.
830 * We block all signals which we don't want to take action immediately,
831 * i.e. we block all signals which need to have special handling as described
832 * above, and all signals which have traps set.
833 * After each pipe execution, we extract any pending signals via sigtimedwait()
836 * unsigned non_DFL_mask: a mask of such "special" signals
837 * sigset_t blocked_set: current blocked signal set
840 * clear bit in blocked_set unless it is also in non_DFL
841 * "trap 'cmd' SIGxxx":
842 * set bit in blocked_set (even if 'cmd' is '')
843 * after [v]fork, if we plan to be a shell:
844 * nothing for {} child shell (say, "true | { true; true; } | true")
845 * unset all traps if () shell. [TODO]
846 * after [v]fork, if we plan to exec:
847 * POSIX says pending signal mask is cleared in child - no need to clear it.
848 * Restore blocked signal set to one inherited by shell just prior to exec.
850 * Note: as a result, we do not use signal handlers much. The only uses
851 * are to count SIGCHLDs [disabled - bug somewhere, + bloat]
852 * and to restore tty pgrp on signal-induced exit.
854 * TODO: check/fix wait builtin to be interruptible.
857 //static void SIGCHLD_handler(int sig UNUSED_PARAM)
859 // G.count_SIGCHLD++;
862 /* called once at shell init */
863 static void init_signal_mask(void)
866 unsigned mask = (1 << SIGQUIT);
867 if (G_interactive_fd) {
873 | (1 << SIGTTIN) | (1 << SIGTTOU) | (1 << SIGTSTP)
878 G.non_DFL_mask = mask;
880 sigprocmask(SIG_SETMASK, NULL, &G.blocked_set);
884 sigaddset(&G.blocked_set, sig);
888 sigdelset(&G.blocked_set, SIGCHLD);
889 sigprocmask(SIG_SETMASK, &G.blocked_set, &G.inherited_set);
892 static int check_and_run_traps(int sig)
894 static const struct timespec zero_timespec = { 0, 0 };
895 smalluint save_rcode;
901 sig = sigtimedwait(&G.blocked_set, NULL, &zero_timespec);
906 if (G.traps && G.traps[sig]) {
907 if (G.traps[sig][0]) {
908 /* We have user-defined handler */
909 char *argv[] = { NULL, xstrdup(G.traps[sig]), NULL };
910 save_rcode = G.last_return_code;
913 G.last_return_code = save_rcode;
914 } /* else: "" trap, ignoring signal */
917 /* not a trap: special action */
920 // G.count_SIGCHLD++;
929 default: /* SIGTERM, SIGQUIT, SIGTTIN, SIGTTOU, SIGTSTP */
938 /* Restores tty foreground process group, and exits.
939 * May be called as signal handler for fatal signal
940 * (will faithfully resend signal to itself, producing correct exit state)
941 * or called directly with -EXITCODE.
942 * We also call it if xfunc is exiting. */
943 static void sigexit(int sig) NORETURN;
944 static void sigexit(int sig)
946 /* Disable all signals: job control, SIGPIPE, etc. */
947 sigprocmask_allsigs(SIG_BLOCK);
949 /* Careful: we can end up here after [v]fork. Do not restore
950 * tty pgrp then, only top-level shell process does that */
951 if (G_interactive_fd && getpid() == G.root_pid)
952 tcsetpgrp(G_interactive_fd, G.saved_tty_pgrp);
954 /* Not a signal, just exit */
958 kill_myself_with_sig(sig); /* does not return */
962 static void maybe_set_sighandler(int sig)
964 void (*handler)(int);
965 /* non_DFL_mask'ed signals are, well, masked,
966 * no need to set handler for them.
968 if (!((G.non_DFL_mask >> sig) & 1)) {
969 handler = signal(sig, sigexit);
970 if (handler == SIG_IGN) /* oops... restore back to IGN! */
971 signal(sig, handler);
974 /* Used only to set handler to restore pgrp on exit */
975 static void set_fatal_signals_to_sigexit(void)
978 maybe_set_sighandler(SIGILL );
979 maybe_set_sighandler(SIGFPE );
980 maybe_set_sighandler(SIGBUS );
981 maybe_set_sighandler(SIGSEGV);
982 maybe_set_sighandler(SIGTRAP);
983 } /* else: hush is perfect. what SEGV? */
985 maybe_set_sighandler(SIGABRT);
987 /* bash 3.2 seems to handle these just like 'fatal' ones */
988 maybe_set_sighandler(SIGPIPE);
989 maybe_set_sighandler(SIGALRM);
990 maybe_set_sighandler(SIGHUP );
992 /* if we aren't interactive... but in this case
993 * we never want to restore pgrp on exit, and this fn is not called */
994 /*maybe_set_sighandler(SIGTERM);*/
995 /*maybe_set_sighandler(SIGINT );*/
997 /* Used only to suppress ^Z in `cmd` */
998 static void set_jobctrl_signals_to_IGN(void)
1009 #define set_fatal_signals_to_sigexit(handler) ((void)0)
1010 #define set_jobctrl_signals_to_IGN(handler) ((void)0)
1014 /* Restores tty foreground process group, and exits. */
1015 static void hush_exit(int exitcode) NORETURN;
1016 static void hush_exit(int exitcode)
1018 if (G.traps && G.traps[0] && G.traps[0][0]) {
1019 char *argv[] = { NULL, xstrdup(G.traps[0]), NULL };
1025 fflush(NULL); /* flush all streams */
1026 sigexit(- (exitcode & 0xff));
1033 static const char *set_cwd(void)
1035 /* xrealloc_getcwd_or_warn(arg) calls free(arg),
1036 * we must not try to free(bb_msg_unknown) */
1037 if (G.cwd == bb_msg_unknown)
1039 G.cwd = xrealloc_getcwd_or_warn((char *)G.cwd);
1041 G.cwd = bb_msg_unknown;
1046 /* Get/check local shell variables */
1047 static struct variable *get_local_var(const char *name)
1049 struct variable *cur;
1055 for (cur = G.top_var; cur; cur = cur->next) {
1056 if (strncmp(cur->varstr, name, len) == 0 && cur->varstr[len] == '=')
1062 /* Basically useful version until someone wants to get fancier,
1063 * see the bash man page under "Parameter Expansion" */
1064 static const char *lookup_param(const char *src)
1066 struct variable *var = get_local_var(src);
1068 return strchr(var->varstr, '=') + 1;
1072 /* str holds "NAME=VAL" and is expected to be malloced.
1073 * We take ownership of it.
1074 * flg_export is used by:
1077 * -1: if NAME is set, leave export status alone
1078 * if NAME is not set, do not export
1080 static int set_local_var(char *str, int flg_export)
1082 struct variable *cur;
1086 value = strchr(str, '=');
1087 if (!value) { /* not expected to ever happen? */
1092 name_len = value - str + 1; /* including '=' */
1093 cur = G.top_var; /* cannot be NULL (we have HUSH_VERSION and it's RO) */
1095 if (strncmp(cur->varstr, str, name_len) != 0) {
1097 /* Bail out. Note that now cur points
1098 * to last var in linked list */
1104 /* We found an existing var with this name */
1106 if (cur->flg_read_only) {
1107 bb_error_msg("%s: readonly variable", str);
1111 debug_printf_env("%s: unsetenv '%s'\n", __func__, str);
1112 unsetenv(str); /* just in case */
1114 if (strcmp(cur->varstr, str) == 0) {
1119 if (cur->max_len >= strlen(str)) {
1120 /* This one is from startup env, reuse space */
1121 strcpy(cur->varstr, str);
1124 /* max_len == 0 signifies "malloced" var, which we can
1125 * (and has to) free */
1129 goto set_str_and_exp;
1132 /* Not found - create next variable struct */
1133 cur->next = xzalloc(sizeof(*cur));
1139 if (flg_export == 1)
1140 cur->flg_export = 1;
1141 if (cur->flg_export) {
1142 debug_printf_env("%s: putenv '%s'\n", __func__, cur->varstr);
1143 return putenv(cur->varstr);
1148 static int unset_local_var(const char *name)
1150 struct variable *cur;
1151 struct variable *prev = prev; /* for gcc */
1155 return EXIT_SUCCESS;
1156 name_len = strlen(name);
1159 if (strncmp(cur->varstr, name, name_len) == 0 && cur->varstr[name_len] == '=') {
1160 if (cur->flg_read_only) {
1161 bb_error_msg("%s: readonly variable", name);
1162 return EXIT_FAILURE;
1164 /* prev is ok to use here because 1st variable, HUSH_VERSION,
1165 * is ro, and we cannot reach this code on the 1st pass */
1166 prev->next = cur->next;
1167 debug_printf_env("%s: unsetenv '%s'\n", __func__, cur->varstr);
1168 bb_unsetenv(cur->varstr);
1172 return EXIT_SUCCESS;
1177 return EXIT_SUCCESS;
1180 #if ENABLE_SH_MATH_SUPPORT
1181 #define is_name(c) ((c) == '_' || isalpha((unsigned char)(c)))
1182 #define is_in_name(c) ((c) == '_' || isalnum((unsigned char)(c)))
1183 static char *endofname(const char *name)
1191 if (!is_in_name(*p))
1197 static void arith_set_local_var(const char *name, const char *val, int flags)
1199 /* arith code doesnt malloc space, so do it for it */
1200 char *var = xasprintf("%s=%s", name, val);
1201 set_local_var(var, flags);
1209 static int static_get(struct in_str *i)
1218 static int static_peek(struct in_str *i)
1223 #if ENABLE_HUSH_INTERACTIVE
1225 static void cmdedit_set_initial_prompt(void)
1227 if (ENABLE_FEATURE_EDITING_FANCY_PROMPT) {
1228 G.PS1 = getenv("PS1");
1235 static const char* setup_prompt_string(int promptmode)
1237 const char *prompt_str;
1238 debug_printf("setup_prompt_string %d ", promptmode);
1239 if (!ENABLE_FEATURE_EDITING_FANCY_PROMPT) {
1240 /* Set up the prompt */
1241 if (promptmode == 0) { /* PS1 */
1243 G.PS1 = xasprintf("%s %c ", G.cwd, (geteuid() != 0) ? '$' : '#');
1248 prompt_str = (promptmode == 0) ? G.PS1 : G.PS2;
1249 debug_printf("result '%s'\n", prompt_str);
1253 static void get_user_input(struct in_str *i)
1256 const char *prompt_str;
1258 prompt_str = setup_prompt_string(i->promptmode);
1259 #if ENABLE_FEATURE_EDITING
1260 /* Enable command line editing only while a command line
1261 * is actually being read */
1264 /* buglet: SIGINT will not make new prompt to appear _at once_,
1265 * only after <Enter>. (^C will work) */
1266 r = read_line_input(prompt_str, G.user_input_buf, BUFSIZ-1, G.line_input_state);
1267 /* catch *SIGINT* etc (^C is handled by read_line_input) */
1268 check_and_run_traps(0);
1269 } while (r == 0 || G.flag_SIGINT); /* repeat if ^C or SIGINT */
1270 i->eof_flag = (r < 0);
1271 if (i->eof_flag) { /* EOF/error detected */
1272 G.user_input_buf[0] = EOF; /* yes, it will be truncated, it's ok */
1273 G.user_input_buf[1] = '\0';
1278 fputs(prompt_str, stdout);
1280 G.user_input_buf[0] = r = fgetc(i->file);
1281 /*G.user_input_buf[1] = '\0'; - already is and never changed */
1282 //do we need check_and_run_traps(0)? (maybe only if stdin)
1283 } while (G.flag_SIGINT);
1284 i->eof_flag = (r == EOF);
1286 i->p = G.user_input_buf;
1289 #endif /* INTERACTIVE */
1291 /* This is the magic location that prints prompts
1292 * and gets data back from the user */
1293 static int file_get(struct in_str *i)
1297 /* If there is data waiting, eat it up */
1298 if (i->p && *i->p) {
1299 #if ENABLE_HUSH_INTERACTIVE
1303 if (i->eof_flag && !*i->p)
1306 /* need to double check i->file because we might be doing something
1307 * more complicated by now, like sourcing or substituting. */
1308 #if ENABLE_HUSH_INTERACTIVE
1309 if (G_interactive_fd && i->promptme && i->file == stdin) {
1312 } while (!*i->p); /* need non-empty line */
1313 i->promptmode = 1; /* PS2 */
1318 ch = fgetc(i->file);
1320 debug_printf("file_get: got a '%c' %d\n", ch, ch);
1321 #if ENABLE_HUSH_INTERACTIVE
1328 /* All the callers guarantee this routine will never be
1329 * used right after a newline, so prompting is not needed.
1331 static int file_peek(struct in_str *i)
1334 if (i->p && *i->p) {
1335 if (i->eof_flag && !i->p[1])
1339 ch = fgetc(i->file);
1340 i->eof_flag = (ch == EOF);
1341 i->peek_buf[0] = ch;
1342 i->peek_buf[1] = '\0';
1344 debug_printf("file_peek: got a '%c' %d\n", *i->p, *i->p);
1348 static void setup_file_in_str(struct in_str *i, FILE *f)
1350 i->peek = file_peek;
1352 #if ENABLE_HUSH_INTERACTIVE
1354 i->promptmode = 0; /* PS1 */
1360 static void setup_string_in_str(struct in_str *i, const char *s)
1362 i->peek = static_peek;
1363 i->get = static_get;
1364 #if ENABLE_HUSH_INTERACTIVE
1366 i->promptmode = 0; /* PS1 */
1376 #define B_CHUNK (32 * sizeof(char*))
1378 static void o_reset(o_string *o)
1386 static void o_free(o_string *o)
1389 memset(o, 0, sizeof(*o));
1392 static void o_grow_by(o_string *o, int len)
1394 if (o->length + len > o->maxlen) {
1395 o->maxlen += (2*len > B_CHUNK ? 2*len : B_CHUNK);
1396 o->data = xrealloc(o->data, 1 + o->maxlen);
1400 static void o_addchr(o_string *o, int ch)
1402 debug_printf("o_addchr: '%c' o->length=%d o=%p\n", ch, o->length, o);
1404 o->data[o->length] = ch;
1406 o->data[o->length] = '\0';
1409 static void o_addstr(o_string *o, const char *str, int len)
1412 memcpy(&o->data[o->length], str, len);
1414 o->data[o->length] = '\0';
1417 static void o_addstrauto(o_string *o, const char *str)
1419 o_addstr(o, str, strlen(str) + 1);
1422 static void o_addstr_duplicate_backslash(o_string *o, const char *str, int len)
1427 && (*str != '*' && *str != '?' && *str != '[')
1435 /* My analysis of quoting semantics tells me that state information
1436 * is associated with a destination, not a source.
1438 static void o_addqchr(o_string *o, int ch)
1441 char *found = strchr("*?[\\", ch);
1446 o->data[o->length] = '\\';
1449 o->data[o->length] = ch;
1451 o->data[o->length] = '\0';
1454 static void o_addQchr(o_string *o, int ch)
1457 if (o->o_escape && strchr("*?[\\", ch)) {
1459 o->data[o->length] = '\\';
1463 o->data[o->length] = ch;
1465 o->data[o->length] = '\0';
1468 static void o_addQstr(o_string *o, const char *str, int len)
1471 o_addstr(o, str, len);
1477 int ordinary_cnt = strcspn(str, "*?[\\");
1478 if (ordinary_cnt > len) /* paranoia */
1480 o_addstr(o, str, ordinary_cnt);
1481 if (ordinary_cnt == len)
1483 str += ordinary_cnt;
1484 len -= ordinary_cnt + 1; /* we are processing + 1 char below */
1488 if (ch) { /* it is necessarily one of "*?[\\" */
1490 o->data[o->length] = '\\';
1494 o->data[o->length] = ch;
1496 o->data[o->length] = '\0';
1500 /* A special kind of o_string for $VAR and `cmd` expansion.
1501 * It contains char* list[] at the beginning, which is grown in 16 element
1502 * increments. Actual string data starts at the next multiple of 16 * (char*).
1503 * list[i] contains an INDEX (int!) into this string data.
1504 * It means that if list[] needs to grow, data needs to be moved higher up
1505 * but list[i]'s need not be modified.
1506 * NB: remembering how many list[i]'s you have there is crucial.
1507 * o_finalize_list() operation post-processes this structure - calculates
1508 * and stores actual char* ptrs in list[]. Oh, it NULL terminates it as well.
1510 #if DEBUG_EXPAND || DEBUG_GLOB
1511 static void debug_print_list(const char *prefix, o_string *o, int n)
1513 char **list = (char**)o->data;
1514 int string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
1516 fprintf(stderr, "%s: list:%p n:%d string_start:%d length:%d maxlen:%d\n",
1517 prefix, list, n, string_start, o->length, o->maxlen);
1519 fprintf(stderr, " list[%d]=%d '%s' %p\n", i, (int)list[i],
1520 o->data + (int)list[i] + string_start,
1521 o->data + (int)list[i] + string_start);
1525 const char *p = o->data + (int)list[n - 1] + string_start;
1526 fprintf(stderr, " total_sz:%ld\n", (long)((p + strlen(p) + 1) - o->data));
1530 #define debug_print_list(prefix, o, n) ((void)0)
1533 /* n = o_save_ptr_helper(str, n) "starts new string" by storing an index value
1534 * in list[n] so that it points past last stored byte so far.
1535 * It returns n+1. */
1536 static int o_save_ptr_helper(o_string *o, int n)
1538 char **list = (char**)o->data;
1542 if (!o->has_empty_slot) {
1543 string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
1544 string_len = o->length - string_start;
1545 if (!(n & 0xf)) { /* 0, 0x10, 0x20...? */
1546 debug_printf_list("list[%d]=%d string_start=%d (growing)\n", n, string_len, string_start);
1547 /* list[n] points to string_start, make space for 16 more pointers */
1548 o->maxlen += 0x10 * sizeof(list[0]);
1549 o->data = xrealloc(o->data, o->maxlen + 1);
1550 list = (char**)o->data;
1551 memmove(list + n + 0x10, list + n, string_len);
1552 o->length += 0x10 * sizeof(list[0]);
1554 debug_printf_list("list[%d]=%d string_start=%d\n", n, string_len, string_start);
1556 /* We have empty slot at list[n], reuse without growth */
1557 string_start = ((n+1 + 0xf) & ~0xf) * sizeof(list[0]); /* NB: n+1! */
1558 string_len = o->length - string_start;
1559 debug_printf_list("list[%d]=%d string_start=%d (empty slot)\n", n, string_len, string_start);
1560 o->has_empty_slot = 0;
1562 list[n] = (char*)(ptrdiff_t)string_len;
1566 /* "What was our last o_save_ptr'ed position (byte offset relative o->data)?" */
1567 static int o_get_last_ptr(o_string *o, int n)
1569 char **list = (char**)o->data;
1570 int string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
1572 return ((int)(ptrdiff_t)list[n-1]) + string_start;
1575 /* o_glob performs globbing on last list[], saving each result
1576 * as a new list[]. */
1577 static int o_glob(o_string *o, int n)
1583 debug_printf_glob("start o_glob: n:%d o->data:%p\n", n, o->data);
1585 return o_save_ptr_helper(o, n);
1586 pattern = o->data + o_get_last_ptr(o, n);
1587 debug_printf_glob("glob pattern '%s'\n", pattern);
1588 if (!glob_needed(pattern)) {
1590 o->length = unbackslash(pattern) - o->data;
1591 debug_printf_glob("glob pattern '%s' is literal\n", pattern);
1592 return o_save_ptr_helper(o, n);
1595 memset(&globdata, 0, sizeof(globdata));
1596 gr = glob(pattern, 0, NULL, &globdata);
1597 debug_printf_glob("glob('%s'):%d\n", pattern, gr);
1598 if (gr == GLOB_NOSPACE)
1599 bb_error_msg_and_die("out of memory during glob");
1600 if (gr == GLOB_NOMATCH) {
1601 globfree(&globdata);
1604 if (gr != 0) { /* GLOB_ABORTED ? */
1605 //TODO: testcase for bad glob pattern behavior
1606 bb_error_msg("glob(3) error %d on '%s'", gr, pattern);
1608 if (globdata.gl_pathv && globdata.gl_pathv[0]) {
1609 char **argv = globdata.gl_pathv;
1610 o->length = pattern - o->data; /* "forget" pattern */
1612 o_addstrauto(o, *argv);
1613 n = o_save_ptr_helper(o, n);
1619 globfree(&globdata);
1621 debug_print_list("o_glob returning", o, n);
1625 /* If o->o_glob == 1, glob the string so far remembered.
1626 * Otherwise, just finish current list[] and start new */
1627 static int o_save_ptr(o_string *o, int n)
1629 if (o->o_glob) { /* if globbing is requested */
1630 /* If o->has_empty_slot, list[n] was already globbed
1631 * (if it was requested back then when it was filled)
1632 * so don't do that again! */
1633 if (!o->has_empty_slot)
1634 return o_glob(o, n); /* o_save_ptr_helper is inside */
1636 return o_save_ptr_helper(o, n);
1639 /* "Please convert list[n] to real char* ptrs, and NULL terminate it." */
1640 static char **o_finalize_list(o_string *o, int n)
1645 n = o_save_ptr(o, n); /* force growth for list[n] if necessary */
1647 debug_print_list("finalized", o, n);
1648 debug_printf_expand("finalized n:%d\n", n);
1649 list = (char**)o->data;
1650 string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
1654 list[n] = o->data + (int)(ptrdiff_t)list[n] + string_start;
1660 /* Expansion can recurse */
1661 #if ENABLE_HUSH_TICK
1662 static int process_command_subs(o_string *dest, struct in_str *input);
1664 static char *expand_string_to_string(const char *str);
1665 static int parse_stream_dquoted(o_string *dest, struct in_str *input, int dquote_end);
1667 /* expand_strvec_to_strvec() takes a list of strings, expands
1668 * all variable references within and returns a pointer to
1669 * a list of expanded strings, possibly with larger number
1670 * of strings. (Think VAR="a b"; echo $VAR).
1671 * This new list is allocated as a single malloc block.
1672 * NULL-terminated list of char* pointers is at the beginning of it,
1673 * followed by strings themself.
1674 * Caller can deallocate entire list by single free(list). */
1676 /* Store given string, finalizing the word and starting new one whenever
1677 * we encounter IFS char(s). This is used for expanding variable values.
1678 * End-of-string does NOT finalize word: think about 'echo -$VAR-' */
1679 static int expand_on_ifs(o_string *output, int n, const char *str)
1682 int word_len = strcspn(str, G.ifs);
1684 if (output->o_escape || !output->o_glob)
1685 o_addQstr(output, str, word_len);
1686 else /* protect backslashes against globbing up :) */
1687 o_addstr_duplicate_backslash(output, str, word_len);
1690 if (!*str) /* EOL - do not finalize word */
1692 o_addchr(output, '\0');
1693 debug_print_list("expand_on_ifs", output, n);
1694 n = o_save_ptr(output, n);
1695 str += strspn(str, G.ifs); /* skip ifs chars */
1697 debug_print_list("expand_on_ifs[1]", output, n);
1701 /* Expand all variable references in given string, adding words to list[]
1702 * at n, n+1,... positions. Return updated n (so that list[n] is next one
1703 * to be filled). This routine is extremely tricky: has to deal with
1704 * variables/parameters with whitespace, $* and $@, and constructs like
1705 * 'echo -$*-'. If you play here, you must run testsuite afterwards! */
1706 static int expand_vars_to_list(o_string *output, int n, char *arg, char or_mask)
1708 /* or_mask is either 0 (normal case) or 0x80
1709 * (expansion of right-hand side of assignment == 1-element expand.
1710 * It will also do no globbing, and thus we must not backslash-quote!) */
1712 char first_ch, ored_ch;
1719 debug_printf_expand("expand_vars_to_list: arg '%s'\n", arg);
1720 debug_print_list("expand_vars_to_list", output, n);
1721 n = o_save_ptr(output, n);
1722 debug_print_list("expand_vars_to_list[0]", output, n);
1724 while ((p = strchr(arg, SPECIAL_VAR_SYMBOL)) != NULL) {
1725 #if ENABLE_HUSH_TICK
1726 o_string subst_result = NULL_O_STRING;
1728 #if ENABLE_SH_MATH_SUPPORT
1729 char arith_buf[sizeof(arith_t)*3 + 2];
1731 o_addstr(output, arg, p - arg);
1732 debug_print_list("expand_vars_to_list[1]", output, n);
1734 p = strchr(p, SPECIAL_VAR_SYMBOL);
1736 first_ch = arg[0] | or_mask; /* forced to "quoted" if or_mask = 0x80 */
1737 /* "$@" is special. Even if quoted, it can still
1738 * expand to nothing (not even an empty string) */
1739 if ((first_ch & 0x7f) != '@')
1740 ored_ch |= first_ch;
1743 switch (first_ch & 0x7f) {
1744 /* Highest bit in first_ch indicates that var is double-quoted */
1746 val = utoa(G.root_pid);
1748 case '!': /* bg pid */
1749 val = G.last_bg_pid ? utoa(G.last_bg_pid) : (char*)"";
1751 case '?': /* exitcode */
1752 val = utoa(G.last_return_code);
1754 case '#': /* argc */
1755 if (arg[1] != SPECIAL_VAR_SYMBOL)
1756 /* actually, it's a ${#var} */
1758 val = utoa(G.global_argc ? G.global_argc-1 : 0);
1763 if (!G.global_argv[i])
1765 ored_ch |= first_ch; /* do it for "$@" _now_, when we know it's not empty */
1766 if (!(first_ch & 0x80)) { /* unquoted $* or $@ */
1767 smallint sv = output->o_escape;
1768 /* unquoted var's contents should be globbed, so don't escape */
1769 output->o_escape = 0;
1770 while (G.global_argv[i]) {
1771 n = expand_on_ifs(output, n, G.global_argv[i]);
1772 debug_printf_expand("expand_vars_to_list: argv %d (last %d)\n", i, G.global_argc - 1);
1773 if (G.global_argv[i++][0] && G.global_argv[i]) {
1774 /* this argv[] is not empty and not last:
1775 * put terminating NUL, start new word */
1776 o_addchr(output, '\0');
1777 debug_print_list("expand_vars_to_list[2]", output, n);
1778 n = o_save_ptr(output, n);
1779 debug_print_list("expand_vars_to_list[3]", output, n);
1782 output->o_escape = sv;
1784 /* If or_mask is nonzero, we handle assignment 'a=....$@.....'
1785 * and in this case should treat it like '$*' - see 'else...' below */
1786 if (first_ch == ('@'|0x80) && !or_mask) { /* quoted $@ */
1788 o_addQstr(output, G.global_argv[i], strlen(G.global_argv[i]));
1789 if (++i >= G.global_argc)
1791 o_addchr(output, '\0');
1792 debug_print_list("expand_vars_to_list[4]", output, n);
1793 n = o_save_ptr(output, n);
1795 } else { /* quoted $*: add as one word */
1797 o_addQstr(output, G.global_argv[i], strlen(G.global_argv[i]));
1798 if (!G.global_argv[++i])
1801 o_addchr(output, G.ifs[0]);
1805 case SPECIAL_VAR_SYMBOL: /* <SPECIAL_VAR_SYMBOL><SPECIAL_VAR_SYMBOL> */
1806 /* "Empty variable", used to make "" etc to not disappear */
1810 #if ENABLE_HUSH_TICK
1811 case '`': { /* <SPECIAL_VAR_SYMBOL>`cmd<SPECIAL_VAR_SYMBOL> */
1812 struct in_str input;
1815 //TODO: can we just stuff it into "output" directly?
1816 debug_printf_subst("SUBST '%s' first_ch %x\n", arg, first_ch);
1817 setup_string_in_str(&input, arg);
1818 process_command_subs(&subst_result, &input);
1819 debug_printf_subst("SUBST RES '%s'\n", subst_result.data);
1820 val = subst_result.data;
1824 #if ENABLE_SH_MATH_SUPPORT
1825 case '+': { /* <SPECIAL_VAR_SYMBOL>+cmd<SPECIAL_VAR_SYMBOL> */
1826 arith_eval_hooks_t hooks;
1831 arg++; /* skip '+' */
1832 *p = '\0'; /* replace trailing <SPECIAL_VAR_SYMBOL> */
1833 debug_printf_subst("ARITH '%s' first_ch %x\n", arg, first_ch);
1835 /* Optional: skip expansion if expr is simple ("a + 3", "i++" etc) */
1838 unsigned char c = *exp_str++;
1845 if (strchr(" \t+-*/%_", c) != NULL)
1847 c |= 0x20; /* tolower */
1848 if (c >= 'a' && c <= 'z')
1852 /* We need to expand. Example: "echo $(($a + 1)) $((1 + $((2)) ))" */
1854 struct in_str input;
1855 o_string dest = NULL_O_STRING;
1857 setup_string_in_str(&input, arg);
1858 parse_stream_dquoted(&dest, &input, EOF);
1859 //bb_error_msg("'%s' -> '%s'", arg, dest.data);
1860 exp_str = expand_string_to_string(dest.data);
1861 //bb_error_msg("'%s' -> '%s'", dest.data, exp_str);
1865 hooks.lookupvar = lookup_param;
1866 hooks.setvar = arith_set_local_var;
1867 hooks.endofname = endofname;
1868 res = arith(exp_str ? exp_str : arg, &errcode, &hooks);
1873 case -3: maybe_die("arith", "exponent less than 0"); break;
1874 case -2: maybe_die("arith", "divide by zero"); break;
1875 case -5: maybe_die("arith", "expression recursion loop detected"); break;
1876 default: maybe_die("arith", "syntax error"); break;
1879 debug_printf_subst("ARITH RES '"arith_t_fmt"'\n", res);
1880 sprintf(arith_buf, arith_t_fmt, res);
1885 default: /* <SPECIAL_VAR_SYMBOL>varname<SPECIAL_VAR_SYMBOL> */
1887 bool exp_len = false, exp_null = false;
1888 char *var = arg, exp_save, exp_op, *exp_word;
1891 arg[0] = first_ch & 0x7f;
1893 /* prepare for expansions */
1894 if (var[0] == '#') {
1895 /* handle length expansion ${#var} */
1899 /* maybe handle parameter expansion */
1900 exp_off = strcspn(var, ":-=+?");
1904 exp_save = var[exp_off];
1905 exp_null = exp_save == ':';
1906 exp_word = var + exp_off;
1907 if (exp_null) ++exp_word;
1908 exp_op = *exp_word++;
1909 var[exp_off] = '\0';
1913 /* lookup the variable in question */
1914 if (isdigit(var[0])) {
1915 /* handle_dollar() should have vetted var for us */
1917 if (i < G.global_argc)
1918 val = G.global_argv[i];
1919 /* else val remains NULL: $N with too big N */
1921 val = lookup_param(var);
1923 /* handle any expansions */
1925 debug_printf_expand("expand: length of '%s' = ", val);
1926 val = utoa(val ? strlen(val) : 0);
1927 debug_printf_expand("%s\n", val);
1928 } else if (exp_off) {
1929 /* we need to do an expansion */
1930 int exp_test = (!val || (exp_null && !val[0]));
1932 exp_test = !exp_test;
1933 debug_printf_expand("expand: op:%c (null:%s) test:%i\n", exp_op,
1934 exp_null ? "true" : "false", exp_test);
1937 maybe_die(var, *exp_word ? exp_word : "parameter null or not set");
1941 if (exp_op == '=') {
1942 if (isdigit(var[0]) || var[0] == '#') {
1943 maybe_die(var, "special vars cannot assign in this way");
1946 char *new_var = xmalloc(strlen(var) + strlen(val) + 2);
1947 sprintf(new_var, "%s=%s", var, val);
1948 set_local_var(new_var, -1);
1952 var[exp_off] = exp_save;
1957 #if ENABLE_HUSH_TICK
1960 if (!(first_ch & 0x80)) { /* unquoted $VAR */
1961 debug_printf_expand("unquoted '%s', output->o_escape:%d\n", val, output->o_escape);
1963 /* unquoted var's contents should be globbed, so don't escape */
1964 smallint sv = output->o_escape;
1965 output->o_escape = 0;
1966 n = expand_on_ifs(output, n, val);
1968 output->o_escape = sv;
1970 } else { /* quoted $VAR, val will be appended below */
1971 debug_printf_expand("quoted '%s', output->o_escape:%d\n", val, output->o_escape);
1974 } /* switch (char after <SPECIAL_VAR_SYMBOL>) */
1976 o_addQstr(output, val, strlen(val));
1978 /* Do the check to avoid writing to a const string */
1979 if (*p != SPECIAL_VAR_SYMBOL)
1980 *p = SPECIAL_VAR_SYMBOL;
1982 #if ENABLE_HUSH_TICK
1983 o_free(&subst_result);
1986 } /* end of "while (SPECIAL_VAR_SYMBOL is found) ..." */
1989 debug_print_list("expand_vars_to_list[a]", output, n);
1990 /* this part is literal, and it was already pre-quoted
1991 * if needed (much earlier), do not use o_addQstr here! */
1992 o_addstrauto(output, arg);
1993 debug_print_list("expand_vars_to_list[b]", output, n);
1994 } else if (output->length == o_get_last_ptr(output, n) /* expansion is empty */
1995 && !(ored_ch & 0x80) /* and all vars were not quoted. */
1998 /* allow to reuse list[n] later without re-growth */
1999 output->has_empty_slot = 1;
2001 o_addchr(output, '\0');
2006 static char **expand_variables(char **argv, int or_mask)
2011 o_string output = NULL_O_STRING;
2013 if (or_mask & 0x100) {
2014 output.o_escape = 1; /* protect against globbing for "$var" */
2015 /* (unquoted $var will temporarily switch it off) */
2022 n = expand_vars_to_list(&output, n, *v, (char)or_mask);
2025 debug_print_list("expand_variables", &output, n);
2027 /* output.data (malloced in one block) gets returned in "list" */
2028 list = o_finalize_list(&output, n);
2029 debug_print_strings("expand_variables[1]", list);
2033 static char **expand_strvec_to_strvec(char **argv)
2035 return expand_variables(argv, 0x100);
2038 /* Used for expansion of right hand of assignments */
2039 /* NB: should NOT do globbing! "export v=/bin/c*; env | grep ^v=" outputs
2041 static char *expand_string_to_string(const char *str)
2043 char *argv[2], **list;
2045 argv[0] = (char*)str;
2047 list = expand_variables(argv, 0x80); /* 0x80: make one-element expansion */
2049 if (!list[0] || list[1])
2050 bb_error_msg_and_die("BUG in varexp2");
2051 /* actually, just move string 2*sizeof(char*) bytes back */
2052 overlapping_strcpy((char*)list, list[0]);
2053 debug_printf_expand("string_to_string='%s'\n", (char*)list);
2057 /* Used for "eval" builtin */
2058 static char* expand_strvec_to_string(char **argv)
2062 list = expand_variables(argv, 0x80);
2063 /* Convert all NULs to spaces */
2068 if (list[n-1] + strlen(list[n-1]) + 1 != list[n])
2069 bb_error_msg_and_die("BUG in varexp3");
2070 list[n][-1] = ' '; /* TODO: or to G.ifs[0]? */
2074 overlapping_strcpy((char*)list, list[0]);
2075 debug_printf_expand("strvec_to_string='%s'\n", (char*)list);
2079 static char **expand_assignments(char **argv, int count)
2083 /* Expand assignments into one string each */
2084 for (i = 0; i < count; i++) {
2085 p = add_string_to_strings(p, expand_string_to_string(argv[i]));
2091 /* squirrel != NULL means we squirrel away copies of stdin, stdout,
2092 * and stderr if they are redirected. */
2093 static int setup_redirects(struct command *prog, int squirrel[])
2096 struct redir_struct *redir;
2098 for (redir = prog->redirects; redir; redir = redir->next) {
2099 if (redir->dup == -1 && redir->rd_filename == NULL) {
2100 /* something went wrong in the parse. Pretend it didn't happen */
2103 if (redir->dup == -1) {
2105 mode = redir_table[redir->rd_type].mode;
2106 //TODO: check redir for names like '\\'
2107 p = expand_string_to_string(redir->rd_filename);
2108 openfd = open_or_warn(p, mode);
2111 /* this could get lost if stderr has been redirected, but
2112 bash and ash both lose it as well (though zsh doesn't!) */
2116 openfd = redir->dup;
2119 if (openfd != redir->fd) {
2120 if (squirrel && redir->fd < 3) {
2121 squirrel[redir->fd] = dup(redir->fd);
2124 //close(openfd); // close(-3) ??!
2126 dup2(openfd, redir->fd);
2127 if (redir->dup == -1)
2135 static void restore_redirects(int squirrel[])
2138 for (i = 0; i < 3; i++) {
2141 /* We simply die on error */
2148 #if !defined(DEBUG_CLEAN)
2149 #define free_pipe_list(head, indent) free_pipe_list(head)
2150 #define free_pipe(pi, indent) free_pipe(pi)
2152 static void free_pipe_list(struct pipe *head, int indent);
2154 /* return code is the exit status of the pipe */
2155 static void free_pipe(struct pipe *pi, int indent)
2158 struct command *command;
2159 struct redir_struct *r, *rnext;
2162 if (pi->stopped_cmds > 0)
2164 debug_printf_clean("%s run pipe: (pid %d)\n", indenter(indent), getpid());
2165 for (i = 0; i < pi->num_cmds; i++) {
2166 command = &pi->cmds[i];
2167 debug_printf_clean("%s command %d:\n", indenter(indent), i);
2168 if (command->argv) {
2169 for (a = 0, p = command->argv; *p; a++, p++) {
2170 debug_printf_clean("%s argv[%d] = %s\n", indenter(indent), a, *p);
2172 free_strings(command->argv);
2173 command->argv = NULL;
2175 /* not "else if": on syntax error, we may have both! */
2176 if (command->group) {
2177 debug_printf_clean("%s begin group (grp_type:%d)\n", indenter(indent), command->grp_type);
2178 free_pipe_list(command->group, indent+3);
2179 debug_printf_clean("%s end group\n", indenter(indent));
2180 command->group = NULL;
2182 for (r = command->redirects; r; r = rnext) {
2183 debug_printf_clean("%s redirect %d%s", indenter(indent), r->fd, redir_table[r->rd_type].descrip);
2185 /* guard against the case >$FOO, where foo is unset or blank */
2186 if (r->rd_filename) {
2187 debug_printf_clean(" %s\n", r->rd_filename);
2188 free(r->rd_filename);
2189 r->rd_filename = NULL;
2192 debug_printf_clean("&%d\n", r->dup);
2197 command->redirects = NULL;
2199 free(pi->cmds); /* children are an array, they get freed all at once */
2207 static void free_pipe_list(struct pipe *head, int indent)
2209 struct pipe *pi, *next;
2211 for (pi = head; pi; pi = next) {
2213 debug_printf_clean("%s pipe reserved mode %d\n", indenter(indent), pi->res_word);
2215 free_pipe(pi, indent);
2216 debug_printf_clean("%s pipe followup code %d\n", indenter(indent), pi->followup);
2218 /*pi->next = NULL;*/
2225 typedef struct nommu_save_t {
2231 #define pseudo_exec_argv(nommu_save, argv, assignment_cnt, argv_expanded) \
2232 pseudo_exec_argv(argv, assignment_cnt, argv_expanded)
2233 #define pseudo_exec(nommu_save, command, argv_expanded) \
2234 pseudo_exec(command, argv_expanded)
2237 /* Called after [v]fork() in run_pipe(), or from builtin_exec().
2239 * XXX no exit() here. If you don't exec, use _exit instead.
2240 * The at_exit handlers apparently confuse the calling process,
2241 * in particular stdin handling. Not sure why? -- because of vfork! (vda) */
2242 static void pseudo_exec_argv(nommu_save_t *nommu_save, char **argv, int assignment_cnt, char **argv_expanded) NORETURN;
2243 static void pseudo_exec_argv(nommu_save_t *nommu_save, char **argv, int assignment_cnt, char **argv_expanded)
2247 const struct built_in_command *x;
2249 /* If a variable is assigned in a forest, and nobody listens,
2250 * was it ever really set?
2252 if (!argv[assignment_cnt])
2253 _exit(EXIT_SUCCESS);
2255 new_env = expand_assignments(argv, assignment_cnt);
2257 putenv_all(new_env);
2258 free(new_env); /* optional */
2260 nommu_save->new_env = new_env;
2261 nommu_save->old_env = putenv_all_and_save_old(new_env);
2263 if (argv_expanded) {
2264 argv = argv_expanded;
2266 argv = expand_strvec_to_strvec(argv + assignment_cnt);
2268 nommu_save->argv = argv;
2273 * Check if the command matches any of the builtins.
2274 * Depending on context, this might be redundant. But it's
2275 * easier to waste a few CPU cycles than it is to figure out
2276 * if this is one of those cases.
2278 for (x = bltins; x != &bltins[ARRAY_SIZE(bltins)]; x++) {
2279 if (strcmp(argv[0], x->cmd) == 0) {
2280 debug_printf_exec("running builtin '%s'\n", argv[0]);
2281 rcode = x->function(argv);
2287 /* Check if the command matches any busybox applets */
2288 #if ENABLE_FEATURE_SH_STANDALONE
2289 if (strchr(argv[0], '/') == NULL) {
2290 int a = find_applet_by_name(argv[0]);
2292 if (APPLET_IS_NOEXEC(a)) {
2293 debug_printf_exec("running applet '%s'\n", argv[0]);
2294 // is it ok that run_applet_no_and_exit() does exit(), not _exit()?
2295 run_applet_no_and_exit(a, argv);
2297 /* re-exec ourselves with the new arguments */
2298 debug_printf_exec("re-execing applet '%s'\n", argv[0]);
2299 execvp(bb_busybox_exec_path, argv);
2300 /* If they called chroot or otherwise made the binary no longer
2301 * executable, fall through */
2306 sigprocmask(SIG_SETMASK, &G.inherited_set, NULL);
2308 debug_printf_exec("execing '%s'\n", argv[0]);
2309 execvp(argv[0], argv);
2310 bb_perror_msg("can't exec '%s'", argv[0]);
2311 _exit(EXIT_FAILURE);
2314 static int run_list(struct pipe *pi);
2316 /* Called after [v]fork() in run_pipe()
2318 static void pseudo_exec(nommu_save_t *nommu_save, struct command *command, char **argv_expanded) NORETURN;
2319 static void pseudo_exec(nommu_save_t *nommu_save, struct command *command, char **argv_expanded)
2322 pseudo_exec_argv(nommu_save, command->argv, command->assignment_cnt, argv_expanded);
2324 if (command->group) {
2326 bb_error_msg_and_die("nested lists are not supported on NOMMU");
2329 debug_printf_exec("pseudo_exec: run_list\n");
2330 rcode = run_list(command->group);
2331 /* OK to leak memory by not calling free_pipe_list,
2332 * since this process is about to exit */
2337 /* Can happen. See what bash does with ">foo" by itself. */
2338 debug_printf("trying to pseudo_exec null command\n");
2339 _exit(EXIT_SUCCESS);
2343 static const char *get_cmdtext(struct pipe *pi)
2349 /* This is subtle. ->cmdtext is created only on first backgrounding.
2350 * (Think "cat, <ctrl-z>, fg, <ctrl-z>, fg, <ctrl-z>...." here...)
2351 * On subsequent bg argv is trashed, but we won't use it */
2354 argv = pi->cmds[0].argv;
2355 if (!argv || !argv[0]) {
2356 pi->cmdtext = xzalloc(1);
2361 do len += strlen(*argv) + 1; while (*++argv);
2362 pi->cmdtext = p = xmalloc(len);
2363 argv = pi->cmds[0].argv;
2365 len = strlen(*argv);
2366 memcpy(p, *argv, len);
2374 static void insert_bg_job(struct pipe *pi)
2376 struct pipe *thejob;
2379 /* Linear search for the ID of the job to use */
2381 for (thejob = G.job_list; thejob; thejob = thejob->next)
2382 if (thejob->jobid >= pi->jobid)
2383 pi->jobid = thejob->jobid + 1;
2385 /* Add thejob to the list of running jobs */
2387 thejob = G.job_list = xmalloc(sizeof(*thejob));
2389 for (thejob = G.job_list; thejob->next; thejob = thejob->next)
2391 thejob->next = xmalloc(sizeof(*thejob));
2392 thejob = thejob->next;
2395 /* Physically copy the struct job */
2396 memcpy(thejob, pi, sizeof(struct pipe));
2397 thejob->cmds = xzalloc(sizeof(pi->cmds[0]) * pi->num_cmds);
2398 /* We cannot copy entire pi->cmds[] vector! Double free()s will happen */
2399 for (i = 0; i < pi->num_cmds; i++) {
2400 // TODO: do we really need to have so many fields which are just dead weight
2401 // at execution stage?
2402 thejob->cmds[i].pid = pi->cmds[i].pid;
2403 /* all other fields are not used and stay zero */
2405 thejob->next = NULL;
2406 thejob->cmdtext = xstrdup(get_cmdtext(pi));
2408 /* We don't wait for background thejobs to return -- append it
2409 to the list of backgrounded thejobs and leave it alone */
2410 if (G_interactive_fd)
2411 printf("[%d] %d %s\n", thejob->jobid, thejob->cmds[0].pid, thejob->cmdtext);
2412 G.last_bg_pid = thejob->cmds[0].pid;
2413 G.last_jobid = thejob->jobid;
2416 static void remove_bg_job(struct pipe *pi)
2418 struct pipe *prev_pipe;
2420 if (pi == G.job_list) {
2421 G.job_list = pi->next;
2423 prev_pipe = G.job_list;
2424 while (prev_pipe->next != pi)
2425 prev_pipe = prev_pipe->next;
2426 prev_pipe->next = pi->next;
2429 G.last_jobid = G.job_list->jobid;
2434 /* Remove a backgrounded job */
2435 static void delete_finished_bg_job(struct pipe *pi)
2438 pi->stopped_cmds = 0;
2444 /* Check to see if any processes have exited -- if they
2445 * have, figure out why and see if a job has completed */
2446 static int checkjobs(struct pipe* fg_pipe)
2456 debug_printf_jobs("checkjobs %p\n", fg_pipe);
2459 // if (G.handled_SIGCHLD == G.count_SIGCHLD)
2460 // /* avoid doing syscall, nothing there anyway */
2463 attributes = WUNTRACED;
2464 if (fg_pipe == NULL)
2465 attributes |= WNOHANG;
2467 /* Do we do this right?
2468 * bash-3.00# sleep 20 | false
2470 * [3]+ Stopped sleep 20 | false
2471 * bash-3.00# echo $?
2472 * 1 <========== bg pipe is not fully done, but exitcode is already known!
2475 //FIXME: non-interactive bash does not continue even if all processes in fg pipe
2476 //are stopped. Testcase: "cat | cat" in a script (not on command line)
2477 // + killall -STOP cat
2484 // i = G.count_SIGCHLD;
2485 childpid = waitpid(-1, &status, attributes);
2486 if (childpid <= 0) {
2487 if (childpid && errno != ECHILD)
2488 bb_perror_msg("waitpid");
2489 // else /* Until next SIGCHLD, waitpid's are useless */
2490 // G.handled_SIGCHLD = i;
2493 dead = WIFEXITED(status) || WIFSIGNALED(status);
2496 if (WIFSTOPPED(status))
2497 debug_printf_jobs("pid %d stopped by sig %d (exitcode %d)\n",
2498 childpid, WSTOPSIG(status), WEXITSTATUS(status));
2499 if (WIFSIGNALED(status))
2500 debug_printf_jobs("pid %d killed by sig %d (exitcode %d)\n",
2501 childpid, WTERMSIG(status), WEXITSTATUS(status));
2502 if (WIFEXITED(status))
2503 debug_printf_jobs("pid %d exited, exitcode %d\n",
2504 childpid, WEXITSTATUS(status));
2506 /* Were we asked to wait for fg pipe? */
2508 for (i = 0; i < fg_pipe->num_cmds; i++) {
2509 debug_printf_jobs("check pid %d\n", fg_pipe->cmds[i].pid);
2510 if (fg_pipe->cmds[i].pid != childpid)
2512 /* printf("process %d exit %d\n", i, WEXITSTATUS(status)); */
2514 fg_pipe->cmds[i].pid = 0;
2515 fg_pipe->alive_cmds--;
2516 if (i == fg_pipe->num_cmds - 1) {
2517 /* last process gives overall exitstatus */
2518 rcode = WEXITSTATUS(status);
2519 IF_HAS_KEYWORDS(if (fg_pipe->pi_inverted) rcode = !rcode;)
2522 fg_pipe->cmds[i].is_stopped = 1;
2523 fg_pipe->stopped_cmds++;
2525 debug_printf_jobs("fg_pipe: alive_cmds %d stopped_cmds %d\n",
2526 fg_pipe->alive_cmds, fg_pipe->stopped_cmds);
2527 if (fg_pipe->alive_cmds - fg_pipe->stopped_cmds <= 0) {
2528 /* All processes in fg pipe have exited/stopped */
2530 if (fg_pipe->alive_cmds)
2531 insert_bg_job(fg_pipe);
2535 /* There are still running processes in the fg pipe */
2536 goto wait_more; /* do waitpid again */
2538 /* it wasnt fg_pipe, look for process in bg pipes */
2542 /* We asked to wait for bg or orphaned children */
2543 /* No need to remember exitcode in this case */
2544 for (pi = G.job_list; pi; pi = pi->next) {
2545 for (i = 0; i < pi->num_cmds; i++) {
2546 if (pi->cmds[i].pid == childpid)
2547 goto found_pi_and_prognum;
2550 /* Happens when shell is used as init process (init=/bin/sh) */
2551 debug_printf("checkjobs: pid %d was not in our list!\n", childpid);
2552 continue; /* do waitpid again */
2554 found_pi_and_prognum:
2557 pi->cmds[i].pid = 0;
2559 if (!pi->alive_cmds) {
2560 if (G_interactive_fd)
2561 printf(JOB_STATUS_FORMAT, pi->jobid,
2562 "Done", pi->cmdtext);
2563 delete_finished_bg_job(pi);
2567 pi->cmds[i].is_stopped = 1;
2571 } /* while (waitpid succeeds)... */
2577 static int checkjobs_and_fg_shell(struct pipe* fg_pipe)
2580 int rcode = checkjobs(fg_pipe);
2581 /* Job finished, move the shell to the foreground */
2582 p = getpgid(0); /* pgid of our process */
2583 debug_printf_jobs("fg'ing ourself: getpgid(0)=%d\n", (int)p);
2584 tcsetpgrp(G_interactive_fd, p);
2589 /* run_pipe() starts all the jobs, but doesn't wait for anything
2590 * to finish. See checkjobs().
2592 * return code is normally -1, when the caller has to wait for children
2593 * to finish to determine the exit status of the pipe. If the pipe
2594 * is a simple builtin command, however, the action is done by the
2595 * time run_pipe returns, and the exit code is provided as the
2598 * The input of the pipe is always stdin, the output is always
2599 * stdout. The outpipe[] mechanism in BusyBox-0.48 lash is bogus,
2600 * because it tries to avoid running the command substitution in
2601 * subshell, when that is in fact necessary. The subshell process
2602 * now has its stdout directed to the input of the appropriate pipe,
2603 * so this routine is noticeably simpler.
2605 * Returns -1 only if started some children. IOW: we have to
2606 * mask out retvals of builtins etc with 0xff!
2608 static int run_pipe(struct pipe *pi)
2612 int pipefds[2]; /* pipefds[0] is for reading */
2613 struct command *command;
2614 char **argv_expanded;
2616 const struct built_in_command *x;
2618 /* it is not always needed, but we aim to smaller code */
2619 int squirrel[] = { -1, -1, -1 };
2621 const int single_and_fg = (pi->num_cmds == 1 && pi->followup != PIPE_BG);
2623 debug_printf_exec("run_pipe start: single_and_fg=%d\n", single_and_fg);
2629 pi->stopped_cmds = 0;
2631 /* Check if this is a simple builtin (not part of a pipe).
2632 * Builtins within pipes have to fork anyway, and are handled in
2633 * pseudo_exec. "echo foo | read bar" doesn't work on bash, either.
2635 command = &(pi->cmds[0]);
2637 #if ENABLE_HUSH_FUNCTIONS
2638 if (single_and_fg && command->group && command->grp_type == GRP_FUNCTION) {
2639 /* We "execute" function definition */
2640 bb_error_msg("here we ought to remember function definition, and go on");
2641 return EXIT_SUCCESS;
2645 if (single_and_fg && command->group && command->grp_type == GRP_NORMAL) {
2646 debug_printf("non-subshell grouping\n");
2647 setup_redirects(command, squirrel);
2648 debug_printf_exec(": run_list\n");
2649 rcode = run_list(command->group) & 0xff;
2650 restore_redirects(squirrel);
2651 debug_printf_exec("run_pipe return %d\n", rcode);
2652 IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
2656 argv = command->argv;
2657 argv_expanded = NULL;
2659 if (single_and_fg && argv != NULL) {
2660 char **new_env = NULL;
2661 char **old_env = NULL;
2663 i = command->assignment_cnt;
2664 if (i != 0 && argv[i] == NULL) {
2665 /* assignments, but no command: set local environment */
2666 for (i = 0; argv[i] != NULL; i++) {
2667 debug_printf("local environment set: %s\n", argv[i]);
2668 p = expand_string_to_string(argv[i]);
2669 set_local_var(p, 0);
2671 return EXIT_SUCCESS; /* don't worry about errors in set_local_var() yet */
2674 /* Expand the rest into (possibly) many strings each */
2675 argv_expanded = expand_strvec_to_strvec(argv + i);
2677 for (x = bltins; x != &bltins[ARRAY_SIZE(bltins)]; x++) {
2678 if (strcmp(argv_expanded[0], x->cmd) != 0)
2680 if (x->function == builtin_exec && argv_expanded[1] == NULL) {
2681 debug_printf("exec with redirects only\n");
2682 setup_redirects(command, NULL);
2683 rcode = EXIT_SUCCESS;
2684 goto clean_up_and_ret1;
2686 debug_printf("builtin inline %s\n", argv_expanded[0]);
2687 /* XXX setup_redirects acts on file descriptors, not FILEs.
2688 * This is perfect for work that comes after exec().
2689 * Is it really safe for inline use? Experimentally,
2690 * things seem to work with glibc. */
2691 setup_redirects(command, squirrel);
2692 new_env = expand_assignments(argv, command->assignment_cnt);
2693 old_env = putenv_all_and_save_old(new_env);
2694 debug_printf_exec(": builtin '%s' '%s'...\n", x->cmd, argv_expanded[1]);
2695 rcode = x->function(argv_expanded) & 0xff;
2696 #if ENABLE_FEATURE_SH_STANDALONE
2699 restore_redirects(squirrel);
2700 free_strings_and_unsetenv(new_env, 1);
2701 putenv_all(old_env);
2702 free(old_env); /* not free_strings()! */
2704 free(argv_expanded);
2705 IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
2706 debug_printf_exec("run_pipe return %d\n", rcode);
2709 #if ENABLE_FEATURE_SH_STANDALONE
2710 i = find_applet_by_name(argv_expanded[0]);
2711 if (i >= 0 && APPLET_IS_NOFORK(i)) {
2712 setup_redirects(command, squirrel);
2713 save_nofork_data(&G.nofork_save);
2714 new_env = expand_assignments(argv, command->assignment_cnt);
2715 old_env = putenv_all_and_save_old(new_env);
2716 debug_printf_exec(": run_nofork_applet '%s' '%s'...\n", argv_expanded[0], argv_expanded[1]);
2717 rcode = run_nofork_applet_prime(&G.nofork_save, i, argv_expanded);
2718 goto clean_up_and_ret;
2723 /* NB: argv_expanded may already be created, and that
2724 * might include `cmd` runs! Do not rerun it! We *must*
2725 * use argv_expanded if it's non-NULL */
2727 /* Going to fork a child per each pipe member */
2731 for (i = 0; i < pi->num_cmds; i++) {
2733 volatile nommu_save_t nommu_save;
2734 nommu_save.new_env = NULL;
2735 nommu_save.old_env = NULL;
2736 nommu_save.argv = NULL;
2738 command = &(pi->cmds[i]);
2739 if (command->argv) {
2740 debug_printf_exec(": pipe member '%s' '%s'...\n", command->argv[0], command->argv[1]);
2742 debug_printf_exec(": pipe member with no argv\n");
2744 /* pipes are inserted between pairs of commands */
2747 if ((i + 1) < pi->num_cmds)
2750 command->pid = BB_MMU ? fork() : vfork();
2751 if (!command->pid) { /* child */
2753 die_sleep = 0; /* let nofork's xfuncs die */
2755 /* Every child adds itself to new process group
2756 * with pgid == pid_of_first_child_in_pipe */
2757 if (G.run_list_level == 1 && G_interactive_fd) {
2760 if (pgrp < 0) /* true for 1st process only */
2762 if (setpgid(0, pgrp) == 0 && pi->followup != PIPE_BG) {
2763 /* We do it in *every* child, not just first,
2765 tcsetpgrp(G_interactive_fd, pgrp);
2769 xmove_fd(nextin, 0);
2770 xmove_fd(pipefds[1], 1); /* write end */
2772 close(pipefds[0]); /* read end */
2773 /* Like bash, explicit redirects override pipes,
2774 * and the pipe fd is available for dup'ing. */
2775 setup_redirects(command, NULL);
2777 /* Restore default handlers just prior to exec */
2778 /*signal(SIGCHLD, SIG_DFL); - so far we don't have any handlers */
2780 /* Stores to nommu_save list of env vars putenv'ed
2781 * (NOMMU, on MMU we don't need that) */
2782 /* cast away volatility... */
2783 pseudo_exec((nommu_save_t*) &nommu_save, command, argv_expanded);
2784 /* pseudo_exec() does not return */
2788 /* Clean up after vforked child */
2789 free(nommu_save.argv);
2790 free_strings_and_unsetenv(nommu_save.new_env, 1);
2791 putenv_all(nommu_save.old_env);
2793 free(argv_expanded);
2794 argv_expanded = NULL;
2795 if (command->pid < 0) { /* [v]fork failed */
2796 /* Clearly indicate, was it fork or vfork */
2797 bb_perror_msg(BB_MMU ? "fork" : "vfork");
2801 /* Second and next children need to know pid of first one */
2803 pi->pgrp = command->pid;
2809 if ((i + 1) < pi->num_cmds)
2810 close(pipefds[1]); /* write end */
2811 /* Pass read (output) pipe end to next iteration */
2812 nextin = pipefds[0];
2815 if (!pi->alive_cmds) {
2816 debug_printf_exec("run_pipe return 1 (all forks failed, no children)\n");
2820 debug_printf_exec("run_pipe return -1 (%u children started)\n", pi->alive_cmds);
2824 #ifndef debug_print_tree
2825 static void debug_print_tree(struct pipe *pi, int lvl)
2827 static const char *const PIPE[] = {
2833 static const char *RES[] = {
2834 [RES_NONE ] = "NONE" ,
2837 [RES_THEN ] = "THEN" ,
2838 [RES_ELIF ] = "ELIF" ,
2839 [RES_ELSE ] = "ELSE" ,
2842 #if ENABLE_HUSH_LOOPS
2843 [RES_FOR ] = "FOR" ,
2844 [RES_WHILE] = "WHILE",
2845 [RES_UNTIL] = "UNTIL",
2847 [RES_DONE ] = "DONE" ,
2849 #if ENABLE_HUSH_LOOPS || ENABLE_HUSH_CASE
2852 #if ENABLE_HUSH_CASE
2853 [RES_CASE ] = "CASE" ,
2854 [RES_MATCH] = "MATCH",
2855 [RES_CASEI] = "CASEI",
2856 [RES_ESAC ] = "ESAC" ,
2858 [RES_XXXX ] = "XXXX" ,
2859 [RES_SNTX ] = "SNTX" ,
2861 static const char *const GRPTYPE[] = {
2864 #if ENABLE_HUSH_FUNCTIONS
2873 fprintf(stderr, "%*spipe %d res_word=%s followup=%d %s\n", lvl*2, "",
2874 pin, RES[pi->res_word], pi->followup, PIPE[pi->followup]);
2876 while (prn < pi->num_cmds) {
2877 struct command *command = &pi->cmds[prn];
2878 char **argv = command->argv;
2880 fprintf(stderr, "%*s prog %d assignment_cnt:%d", lvl*2, "", prn, command->assignment_cnt);
2881 if (command->group) {
2882 fprintf(stderr, " group %s: (argv=%p)\n",
2883 GRPTYPE[command->grp_type],
2885 debug_print_tree(command->group, lvl+1);
2889 if (argv) while (*argv) {
2890 fprintf(stderr, " '%s'", *argv);
2893 fprintf(stderr, "\n");
2902 /* NB: called by pseudo_exec, and therefore must not modify any
2903 * global data until exec/_exit (we can be a child after vfork!) */
2904 static int run_list(struct pipe *pi)
2906 #if ENABLE_HUSH_CASE
2907 char *case_word = NULL;
2909 #if ENABLE_HUSH_LOOPS
2910 struct pipe *loop_top = NULL;
2911 char *for_varname = NULL;
2912 char **for_lcur = NULL;
2913 char **for_list = NULL;
2915 smallint flag_skip = 1;
2916 smalluint rcode = 0; /* probably just for compiler */
2917 #if ENABLE_HUSH_IF || ENABLE_HUSH_CASE
2918 smalluint cond_code = 0;
2920 enum { cond_code = 0, };
2922 /*enum reserved_style*/ smallint rword = RES_NONE;
2923 /*enum reserved_style*/ smallint skip_more_for_this_rword = RES_XXXX;
2925 debug_printf_exec("run_list start lvl %d\n", G.run_list_level + 1);
2927 #if ENABLE_HUSH_LOOPS
2928 /* Check syntax for "for" */
2929 for (struct pipe *cpipe = pi; cpipe; cpipe = cpipe->next) {
2930 if (cpipe->res_word != RES_FOR && cpipe->res_word != RES_IN)
2932 /* current word is FOR or IN (BOLD in comments below) */
2933 if (cpipe->next == NULL) {
2934 syntax("malformed for");
2935 debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
2938 /* "FOR v; do ..." and "for v IN a b; do..." are ok */
2939 if (cpipe->next->res_word == RES_DO)
2941 /* next word is not "do". It must be "in" then ("FOR v in ...") */
2942 if (cpipe->res_word == RES_IN /* "for v IN a b; not_do..."? */
2943 || cpipe->next->res_word != RES_IN /* FOR v not_do_and_not_in..."? */
2945 syntax("malformed for");
2946 debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
2952 /* Past this point, all code paths should jump to ret: label
2953 * in order to return, no direct "return" statements please.
2954 * This helps to ensure that no memory is leaked. */
2956 ////TODO: ctrl-Z handling needs re-thinking and re-testing
2959 /* Example of nested list: "while true; do { sleep 1 | exit 2; } done".
2960 * We are saving state before entering outermost list ("while...done")
2961 * so that ctrl-Z will correctly background _entire_ outermost list,
2962 * not just a part of it (like "sleep 1 | exit 2") */
2963 if (++G.run_list_level == 1 && G_interactive_fd) {
2964 if (sigsetjmp(G.toplevel_jb, 1)) {
2965 /* ctrl-Z forked and we are parent; or ctrl-C.
2966 * Sighandler has longjmped us here */
2967 signal(SIGINT, SIG_IGN);
2968 signal(SIGTSTP, SIG_IGN);
2969 /* Restore level (we can be coming from deep inside
2971 G.run_list_level = 1;
2972 #if ENABLE_FEATURE_SH_STANDALONE
2973 if (G.nofork_save.saved) { /* if save area is valid */
2974 debug_printf_jobs("exiting nofork early\n");
2975 restore_nofork_data(&G.nofork_save);
2978 //// if (G.ctrl_z_flag) {
2979 //// /* ctrl-Z has forked and stored pid of the child in pi->pid.
2980 //// * Remember this child as background job */
2981 //// insert_bg_job(pi);
2983 /* ctrl-C. We just stop doing whatever we were doing */
2986 USE_HUSH_LOOPS(loop_top = NULL;)
2987 USE_HUSH_LOOPS(G.depth_of_loop = 0;)
2991 //// /* ctrl-Z handler will store pid etc in pi */
2992 //// G.toplevel_list = pi;
2993 //// G.ctrl_z_flag = 0;
2994 ////#if ENABLE_FEATURE_SH_STANDALONE
2995 //// G.nofork_save.saved = 0; /* in case we will run a nofork later */
2997 //// signal_SA_RESTART_empty_mask(SIGTSTP, handler_ctrl_z);
2998 //// signal(SIGINT, handler_ctrl_c);
3002 /* Go through list of pipes, (maybe) executing them. */
3003 for (; pi; pi = USE_HUSH_LOOPS(rword == RES_DONE ? loop_top : ) pi->next) {
3007 IF_HAS_KEYWORDS(rword = pi->res_word;)
3008 IF_HAS_NO_KEYWORDS(rword = RES_NONE;)
3009 debug_printf_exec(": rword=%d cond_code=%d skip_more=%d\n",
3010 rword, cond_code, skip_more_for_this_rword);
3011 #if ENABLE_HUSH_LOOPS
3012 if ((rword == RES_WHILE || rword == RES_UNTIL || rword == RES_FOR)
3013 && loop_top == NULL /* avoid bumping G.depth_of_loop twice */
3015 /* start of a loop: remember where loop starts */
3020 if (rword == skip_more_for_this_rword && flag_skip) {
3021 if (pi->followup == PIPE_SEQ)
3023 /* it is "<false> && CMD" or "<true> || CMD"
3024 * and we should not execute CMD */
3028 skip_more_for_this_rword = RES_XXXX;
3031 if (rword == RES_THEN) {
3032 /* "if <false> THEN cmd": skip cmd */
3036 if (rword == RES_ELSE || rword == RES_ELIF) {
3037 /* "if <true> then ... ELSE/ELIF cmd":
3038 * skip cmd and all following ones */
3043 #if ENABLE_HUSH_LOOPS
3044 if (rword == RES_FOR) { /* && pi->num_cmds - always == 1 */
3046 /* first loop through for */
3048 static const char encoded_dollar_at[] ALIGN1 = {
3049 SPECIAL_VAR_SYMBOL, '@' | 0x80, SPECIAL_VAR_SYMBOL, '\0'
3050 }; /* encoded representation of "$@" */
3051 static const char *const encoded_dollar_at_argv[] = {
3052 encoded_dollar_at, NULL
3053 }; /* argv list with one element: "$@" */
3056 vals = (char**)encoded_dollar_at_argv;
3057 if (pi->next->res_word == RES_IN) {
3058 /* if no variable values after "in" we skip "for" */
3059 if (!pi->next->cmds[0].argv)
3061 vals = pi->next->cmds[0].argv;
3062 } /* else: "for var; do..." -> assume "$@" list */
3063 /* create list of variable values */
3064 debug_print_strings("for_list made from", vals);
3065 for_list = expand_strvec_to_strvec(vals);
3066 for_lcur = for_list;
3067 debug_print_strings("for_list", for_list);
3068 for_varname = pi->cmds[0].argv[0];
3069 pi->cmds[0].argv[0] = NULL;
3071 free(pi->cmds[0].argv[0]);
3073 /* "for" loop is over, clean up */
3077 pi->cmds[0].argv[0] = for_varname;
3080 /* insert next value from for_lcur */
3081 //TODO: does it need escaping?
3082 pi->cmds[0].argv[0] = xasprintf("%s=%s", for_varname, *for_lcur++);
3083 pi->cmds[0].assignment_cnt = 1;
3085 if (rword == RES_IN) /* "for v IN list;..." - "in" has no cmds anyway */
3087 if (rword == RES_DONE) {
3088 continue; /* "done" has no cmds too */
3091 #if ENABLE_HUSH_CASE
3092 if (rword == RES_CASE) {
3093 case_word = expand_strvec_to_string(pi->cmds->argv);
3096 if (rword == RES_MATCH) {
3099 if (!case_word) /* "case ... matched_word) ... WORD)": we executed selected branch, stop */
3101 /* all prev words didn't match, does this one match? */
3102 argv = pi->cmds->argv;
3104 char *pattern = expand_string_to_string(*argv);
3105 /* TODO: which FNM_xxx flags to use? */
3106 cond_code = (fnmatch(pattern, case_word, /*flags:*/ 0) != 0);
3108 if (cond_code == 0) { /* match! we will execute this branch */
3109 free(case_word); /* make future "word)" stop */
3117 if (rword == RES_CASEI) { /* inside of a case branch */
3119 continue; /* not matched yet, skip this pipe */
3122 /* Just pressing <enter> in shell should check for jobs.
3123 * OTOH, in non-interactive shell this is useless
3124 * and only leads to extra job checks */
3125 if (pi->num_cmds == 0) {
3126 if (G_interactive_fd)
3127 goto check_jobs_and_continue;
3131 /* After analyzing all keywords and conditions, we decided
3132 * to execute this pipe. NB: have to do checkjobs(NULL)
3133 * after run_pipe() to collect any background children,
3134 * even if list execution is to be stopped. */
3135 debug_printf_exec(": run_pipe with %d members\n", pi->num_cmds);
3138 #if ENABLE_HUSH_LOOPS
3139 G.flag_break_continue = 0;
3141 rcode = r = run_pipe(pi); /* NB: rcode is a smallint */
3143 /* we only ran a builtin: rcode is already known
3144 * and we don't need to wait for anything. */
3145 check_and_run_traps(0);
3146 #if ENABLE_HUSH_LOOPS
3147 /* was it "break" or "continue"? */
3148 if (G.flag_break_continue) {
3149 smallint fbc = G.flag_break_continue;
3150 /* we might fall into outer *loop*,
3151 * don't want to break it too */
3153 G.depth_break_continue--;
3154 if (G.depth_break_continue == 0)
3155 G.flag_break_continue = 0;
3156 /* else: e.g. "continue 2" should *break* once, *then* continue */
3157 } /* else: "while... do... { we are here (innermost list is not a loop!) };...done" */
3158 if (G.depth_break_continue != 0 || fbc == BC_BREAK)
3159 goto check_jobs_and_break;
3160 /* "continue": simulate end of loop */
3165 } else if (pi->followup == PIPE_BG) {
3166 /* what does bash do with attempts to background builtins? */
3167 /* even bash 3.2 doesn't do that well with nested bg:
3168 * try "{ { sleep 10; echo DEEP; } & echo HERE; } &".
3169 * I'm NOT treating inner &'s as jobs */
3170 check_and_run_traps(0);
3172 if (G.run_list_level == 1)
3175 rcode = 0; /* EXIT_SUCCESS */
3178 if (G.run_list_level == 1 && G_interactive_fd) {
3179 /* waits for completion, then fg's main shell */
3180 rcode = checkjobs_and_fg_shell(pi);
3181 check_and_run_traps(0);
3182 debug_printf_exec(": checkjobs_and_fg_shell returned %d\n", rcode);
3185 { /* this one just waits for completion */
3186 rcode = checkjobs(pi);
3187 check_and_run_traps(0);
3188 debug_printf_exec(": checkjobs returned %d\n", rcode);
3192 debug_printf_exec(": setting last_return_code=%d\n", rcode);
3193 G.last_return_code = rcode;
3195 /* Analyze how result affects subsequent commands */
3197 if (rword == RES_IF || rword == RES_ELIF)
3200 #if ENABLE_HUSH_LOOPS
3201 if (rword == RES_WHILE) {
3203 rcode = 0; /* "while false; do...done" - exitcode 0 */
3204 goto check_jobs_and_break;
3207 if (rword == RES_UNTIL) {
3209 check_jobs_and_break:
3215 if ((rcode == 0 && pi->followup == PIPE_OR)
3216 || (rcode != 0 && pi->followup == PIPE_AND)
3218 skip_more_for_this_rword = rword;
3221 check_jobs_and_continue:
3226 //// if (G.ctrl_z_flag) {
3227 //// /* ctrl-Z forked somewhere in the past, we are the child,
3228 //// * and now we completed running the list. Exit. */
3234 //// if (!G.run_list_level && G_interactive_fd) {
3235 //// signal(SIGTSTP, SIG_IGN);
3236 //// signal(SIGINT, SIG_IGN);
3239 debug_printf_exec("run_list lvl %d return %d\n", G.run_list_level + 1, rcode);
3240 #if ENABLE_HUSH_LOOPS
3245 #if ENABLE_HUSH_CASE
3251 /* Select which version we will use */
3252 static int run_and_free_list(struct pipe *pi)
3255 debug_printf_exec("run_and_free_list entered\n");
3257 debug_printf_exec(": run_list with %d members\n", pi->num_cmds);
3258 rcode = run_list(pi);
3260 /* free_pipe_list has the side effect of clearing memory.
3261 * In the long run that function can be merged with run_list,
3262 * but doing that now would hobble the debugging effort. */
3263 free_pipe_list(pi, /* indent: */ 0);
3264 debug_printf_exec("run_and_free_list return %d\n", rcode);
3269 /* Peek ahead in the in_str to find out if we have a "&n" construct,
3270 * as in "2>&1", that represents duplicating a file descriptor.
3271 * Return either -2 (syntax error), -1 (no &), or the number found.
3273 static int redirect_dup_num(struct in_str *input)
3275 int ch, d = 0, ok = 0;
3277 if (ch != '&') return -1;
3279 i_getch(input); /* get the & */
3283 return -3; /* "-" represents "close me" */
3285 while (isdigit(ch)) {
3286 d = d*10 + (ch-'0');
3293 bb_error_msg("ambiguous redirect");
3297 /* The src parameter allows us to peek forward to a possible &n syntax
3298 * for file descriptor duplication, e.g., "2>&1".
3299 * Return code is 0 normally, 1 if a syntax error is detected in src.
3300 * Resource errors (in xmalloc) cause the process to exit */
3301 static int setup_redirect(struct parse_context *ctx,
3304 struct in_str *input)
3306 struct command *command = ctx->command;
3307 struct redir_struct *redir;
3308 struct redir_struct **redirp;
3311 /* Check for a '2>&1' type redirect */
3312 dup_num = redirect_dup_num(input);
3314 return 1; /* syntax error */
3316 /* Create a new redir_struct and drop it onto the end of the linked list */
3317 redirp = &command->redirects;
3318 while ((redir = *redirp) != NULL) {
3319 redirp = &(redir->next);
3321 *redirp = redir = xzalloc(sizeof(*redir));
3322 /* redir->next = NULL; */
3323 /* redir->rd_filename = NULL; */
3324 redir->rd_type = style;
3325 redir->fd = (fd == -1) ? redir_table[style].default_fd : fd;
3327 debug_printf("Redirect type %d%s\n", redir->fd, redir_table[style].descrip);
3329 redir->dup = dup_num;
3330 if (dup_num != -1) {
3331 /* Erik had a check here that the file descriptor in question
3332 * is legit; I postpone that to "run time"
3333 * A "-" representation of "close me" shows up as a -3 here */
3334 debug_printf("Duplicating redirect '%d>&%d'\n", redir->fd, redir->dup);
3336 /* We do _not_ try to open the file that src points to,
3337 * since we need to return and let src be expanded first.
3338 * Set ctx->pending_redirect, so we know what to do at the
3339 * end of the next parsed word. */
3340 ctx->pending_redirect = redir;
3346 static struct pipe *new_pipe(void)
3349 pi = xzalloc(sizeof(struct pipe));
3350 /*pi->followup = 0; - deliberately invalid value */
3351 /*pi->res_word = RES_NONE; - RES_NONE is 0 anyway */
3355 /* Command (member of a pipe) is complete. The only possible error here
3356 * is out of memory, in which case xmalloc exits. */
3357 static int done_command(struct parse_context *ctx)
3359 /* The command is really already in the pipe structure, so
3360 * advance the pipe counter and make a new, null command. */
3361 struct pipe *pi = ctx->pipe;
3362 struct command *command = ctx->command;
3365 if (command->group == NULL
3366 && command->argv == NULL
3367 && command->redirects == NULL
3369 debug_printf_parse("done_command: skipping null cmd, num_cmds=%d\n", pi->num_cmds);
3370 return pi->num_cmds;
3373 debug_printf_parse("done_command: ++num_cmds=%d\n", pi->num_cmds);
3375 debug_printf_parse("done_command: initializing, num_cmds=%d\n", pi->num_cmds);
3378 /* Only real trickiness here is that the uncommitted
3379 * command structure is not counted in pi->num_cmds. */
3380 pi->cmds = xrealloc(pi->cmds, sizeof(*pi->cmds) * (pi->num_cmds+1));
3381 command = &pi->cmds[pi->num_cmds];
3382 memset(command, 0, sizeof(*command));
3384 ctx->command = command;
3385 /* but ctx->pipe and ctx->list_head remain unchanged */
3387 return pi->num_cmds; /* used only for 0/nonzero check */
3390 static void done_pipe(struct parse_context *ctx, pipe_style type)
3394 debug_printf_parse("done_pipe entered, followup %d\n", type);
3395 /* Close previous command */
3396 not_null = done_command(ctx);
3397 ctx->pipe->followup = type;
3398 IF_HAS_KEYWORDS(ctx->pipe->pi_inverted = ctx->ctx_inverted;)
3399 IF_HAS_KEYWORDS(ctx->ctx_inverted = 0;)
3400 IF_HAS_KEYWORDS(ctx->pipe->res_word = ctx->ctx_res_w;)
3402 /* Without this check, even just <enter> on command line generates
3403 * tree of three NOPs (!). Which is harmless but annoying.
3404 * IOW: it is safe to do it unconditionally.
3405 * RES_NONE case is for "for a in; do ..." (empty IN set)
3406 * to work, possibly other cases too. */
3407 if (not_null IF_HAS_KEYWORDS(|| ctx->ctx_res_w != RES_NONE)) {
3409 debug_printf_parse("done_pipe: adding new pipe: "
3410 "not_null:%d ctx->ctx_res_w:%d\n",
3411 not_null, ctx->ctx_res_w);
3413 ctx->pipe->next = new_p;
3415 /* RES_THEN, RES_DO etc are "sticky" -
3416 * they remain set for commands inside if/while.
3417 * This is used to control execution.
3418 * RES_FOR and RES_IN are NOT sticky (needed to support
3419 * cases where variable or value happens to match a keyword):
3421 #if ENABLE_HUSH_LOOPS
3422 if (ctx->ctx_res_w == RES_FOR
3423 || ctx->ctx_res_w == RES_IN)
3424 ctx->ctx_res_w = RES_NONE;
3426 #if ENABLE_HUSH_CASE
3427 if (ctx->ctx_res_w == RES_MATCH)
3428 ctx->ctx_res_w = RES_CASEI;
3430 ctx->command = NULL; /* trick done_command below */
3431 /* Create the memory for command, roughly:
3432 * ctx->pipe->cmds = new struct command;
3433 * ctx->command = &ctx->pipe->cmds[0];
3437 debug_printf_parse("done_pipe return\n");
3440 static void initialize_context(struct parse_context *ctx)
3442 memset(ctx, 0, sizeof(*ctx));
3443 ctx->pipe = ctx->list_head = new_pipe();
3444 /* Create the memory for command, roughly:
3445 * ctx->pipe->cmds = new struct command;
3446 * ctx->command = &ctx->pipe->cmds[0];
3452 /* If a reserved word is found and processed, parse context is modified
3453 * and 1 is returned.
3456 struct reserved_combo {
3459 unsigned char assignment_flag;
3463 FLAG_END = (1 << RES_NONE ),
3465 FLAG_IF = (1 << RES_IF ),
3466 FLAG_THEN = (1 << RES_THEN ),
3467 FLAG_ELIF = (1 << RES_ELIF ),
3468 FLAG_ELSE = (1 << RES_ELSE ),
3469 FLAG_FI = (1 << RES_FI ),
3471 #if ENABLE_HUSH_LOOPS
3472 FLAG_FOR = (1 << RES_FOR ),
3473 FLAG_WHILE = (1 << RES_WHILE),
3474 FLAG_UNTIL = (1 << RES_UNTIL),
3475 FLAG_DO = (1 << RES_DO ),
3476 FLAG_DONE = (1 << RES_DONE ),
3477 FLAG_IN = (1 << RES_IN ),
3479 #if ENABLE_HUSH_CASE
3480 FLAG_MATCH = (1 << RES_MATCH),
3481 FLAG_ESAC = (1 << RES_ESAC ),
3483 FLAG_START = (1 << RES_XXXX ),
3486 static const struct reserved_combo* match_reserved_word(o_string *word)
3488 /* Mostly a list of accepted follow-up reserved words.
3489 * FLAG_END means we are done with the sequence, and are ready
3490 * to turn the compound list into a command.
3491 * FLAG_START means the word must start a new compound list.
3493 static const struct reserved_combo reserved_list[] = {
3495 { "!", RES_NONE, NOT_ASSIGNMENT , 0 },
3496 { "if", RES_IF, WORD_IS_KEYWORD, FLAG_THEN | FLAG_START },
3497 { "then", RES_THEN, WORD_IS_KEYWORD, FLAG_ELIF | FLAG_ELSE | FLAG_FI },
3498 { "elif", RES_ELIF, WORD_IS_KEYWORD, FLAG_THEN },
3499 { "else", RES_ELSE, WORD_IS_KEYWORD, FLAG_FI },
3500 { "fi", RES_FI, NOT_ASSIGNMENT , FLAG_END },
3502 #if ENABLE_HUSH_LOOPS
3503 { "for", RES_FOR, NOT_ASSIGNMENT , FLAG_IN | FLAG_DO | FLAG_START },
3504 { "while", RES_WHILE, WORD_IS_KEYWORD, FLAG_DO | FLAG_START },
3505 { "until", RES_UNTIL, WORD_IS_KEYWORD, FLAG_DO | FLAG_START },
3506 { "in", RES_IN, NOT_ASSIGNMENT , FLAG_DO },
3507 { "do", RES_DO, WORD_IS_KEYWORD, FLAG_DONE },
3508 { "done", RES_DONE, NOT_ASSIGNMENT , FLAG_END },
3510 #if ENABLE_HUSH_CASE
3511 { "case", RES_CASE, NOT_ASSIGNMENT , FLAG_MATCH | FLAG_START },
3512 { "esac", RES_ESAC, NOT_ASSIGNMENT , FLAG_END },
3515 const struct reserved_combo *r;
3517 for (r = reserved_list; r < reserved_list + ARRAY_SIZE(reserved_list); r++) {
3518 if (strcmp(word->data, r->literal) == 0)
3523 static int reserved_word(o_string *word, struct parse_context *ctx)
3525 #if ENABLE_HUSH_CASE
3526 static const struct reserved_combo reserved_match = {
3527 "", RES_MATCH, NOT_ASSIGNMENT , FLAG_MATCH | FLAG_ESAC
3530 const struct reserved_combo *r;
3532 r = match_reserved_word(word);
3536 debug_printf("found reserved word %s, res %d\n", r->literal, r->res);
3537 #if ENABLE_HUSH_CASE
3538 if (r->res == RES_IN && ctx->ctx_res_w == RES_CASE)
3539 /* "case word IN ..." - IN part starts first match part */
3540 r = &reserved_match;
3543 if (r->flag == 0) { /* '!' */
3544 if (ctx->ctx_inverted) { /* bash doesn't accept '! ! true' */
3545 syntax("! ! command");
3546 IF_HAS_KEYWORDS(ctx->ctx_res_w = RES_SNTX;)
3548 ctx->ctx_inverted = 1;
3551 if (r->flag & FLAG_START) {
3552 struct parse_context *old;
3553 old = xmalloc(sizeof(*old));
3554 debug_printf_parse("push stack %p\n", old);
3555 *old = *ctx; /* physical copy */
3556 initialize_context(ctx);
3558 } else if (/*ctx->ctx_res_w == RES_NONE ||*/ !(ctx->old_flag & (1 << r->res))) {
3560 ctx->ctx_res_w = RES_SNTX;
3563 ctx->ctx_res_w = r->res;
3564 ctx->old_flag = r->flag;
3565 if (ctx->old_flag & FLAG_END) {
3566 struct parse_context *old;
3567 done_pipe(ctx, PIPE_SEQ);
3568 debug_printf_parse("pop stack %p\n", ctx->stack);
3570 old->command->group = ctx->list_head;
3571 old->command->grp_type = GRP_NORMAL;
3572 *ctx = *old; /* physical copy */
3575 word->o_assignment = r->assignment_flag;
3580 /* Word is complete, look at it and update parsing context.
3581 * Normal return is 0. Syntax errors return 1.
3582 * Note: on return, word is reset, but not o_free'd!
3584 static int done_word(o_string *word, struct parse_context *ctx)
3586 struct command *command = ctx->command;
3588 debug_printf_parse("done_word entered: '%s' %p\n", word->data, command);
3589 if (word->length == 0 && word->nonnull == 0) {
3590 debug_printf_parse("done_word return 0: true null, ignored\n");
3593 /* If this word wasn't an assignment, next ones definitely
3594 * can't be assignments. Even if they look like ones. */
3595 if (word->o_assignment != DEFINITELY_ASSIGNMENT
3596 && word->o_assignment != WORD_IS_KEYWORD
3598 word->o_assignment = NOT_ASSIGNMENT;
3600 if (word->o_assignment == DEFINITELY_ASSIGNMENT)
3601 command->assignment_cnt++;
3602 word->o_assignment = MAYBE_ASSIGNMENT;
3605 if (ctx->pending_redirect) {
3606 /* We do not glob in e.g. >*.tmp case. bash seems to glob here
3607 * only if run as "bash", not "sh" */
3608 ctx->pending_redirect->rd_filename = xstrdup(word->data);
3609 word->o_assignment = NOT_ASSIGNMENT;
3610 debug_printf("word stored in rd_filename: '%s'\n", word->data);
3612 /* "{ echo foo; } echo bar" - bad */
3613 /* NB: bash allows e.g.:
3614 * if true; then { echo foo; } fi
3615 * while if false; then false; fi do break; done
3617 if (command->group) {
3619 debug_printf_parse("done_word return 1: syntax error, "
3620 "groups and arglists don't mix\n");
3624 #if ENABLE_HUSH_CASE
3625 if (ctx->ctx_dsemicolon
3626 && strcmp(word->data, "esac") != 0 /* not "... pattern) cmd;; esac" */
3628 /* already done when ctx_dsemicolon was set to 1: */
3629 /* ctx->ctx_res_w = RES_MATCH; */
3630 ctx->ctx_dsemicolon = 0;
3633 if (!command->argv /* if it's the first word... */
3634 #if ENABLE_HUSH_LOOPS
3635 && ctx->ctx_res_w != RES_FOR /* ...not after FOR or IN */
3636 && ctx->ctx_res_w != RES_IN
3639 debug_printf_parse(": checking '%s' for reserved-ness\n", word->data);
3640 if (reserved_word(word, ctx)) {
3642 debug_printf_parse("done_word return %d\n", (ctx->ctx_res_w == RES_SNTX));
3643 return (ctx->ctx_res_w == RES_SNTX);
3647 if (word->nonnull /* word had "xx" or 'xx' at least as part of it. */
3648 /* optimization: and if it's ("" or '') or ($v... or `cmd`...): */
3649 && (word->data[0] == '\0' || word->data[0] == SPECIAL_VAR_SYMBOL)
3650 /* (otherwise it's known to be not empty and is already safe) */
3652 /* exclude "$@" - it can expand to no word despite "" */
3653 char *p = word->data;
3654 while (p[0] == SPECIAL_VAR_SYMBOL
3655 && (p[1] & 0x7f) == '@'
3656 && p[2] == SPECIAL_VAR_SYMBOL
3660 if (p == word->data || p[0] != '\0') {
3661 /* saw no "$@", or not only "$@" but some
3662 * real text is there too */
3663 /* insert "empty variable" reference, this makes
3664 * e.g. "", $empty"" etc to not disappear */
3665 o_addchr(word, SPECIAL_VAR_SYMBOL);
3666 o_addchr(word, SPECIAL_VAR_SYMBOL);
3669 command->argv = add_string_to_strings(command->argv, xstrdup(word->data));
3670 debug_print_strings("word appended to argv", command->argv);
3674 ctx->pending_redirect = NULL;
3676 #if ENABLE_HUSH_LOOPS
3677 /* Force FOR to have just one word (variable name) */
3678 /* NB: basically, this makes hush see "for v in ..." syntax as if
3679 * as it is "for v; in ...". FOR and IN become two pipe structs
3681 if (ctx->ctx_res_w == RES_FOR) {
3682 //TODO: check that command->argv[0] is a valid variable name!
3683 done_pipe(ctx, PIPE_SEQ);
3686 #if ENABLE_HUSH_CASE
3687 /* Force CASE to have just one word */
3688 if (ctx->ctx_res_w == RES_CASE) {
3689 done_pipe(ctx, PIPE_SEQ);
3692 debug_printf_parse("done_word return 0\n");
3696 /* If a redirect is immediately preceded by a number, that number is
3697 * supposed to tell which file descriptor to redirect. This routine
3698 * looks for such preceding numbers. In an ideal world this routine
3699 * needs to handle all the following classes of redirects...
3700 * echo 2>foo # redirects fd 2 to file "foo", nothing passed to echo
3701 * echo 49>foo # redirects fd 49 to file "foo", nothing passed to echo
3702 * echo -2>foo # redirects fd 1 to file "foo", "-2" passed to echo
3703 * echo 49x>foo # redirects fd 1 to file "foo", "49x" passed to echo
3704 * A -1 output from this program means no valid number was found, so the
3705 * caller should use the appropriate default for this redirection.
3707 static int redirect_opt_num(o_string *o)
3713 for (num = 0; num < o->length; num++) {
3714 if (!isdigit(o->data[num])) {
3718 num = atoi(o->data);
3723 static struct pipe *parse_stream(struct in_str *input, int end_trigger);
3725 #if ENABLE_HUSH_TICK
3726 static FILE *generate_stream_from_list(struct pipe *head)
3729 int pid, channel[2];
3732 /* *** NOMMU WARNING *** */
3733 /* By using vfork here, we suspend parent till child exits or execs.
3734 * If child will not do it before it fills the pipe, it can block forever
3735 * in write(STDOUT_FILENO), and parent (shell) will be also stuck.
3737 * yes "0123456789012345678901234567890" | dd bs=32 count=64k >TESTFILE
3738 * huge=`cat TESTFILE` # will block here forever
3741 pid = BB_MMU ? fork() : vfork();
3743 bb_perror_msg_and_die(BB_MMU ? "fork" : "vfork");
3744 if (pid == 0) { /* child */
3745 if (ENABLE_HUSH_JOB)
3746 die_sleep = 0; /* let nofork's xfuncs die */
3747 close(channel[0]); /* NB: close _first_, then move fd! */
3748 xmove_fd(channel[1], 1);
3749 /* Prevent it from trying to handle ctrl-z etc */
3751 G.run_list_level = 1;
3753 /* Process substitution is not considered to be usual
3754 * 'command execution'.
3755 * SUSv3 says ctrl-Z should be ignored, ctrl-C should not.
3757 set_jobctrl_signals_to_IGN();
3759 /* Note: freeing 'head' here would break NOMMU. */
3760 _exit(run_list(head));
3763 pf = fdopen(channel[0], "r");
3765 /* 'head' is freed by the caller */
3768 /* Return code is exit status of the process that is run. */
3769 static int process_command_subs(o_string *dest,
3770 struct in_str *input)
3772 int retcode, ch, eol_cnt;
3773 struct pipe *pipe_list;
3775 struct in_str pipe_str;
3777 /* Recursion to generate command */
3778 pipe_list = parse_stream(input, '\0');
3779 if (pipe_list == NULL)
3780 return 0; /* EOF: empty `cmd`: ``, ` ` etc */
3781 if (pipe_list == ERR_PTR)
3782 return 1; /* parse error. can this really happen? */
3784 p = generate_stream_from_list(pipe_list);
3785 free_pipe_list(pipe_list, /* indent: */ 0);
3788 close_on_exec_on(fileno(p));
3790 /* Now send results of command back into original context */
3791 setup_file_in_str(&pipe_str, p);
3793 while ((ch = i_getch(&pipe_str)) != EOF) {
3799 o_addchr(dest, '\n');
3802 o_addQchr(dest, ch);
3805 debug_printf("done reading from pipe, pclose()ing\n");
3806 /* Note: we got EOF, and we just close the read end of the pipe.
3807 * We do not wait for the `cmd` child to terminate. bash and ash do.
3809 * echo `echo Hi; exec 1>&-; sleep 2`
3811 retcode = fclose(p);
3812 debug_printf("closed FILE from child, retcode=%d\n", retcode);
3817 static int parse_group(o_string *dest, struct parse_context *ctx,
3818 struct in_str *input, int ch)
3820 /* dest contains characters seen prior to ( or {.
3821 * Typically it's empty, but for function defs,
3822 * it contains function name (without '()'). */
3823 struct pipe *pipe_list;
3825 struct command *command = ctx->command;
3827 debug_printf_parse("parse_group entered\n");
3828 #if ENABLE_HUSH_FUNCTIONS
3829 if (ch == 'F') { /* function definition? */
3830 bb_error_msg("aha '%s' is a function, parsing it...", dest->data);
3831 //command->fname = dest->data;
3832 command->grp_type = GRP_FUNCTION;
3833 //TODO: review every o_reset() location... do they handle all o_string fields correctly?
3834 memset(dest, 0, sizeof(*dest));
3837 if (command->argv /* word [word](... */
3838 || dest->length /* word(... */
3839 || dest->nonnull /* ""(... */
3842 debug_printf_parse("parse_group return 1: syntax error, groups and arglists don't mix\n");
3848 command->grp_type = GRP_SUBSHELL;
3850 pipe_list = parse_stream(input, endch);
3851 /* empty ()/{} or parse error? */
3852 if (!pipe_list || pipe_list == ERR_PTR) {
3854 debug_printf_parse("parse_group return 1: parse_stream returned %p\n", pipe_list);
3857 command->group = pipe_list;
3858 debug_printf_parse("parse_group return 0\n");
3860 /* command remains "open", available for possible redirects */
3863 #if ENABLE_HUSH_TICK || ENABLE_SH_MATH_SUPPORT
3864 /* Subroutines for copying $(...) and `...` things */
3865 static void add_till_backquote(o_string *dest, struct in_str *input);
3867 static void add_till_single_quote(o_string *dest, struct in_str *input)
3870 int ch = i_getch(input);
3878 /* "...\"...`..`...." - do we need to handle "...$(..)..." too? */
3879 static void add_till_double_quote(o_string *dest, struct in_str *input)
3882 int ch = i_getch(input);
3885 if (ch == '\\') { /* \x. Copy both chars. */
3887 ch = i_getch(input);
3893 add_till_backquote(dest, input);
3897 //if (ch == '$') ...
3900 /* Process `cmd` - copy contents until "`" is seen. Complicated by
3902 * "Within the backquoted style of command substitution, backslash
3903 * shall retain its literal meaning, except when followed by: '$', '`', or '\'.
3904 * The search for the matching backquote shall be satisfied by the first
3905 * backquote found without a preceding backslash; during this search,
3906 * if a non-escaped backquote is encountered within a shell comment,
3907 * a here-document, an embedded command substitution of the $(command)
3908 * form, or a quoted string, undefined results occur. A single-quoted
3909 * or double-quoted string that begins, but does not end, within the
3910 * "`...`" sequence produces undefined results."
3912 * echo `echo '\'TEST\`echo ZZ\`BEST` \TESTZZBEST
3914 static void add_till_backquote(o_string *dest, struct in_str *input)
3917 int ch = i_getch(input);
3920 if (ch == '\\') { /* \x. Copy both chars unless it is \` */
3921 int ch2 = i_getch(input);
3922 if (ch2 != '`' && ch2 != '$' && ch2 != '\\')
3931 /* Process $(cmd) - copy contents until ")" is seen. Complicated by
3932 * quoting and nested ()s.
3933 * "With the $(command) style of command substitution, all characters
3934 * following the open parenthesis to the matching closing parenthesis
3935 * constitute the command. Any valid shell script can be used for command,
3936 * except a script consisting solely of redirections which produces
3937 * unspecified results."
3939 * echo $(echo '(TEST)' BEST) (TEST) BEST
3940 * echo $(echo 'TEST)' BEST) TEST) BEST
3941 * echo $(echo \(\(TEST\) BEST) ((TEST) BEST
3943 static void add_till_closing_paren(o_string *dest, struct in_str *input, bool dbl)
3947 int ch = i_getch(input);
3956 if (i_peek(input) == ')') {
3963 add_till_single_quote(dest, input);
3968 add_till_double_quote(dest, input);
3972 if (ch == '\\') { /* \x. Copy verbatim. Important for \(, \) */
3973 ch = i_getch(input);
3981 #endif /* ENABLE_HUSH_TICK || ENABLE_SH_MATH_SUPPORT */
3983 /* Return code: 0 for OK, 1 for syntax error */
3984 static int handle_dollar(o_string *dest, struct in_str *input)
3987 int ch = i_peek(input); /* first character after the $ */
3988 unsigned char quote_mask = dest->o_escape ? 0x80 : 0;
3990 debug_printf_parse("handle_dollar entered: ch='%c'\n", ch);
3994 o_addchr(dest, SPECIAL_VAR_SYMBOL);
3996 debug_printf_parse(": '%c'\n", ch);
3997 o_addchr(dest, ch | quote_mask);
4000 if (!isalnum(ch) && ch != '_')
4004 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4005 } else if (isdigit(ch)) {
4008 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4009 debug_printf_parse(": '%c'\n", ch);
4010 o_addchr(dest, ch | quote_mask);
4011 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4012 } else switch (ch) {
4014 case '!': /* last bg pid */
4015 case '?': /* last exit code */
4016 case '#': /* number of args */
4017 case '*': /* args */
4018 case '@': /* args */
4019 goto make_one_char_var;
4021 bool first_char, all_digits;
4023 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4025 /* XXX maybe someone will try to escape the '}' */
4030 ch = i_getch(input);
4036 /* ${#var}: length of var contents */
4038 else if (isdigit(ch)) {
4044 if (expansion < 2 &&
4045 ((all_digits && !isdigit(ch)) ||
4046 (!all_digits && !isalnum(ch) && ch != '_')))
4048 /* handle parameter expansions
4049 * http://www.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html#tag_02_06_02
4054 case ':': /* null modifier */
4055 if (expansion == 0) {
4056 debug_printf_parse(": null modifier\n");
4062 #if 0 /* not implemented yet :( */
4063 case '#': /* remove prefix */
4064 case '%': /* remove suffix */
4065 if (expansion == 0) {
4066 debug_printf_parse(": remove suffix/prefix\n");
4073 case '-': /* default value */
4074 case '=': /* assign default */
4075 case '+': /* alternative */
4076 case '?': /* error indicate */
4077 debug_printf_parse(": parameter expansion\n");
4083 syntax("unterminated ${name}");
4084 debug_printf_parse("handle_dollar return 1: unterminated ${name}\n");
4090 debug_printf_parse(": '%c'\n", ch);
4091 o_addchr(dest, ch | quote_mask);
4095 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4101 #if ENABLE_SH_MATH_SUPPORT
4102 if (i_peek(input) == '(') {
4104 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4105 o_addchr(dest, /*quote_mask |*/ '+');
4106 add_till_closing_paren(dest, input, true);
4107 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4112 #if ENABLE_HUSH_TICK
4113 //int pos = dest->length;
4114 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4115 o_addchr(dest, quote_mask | '`');
4116 add_till_closing_paren(dest, input, false);
4117 //debug_printf_subst("SUBST RES2 '%s'\n", dest->data + pos);
4118 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4125 if (isalnum(ch)) { /* it's $_name or $_123 */
4131 /* still unhandled, but should be eventually */
4132 bb_error_msg("unhandled syntax: $%c", ch);
4136 o_addQchr(dest, '$');
4138 debug_printf_parse("handle_dollar return 0\n");
4142 static int parse_stream_dquoted(o_string *dest, struct in_str *input, int dquote_end)
4148 ch = i_getch(input);
4149 if (ch == dquote_end) { /* may be only '"' or EOF */
4151 if (dest->o_assignment == NOT_ASSIGNMENT)
4152 dest->o_escape ^= 1;
4153 debug_printf_parse("parse_stream_dquoted return 0\n");
4157 syntax("unterminated \"");
4158 debug_printf_parse("parse_stream_dquoted return 1: unterminated \"\n");
4164 next = i_peek(input);
4166 debug_printf_parse(": ch=%c (%d) m=%d escape=%d\n",
4167 ch, ch, m, dest->o_escape);
4168 /* Basically, checking every CHAR_SPECIAL char except '"' */
4172 debug_printf_parse("parse_stream_dquoted return 1: \\<eof>\n");
4176 * "The backslash retains its special meaning [in "..."]
4177 * only when followed by one of the following characters:
4178 * $, `, ", \, or <newline>. A double quote may be quoted
4179 * within double quotes by preceding it with a backslash.
4180 * If enabled, history expansion will be performed unless
4181 * an ! appearing in double quotes is escaped using
4182 * a backslash. The backslash preceding the ! is not removed."
4184 if (strchr("$`\"\\", next) != NULL) {
4185 o_addqchr(dest, i_getch(input));
4187 o_addqchr(dest, '\\');
4192 if (handle_dollar(dest, input) != 0) {
4193 debug_printf_parse("parse_stream_dquoted return 1: handle_dollar returned non-0\n");
4198 #if ENABLE_HUSH_TICK
4200 //int pos = dest->length;
4201 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4202 o_addchr(dest, 0x80 | '`');
4203 add_till_backquote(dest, input);
4204 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4205 //debug_printf_subst("SUBST RES3 '%s'\n", dest->data + pos);
4209 o_addQchr(dest, ch);
4211 && (dest->o_assignment == MAYBE_ASSIGNMENT
4212 || dest->o_assignment == WORD_IS_KEYWORD)
4213 && is_assignment(dest->data)
4215 dest->o_assignment = DEFINITELY_ASSIGNMENT;
4221 * Scan input until EOF or end_trigger char.
4222 * Return a list of pipes to execute, or NULL on EOF
4223 * or if end_trigger character is met.
4224 * On syntax error, exit is shell is not interactive,
4225 * reset parsing machinery and start parsing anew,
4226 * or return ERR_PTR.
4228 static struct pipe *parse_stream(struct in_str *input, int end_trigger)
4230 struct parse_context ctx;
4231 o_string dest = NULL_O_STRING;
4234 redir_type redir_style;
4238 /* Double-quote state is handled in the state variable is_in_dquote.
4239 * A single-quote triggers a bypass of the main loop until its mate is
4240 * found. When recursing, quote state is passed in via dest->o_escape. */
4242 debug_printf_parse("parse_stream entered, end_trigger='%c'\n",
4243 end_trigger ? : 'X');
4246 #if ENABLE_HUSH_INTERACTIVE
4247 input->promptmode = 0; /* PS1 */
4249 /* dest.o_assignment = MAYBE_ASSIGNMENT; - already is */
4250 initialize_context(&ctx);
4254 if (parse_stream_dquoted(&dest, input, '"')) {
4257 /* We reached closing '"' */
4262 ch = i_getch(input);
4266 next = i_peek(input);
4269 debug_printf_parse(": ch=%c (%d) m=%d escape=%d\n",
4270 ch, ch, m, dest.o_escape);
4271 if (m == CHAR_ORDINARY) {
4272 o_addQchr(&dest, ch);
4273 if ((dest.o_assignment == MAYBE_ASSIGNMENT
4274 || dest.o_assignment == WORD_IS_KEYWORD)
4276 && is_assignment(dest.data)
4278 dest.o_assignment = DEFINITELY_ASSIGNMENT;
4283 /* m is SPECIAL ($,`), IFS, or ORDINARY_IF_QUOTED (*,#) */
4285 if (m == CHAR_IFS) {
4288 if (done_word(&dest, &ctx)) {
4292 done_pipe(&ctx, PIPE_SEQ);
4293 /* If we got nothing... */
4295 if (pi->num_cmds == 0
4296 IF_HAS_KEYWORDS( && pi->res_word == RES_NONE)
4298 free_pipe_list(pi, 0);
4301 debug_printf_parse("parse_stream return %p\n", pi);
4304 if (done_word(&dest, &ctx)) {
4308 #if ENABLE_HUSH_CASE
4309 /* "case ... in <newline> word) ..." -
4310 * newlines are ignored (but ';' wouldn't be) */
4311 if (ctx.command->argv == NULL
4312 && ctx.ctx_res_w == RES_MATCH
4317 /* Treat newline as a command separator. */
4318 done_pipe(&ctx, PIPE_SEQ);
4319 dest.o_assignment = MAYBE_ASSIGNMENT;
4321 /* note: if (m == CHAR_IFS) continue;
4322 * will still trigger for us */
4325 if (end_trigger && end_trigger == ch) {
4326 //TODO: disallow "{ cmd }" without semicolon
4327 if (done_word(&dest, &ctx)) {
4330 done_pipe(&ctx, PIPE_SEQ);
4331 dest.o_assignment = MAYBE_ASSIGNMENT;
4332 /* Do we sit outside of any if's, loops or case's? */
4334 IF_HAS_KEYWORDS(|| (ctx.ctx_res_w == RES_NONE && ctx.old_flag == 0))
4336 debug_printf_parse("parse_stream return %p: "
4337 "end_trigger char found\n",
4340 return ctx.list_head;
4346 /* m is SPECIAL (e.g. $,`) or ORDINARY_IF_QUOTED (*,#) */
4348 if (dest.o_assignment == MAYBE_ASSIGNMENT) {
4349 /* ch is a special char and thus this word
4350 * cannot be an assignment */
4351 dest.o_assignment = NOT_ASSIGNMENT;
4356 if (dest.length == 0) {
4359 if (ch == EOF || ch == '\n')
4364 o_addQchr(&dest, ch);
4372 o_addchr(&dest, '\\');
4373 o_addchr(&dest, i_getch(input));
4376 if (handle_dollar(&dest, input) != 0) {
4377 debug_printf_parse("parse_stream parse error: handle_dollar returned non-0\n");
4384 ch = i_getch(input);
4386 syntax("unterminated '");
4391 if (dest.o_assignment == NOT_ASSIGNMENT)
4392 o_addqchr(&dest, ch);
4394 o_addchr(&dest, ch);
4399 is_in_dquote ^= 1; /* invert */
4400 if (dest.o_assignment == NOT_ASSIGNMENT)
4403 #if ENABLE_HUSH_TICK
4405 //int pos = dest.length;
4406 o_addchr(&dest, SPECIAL_VAR_SYMBOL);
4407 o_addchr(&dest, '`');
4408 add_till_backquote(&dest, input);
4409 o_addchr(&dest, SPECIAL_VAR_SYMBOL);
4410 //debug_printf_subst("SUBST RES3 '%s'\n", dest.data + pos);
4415 redir_fd = redirect_opt_num(&dest);
4416 if (done_word(&dest, &ctx)) {
4419 redir_style = REDIRECT_OVERWRITE;
4421 redir_style = REDIRECT_APPEND;
4425 else if (next == '(') {
4426 syntax(">(process) not supported");
4430 setup_redirect(&ctx, redir_fd, redir_style, input);
4433 redir_fd = redirect_opt_num(&dest);
4434 if (done_word(&dest, &ctx)) {
4437 redir_style = REDIRECT_INPUT;
4439 redir_style = REDIRECT_HEREIS;
4441 } else if (next == '>') {
4442 redir_style = REDIRECT_IO;
4446 else if (next == '(') {
4447 syntax("<(process) not supported");
4451 setup_redirect(&ctx, redir_fd, redir_style, input);
4454 #if ENABLE_HUSH_CASE
4457 if (done_word(&dest, &ctx)) {
4460 done_pipe(&ctx, PIPE_SEQ);
4461 #if ENABLE_HUSH_CASE
4462 /* Eat multiple semicolons, detect
4463 * whether it means something special */
4469 if (ctx.ctx_res_w == RES_CASEI) {
4470 ctx.ctx_dsemicolon = 1;
4471 ctx.ctx_res_w = RES_MATCH;
4477 /* We just finished a cmd. New one may start
4478 * with an assignment */
4479 dest.o_assignment = MAYBE_ASSIGNMENT;
4482 if (done_word(&dest, &ctx)) {
4487 done_pipe(&ctx, PIPE_AND);
4489 done_pipe(&ctx, PIPE_BG);
4493 if (done_word(&dest, &ctx)) {
4496 #if ENABLE_HUSH_CASE
4497 if (ctx.ctx_res_w == RES_MATCH)
4498 break; /* we are in case's "word | word)" */
4500 if (next == '|') { /* || */
4502 done_pipe(&ctx, PIPE_OR);
4504 /* we could pick up a file descriptor choice here
4505 * with redirect_opt_num(), but bash doesn't do it.
4506 * "echo foo 2| cat" yields "foo 2". */
4511 #if ENABLE_HUSH_CASE
4512 /* "case... in [(]word)..." - skip '(' */
4513 if (ctx.ctx_res_w == RES_MATCH
4514 && ctx.command->argv == NULL /* not (word|(... */
4515 && dest.length == 0 /* not word(... */
4516 && dest.nonnull == 0 /* not ""(... */
4521 #if ENABLE_HUSH_FUNCTIONS
4522 if (dest.length != 0 /* not just () but word() */
4523 && dest.nonnull == 0 /* not a"b"c() */
4524 && ctx.command->argv == NULL /* it's the first word */
4525 //TODO: "func ( ) {...}" - note spaces - is valid format too in bash
4526 && i_peek(input) == ')'
4527 && !match_reserved_word(&dest)
4529 bb_error_msg("seems like a function definition");
4532 //TODO: do it properly.
4533 ch = i_getch(input);
4534 } while (ch == ' ' || ch == '\n');
4536 syntax("was expecting {");
4539 ch = 'F'; /* magic value */
4543 if (parse_group(&dest, &ctx, input, ch) != 0) {
4548 #if ENABLE_HUSH_CASE
4549 if (ctx.ctx_res_w == RES_MATCH)
4553 /* proper use of this character is caught by end_trigger:
4554 * if we see {, we call parse_group(..., end_trigger='}')
4555 * and it will match } earlier (not here). */
4556 syntax("unexpected } or )");
4560 bb_error_msg_and_die("BUG: unexpected %c\n", ch);
4566 struct parse_context *pctx;
4567 IF_HAS_KEYWORDS(struct parse_context *p2;)
4569 /* Clean up allocated tree.
4570 * Samples for finding leaks on syntax error recovery path.
4571 * Execute them from interactive shell and watch pmap `pidof hush`.
4572 * while if false; then false; fi do break; done (bash accepts it)
4573 * while if false; then false; fi; do break; fi
4577 /* Update pipe/command counts,
4578 * otherwise freeing may miss some */
4579 done_pipe(pctx, PIPE_SEQ);
4580 debug_printf_clean("freeing list %p from ctx %p\n",
4581 pctx->list_head, pctx);
4582 debug_print_tree(pctx->list_head, 0);
4583 free_pipe_list(pctx->list_head, 0);
4584 debug_printf_clean("freed list %p\n", pctx->list_head);
4585 IF_HAS_KEYWORDS(p2 = pctx->stack;)
4589 IF_HAS_KEYWORDS(pctx = p2;)
4590 } while (HAS_KEYWORDS && pctx);
4591 /* Free text, clear all dest fields */
4593 /* If we are not in top-level parse, we return,
4594 * our caller will propagate error.
4596 if (end_trigger != ';')
4598 /* Discard cached input, force prompt */
4600 USE_HUSH_INTERACTIVE(input->promptme = 1;)
4605 static void set_in_charmap(const char *set, int code)
4608 G.charmap[(unsigned char)*set++] = code;
4611 static void update_charmap(void)
4613 G.ifs = getenv("IFS");
4616 /* Precompute a list of 'flow through' behavior so it can be treated
4617 * quickly up front. Computation is necessary because of IFS.
4618 * Special case handling of IFS == " \t\n" is not implemented.
4619 * The charmap[] array only really needs two bits each,
4620 * and on most machines that would be faster (reduced L1 cache use).
4622 memset(G.charmap, CHAR_ORDINARY, sizeof(G.charmap));
4623 #if ENABLE_HUSH_TICK
4624 set_in_charmap("\\$\"`", CHAR_SPECIAL);
4626 set_in_charmap("\\$\"", CHAR_SPECIAL);
4628 set_in_charmap("<>;&|(){}#'", CHAR_ORDINARY_IF_QUOTED);
4629 set_in_charmap(G.ifs, CHAR_IFS); /* are ordinary if quoted */
4632 /* Execiting from string: eval, sh -c '...'
4633 * or from file: /etc/profile, . file, sh <script>, sh (intereactive)
4634 * end_trigger controls how often we stop parsing
4635 * NUL: parse all, execute, return
4636 * ';': parse till ';' or newline, execute, repeat till EOF
4638 static void parse_and_run_stream(struct in_str *inp, int end_trigger)
4641 struct pipe *pipe_list;
4645 pipe_list = parse_stream(inp, end_trigger);
4646 if (!pipe_list) /* EOF */
4648 debug_print_tree(pipe_list, 0);
4649 debug_printf_exec("parse_and_run_stream: run_and_free_list\n");
4650 run_and_free_list(pipe_list);
4651 /* Loop on syntax errors, return on EOF: */
4655 static void parse_and_run_string(const char *s)
4657 struct in_str input;
4658 setup_string_in_str(&input, s);
4659 parse_and_run_stream(&input, '\0');
4662 static void parse_and_run_file(FILE *f)
4664 struct in_str input;
4665 setup_file_in_str(&input, f);
4666 parse_and_run_stream(&input, ';');
4670 /* Make sure we have a controlling tty. If we get started under a job
4671 * aware app (like bash for example), make sure we are now in charge so
4672 * we don't fight over who gets the foreground */
4673 static void setup_job_control(void)
4677 shell_pgrp = getpgrp();
4679 /* If we were ran as 'hush &',
4680 * sleep until we are in the foreground. */
4681 while (tcgetpgrp(G_interactive_fd) != shell_pgrp) {
4682 /* Send TTIN to ourself (should stop us) */
4683 kill(- shell_pgrp, SIGTTIN);
4684 shell_pgrp = getpgrp();
4687 /* We _must_ restore tty pgrp on fatal signals */
4688 set_fatal_signals_to_sigexit();
4690 /* Put ourselves in our own process group. */
4691 bb_setpgrp(); /* is the same as setpgid(our_pid, our_pid); */
4692 /* Grab control of the terminal. */
4693 tcsetpgrp(G_interactive_fd, getpid());
4697 static int set_mode(const char cstate, const char mode)
4699 int state = (cstate == '-' ? 1 : 0);
4701 case 'n': G.fake_mode = state; break;
4702 case 'x': /*G.debug_mode = state;*/ break;
4703 default: return EXIT_FAILURE;
4705 return EXIT_SUCCESS;
4708 int hush_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
4709 int hush_main(int argc, char **argv)
4711 static const struct variable const_shell_ver = {
4713 .varstr = (char*)hush_version_str,
4714 .max_len = 1, /* 0 can provoke free(name) */
4722 struct variable *cur_var;
4726 G.root_pid = getpid();
4728 /* Deal with HUSH_VERSION */
4729 G.shell_ver = const_shell_ver; /* copying struct here */
4730 G.top_var = &G.shell_ver;
4731 debug_printf_env("unsetenv '%s'\n", "HUSH_VERSION");
4732 unsetenv("HUSH_VERSION"); /* in case it exists in initial env */
4733 /* Initialize our shell local variables with the values
4734 * currently living in the environment */
4735 cur_var = G.top_var;
4738 char *value = strchr(*e, '=');
4739 if (value) { /* paranoia */
4740 cur_var->next = xzalloc(sizeof(*cur_var));
4741 cur_var = cur_var->next;
4742 cur_var->varstr = *e;
4743 cur_var->max_len = strlen(*e);
4744 cur_var->flg_export = 1;
4748 debug_printf_env("putenv '%s'\n", hush_version_str);
4749 putenv((char *)hush_version_str); /* reinstate HUSH_VERSION */
4751 #if ENABLE_FEATURE_EDITING
4752 G.line_input_state = new_line_input_t(FOR_SHELL);
4754 /* XXX what should these be while sourcing /etc/profile? */
4755 G.global_argc = argc;
4756 G.global_argv = argv;
4757 /* Initialize some more globals to non-zero values */
4759 #if ENABLE_HUSH_INTERACTIVE
4760 if (ENABLE_FEATURE_EDITING)
4761 cmdedit_set_initial_prompt();
4765 if (EXIT_SUCCESS) /* otherwise is already done */
4766 G.last_return_code = EXIT_SUCCESS;
4768 if (argv[0] && argv[0][0] == '-') {
4769 debug_printf("sourcing /etc/profile\n");
4770 input = fopen_for_read("/etc/profile");
4771 if (input != NULL) {
4772 close_on_exec_on(fileno(input));
4773 parse_and_run_file(input);
4779 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/sh.html */
4780 while ((opt = getopt(argc, argv, "c:xins")) > 0) {
4783 G.global_argv = argv + optind;
4784 if (!argv[optind]) {
4785 /* -c 'script' (no params): prevent empty $0 */
4786 *--G.global_argv = argv[0];
4788 } /* else -c 'script' PAR0 PAR1: $0 is PAR0 */
4789 G.global_argc = argc - optind;
4790 parse_and_run_string(optarg);
4793 /* Well, we cannot just declare interactiveness,
4794 * we have to have some stuff (ctty, etc) */
4795 /* G_interactive_fd++; */
4798 /* "-s" means "read from stdin", but this is how we always
4799 * operate, so simply do nothing here. */
4803 if (!set_mode('-', opt))
4807 fprintf(stderr, "Usage: sh [FILE]...\n"
4808 " or: sh -c command [args]...\n\n");
4816 /* A shell is interactive if the '-i' flag was given, or if all of
4817 * the following conditions are met:
4819 * no arguments remaining or the -s flag given
4820 * standard input is a terminal
4821 * standard output is a terminal
4822 * Refer to Posix.2, the description of the 'sh' utility. */
4823 if (argv[optind] == NULL && input == stdin
4824 && isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)
4826 G.saved_tty_pgrp = tcgetpgrp(STDIN_FILENO);
4827 debug_printf("saved_tty_pgrp=%d\n", G.saved_tty_pgrp);
4828 if (G.saved_tty_pgrp >= 0) {
4829 /* try to dup to high fd#, >= 255 */
4830 G_interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
4831 if (G_interactive_fd < 0) {
4832 /* try to dup to any fd */
4833 G_interactive_fd = dup(STDIN_FILENO);
4834 if (G_interactive_fd < 0)
4836 G_interactive_fd = 0;
4838 // TODO: track & disallow any attempts of user
4839 // to (inadvertently) close/redirect it
4842 init_signal_mask(); /* note: ensures SIGCHLD is not masked */
4843 debug_printf("interactive_fd=%d\n", G_interactive_fd);
4844 if (G_interactive_fd) {
4845 fcntl(G_interactive_fd, F_SETFD, FD_CLOEXEC);
4846 /* Looks like they want an interactive shell */
4847 setup_job_control();
4848 /* -1 is special - makes xfuncs longjmp, not exit
4849 * (we reset die_sleep = 0 whereever we [v]fork) */
4851 if (setjmp(die_jmp)) {
4852 /* xfunc has failed! die die die */
4853 hush_exit(xfunc_error_retval);
4856 #elif ENABLE_HUSH_INTERACTIVE
4857 /* no job control compiled, only prompt/line editing */
4858 if (argv[optind] == NULL && input == stdin
4859 && isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)
4861 G_interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
4862 if (G_interactive_fd < 0) {
4863 /* try to dup to any fd */
4864 G_interactive_fd = dup(STDIN_FILENO);
4865 if (G_interactive_fd < 0)
4867 G_interactive_fd = 0;
4869 if (G_interactive_fd) {
4870 fcntl(G_interactive_fd, F_SETFD, FD_CLOEXEC);
4873 init_signal_mask(); /* note: ensures SIGCHLD is not masked */
4877 /* POSIX allows shell to re-enable SIGCHLD
4878 * even if it was SIG_IGN on entry */
4879 // G.count_SIGCHLD++; /* ensure it is != G.handled_SIGCHLD */
4880 signal(SIGCHLD, SIG_DFL); // SIGCHLD_handler);
4882 #if ENABLE_HUSH_INTERACTIVE && !ENABLE_FEATURE_SH_EXTRA_QUIET
4883 if (G_interactive_fd) {
4884 printf("\n\n%s hush - the humble shell v"HUSH_VER_STR"\n", bb_banner);
4885 printf("Enter 'help' for a list of built-in commands.\n\n");
4889 if (argv[optind] == NULL) {
4890 parse_and_run_file(stdin);
4892 debug_printf("\nrunning script '%s'\n", argv[optind]);
4893 G.global_argv = argv + optind;
4894 G.global_argc = argc - optind;
4895 input = xfopen_for_read(argv[optind]);
4896 fcntl(fileno(input), F_SETFD, FD_CLOEXEC);
4897 parse_and_run_file(input);
4902 #if ENABLE_FEATURE_CLEAN_UP
4904 if (G.cwd != bb_msg_unknown)
4906 cur_var = G.top_var->next;
4908 struct variable *tmp = cur_var;
4909 if (!cur_var->max_len)
4910 free(cur_var->varstr);
4911 cur_var = cur_var->next;
4915 hush_exit(G.last_return_code);
4920 int lash_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
4921 int lash_main(int argc, char **argv)
4923 //bb_error_msg("lash is deprecated, please use hush instead");
4924 return hush_main(argc, argv);
4932 static int builtin_trap(char **argv)
4939 G.traps = xzalloc(sizeof(G.traps[0]) * NSIG);
4942 /* No args: print all trapped. This isn't 100% correct as we should
4943 * be escaping the cmd so that it can be pasted back in ...
4945 for (i = 0; i < NSIG; ++i)
4947 printf("trap -- '%s' %s\n", G.traps[i], get_signame(i));
4948 return EXIT_SUCCESS;
4953 /* if first arg is decimal: reset all specified */
4954 sig = bb_strtou(*++argv, NULL, 10);
4960 sig = get_signum(*argv++);
4961 if (sig < 0 || sig >= NSIG) {
4963 /* mimic bash message exactly */
4964 bb_perror_msg("trap: %s: invalid signal specification", argv[i]);
4969 G.traps[sig] = xstrdup(new_cmd);
4971 debug_printf("trap: setting SIG%s (%i) to '%s'",
4972 get_signame(sig), sig, G.traps[sig]);
4974 /* There is no signal for 0 (EXIT) */
4979 sigaddset(&G.blocked_set, sig);
4981 /* there was a trap handler, we are removing it
4982 * (if sig has non-DFL handling,
4983 * we don't need to do anything) */
4984 if (sig < 32 && (G.non_DFL_mask & (1 << sig)))
4986 sigdelset(&G.blocked_set, sig);
4988 sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
4993 /* first arg is "-": reset all specified to default */
4994 /* first arg is "": ignore all specified */
4995 /* everything else: execute first arg upon signal */
4997 bb_error_msg("trap: invalid arguments");
4998 return EXIT_FAILURE;
5000 if (LONE_DASH(*argv))
5008 static int builtin_true(char **argv UNUSED_PARAM)
5013 static int builtin_test(char **argv)
5020 return test_main(argc, argv - argc);
5023 static int builtin_echo(char **argv)
5030 return echo_main(argc, argv - argc);
5033 static int builtin_eval(char **argv)
5035 int rcode = EXIT_SUCCESS;
5038 char *str = expand_strvec_to_string(argv + 1);
5040 * eval "echo Hi; done" ("done" is syntax error):
5041 * "echo Hi" will not execute too.
5043 parse_and_run_string(str);
5045 rcode = G.last_return_code;
5050 static int builtin_cd(char **argv)
5053 if (argv[1] == NULL) {
5054 /* bash does nothing (exitcode 0) if HOME is ""; if it's unset,
5055 * bash says "bash: cd: HOME not set" and does nothing (exitcode 1)
5057 newdir = getenv("HOME") ? : "/";
5060 if (chdir(newdir)) {
5061 printf("cd: %s: %s\n", newdir, strerror(errno));
5062 return EXIT_FAILURE;
5065 return EXIT_SUCCESS;
5068 static int builtin_exec(char **argv)
5070 if (argv[1] == NULL)
5071 return EXIT_SUCCESS; /* bash does this */
5076 // FIXME: if exec fails, bash does NOT exit! We do...
5077 pseudo_exec_argv(&dummy, argv + 1, 0, NULL);
5082 static int builtin_exit(char **argv)
5084 // TODO: bash does it ONLY on top-level sh exit (+interacive only?)
5085 //puts("exit"); /* bash does it */
5086 // TODO: warn if we have background jobs: "There are stopped jobs"
5087 // On second consecutive 'exit', exit anyway.
5088 if (argv[1] == NULL)
5089 hush_exit(G.last_return_code);
5090 /* mimic bash: exit 123abc == exit 255 + error msg */
5091 xfunc_error_retval = 255;
5092 /* bash: exit -2 == exit 254, no error msg */
5093 hush_exit(xatoi(argv[1]) & 0xff);
5096 static int builtin_export(char **argv)
5099 char *name = argv[1];
5103 // ash emits: export VAR='VAL'
5104 // bash: declare -x VAR="VAL"
5105 // (both also escape as needed (quotes, $, etc))
5110 return EXIT_SUCCESS;
5113 value = strchr(name, '=');
5115 /* They are exporting something without a =VALUE */
5116 struct variable *var;
5118 var = get_local_var(name);
5120 var->flg_export = 1;
5121 debug_printf_env("%s: putenv '%s'\n", __func__, var->varstr);
5122 putenv(var->varstr);
5124 /* bash does not return an error when trying to export
5125 * an undefined variable. Do likewise. */
5126 return EXIT_SUCCESS;
5129 set_local_var(xstrdup(name), 1);
5130 return EXIT_SUCCESS;
5134 /* built-in 'fg' and 'bg' handler */
5135 static int builtin_fg_bg(char **argv)
5140 if (!G_interactive_fd)
5141 return EXIT_FAILURE;
5142 /* If they gave us no args, assume they want the last backgrounded task */
5144 for (pi = G.job_list; pi; pi = pi->next) {
5145 if (pi->jobid == G.last_jobid) {
5149 bb_error_msg("%s: no current job", argv[0]);
5150 return EXIT_FAILURE;
5152 if (sscanf(argv[1], "%%%d", &jobnum) != 1) {
5153 bb_error_msg("%s: bad argument '%s'", argv[0], argv[1]);
5154 return EXIT_FAILURE;
5156 for (pi = G.job_list; pi; pi = pi->next) {
5157 if (pi->jobid == jobnum) {
5161 bb_error_msg("%s: %d: no such job", argv[0], jobnum);
5162 return EXIT_FAILURE;
5164 // TODO: bash prints a string representation
5165 // of job being foregrounded (like "sleep 1 | cat")
5166 if (*argv[0] == 'f') {
5167 /* Put the job into the foreground. */
5168 tcsetpgrp(G_interactive_fd, pi->pgrp);
5171 /* Restart the processes in the job */
5172 debug_printf_jobs("reviving %d procs, pgrp %d\n", pi->num_cmds, pi->pgrp);
5173 for (i = 0; i < pi->num_cmds; i++) {
5174 debug_printf_jobs("reviving pid %d\n", pi->cmds[i].pid);
5175 pi->cmds[i].is_stopped = 0;
5177 pi->stopped_cmds = 0;
5179 i = kill(- pi->pgrp, SIGCONT);
5181 if (errno == ESRCH) {
5182 delete_finished_bg_job(pi);
5183 return EXIT_SUCCESS;
5185 bb_perror_msg("kill (SIGCONT)");
5189 if (*argv[0] == 'f') {
5191 return checkjobs_and_fg_shell(pi);
5193 return EXIT_SUCCESS;
5197 #if ENABLE_HUSH_HELP
5198 static int builtin_help(char **argv UNUSED_PARAM)
5200 const struct built_in_command *x;
5202 printf("\nBuilt-in commands:\n");
5203 printf("-------------------\n");
5204 for (x = bltins; x != &bltins[ARRAY_SIZE(bltins)]; x++) {
5205 printf("%s\t%s\n", x->cmd, x->descr);
5208 return EXIT_SUCCESS;
5213 static int builtin_jobs(char **argv UNUSED_PARAM)
5216 const char *status_string;
5218 for (job = G.job_list; job; job = job->next) {
5219 if (job->alive_cmds == job->stopped_cmds)
5220 status_string = "Stopped";
5222 status_string = "Running";
5224 printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->cmdtext);
5226 return EXIT_SUCCESS;
5230 static int builtin_pwd(char **argv UNUSED_PARAM)
5233 return EXIT_SUCCESS;
5236 static int builtin_read(char **argv)
5239 const char *name = argv[1] ? argv[1] : "REPLY";
5241 string = xmalloc_reads(STDIN_FILENO, xasprintf("%s=", name), NULL);
5242 return set_local_var(string, 0);
5245 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#set
5246 * built-in 'set' handler
5248 * set [-abCefhmnuvx] [-o option] [argument...]
5249 * set [+abCefhmnuvx] [+o option] [argument...]
5250 * set -- [argument...]
5253 * Implementations shall support the options in both their hyphen and
5254 * plus-sign forms. These options can also be specified as options to sh.
5256 * Write out all variables and their values: set
5257 * Set $1, $2, and $3 and set "$#" to 3: set c a b
5258 * Turn on the -x and -v options: set -xv
5259 * Unset all positional parameters: set --
5260 * Set $1 to the value of x, even if it begins with '-' or '+': set -- "$x"
5261 * Set the positional parameters to the expansion of x, even if x expands
5262 * with a leading '-' or '+': set -- $x
5264 * So far, we only support "set -- [argument...]" and some of the short names.
5266 static int builtin_set(char **argv)
5269 char **pp, **g_argv;
5270 char *arg = *++argv;
5274 for (e = G.top_var; e; e = e->next)
5276 return EXIT_SUCCESS;
5280 if (!strcmp(arg, "--")) {
5285 if (arg[0] == '+' || arg[0] == '-') {
5286 for (n = 1; arg[n]; ++n)
5287 if (set_mode(arg[0], arg[n]))
5293 } while ((arg = *++argv) != NULL);
5294 /* Now argv[0] is 1st argument */
5296 /* Only reset global_argv if we didn't process anything */
5298 return EXIT_SUCCESS;
5301 /* NB: G.global_argv[0] ($0) is never freed/changed */
5302 g_argv = G.global_argv;
5303 if (G.global_args_malloced) {
5309 G.global_args_malloced = 1;
5310 pp = xzalloc(sizeof(pp[0]) * 2);
5311 pp[0] = g_argv[0]; /* retain $0 */
5314 /* This realloc's G.global_argv */
5315 G.global_argv = pp = add_strings_to_strings(g_argv, argv, /*dup:*/ 1);
5322 return EXIT_SUCCESS;
5324 /* Nothing known, so abort */
5326 bb_error_msg("set: %s: invalid option", arg);
5327 return EXIT_FAILURE;
5330 static int builtin_shift(char **argv)
5336 if (n >= 0 && n < G.global_argc) {
5337 if (G.global_args_malloced) {
5340 free(G.global_argv[m++]);
5343 memmove(&G.global_argv[1], &G.global_argv[n+1],
5344 G.global_argc * sizeof(G.global_argv[0]));
5345 return EXIT_SUCCESS;
5347 return EXIT_FAILURE;
5350 static int builtin_source(char **argv)
5354 if (argv[1] == NULL)
5355 return EXIT_FAILURE;
5357 /* XXX search through $PATH is missing */
5358 input = fopen_for_read(argv[1]);
5360 bb_error_msg("can't open '%s'", argv[1]);
5361 return EXIT_FAILURE;
5363 close_on_exec_on(fileno(input));
5365 /* Now run the file */
5366 /* XXX argv and argc are broken; need to save old G.global_argv
5367 * (pointer only is OK!) on this stack frame,
5368 * set G.global_argv=argv+1, recurse, and restore. */
5369 parse_and_run_file(input);
5371 return G.last_return_code;
5374 static int builtin_umask(char **argv)
5377 const char *arg = argv[1];
5379 new_umask = bb_strtou(arg, NULL, 8);
5381 return EXIT_FAILURE;
5383 new_umask = umask(0);
5384 printf("%.3o\n", (unsigned) new_umask);
5387 return EXIT_SUCCESS;
5390 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#unset */
5391 static int builtin_unset(char **argv)
5398 return EXIT_SUCCESS;
5401 if (argv[1][0] == '-') {
5402 switch (argv[1][1]) {
5404 case 'f': if (ENABLE_HUSH_FUNCTIONS) { var = false; break; }
5406 bb_error_msg("unset: %s: invalid option", argv[1]);
5407 return EXIT_FAILURE;
5415 if (unset_local_var(argv[i]))
5418 #if ENABLE_HUSH_FUNCTIONS
5420 unset_local_func(argv[i]);
5426 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/wait.html */
5427 static int builtin_wait(char **argv)
5429 int ret = EXIT_SUCCESS;
5432 if (*++argv == NULL) {
5433 /* Don't care about wait results */
5434 /* Note 1: must wait until there are no more children */
5435 /* Note 2: must be interruptible */
5437 * $ sleep 3 & sleep 6 & wait
5442 * $ sleep 3 & sleep 6 & wait
5446 * ^C <-- after ~4 sec from keyboard
5449 sigaddset(&G.blocked_set, SIGCHLD);
5450 sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
5453 if (errno == ECHILD)
5455 /* Wait for SIGCHLD or any other signal of interest */
5456 /* sigtimedwait with infinite timeout: */
5457 sig = sigwaitinfo(&G.blocked_set, NULL);
5459 sig = check_and_run_traps(sig);
5460 if (sig && sig != SIGCHLD) { /* see note 2 */
5466 sigdelset(&G.blocked_set, SIGCHLD);
5467 sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
5471 /* This is probably buggy wrt interruptible-ness */
5473 pid_t pid = bb_strtou(*argv, NULL, 10);
5475 /* mimic bash message */
5476 bb_error_msg("wait: '%s': not a pid or valid job spec", *argv);
5477 return EXIT_FAILURE;
5479 if (waitpid(pid, &status, 0) == pid) {
5480 if (WIFSIGNALED(status))
5481 ret = 128 + WTERMSIG(status);
5482 else if (WIFEXITED(status))
5483 ret = WEXITSTATUS(status);
5487 bb_perror_msg("wait %s", *argv);
5496 #if ENABLE_HUSH_LOOPS
5497 static int builtin_break(char **argv)
5499 if (G.depth_of_loop == 0) {
5500 bb_error_msg("%s: only meaningful in a loop", argv[0]);
5501 return EXIT_SUCCESS; /* bash compat */
5503 G.flag_break_continue++; /* BC_BREAK = 1 */
5504 G.depth_break_continue = 1;
5506 G.depth_break_continue = bb_strtou(argv[1], NULL, 10);
5507 if (errno || !G.depth_break_continue || argv[2]) {
5508 bb_error_msg("%s: bad arguments", argv[0]);
5509 G.flag_break_continue = BC_BREAK;
5510 G.depth_break_continue = UINT_MAX;
5513 if (G.depth_of_loop < G.depth_break_continue)
5514 G.depth_break_continue = G.depth_of_loop;
5515 return EXIT_SUCCESS;
5518 static int builtin_continue(char **argv)
5520 G.flag_break_continue = 1; /* BC_CONTINUE = 2 = 1+1 */
5521 return builtin_break(argv);