blob: e0c1fde6bce6480cda0bd4a4889e677b7ee87a37 [file] [log] [blame]
Eric Andersen25f27032001-04-26 23:22:31 +00001/* vi: set sw=4 ts=4: */
2/*
Denis Vlasenko424f79b2009-03-22 14:23:34 +00003 * 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.
Eric Andersen25f27032001-04-26 23:22:31 +00007 *
8 * Copyright (C) 2000,2001 Larry Doolittle <larry@doolittle.boa.org>
9 *
10 * Credits:
11 * The parser routines proper are all original material, first
Eric Andersencb81e642003-07-14 21:21:08 +000012 * 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
Eric Andersenc7bda1c2004-03-15 08:29:22 +000015 * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
Eric Andersencb81e642003-07-14 21:21:08 +000016 * written by Erik Andersen <andersen@codepoet.org>. That, in turn,
17 * is based in part on ladsh.c, by Michael K. Johnson and Erik W.
18 * Troan, which they placed in the public domain. I don't know
19 * how much of the Johnson/Troan code has survived the repeated
20 * rewrites.
21 *
Eric Andersen25f27032001-04-26 23:22:31 +000022 * Other credits:
Denis Vlasenkoa8442002008-06-14 11:00:17 +000023 * o_addchr() derived from similar w_addchar function in glibc-2.2.
Eric Andersen25f27032001-04-26 23:22:31 +000024 * setup_redirect(), redirect_opt_num(), and big chunks of main()
Denis Vlasenko424f79b2009-03-22 14:23:34 +000025 * and many builtins derived from contributions by Erik Andersen.
26 * Miscellaneous bugfixes from Matt Kraai.
Eric Andersen25f27032001-04-26 23:22:31 +000027 *
28 * There are two big (and related) architecture differences between
29 * this parser and the lash parser. One is that this version is
30 * actually designed from the ground up to understand nearly all
31 * of the Bourne grammar. The second, consequential change is that
32 * the parser and input reader have been turned inside out. Now,
33 * the parser is in control, and asks for input as needed. The old
34 * way had the input reader in control, and it asked for parsing to
35 * take place as needed. The new way makes it much easier to properly
36 * handle the recursion implicit in the various substitutions, especially
37 * across continuation lines.
38 *
Mike Frysinger25a6ca02009-03-28 13:59:26 +000039 * POSIX syntax not implemented:
Eric Andersen78a7c992001-05-15 16:30:25 +000040 * aliases
Eric Andersen25f27032001-04-26 23:22:31 +000041 * <(list) and >(list) Process Substitution
Eric Andersen25f27032001-04-26 23:22:31 +000042 * Here Documents ( << word )
43 * Functions
Mike Frysinger25a6ca02009-03-28 13:59:26 +000044 * Tilde Expansion
Mike Frysinger6379bb42009-03-28 18:55:03 +000045 * Parameter Expansion for substring processing ${var#word} ${var%word}
Mike Frysinger25a6ca02009-03-28 13:59:26 +000046 *
47 * Bash stuff maybe optional enable:
48 * &> and >& redirection of stdout+stderr
49 * Brace expansion
50 * reserved words: [[ ]] function select
Mike Frysinger6379bb42009-03-28 18:55:03 +000051 * substrings ${var:1:5}
Mike Frysinger25a6ca02009-03-28 13:59:26 +000052 *
Eric Andersen25f27032001-04-26 23:22:31 +000053 * Major bugs:
Denis Vlasenkob81b3df2007-04-28 16:48:04 +000054 * job handling woefully incomplete and buggy (improved --vda)
Eric Andersen25f27032001-04-26 23:22:31 +000055 * to-do:
Eric Andersen83a2ae22001-05-07 17:59:25 +000056 * port selected bugfixes from post-0.49 busybox lash - done?
Eric Andersen83a2ae22001-05-07 17:59:25 +000057 * change { and } from special chars to reserved words
Denis Vlasenkobcb25532008-07-28 23:04:34 +000058 * builtins: return, trap, ulimit
Denis Vlasenkoafd7a8d2008-10-09 16:29:44 +000059 * test magic exec with redirection only
Eric Andersen25f27032001-04-26 23:22:31 +000060 * follow IFS rules more precisely, including update semantics
Eric Andersen25f27032001-04-26 23:22:31 +000061 * figure out what to do with backslash-newline
Eric Andersen25f27032001-04-26 23:22:31 +000062 * propagate syntax errors, die on resource errors?
63 * continuation lines, both explicit and implicit - done?
Denis Vlasenko8f6bdb42007-05-16 09:36:55 +000064 * maybe change charmap[] to use 2-bit entries
Eric Andersen25f27032001-04-26 23:22:31 +000065 *
Bernhard Reutner-Fischer86f5c992006-01-22 22:55:11 +000066 * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
Eric Andersen25f27032001-04-26 23:22:31 +000067 */
Bernhard Reutner-Fischere15d7572006-06-02 20:56:16 +000068
Denis Vlasenko1aa7e472007-11-28 06:49:03 +000069#include "busybox.h" /* for APPLET_IS_NOFORK/NOEXEC */
Denis Vlasenko424f79b2009-03-22 14:23:34 +000070//TODO: pull in some .h and find out whether we have SINGLE_APPLET_MAIN?
Denis Vlasenko61befda2008-11-25 01:36:03 +000071//#include "applet_tables.h" doesn't work
Denis Vlasenkobe709c22008-07-28 00:01:16 +000072#include <glob.h>
73/* #include <dmalloc.h> */
74#if ENABLE_HUSH_CASE
75#include <fnmatch.h>
76#endif
Denis Vlasenko17f02e72008-07-14 04:32:29 +000077
Mike Frysinger98c52642009-04-02 10:02:37 +000078#include "math.h"
79
Denis Vlasenko424f79b2009-03-22 14:23:34 +000080#define HUSH_VER_STR "0.92"
Denis Vlasenkod01ff132007-05-02 21:40:23 +000081
Denis Vlasenko61befda2008-11-25 01:36:03 +000082#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__
91#endif
92
Denis Vlasenko05743d72008-02-10 12:10:08 +000093#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().
99#endif
100
Denis Vlasenko05743d72008-02-10 12:10:08 +0000101#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
Denis Vlasenko8412d792007-10-01 09:59:47 +0000106#endif
107
Denis Vlasenko424f79b2009-03-22 14:23:34 +0000108/* 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(...)
113#else
114#define HAS_KEYWORDS 0
115#define IF_HAS_KEYWORDS(...)
116#define IF_HAS_NO_KEYWORDS(...) __VA_ARGS__
117#endif
Denis Vlasenko8412d792007-10-01 09:59:47 +0000118
Denis Vlasenko371de4a2008-10-14 12:43:13 +0000119/* Keep unconditionally on for now */
120#define HUSH_DEBUG 1
121/* In progress... */
122#define ENABLE_HUSH_FUNCTIONS 0
123
124
Denis Vlasenkod01ff132007-05-02 21:40:23 +0000125/* If you comment out one of these below, it will be #defined later
126 * to perform debug printfs to stderr: */
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +0000127#define debug_printf(...) do {} while (0)
Denis Vlasenko400c5b62007-05-04 13:07:27 +0000128/* Finer-grained debug switches */
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +0000129#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)
Denis Vlasenkof886fd22008-10-13 12:36:05 +0000132#define debug_printf_env(...) do {} while (0)
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +0000133#define debug_printf_jobs(...) do {} while (0)
134#define debug_printf_expand(...) do {} while (0)
Denis Vlasenkob61e13d2008-06-17 05:11:43 +0000135#define debug_printf_glob(...) do {} while (0)
136#define debug_printf_list(...) do {} while (0)
Denis Vlasenko30c9cc52008-06-17 07:24:29 +0000137#define debug_printf_subst(...) do {} while (0)
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +0000138#define debug_printf_clean(...) do {} while (0)
Denis Vlasenkod01ff132007-05-02 21:40:23 +0000139
140#ifndef debug_printf
141#define debug_printf(...) fprintf(stderr, __VA_ARGS__)
Denis Vlasenkod01ff132007-05-02 21:40:23 +0000142#endif
Denis Vlasenkod01ff132007-05-02 21:40:23 +0000143
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +0000144#ifndef debug_printf_parse
145#define debug_printf_parse(...) fprintf(stderr, __VA_ARGS__)
Denis Vlasenkod01ff132007-05-02 21:40:23 +0000146#endif
147
148#ifndef debug_printf_exec
149#define debug_printf_exec(...) fprintf(stderr, __VA_ARGS__)
150#endif
151
Denis Vlasenkof886fd22008-10-13 12:36:05 +0000152#ifndef debug_printf_env
153#define debug_printf_env(...) fprintf(stderr, __VA_ARGS__)
154#endif
155
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +0000156#ifndef debug_printf_jobs
157#define debug_printf_jobs(...) fprintf(stderr, __VA_ARGS__)
Denis Vlasenkob61e13d2008-06-17 05:11:43 +0000158#define DEBUG_JOBS 1
159#else
160#define DEBUG_JOBS 0
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +0000161#endif
162
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +0000163#ifndef debug_printf_expand
164#define debug_printf_expand(...) fprintf(stderr, __VA_ARGS__)
165#define DEBUG_EXPAND 1
Denis Vlasenkob61e13d2008-06-17 05:11:43 +0000166#else
167#define DEBUG_EXPAND 0
168#endif
169
170#ifndef debug_printf_glob
171#define debug_printf_glob(...) fprintf(stderr, __VA_ARGS__)
172#define DEBUG_GLOB 1
173#else
174#define DEBUG_GLOB 0
175#endif
176
177#ifndef debug_printf_list
178#define debug_printf_list(...) fprintf(stderr, __VA_ARGS__)
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +0000179#endif
180
Denis Vlasenko30c9cc52008-06-17 07:24:29 +0000181#ifndef debug_printf_subst
182#define debug_printf_subst(...) fprintf(stderr, __VA_ARGS__)
183#endif
184
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +0000185#ifndef debug_printf_clean
186/* broken, of course, but OK for testing */
187static const char *indenter(int i)
188{
Denis Vlasenko6ca409e2007-08-12 20:58:27 +0000189 static const char blanks[] ALIGN1 =
190 " ";
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +0000191 return &blanks[sizeof(blanks) - i - 1];
192}
193#define debug_printf_clean(...) fprintf(stderr, __VA_ARGS__)
Denis Vlasenkoc666f712007-05-16 22:18:54 +0000194#define DEBUG_CLEAN 1
Denis Vlasenkoe725bfe2007-05-03 22:45:39 +0000195#endif
196
Denis Vlasenkob61e13d2008-06-17 05:11:43 +0000197#if DEBUG_EXPAND
198static void debug_print_strings(const char *prefix, char **vv)
199{
200 fprintf(stderr, "%s:\n", prefix);
201 while (*vv)
202 fprintf(stderr, " '%s'\n", *vv++);
203}
204#else
205#define debug_print_strings(prefix, vv) ((void)0)
206#endif
207
Denis Vlasenkof962a032007-11-23 12:50:54 +0000208/*
209 * Leak hunting. Use hush_leaktool.sh for post-processing.
210 */
211#ifdef FOR_HUSH_LEAKTOOL
Denis Vlasenkoccce59d2008-06-16 14:35:57 +0000212/* suppress "warning: no previous prototype..." */
213void *xxmalloc(int lineno, size_t size);
214void *xxrealloc(int lineno, void *ptr, size_t size);
215char *xxstrdup(int lineno, const char *str);
216void xxfree(void *ptr);
Denis Vlasenkof962a032007-11-23 12:50:54 +0000217void *xxmalloc(int lineno, size_t size)
218{
219 void *ptr = xmalloc((size + 0xff) & ~0xff);
Denis Vlasenkob6e65562009-04-03 16:49:04 +0000220 fdprintf(2, "line %d: malloc %p\n", lineno, ptr);
Denis Vlasenkof962a032007-11-23 12:50:54 +0000221 return ptr;
222}
223void *xxrealloc(int lineno, void *ptr, size_t size)
224{
225 ptr = xrealloc(ptr, (size + 0xff) & ~0xff);
Denis Vlasenkob6e65562009-04-03 16:49:04 +0000226 fdprintf(2, "line %d: realloc %p\n", lineno, ptr);
Denis Vlasenkof962a032007-11-23 12:50:54 +0000227 return ptr;
228}
229char *xxstrdup(int lineno, const char *str)
230{
231 char *ptr = xstrdup(str);
Denis Vlasenkob6e65562009-04-03 16:49:04 +0000232 fdprintf(2, "line %d: strdup %p\n", lineno, ptr);
Denis Vlasenkof962a032007-11-23 12:50:54 +0000233 return ptr;
234}
235void xxfree(void *ptr)
236{
Denis Vlasenkob6e65562009-04-03 16:49:04 +0000237 fdprintf(2, "free %p\n", ptr);
Denis Vlasenkof962a032007-11-23 12:50:54 +0000238 free(ptr);
239}
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)
244#endif
245
246
Denis Vlasenkob6e65562009-04-03 16:49:04 +0000247#define ERR_PTR ((void*)(long)1)
248
Denis Vlasenko424f79b2009-03-22 14:23:34 +0000249static const char hush_version_str[] ALIGN1 = "HUSH_VERSION="HUSH_VER_STR;
Denis Vlasenko5ec61322008-06-24 00:50:07 +0000250
Denis Vlasenko424f79b2009-03-22 14:23:34 +0000251#define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
Denis Vlasenko5ec61322008-06-24 00:50:07 +0000252
Denis Vlasenkob6e65562009-04-03 16:49:04 +0000253#define SPECIAL_VAR_SYMBOL 3
Eric Andersen25f27032001-04-26 23:22:31 +0000254
Denis Vlasenkobcb25532008-07-28 23:04:34 +0000255typedef enum redir_type {
Eric Andersen25f27032001-04-26 23:22:31 +0000256 REDIRECT_INPUT = 1,
257 REDIRECT_OVERWRITE = 2,
258 REDIRECT_APPEND = 3,
259 REDIRECT_HEREIS = 4,
260 REDIRECT_IO = 5
261} redir_type;
262
Denis Vlasenko55789c62008-06-18 16:30:42 +0000263/* The descrip member of this structure is only used to make
264 * debugging output pretty */
Denis Vlasenkofbf6dea2007-04-13 19:56:56 +0000265static const struct {
266 int mode;
Denis Vlasenkoef36ead2007-05-02 15:34:47 +0000267 signed char default_fd;
268 char descrip[3];
Denis Vlasenkofbf6dea2007-04-13 19:56:56 +0000269} redir_table[] = {
Eric Andersen25f27032001-04-26 23:22:31 +0000270 { 0, 0, "()" },
271 { O_RDONLY, 0, "<" },
272 { O_CREAT|O_TRUNC|O_WRONLY, 1, ">" },
273 { O_CREAT|O_APPEND|O_WRONLY, 1, ">>" },
274 { O_RDONLY, -1, "<<" },
275 { O_RDWR, 1, "<>" }
276};
277
Denis Vlasenkobcb25532008-07-28 23:04:34 +0000278typedef enum pipe_style {
Eric Andersen25f27032001-04-26 23:22:31 +0000279 PIPE_SEQ = 1,
280 PIPE_AND = 2,
281 PIPE_OR = 3,
282 PIPE_BG = 4,
283} pipe_style;
284
Denis Vlasenkobcb25532008-07-28 23:04:34 +0000285typedef enum reserved_style {
Eric Andersen25f27032001-04-26 23:22:31 +0000286 RES_NONE = 0,
Denis Vlasenko06810332007-05-21 23:30:54 +0000287#if ENABLE_HUSH_IF
Denis Vlasenko17f02e72008-07-14 04:32:29 +0000288 RES_IF ,
289 RES_THEN ,
290 RES_ELIF ,
291 RES_ELSE ,
292 RES_FI ,
Denis Vlasenko06810332007-05-21 23:30:54 +0000293#endif
294#if ENABLE_HUSH_LOOPS
Denis Vlasenko17f02e72008-07-14 04:32:29 +0000295 RES_FOR ,
296 RES_WHILE ,
297 RES_UNTIL ,
298 RES_DO ,
299 RES_DONE ,
Denis Vlasenkod91afa32008-07-29 11:10:01 +0000300#endif
301#if ENABLE_HUSH_LOOPS || ENABLE_HUSH_CASE
Denis Vlasenko17f02e72008-07-14 04:32:29 +0000302 RES_IN ,
Denis Vlasenko06810332007-05-21 23:30:54 +0000303#endif
Denis Vlasenko17f02e72008-07-14 04:32:29 +0000304#if ENABLE_HUSH_CASE
305 RES_CASE ,
306 /* two pseudo-keywords support contrived "case" syntax: */
307 RES_MATCH , /* "word)" */
308 RES_CASEI , /* "this command is inside CASE" */
309 RES_ESAC ,
310#endif
311 RES_XXXX ,
312 RES_SNTX
Eric Andersen25f27032001-04-26 23:22:31 +0000313} reserved_style;
Denis Vlasenkoc7985b72008-06-17 05:43:38 +0000314
Eric Andersen25f27032001-04-26 23:22:31 +0000315struct redir_struct {
Denis Vlasenko55789c62008-06-18 16:30:42 +0000316 struct redir_struct *next;
Denis Vlasenko5ec61322008-06-24 00:50:07 +0000317 char *rd_filename; /* filename */
Denis Vlasenko0c886c62007-01-30 22:30:09 +0000318 int fd; /* file descriptor being redirected */
319 int dup; /* -1, or file descriptor being duplicated */
Denis Vlasenko5ec61322008-06-24 00:50:07 +0000320 smallint /*enum redir_type*/ rd_type;
Eric Andersen25f27032001-04-26 23:22:31 +0000321};
322
Denis Vlasenko9af22c72008-10-09 12:54:58 +0000323struct command {
Denis Vlasenko0c886c62007-01-30 22:30:09 +0000324 pid_t pid; /* 0 if exited */
Denis Vlasenko2b576b82008-08-04 00:46:07 +0000325 int assignment_cnt; /* how many argv[i] are assignments? */
Denis Vlasenko9af22c72008-10-09 12:54:58 +0000326 smallint is_stopped; /* is the command currently running? */
Denis Vlasenko424f79b2009-03-22 14:23:34 +0000327 smallint grp_type; /* GRP_xxx */
Denis Vlasenko2b576b82008-08-04 00:46:07 +0000328 struct pipe *group; /* if non-NULL, this "prog" is {} group,
329 * subshell, or a compound statement */
Denis Vlasenko9af22c72008-10-09 12:54:58 +0000330 char **argv; /* command name and arguments */
Denis Vlasenko0c886c62007-01-30 22:30:09 +0000331 struct redir_struct *redirects; /* I/O redirections */
Eric Andersen25f27032001-04-26 23:22:31 +0000332};
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +0000333/* 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 .$*.
Denis Vlasenkoc7985b72008-06-17 05:43:38 +0000337 * References of the form ^C`cmd arg^C are `cmd arg` substitutions.
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +0000338 */
Denis Vlasenko371de4a2008-10-14 12:43:13 +0000339#define GRP_NORMAL 0
340#define GRP_SUBSHELL 1
341#if ENABLE_HUSH_FUNCTIONS
342#define GRP_FUNCTION 2
343#endif
Eric Andersen25f27032001-04-26 23:22:31 +0000344
345struct pipe {
Denis Vlasenkob81b3df2007-04-28 16:48:04 +0000346 struct pipe *next;
Denis Vlasenko9af22c72008-10-09 12:54:58 +0000347 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 */
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +0000350#if ENABLE_HUSH_JOB
Denis Vlasenkob81b3df2007-04-28 16:48:04 +0000351 int jobid; /* job number */
Denis Vlasenko0c886c62007-01-30 22:30:09 +0000352 pid_t pgrp; /* process group ID for the job */
Denis Vlasenko219e88d2007-05-21 10:18:23 +0000353 char *cmdtext; /* name of job */
Denis Vlasenkob81b3df2007-04-28 16:48:04 +0000354#endif
Denis Vlasenko9af22c72008-10-09 12:54:58 +0000355 struct command *cmds; /* array of commands in pipe */
Denis Vlasenko219e88d2007-05-21 10:18:23 +0000356 smallint followup; /* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */
Denis Vlasenko5ec61322008-06-24 00:50:07 +0000357 IF_HAS_KEYWORDS(smallint pi_inverted;) /* "! cmd | cmd" */
358 IF_HAS_KEYWORDS(smallint res_word;) /* needed for if, for, while, until... */
Eric Andersen25f27032001-04-26 23:22:31 +0000359};
360
Denis Vlasenko9af22c72008-10-09 12:54:58 +0000361/* This holds pointers to the various results of parsing */
362struct parse_context {
Denis Vlasenkof9f74292009-04-03 00:07:05 +0000363 /* linked list of pipes */
Denis Vlasenko9af22c72008-10-09 12:54:58 +0000364 struct pipe *list_head;
Denis Vlasenkof9f74292009-04-03 00:07:05 +0000365 /* last pipe (being constructed right now) */
Denis Vlasenko9af22c72008-10-09 12:54:58 +0000366 struct pipe *pipe;
Denis Vlasenkof9f74292009-04-03 00:07:05 +0000367 /* last command in pipe (being constructed right now) */
368 struct command *command;
369 /* last redirect in command->redirects list */
Denis Vlasenko9af22c72008-10-09 12:54:58 +0000370 struct redir_struct *pending_redirect;
371#if HAS_KEYWORDS
372 smallint ctx_res_w;
373 smallint ctx_inverted; /* "! cmd | cmd" */
374#if ENABLE_HUSH_CASE
375 smallint ctx_dsemicolon; /* ";;" seen */
376#endif
Denis Vlasenkof9f74292009-04-03 00:07:05 +0000377 /* bitmask of FLAG_xxx, for figuring out valid reserved words */
378 int old_flag;
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.
385 */
Denis Vlasenko9af22c72008-10-09 12:54:58 +0000386 struct parse_context *stack;
387#endif
388};
389
Denis Vlasenkod76c0492007-05-25 02:16:25 +0000390/* 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()
396struct variable {
397 struct variable *next;
Denis Vlasenko28c0f0f2007-05-25 02:46:01 +0000398 char *varstr; /* points to "name=" portion */
Denis Vlasenkod76c0492007-05-25 02:16:25 +0000399 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 */
Denis Vlasenko219e88d2007-05-21 10:18:23 +0000401 smallint flg_read_only;
Eric Andersen9ffb7dd2001-05-19 03:00:46 +0000402};
403
Denis Vlasenkobcb25532008-07-28 23:04:34 +0000404typedef struct o_string {
Eric Andersen25f27032001-04-26 23:22:31 +0000405 char *data;
Denis Vlasenko17f02e72008-07-14 04:32:29 +0000406 int length; /* position where data is appended */
Eric Andersen25f27032001-04-26 23:22:31 +0000407 int maxlen;
Denis Vlasenkob7aaae92009-04-02 20:17:49 +0000408 /* Protect newly added chars against globbing
409 * (by prepending \ to *, ?, [, \) */
410 smallint o_escape;
Denis Vlasenkob61e13d2008-06-17 05:11:43 +0000411 smallint o_glob;
Denis Vlasenkoff097622007-10-01 10:00:45 +0000412 smallint nonnull;
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +0000413 smallint has_empty_slot;
Denis Vlasenko55789c62008-06-18 16:30:42 +0000414 smallint o_assignment; /* 0:maybe, 1:yes, 2:no */
Eric Andersen25f27032001-04-26 23:22:31 +0000415} o_string;
Denis Vlasenko55789c62008-06-18 16:30:42 +0000416enum {
417 MAYBE_ASSIGNMENT = 0,
418 DEFINITELY_ASSIGNMENT = 1,
419 NOT_ASSIGNMENT = 2,
Denis Vlasenko2b576b82008-08-04 00:46:07 +0000420 WORD_IS_KEYWORD = 3, /* not assigment, but next word may be: "if v=xyz cmd;" */
Denis Vlasenko55789c62008-06-18 16:30:42 +0000421};
Denis Vlasenkoc7985b72008-06-17 05:43:38 +0000422/* Used for initialization: o_string foo = NULL_O_STRING; */
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +0000423#define NULL_O_STRING { NULL }
Eric Andersen25f27032001-04-26 23:22:31 +0000424
Denis Vlasenkobcb25532008-07-28 23:04:34 +0000425/* I can almost use ordinary FILE*. Is open_memstream() universally
Eric Andersen25f27032001-04-26 23:22:31 +0000426 * available? Where is it documented? */
Denis Vlasenkobcb25532008-07-28 23:04:34 +0000427typedef struct in_str {
Denis Vlasenko3e9aaae2007-05-11 12:56:43 +0000428 const char *p;
429 /* eof_flag=1: last char in ->p is really an EOF */
430 char eof_flag; /* meaningless if ->p == NULL */
431 char peek_buf[2];
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +0000432#if ENABLE_HUSH_INTERACTIVE
Denis Vlasenko5a1437d2007-05-24 13:22:47 +0000433 smallint promptme;
434 smallint promptmode; /* 0: PS1, 1: PS2 */
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +0000435#endif
Eric Andersen25f27032001-04-26 23:22:31 +0000436 FILE *file;
437 int (*get) (struct in_str *);
438 int (*peek) (struct in_str *);
Denis Vlasenkobcb25532008-07-28 23:04:34 +0000439} in_str;
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +0000440#define i_getch(input) ((input)->get(input))
441#define i_peek(input) ((input)->peek(input))
Eric Andersen25f27032001-04-26 23:22:31 +0000442
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +0000443enum {
444 CHAR_ORDINARY = 0,
445 CHAR_ORDINARY_IF_QUOTED = 1, /* example: *, # */
446 CHAR_IFS = 2, /* treated as ordinary if quoted */
Denis Vlasenkof328e002009-04-02 16:55:38 +0000447 CHAR_SPECIAL = 3, /* \, $, ", maybe ` */
Eric Andersen25f27032001-04-26 23:22:31 +0000448};
449
Denis Vlasenkobcb25532008-07-28 23:04:34 +0000450enum {
451 BC_BREAK = 1,
452 BC_CONTINUE = 2,
453};
454
Denis Vlasenkod76c0492007-05-25 02:16:25 +0000455
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +0000456/* "Globals" within this file */
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +0000457/* Sorted roughly by size (smaller offsets == smaller code) */
458struct globals {
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 */
462 int interactive_fd;
463 const char *PS1;
464 const char *PS2;
465#endif
466#if ENABLE_FEATURE_EDITING
467 line_input_t *line_input_state;
468#endif
Denis Vlasenkocc3f20b2008-06-23 22:31:52 +0000469 pid_t root_pid;
Denis Vlasenko87a86552008-07-29 19:43:10 +0000470 pid_t last_bg_pid;
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +0000471#if ENABLE_HUSH_JOB
472 int run_list_level;
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +0000473 pid_t saved_tty_pgrp;
474 int last_jobid;
475 struct pipe *job_list;
476 struct pipe *toplevel_list;
Denis Vlasenkod5762932009-03-31 11:22:57 +0000477//// smallint ctrl_z_flag;
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +0000478#endif
Denis Vlasenko422cd7c2009-03-31 12:41:52 +0000479 smallint flag_SIGINT;
Denis Vlasenkodadfb492008-07-29 10:16:05 +0000480#if ENABLE_HUSH_LOOPS
Denis Vlasenkobcb25532008-07-28 23:04:34 +0000481 smallint flag_break_continue;
Denis Vlasenkodadfb492008-07-29 10:16:05 +0000482#endif
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +0000483 smallint fake_mode;
Denis Vlasenkod5762932009-03-31 11:22:57 +0000484 /* These four support $?, $#, and $1 */
Denis Vlasenko5e052ca2008-07-28 15:15:09 +0000485 smalluint last_return_code;
Denis Vlasenkoe1300f62009-03-22 11:41:18 +0000486 /* is global_argv and global_argv[1..n] malloced? (note: not [0]) */
Denis Vlasenko11fb7cf2009-03-20 10:13:08 +0000487 smalluint global_args_malloced;
Denis Vlasenkoe1300f62009-03-22 11:41:18 +0000488 /* how many non-NULL argv's we have. NB: $# + 1 */
489 int global_argc;
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +0000490 char **global_argv;
Denis Vlasenkodadfb492008-07-29 10:16:05 +0000491#if ENABLE_HUSH_LOOPS
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +0000492 unsigned depth_break_continue;
Denis Vlasenkofcf37c32008-07-29 11:37:15 +0000493 unsigned depth_of_loop;
Denis Vlasenkodadfb492008-07-29 10:16:05 +0000494#endif
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +0000495 const char *ifs;
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +0000496 const char *cwd;
Denis Vlasenko87a86552008-07-29 19:43:10 +0000497 struct variable *top_var; /* = &G.shell_ver (set in main()) */
Denis Vlasenko0a83fc32007-05-25 11:12:32 +0000498 struct variable shell_ver;
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +0000499#if ENABLE_FEATURE_SH_STANDALONE
500 struct nofork_save_area nofork_save;
501#endif
502#if ENABLE_HUSH_JOB
503 sigjmp_buf toplevel_jb;
504#endif
505 unsigned char charmap[256];
506 char user_input_buf[ENABLE_FEATURE_EDITING ? BUFSIZ : 2];
Denis Vlasenkod5762932009-03-31 11:22:57 +0000507 /* Signal and trap handling */
Denis Vlasenko7566bae2009-03-31 17:24:49 +0000508// unsigned count_SIGCHLD;
509// unsigned handled_SIGCHLD;
Denis Vlasenkod5762932009-03-31 11:22:57 +0000510 /* which signals have non-DFL handler (even with no traps set)? */
511 unsigned non_DFL_mask;
Denis Vlasenko7566bae2009-03-31 17:24:49 +0000512 char **traps; /* char *traps[NSIG] */
Denis Vlasenkod5762932009-03-31 11:22:57 +0000513 sigset_t blocked_set;
514 sigset_t inherited_set;
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +0000515};
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +0000516#define G (*ptr_to_globals)
Denis Vlasenko87a86552008-07-29 19:43:10 +0000517/* Not #defining name to G.name - this quickly gets unwieldy
518 * (too many defines). Also, I actually prefer to see when a variable
519 * is global, thus "G." prefix is a useful hint */
Denis Vlasenko574f2f42008-02-27 18:41:59 +0000520#define INIT_G() do { \
521 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
522} while (0)
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +0000523
524
Denis Vlasenko424f79b2009-03-22 14:23:34 +0000525/* Function prototypes for builtins */
526static int builtin_cd(char **argv);
527static int builtin_echo(char **argv);
528static int builtin_eval(char **argv);
529static int builtin_exec(char **argv);
530static int builtin_exit(char **argv);
531static int builtin_export(char **argv);
532#if ENABLE_HUSH_JOB
533static int builtin_fg_bg(char **argv);
534static int builtin_jobs(char **argv);
535#endif
536#if ENABLE_HUSH_HELP
537static int builtin_help(char **argv);
538#endif
539static int builtin_pwd(char **argv);
540static int builtin_read(char **argv);
541static int builtin_test(char **argv);
Mike Frysinger9f8128f2009-03-29 23:49:37 +0000542static int builtin_trap(char **argv);
Denis Vlasenko424f79b2009-03-22 14:23:34 +0000543static int builtin_true(char **argv);
544static int builtin_set(char **argv);
545static int builtin_shift(char **argv);
546static int builtin_source(char **argv);
547static int builtin_umask(char **argv);
548static int builtin_unset(char **argv);
Mike Frysinger56bdea12009-03-28 20:01:58 +0000549static int builtin_wait(char **argv);
Denis Vlasenko424f79b2009-03-22 14:23:34 +0000550#if ENABLE_HUSH_LOOPS
551static int builtin_break(char **argv);
552static int builtin_continue(char **argv);
553#endif
554//static int builtin_not_written(char **argv);
555
556/* Table of built-in functions. They can be forked or not, depending on
557 * context: within pipes, they fork. As simple commands, they do not.
558 * When used in non-forking context, they can change global variables
559 * in the parent shell process. If forked, of course they cannot.
560 * For example, 'unset foo | whatever' will parse and run, but foo will
561 * still be set at the end. */
562struct built_in_command {
563 const char *cmd;
564 int (*function)(char **argv);
565#if ENABLE_HUSH_HELP
566 const char *descr;
567#define BLTIN(cmd, func, help) { cmd, func, help }
568#else
569#define BLTIN(cmd, func, help) { cmd, func }
570#endif
571};
572
573/* For now, echo and test are unconditionally enabled.
574 * Maybe make it configurable? */
575static const struct built_in_command bltins[] = {
576 BLTIN("." , builtin_source, "Run commands in a file"),
577 BLTIN(":" , builtin_true, "No-op"),
578 BLTIN("[" , builtin_test, "Test condition"),
Denis Vlasenko424f79b2009-03-22 14:23:34 +0000579#if ENABLE_HUSH_JOB
580 BLTIN("bg" , builtin_fg_bg, "Resume a job in the background"),
581#endif
582#if ENABLE_HUSH_LOOPS
583 BLTIN("break" , builtin_break, "Exit from a loop"),
584#endif
585 BLTIN("cd" , builtin_cd, "Change directory"),
586#if ENABLE_HUSH_LOOPS
587 BLTIN("continue", builtin_continue, "Start new loop iteration"),
588#endif
589 BLTIN("echo" , builtin_echo, "Write to stdout"),
590 BLTIN("eval" , builtin_eval, "Construct and run shell command"),
591 BLTIN("exec" , builtin_exec, "Execute command, don't return to shell"),
592 BLTIN("exit" , builtin_exit, "Exit"),
593 BLTIN("export", builtin_export, "Set environment variable"),
594#if ENABLE_HUSH_JOB
595 BLTIN("fg" , builtin_fg_bg, "Bring job into the foreground"),
596 BLTIN("jobs" , builtin_jobs, "List active jobs"),
597#endif
598 BLTIN("pwd" , builtin_pwd, "Print current directory"),
599 BLTIN("read" , builtin_read, "Input environment variable"),
600// BLTIN("return", builtin_not_written, "Return from a function"),
601 BLTIN("set" , builtin_set, "Set/unset shell local variables"),
602 BLTIN("shift" , builtin_shift, "Shift positional parameters"),
Denis Vlasenko424f79b2009-03-22 14:23:34 +0000603 BLTIN("test" , builtin_test, "Test condition"),
Mike Frysinger9f8128f2009-03-29 23:49:37 +0000604 BLTIN("trap" , builtin_trap, "Trap signals"),
Denis Vlasenko424f79b2009-03-22 14:23:34 +0000605// BLTIN("ulimit", builtin_not_written, "Control resource limits"),
606 BLTIN("umask" , builtin_umask, "Set file creation mask"),
607 BLTIN("unset" , builtin_unset, "Unset environment variable"),
Mike Frysinger56bdea12009-03-28 20:01:58 +0000608 BLTIN("wait" , builtin_wait, "Wait for process"),
Denis Vlasenko424f79b2009-03-22 14:23:34 +0000609#if ENABLE_HUSH_HELP
610 BLTIN("help" , builtin_help, "List shell built-in commands"),
611#endif
612};
613
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +0000614
Denis Vlasenko90e485c2007-05-23 15:22:50 +0000615/* Normal */
Mike Frysinger6379bb42009-03-28 18:55:03 +0000616static void maybe_die(const char *notice, const char *msg)
Denis Vlasenko90e485c2007-05-23 15:22:50 +0000617{
Denis Vlasenko5a1437d2007-05-24 13:22:47 +0000618 /* Was using fancy stuff:
Denis Vlasenko87a86552008-07-29 19:43:10 +0000619 * (G.interactive_fd ? bb_error_msg : bb_error_msg_and_die)(...params...)
Denis Vlasenko5a1437d2007-05-24 13:22:47 +0000620 * but it SEGVs. ?! Oh well... explicit temp ptr works around that */
Mike Frysinger6379bb42009-03-28 18:55:03 +0000621 void FAST_FUNC (*fp)(const char *s, ...) = bb_error_msg_and_die;
622#if ENABLE_HUSH_INTERACTIVE
Denis Vlasenko87a86552008-07-29 19:43:10 +0000623 fp = (G.interactive_fd ? bb_error_msg : bb_error_msg_and_die);
Denis Vlasenko87a86552008-07-29 19:43:10 +0000624#endif
Mike Frysinger6379bb42009-03-28 18:55:03 +0000625 fp(msg ? "%s: %s" : notice, notice, msg);
626}
Mike Frysinger5a828452009-03-28 19:09:04 +0000627#if 1
628#define syntax(msg) maybe_die("syntax error", msg);
Denis Vlasenko90e485c2007-05-23 15:22:50 +0000629#else
Mike Frysinger5a828452009-03-28 19:09:04 +0000630/* Debug -- trick gcc to expand __LINE__ and convert to string */
631#define __syntax(msg, line) maybe_die("syntax error hush.c:" # line, msg)
632#define _syntax(msg, line) __syntax(msg, line)
633#define syntax(msg) _syntax(msg, __LINE__)
Denis Vlasenko90e485c2007-05-23 15:22:50 +0000634#endif
Eric Andersen25f27032001-04-26 23:22:31 +0000635
Denis Vlasenkob61e13d2008-06-17 05:11:43 +0000636static int glob_needed(const char *s)
637{
638 while (*s) {
639 if (*s == '\\')
640 s++;
641 if (*s == '*' || *s == '[' || *s == '?')
642 return 1;
643 s++;
644 }
645 return 0;
646}
647
Denis Vlasenko30c9cc52008-06-17 07:24:29 +0000648static int is_assignment(const char *s)
649{
Denis Vlasenkod4981312008-07-31 10:34:48 +0000650 if (!s || !(isalpha(*s) || *s == '_'))
Denis Vlasenko30c9cc52008-06-17 07:24:29 +0000651 return 0;
652 s++;
653 while (isalnum(*s) || *s == '_')
654 s++;
655 return *s == '=';
656}
657
Denis Vlasenko55789c62008-06-18 16:30:42 +0000658/* Replace each \x with x in place, return ptr past NUL. */
659static char *unbackslash(char *src)
660{
661 char *dst = src;
662 while (1) {
663 if (*src == '\\')
664 src++;
665 if ((*dst++ = *src++) == '\0')
666 break;
667 }
668 return dst;
669}
670
Denis Vlasenko11fb7cf2009-03-20 10:13:08 +0000671static char **add_strings_to_strings(char **strings, char **add, int need_to_dup)
Denis Vlasenkod65ea392007-10-01 10:02:25 +0000672{
673 int i;
674 unsigned count1;
675 unsigned count2;
676 char **v;
677
678 v = strings;
679 count1 = 0;
680 if (v) {
681 while (*v) {
682 count1++;
683 v++;
684 }
685 }
686 count2 = 0;
687 v = add;
688 while (*v) {
689 count2++;
690 v++;
691 }
692 v = xrealloc(strings, (count1 + count2 + 1) * sizeof(char*));
693 v[count1 + count2] = NULL;
694 i = count2;
695 while (--i >= 0)
Denis Vlasenko11fb7cf2009-03-20 10:13:08 +0000696 v[count1 + i] = (need_to_dup ? xstrdup(add[i]) : add[i]);
Denis Vlasenkod65ea392007-10-01 10:02:25 +0000697 return v;
698}
699
Denis Vlasenko22d10a02008-10-13 08:53:43 +0000700static char **add_string_to_strings(char **strings, char *add)
Denis Vlasenkod65ea392007-10-01 10:02:25 +0000701{
702 char *v[2];
Denis Vlasenkod65ea392007-10-01 10:02:25 +0000703 v[0] = add;
704 v[1] = NULL;
Denis Vlasenko11fb7cf2009-03-20 10:13:08 +0000705 return add_strings_to_strings(strings, v, /*dup:*/ 0);
Denis Vlasenko22d10a02008-10-13 08:53:43 +0000706}
Denis Vlasenkod65ea392007-10-01 10:02:25 +0000707
Denis Vlasenko22d10a02008-10-13 08:53:43 +0000708static void putenv_all(char **strings)
709{
710 if (!strings)
711 return;
Denis Vlasenkof886fd22008-10-13 12:36:05 +0000712 while (*strings) {
713 debug_printf_env("putenv '%s'\n", *strings);
Denis Vlasenko22d10a02008-10-13 08:53:43 +0000714 putenv(*strings++);
Denis Vlasenkof886fd22008-10-13 12:36:05 +0000715 }
Denis Vlasenko22d10a02008-10-13 08:53:43 +0000716}
717
718static char **putenv_all_and_save_old(char **strings)
719{
720 char **old = NULL;
721 char **s = strings;
722
723 if (!strings)
724 return old;
725 while (*strings) {
Denis Vlasenkof886fd22008-10-13 12:36:05 +0000726 char *v, *eq;
727
728 eq = strchr(*strings, '=');
729 if (eq) {
730 *eq = '\0';
731 v = getenv(*strings);
732 *eq = '=';
733 if (v) {
734 /* v points to VAL in VAR=VAL, go back to VAR */
735 v -= (eq - *strings) + 1;
736 old = add_string_to_strings(old, v);
737 }
738 }
739 strings++;
Denis Vlasenko22d10a02008-10-13 08:53:43 +0000740 }
741 putenv_all(s);
742 return old;
Denis Vlasenkod65ea392007-10-01 10:02:25 +0000743}
744
Denis Vlasenkoafd7a8d2008-10-09 16:29:44 +0000745static void free_strings_and_unsetenv(char **strings, int unset)
Denis Vlasenkod65ea392007-10-01 10:02:25 +0000746{
Denis Vlasenkoafd7a8d2008-10-09 16:29:44 +0000747 char **v;
748
749 if (!strings)
750 return;
751
752 v = strings;
753 while (*v) {
754 if (unset) {
Denis Vlasenko76ddc2e2008-12-30 05:05:31 +0000755 debug_printf_env("unsetenv '%s'\n", *v);
756 bb_unsetenv(*v);
Denis Vlasenkoafd7a8d2008-10-09 16:29:44 +0000757 }
758 free(*v++);
Denis Vlasenkod65ea392007-10-01 10:02:25 +0000759 }
Denis Vlasenkoafd7a8d2008-10-09 16:29:44 +0000760 free(strings);
Denis Vlasenkod65ea392007-10-01 10:02:25 +0000761}
762
Denis Vlasenkoafd7a8d2008-10-09 16:29:44 +0000763static void free_strings(char **strings)
Denis Vlasenko76d50412008-06-10 16:19:39 +0000764{
Denis Vlasenkoafd7a8d2008-10-09 16:29:44 +0000765 free_strings_and_unsetenv(strings, 0);
Denis Vlasenko76d50412008-06-10 16:19:39 +0000766}
Denis Vlasenko76d50412008-06-10 16:19:39 +0000767
768
Denis Vlasenkod5762932009-03-31 11:22:57 +0000769/* Basic theory of signal handling in shell
770 * ========================================
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000771 * This does not describe what hush does, rather, it is current understanding
772 * what it _should_ do. If it doesn't, it's a bug.
Denis Vlasenkod5762932009-03-31 11:22:57 +0000773 * http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#trap
774 *
775 * Signals are handled only after each pipe ("cmd | cmd | cmd" thing)
776 * is finished or backgrounded. It is the same in interactive and
777 * non-interactive shells, and is the same regardless of whether
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000778 * a user trap handler is installed or a shell special one is in effect.
Denis Vlasenkod5762932009-03-31 11:22:57 +0000779 * ^C or ^Z from keyboard seem to execute "at once" because it usually
780 * backgrounds (i.e. stops) or kills all members of currently running
781 * pipe.
782 *
783 * Wait builtin in interruptible by signals for which user trap is set
784 * or by SIGINT in interactive shell.
785 *
786 * Trap handlers will execute even within trap handlers. (right?)
787 *
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000788 * User trap handlers are forgotten when subshell ("(cmd)") is entered. [TODO]
Denis Vlasenkod5762932009-03-31 11:22:57 +0000789 *
790 * If job control is off, backgrounded commands ("cmd &")
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000791 * have SIGINT, SIGQUIT set to SIG_IGN.
Denis Vlasenkod5762932009-03-31 11:22:57 +0000792 *
793 * Commands run in command substitution ("`cmd`")
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000794 * have SIGTTIN, SIGTTOU, SIGTSTP set to SIG_IGN.
Denis Vlasenkod5762932009-03-31 11:22:57 +0000795 *
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000796 * Ordinary commands have signals set to SIG_IGN/DFL set as inherited
797 * by the shell from its parent.
Denis Vlasenkod5762932009-03-31 11:22:57 +0000798 *
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000799 * Siganls which differ from SIG_DFL action
800 * (note: child (i.e., [v]forked) shell is not an interactive shell):
Denis Vlasenkod5762932009-03-31 11:22:57 +0000801 *
802 * SIGQUIT: ignore
803 * SIGTERM (interactive): ignore
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000804 * SIGHUP (interactive):
805 * send SIGCONT to stopped jobs, send SIGHUP to all jobs and exit
Denis Vlasenkod5762932009-03-31 11:22:57 +0000806 * SIGTTIN, SIGTTOU, SIGTSTP (if job control is on): ignore
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000807 * (note that ^Z is handled not by trapping SIGTSTP, but by seeing
808 * that all pipe members are stopped) (right?)
Denis Vlasenkod5762932009-03-31 11:22:57 +0000809 * SIGINT (interactive): wait for last pipe, ignore the rest
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000810 * of the command line, show prompt. NB: ^C does not send SIGINT
811 * to interactive shell while shell is waiting for a pipe,
812 * since shell is bg'ed (is not in foreground process group).
813 * (check/expand this)
814 * Example 1: this waits 5 sec, but does not execute ls:
815 * "echo $$; sleep 5; ls -l" + "kill -INT <pid>"
816 * Example 2: this does not wait and does not execute ls:
817 * "echo $$; sleep 5 & wait; ls -l" + "kill -INT <pid>"
818 * Example 3: this does not wait 5 sec, but executes ls:
819 * "sleep 5; ls -l" + press ^C
Denis Vlasenkod5762932009-03-31 11:22:57 +0000820 *
821 * (What happens to signals which are IGN on shell start?)
822 * (What happens with signal mask on shell start?)
823 *
824 * Implementation in hush
825 * ======================
826 * We use in-kernel pending signal mask to determine which signals were sent.
827 * We block all signals which we don't want to take action immediately,
828 * i.e. we block all signals which need to have special handling as described
829 * above, and all signals which have traps set.
830 * After each pipe execution, we extract any pending signals via sigtimedwait()
831 * and act on them.
832 *
833 * unsigned non_DFL_mask: a mask of such "special" signals
834 * sigset_t blocked_set: current blocked signal set
835 *
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000836 * "trap - SIGxxx":
837 * clear bit in blocked_set unless it is also in non_DFL
838 * "trap 'cmd' SIGxxx":
839 * set bit in blocked_set (even if 'cmd' is '')
Denis Vlasenkod5762932009-03-31 11:22:57 +0000840 * after [v]fork, if we plan to be a shell:
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000841 * nothing for {} child shell (say, "true | { true; true; } | true")
842 * unset all traps if () shell. [TODO]
Denis Vlasenkod5762932009-03-31 11:22:57 +0000843 * after [v]fork, if we plan to exec:
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000844 * POSIX says pending signal mask is cleared in child - no need to clear it.
845 * Restore blocked signal set to one inherited by shell just prior to exec.
Denis Vlasenkod5762932009-03-31 11:22:57 +0000846 *
Denis Vlasenko7566bae2009-03-31 17:24:49 +0000847 * Note: as a result, we do not use signal handlers much. The only uses
848 * are to count SIGCHLDs [disabled - bug somewhere, + bloat]
849 * and to restore tty pgrp on signal-induced exit.
Denis Vlasenkod5762932009-03-31 11:22:57 +0000850 *
851 * TODO: check/fix wait builtin to be interruptible.
852 */
853
Denis Vlasenko7566bae2009-03-31 17:24:49 +0000854//static void SIGCHLD_handler(int sig UNUSED_PARAM)
855//{
856// G.count_SIGCHLD++;
857//}
858
Denis Vlasenkod5762932009-03-31 11:22:57 +0000859/* called once at shell init */
860static void init_signal_mask(void)
Denis Vlasenko4830fc52008-05-25 21:50:55 +0000861{
Denis Vlasenkod5762932009-03-31 11:22:57 +0000862 unsigned sig;
863 unsigned mask = (1 << SIGQUIT);
864#if ENABLE_HUSH_INTERACTIVE
865 if (G.interactive_fd) {
866 mask = 0
867 | (1 << SIGQUIT)
868 | (1 << SIGTERM)
869 | (1 << SIGHUP)
870#if ENABLE_HUSH_JOB
871 | (1 << SIGTTIN) | (1 << SIGTTOU) | (1 << SIGTSTP)
872#endif
873 | (1 << SIGINT)
874 ;
875 }
876#endif
877 G.non_DFL_mask = mask;
878
Denis Vlasenkod5762932009-03-31 11:22:57 +0000879 sigprocmask(SIG_SETMASK, NULL, &G.blocked_set);
880 sig = 0;
881 while (mask) {
882 if (mask & 1)
883 sigaddset(&G.blocked_set, sig);
884 mask >>= 1;
885 sig++;
886 }
Denis Vlasenko7566bae2009-03-31 17:24:49 +0000887 sigdelset(&G.blocked_set, SIGCHLD);
Denis Vlasenkod5762932009-03-31 11:22:57 +0000888 sigprocmask(SIG_SETMASK, &G.blocked_set, &G.inherited_set);
Denis Vlasenko4830fc52008-05-25 21:50:55 +0000889}
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000890
Denis Vlasenko7566bae2009-03-31 17:24:49 +0000891static int check_and_run_traps(int sig)
Denis Vlasenkod5762932009-03-31 11:22:57 +0000892{
Denis Vlasenko7566bae2009-03-31 17:24:49 +0000893 static const struct timespec zero_timespec = { 0, 0 };
Denis Vlasenkod5762932009-03-31 11:22:57 +0000894 smalluint save_rcode;
Denis Vlasenko7566bae2009-03-31 17:24:49 +0000895 int last_sig = 0;
Denis Vlasenkod5762932009-03-31 11:22:57 +0000896
Denis Vlasenko7566bae2009-03-31 17:24:49 +0000897 if (sig)
898 goto jump_in;
Denis Vlasenkod5762932009-03-31 11:22:57 +0000899 while (1) {
Denis Vlasenko7566bae2009-03-31 17:24:49 +0000900 sig = sigtimedwait(&G.blocked_set, NULL, &zero_timespec);
Denis Vlasenkod5762932009-03-31 11:22:57 +0000901 if (sig <= 0)
902 break;
Denis Vlasenko7566bae2009-03-31 17:24:49 +0000903 jump_in:
904 last_sig = sig;
Denis Vlasenkod5762932009-03-31 11:22:57 +0000905 if (G.traps && G.traps[sig]) {
906 if (G.traps[sig][0]) {
907 /* We have user-defined handler */
908 char *argv[] = { NULL, xstrdup(G.traps[sig]), NULL };
909 save_rcode = G.last_return_code;
910 builtin_eval(argv);
911 free(argv[1]);
912 G.last_return_code = save_rcode;
913 } /* else: "" trap, ignoring signal */
914 continue;
915 }
916 /* not a trap: special action */
Denis Vlasenkod5762932009-03-31 11:22:57 +0000917 switch (sig) {
Denis Vlasenko7566bae2009-03-31 17:24:49 +0000918// case SIGCHLD:
919// G.count_SIGCHLD++;
920// break;
Denis Vlasenko422cd7c2009-03-31 12:41:52 +0000921 case SIGINT:
Denis Vlasenko7566bae2009-03-31 17:24:49 +0000922 bb_putchar('\n');
Denis Vlasenko422cd7c2009-03-31 12:41:52 +0000923 G.flag_SIGINT = 1;
Denis Vlasenkod5762932009-03-31 11:22:57 +0000924 break;
Denis Vlasenko422cd7c2009-03-31 12:41:52 +0000925//TODO
926// case SIGHUP: ...
927// break;
Denis Vlasenkod5762932009-03-31 11:22:57 +0000928 default: /* SIGTERM, SIGQUIT, SIGTTIN, SIGTTOU, SIGTSTP */
Denis Vlasenko422cd7c2009-03-31 12:41:52 +0000929 break;
Denis Vlasenkod5762932009-03-31 11:22:57 +0000930 }
Denis Vlasenkod5762932009-03-31 11:22:57 +0000931 }
Denis Vlasenko7566bae2009-03-31 17:24:49 +0000932 return last_sig;
Denis Vlasenkod5762932009-03-31 11:22:57 +0000933}
934
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +0000935#if ENABLE_HUSH_JOB
Denis Vlasenkob81b3df2007-04-28 16:48:04 +0000936
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +0000937/* Restores tty foreground process group, and exits.
938 * May be called as signal handler for fatal signal
939 * (will faithfully resend signal to itself, producing correct exit state)
940 * or called directly with -EXITCODE.
941 * We also call it if xfunc is exiting. */
Denis Vlasenkoa60f84e2008-07-05 09:18:54 +0000942static void sigexit(int sig) NORETURN;
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +0000943static void sigexit(int sig)
944{
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +0000945 /* Disable all signals: job control, SIGPIPE, etc. */
Denis Vlasenko3f165fa2008-03-17 08:29:08 +0000946 sigprocmask_allsigs(SIG_BLOCK);
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +0000947
Denis Vlasenko87a86552008-07-29 19:43:10 +0000948#if ENABLE_HUSH_INTERACTIVE
Denis Vlasenkoabedaac2009-03-31 12:03:40 +0000949 /* Careful: we can end up here after [v]fork. Do not restore
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000950 * tty pgrp then, only top-level shell process does that */
Denis Vlasenkoabedaac2009-03-31 12:03:40 +0000951 if (G.interactive_fd && getpid() == G.root_pid)
Denis Vlasenko87a86552008-07-29 19:43:10 +0000952 tcsetpgrp(G.interactive_fd, G.saved_tty_pgrp);
953#endif
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +0000954
955 /* Not a signal, just exit */
956 if (sig <= 0)
957 _exit(- sig);
958
Denis Vlasenko400d8bb2008-02-24 13:36:01 +0000959 kill_myself_with_sig(sig); /* does not return */
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +0000960}
961
Denis Vlasenkoabedaac2009-03-31 12:03:40 +0000962/* helper */
963static void maybe_set_sighandler(int sig)
964{
965 void (*handler)(int);
966 /* non_DFL_mask'ed signals are, well, masked,
967 * no need to set handler for them.
968 */
969 if (!((G.non_DFL_mask >> sig) & 1)) {
970 handler = signal(sig, sigexit);
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000971 if (handler == SIG_IGN) /* oops... restore back to IGN! */
Denis Vlasenkoabedaac2009-03-31 12:03:40 +0000972 signal(sig, handler);
973 }
974}
Denis Vlasenko7b830e72009-03-31 13:05:32 +0000975/* Used only to set handler to restore pgrp on exit */
Denis Vlasenkoabedaac2009-03-31 12:03:40 +0000976static void set_fatal_signals_to_sigexit(void)
977{
978 if (HUSH_DEBUG) {
979 maybe_set_sighandler(SIGILL );
980 maybe_set_sighandler(SIGFPE );
981 maybe_set_sighandler(SIGBUS );
982 maybe_set_sighandler(SIGSEGV);
983 maybe_set_sighandler(SIGTRAP);
984 } /* else: hush is perfect. what SEGV? */
985
986 maybe_set_sighandler(SIGABRT);
987
988 /* bash 3.2 seems to handle these just like 'fatal' ones */
989 maybe_set_sighandler(SIGPIPE);
990 maybe_set_sighandler(SIGALRM);
991 maybe_set_sighandler(SIGHUP );
992
993 /* if we aren't interactive... but in this case
994 * we never want to restore pgrp on exit, and this fn is not called */
995 /*maybe_set_sighandler(SIGTERM);*/
996 /*maybe_set_sighandler(SIGINT );*/
997}
998/* Used only to suppress ^Z in `cmd` */
999static void set_jobctrl_signals_to_IGN(void)
1000{
1001 bb_signals(0
1002 + (1 << SIGTSTP)
1003 + (1 << SIGTTIN)
1004 + (1 << SIGTTOU)
1005 , SIG_IGN);
1006}
1007
Denis Vlasenkoef36ead2007-05-02 15:34:47 +00001008#else /* !JOB */
Denis Vlasenkob81b3df2007-04-28 16:48:04 +00001009
Denis Vlasenkoabedaac2009-03-31 12:03:40 +00001010#define set_fatal_signals_to_sigexit(handler) ((void)0)
1011#define set_jobctrl_signals_to_IGN(handler) ((void)0)
Denis Vlasenkob81b3df2007-04-28 16:48:04 +00001012
Denis Vlasenkoef36ead2007-05-02 15:34:47 +00001013#endif /* JOB */
Denis Vlasenkob81b3df2007-04-28 16:48:04 +00001014
Mike Frysinger9f8128f2009-03-29 23:49:37 +00001015/* Restores tty foreground process group, and exits. */
1016static void hush_exit(int exitcode) NORETURN;
1017static void hush_exit(int exitcode)
1018{
Denis Vlasenkod5762932009-03-31 11:22:57 +00001019 if (G.traps && G.traps[0] && G.traps[0][0]) {
1020 char *argv[] = { NULL, xstrdup(G.traps[0]), NULL };
1021 builtin_eval(argv);
1022 free(argv[1]);
1023 }
Mike Frysinger9f8128f2009-03-29 23:49:37 +00001024
Denis Vlasenkoabedaac2009-03-31 12:03:40 +00001025#if ENABLE_HUSH_JOB
1026 fflush(NULL); /* flush all streams */
1027 sigexit(- (exitcode & 0xff));
1028#else
1029 exit(exitcode);
1030#endif
Mike Frysinger9f8128f2009-03-29 23:49:37 +00001031}
1032
Denis Vlasenkob81b3df2007-04-28 16:48:04 +00001033
Eric Andersen9ffb7dd2001-05-19 03:00:46 +00001034static const char *set_cwd(void)
1035{
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001036 /* xrealloc_getcwd_or_warn(arg) calls free(arg),
1037 * we must not try to free(bb_msg_unknown) */
Denis Vlasenko87a86552008-07-29 19:43:10 +00001038 if (G.cwd == bb_msg_unknown)
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001039 G.cwd = NULL;
Denis Vlasenko87a86552008-07-29 19:43:10 +00001040 G.cwd = xrealloc_getcwd_or_warn((char *)G.cwd);
1041 if (!G.cwd)
1042 G.cwd = bb_msg_unknown;
1043 return G.cwd;
Eric Andersen9ffb7dd2001-05-19 03:00:46 +00001044}
1045
Denis Vlasenko83506862007-11-23 13:11:42 +00001046
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001047/* Get/check local shell variables */
1048static struct variable *get_local_var(const char *name)
1049{
1050 struct variable *cur;
1051 int len;
1052
1053 if (!name)
1054 return NULL;
1055 len = strlen(name);
1056 for (cur = G.top_var; cur; cur = cur->next) {
1057 if (strncmp(cur->varstr, name, len) == 0 && cur->varstr[len] == '=')
1058 return cur;
1059 }
1060 return NULL;
1061}
1062
1063/* Basically useful version until someone wants to get fancier,
1064 * see the bash man page under "Parameter Expansion" */
1065static const char *lookup_param(const char *src)
1066{
1067 struct variable *var = get_local_var(src);
1068 if (var)
1069 return strchr(var->varstr, '=') + 1;
1070 return NULL;
1071}
1072
1073/* str holds "NAME=VAL" and is expected to be malloced.
Mike Frysinger6379bb42009-03-28 18:55:03 +00001074 * We take ownership of it.
1075 * flg_export is used by:
1076 * 0: do not export
1077 * 1: export
1078 * -1: if NAME is set, leave export status alone
1079 * if NAME is not set, do not export
1080 */
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001081static int set_local_var(char *str, int flg_export)
1082{
1083 struct variable *cur;
1084 char *value;
1085 int name_len;
1086
1087 value = strchr(str, '=');
1088 if (!value) { /* not expected to ever happen? */
1089 free(str);
1090 return -1;
1091 }
1092
1093 name_len = value - str + 1; /* including '=' */
1094 cur = G.top_var; /* cannot be NULL (we have HUSH_VERSION and it's RO) */
1095 while (1) {
1096 if (strncmp(cur->varstr, str, name_len) != 0) {
1097 if (!cur->next) {
1098 /* Bail out. Note that now cur points
1099 * to last var in linked list */
1100 break;
1101 }
1102 cur = cur->next;
1103 continue;
1104 }
1105 /* We found an existing var with this name */
1106 *value = '\0';
1107 if (cur->flg_read_only) {
1108 bb_error_msg("%s: readonly variable", str);
1109 free(str);
1110 return -1;
1111 }
1112 debug_printf_env("%s: unsetenv '%s'\n", __func__, str);
1113 unsetenv(str); /* just in case */
1114 *value = '=';
1115 if (strcmp(cur->varstr, str) == 0) {
1116 free_and_exp:
1117 free(str);
1118 goto exp;
1119 }
1120 if (cur->max_len >= strlen(str)) {
1121 /* This one is from startup env, reuse space */
1122 strcpy(cur->varstr, str);
1123 goto free_and_exp;
1124 }
1125 /* max_len == 0 signifies "malloced" var, which we can
1126 * (and has to) free */
1127 if (!cur->max_len)
1128 free(cur->varstr);
1129 cur->max_len = 0;
1130 goto set_str_and_exp;
1131 }
1132
1133 /* Not found - create next variable struct */
1134 cur->next = xzalloc(sizeof(*cur));
1135 cur = cur->next;
1136
1137 set_str_and_exp:
1138 cur->varstr = str;
1139 exp:
Mike Frysinger6379bb42009-03-28 18:55:03 +00001140 if (flg_export == 1)
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001141 cur->flg_export = 1;
1142 if (cur->flg_export) {
1143 debug_printf_env("%s: putenv '%s'\n", __func__, cur->varstr);
1144 return putenv(cur->varstr);
1145 }
1146 return 0;
1147}
1148
Mike Frysingerd690f682009-03-30 06:50:54 +00001149static int unset_local_var(const char *name)
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001150{
1151 struct variable *cur;
1152 struct variable *prev = prev; /* for gcc */
1153 int name_len;
1154
1155 if (!name)
Mike Frysingerd690f682009-03-30 06:50:54 +00001156 return EXIT_SUCCESS;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001157 name_len = strlen(name);
1158 cur = G.top_var;
1159 while (cur) {
1160 if (strncmp(cur->varstr, name, name_len) == 0 && cur->varstr[name_len] == '=') {
1161 if (cur->flg_read_only) {
1162 bb_error_msg("%s: readonly variable", name);
Mike Frysingerd690f682009-03-30 06:50:54 +00001163 return EXIT_FAILURE;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001164 }
1165 /* prev is ok to use here because 1st variable, HUSH_VERSION,
1166 * is ro, and we cannot reach this code on the 1st pass */
1167 prev->next = cur->next;
1168 debug_printf_env("%s: unsetenv '%s'\n", __func__, cur->varstr);
1169 bb_unsetenv(cur->varstr);
1170 if (!cur->max_len)
1171 free(cur->varstr);
1172 free(cur);
Mike Frysingerd690f682009-03-30 06:50:54 +00001173 return EXIT_SUCCESS;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001174 }
1175 prev = cur;
1176 cur = cur->next;
1177 }
Mike Frysingerd690f682009-03-30 06:50:54 +00001178 return EXIT_SUCCESS;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001179}
1180
Mike Frysinger98c52642009-04-02 10:02:37 +00001181#if ENABLE_SH_MATH_SUPPORT
1182#define is_name(c) ((c) == '_' || isalpha((unsigned char)(c)))
1183#define is_in_name(c) ((c) == '_' || isalnum((unsigned char)(c)))
1184static char *endofname(const char *name)
1185{
1186 char *p;
1187
1188 p = (char *) name;
1189 if (!is_name(*p))
1190 return p;
1191 while (*++p) {
1192 if (!is_in_name(*p))
1193 break;
1194 }
1195 return p;
1196}
1197
1198static void arith_set_local_var(const char *name, const char *val, int flags)
1199{
1200 /* arith code doesnt malloc space, so do it for it */
Denis Vlasenkob29eb6e2009-04-02 13:46:27 +00001201 char *var = xasprintf("%s=%s", name, val);
Mike Frysinger98c52642009-04-02 10:02:37 +00001202 set_local_var(var, flags);
1203}
1204#endif
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001205
Denis Vlasenkob29eb6e2009-04-02 13:46:27 +00001206
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001207/*
1208 * in_str support
1209 */
1210static int static_get(struct in_str *i)
1211{
1212 int ch = *i->p++;
Denis Vlasenkob6e65562009-04-03 16:49:04 +00001213 if (ch != '\0')
1214 return ch;
1215 i->p--;
1216 return EOF;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001217}
1218
1219static int static_peek(struct in_str *i)
1220{
1221 return *i->p;
1222}
1223
1224#if ENABLE_HUSH_INTERACTIVE
1225
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001226static void cmdedit_set_initial_prompt(void)
1227{
Mike Frysingerec2c6552009-03-28 12:24:44 +00001228 if (ENABLE_FEATURE_EDITING_FANCY_PROMPT) {
1229 G.PS1 = getenv("PS1");
1230 if (G.PS1 == NULL)
1231 G.PS1 = "\\w \\$ ";
1232 } else
1233 G.PS1 = NULL;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001234}
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001235
1236static const char* setup_prompt_string(int promptmode)
1237{
1238 const char *prompt_str;
1239 debug_printf("setup_prompt_string %d ", promptmode);
Mike Frysingerec2c6552009-03-28 12:24:44 +00001240 if (!ENABLE_FEATURE_EDITING_FANCY_PROMPT) {
1241 /* Set up the prompt */
1242 if (promptmode == 0) { /* PS1 */
1243 free((char*)G.PS1);
1244 G.PS1 = xasprintf("%s %c ", G.cwd, (geteuid() != 0) ? '$' : '#');
1245 prompt_str = G.PS1;
1246 } else
1247 prompt_str = G.PS2;
1248 } else
1249 prompt_str = (promptmode == 0) ? G.PS1 : G.PS2;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001250 debug_printf("result '%s'\n", prompt_str);
1251 return prompt_str;
1252}
1253
1254static void get_user_input(struct in_str *i)
1255{
1256 int r;
1257 const char *prompt_str;
1258
1259 prompt_str = setup_prompt_string(i->promptmode);
1260#if ENABLE_FEATURE_EDITING
1261 /* Enable command line editing only while a command line
1262 * is actually being read */
1263 do {
Denis Vlasenko422cd7c2009-03-31 12:41:52 +00001264 G.flag_SIGINT = 0;
1265 /* buglet: SIGINT will not make new prompt to appear _at once_,
1266 * only after <Enter>. (^C will work) */
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001267 r = read_line_input(prompt_str, G.user_input_buf, BUFSIZ-1, G.line_input_state);
Denis Vlasenko422cd7c2009-03-31 12:41:52 +00001268 /* catch *SIGINT* etc (^C is handled by read_line_input) */
Denis Vlasenko7566bae2009-03-31 17:24:49 +00001269 check_and_run_traps(0);
Denis Vlasenko422cd7c2009-03-31 12:41:52 +00001270 } while (r == 0 || G.flag_SIGINT); /* repeat if ^C or SIGINT */
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001271 i->eof_flag = (r < 0);
1272 if (i->eof_flag) { /* EOF/error detected */
1273 G.user_input_buf[0] = EOF; /* yes, it will be truncated, it's ok */
1274 G.user_input_buf[1] = '\0';
1275 }
1276#else
Denis Vlasenko422cd7c2009-03-31 12:41:52 +00001277 do {
1278 G.flag_SIGINT = 0;
1279 fputs(prompt_str, stdout);
1280 fflush(stdout);
1281 G.user_input_buf[0] = r = fgetc(i->file);
1282 /*G.user_input_buf[1] = '\0'; - already is and never changed */
Denis Vlasenko7566bae2009-03-31 17:24:49 +00001283//do we need check_and_run_traps(0)? (maybe only if stdin)
Denis Vlasenko422cd7c2009-03-31 12:41:52 +00001284 } while (G.flag_SIGINT);
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001285 i->eof_flag = (r == EOF);
1286#endif
1287 i->p = G.user_input_buf;
1288}
1289
1290#endif /* INTERACTIVE */
1291
1292/* This is the magic location that prints prompts
1293 * and gets data back from the user */
1294static int file_get(struct in_str *i)
1295{
1296 int ch;
1297
1298 /* If there is data waiting, eat it up */
1299 if (i->p && *i->p) {
1300#if ENABLE_HUSH_INTERACTIVE
1301 take_cached:
1302#endif
1303 ch = *i->p++;
1304 if (i->eof_flag && !*i->p)
1305 ch = EOF;
1306 } else {
1307 /* need to double check i->file because we might be doing something
1308 * more complicated by now, like sourcing or substituting. */
1309#if ENABLE_HUSH_INTERACTIVE
1310 if (G.interactive_fd && i->promptme && i->file == stdin) {
1311 do {
1312 get_user_input(i);
1313 } while (!*i->p); /* need non-empty line */
1314 i->promptmode = 1; /* PS2 */
1315 i->promptme = 0;
1316 goto take_cached;
1317 }
1318#endif
1319 ch = fgetc(i->file);
1320 }
1321 debug_printf("file_get: got a '%c' %d\n", ch, ch);
1322#if ENABLE_HUSH_INTERACTIVE
1323 if (ch == '\n')
1324 i->promptme = 1;
1325#endif
1326 return ch;
1327}
1328
1329/* All the callers guarantee this routine will never be
1330 * used right after a newline, so prompting is not needed.
1331 */
1332static int file_peek(struct in_str *i)
1333{
1334 int ch;
1335 if (i->p && *i->p) {
1336 if (i->eof_flag && !i->p[1])
1337 return EOF;
1338 return *i->p;
1339 }
1340 ch = fgetc(i->file);
1341 i->eof_flag = (ch == EOF);
1342 i->peek_buf[0] = ch;
1343 i->peek_buf[1] = '\0';
1344 i->p = i->peek_buf;
1345 debug_printf("file_peek: got a '%c' %d\n", *i->p, *i->p);
1346 return ch;
1347}
1348
1349static void setup_file_in_str(struct in_str *i, FILE *f)
1350{
1351 i->peek = file_peek;
1352 i->get = file_get;
1353#if ENABLE_HUSH_INTERACTIVE
1354 i->promptme = 1;
1355 i->promptmode = 0; /* PS1 */
1356#endif
1357 i->file = f;
1358 i->p = NULL;
1359}
1360
1361static void setup_string_in_str(struct in_str *i, const char *s)
1362{
1363 i->peek = static_peek;
1364 i->get = static_get;
1365#if ENABLE_HUSH_INTERACTIVE
1366 i->promptme = 1;
1367 i->promptmode = 0; /* PS1 */
1368#endif
1369 i->p = s;
1370 i->eof_flag = 0;
1371}
1372
1373
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001374/*
1375 * o_string support
1376 */
1377#define B_CHUNK (32 * sizeof(char*))
Eric Andersen25f27032001-04-26 23:22:31 +00001378
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00001379static void o_reset(o_string *o)
Eric Andersen25f27032001-04-26 23:22:31 +00001380{
1381 o->length = 0;
1382 o->nonnull = 0;
Denis Vlasenkod65ea392007-10-01 10:02:25 +00001383 if (o->data)
1384 o->data[0] = '\0';
Eric Andersen25f27032001-04-26 23:22:31 +00001385}
1386
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00001387static void o_free(o_string *o)
Eric Andersen25f27032001-04-26 23:22:31 +00001388{
Aaron Lehmanna170e1c2002-11-28 11:27:31 +00001389 free(o->data);
Denis Vlasenkod65ea392007-10-01 10:02:25 +00001390 memset(o, 0, sizeof(*o));
Eric Andersen25f27032001-04-26 23:22:31 +00001391}
1392
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00001393static void o_grow_by(o_string *o, int len)
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001394{
1395 if (o->length + len > o->maxlen) {
1396 o->maxlen += (2*len > B_CHUNK ? 2*len : B_CHUNK);
1397 o->data = xrealloc(o->data, 1 + o->maxlen);
1398 }
1399}
1400
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00001401static void o_addchr(o_string *o, int ch)
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001402{
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00001403 debug_printf("o_addchr: '%c' o->length=%d o=%p\n", ch, o->length, o);
1404 o_grow_by(o, 1);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001405 o->data[o->length] = ch;
1406 o->length++;
1407 o->data[o->length] = '\0';
1408}
1409
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00001410static void o_addstr(o_string *o, const char *str, int len)
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001411{
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00001412 o_grow_by(o, len);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001413 memcpy(&o->data[o->length], str, len);
1414 o->length += len;
1415 o->data[o->length] = '\0';
1416}
1417
Mike Frysinger98c52642009-04-02 10:02:37 +00001418static void o_addstrauto(o_string *o, const char *str)
1419{
1420 o_addstr(o, str, strlen(str) + 1);
1421}
1422
Denis Vlasenko55789c62008-06-18 16:30:42 +00001423static void o_addstr_duplicate_backslash(o_string *o, const char *str, int len)
1424{
1425 while (len) {
1426 o_addchr(o, *str);
1427 if (*str++ == '\\'
1428 && (*str != '*' && *str != '?' && *str != '[')
1429 ) {
1430 o_addchr(o, '\\');
1431 }
1432 len--;
1433 }
1434}
1435
Eric Andersen25f27032001-04-26 23:22:31 +00001436/* My analysis of quoting semantics tells me that state information
1437 * is associated with a destination, not a source.
1438 */
Denis Vlasenko7e3d33b2008-06-12 13:31:04 +00001439static void o_addqchr(o_string *o, int ch)
Eric Andersen25f27032001-04-26 23:22:31 +00001440{
Denis Vlasenko7e3d33b2008-06-12 13:31:04 +00001441 int sz = 1;
Denis Vlasenko371de4a2008-10-14 12:43:13 +00001442 char *found = strchr("*?[\\", ch);
1443 if (found)
Denis Vlasenko7e3d33b2008-06-12 13:31:04 +00001444 sz++;
Denis Vlasenko371de4a2008-10-14 12:43:13 +00001445 o_grow_by(o, sz);
1446 if (found) {
Denis Vlasenko7e3d33b2008-06-12 13:31:04 +00001447 o->data[o->length] = '\\';
1448 o->length++;
Eric Andersen25f27032001-04-26 23:22:31 +00001449 }
Denis Vlasenko7e3d33b2008-06-12 13:31:04 +00001450 o->data[o->length] = ch;
1451 o->length++;
1452 o->data[o->length] = '\0';
Eric Andersen25f27032001-04-26 23:22:31 +00001453}
1454
Denis Vlasenko7e3d33b2008-06-12 13:31:04 +00001455static void o_addQchr(o_string *o, int ch)
Denis Vlasenko87f40ba2008-06-10 22:39:37 +00001456{
Denis Vlasenko7e3d33b2008-06-12 13:31:04 +00001457 int sz = 1;
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00001458 if (o->o_escape && strchr("*?[\\", ch)) {
Denis Vlasenko7e3d33b2008-06-12 13:31:04 +00001459 sz++;
1460 o->data[o->length] = '\\';
1461 o->length++;
1462 }
1463 o_grow_by(o, sz);
1464 o->data[o->length] = ch;
1465 o->length++;
1466 o->data[o->length] = '\0';
1467}
1468
1469static void o_addQstr(o_string *o, const char *str, int len)
1470{
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00001471 if (!o->o_escape) {
Denis Vlasenko87f40ba2008-06-10 22:39:37 +00001472 o_addstr(o, str, len);
1473 return;
1474 }
1475 while (len) {
Denis Vlasenko7e3d33b2008-06-12 13:31:04 +00001476 char ch;
1477 int sz;
1478 int ordinary_cnt = strcspn(str, "*?[\\");
1479 if (ordinary_cnt > len) /* paranoia */
1480 ordinary_cnt = len;
1481 o_addstr(o, str, ordinary_cnt);
1482 if (ordinary_cnt == len)
1483 return;
1484 str += ordinary_cnt;
Denis Vlasenko30c9cc52008-06-17 07:24:29 +00001485 len -= ordinary_cnt + 1; /* we are processing + 1 char below */
Denis Vlasenko7e3d33b2008-06-12 13:31:04 +00001486
Denis Vlasenko87f40ba2008-06-10 22:39:37 +00001487 ch = *str++;
Denis Vlasenko7e3d33b2008-06-12 13:31:04 +00001488 sz = 1;
1489 if (ch) { /* it is necessarily one of "*?[\\" */
1490 sz++;
1491 o->data[o->length] = '\\';
1492 o->length++;
Denis Vlasenko87f40ba2008-06-10 22:39:37 +00001493 }
Denis Vlasenko7e3d33b2008-06-12 13:31:04 +00001494 o_grow_by(o, sz);
1495 o->data[o->length] = ch;
1496 o->length++;
1497 o->data[o->length] = '\0';
Denis Vlasenko87f40ba2008-06-10 22:39:37 +00001498 }
1499}
1500
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001501/* A special kind of o_string for $VAR and `cmd` expansion.
1502 * It contains char* list[] at the beginning, which is grown in 16 element
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00001503 * increments. Actual string data starts at the next multiple of 16 * (char*).
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001504 * list[i] contains an INDEX (int!) into this string data.
1505 * It means that if list[] needs to grow, data needs to be moved higher up
1506 * but list[i]'s need not be modified.
1507 * NB: remembering how many list[i]'s you have there is crucial.
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00001508 * o_finalize_list() operation post-processes this structure - calculates
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001509 * and stores actual char* ptrs in list[]. Oh, it NULL terminates it as well.
1510 */
Denis Vlasenkob61e13d2008-06-17 05:11:43 +00001511#if DEBUG_EXPAND || DEBUG_GLOB
1512static void debug_print_list(const char *prefix, o_string *o, int n)
1513{
1514 char **list = (char**)o->data;
1515 int string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
1516 int i = 0;
1517 fprintf(stderr, "%s: list:%p n:%d string_start:%d length:%d maxlen:%d\n",
1518 prefix, list, n, string_start, o->length, o->maxlen);
1519 while (i < n) {
1520 fprintf(stderr, " list[%d]=%d '%s' %p\n", i, (int)list[i],
1521 o->data + (int)list[i] + string_start,
1522 o->data + (int)list[i] + string_start);
1523 i++;
1524 }
1525 if (n) {
1526 const char *p = o->data + (int)list[n - 1] + string_start;
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00001527 fprintf(stderr, " total_sz:%ld\n", (long)((p + strlen(p) + 1) - o->data));
Denis Vlasenkob61e13d2008-06-17 05:11:43 +00001528 }
1529}
1530#else
1531#define debug_print_list(prefix, o, n) ((void)0)
1532#endif
1533
1534/* n = o_save_ptr_helper(str, n) "starts new string" by storing an index value
1535 * in list[n] so that it points past last stored byte so far.
1536 * It returns n+1. */
1537static int o_save_ptr_helper(o_string *o, int n)
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001538{
1539 char **list = (char**)o->data;
Denis Vlasenko895bea22008-06-10 18:06:24 +00001540 int string_start;
1541 int string_len;
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001542
1543 if (!o->has_empty_slot) {
Denis Vlasenko895bea22008-06-10 18:06:24 +00001544 string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
1545 string_len = o->length - string_start;
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001546 if (!(n & 0xf)) { /* 0, 0x10, 0x20...? */
Denis Vlasenko30c9cc52008-06-17 07:24:29 +00001547 debug_printf_list("list[%d]=%d string_start=%d (growing)\n", n, string_len, string_start);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001548 /* list[n] points to string_start, make space for 16 more pointers */
1549 o->maxlen += 0x10 * sizeof(list[0]);
1550 o->data = xrealloc(o->data, o->maxlen + 1);
Denis Vlasenko7049ff82008-06-25 09:53:17 +00001551 list = (char**)o->data;
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001552 memmove(list + n + 0x10, list + n, string_len);
1553 o->length += 0x10 * sizeof(list[0]);
Denis Vlasenkob61e13d2008-06-17 05:11:43 +00001554 } else
Denis Vlasenko30c9cc52008-06-17 07:24:29 +00001555 debug_printf_list("list[%d]=%d string_start=%d\n", n, string_len, string_start);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001556 } else {
1557 /* We have empty slot at list[n], reuse without growth */
Denis Vlasenko895bea22008-06-10 18:06:24 +00001558 string_start = ((n+1 + 0xf) & ~0xf) * sizeof(list[0]); /* NB: n+1! */
1559 string_len = o->length - string_start;
Denis Vlasenko30c9cc52008-06-17 07:24:29 +00001560 debug_printf_list("list[%d]=%d string_start=%d (empty slot)\n", n, string_len, string_start);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001561 o->has_empty_slot = 0;
1562 }
Denis Vlasenkocc3f20b2008-06-23 22:31:52 +00001563 list[n] = (char*)(ptrdiff_t)string_len;
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001564 return n + 1;
1565}
1566
Denis Vlasenkob61e13d2008-06-17 05:11:43 +00001567/* "What was our last o_save_ptr'ed position (byte offset relative o->data)?" */
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00001568static int o_get_last_ptr(o_string *o, int n)
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001569{
1570 char **list = (char**)o->data;
1571 int string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
1572
Denis Vlasenkocc3f20b2008-06-23 22:31:52 +00001573 return ((int)(ptrdiff_t)list[n-1]) + string_start;
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001574}
1575
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00001576/* o_glob performs globbing on last list[], saving each result
Denis Vlasenko55789c62008-06-18 16:30:42 +00001577 * as a new list[]. */
Denis Vlasenkob61e13d2008-06-17 05:11:43 +00001578static int o_glob(o_string *o, int n)
1579{
1580 glob_t globdata;
1581 int gr;
1582 char *pattern;
1583
Denis Vlasenko30c9cc52008-06-17 07:24:29 +00001584 debug_printf_glob("start o_glob: n:%d o->data:%p\n", n, o->data);
Denis Vlasenkob61e13d2008-06-17 05:11:43 +00001585 if (!o->data)
1586 return o_save_ptr_helper(o, n);
1587 pattern = o->data + o_get_last_ptr(o, n);
Denis Vlasenko30c9cc52008-06-17 07:24:29 +00001588 debug_printf_glob("glob pattern '%s'\n", pattern);
Denis Vlasenkob61e13d2008-06-17 05:11:43 +00001589 if (!glob_needed(pattern)) {
1590 literal:
1591 o->length = unbackslash(pattern) - o->data;
Denis Vlasenko30c9cc52008-06-17 07:24:29 +00001592 debug_printf_glob("glob pattern '%s' is literal\n", pattern);
Denis Vlasenkob61e13d2008-06-17 05:11:43 +00001593 return o_save_ptr_helper(o, n);
1594 }
1595
1596 memset(&globdata, 0, sizeof(globdata));
1597 gr = glob(pattern, 0, NULL, &globdata);
1598 debug_printf_glob("glob('%s'):%d\n", pattern, gr);
1599 if (gr == GLOB_NOSPACE)
1600 bb_error_msg_and_die("out of memory during glob");
1601 if (gr == GLOB_NOMATCH) {
1602 globfree(&globdata);
1603 goto literal;
1604 }
1605 if (gr != 0) { /* GLOB_ABORTED ? */
1606//TODO: testcase for bad glob pattern behavior
1607 bb_error_msg("glob(3) error %d on '%s'", gr, pattern);
1608 }
1609 if (globdata.gl_pathv && globdata.gl_pathv[0]) {
1610 char **argv = globdata.gl_pathv;
1611 o->length = pattern - o->data; /* "forget" pattern */
1612 while (1) {
Mike Frysinger98c52642009-04-02 10:02:37 +00001613 o_addstrauto(o, *argv);
Denis Vlasenkob61e13d2008-06-17 05:11:43 +00001614 n = o_save_ptr_helper(o, n);
1615 argv++;
1616 if (!*argv)
1617 break;
1618 }
1619 }
1620 globfree(&globdata);
1621 if (DEBUG_GLOB)
1622 debug_print_list("o_glob returning", o, n);
1623 return n;
1624}
1625
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00001626/* If o->o_glob == 1, glob the string so far remembered.
1627 * Otherwise, just finish current list[] and start new */
Denis Vlasenkob61e13d2008-06-17 05:11:43 +00001628static int o_save_ptr(o_string *o, int n)
1629{
Denis Vlasenkoa8b6dff2009-03-20 12:05:14 +00001630 if (o->o_glob) { /* if globbing is requested */
1631 /* If o->has_empty_slot, list[n] was already globbed
1632 * (if it was requested back then when it was filled)
1633 * so don't do that again! */
1634 if (!o->has_empty_slot)
1635 return o_glob(o, n); /* o_save_ptr_helper is inside */
1636 }
Denis Vlasenkob61e13d2008-06-17 05:11:43 +00001637 return o_save_ptr_helper(o, n);
1638}
1639
1640/* "Please convert list[n] to real char* ptrs, and NULL terminate it." */
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00001641static char **o_finalize_list(o_string *o, int n)
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001642{
Denis Vlasenkob61e13d2008-06-17 05:11:43 +00001643 char **list;
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001644 int string_start;
1645
Denis Vlasenkob61e13d2008-06-17 05:11:43 +00001646 n = o_save_ptr(o, n); /* force growth for list[n] if necessary */
1647 if (DEBUG_EXPAND)
1648 debug_print_list("finalized", o, n);
Denis Vlasenko30c9cc52008-06-17 07:24:29 +00001649 debug_printf_expand("finalized n:%d\n", n);
Denis Vlasenkob61e13d2008-06-17 05:11:43 +00001650 list = (char**)o->data;
1651 string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
1652 list[--n] = NULL;
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001653 while (n) {
1654 n--;
Denis Vlasenkocc3f20b2008-06-23 22:31:52 +00001655 list[n] = o->data + (int)(ptrdiff_t)list[n] + string_start;
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001656 }
1657 return list;
1658}
1659
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00001660
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00001661/* Expansion can recurse */
1662#if ENABLE_HUSH_TICK
Denis Vlasenko37181682009-04-03 03:19:15 +00001663static int process_command_subs(o_string *dest, struct in_str *input);
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00001664#endif
1665static char *expand_string_to_string(const char *str);
1666static int parse_stream_dquoted(o_string *dest, struct in_str *input, int dquote_end);
1667
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001668/* expand_strvec_to_strvec() takes a list of strings, expands
1669 * all variable references within and returns a pointer to
1670 * a list of expanded strings, possibly with larger number
1671 * of strings. (Think VAR="a b"; echo $VAR).
1672 * This new list is allocated as a single malloc block.
1673 * NULL-terminated list of char* pointers is at the beginning of it,
1674 * followed by strings themself.
1675 * Caller can deallocate entire list by single free(list). */
Eric Andersen25f27032001-04-26 23:22:31 +00001676
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001677/* Store given string, finalizing the word and starting new one whenever
1678 * we encounter IFS char(s). This is used for expanding variable values.
1679 * End-of-string does NOT finalize word: think about 'echo -$VAR-' */
1680static int expand_on_ifs(o_string *output, int n, const char *str)
Eric Andersen25f27032001-04-26 23:22:31 +00001681{
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001682 while (1) {
1683 int word_len = strcspn(str, G.ifs);
1684 if (word_len) {
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00001685 if (output->o_escape || !output->o_glob)
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001686 o_addQstr(output, str, word_len);
1687 else /* protect backslashes against globbing up :) */
1688 o_addstr_duplicate_backslash(output, str, word_len);
1689 str += word_len;
1690 }
1691 if (!*str) /* EOL - do not finalize word */
1692 break;
1693 o_addchr(output, '\0');
1694 debug_print_list("expand_on_ifs", output, n);
1695 n = o_save_ptr(output, n);
1696 str += strspn(str, G.ifs); /* skip ifs chars */
Eric Andersen25f27032001-04-26 23:22:31 +00001697 }
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001698 debug_print_list("expand_on_ifs[1]", output, n);
1699 return n;
Eric Andersen25f27032001-04-26 23:22:31 +00001700}
1701
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001702/* Expand all variable references in given string, adding words to list[]
1703 * at n, n+1,... positions. Return updated n (so that list[n] is next one
1704 * to be filled). This routine is extremely tricky: has to deal with
1705 * variables/parameters with whitespace, $* and $@, and constructs like
1706 * 'echo -$*-'. If you play here, you must run testsuite afterwards! */
1707static int expand_vars_to_list(o_string *output, int n, char *arg, char or_mask)
Eric Andersen25f27032001-04-26 23:22:31 +00001708{
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001709 /* or_mask is either 0 (normal case) or 0x80
1710 * (expansion of right-hand side of assignment == 1-element expand.
1711 * It will also do no globbing, and thus we must not backslash-quote!) */
Eric Andersen25f27032001-04-26 23:22:31 +00001712
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001713 char first_ch, ored_ch;
1714 int i;
1715 const char *val;
1716 char *p;
1717
1718 ored_ch = 0;
1719
1720 debug_printf_expand("expand_vars_to_list: arg '%s'\n", arg);
1721 debug_print_list("expand_vars_to_list", output, n);
1722 n = o_save_ptr(output, n);
1723 debug_print_list("expand_vars_to_list[0]", output, n);
1724
1725 while ((p = strchr(arg, SPECIAL_VAR_SYMBOL)) != NULL) {
1726#if ENABLE_HUSH_TICK
1727 o_string subst_result = NULL_O_STRING;
Denis Vlasenko96f67dc2007-05-17 13:02:41 +00001728#endif
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00001729#if ENABLE_SH_MATH_SUPPORT
1730 char arith_buf[sizeof(arith_t)*3 + 2];
1731#endif
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001732 o_addstr(output, arg, p - arg);
1733 debug_print_list("expand_vars_to_list[1]", output, n);
1734 arg = ++p;
1735 p = strchr(p, SPECIAL_VAR_SYMBOL);
1736
1737 first_ch = arg[0] | or_mask; /* forced to "quoted" if or_mask = 0x80 */
1738 /* "$@" is special. Even if quoted, it can still
1739 * expand to nothing (not even an empty string) */
1740 if ((first_ch & 0x7f) != '@')
1741 ored_ch |= first_ch;
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00001742
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001743 val = NULL;
1744 switch (first_ch & 0x7f) {
1745 /* Highest bit in first_ch indicates that var is double-quoted */
1746 case '$': /* pid */
1747 val = utoa(G.root_pid);
1748 break;
1749 case '!': /* bg pid */
1750 val = G.last_bg_pid ? utoa(G.last_bg_pid) : (char*)"";
1751 break;
1752 case '?': /* exitcode */
1753 val = utoa(G.last_return_code);
1754 break;
1755 case '#': /* argc */
Mike Frysinger6379bb42009-03-28 18:55:03 +00001756 if (arg[1] != SPECIAL_VAR_SYMBOL)
1757 /* actually, it's a ${#var} */
1758 goto case_default;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001759 val = utoa(G.global_argc ? G.global_argc-1 : 0);
1760 break;
1761 case '*':
1762 case '@':
1763 i = 1;
1764 if (!G.global_argv[i])
1765 break;
1766 ored_ch |= first_ch; /* do it for "$@" _now_, when we know it's not empty */
1767 if (!(first_ch & 0x80)) { /* unquoted $* or $@ */
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00001768 smallint sv = output->o_escape;
1769 /* unquoted var's contents should be globbed, so don't escape */
1770 output->o_escape = 0;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001771 while (G.global_argv[i]) {
1772 n = expand_on_ifs(output, n, G.global_argv[i]);
1773 debug_printf_expand("expand_vars_to_list: argv %d (last %d)\n", i, G.global_argc - 1);
1774 if (G.global_argv[i++][0] && G.global_argv[i]) {
1775 /* this argv[] is not empty and not last:
1776 * put terminating NUL, start new word */
1777 o_addchr(output, '\0');
1778 debug_print_list("expand_vars_to_list[2]", output, n);
1779 n = o_save_ptr(output, n);
1780 debug_print_list("expand_vars_to_list[3]", output, n);
1781 }
1782 }
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00001783 output->o_escape = sv;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001784 } else
1785 /* If or_mask is nonzero, we handle assignment 'a=....$@.....'
1786 * and in this case should treat it like '$*' - see 'else...' below */
1787 if (first_ch == ('@'|0x80) && !or_mask) { /* quoted $@ */
1788 while (1) {
1789 o_addQstr(output, G.global_argv[i], strlen(G.global_argv[i]));
1790 if (++i >= G.global_argc)
1791 break;
1792 o_addchr(output, '\0');
1793 debug_print_list("expand_vars_to_list[4]", output, n);
1794 n = o_save_ptr(output, n);
1795 }
1796 } else { /* quoted $*: add as one word */
1797 while (1) {
1798 o_addQstr(output, G.global_argv[i], strlen(G.global_argv[i]));
1799 if (!G.global_argv[++i])
1800 break;
1801 if (G.ifs[0])
1802 o_addchr(output, G.ifs[0]);
1803 }
1804 }
1805 break;
1806 case SPECIAL_VAR_SYMBOL: /* <SPECIAL_VAR_SYMBOL><SPECIAL_VAR_SYMBOL> */
1807 /* "Empty variable", used to make "" etc to not disappear */
1808 arg++;
1809 ored_ch = 0x80;
1810 break;
1811#if ENABLE_HUSH_TICK
1812 case '`': { /* <SPECIAL_VAR_SYMBOL>`cmd<SPECIAL_VAR_SYMBOL> */
1813 struct in_str input;
1814 *p = '\0';
1815 arg++;
1816//TODO: can we just stuff it into "output" directly?
1817 debug_printf_subst("SUBST '%s' first_ch %x\n", arg, first_ch);
1818 setup_string_in_str(&input, arg);
Denis Vlasenko37181682009-04-03 03:19:15 +00001819 process_command_subs(&subst_result, &input);
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001820 debug_printf_subst("SUBST RES '%s'\n", subst_result.data);
1821 val = subst_result.data;
1822 goto store_val;
Eric Andersen25f27032001-04-26 23:22:31 +00001823 }
Denis Vlasenko96f67dc2007-05-17 13:02:41 +00001824#endif
Mike Frysinger98c52642009-04-02 10:02:37 +00001825#if ENABLE_SH_MATH_SUPPORT
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00001826 case '+': { /* <SPECIAL_VAR_SYMBOL>+cmd<SPECIAL_VAR_SYMBOL> */
Denis Vlasenkob29eb6e2009-04-02 13:46:27 +00001827 arith_eval_hooks_t hooks;
Mike Frysinger98c52642009-04-02 10:02:37 +00001828 arith_t res;
Mike Frysinger98c52642009-04-02 10:02:37 +00001829 int errcode;
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00001830 char *exp_str;
Denis Vlasenkob29eb6e2009-04-02 13:46:27 +00001831
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00001832 arg++; /* skip '+' */
1833 *p = '\0'; /* replace trailing <SPECIAL_VAR_SYMBOL> */
Mike Frysinger98c52642009-04-02 10:02:37 +00001834 debug_printf_subst("ARITH '%s' first_ch %x\n", arg, first_ch);
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00001835
1836 /* Optional: skip expansion if expr is simple ("a + 3", "i++" etc) */
1837 exp_str = arg;
1838 while (1) {
1839 unsigned char c = *exp_str++;
1840 if (c == '\0') {
1841 exp_str = NULL;
1842 goto skip_expand;
1843 }
1844 if (isdigit(c))
1845 continue;
1846 if (strchr(" \t+-*/%_", c) != NULL)
1847 continue;
1848 c |= 0x20; /* tolower */
1849 if (c >= 'a' && c <= 'z')
1850 continue;
1851 break;
1852 }
1853 /* We need to expand. Example: "echo $(($a + 1)) $((1 + $((2)) ))" */
1854 {
1855 struct in_str input;
1856 o_string dest = NULL_O_STRING;
1857
1858 setup_string_in_str(&input, arg);
1859 parse_stream_dquoted(&dest, &input, EOF);
1860 //bb_error_msg("'%s' -> '%s'", arg, dest.data);
1861 exp_str = expand_string_to_string(dest.data);
1862 //bb_error_msg("'%s' -> '%s'", dest.data, exp_str);
1863 o_free(&dest);
1864 }
1865 skip_expand:
Denis Vlasenkob29eb6e2009-04-02 13:46:27 +00001866 hooks.lookupvar = lookup_param;
1867 hooks.setvar = arith_set_local_var;
1868 hooks.endofname = endofname;
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00001869 res = arith(exp_str ? exp_str : arg, &errcode, &hooks);
1870 free(exp_str);
1871
Denis Vlasenkob29eb6e2009-04-02 13:46:27 +00001872 if (errcode < 0) {
Mike Frysinger98c52642009-04-02 10:02:37 +00001873 switch (errcode) {
1874 case -3: maybe_die("arith", "exponent less than 0"); break;
1875 case -2: maybe_die("arith", "divide by zero"); break;
1876 case -5: maybe_die("arith", "expression recursion loop detected"); break;
Denis Vlasenkob29eb6e2009-04-02 13:46:27 +00001877 default: maybe_die("arith", "syntax error"); break;
Mike Frysinger98c52642009-04-02 10:02:37 +00001878 }
Denis Vlasenkob29eb6e2009-04-02 13:46:27 +00001879 }
Mike Frysinger98c52642009-04-02 10:02:37 +00001880 debug_printf_subst("ARITH RES '"arith_t_fmt"'\n", res);
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00001881 sprintf(arith_buf, arith_t_fmt, res);
1882 val = arith_buf;
Mike Frysinger98c52642009-04-02 10:02:37 +00001883 break;
1884 }
1885#endif
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001886 default: /* <SPECIAL_VAR_SYMBOL>varname<SPECIAL_VAR_SYMBOL> */
Mike Frysinger6379bb42009-03-28 18:55:03 +00001887 case_default: {
1888 bool exp_len = false, exp_null = false;
1889 char *var = arg, exp_save, exp_op, *exp_word;
1890 size_t exp_off = 0;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001891 *p = '\0';
1892 arg[0] = first_ch & 0x7f;
Mike Frysinger6379bb42009-03-28 18:55:03 +00001893
1894 /* prepare for expansions */
1895 if (var[0] == '#') {
1896 /* handle length expansion ${#var} */
1897 exp_len = true;
1898 ++var;
1899 } else {
1900 /* maybe handle parameter expansion */
1901 exp_off = strcspn(var, ":-=+?");
1902 if (!var[exp_off])
1903 exp_off = 0;
1904 if (exp_off) {
1905 exp_save = var[exp_off];
1906 exp_null = exp_save == ':';
1907 exp_word = var + exp_off;
1908 if (exp_null) ++exp_word;
1909 exp_op = *exp_word++;
1910 var[exp_off] = '\0';
1911 }
1912 }
1913
1914 /* lookup the variable in question */
1915 if (isdigit(var[0])) {
Mike Frysinger7c3e52c2009-03-28 21:06:22 +00001916 /* handle_dollar() should have vetted var for us */
Mike Frysinger6379bb42009-03-28 18:55:03 +00001917 i = xatoi_u(var);
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001918 if (i < G.global_argc)
1919 val = G.global_argv[i];
1920 /* else val remains NULL: $N with too big N */
1921 } else
Mike Frysinger6379bb42009-03-28 18:55:03 +00001922 val = lookup_param(var);
1923
1924 /* handle any expansions */
1925 if (exp_len) {
1926 debug_printf_expand("expand: length of '%s' = ", val);
1927 val = utoa(val ? strlen(val) : 0);
1928 debug_printf_expand("%s\n", val);
1929 } else if (exp_off) {
1930 /* we need to do an expansion */
1931 int exp_test = (!val || (exp_null && !val[0]));
1932 if (exp_op == '+')
1933 exp_test = !exp_test;
1934 debug_printf_expand("expand: op:%c (null:%s) test:%i\n", exp_op,
1935 exp_null ? "true" : "false", exp_test);
1936 if (exp_test) {
1937 if (exp_op == '?')
1938 maybe_die(var, *exp_word ? exp_word : "parameter null or not set");
1939 else
1940 val = exp_word;
1941
1942 if (exp_op == '=') {
1943 if (isdigit(var[0]) || var[0] == '#') {
1944 maybe_die(var, "special vars cannot assign in this way");
1945 val = NULL;
1946 } else {
1947 char *new_var = xmalloc(strlen(var) + strlen(val) + 2);
1948 sprintf(new_var, "%s=%s", var, val);
1949 set_local_var(new_var, -1);
1950 }
1951 }
1952 }
1953 var[exp_off] = exp_save;
1954 }
1955
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001956 arg[0] = first_ch;
Mike Frysinger6379bb42009-03-28 18:55:03 +00001957
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001958#if ENABLE_HUSH_TICK
1959 store_val:
1960#endif
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001961 if (!(first_ch & 0x80)) { /* unquoted $VAR */
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00001962 debug_printf_expand("unquoted '%s', output->o_escape:%d\n", val, output->o_escape);
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001963 if (val) {
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00001964 /* unquoted var's contents should be globbed, so don't escape */
1965 smallint sv = output->o_escape;
1966 output->o_escape = 0;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001967 n = expand_on_ifs(output, n, val);
1968 val = NULL;
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00001969 output->o_escape = sv;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001970 }
1971 } else { /* quoted $VAR, val will be appended below */
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00001972 debug_printf_expand("quoted '%s', output->o_escape:%d\n", val, output->o_escape);
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001973 }
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00001974 } /* default: */
1975 } /* switch (char after <SPECIAL_VAR_SYMBOL>) */
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001976 if (val) {
1977 o_addQstr(output, val, strlen(val));
1978 }
Mike Frysinger6379bb42009-03-28 18:55:03 +00001979 /* Do the check to avoid writing to a const string */
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00001980 if (*p != SPECIAL_VAR_SYMBOL)
Mike Frysinger6379bb42009-03-28 18:55:03 +00001981 *p = SPECIAL_VAR_SYMBOL;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001982
1983#if ENABLE_HUSH_TICK
1984 o_free(&subst_result);
1985#endif
1986 arg = ++p;
1987 } /* end of "while (SPECIAL_VAR_SYMBOL is found) ..." */
1988
1989 if (arg[0]) {
1990 debug_print_list("expand_vars_to_list[a]", output, n);
1991 /* this part is literal, and it was already pre-quoted
1992 * if needed (much earlier), do not use o_addQstr here! */
Mike Frysinger98c52642009-04-02 10:02:37 +00001993 o_addstrauto(output, arg);
Denis Vlasenko424f79b2009-03-22 14:23:34 +00001994 debug_print_list("expand_vars_to_list[b]", output, n);
1995 } else if (output->length == o_get_last_ptr(output, n) /* expansion is empty */
1996 && !(ored_ch & 0x80) /* and all vars were not quoted. */
1997 ) {
1998 n--;
1999 /* allow to reuse list[n] later without re-growth */
2000 output->has_empty_slot = 1;
2001 } else {
2002 o_addchr(output, '\0');
Eric Andersen25f27032001-04-26 23:22:31 +00002003 }
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002004 return n;
Eric Andersen25f27032001-04-26 23:22:31 +00002005}
2006
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002007static char **expand_variables(char **argv, int or_mask)
Eric Andersen25f27032001-04-26 23:22:31 +00002008{
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002009 int n;
2010 char **list;
2011 char **v;
2012 o_string output = NULL_O_STRING;
2013
2014 if (or_mask & 0x100) {
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00002015 output.o_escape = 1; /* protect against globbing for "$var" */
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002016 /* (unquoted $var will temporarily switch it off) */
2017 output.o_glob = 1;
Eric Andersen25f27032001-04-26 23:22:31 +00002018 }
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002019
2020 n = 0;
2021 v = argv;
2022 while (*v) {
2023 n = expand_vars_to_list(&output, n, *v, (char)or_mask);
2024 v++;
2025 }
2026 debug_print_list("expand_variables", &output, n);
2027
2028 /* output.data (malloced in one block) gets returned in "list" */
2029 list = o_finalize_list(&output, n);
2030 debug_print_strings("expand_variables[1]", list);
2031 return list;
Eric Andersen25f27032001-04-26 23:22:31 +00002032}
2033
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002034static char **expand_strvec_to_strvec(char **argv)
Eric Andersen25f27032001-04-26 23:22:31 +00002035{
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002036 return expand_variables(argv, 0x100);
Eric Andersen25f27032001-04-26 23:22:31 +00002037}
2038
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002039/* Used for expansion of right hand of assignments */
2040/* NB: should NOT do globbing! "export v=/bin/c*; env | grep ^v=" outputs
2041 * "v=/bin/c*" */
2042static char *expand_string_to_string(const char *str)
Eric Andersen25f27032001-04-26 23:22:31 +00002043{
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002044 char *argv[2], **list;
2045
2046 argv[0] = (char*)str;
2047 argv[1] = NULL;
2048 list = expand_variables(argv, 0x80); /* 0x80: make one-element expansion */
2049 if (HUSH_DEBUG)
2050 if (!list[0] || list[1])
2051 bb_error_msg_and_die("BUG in varexp2");
2052 /* actually, just move string 2*sizeof(char*) bytes back */
2053 overlapping_strcpy((char*)list, list[0]);
2054 debug_printf_expand("string_to_string='%s'\n", (char*)list);
2055 return (char*)list;
2056}
2057
2058/* Used for "eval" builtin */
2059static char* expand_strvec_to_string(char **argv)
2060{
2061 char **list;
2062
2063 list = expand_variables(argv, 0x80);
2064 /* Convert all NULs to spaces */
2065 if (list[0]) {
2066 int n = 1;
2067 while (list[n]) {
2068 if (HUSH_DEBUG)
2069 if (list[n-1] + strlen(list[n-1]) + 1 != list[n])
2070 bb_error_msg_and_die("BUG in varexp3");
2071 list[n][-1] = ' '; /* TODO: or to G.ifs[0]? */
2072 n++;
2073 }
2074 }
2075 overlapping_strcpy((char*)list, list[0]);
2076 debug_printf_expand("strvec_to_string='%s'\n", (char*)list);
2077 return (char*)list;
2078}
2079
2080static char **expand_assignments(char **argv, int count)
2081{
2082 int i;
2083 char **p = NULL;
2084 /* Expand assignments into one string each */
2085 for (i = 0; i < count; i++) {
2086 p = add_string_to_strings(p, expand_string_to_string(argv[i]));
2087 }
2088 return p;
Eric Andersen25f27032001-04-26 23:22:31 +00002089}
2090
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00002091
Eric Andersen25f27032001-04-26 23:22:31 +00002092/* squirrel != NULL means we squirrel away copies of stdin, stdout,
2093 * and stderr if they are redirected. */
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002094static int setup_redirects(struct command *prog, int squirrel[])
Eric Andersen25f27032001-04-26 23:22:31 +00002095{
2096 int openfd, mode;
2097 struct redir_struct *redir;
2098
Denis Vlasenko0c886c62007-01-30 22:30:09 +00002099 for (redir = prog->redirects; redir; redir = redir->next) {
Denis Vlasenkoab876cd2008-06-18 16:29:32 +00002100 if (redir->dup == -1 && redir->rd_filename == NULL) {
Eric Andersen817e73c2001-06-06 17:56:09 +00002101 /* something went wrong in the parse. Pretend it didn't happen */
2102 continue;
2103 }
Eric Andersen25f27032001-04-26 23:22:31 +00002104 if (redir->dup == -1) {
Denis Vlasenkocccdc4e2007-11-23 21:08:38 +00002105 char *p;
Denis Vlasenko55789c62008-06-18 16:30:42 +00002106 mode = redir_table[redir->rd_type].mode;
Denis Vlasenko733e3fb2008-07-06 10:01:13 +00002107//TODO: check redir for names like '\\'
Denis Vlasenkoab876cd2008-06-18 16:29:32 +00002108 p = expand_string_to_string(redir->rd_filename);
Denis Vlasenkocccdc4e2007-11-23 21:08:38 +00002109 openfd = open_or_warn(p, mode);
2110 free(p);
Eric Andersen25f27032001-04-26 23:22:31 +00002111 if (openfd < 0) {
2112 /* this could get lost if stderr has been redirected, but
2113 bash and ash both lose it as well (though zsh doesn't!) */
Eric Andersen25f27032001-04-26 23:22:31 +00002114 return 1;
2115 }
2116 } else {
2117 openfd = redir->dup;
2118 }
2119
2120 if (openfd != redir->fd) {
2121 if (squirrel && redir->fd < 3) {
2122 squirrel[redir->fd] = dup(redir->fd);
2123 }
Eric Andersen83a2ae22001-05-07 17:59:25 +00002124 if (openfd == -3) {
Denis Vlasenko8412d792007-10-01 09:59:47 +00002125 //close(openfd); // close(-3) ??!
Eric Andersen83a2ae22001-05-07 17:59:25 +00002126 } else {
2127 dup2(openfd, redir->fd);
Matt Kraaic616e532001-06-05 16:50:08 +00002128 if (redir->dup == -1)
Denis Vlasenkof03dbed2007-04-13 19:55:50 +00002129 close(openfd);
Eric Andersen83a2ae22001-05-07 17:59:25 +00002130 }
Eric Andersen25f27032001-04-26 23:22:31 +00002131 }
2132 }
2133 return 0;
2134}
2135
2136static void restore_redirects(int squirrel[])
2137{
2138 int i, fd;
Denis Vlasenko0c886c62007-01-30 22:30:09 +00002139 for (i = 0; i < 3; i++) {
Eric Andersen25f27032001-04-26 23:22:31 +00002140 fd = squirrel[i];
2141 if (fd != -1) {
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +00002142 /* We simply die on error */
2143 xmove_fd(fd, i);
Eric Andersen25f27032001-04-26 23:22:31 +00002144 }
2145 }
2146}
2147
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002148
2149#if !defined(DEBUG_CLEAN)
2150#define free_pipe_list(head, indent) free_pipe_list(head)
2151#define free_pipe(pi, indent) free_pipe(pi)
2152#endif
Denis Vlasenkob6e65562009-04-03 16:49:04 +00002153static void free_pipe_list(struct pipe *head, int indent);
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002154
2155/* return code is the exit status of the pipe */
Denis Vlasenkob6e65562009-04-03 16:49:04 +00002156static void free_pipe(struct pipe *pi, int indent)
Denis Vlasenkof886fd22008-10-13 12:36:05 +00002157{
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002158 char **p;
2159 struct command *command;
2160 struct redir_struct *r, *rnext;
Denis Vlasenkob6e65562009-04-03 16:49:04 +00002161 int a, i;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002162
2163 if (pi->stopped_cmds > 0)
Denis Vlasenkob6e65562009-04-03 16:49:04 +00002164 return;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002165 debug_printf_clean("%s run pipe: (pid %d)\n", indenter(indent), getpid());
2166 for (i = 0; i < pi->num_cmds; i++) {
2167 command = &pi->cmds[i];
2168 debug_printf_clean("%s command %d:\n", indenter(indent), i);
2169 if (command->argv) {
2170 for (a = 0, p = command->argv; *p; a++, p++) {
2171 debug_printf_clean("%s argv[%d] = %s\n", indenter(indent), a, *p);
2172 }
2173 free_strings(command->argv);
2174 command->argv = NULL;
Denis Vlasenkob6e65562009-04-03 16:49:04 +00002175 }
2176 /* not "else if": on syntax error, we may have both! */
2177 if (command->group) {
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002178 debug_printf_clean("%s begin group (grp_type:%d)\n", indenter(indent), command->grp_type);
Denis Vlasenkob6e65562009-04-03 16:49:04 +00002179 free_pipe_list(command->group, indent+3);
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002180 debug_printf_clean("%s end group\n", indenter(indent));
Denis Vlasenkob6e65562009-04-03 16:49:04 +00002181 command->group = NULL;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002182 }
2183 for (r = command->redirects; r; r = rnext) {
2184 debug_printf_clean("%s redirect %d%s", indenter(indent), r->fd, redir_table[r->rd_type].descrip);
2185 if (r->dup == -1) {
2186 /* guard against the case >$FOO, where foo is unset or blank */
2187 if (r->rd_filename) {
2188 debug_printf_clean(" %s\n", r->rd_filename);
2189 free(r->rd_filename);
2190 r->rd_filename = NULL;
2191 }
2192 } else {
2193 debug_printf_clean("&%d\n", r->dup);
2194 }
2195 rnext = r->next;
2196 free(r);
2197 }
2198 command->redirects = NULL;
Denis Vlasenkof886fd22008-10-13 12:36:05 +00002199 }
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002200 free(pi->cmds); /* children are an array, they get freed all at once */
2201 pi->cmds = NULL;
2202#if ENABLE_HUSH_JOB
2203 free(pi->cmdtext);
2204 pi->cmdtext = NULL;
2205#endif
Denis Vlasenkof886fd22008-10-13 12:36:05 +00002206}
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00002207
Denis Vlasenkob6e65562009-04-03 16:49:04 +00002208static void free_pipe_list(struct pipe *head, int indent)
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002209{
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002210 struct pipe *pi, *next;
2211
2212 for (pi = head; pi; pi = next) {
2213#if HAS_KEYWORDS
2214 debug_printf_clean("%s pipe reserved mode %d\n", indenter(indent), pi->res_word);
2215#endif
Denis Vlasenkob6e65562009-04-03 16:49:04 +00002216 free_pipe(pi, indent);
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002217 debug_printf_clean("%s pipe followup code %d\n", indenter(indent), pi->followup);
2218 next = pi->next;
2219 /*pi->next = NULL;*/
2220 free(pi);
2221 }
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002222}
2223
2224
2225#if !BB_MMU
2226typedef struct nommu_save_t {
2227 char **new_env;
2228 char **old_env;
2229 char **argv;
2230} nommu_save_t;
2231#else
2232#define pseudo_exec_argv(nommu_save, argv, assignment_cnt, argv_expanded) \
2233 pseudo_exec_argv(argv, assignment_cnt, argv_expanded)
2234#define pseudo_exec(nommu_save, command, argv_expanded) \
2235 pseudo_exec(command, argv_expanded)
2236#endif
2237
Denis Vlasenko05743d72008-02-10 12:10:08 +00002238/* Called after [v]fork() in run_pipe(), or from builtin_exec().
Denis Vlasenko8412d792007-10-01 09:59:47 +00002239 * Never returns.
2240 * XXX no exit() here. If you don't exec, use _exit instead.
Eric Andersen94ac2442001-05-22 19:05:18 +00002241 * The at_exit handlers apparently confuse the calling process,
Denis Vlasenko87cb2db2007-04-21 10:00:01 +00002242 * in particular stdin handling. Not sure why? -- because of vfork! (vda) */
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002243static void pseudo_exec_argv(nommu_save_t *nommu_save, char **argv, int assignment_cnt, char **argv_expanded) NORETURN;
Denis Vlasenkof886fd22008-10-13 12:36:05 +00002244static void pseudo_exec_argv(nommu_save_t *nommu_save, char **argv, int assignment_cnt, char **argv_expanded)
Eric Andersen25f27032001-04-26 23:22:31 +00002245{
Denis Vlasenkof886fd22008-10-13 12:36:05 +00002246 int rcode;
2247 char **new_env;
"Vladimir N. Oleynik"485d7cb2005-10-17 09:48:57 +00002248 const struct built_in_command *x;
Denis Vlasenko87cb2db2007-04-21 10:00:01 +00002249
Denis Vlasenko1359da62007-04-21 23:27:30 +00002250 /* If a variable is assigned in a forest, and nobody listens,
2251 * was it ever really set?
2252 */
Denis Vlasenkoafd7a8d2008-10-09 16:29:44 +00002253 if (!argv[assignment_cnt])
Denis Vlasenko1359da62007-04-21 23:27:30 +00002254 _exit(EXIT_SUCCESS);
Denis Vlasenko87cb2db2007-04-21 10:00:01 +00002255
Denis Vlasenko9504e442008-10-29 01:19:15 +00002256 new_env = expand_assignments(argv, assignment_cnt);
Denis Vlasenkof886fd22008-10-13 12:36:05 +00002257#if BB_MMU
2258 putenv_all(new_env);
2259 free(new_env); /* optional */
2260#else
2261 nommu_save->new_env = new_env;
2262 nommu_save->old_env = putenv_all_and_save_old(new_env);
Denis Vlasenkoafd7a8d2008-10-09 16:29:44 +00002263#endif
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +00002264 if (argv_expanded) {
2265 argv = argv_expanded;
2266 } else {
Denis Vlasenko37181682009-04-03 03:19:15 +00002267 argv = expand_strvec_to_strvec(argv + assignment_cnt);
Denis Vlasenko76d50412008-06-10 16:19:39 +00002268#if !BB_MMU
Denis Vlasenkof886fd22008-10-13 12:36:05 +00002269 nommu_save->argv = argv;
Denis Vlasenko76d50412008-06-10 16:19:39 +00002270#endif
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +00002271 }
Denis Vlasenko764d59d2007-05-14 16:23:23 +00002272
Denis Vlasenko1359da62007-04-21 23:27:30 +00002273 /*
2274 * Check if the command matches any of the builtins.
2275 * Depending on context, this might be redundant. But it's
2276 * easier to waste a few CPU cycles than it is to figure out
2277 * if this is one of those cases.
2278 */
Denis Vlasenkodd316dd2008-06-14 15:50:55 +00002279 for (x = bltins; x != &bltins[ARRAY_SIZE(bltins)]; x++) {
Denis Vlasenko1359da62007-04-21 23:27:30 +00002280 if (strcmp(argv[0], x->cmd) == 0) {
Denis Vlasenko764d59d2007-05-14 16:23:23 +00002281 debug_printf_exec("running builtin '%s'\n", argv[0]);
Denis Vlasenko1359da62007-04-21 23:27:30 +00002282 rcode = x->function(argv);
2283 fflush(stdout);
2284 _exit(rcode);
Eric Andersen94ac2442001-05-22 19:05:18 +00002285 }
Denis Vlasenko1359da62007-04-21 23:27:30 +00002286 }
Eric Andersen78a7c992001-05-15 16:30:25 +00002287
Denis Vlasenkoc666f712007-05-16 22:18:54 +00002288 /* Check if the command matches any busybox applets */
Denis Vlasenko80d14be2007-04-10 23:03:30 +00002289#if ENABLE_FEATURE_SH_STANDALONE
Denis Vlasenkoc666f712007-05-16 22:18:54 +00002290 if (strchr(argv[0], '/') == NULL) {
Denis Vlasenko1aa7e472007-11-28 06:49:03 +00002291 int a = find_applet_by_name(argv[0]);
2292 if (a >= 0) {
2293 if (APPLET_IS_NOEXEC(a)) {
Denis Vlasenkoc666f712007-05-16 22:18:54 +00002294 debug_printf_exec("running applet '%s'\n", argv[0]);
Denis Vlasenko1aa7e472007-11-28 06:49:03 +00002295// is it ok that run_applet_no_and_exit() does exit(), not _exit()?
2296 run_applet_no_and_exit(a, argv);
Denis Vlasenkoc666f712007-05-16 22:18:54 +00002297 }
2298 /* re-exec ourselves with the new arguments */
2299 debug_printf_exec("re-execing applet '%s'\n", argv[0]);
Denis Vlasenkobdbbb7e2007-06-08 15:02:55 +00002300 execvp(bb_busybox_exec_path, argv);
Denis Vlasenkoc666f712007-05-16 22:18:54 +00002301 /* If they called chroot or otherwise made the binary no longer
2302 * executable, fall through */
2303 }
2304 }
Eric Andersenaac75e52001-04-30 18:18:45 +00002305#endif
Denis Vlasenkoc666f712007-05-16 22:18:54 +00002306
Denis Vlasenkod5762932009-03-31 11:22:57 +00002307 sigprocmask(SIG_SETMASK, &G.inherited_set, NULL);
2308
Denis Vlasenkoc666f712007-05-16 22:18:54 +00002309 debug_printf_exec("execing '%s'\n", argv[0]);
Denis Vlasenko1359da62007-04-21 23:27:30 +00002310 execvp(argv[0], argv);
Bernhard Reutner-Fischera53de7f2008-07-21 13:46:54 +00002311 bb_perror_msg("can't exec '%s'", argv[0]);
Bernhard Reutner-Fischer636a1f82008-05-19 09:29:47 +00002312 _exit(EXIT_FAILURE);
Denis Vlasenko1359da62007-04-21 23:27:30 +00002313}
2314
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002315static int run_list(struct pipe *pi);
2316
Denis Vlasenko05743d72008-02-10 12:10:08 +00002317/* Called after [v]fork() in run_pipe()
Denis Vlasenko8412d792007-10-01 09:59:47 +00002318 */
Denis Vlasenko424f79b2009-03-22 14:23:34 +00002319static void pseudo_exec(nommu_save_t *nommu_save, struct command *command, char **argv_expanded) NORETURN;
Denis Vlasenkof886fd22008-10-13 12:36:05 +00002320static void pseudo_exec(nommu_save_t *nommu_save, struct command *command, char **argv_expanded)
Denis Vlasenko1359da62007-04-21 23:27:30 +00002321{
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002322 if (command->argv)
Denis Vlasenkof886fd22008-10-13 12:36:05 +00002323 pseudo_exec_argv(nommu_save, command->argv, command->assignment_cnt, argv_expanded);
Denis Vlasenkof03dbed2007-04-13 19:55:50 +00002324
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002325 if (command->group) {
Denis Vlasenko8412d792007-10-01 09:59:47 +00002326#if !BB_MMU
Denis Vlasenko3b492162007-12-24 14:26:57 +00002327 bb_error_msg_and_die("nested lists are not supported on NOMMU");
Denis Vlasenko8412d792007-10-01 09:59:47 +00002328#else
Denis Vlasenko3b492162007-12-24 14:26:57 +00002329 int rcode;
Denis Vlasenko05743d72008-02-10 12:10:08 +00002330 debug_printf_exec("pseudo_exec: run_list\n");
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002331 rcode = run_list(command->group);
Eric Andersenbf7df042001-05-23 22:18:35 +00002332 /* OK to leak memory by not calling free_pipe_list,
Eric Andersen25f27032001-04-26 23:22:31 +00002333 * since this process is about to exit */
Eric Andersen94ac2442001-05-22 19:05:18 +00002334 _exit(rcode);
Denis Vlasenko8412d792007-10-01 09:59:47 +00002335#endif
Eric Andersen25f27032001-04-26 23:22:31 +00002336 }
Denis Vlasenkof03dbed2007-04-13 19:55:50 +00002337
2338 /* Can happen. See what bash does with ">foo" by itself. */
2339 debug_printf("trying to pseudo_exec null command\n");
2340 _exit(EXIT_SUCCESS);
Eric Andersen25f27032001-04-26 23:22:31 +00002341}
2342
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00002343#if ENABLE_HUSH_JOB
Denis Vlasenko3ac0e002007-04-28 16:45:22 +00002344static const char *get_cmdtext(struct pipe *pi)
2345{
2346 char **argv;
2347 char *p;
2348 int len;
2349
2350 /* This is subtle. ->cmdtext is created only on first backgrounding.
2351 * (Think "cat, <ctrl-z>, fg, <ctrl-z>, fg, <ctrl-z>...." here...)
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +00002352 * On subsequent bg argv is trashed, but we won't use it */
Denis Vlasenko3ac0e002007-04-28 16:45:22 +00002353 if (pi->cmdtext)
2354 return pi->cmdtext;
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002355 argv = pi->cmds[0].argv;
Denis Vlasenkoa8442002008-06-14 11:00:17 +00002356 if (!argv || !argv[0]) {
2357 pi->cmdtext = xzalloc(1);
2358 return pi->cmdtext;
2359 }
Denis Vlasenko3ac0e002007-04-28 16:45:22 +00002360
2361 len = 0;
2362 do len += strlen(*argv) + 1; while (*++argv);
2363 pi->cmdtext = p = xmalloc(len);
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002364 argv = pi->cmds[0].argv;
Denis Vlasenko3ac0e002007-04-28 16:45:22 +00002365 do {
2366 len = strlen(*argv);
2367 memcpy(p, *argv, len);
2368 p += len;
2369 *p++ = ' ';
2370 } while (*++argv);
2371 p[-1] = '\0';
2372 return pi->cmdtext;
2373}
2374
Eric Andersenbafd94f2001-05-02 16:11:59 +00002375static void insert_bg_job(struct pipe *pi)
2376{
2377 struct pipe *thejob;
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +00002378 int i;
Eric Andersenbafd94f2001-05-02 16:11:59 +00002379
2380 /* Linear search for the ID of the job to use */
2381 pi->jobid = 1;
Denis Vlasenko87a86552008-07-29 19:43:10 +00002382 for (thejob = G.job_list; thejob; thejob = thejob->next)
Eric Andersenbafd94f2001-05-02 16:11:59 +00002383 if (thejob->jobid >= pi->jobid)
2384 pi->jobid = thejob->jobid + 1;
2385
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +00002386 /* Add thejob to the list of running jobs */
Denis Vlasenko87a86552008-07-29 19:43:10 +00002387 if (!G.job_list) {
2388 thejob = G.job_list = xmalloc(sizeof(*thejob));
Eric Andersenbafd94f2001-05-02 16:11:59 +00002389 } else {
Denis Vlasenko87a86552008-07-29 19:43:10 +00002390 for (thejob = G.job_list; thejob->next; thejob = thejob->next)
Denis Vlasenkof03dbed2007-04-13 19:55:50 +00002391 continue;
Eric Andersenbafd94f2001-05-02 16:11:59 +00002392 thejob->next = xmalloc(sizeof(*thejob));
2393 thejob = thejob->next;
2394 }
2395
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +00002396 /* Physically copy the struct job */
Eric Andersen0fcd4472001-05-02 20:12:03 +00002397 memcpy(thejob, pi, sizeof(struct pipe));
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002398 thejob->cmds = xzalloc(sizeof(pi->cmds[0]) * pi->num_cmds);
2399 /* We cannot copy entire pi->cmds[] vector! Double free()s will happen */
2400 for (i = 0; i < pi->num_cmds; i++) {
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +00002401// TODO: do we really need to have so many fields which are just dead weight
2402// at execution stage?
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002403 thejob->cmds[i].pid = pi->cmds[i].pid;
Denis Vlasenkoc666f712007-05-16 22:18:54 +00002404 /* all other fields are not used and stay zero */
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +00002405 }
Eric Andersenbafd94f2001-05-02 16:11:59 +00002406 thejob->next = NULL;
Denis Vlasenko3ac0e002007-04-28 16:45:22 +00002407 thejob->cmdtext = xstrdup(get_cmdtext(pi));
Eric Andersenbafd94f2001-05-02 16:11:59 +00002408
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +00002409 /* We don't wait for background thejobs to return -- append it
Eric Andersenbafd94f2001-05-02 16:11:59 +00002410 to the list of backgrounded thejobs and leave it alone */
Mike Frysinger87824e02009-03-30 00:19:30 +00002411 if (G.interactive_fd)
2412 printf("[%d] %d %s\n", thejob->jobid, thejob->cmds[0].pid, thejob->cmdtext);
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002413 G.last_bg_pid = thejob->cmds[0].pid;
Denis Vlasenko87a86552008-07-29 19:43:10 +00002414 G.last_jobid = thejob->jobid;
Eric Andersenbafd94f2001-05-02 16:11:59 +00002415}
2416
Eric Andersenbafd94f2001-05-02 16:11:59 +00002417static void remove_bg_job(struct pipe *pi)
2418{
2419 struct pipe *prev_pipe;
2420
Denis Vlasenko87a86552008-07-29 19:43:10 +00002421 if (pi == G.job_list) {
2422 G.job_list = pi->next;
Eric Andersenbafd94f2001-05-02 16:11:59 +00002423 } else {
Denis Vlasenko87a86552008-07-29 19:43:10 +00002424 prev_pipe = G.job_list;
Eric Andersenbafd94f2001-05-02 16:11:59 +00002425 while (prev_pipe->next != pi)
2426 prev_pipe = prev_pipe->next;
2427 prev_pipe->next = pi->next;
2428 }
Denis Vlasenko87a86552008-07-29 19:43:10 +00002429 if (G.job_list)
2430 G.last_jobid = G.job_list->jobid;
Eric Andersen028b65b2001-06-28 01:10:11 +00002431 else
Denis Vlasenko87a86552008-07-29 19:43:10 +00002432 G.last_jobid = 0;
Denis Vlasenko1359da62007-04-21 23:27:30 +00002433}
Eric Andersen028b65b2001-06-28 01:10:11 +00002434
Denis Vlasenko003f9fb2008-06-24 00:47:58 +00002435/* Remove a backgrounded job */
Denis Vlasenko1359da62007-04-21 23:27:30 +00002436static void delete_finished_bg_job(struct pipe *pi)
2437{
2438 remove_bg_job(pi);
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002439 pi->stopped_cmds = 0;
Eric Andersenbf7df042001-05-23 22:18:35 +00002440 free_pipe(pi, 0);
Eric Andersenbafd94f2001-05-02 16:11:59 +00002441 free(pi);
2442}
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +00002443#endif /* JOB */
Eric Andersenbafd94f2001-05-02 16:11:59 +00002444
Denis Vlasenko003f9fb2008-06-24 00:47:58 +00002445/* Check to see if any processes have exited -- if they
2446 * have, figure out why and see if a job has completed */
Eric Andersenc798b072001-06-22 06:23:03 +00002447static int checkjobs(struct pipe* fg_pipe)
Eric Andersenbafd94f2001-05-02 16:11:59 +00002448{
Eric Andersenc798b072001-06-22 06:23:03 +00002449 int attributes;
2450 int status;
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00002451#if ENABLE_HUSH_JOB
Eric Andersenbafd94f2001-05-02 16:11:59 +00002452 struct pipe *pi;
Denis Vlasenkob81b3df2007-04-28 16:48:04 +00002453#endif
Eric Andersenbafd94f2001-05-02 16:11:59 +00002454 pid_t childpid;
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00002455 int rcode = 0;
Eric Andersenbafd94f2001-05-02 16:11:59 +00002456
Denis Vlasenkod5762932009-03-31 11:22:57 +00002457 debug_printf_jobs("checkjobs %p\n", fg_pipe);
2458
Denis Vlasenko7566bae2009-03-31 17:24:49 +00002459 errno = 0;
2460// if (G.handled_SIGCHLD == G.count_SIGCHLD)
2461// /* avoid doing syscall, nothing there anyway */
2462// return rcode;
2463
Eric Andersenc798b072001-06-22 06:23:03 +00002464 attributes = WUNTRACED;
Denis Vlasenko003f9fb2008-06-24 00:47:58 +00002465 if (fg_pipe == NULL)
Eric Andersenc798b072001-06-22 06:23:03 +00002466 attributes |= WNOHANG;
Eric Andersenc798b072001-06-22 06:23:03 +00002467
Denis Vlasenko1359da62007-04-21 23:27:30 +00002468/* Do we do this right?
2469 * bash-3.00# sleep 20 | false
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00002470 * <ctrl-Z pressed>
Denis Vlasenko1359da62007-04-21 23:27:30 +00002471 * [3]+ Stopped sleep 20 | false
2472 * bash-3.00# echo $?
2473 * 1 <========== bg pipe is not fully done, but exitcode is already known!
2474 */
2475
Denis Vlasenkob81b3df2007-04-28 16:48:04 +00002476//FIXME: non-interactive bash does not continue even if all processes in fg pipe
2477//are stopped. Testcase: "cat | cat" in a script (not on command line)
2478// + killall -STOP cat
2479
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00002480 wait_more:
Denis Vlasenko7566bae2009-03-31 17:24:49 +00002481 while (1) {
Denis Vlasenko003f9fb2008-06-24 00:47:58 +00002482 int i;
Denis Vlasenko7566bae2009-03-31 17:24:49 +00002483 int dead;
2484
2485// i = G.count_SIGCHLD;
2486 childpid = waitpid(-1, &status, attributes);
2487 if (childpid <= 0) {
2488 if (childpid && errno != ECHILD)
2489 bb_perror_msg("waitpid");
2490// else /* Until next SIGCHLD, waitpid's are useless */
2491// G.handled_SIGCHLD = i;
2492 break;
2493 }
2494 dead = WIFEXITED(status) || WIFSIGNALED(status);
2495
Denis Vlasenkob61e13d2008-06-17 05:11:43 +00002496#if DEBUG_JOBS
Denis Vlasenko1359da62007-04-21 23:27:30 +00002497 if (WIFSTOPPED(status))
Denis Vlasenkod01ff132007-05-02 21:40:23 +00002498 debug_printf_jobs("pid %d stopped by sig %d (exitcode %d)\n",
Denis Vlasenko1359da62007-04-21 23:27:30 +00002499 childpid, WSTOPSIG(status), WEXITSTATUS(status));
2500 if (WIFSIGNALED(status))
Denis Vlasenkod01ff132007-05-02 21:40:23 +00002501 debug_printf_jobs("pid %d killed by sig %d (exitcode %d)\n",
Denis Vlasenko1359da62007-04-21 23:27:30 +00002502 childpid, WTERMSIG(status), WEXITSTATUS(status));
2503 if (WIFEXITED(status))
Denis Vlasenkod01ff132007-05-02 21:40:23 +00002504 debug_printf_jobs("pid %d exited, exitcode %d\n",
Denis Vlasenko1359da62007-04-21 23:27:30 +00002505 childpid, WEXITSTATUS(status));
2506#endif
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00002507 /* Were we asked to wait for fg pipe? */
Eric Andersenc798b072001-06-22 06:23:03 +00002508 if (fg_pipe) {
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002509 for (i = 0; i < fg_pipe->num_cmds; i++) {
2510 debug_printf_jobs("check pid %d\n", fg_pipe->cmds[i].pid);
2511 if (fg_pipe->cmds[i].pid != childpid)
Denis Vlasenko003f9fb2008-06-24 00:47:58 +00002512 continue;
2513 /* printf("process %d exit %d\n", i, WEXITSTATUS(status)); */
2514 if (dead) {
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002515 fg_pipe->cmds[i].pid = 0;
2516 fg_pipe->alive_cmds--;
2517 if (i == fg_pipe->num_cmds - 1) {
Denis Vlasenko003f9fb2008-06-24 00:47:58 +00002518 /* last process gives overall exitstatus */
2519 rcode = WEXITSTATUS(status);
Denis Vlasenko5ec61322008-06-24 00:50:07 +00002520 IF_HAS_KEYWORDS(if (fg_pipe->pi_inverted) rcode = !rcode;)
Denis Vlasenko1359da62007-04-21 23:27:30 +00002521 }
Denis Vlasenko003f9fb2008-06-24 00:47:58 +00002522 } else {
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002523 fg_pipe->cmds[i].is_stopped = 1;
2524 fg_pipe->stopped_cmds++;
Eric Andersenc798b072001-06-22 06:23:03 +00002525 }
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002526 debug_printf_jobs("fg_pipe: alive_cmds %d stopped_cmds %d\n",
2527 fg_pipe->alive_cmds, fg_pipe->stopped_cmds);
2528 if (fg_pipe->alive_cmds - fg_pipe->stopped_cmds <= 0) {
Denis Vlasenko003f9fb2008-06-24 00:47:58 +00002529 /* All processes in fg pipe have exited/stopped */
2530#if ENABLE_HUSH_JOB
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002531 if (fg_pipe->alive_cmds)
Denis Vlasenko003f9fb2008-06-24 00:47:58 +00002532 insert_bg_job(fg_pipe);
2533#endif
2534 return rcode;
2535 }
2536 /* There are still running processes in the fg pipe */
2537 goto wait_more; /* do waitpid again */
Eric Andersenc798b072001-06-22 06:23:03 +00002538 }
Denis Vlasenko003f9fb2008-06-24 00:47:58 +00002539 /* it wasnt fg_pipe, look for process in bg pipes */
Eric Andersenc798b072001-06-22 06:23:03 +00002540 }
2541
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00002542#if ENABLE_HUSH_JOB
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00002543 /* We asked to wait for bg or orphaned children */
2544 /* No need to remember exitcode in this case */
Denis Vlasenko87a86552008-07-29 19:43:10 +00002545 for (pi = G.job_list; pi; pi = pi->next) {
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002546 for (i = 0; i < pi->num_cmds; i++) {
2547 if (pi->cmds[i].pid == childpid)
Denis Vlasenko5f786c22007-04-20 08:35:45 +00002548 goto found_pi_and_prognum;
Eric Andersen52a97ca2001-06-22 06:49:26 +00002549 }
Eric Andersenbafd94f2001-05-02 16:11:59 +00002550 }
Denis Vlasenko5f786c22007-04-20 08:35:45 +00002551 /* Happens when shell is used as init process (init=/bin/sh) */
2552 debug_printf("checkjobs: pid %d was not in our list!\n", childpid);
Denis Vlasenko003f9fb2008-06-24 00:47:58 +00002553 continue; /* do waitpid again */
Eric Andersenaeb44c42001-05-22 20:29:00 +00002554
Denis Vlasenko5f786c22007-04-20 08:35:45 +00002555 found_pi_and_prognum:
Denis Vlasenko1359da62007-04-21 23:27:30 +00002556 if (dead) {
Eric Andersenbafd94f2001-05-02 16:11:59 +00002557 /* child exited */
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002558 pi->cmds[i].pid = 0;
2559 pi->alive_cmds--;
2560 if (!pi->alive_cmds) {
Mike Frysinger87824e02009-03-30 00:19:30 +00002561 if (G.interactive_fd)
2562 printf(JOB_STATUS_FORMAT, pi->jobid,
2563 "Done", pi->cmdtext);
Denis Vlasenko1359da62007-04-21 23:27:30 +00002564 delete_finished_bg_job(pi);
Eric Andersenbafd94f2001-05-02 16:11:59 +00002565 }
2566 } else {
2567 /* child stopped */
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002568 pi->cmds[i].is_stopped = 1;
2569 pi->stopped_cmds++;
Eric Andersenbafd94f2001-05-02 16:11:59 +00002570 }
Denis Vlasenkob81b3df2007-04-28 16:48:04 +00002571#endif
Denis Vlasenko003f9fb2008-06-24 00:47:58 +00002572 } /* while (waitpid succeeds)... */
Eric Andersenbafd94f2001-05-02 16:11:59 +00002573
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00002574 return rcode;
Eric Andersenada18ff2001-05-21 16:18:22 +00002575}
2576
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00002577#if ENABLE_HUSH_JOB
Denis Vlasenko52881e92007-04-21 13:42:52 +00002578static int checkjobs_and_fg_shell(struct pipe* fg_pipe)
2579{
2580 pid_t p;
2581 int rcode = checkjobs(fg_pipe);
2582 /* Job finished, move the shell to the foreground */
Denis Vlasenko170435c2007-05-23 13:01:10 +00002583 p = getpgid(0); /* pgid of our process */
2584 debug_printf_jobs("fg'ing ourself: getpgid(0)=%d\n", (int)p);
Denis Vlasenko87a86552008-07-29 19:43:10 +00002585 tcsetpgrp(G.interactive_fd, p);
Denis Vlasenko52881e92007-04-21 13:42:52 +00002586 return rcode;
2587}
Denis Vlasenkob81b3df2007-04-28 16:48:04 +00002588#endif
Denis Vlasenko52881e92007-04-21 13:42:52 +00002589
Denis Vlasenko05743d72008-02-10 12:10:08 +00002590/* run_pipe() starts all the jobs, but doesn't wait for anything
Eric Andersenc798b072001-06-22 06:23:03 +00002591 * to finish. See checkjobs().
Eric Andersen25f27032001-04-26 23:22:31 +00002592 *
2593 * return code is normally -1, when the caller has to wait for children
2594 * to finish to determine the exit status of the pipe. If the pipe
2595 * is a simple builtin command, however, the action is done by the
Denis Vlasenko05743d72008-02-10 12:10:08 +00002596 * time run_pipe returns, and the exit code is provided as the
Eric Andersen25f27032001-04-26 23:22:31 +00002597 * return value.
2598 *
2599 * The input of the pipe is always stdin, the output is always
2600 * stdout. The outpipe[] mechanism in BusyBox-0.48 lash is bogus,
2601 * because it tries to avoid running the command substitution in
2602 * subshell, when that is in fact necessary. The subshell process
2603 * now has its stdout directed to the input of the appropriate pipe,
2604 * so this routine is noticeably simpler.
Denis Vlasenko170435c2007-05-23 13:01:10 +00002605 *
2606 * Returns -1 only if started some children. IOW: we have to
2607 * mask out retvals of builtins etc with 0xff!
Eric Andersen25f27032001-04-26 23:22:31 +00002608 */
Denis Vlasenko05743d72008-02-10 12:10:08 +00002609static int run_pipe(struct pipe *pi)
Eric Andersen25f27032001-04-26 23:22:31 +00002610{
2611 int i;
Denis Vlasenkod2c450c2008-01-08 20:32:12 +00002612 int nextin;
2613 int pipefds[2]; /* pipefds[0] is for reading */
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002614 struct command *command;
Denis Vlasenko22d10a02008-10-13 08:53:43 +00002615 char **argv_expanded;
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +00002616 char **argv;
"Vladimir N. Oleynik"485d7cb2005-10-17 09:48:57 +00002617 const struct built_in_command *x;
Eric Andersen4c9b68f2002-04-13 12:33:41 +00002618 char *p;
Denis Vlasenkof5294e12007-04-14 10:09:57 +00002619 /* it is not always needed, but we aim to smaller code */
2620 int squirrel[] = { -1, -1, -1 };
2621 int rcode;
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002622 const int single_and_fg = (pi->num_cmds == 1 && pi->followup != PIPE_BG);
Eric Andersen25f27032001-04-26 23:22:31 +00002623
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +00002624 debug_printf_exec("run_pipe start: single_and_fg=%d\n", single_and_fg);
Denis Vlasenko4ac530c2007-05-02 15:35:45 +00002625
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00002626#if ENABLE_HUSH_JOB
Eric Andersenada18ff2001-05-21 16:18:22 +00002627 pi->pgrp = -1;
Denis Vlasenkob81b3df2007-04-28 16:48:04 +00002628#endif
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002629 pi->alive_cmds = 1;
2630 pi->stopped_cmds = 0;
Eric Andersen25f27032001-04-26 23:22:31 +00002631
2632 /* Check if this is a simple builtin (not part of a pipe).
2633 * Builtins within pipes have to fork anyway, and are handled in
2634 * pseudo_exec. "echo foo | read bar" doesn't work on bash, either.
2635 */
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002636 command = &(pi->cmds[0]);
Denis Vlasenko22d10a02008-10-13 08:53:43 +00002637
Denis Vlasenko371de4a2008-10-14 12:43:13 +00002638#if ENABLE_HUSH_FUNCTIONS
2639 if (single_and_fg && command->group && command->grp_type == GRP_FUNCTION) {
2640 /* We "execute" function definition */
2641 bb_error_msg("here we ought to remember function definition, and go on");
2642 return EXIT_SUCCESS;
2643 }
2644#endif
2645
2646 if (single_and_fg && command->group && command->grp_type == GRP_NORMAL) {
Eric Andersen04407e52001-06-07 16:42:05 +00002647 debug_printf("non-subshell grouping\n");
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002648 setup_redirects(command, squirrel);
Denis Vlasenko05743d72008-02-10 12:10:08 +00002649 debug_printf_exec(": run_list\n");
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002650 rcode = run_list(command->group) & 0xff;
Eric Andersen04407e52001-06-07 16:42:05 +00002651 restore_redirects(squirrel);
Denis Vlasenko05743d72008-02-10 12:10:08 +00002652 debug_printf_exec("run_pipe return %d\n", rcode);
Denis Vlasenko5ec61322008-06-24 00:50:07 +00002653 IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
Denis Vlasenko05743d72008-02-10 12:10:08 +00002654 return rcode;
Denis Vlasenkof03dbed2007-04-13 19:55:50 +00002655 }
2656
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002657 argv = command->argv;
Denis Vlasenko22d10a02008-10-13 08:53:43 +00002658 argv_expanded = NULL;
Denis Vlasenko1359da62007-04-21 23:27:30 +00002659
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +00002660 if (single_and_fg && argv != NULL) {
Denis Vlasenko22d10a02008-10-13 08:53:43 +00002661 char **new_env = NULL;
2662 char **old_env = NULL;
2663
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002664 i = command->assignment_cnt;
Denis Vlasenko1359da62007-04-21 23:27:30 +00002665 if (i != 0 && argv[i] == NULL) {
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +00002666 /* assignments, but no command: set local environment */
Denis Vlasenko1359da62007-04-21 23:27:30 +00002667 for (i = 0; argv[i] != NULL; i++) {
Denis Vlasenkod76c0492007-05-25 02:16:25 +00002668 debug_printf("local environment set: %s\n", argv[i]);
Denis Vlasenko170435c2007-05-23 13:01:10 +00002669 p = expand_string_to_string(argv[i]);
Denis Vlasenkod76c0492007-05-25 02:16:25 +00002670 set_local_var(p, 0);
Eric Andersen78a7c992001-05-15 16:30:25 +00002671 }
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +00002672 return EXIT_SUCCESS; /* don't worry about errors in set_local_var() yet */
Eric Andersen78a7c992001-05-15 16:30:25 +00002673 }
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +00002674
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +00002675 /* Expand the rest into (possibly) many strings each */
2676 argv_expanded = expand_strvec_to_strvec(argv + i);
2677
Denis Vlasenkodd316dd2008-06-14 15:50:55 +00002678 for (x = bltins; x != &bltins[ARRAY_SIZE(bltins)]; x++) {
Denis Vlasenko22d10a02008-10-13 08:53:43 +00002679 if (strcmp(argv_expanded[0], x->cmd) != 0)
2680 continue;
2681 if (x->function == builtin_exec && argv_expanded[1] == NULL) {
2682 debug_printf("exec with redirects only\n");
2683 setup_redirects(command, NULL);
2684 rcode = EXIT_SUCCESS;
2685 goto clean_up_and_ret1;
Eric Andersen25f27032001-04-26 23:22:31 +00002686 }
Denis Vlasenko22d10a02008-10-13 08:53:43 +00002687 debug_printf("builtin inline %s\n", argv_expanded[0]);
2688 /* XXX setup_redirects acts on file descriptors, not FILEs.
2689 * This is perfect for work that comes after exec().
2690 * Is it really safe for inline use? Experimentally,
2691 * things seem to work with glibc. */
2692 setup_redirects(command, squirrel);
2693 new_env = expand_assignments(argv, command->assignment_cnt);
2694 old_env = putenv_all_and_save_old(new_env);
2695 debug_printf_exec(": builtin '%s' '%s'...\n", x->cmd, argv_expanded[1]);
2696 rcode = x->function(argv_expanded) & 0xff;
Denis Vlasenkof886fd22008-10-13 12:36:05 +00002697#if ENABLE_FEATURE_SH_STANDALONE
2698 clean_up_and_ret:
2699#endif
Denis Vlasenko22d10a02008-10-13 08:53:43 +00002700 restore_redirects(squirrel);
2701 free_strings_and_unsetenv(new_env, 1);
2702 putenv_all(old_env);
Denis Vlasenkof886fd22008-10-13 12:36:05 +00002703 free(old_env); /* not free_strings()! */
Denis Vlasenko22d10a02008-10-13 08:53:43 +00002704 clean_up_and_ret1:
2705 free(argv_expanded);
2706 IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
2707 debug_printf_exec("run_pipe return %d\n", rcode);
2708 return rcode;
Eric Andersen25f27032001-04-26 23:22:31 +00002709 }
Denis Vlasenkof5294e12007-04-14 10:09:57 +00002710#if ENABLE_FEATURE_SH_STANDALONE
Denis Vlasenko22d10a02008-10-13 08:53:43 +00002711 i = find_applet_by_name(argv_expanded[0]);
2712 if (i >= 0 && APPLET_IS_NOFORK(i)) {
2713 setup_redirects(command, squirrel);
2714 save_nofork_data(&G.nofork_save);
2715 new_env = expand_assignments(argv, command->assignment_cnt);
2716 old_env = putenv_all_and_save_old(new_env);
2717 debug_printf_exec(": run_nofork_applet '%s' '%s'...\n", argv_expanded[0], argv_expanded[1]);
2718 rcode = run_nofork_applet_prime(&G.nofork_save, i, argv_expanded);
2719 goto clean_up_and_ret;
Denis Vlasenkof5294e12007-04-14 10:09:57 +00002720 }
2721#endif
Eric Andersen25f27032001-04-26 23:22:31 +00002722 }
2723
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +00002724 /* NB: argv_expanded may already be created, and that
2725 * might include `cmd` runs! Do not rerun it! We *must*
2726 * use argv_expanded if it's non-NULL */
2727
Denis Vlasenkod2c450c2008-01-08 20:32:12 +00002728 /* Going to fork a child per each pipe member */
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002729 pi->alive_cmds = 0;
Denis Vlasenkod2c450c2008-01-08 20:32:12 +00002730 nextin = 0;
2731
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002732 for (i = 0; i < pi->num_cmds; i++) {
Denis Vlasenko76d50412008-06-10 16:19:39 +00002733#if !BB_MMU
Denis Vlasenkof886fd22008-10-13 12:36:05 +00002734 volatile nommu_save_t nommu_save;
2735 nommu_save.new_env = NULL;
2736 nommu_save.old_env = NULL;
2737 nommu_save.argv = NULL;
Denis Vlasenko76d50412008-06-10 16:19:39 +00002738#endif
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002739 command = &(pi->cmds[i]);
2740 if (command->argv) {
2741 debug_printf_exec(": pipe member '%s' '%s'...\n", command->argv[0], command->argv[1]);
Denis Vlasenko76d50412008-06-10 16:19:39 +00002742 } else
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +00002743 debug_printf_exec(": pipe member with no argv\n");
Eric Andersen25f27032001-04-26 23:22:31 +00002744
2745 /* pipes are inserted between pairs of commands */
Denis Vlasenkod2c450c2008-01-08 20:32:12 +00002746 pipefds[0] = 0;
2747 pipefds[1] = 1;
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002748 if ((i + 1) < pi->num_cmds)
Denis Vlasenkod2c450c2008-01-08 20:32:12 +00002749 xpipe(pipefds);
Eric Andersen25f27032001-04-26 23:22:31 +00002750
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002751 command->pid = BB_MMU ? fork() : vfork();
2752 if (!command->pid) { /* child */
Denis Vlasenkod2c450c2008-01-08 20:32:12 +00002753#if ENABLE_HUSH_JOB
Denis Vlasenkod5762932009-03-31 11:22:57 +00002754 die_sleep = 0; /* let nofork's xfuncs die */
2755
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00002756 /* Every child adds itself to new process group
Denis Vlasenko05743d72008-02-10 12:10:08 +00002757 * with pgid == pid_of_first_child_in_pipe */
Denis Vlasenko87a86552008-07-29 19:43:10 +00002758 if (G.run_list_level == 1 && G.interactive_fd) {
Denis Vlasenko05743d72008-02-10 12:10:08 +00002759 pid_t pgrp;
Denis Vlasenko05743d72008-02-10 12:10:08 +00002760 pgrp = pi->pgrp;
2761 if (pgrp < 0) /* true for 1st process only */
2762 pgrp = getpid();
2763 if (setpgid(0, pgrp) == 0 && pi->followup != PIPE_BG) {
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00002764 /* We do it in *every* child, not just first,
2765 * to avoid races */
Denis Vlasenko87a86552008-07-29 19:43:10 +00002766 tcsetpgrp(G.interactive_fd, pgrp);
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00002767 }
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00002768 }
Denis Vlasenkob81b3df2007-04-28 16:48:04 +00002769#endif
Denis Vlasenko8412d792007-10-01 09:59:47 +00002770 xmove_fd(nextin, 0);
Denis Vlasenkod2c450c2008-01-08 20:32:12 +00002771 xmove_fd(pipefds[1], 1); /* write end */
2772 if (pipefds[0] > 1)
2773 close(pipefds[0]); /* read end */
Eric Andersen25f27032001-04-26 23:22:31 +00002774 /* Like bash, explicit redirects override pipes,
2775 * and the pipe fd is available for dup'ing. */
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002776 setup_redirects(command, NULL);
Eric Andersen52a97ca2001-06-22 06:49:26 +00002777
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00002778 /* Restore default handlers just prior to exec */
Denis Vlasenkoabedaac2009-03-31 12:03:40 +00002779 /*signal(SIGCHLD, SIG_DFL); - so far we don't have any handlers */
2780
Denis Vlasenkof886fd22008-10-13 12:36:05 +00002781 /* Stores to nommu_save list of env vars putenv'ed
2782 * (NOMMU, on MMU we don't need that) */
2783 /* cast away volatility... */
2784 pseudo_exec((nommu_save_t*) &nommu_save, command, argv_expanded);
Denis Vlasenkoafd7a8d2008-10-09 16:29:44 +00002785 /* pseudo_exec() does not return */
Eric Andersen25f27032001-04-26 23:22:31 +00002786 }
Denis Vlasenkoafd7a8d2008-10-09 16:29:44 +00002787 /* parent */
2788#if !BB_MMU
Denis Vlasenkof886fd22008-10-13 12:36:05 +00002789 /* Clean up after vforked child */
2790 free(nommu_save.argv);
2791 free_strings_and_unsetenv(nommu_save.new_env, 1);
2792 putenv_all(nommu_save.old_env);
Denis Vlasenkoafd7a8d2008-10-09 16:29:44 +00002793#endif
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +00002794 free(argv_expanded);
2795 argv_expanded = NULL;
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002796 if (command->pid < 0) { /* [v]fork failed */
Denis Vlasenkod2c450c2008-01-08 20:32:12 +00002797 /* Clearly indicate, was it fork or vfork */
Denis Vlasenko82604e92008-07-01 15:59:42 +00002798 bb_perror_msg(BB_MMU ? "fork" : "vfork");
Denis Vlasenkod2c450c2008-01-08 20:32:12 +00002799 } else {
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002800 pi->alive_cmds++;
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00002801#if ENABLE_HUSH_JOB
Denis Vlasenkod2c450c2008-01-08 20:32:12 +00002802 /* Second and next children need to know pid of first one */
2803 if (pi->pgrp < 0)
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002804 pi->pgrp = command->pid;
Denis Vlasenkob81b3df2007-04-28 16:48:04 +00002805#endif
Denis Vlasenkod2c450c2008-01-08 20:32:12 +00002806 }
Eric Andersen25f27032001-04-26 23:22:31 +00002807
Denis Vlasenkod2c450c2008-01-08 20:32:12 +00002808 if (i)
2809 close(nextin);
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002810 if ((i + 1) < pi->num_cmds)
Denis Vlasenkod2c450c2008-01-08 20:32:12 +00002811 close(pipefds[1]); /* write end */
2812 /* Pass read (output) pipe end to next iteration */
Eric Andersen25f27032001-04-26 23:22:31 +00002813 nextin = pipefds[0];
2814 }
Denis Vlasenkod2c450c2008-01-08 20:32:12 +00002815
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002816 if (!pi->alive_cmds) {
Denis Vlasenko05743d72008-02-10 12:10:08 +00002817 debug_printf_exec("run_pipe return 1 (all forks failed, no children)\n");
2818 return 1;
2819 }
2820
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002821 debug_printf_exec("run_pipe return -1 (%u children started)\n", pi->alive_cmds);
Eric Andersen25f27032001-04-26 23:22:31 +00002822 return -1;
2823}
2824
Denis Vlasenko4b924f32007-05-30 00:29:55 +00002825#ifndef debug_print_tree
Denis Vlasenko400c5b62007-05-04 13:07:27 +00002826static void debug_print_tree(struct pipe *pi, int lvl)
2827{
Denis Vlasenko371de4a2008-10-14 12:43:13 +00002828 static const char *const PIPE[] = {
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00002829 [PIPE_SEQ] = "SEQ",
2830 [PIPE_AND] = "AND",
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +00002831 [PIPE_OR ] = "OR" ,
2832 [PIPE_BG ] = "BG" ,
Denis Vlasenko400c5b62007-05-04 13:07:27 +00002833 };
2834 static const char *RES[] = {
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00002835 [RES_NONE ] = "NONE" ,
Denis Vlasenko06810332007-05-21 23:30:54 +00002836#if ENABLE_HUSH_IF
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00002837 [RES_IF ] = "IF" ,
2838 [RES_THEN ] = "THEN" ,
2839 [RES_ELIF ] = "ELIF" ,
2840 [RES_ELSE ] = "ELSE" ,
2841 [RES_FI ] = "FI" ,
Denis Vlasenko06810332007-05-21 23:30:54 +00002842#endif
2843#if ENABLE_HUSH_LOOPS
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00002844 [RES_FOR ] = "FOR" ,
2845 [RES_WHILE] = "WHILE",
2846 [RES_UNTIL] = "UNTIL",
2847 [RES_DO ] = "DO" ,
2848 [RES_DONE ] = "DONE" ,
Denis Vlasenkod91afa32008-07-29 11:10:01 +00002849#endif
2850#if ENABLE_HUSH_LOOPS || ENABLE_HUSH_CASE
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00002851 [RES_IN ] = "IN" ,
Denis Vlasenko06810332007-05-21 23:30:54 +00002852#endif
Denis Vlasenko17f02e72008-07-14 04:32:29 +00002853#if ENABLE_HUSH_CASE
2854 [RES_CASE ] = "CASE" ,
2855 [RES_MATCH] = "MATCH",
2856 [RES_CASEI] = "CASEI",
2857 [RES_ESAC ] = "ESAC" ,
2858#endif
Denis Vlasenko06810332007-05-21 23:30:54 +00002859 [RES_XXXX ] = "XXXX" ,
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00002860 [RES_SNTX ] = "SNTX" ,
Denis Vlasenko400c5b62007-05-04 13:07:27 +00002861 };
Denis Vlasenko371de4a2008-10-14 12:43:13 +00002862 static const char *const GRPTYPE[] = {
2863 "()",
2864 "{}",
2865#if ENABLE_HUSH_FUNCTIONS
2866 "func()",
2867#endif
2868 };
Denis Vlasenko400c5b62007-05-04 13:07:27 +00002869
2870 int pin, prn;
Denis Vlasenko219e88d2007-05-21 10:18:23 +00002871
Denis Vlasenko400c5b62007-05-04 13:07:27 +00002872 pin = 0;
2873 while (pi) {
Denis Vlasenko219e88d2007-05-21 10:18:23 +00002874 fprintf(stderr, "%*spipe %d res_word=%s followup=%d %s\n", lvl*2, "",
2875 pin, RES[pi->res_word], pi->followup, PIPE[pi->followup]);
Denis Vlasenko400c5b62007-05-04 13:07:27 +00002876 prn = 0;
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002877 while (prn < pi->num_cmds) {
2878 struct command *command = &pi->cmds[prn];
2879 char **argv = command->argv;
Denis Vlasenkoa6c467f2007-05-05 15:10:52 +00002880
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002881 fprintf(stderr, "%*s prog %d assignment_cnt:%d", lvl*2, "", prn, command->assignment_cnt);
2882 if (command->group) {
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00002883 fprintf(stderr, " group %s: (argv=%p)\n",
Denis Vlasenko371de4a2008-10-14 12:43:13 +00002884 GRPTYPE[command->grp_type],
Denis Vlasenkoa6c467f2007-05-05 15:10:52 +00002885 argv);
Denis Vlasenko9af22c72008-10-09 12:54:58 +00002886 debug_print_tree(command->group, lvl+1);
Denis Vlasenko400c5b62007-05-04 13:07:27 +00002887 prn++;
2888 continue;
2889 }
Denis Vlasenko400c5b62007-05-04 13:07:27 +00002890 if (argv) while (*argv) {
2891 fprintf(stderr, " '%s'", *argv);
2892 argv++;
Denis Vlasenko4b924f32007-05-30 00:29:55 +00002893 }
Denis Vlasenko400c5b62007-05-04 13:07:27 +00002894 fprintf(stderr, "\n");
2895 prn++;
2896 }
2897 pi = pi->next;
2898 pin++;
2899 }
2900}
2901#endif
2902
Denis Vlasenkoc666f712007-05-16 22:18:54 +00002903/* NB: called by pseudo_exec, and therefore must not modify any
2904 * global data until exec/_exit (we can be a child after vfork!) */
Denis Vlasenko05743d72008-02-10 12:10:08 +00002905static int run_list(struct pipe *pi)
Eric Andersen25f27032001-04-26 23:22:31 +00002906{
Denis Vlasenko17f02e72008-07-14 04:32:29 +00002907#if ENABLE_HUSH_CASE
2908 char *case_word = NULL;
2909#endif
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00002910#if ENABLE_HUSH_LOOPS
Denis Vlasenkobcb25532008-07-28 23:04:34 +00002911 struct pipe *loop_top = NULL;
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00002912 char *for_varname = NULL;
2913 char **for_lcur = NULL;
2914 char **for_list = NULL;
Denis Vlasenko06810332007-05-21 23:30:54 +00002915#endif
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00002916 smallint flag_skip = 1;
Denis Vlasenkocf22c892008-07-28 15:17:44 +00002917 smalluint rcode = 0; /* probably just for compiler */
Denis Vlasenkod91afa32008-07-29 11:10:01 +00002918#if ENABLE_HUSH_IF || ENABLE_HUSH_CASE
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00002919 smalluint cond_code = 0;
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00002920#else
Denis Vlasenkobcb25532008-07-28 23:04:34 +00002921 enum { cond_code = 0, };
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00002922#endif
Denis Vlasenkobcb25532008-07-28 23:04:34 +00002923 /*enum reserved_style*/ smallint rword = RES_NONE;
2924 /*enum reserved_style*/ smallint skip_more_for_this_rword = RES_XXXX;
Denis Vlasenko4ac530c2007-05-02 15:35:45 +00002925
Denis Vlasenko87a86552008-07-29 19:43:10 +00002926 debug_printf_exec("run_list start lvl %d\n", G.run_list_level + 1);
Denis Vlasenko4ac530c2007-05-02 15:35:45 +00002927
Denis Vlasenko06810332007-05-21 23:30:54 +00002928#if ENABLE_HUSH_LOOPS
Denis Vlasenkobcb25532008-07-28 23:04:34 +00002929 /* Check syntax for "for" */
Denis Vlasenkocf22c892008-07-28 15:17:44 +00002930 for (struct pipe *cpipe = pi; cpipe; cpipe = cpipe->next) {
2931 if (cpipe->res_word != RES_FOR && cpipe->res_word != RES_IN)
Denis Vlasenko17f02e72008-07-14 04:32:29 +00002932 continue;
2933 /* current word is FOR or IN (BOLD in comments below) */
Denis Vlasenkocf22c892008-07-28 15:17:44 +00002934 if (cpipe->next == NULL) {
Denis Vlasenko17f02e72008-07-14 04:32:29 +00002935 syntax("malformed for");
Denis Vlasenko87a86552008-07-29 19:43:10 +00002936 debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
Denis Vlasenko0c886c62007-01-30 22:30:09 +00002937 return 1;
Eric Andersenc7bda1c2004-03-15 08:29:22 +00002938 }
Denis Vlasenko17f02e72008-07-14 04:32:29 +00002939 /* "FOR v; do ..." and "for v IN a b; do..." are ok */
Denis Vlasenkocf22c892008-07-28 15:17:44 +00002940 if (cpipe->next->res_word == RES_DO)
Denis Vlasenko17f02e72008-07-14 04:32:29 +00002941 continue;
2942 /* next word is not "do". It must be "in" then ("FOR v in ...") */
Denis Vlasenkocf22c892008-07-28 15:17:44 +00002943 if (cpipe->res_word == RES_IN /* "for v IN a b; not_do..."? */
2944 || cpipe->next->res_word != RES_IN /* FOR v not_do_and_not_in..."? */
Denis Vlasenko0c886c62007-01-30 22:30:09 +00002945 ) {
Denis Vlasenkoff182a32008-07-05 20:29:59 +00002946 syntax("malformed for");
Denis Vlasenko87a86552008-07-29 19:43:10 +00002947 debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
Denis Vlasenko0c886c62007-01-30 22:30:09 +00002948 return 1;
Eric Andersen4c9b68f2002-04-13 12:33:41 +00002949 }
2950 }
Denis Vlasenko06810332007-05-21 23:30:54 +00002951#endif
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00002952
Denis Vlasenkobe709c22008-07-28 00:01:16 +00002953 /* Past this point, all code paths should jump to ret: label
Denis Vlasenko12acec52008-07-28 15:15:59 +00002954 * in order to return, no direct "return" statements please.
2955 * This helps to ensure that no memory is leaked. */
Denis Vlasenkobe709c22008-07-28 00:01:16 +00002956
Denis Vlasenkoabedaac2009-03-31 12:03:40 +00002957////TODO: ctrl-Z handling needs re-thinking and re-testing
Denis Vlasenkod5762932009-03-31 11:22:57 +00002958
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00002959#if ENABLE_HUSH_JOB
2960 /* Example of nested list: "while true; do { sleep 1 | exit 2; } done".
2961 * We are saving state before entering outermost list ("while...done")
2962 * so that ctrl-Z will correctly background _entire_ outermost list,
2963 * not just a part of it (like "sleep 1 | exit 2") */
Denis Vlasenko87a86552008-07-29 19:43:10 +00002964 if (++G.run_list_level == 1 && G.interactive_fd) {
2965 if (sigsetjmp(G.toplevel_jb, 1)) {
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00002966 /* ctrl-Z forked and we are parent; or ctrl-C.
2967 * Sighandler has longjmped us here */
2968 signal(SIGINT, SIG_IGN);
2969 signal(SIGTSTP, SIG_IGN);
2970 /* Restore level (we can be coming from deep inside
2971 * nested levels) */
Denis Vlasenko87a86552008-07-29 19:43:10 +00002972 G.run_list_level = 1;
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00002973#if ENABLE_FEATURE_SH_STANDALONE
Denis Vlasenko87a86552008-07-29 19:43:10 +00002974 if (G.nofork_save.saved) { /* if save area is valid */
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00002975 debug_printf_jobs("exiting nofork early\n");
Denis Vlasenko87a86552008-07-29 19:43:10 +00002976 restore_nofork_data(&G.nofork_save);
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00002977 }
2978#endif
Denis Vlasenkod5762932009-03-31 11:22:57 +00002979//// if (G.ctrl_z_flag) {
2980//// /* ctrl-Z has forked and stored pid of the child in pi->pid.
2981//// * Remember this child as background job */
2982//// insert_bg_job(pi);
2983//// } else {
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +00002984 /* ctrl-C. We just stop doing whatever we were doing */
Denis Vlasenko4daad902007-09-27 10:20:47 +00002985 bb_putchar('\n');
Denis Vlasenkod5762932009-03-31 11:22:57 +00002986//// }
Denis Vlasenkoff29b4f2008-07-29 13:57:59 +00002987 USE_HUSH_LOOPS(loop_top = NULL;)
Denis Vlasenko87a86552008-07-29 19:43:10 +00002988 USE_HUSH_LOOPS(G.depth_of_loop = 0;)
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00002989 rcode = 0;
2990 goto ret;
2991 }
Denis Vlasenkod5762932009-03-31 11:22:57 +00002992//// /* ctrl-Z handler will store pid etc in pi */
2993//// G.toplevel_list = pi;
2994//// G.ctrl_z_flag = 0;
2995////#if ENABLE_FEATURE_SH_STANDALONE
2996//// G.nofork_save.saved = 0; /* in case we will run a nofork later */
2997////#endif
2998//// signal_SA_RESTART_empty_mask(SIGTSTP, handler_ctrl_z);
2999//// signal(SIGINT, handler_ctrl_c);
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00003000 }
Denis Vlasenko05743d72008-02-10 12:10:08 +00003001#endif /* JOB */
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00003002
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003003 /* Go through list of pipes, (maybe) executing them. */
3004 for (; pi; pi = USE_HUSH_LOOPS(rword == RES_DONE ? loop_top : ) pi->next) {
Denis Vlasenko422cd7c2009-03-31 12:41:52 +00003005 if (G.flag_SIGINT)
3006 break;
3007
Denis Vlasenko5ec61322008-06-24 00:50:07 +00003008 IF_HAS_KEYWORDS(rword = pi->res_word;)
3009 IF_HAS_NO_KEYWORDS(rword = RES_NONE;)
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003010 debug_printf_exec(": rword=%d cond_code=%d skip_more=%d\n",
3011 rword, cond_code, skip_more_for_this_rword);
Denis Vlasenko06810332007-05-21 23:30:54 +00003012#if ENABLE_HUSH_LOOPS
Denis Vlasenko4554b722008-07-29 13:36:09 +00003013 if ((rword == RES_WHILE || rword == RES_UNTIL || rword == RES_FOR)
Denis Vlasenko87a86552008-07-29 19:43:10 +00003014 && loop_top == NULL /* avoid bumping G.depth_of_loop twice */
Denis Vlasenko4554b722008-07-29 13:36:09 +00003015 ) {
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003016 /* start of a loop: remember where loop starts */
3017 loop_top = pi;
Denis Vlasenko87a86552008-07-29 19:43:10 +00003018 G.depth_of_loop++;
Eric Andersen4c9b68f2002-04-13 12:33:41 +00003019 }
Denis Vlasenko06810332007-05-21 23:30:54 +00003020#endif
Denis Vlasenko219e88d2007-05-21 10:18:23 +00003021 if (rword == skip_more_for_this_rword && flag_skip) {
Denis Vlasenko0c886c62007-01-30 22:30:09 +00003022 if (pi->followup == PIPE_SEQ)
3023 flag_skip = 0;
Denis Vlasenkofcf37c32008-07-29 11:37:15 +00003024 /* it is "<false> && CMD" or "<true> || CMD"
3025 * and we should not execute CMD */
Eric Andersen4c9b68f2002-04-13 12:33:41 +00003026 continue;
3027 }
3028 flag_skip = 1;
Denis Vlasenko219e88d2007-05-21 10:18:23 +00003029 skip_more_for_this_rword = RES_XXXX;
Denis Vlasenko06810332007-05-21 23:30:54 +00003030#if ENABLE_HUSH_IF
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003031 if (cond_code) {
3032 if (rword == RES_THEN) {
3033 /* "if <false> THEN cmd": skip cmd */
3034 continue;
3035 }
3036 } else {
3037 if (rword == RES_ELSE || rword == RES_ELIF) {
3038 /* "if <true> then ... ELSE/ELIF cmd":
3039 * skip cmd and all following ones */
3040 break;
3041 }
3042 }
Denis Vlasenko06810332007-05-21 23:30:54 +00003043#endif
3044#if ENABLE_HUSH_LOOPS
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003045 if (rword == RES_FOR) { /* && pi->num_cmds - always == 1 */
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +00003046 if (!for_lcur) {
Denis Vlasenkod65ea392007-10-01 10:02:25 +00003047 /* first loop through for */
Denis Vlasenkoff182a32008-07-05 20:29:59 +00003048
3049 static const char encoded_dollar_at[] ALIGN1 = {
3050 SPECIAL_VAR_SYMBOL, '@' | 0x80, SPECIAL_VAR_SYMBOL, '\0'
3051 }; /* encoded representation of "$@" */
3052 static const char *const encoded_dollar_at_argv[] = {
3053 encoded_dollar_at, NULL
3054 }; /* argv list with one element: "$@" */
3055 char **vals;
3056
3057 vals = (char**)encoded_dollar_at_argv;
Denis Vlasenkocf22c892008-07-28 15:17:44 +00003058 if (pi->next->res_word == RES_IN) {
Denis Vlasenkoff182a32008-07-05 20:29:59 +00003059 /* if no variable values after "in" we skip "for" */
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003060 if (!pi->next->cmds[0].argv)
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003061 break;
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003062 vals = pi->next->cmds[0].argv;
Denis Vlasenkoff182a32008-07-05 20:29:59 +00003063 } /* else: "for var; do..." -> assume "$@" list */
Eric Andersen4c9b68f2002-04-13 12:33:41 +00003064 /* create list of variable values */
Denis Vlasenkoff182a32008-07-05 20:29:59 +00003065 debug_print_strings("for_list made from", vals);
3066 for_list = expand_strvec_to_strvec(vals);
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +00003067 for_lcur = for_list;
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003068 debug_print_strings("for_list", for_list);
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003069 for_varname = pi->cmds[0].argv[0];
3070 pi->cmds[0].argv[0] = NULL;
Eric Andersenc7bda1c2004-03-15 08:29:22 +00003071 }
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003072 free(pi->cmds[0].argv[0]);
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +00003073 if (!*for_lcur) {
Denis Vlasenko12acec52008-07-28 15:15:59 +00003074 /* "for" loop is over, clean up */
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +00003075 free(for_list);
Denis Vlasenkobe709c22008-07-28 00:01:16 +00003076 for_list = NULL;
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +00003077 for_lcur = NULL;
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003078 pi->cmds[0].argv[0] = for_varname;
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003079 break;
Eric Andersen4c9b68f2002-04-13 12:33:41 +00003080 }
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +00003081 /* insert next value from for_lcur */
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003082//TODO: does it need escaping?
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003083 pi->cmds[0].argv[0] = xasprintf("%s=%s", for_varname, *for_lcur++);
3084 pi->cmds[0].assignment_cnt = 1;
Eric Andersenc7bda1c2004-03-15 08:29:22 +00003085 }
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003086 if (rword == RES_IN) /* "for v IN list;..." - "in" has no cmds anyway */
Denis Vlasenko0c886c62007-01-30 22:30:09 +00003087 continue;
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003088 if (rword == RES_DONE) {
3089 continue; /* "done" has no cmds too */
Eric Andersenc7bda1c2004-03-15 08:29:22 +00003090 }
Denis Vlasenko06810332007-05-21 23:30:54 +00003091#endif
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003092#if ENABLE_HUSH_CASE
3093 if (rword == RES_CASE) {
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003094 case_word = expand_strvec_to_string(pi->cmds->argv);
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003095 continue;
3096 }
3097 if (rword == RES_MATCH) {
Denis Vlasenkofbeeb322008-07-31 00:17:01 +00003098 char **argv;
3099
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003100 if (!case_word) /* "case ... matched_word) ... WORD)": we executed selected branch, stop */
3101 break;
3102 /* all prev words didn't match, does this one match? */
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003103 argv = pi->cmds->argv;
Denis Vlasenkofbeeb322008-07-31 00:17:01 +00003104 while (*argv) {
3105 char *pattern = expand_string_to_string(*argv);
3106 /* TODO: which FNM_xxx flags to use? */
3107 cond_code = (fnmatch(pattern, case_word, /*flags:*/ 0) != 0);
3108 free(pattern);
3109 if (cond_code == 0) { /* match! we will execute this branch */
3110 free(case_word); /* make future "word)" stop */
3111 case_word = NULL;
3112 break;
3113 }
3114 argv++;
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003115 }
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003116 continue;
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003117 }
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003118 if (rword == RES_CASEI) { /* inside of a case branch */
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003119 if (cond_code != 0)
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003120 continue; /* not matched yet, skip this pipe */
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003121 }
3122#endif
Denis Vlasenkod5762932009-03-31 11:22:57 +00003123 /* Just pressing <enter> in shell should check for jobs.
3124 * OTOH, in non-interactive shell this is useless
3125 * and only leads to extra job checks */
3126 if (pi->num_cmds == 0) {
3127 if (G.interactive_fd)
3128 goto check_jobs_and_continue;
3129 continue;
3130 }
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003131
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003132 /* After analyzing all keywords and conditions, we decided
Denis Vlasenkod5762932009-03-31 11:22:57 +00003133 * to execute this pipe. NB: have to do checkjobs(NULL)
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003134 * after run_pipe() to collect any background children,
3135 * even if list execution is to be stopped. */
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003136 debug_printf_exec(": run_pipe with %d members\n", pi->num_cmds);
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003137 {
3138 int r;
Denis Vlasenkodadfb492008-07-29 10:16:05 +00003139#if ENABLE_HUSH_LOOPS
Denis Vlasenko87a86552008-07-29 19:43:10 +00003140 G.flag_break_continue = 0;
Denis Vlasenkodadfb492008-07-29 10:16:05 +00003141#endif
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003142 rcode = r = run_pipe(pi); /* NB: rcode is a smallint */
3143 if (r != -1) {
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003144 /* we only ran a builtin: rcode is already known
3145 * and we don't need to wait for anything. */
Denis Vlasenko7566bae2009-03-31 17:24:49 +00003146 check_and_run_traps(0);
Denis Vlasenkodadfb492008-07-29 10:16:05 +00003147#if ENABLE_HUSH_LOOPS
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003148 /* was it "break" or "continue"? */
Denis Vlasenko87a86552008-07-29 19:43:10 +00003149 if (G.flag_break_continue) {
3150 smallint fbc = G.flag_break_continue;
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003151 /* we might fall into outer *loop*,
3152 * don't want to break it too */
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003153 if (loop_top) {
Denis Vlasenko87a86552008-07-29 19:43:10 +00003154 G.depth_break_continue--;
3155 if (G.depth_break_continue == 0)
3156 G.flag_break_continue = 0;
Denis Vlasenkofcf37c32008-07-29 11:37:15 +00003157 /* else: e.g. "continue 2" should *break* once, *then* continue */
3158 } /* else: "while... do... { we are here (innermost list is not a loop!) };...done" */
Denis Vlasenko87a86552008-07-29 19:43:10 +00003159 if (G.depth_break_continue != 0 || fbc == BC_BREAK)
Denis Vlasenkofcf37c32008-07-29 11:37:15 +00003160 goto check_jobs_and_break;
3161 /* "continue": simulate end of loop */
3162 rword = RES_DONE;
3163 continue;
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003164 }
Denis Vlasenkodadfb492008-07-29 10:16:05 +00003165#endif
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003166 } else if (pi->followup == PIPE_BG) {
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003167 /* what does bash do with attempts to background builtins? */
3168 /* even bash 3.2 doesn't do that well with nested bg:
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003169 * try "{ { sleep 10; echo DEEP; } & echo HERE; } &".
3170 * I'm NOT treating inner &'s as jobs */
Denis Vlasenko7566bae2009-03-31 17:24:49 +00003171 check_and_run_traps(0);
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00003172#if ENABLE_HUSH_JOB
Denis Vlasenko87a86552008-07-29 19:43:10 +00003173 if (G.run_list_level == 1)
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003174 insert_bg_job(pi);
Denis Vlasenkob81b3df2007-04-28 16:48:04 +00003175#endif
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003176 rcode = 0; /* EXIT_SUCCESS */
3177 } else {
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00003178#if ENABLE_HUSH_JOB
Denis Vlasenko87a86552008-07-29 19:43:10 +00003179 if (G.run_list_level == 1 && G.interactive_fd) {
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003180 /* waits for completion, then fg's main shell */
3181 rcode = checkjobs_and_fg_shell(pi);
Denis Vlasenko7566bae2009-03-31 17:24:49 +00003182 check_and_run_traps(0);
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003183 debug_printf_exec(": checkjobs_and_fg_shell returned %d\n", rcode);
3184 } else
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00003185#endif
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003186 { /* this one just waits for completion */
3187 rcode = checkjobs(pi);
Denis Vlasenko7566bae2009-03-31 17:24:49 +00003188 check_and_run_traps(0);
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003189 debug_printf_exec(": checkjobs returned %d\n", rcode);
3190 }
Eric Andersen25f27032001-04-26 23:22:31 +00003191 }
3192 }
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00003193 debug_printf_exec(": setting last_return_code=%d\n", rcode);
Denis Vlasenko87a86552008-07-29 19:43:10 +00003194 G.last_return_code = rcode;
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003195
3196 /* Analyze how result affects subsequent commands */
Denis Vlasenko06810332007-05-21 23:30:54 +00003197#if ENABLE_HUSH_IF
Denis Vlasenko219e88d2007-05-21 10:18:23 +00003198 if (rword == RES_IF || rword == RES_ELIF)
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003199 cond_code = rcode;
Denis Vlasenko06810332007-05-21 23:30:54 +00003200#endif
3201#if ENABLE_HUSH_LOOPS
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003202 if (rword == RES_WHILE) {
Denis Vlasenko918a34b2008-07-28 23:17:31 +00003203 if (rcode) {
3204 rcode = 0; /* "while false; do...done" - exitcode 0 */
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003205 goto check_jobs_and_break;
Denis Vlasenko918a34b2008-07-28 23:17:31 +00003206 }
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003207 }
3208 if (rword == RES_UNTIL) {
Denis Vlasenkobcb25532008-07-28 23:04:34 +00003209 if (!rcode) {
3210 check_jobs_and_break:
3211 checkjobs(NULL);
3212 break;
3213 }
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003214 }
Denis Vlasenko06810332007-05-21 23:30:54 +00003215#endif
Denis Vlasenko5e052ca2008-07-28 15:15:09 +00003216 if ((rcode == 0 && pi->followup == PIPE_OR)
3217 || (rcode != 0 && pi->followup == PIPE_AND)
Denis Vlasenko0c886c62007-01-30 22:30:09 +00003218 ) {
Denis Vlasenko219e88d2007-05-21 10:18:23 +00003219 skip_more_for_this_rword = rword;
Denis Vlasenko0c886c62007-01-30 22:30:09 +00003220 }
Mike Frysinger8ec1c9d2009-03-29 00:45:26 +00003221
3222 check_jobs_and_continue:
Eric Andersen028b65b2001-06-28 01:10:11 +00003223 checkjobs(NULL);
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003224 } /* for (pi) */
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00003225
3226#if ENABLE_HUSH_JOB
Denis Vlasenkod5762932009-03-31 11:22:57 +00003227//// if (G.ctrl_z_flag) {
3228//// /* ctrl-Z forked somewhere in the past, we are the child,
3229//// * and now we completed running the list. Exit. */
3230//////TODO: _exit?
3231//// exit(rcode);
3232//// }
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00003233 ret:
Denis Vlasenkod5762932009-03-31 11:22:57 +00003234 G.run_list_level--;
3235//// if (!G.run_list_level && G.interactive_fd) {
3236//// signal(SIGTSTP, SIG_IGN);
3237//// signal(SIGINT, SIG_IGN);
3238//// }
Denis Vlasenkoac0e5ab2007-05-04 21:37:27 +00003239#endif
Denis Vlasenko87a86552008-07-29 19:43:10 +00003240 debug_printf_exec("run_list lvl %d return %d\n", G.run_list_level + 1, rcode);
Denis Vlasenkobe709c22008-07-28 00:01:16 +00003241#if ENABLE_HUSH_LOOPS
Denis Vlasenkofcf37c32008-07-29 11:37:15 +00003242 if (loop_top)
Denis Vlasenko87a86552008-07-29 19:43:10 +00003243 G.depth_of_loop--;
Denis Vlasenkobe709c22008-07-28 00:01:16 +00003244 free(for_list);
3245#endif
3246#if ENABLE_HUSH_CASE
3247 free(case_word);
3248#endif
Eric Andersen25f27032001-04-26 23:22:31 +00003249 return rcode;
3250}
3251
Eric Andersen25f27032001-04-26 23:22:31 +00003252/* Select which version we will use */
Denis Vlasenko05743d72008-02-10 12:10:08 +00003253static int run_and_free_list(struct pipe *pi)
Eric Andersen25f27032001-04-26 23:22:31 +00003254{
Denis Vlasenko0c886c62007-01-30 22:30:09 +00003255 int rcode = 0;
Denis Vlasenko05743d72008-02-10 12:10:08 +00003256 debug_printf_exec("run_and_free_list entered\n");
Denis Vlasenko87a86552008-07-29 19:43:10 +00003257 if (!G.fake_mode) {
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003258 debug_printf_exec(": run_list with %d members\n", pi->num_cmds);
Denis Vlasenko05743d72008-02-10 12:10:08 +00003259 rcode = run_list(pi);
Eric Andersenc7bda1c2004-03-15 08:29:22 +00003260 }
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +00003261 /* free_pipe_list has the side effect of clearing memory.
Denis Vlasenko05743d72008-02-10 12:10:08 +00003262 * In the long run that function can be merged with run_list,
Eric Andersen25f27032001-04-26 23:22:31 +00003263 * but doing that now would hobble the debugging effort. */
Denis Vlasenko05743d72008-02-10 12:10:08 +00003264 free_pipe_list(pi, /* indent: */ 0);
Denis Vlasenko87f40ba2008-06-10 22:39:37 +00003265 debug_printf_exec("run_and_free_list return %d\n", rcode);
Eric Andersen25f27032001-04-26 23:22:31 +00003266 return rcode;
3267}
3268
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00003269
Denis Vlasenko424f79b2009-03-22 14:23:34 +00003270/* Peek ahead in the in_str to find out if we have a "&n" construct,
3271 * as in "2>&1", that represents duplicating a file descriptor.
3272 * Return either -2 (syntax error), -1 (no &), or the number found.
3273 */
3274static int redirect_dup_num(struct in_str *input)
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +00003275{
Denis Vlasenko424f79b2009-03-22 14:23:34 +00003276 int ch, d = 0, ok = 0;
3277 ch = i_peek(input);
3278 if (ch != '&') return -1;
3279
3280 i_getch(input); /* get the & */
3281 ch = i_peek(input);
3282 if (ch == '-') {
3283 i_getch(input);
3284 return -3; /* "-" represents "close me" */
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +00003285 }
Denis Vlasenko424f79b2009-03-22 14:23:34 +00003286 while (isdigit(ch)) {
3287 d = d*10 + (ch-'0');
3288 ok = 1;
3289 i_getch(input);
3290 ch = i_peek(input);
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +00003291 }
Denis Vlasenko424f79b2009-03-22 14:23:34 +00003292 if (ok) return d;
Denis Vlasenko03eb8bf2007-05-14 16:19:34 +00003293
Denis Vlasenko424f79b2009-03-22 14:23:34 +00003294 bb_error_msg("ambiguous redirect");
3295 return -2;
Eric Andersen78a7c992001-05-15 16:30:25 +00003296}
3297
Denis Vlasenkoff182a32008-07-05 20:29:59 +00003298/* The src parameter allows us to peek forward to a possible &n syntax
Eric Andersen25f27032001-04-26 23:22:31 +00003299 * for file descriptor duplication, e.g., "2>&1".
3300 * Return code is 0 normally, 1 if a syntax error is detected in src.
3301 * Resource errors (in xmalloc) cause the process to exit */
Denis Vlasenkof9f74292009-04-03 00:07:05 +00003302static int setup_redirect(struct parse_context *ctx,
3303 int fd,
3304 redir_type style,
3305 struct in_str *input)
Eric Andersen25f27032001-04-26 23:22:31 +00003306{
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003307 struct command *command = ctx->command;
Denis Vlasenkof9f74292009-04-03 00:07:05 +00003308 struct redir_struct *redir;
3309 struct redir_struct **redirp;
3310 int dup_num;
3311
3312 /* Check for a '2>&1' type redirect */
3313 dup_num = redirect_dup_num(input);
3314 if (dup_num == -2)
3315 return 1; /* syntax error */
Eric Andersen25f27032001-04-26 23:22:31 +00003316
3317 /* Create a new redir_struct and drop it onto the end of the linked list */
Denis Vlasenkof9f74292009-04-03 00:07:05 +00003318 redirp = &command->redirects;
3319 while ((redir = *redirp) != NULL) {
3320 redirp = &(redir->next);
Eric Andersen25f27032001-04-26 23:22:31 +00003321 }
Denis Vlasenkof9f74292009-04-03 00:07:05 +00003322 *redirp = redir = xzalloc(sizeof(*redir));
Denis Vlasenkoff097622007-10-01 10:00:45 +00003323 /* redir->next = NULL; */
Denis Vlasenkoab876cd2008-06-18 16:29:32 +00003324 /* redir->rd_filename = NULL; */
Denis Vlasenko55789c62008-06-18 16:30:42 +00003325 redir->rd_type = style;
Denis Vlasenko0c886c62007-01-30 22:30:09 +00003326 redir->fd = (fd == -1) ? redir_table[style].default_fd : fd;
Eric Andersen25f27032001-04-26 23:22:31 +00003327
3328 debug_printf("Redirect type %d%s\n", redir->fd, redir_table[style].descrip);
3329
Denis Vlasenkof9f74292009-04-03 00:07:05 +00003330 redir->dup = dup_num;
3331 if (dup_num != -1) {
Eric Andersen25f27032001-04-26 23:22:31 +00003332 /* Erik had a check here that the file descriptor in question
Eric Andersen83a2ae22001-05-07 17:59:25 +00003333 * is legit; I postpone that to "run time"
3334 * A "-" representation of "close me" shows up as a -3 here */
Eric Andersen25f27032001-04-26 23:22:31 +00003335 debug_printf("Duplicating redirect '%d>&%d'\n", redir->fd, redir->dup);
3336 } else {
3337 /* We do _not_ try to open the file that src points to,
3338 * since we need to return and let src be expanded first.
3339 * Set ctx->pending_redirect, so we know what to do at the
Denis Vlasenko201c72a2007-05-25 10:00:36 +00003340 * end of the next parsed word. */
Eric Andersen25f27032001-04-26 23:22:31 +00003341 ctx->pending_redirect = redir;
3342 }
3343 return 0;
3344}
3345
Denis Vlasenko424f79b2009-03-22 14:23:34 +00003346
Denis Vlasenkoac678ec2007-04-16 22:32:04 +00003347static struct pipe *new_pipe(void)
3348{
Eric Andersen25f27032001-04-26 23:22:31 +00003349 struct pipe *pi;
Denis Vlasenko3ac0e002007-04-28 16:45:22 +00003350 pi = xzalloc(sizeof(struct pipe));
Denis Vlasenkoa8442002008-06-14 11:00:17 +00003351 /*pi->followup = 0; - deliberately invalid value */
Denis Vlasenko5ec61322008-06-24 00:50:07 +00003352 /*pi->res_word = RES_NONE; - RES_NONE is 0 anyway */
Eric Andersen25f27032001-04-26 23:22:31 +00003353 return pi;
3354}
3355
Denis Vlasenko424f79b2009-03-22 14:23:34 +00003356/* Command (member of a pipe) is complete. The only possible error here
3357 * is out of memory, in which case xmalloc exits. */
3358static int done_command(struct parse_context *ctx)
3359{
3360 /* The command is really already in the pipe structure, so
3361 * advance the pipe counter and make a new, null command. */
3362 struct pipe *pi = ctx->pipe;
3363 struct command *command = ctx->command;
3364
3365 if (command) {
3366 if (command->group == NULL
3367 && command->argv == NULL
3368 && command->redirects == NULL
3369 ) {
3370 debug_printf_parse("done_command: skipping null cmd, num_cmds=%d\n", pi->num_cmds);
3371 return pi->num_cmds;
3372 }
3373 pi->num_cmds++;
3374 debug_printf_parse("done_command: ++num_cmds=%d\n", pi->num_cmds);
3375 } else {
3376 debug_printf_parse("done_command: initializing, num_cmds=%d\n", pi->num_cmds);
3377 }
3378
3379 /* Only real trickiness here is that the uncommitted
3380 * command structure is not counted in pi->num_cmds. */
3381 pi->cmds = xrealloc(pi->cmds, sizeof(*pi->cmds) * (pi->num_cmds+1));
3382 command = &pi->cmds[pi->num_cmds];
3383 memset(command, 0, sizeof(*command));
3384
3385 ctx->command = command;
3386 /* but ctx->pipe and ctx->list_head remain unchanged */
3387
3388 return pi->num_cmds; /* used only for 0/nonzero check */
3389}
3390
3391static void done_pipe(struct parse_context *ctx, pipe_style type)
3392{
3393 int not_null;
3394
3395 debug_printf_parse("done_pipe entered, followup %d\n", type);
3396 /* Close previous command */
3397 not_null = done_command(ctx);
3398 ctx->pipe->followup = type;
3399 IF_HAS_KEYWORDS(ctx->pipe->pi_inverted = ctx->ctx_inverted;)
3400 IF_HAS_KEYWORDS(ctx->ctx_inverted = 0;)
3401 IF_HAS_KEYWORDS(ctx->pipe->res_word = ctx->ctx_res_w;)
3402
3403 /* Without this check, even just <enter> on command line generates
3404 * tree of three NOPs (!). Which is harmless but annoying.
3405 * IOW: it is safe to do it unconditionally.
3406 * RES_NONE case is for "for a in; do ..." (empty IN set)
3407 * to work, possibly other cases too. */
3408 if (not_null IF_HAS_KEYWORDS(|| ctx->ctx_res_w != RES_NONE)) {
3409 struct pipe *new_p;
3410 debug_printf_parse("done_pipe: adding new pipe: "
3411 "not_null:%d ctx->ctx_res_w:%d\n",
3412 not_null, ctx->ctx_res_w);
3413 new_p = new_pipe();
3414 ctx->pipe->next = new_p;
3415 ctx->pipe = new_p;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00003416 /* RES_THEN, RES_DO etc are "sticky" -
3417 * they remain set for commands inside if/while.
3418 * This is used to control execution.
3419 * RES_FOR and RES_IN are NOT sticky (needed to support
3420 * cases where variable or value happens to match a keyword):
3421 */
3422#if ENABLE_HUSH_LOOPS
3423 if (ctx->ctx_res_w == RES_FOR
3424 || ctx->ctx_res_w == RES_IN)
3425 ctx->ctx_res_w = RES_NONE;
3426#endif
3427#if ENABLE_HUSH_CASE
3428 if (ctx->ctx_res_w == RES_MATCH)
3429 ctx->ctx_res_w = RES_CASEI;
3430#endif
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003431 ctx->command = NULL; /* trick done_command below */
Denis Vlasenko424f79b2009-03-22 14:23:34 +00003432 /* Create the memory for command, roughly:
3433 * ctx->pipe->cmds = new struct command;
3434 * ctx->command = &ctx->pipe->cmds[0];
3435 */
3436 done_command(ctx);
3437 }
3438 debug_printf_parse("done_pipe return\n");
3439}
3440
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003441static void initialize_context(struct parse_context *ctx)
Eric Andersen25f27032001-04-26 23:22:31 +00003442{
Denis Vlasenkoa8442002008-06-14 11:00:17 +00003443 memset(ctx, 0, sizeof(*ctx));
Denis Vlasenko1a735862007-05-23 00:32:25 +00003444 ctx->pipe = ctx->list_head = new_pipe();
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003445 /* Create the memory for command, roughly:
3446 * ctx->pipe->cmds = new struct command;
3447 * ctx->command = &ctx->pipe->cmds[0];
Denis Vlasenkoa8442002008-06-14 11:00:17 +00003448 */
3449 done_command(ctx);
Eric Andersen25f27032001-04-26 23:22:31 +00003450}
3451
Denis Vlasenko424f79b2009-03-22 14:23:34 +00003452
Denis Vlasenkoa8442002008-06-14 11:00:17 +00003453/* If a reserved word is found and processed, parse context is modified
3454 * and 1 is returned.
Eric Andersen25f27032001-04-26 23:22:31 +00003455 */
Denis Vlasenko5ec61322008-06-24 00:50:07 +00003456#if HAS_KEYWORDS
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003457struct reserved_combo {
3458 char literal[6];
3459 unsigned char res;
3460 unsigned char assignment_flag;
3461 int flag;
3462};
3463enum {
3464 FLAG_END = (1 << RES_NONE ),
Denis Vlasenkoa8442002008-06-14 11:00:17 +00003465#if ENABLE_HUSH_IF
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003466 FLAG_IF = (1 << RES_IF ),
3467 FLAG_THEN = (1 << RES_THEN ),
3468 FLAG_ELIF = (1 << RES_ELIF ),
3469 FLAG_ELSE = (1 << RES_ELSE ),
3470 FLAG_FI = (1 << RES_FI ),
Denis Vlasenkoa8442002008-06-14 11:00:17 +00003471#endif
3472#if ENABLE_HUSH_LOOPS
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003473 FLAG_FOR = (1 << RES_FOR ),
3474 FLAG_WHILE = (1 << RES_WHILE),
3475 FLAG_UNTIL = (1 << RES_UNTIL),
3476 FLAG_DO = (1 << RES_DO ),
3477 FLAG_DONE = (1 << RES_DONE ),
3478 FLAG_IN = (1 << RES_IN ),
Denis Vlasenkoa8442002008-06-14 11:00:17 +00003479#endif
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003480#if ENABLE_HUSH_CASE
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003481 FLAG_MATCH = (1 << RES_MATCH),
3482 FLAG_ESAC = (1 << RES_ESAC ),
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003483#endif
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003484 FLAG_START = (1 << RES_XXXX ),
3485};
3486
3487static const struct reserved_combo* match_reserved_word(o_string *word)
3488{
Eric Andersen25f27032001-04-26 23:22:31 +00003489 /* Mostly a list of accepted follow-up reserved words.
3490 * FLAG_END means we are done with the sequence, and are ready
3491 * to turn the compound list into a command.
3492 * FLAG_START means the word must start a new compound list.
3493 */
Denis Vlasenkoc72c1ed2007-01-30 22:31:26 +00003494 static const struct reserved_combo reserved_list[] = {
Denis Vlasenko06810332007-05-21 23:30:54 +00003495#if ENABLE_HUSH_IF
Denis Vlasenko2b576b82008-08-04 00:46:07 +00003496 { "!", RES_NONE, NOT_ASSIGNMENT , 0 },
3497 { "if", RES_IF, WORD_IS_KEYWORD, FLAG_THEN | FLAG_START },
3498 { "then", RES_THEN, WORD_IS_KEYWORD, FLAG_ELIF | FLAG_ELSE | FLAG_FI },
3499 { "elif", RES_ELIF, WORD_IS_KEYWORD, FLAG_THEN },
3500 { "else", RES_ELSE, WORD_IS_KEYWORD, FLAG_FI },
3501 { "fi", RES_FI, NOT_ASSIGNMENT , FLAG_END },
Denis Vlasenko06810332007-05-21 23:30:54 +00003502#endif
3503#if ENABLE_HUSH_LOOPS
Denis Vlasenko2b576b82008-08-04 00:46:07 +00003504 { "for", RES_FOR, NOT_ASSIGNMENT , FLAG_IN | FLAG_DO | FLAG_START },
3505 { "while", RES_WHILE, WORD_IS_KEYWORD, FLAG_DO | FLAG_START },
3506 { "until", RES_UNTIL, WORD_IS_KEYWORD, FLAG_DO | FLAG_START },
3507 { "in", RES_IN, NOT_ASSIGNMENT , FLAG_DO },
3508 { "do", RES_DO, WORD_IS_KEYWORD, FLAG_DONE },
3509 { "done", RES_DONE, NOT_ASSIGNMENT , FLAG_END },
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003510#endif
3511#if ENABLE_HUSH_CASE
Denis Vlasenko2b576b82008-08-04 00:46:07 +00003512 { "case", RES_CASE, NOT_ASSIGNMENT , FLAG_MATCH | FLAG_START },
3513 { "esac", RES_ESAC, NOT_ASSIGNMENT , FLAG_END },
Denis Vlasenko06810332007-05-21 23:30:54 +00003514#endif
Eric Andersen25f27032001-04-26 23:22:31 +00003515 };
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003516 const struct reserved_combo *r;
3517
3518 for (r = reserved_list; r < reserved_list + ARRAY_SIZE(reserved_list); r++) {
3519 if (strcmp(word->data, r->literal) == 0)
3520 return r;
3521 }
3522 return NULL;
3523}
3524static int reserved_word(o_string *word, struct parse_context *ctx)
3525{
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003526#if ENABLE_HUSH_CASE
3527 static const struct reserved_combo reserved_match = {
Denis Vlasenko2b576b82008-08-04 00:46:07 +00003528 "", RES_MATCH, NOT_ASSIGNMENT , FLAG_MATCH | FLAG_ESAC
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003529 };
3530#endif
Denis Vlasenkoc72c1ed2007-01-30 22:31:26 +00003531 const struct reserved_combo *r;
Denis Vlasenkoc72c1ed2007-01-30 22:31:26 +00003532
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003533 r = match_reserved_word(word);
3534 if (!r)
3535 return 0;
3536
3537 debug_printf("found reserved word %s, res %d\n", r->literal, r->res);
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003538#if ENABLE_HUSH_CASE
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003539 if (r->res == RES_IN && ctx->ctx_res_w == RES_CASE)
3540 /* "case word IN ..." - IN part starts first match part */
3541 r = &reserved_match;
3542 else
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003543#endif
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003544 if (r->flag == 0) { /* '!' */
3545 if (ctx->ctx_inverted) { /* bash doesn't accept '! ! true' */
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003546 syntax("! ! command");
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003547 IF_HAS_KEYWORDS(ctx->ctx_res_w = RES_SNTX;)
Eric Andersen25f27032001-04-26 23:22:31 +00003548 }
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003549 ctx->ctx_inverted = 1;
Denis Vlasenko1a735862007-05-23 00:32:25 +00003550 return 1;
Eric Andersen25f27032001-04-26 23:22:31 +00003551 }
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003552 if (r->flag & FLAG_START) {
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003553 struct parse_context *old;
3554 old = xmalloc(sizeof(*old));
3555 debug_printf_parse("push stack %p\n", old);
3556 *old = *ctx; /* physical copy */
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003557 initialize_context(ctx);
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003558 ctx->stack = old;
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003559 } else if (/*ctx->ctx_res_w == RES_NONE ||*/ !(ctx->old_flag & (1 << r->res))) {
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003560 syntax(word->data);
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003561 ctx->ctx_res_w = RES_SNTX;
3562 return 1;
3563 }
3564 ctx->ctx_res_w = r->res;
3565 ctx->old_flag = r->flag;
3566 if (ctx->old_flag & FLAG_END) {
3567 struct parse_context *old;
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003568 done_pipe(ctx, PIPE_SEQ);
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003569 debug_printf_parse("pop stack %p\n", ctx->stack);
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003570 old = ctx->stack;
3571 old->command->group = ctx->list_head;
Denis Vlasenko371de4a2008-10-14 12:43:13 +00003572 old->command->grp_type = GRP_NORMAL;
Denis Vlasenkoc3735272008-10-09 12:58:26 +00003573 *ctx = *old; /* physical copy */
3574 free(old);
3575 }
3576 word->o_assignment = r->assignment_flag;
3577 return 1;
Eric Andersen25f27032001-04-26 23:22:31 +00003578}
Denis Vlasenko06810332007-05-21 23:30:54 +00003579#endif
Eric Andersen25f27032001-04-26 23:22:31 +00003580
Denis Vlasenkoa8442002008-06-14 11:00:17 +00003581/* Word is complete, look at it and update parsing context.
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003582 * Normal return is 0. Syntax errors return 1.
3583 * Note: on return, word is reset, but not o_free'd!
3584 */
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003585static int done_word(o_string *word, struct parse_context *ctx)
Eric Andersen25f27032001-04-26 23:22:31 +00003586{
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003587 struct command *command = ctx->command;
Eric Andersen25f27032001-04-26 23:22:31 +00003588
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003589 debug_printf_parse("done_word entered: '%s' %p\n", word->data, command);
Denis Vlasenkoab876cd2008-06-18 16:29:32 +00003590 if (word->length == 0 && word->nonnull == 0) {
3591 debug_printf_parse("done_word return 0: true null, ignored\n");
3592 return 0;
Eric Andersen25f27032001-04-26 23:22:31 +00003593 }
Denis Vlasenko2b576b82008-08-04 00:46:07 +00003594 /* If this word wasn't an assignment, next ones definitely
3595 * can't be assignments. Even if they look like ones. */
3596 if (word->o_assignment != DEFINITELY_ASSIGNMENT
3597 && word->o_assignment != WORD_IS_KEYWORD
3598 ) {
3599 word->o_assignment = NOT_ASSIGNMENT;
3600 } else {
3601 if (word->o_assignment == DEFINITELY_ASSIGNMENT)
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003602 command->assignment_cnt++;
Denis Vlasenko2b576b82008-08-04 00:46:07 +00003603 word->o_assignment = MAYBE_ASSIGNMENT;
3604 }
3605
Eric Andersen25f27032001-04-26 23:22:31 +00003606 if (ctx->pending_redirect) {
Denis Vlasenkoab876cd2008-06-18 16:29:32 +00003607 /* We do not glob in e.g. >*.tmp case. bash seems to glob here
3608 * only if run as "bash", not "sh" */
3609 ctx->pending_redirect->rd_filename = xstrdup(word->data);
Denis Vlasenko55789c62008-06-18 16:30:42 +00003610 word->o_assignment = NOT_ASSIGNMENT;
Denis Vlasenkoab876cd2008-06-18 16:29:32 +00003611 debug_printf("word stored in rd_filename: '%s'\n", word->data);
Eric Andersen25f27032001-04-26 23:22:31 +00003612 } else {
Denis Vlasenko395ae452008-07-14 06:29:38 +00003613 /* "{ echo foo; } echo bar" - bad */
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003614 /* NB: bash allows e.g.:
3615 * if true; then { echo foo; } fi
3616 * while if false; then false; fi do break; done
3617 * TODO? */
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003618 if (command->group) {
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003619 syntax(word->data);
3620 debug_printf_parse("done_word return 1: syntax error, "
3621 "groups and arglists don't mix\n");
Denis Vlasenko395ae452008-07-14 06:29:38 +00003622 return 1;
3623 }
Denis Vlasenko5ec61322008-06-24 00:50:07 +00003624#if HAS_KEYWORDS
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003625#if ENABLE_HUSH_CASE
Denis Vlasenko757361f2008-07-14 08:26:47 +00003626 if (ctx->ctx_dsemicolon
3627 && strcmp(word->data, "esac") != 0 /* not "... pattern) cmd;; esac" */
3628 ) {
Denis Vlasenko395ae452008-07-14 06:29:38 +00003629 /* already done when ctx_dsemicolon was set to 1: */
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003630 /* ctx->ctx_res_w = RES_MATCH; */
3631 ctx->ctx_dsemicolon = 0;
3632 } else
3633#endif
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003634 if (!command->argv /* if it's the first word... */
Denis Vlasenko6bdff082008-07-09 20:14:53 +00003635#if ENABLE_HUSH_LOOPS
Denis Vlasenko733e3fb2008-07-06 10:01:13 +00003636 && ctx->ctx_res_w != RES_FOR /* ...not after FOR or IN */
3637 && ctx->ctx_res_w != RES_IN
Denis Vlasenko6bdff082008-07-09 20:14:53 +00003638#endif
Denis Vlasenko733e3fb2008-07-06 10:01:13 +00003639 ) {
Denis Vlasenkoa8442002008-06-14 11:00:17 +00003640 debug_printf_parse(": checking '%s' for reserved-ness\n", word->data);
3641 if (reserved_word(word, ctx)) {
3642 o_reset(word);
Denis Vlasenko5ec61322008-06-24 00:50:07 +00003643 debug_printf_parse("done_word return %d\n", (ctx->ctx_res_w == RES_SNTX));
3644 return (ctx->ctx_res_w == RES_SNTX);
Denis Vlasenkoe725bfe2007-05-03 22:45:39 +00003645 }
Eric Andersen25f27032001-04-26 23:22:31 +00003646 }
Denis Vlasenko5ec61322008-06-24 00:50:07 +00003647#endif
Denis Vlasenkoff182a32008-07-05 20:29:59 +00003648 if (word->nonnull /* word had "xx" or 'xx' at least as part of it. */
Denis Vlasenko55789c62008-06-18 16:30:42 +00003649 /* optimization: and if it's ("" or '') or ($v... or `cmd`...): */
3650 && (word->data[0] == '\0' || word->data[0] == SPECIAL_VAR_SYMBOL)
Denis Vlasenko733e3fb2008-07-06 10:01:13 +00003651 /* (otherwise it's known to be not empty and is already safe) */
Denis Vlasenkoab876cd2008-06-18 16:29:32 +00003652 ) {
Denis Vlasenko733e3fb2008-07-06 10:01:13 +00003653 /* exclude "$@" - it can expand to no word despite "" */
Denis Vlasenkoafdcd122008-07-05 17:40:04 +00003654 char *p = word->data;
3655 while (p[0] == SPECIAL_VAR_SYMBOL
3656 && (p[1] & 0x7f) == '@'
3657 && p[2] == SPECIAL_VAR_SYMBOL
3658 ) {
3659 p += 3;
3660 }
3661 if (p == word->data || p[0] != '\0') {
Denis Vlasenko733e3fb2008-07-06 10:01:13 +00003662 /* saw no "$@", or not only "$@" but some
3663 * real text is there too */
3664 /* insert "empty variable" reference, this makes
Denis Vlasenkoafdcd122008-07-05 17:40:04 +00003665 * e.g. "", $empty"" etc to not disappear */
3666 o_addchr(word, SPECIAL_VAR_SYMBOL);
3667 o_addchr(word, SPECIAL_VAR_SYMBOL);
3668 }
Denis Vlasenkoc1c63b62008-06-18 09:20:35 +00003669 }
Denis Vlasenko22d10a02008-10-13 08:53:43 +00003670 command->argv = add_string_to_strings(command->argv, xstrdup(word->data));
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003671 debug_print_strings("word appended to argv", command->argv);
Denis Vlasenkoe725bfe2007-05-03 22:45:39 +00003672 }
Eric Andersen25f27032001-04-26 23:22:31 +00003673
Denis Vlasenkoa8442002008-06-14 11:00:17 +00003674 o_reset(word);
Denis Vlasenkoab876cd2008-06-18 16:29:32 +00003675 ctx->pending_redirect = NULL;
3676
Denis Vlasenko06810332007-05-21 23:30:54 +00003677#if ENABLE_HUSH_LOOPS
Denis Vlasenkoab876cd2008-06-18 16:29:32 +00003678 /* Force FOR to have just one word (variable name) */
Denis Vlasenko733e3fb2008-07-06 10:01:13 +00003679 /* NB: basically, this makes hush see "for v in ..." syntax as if
3680 * as it is "for v; in ...". FOR and IN become two pipe structs
3681 * in parse tree. */
3682 if (ctx->ctx_res_w == RES_FOR) {
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003683//TODO: check that command->argv[0] is a valid variable name!
Denis Vlasenkofbf6dea2007-04-13 19:56:56 +00003684 done_pipe(ctx, PIPE_SEQ);
Denis Vlasenko733e3fb2008-07-06 10:01:13 +00003685 }
Denis Vlasenko06810332007-05-21 23:30:54 +00003686#endif
Denis Vlasenko17f02e72008-07-14 04:32:29 +00003687#if ENABLE_HUSH_CASE
3688 /* Force CASE to have just one word */
3689 if (ctx->ctx_res_w == RES_CASE) {
3690 done_pipe(ctx, PIPE_SEQ);
3691 }
3692#endif
Denis Vlasenkoe725bfe2007-05-03 22:45:39 +00003693 debug_printf_parse("done_word return 0\n");
Eric Andersen25f27032001-04-26 23:22:31 +00003694 return 0;
3695}
3696
Eric Andersen25f27032001-04-26 23:22:31 +00003697/* If a redirect is immediately preceded by a number, that number is
3698 * supposed to tell which file descriptor to redirect. This routine
3699 * looks for such preceding numbers. In an ideal world this routine
3700 * needs to handle all the following classes of redirects...
3701 * echo 2>foo # redirects fd 2 to file "foo", nothing passed to echo
3702 * echo 49>foo # redirects fd 49 to file "foo", nothing passed to echo
3703 * echo -2>foo # redirects fd 1 to file "foo", "-2" passed to echo
3704 * echo 49x>foo # redirects fd 1 to file "foo", "49x" passed to echo
3705 * A -1 output from this program means no valid number was found, so the
3706 * caller should use the appropriate default for this redirection.
3707 */
3708static int redirect_opt_num(o_string *o)
3709{
3710 int num;
3711
Denis Vlasenkobb81c582007-01-30 22:32:09 +00003712 if (o->length == 0)
3713 return -1;
3714 for (num = 0; num < o->length; num++) {
Denis Vlasenkoc1c63b62008-06-18 09:20:35 +00003715 if (!isdigit(o->data[num])) {
Eric Andersen25f27032001-04-26 23:22:31 +00003716 return -1;
3717 }
3718 }
Denis Vlasenkobb81c582007-01-30 22:32:09 +00003719 num = atoi(o->data);
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00003720 o_reset(o);
Eric Andersen25f27032001-04-26 23:22:31 +00003721 return num;
3722}
3723
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003724static struct pipe *parse_stream(struct in_str *input, int end_trigger);
Mike Frysingerddbee972009-03-22 22:48:41 +00003725
Denis Vlasenko14b5dd92007-05-20 21:51:38 +00003726#if ENABLE_HUSH_TICK
"Vladimir N. Oleynik"19c37012005-09-22 14:33:15 +00003727static FILE *generate_stream_from_list(struct pipe *head)
Eric Andersen25f27032001-04-26 23:22:31 +00003728{
3729 FILE *pf;
Eric Andersen25f27032001-04-26 23:22:31 +00003730 int pid, channel[2];
Denis Vlasenkoba7cf262007-05-25 14:34:30 +00003731
Denis Vlasenko5a6aedd2007-05-26 16:44:20 +00003732 xpipe(channel);
Denis Vlasenko05743d72008-02-10 12:10:08 +00003733/* *** NOMMU WARNING *** */
3734/* By using vfork here, we suspend parent till child exits or execs.
3735 * If child will not do it before it fills the pipe, it can block forever
3736 * in write(STDOUT_FILENO), and parent (shell) will be also stuck.
Denis Vlasenko3fe4f982008-06-09 16:02:39 +00003737 * Try this script:
3738 * yes "0123456789012345678901234567890" | dd bs=32 count=64k >TESTFILE
3739 * huge=`cat TESTFILE` # will block here forever
3740 * echo OK
Denis Vlasenko05743d72008-02-10 12:10:08 +00003741 */
Denis Vlasenko82604e92008-07-01 15:59:42 +00003742 pid = BB_MMU ? fork() : vfork();
3743 if (pid < 0)
3744 bb_perror_msg_and_die(BB_MMU ? "fork" : "vfork");
Denis Vlasenko05743d72008-02-10 12:10:08 +00003745 if (pid == 0) { /* child */
Denis Vlasenko83177992008-02-11 08:44:36 +00003746 if (ENABLE_HUSH_JOB)
3747 die_sleep = 0; /* let nofork's xfuncs die */
Denis Vlasenko284d0fa2008-02-16 13:18:17 +00003748 close(channel[0]); /* NB: close _first_, then move fd! */
Denis Vlasenko05743d72008-02-10 12:10:08 +00003749 xmove_fd(channel[1], 1);
Denis Vlasenkoba7cf262007-05-25 14:34:30 +00003750 /* Prevent it from trying to handle ctrl-z etc */
Denis Vlasenko27f79ff2007-05-30 00:55:52 +00003751#if ENABLE_HUSH_JOB
Denis Vlasenko87a86552008-07-29 19:43:10 +00003752 G.run_list_level = 1;
Denis Vlasenko27f79ff2007-05-30 00:55:52 +00003753#endif
Denis Vlasenkoba7cf262007-05-25 14:34:30 +00003754 /* Process substitution is not considered to be usual
3755 * 'command execution'.
Denis Vlasenkoabedaac2009-03-31 12:03:40 +00003756 * SUSv3 says ctrl-Z should be ignored, ctrl-C should not.
3757 */
3758 set_jobctrl_signals_to_IGN();
3759
3760 /* Note: freeing 'head' here would break NOMMU. */
Denis Vlasenkoc04163a2008-02-11 08:30:53 +00003761 _exit(run_list(head));
Eric Andersen25f27032001-04-26 23:22:31 +00003762 }
Eric Andersen25f27032001-04-26 23:22:31 +00003763 close(channel[1]);
Denis Vlasenko5f786c22007-04-20 08:35:45 +00003764 pf = fdopen(channel[0], "r");
Eric Andersen25f27032001-04-26 23:22:31 +00003765 return pf;
Denis Vlasenkoc04163a2008-02-11 08:30:53 +00003766 /* 'head' is freed by the caller */
Eric Andersen25f27032001-04-26 23:22:31 +00003767}
3768
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +00003769/* Return code is exit status of the process that is run. */
Denis Vlasenko68404f12008-03-17 09:00:54 +00003770static int process_command_subs(o_string *dest,
Denis Vlasenko37181682009-04-03 03:19:15 +00003771 struct in_str *input)
Eric Andersen25f27032001-04-26 23:22:31 +00003772{
Denis Vlasenko3e9aaae2007-05-11 12:56:43 +00003773 int retcode, ch, eol_cnt;
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003774 struct pipe *pipe_list;
Eric Andersen25f27032001-04-26 23:22:31 +00003775 FILE *p;
3776 struct in_str pipe_str;
Denis Vlasenko3e9aaae2007-05-11 12:56:43 +00003777
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00003778 /* Recursion to generate command */
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003779 pipe_list = parse_stream(input, '\0');
3780 if (pipe_list == NULL)
3781 return 0; /* EOF: empty `cmd`: ``, ` ` etc */
3782 if (pipe_list == ERR_PTR)
3783 return 1; /* parse error. can this really happen? */
Eric Andersen25f27032001-04-26 23:22:31 +00003784
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003785 p = generate_stream_from_list(pipe_list);
3786 free_pipe_list(pipe_list, /* indent: */ 0);
Denis Vlasenko05743d72008-02-10 12:10:08 +00003787 if (p == NULL)
3788 return 1;
Denis Vlasenkoa0898172007-10-01 09:59:01 +00003789 close_on_exec_on(fileno(p));
Eric Andersen25f27032001-04-26 23:22:31 +00003790
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00003791 /* Now send results of command back into original context */
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003792 setup_file_in_str(&pipe_str, p);
Denis Vlasenko3e9aaae2007-05-11 12:56:43 +00003793 eol_cnt = 0;
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00003794 while ((ch = i_getch(&pipe_str)) != EOF) {
Denis Vlasenko3e9aaae2007-05-11 12:56:43 +00003795 if (ch == '\n') {
3796 eol_cnt++;
3797 continue;
3798 }
3799 while (eol_cnt) {
Denis Vlasenko55789c62008-06-18 16:30:42 +00003800 o_addchr(dest, '\n');
Denis Vlasenko3e9aaae2007-05-11 12:56:43 +00003801 eol_cnt--;
3802 }
Denis Vlasenko7e3d33b2008-06-12 13:31:04 +00003803 o_addQchr(dest, ch);
Eric Andersen25f27032001-04-26 23:22:31 +00003804 }
3805
3806 debug_printf("done reading from pipe, pclose()ing\n");
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00003807 /* Note: we got EOF, and we just close the read end of the pipe.
3808 * We do not wait for the `cmd` child to terminate. bash and ash do.
3809 * Try this:
3810 * echo `echo Hi; exec 1>&-; sleep 2`
3811 */
Denis Vlasenkoba7cf262007-05-25 14:34:30 +00003812 retcode = fclose(p);
Denis Vlasenkoba7cf262007-05-25 14:34:30 +00003813 debug_printf("closed FILE from child, retcode=%d\n", retcode);
Eric Andersen25f27032001-04-26 23:22:31 +00003814 return retcode;
3815}
Denis Vlasenko14b5dd92007-05-20 21:51:38 +00003816#endif
Eric Andersen25f27032001-04-26 23:22:31 +00003817
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003818static int parse_group(o_string *dest, struct parse_context *ctx,
Eric Andersen25f27032001-04-26 23:22:31 +00003819 struct in_str *input, int ch)
3820{
Denis Vlasenko371de4a2008-10-14 12:43:13 +00003821 /* dest contains characters seen prior to ( or {.
Denis Vlasenko027e3fd2009-04-02 22:50:40 +00003822 * Typically it's empty, but for function defs,
Denis Vlasenko371de4a2008-10-14 12:43:13 +00003823 * it contains function name (without '()'). */
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003824 struct pipe *pipe_list;
Denis Vlasenko240c2552009-04-03 03:45:05 +00003825 int endch;
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003826 struct command *command = ctx->command;
Denis Vlasenkoe725bfe2007-05-03 22:45:39 +00003827
3828 debug_printf_parse("parse_group entered\n");
Denis Vlasenko371de4a2008-10-14 12:43:13 +00003829#if ENABLE_HUSH_FUNCTIONS
3830 if (ch == 'F') { /* function definition? */
3831 bb_error_msg("aha '%s' is a function, parsing it...", dest->data);
3832 //command->fname = dest->data;
3833 command->grp_type = GRP_FUNCTION;
3834//TODO: review every o_reset() location... do they handle all o_string fields correctly?
3835 memset(dest, 0, sizeof(*dest));
3836 }
3837#endif
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003838 if (command->argv /* word [word](... */
3839 || dest->length /* word(... */
3840 || dest->nonnull /* ""(... */
3841 ) {
Denis Vlasenko90e485c2007-05-23 15:22:50 +00003842 syntax(NULL);
Denis Vlasenkoe725bfe2007-05-03 22:45:39 +00003843 debug_printf_parse("parse_group return 1: syntax error, groups and arglists don't mix\n");
3844 return 1;
Eric Andersen25f27032001-04-26 23:22:31 +00003845 }
Denis Vlasenko240c2552009-04-03 03:45:05 +00003846 endch = '}';
Denis Vlasenko90e485c2007-05-23 15:22:50 +00003847 if (ch == '(') {
Denis Vlasenko240c2552009-04-03 03:45:05 +00003848 endch = ')';
Denis Vlasenko371de4a2008-10-14 12:43:13 +00003849 command->grp_type = GRP_SUBSHELL;
Eric Andersen25f27032001-04-26 23:22:31 +00003850 }
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003851 pipe_list = parse_stream(input, endch);
3852 /* empty ()/{} or parse error? */
3853 if (!pipe_list || pipe_list == ERR_PTR) {
3854 syntax(NULL);
3855 debug_printf_parse("parse_group return 1: parse_stream returned %p\n", pipe_list);
3856 return 1;
Denis Vlasenkof8d01d32008-06-14 17:13:20 +00003857 }
Denis Vlasenkob6e65562009-04-03 16:49:04 +00003858 command->group = pipe_list;
3859 debug_printf_parse("parse_group return 0\n");
3860 return 0;
Denis Vlasenko9af22c72008-10-09 12:54:58 +00003861 /* command remains "open", available for possible redirects */
Eric Andersen25f27032001-04-26 23:22:31 +00003862}
3863
Mike Frysinger98c52642009-04-02 10:02:37 +00003864#if ENABLE_HUSH_TICK || ENABLE_SH_MATH_SUPPORT
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003865/* Subroutines for copying $(...) and `...` things */
3866static void add_till_backquote(o_string *dest, struct in_str *input);
3867/* '...' */
3868static void add_till_single_quote(o_string *dest, struct in_str *input)
3869{
3870 while (1) {
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00003871 int ch = i_getch(input);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003872 if (ch == EOF)
3873 break;
3874 if (ch == '\'')
3875 break;
Denis Vlasenko82dfec32008-06-16 12:47:11 +00003876 o_addchr(dest, ch);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003877 }
3878}
3879/* "...\"...`..`...." - do we need to handle "...$(..)..." too? */
3880static void add_till_double_quote(o_string *dest, struct in_str *input)
3881{
3882 while (1) {
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00003883 int ch = i_getch(input);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003884 if (ch == '"')
3885 break;
3886 if (ch == '\\') { /* \x. Copy both chars. */
Denis Vlasenko82dfec32008-06-16 12:47:11 +00003887 o_addchr(dest, ch);
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00003888 ch = i_getch(input);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003889 }
3890 if (ch == EOF)
3891 break;
Denis Vlasenko82dfec32008-06-16 12:47:11 +00003892 o_addchr(dest, ch);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003893 if (ch == '`') {
3894 add_till_backquote(dest, input);
Denis Vlasenko82dfec32008-06-16 12:47:11 +00003895 o_addchr(dest, ch);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003896 continue;
3897 }
Denis Vlasenko5703c222008-06-15 11:49:42 +00003898 //if (ch == '$') ...
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003899 }
3900}
3901/* Process `cmd` - copy contents until "`" is seen. Complicated by
3902 * \` quoting.
3903 * "Within the backquoted style of command substitution, backslash
3904 * shall retain its literal meaning, except when followed by: '$', '`', or '\'.
3905 * The search for the matching backquote shall be satisfied by the first
3906 * backquote found without a preceding backslash; during this search,
3907 * if a non-escaped backquote is encountered within a shell comment,
3908 * a here-document, an embedded command substitution of the $(command)
3909 * form, or a quoted string, undefined results occur. A single-quoted
3910 * or double-quoted string that begins, but does not end, within the
3911 * "`...`" sequence produces undefined results."
3912 * Example Output
3913 * echo `echo '\'TEST\`echo ZZ\`BEST` \TESTZZBEST
3914 */
3915static void add_till_backquote(o_string *dest, struct in_str *input)
3916{
3917 while (1) {
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00003918 int ch = i_getch(input);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003919 if (ch == '`')
3920 break;
3921 if (ch == '\\') { /* \x. Copy both chars unless it is \` */
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00003922 int ch2 = i_getch(input);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003923 if (ch2 != '`' && ch2 != '$' && ch2 != '\\')
Denis Vlasenko82dfec32008-06-16 12:47:11 +00003924 o_addchr(dest, ch);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003925 ch = ch2;
3926 }
3927 if (ch == EOF)
3928 break;
Denis Vlasenko82dfec32008-06-16 12:47:11 +00003929 o_addchr(dest, ch);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003930 }
3931}
3932/* Process $(cmd) - copy contents until ")" is seen. Complicated by
3933 * quoting and nested ()s.
3934 * "With the $(command) style of command substitution, all characters
3935 * following the open parenthesis to the matching closing parenthesis
3936 * constitute the command. Any valid shell script can be used for command,
3937 * except a script consisting solely of redirections which produces
3938 * unspecified results."
3939 * Example Output
3940 * echo $(echo '(TEST)' BEST) (TEST) BEST
3941 * echo $(echo 'TEST)' BEST) TEST) BEST
3942 * echo $(echo \(\(TEST\) BEST) ((TEST) BEST
3943 */
Mike Frysinger98c52642009-04-02 10:02:37 +00003944static void add_till_closing_paren(o_string *dest, struct in_str *input, bool dbl)
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003945{
3946 int count = 0;
3947 while (1) {
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00003948 int ch = i_getch(input);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003949 if (ch == EOF)
3950 break;
3951 if (ch == '(')
3952 count++;
3953 if (ch == ')')
Mike Frysinger98c52642009-04-02 10:02:37 +00003954 if (--count < 0) {
3955 if (!dbl)
3956 break;
3957 if (i_peek(input) == ')') {
3958 i_getch(input);
3959 break;
3960 }
3961 }
Denis Vlasenko82dfec32008-06-16 12:47:11 +00003962 o_addchr(dest, ch);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003963 if (ch == '\'') {
3964 add_till_single_quote(dest, input);
Denis Vlasenko82dfec32008-06-16 12:47:11 +00003965 o_addchr(dest, ch);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003966 continue;
3967 }
3968 if (ch == '"') {
3969 add_till_double_quote(dest, input);
Denis Vlasenko82dfec32008-06-16 12:47:11 +00003970 o_addchr(dest, ch);
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003971 continue;
3972 }
Denis Vlasenko76db5ad2008-06-12 12:58:20 +00003973 if (ch == '\\') { /* \x. Copy verbatim. Important for \(, \) */
3974 ch = i_getch(input);
3975 if (ch == EOF)
3976 break;
Denis Vlasenko82dfec32008-06-16 12:47:11 +00003977 o_addchr(dest, ch);
Denis Vlasenko76db5ad2008-06-12 12:58:20 +00003978 continue;
3979 }
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003980 }
3981}
Mike Frysinger98c52642009-04-02 10:02:37 +00003982#endif /* ENABLE_HUSH_TICK || ENABLE_SH_MATH_SUPPORT */
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00003983
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00003984/* Return code: 0 for OK, 1 for syntax error */
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00003985static int handle_dollar(o_string *dest, struct in_str *input)
Eric Andersen25f27032001-04-26 23:22:31 +00003986{
Mike Frysinger6379bb42009-03-28 18:55:03 +00003987 int expansion;
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00003988 int ch = i_peek(input); /* first character after the $ */
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00003989 unsigned char quote_mask = dest->o_escape ? 0x80 : 0;
Denis Vlasenkoe0a33672007-05-10 23:06:55 +00003990
3991 debug_printf_parse("handle_dollar entered: ch='%c'\n", ch);
Denis Vlasenko1f4cf512007-05-16 10:39:24 +00003992 if (isalpha(ch)) {
Denis Vlasenkod4981312008-07-31 10:34:48 +00003993 i_getch(input);
3994 make_var:
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00003995 o_addchr(dest, SPECIAL_VAR_SYMBOL);
Denis Vlasenkoe0a33672007-05-10 23:06:55 +00003996 while (1) {
Denis Vlasenkoe0a33672007-05-10 23:06:55 +00003997 debug_printf_parse(": '%c'\n", ch);
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00003998 o_addchr(dest, ch | quote_mask);
Denis Vlasenko1f4cf512007-05-16 10:39:24 +00003999 quote_mask = 0;
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004000 ch = i_peek(input);
Denis Vlasenko602d13c2007-05-13 18:34:53 +00004001 if (!isalnum(ch) && ch != '_')
4002 break;
Denis Vlasenkod4981312008-07-31 10:34:48 +00004003 i_getch(input);
Eric Andersen25f27032001-04-26 23:22:31 +00004004 }
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004005 o_addchr(dest, SPECIAL_VAR_SYMBOL);
Eric Andersen25f27032001-04-26 23:22:31 +00004006 } else if (isdigit(ch)) {
Denis Vlasenko602d13c2007-05-13 18:34:53 +00004007 make_one_char_var:
Denis Vlasenkod4981312008-07-31 10:34:48 +00004008 i_getch(input);
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004009 o_addchr(dest, SPECIAL_VAR_SYMBOL);
Denis Vlasenko602d13c2007-05-13 18:34:53 +00004010 debug_printf_parse(": '%c'\n", ch);
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004011 o_addchr(dest, ch | quote_mask);
4012 o_addchr(dest, SPECIAL_VAR_SYMBOL);
Eric Andersen25f27032001-04-26 23:22:31 +00004013 } else switch (ch) {
Denis Vlasenko602d13c2007-05-13 18:34:53 +00004014 case '$': /* pid */
4015 case '!': /* last bg pid */
4016 case '?': /* last exit code */
4017 case '#': /* number of args */
4018 case '*': /* args */
4019 case '@': /* args */
4020 goto make_one_char_var;
Mike Frysinger6379bb42009-03-28 18:55:03 +00004021 case '{': {
Mike Frysinger7c3e52c2009-03-28 21:06:22 +00004022 bool first_char, all_digits;
Mike Frysinger6379bb42009-03-28 18:55:03 +00004023
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004024 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4025 i_getch(input);
Eric Andersen25f27032001-04-26 23:22:31 +00004026 /* XXX maybe someone will try to escape the '}' */
Mike Frysinger6379bb42009-03-28 18:55:03 +00004027 expansion = 0;
4028 first_char = true;
Mike Frysinger7c3e52c2009-03-28 21:06:22 +00004029 all_digits = false;
Denis Vlasenkobb81c582007-01-30 22:32:09 +00004030 while (1) {
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004031 ch = i_getch(input);
Denis Vlasenkob0550012007-05-24 12:18:16 +00004032 if (ch == '}')
4033 break;
Mike Frysinger6379bb42009-03-28 18:55:03 +00004034
Mike Frysinger7c3e52c2009-03-28 21:06:22 +00004035 if (first_char) {
4036 if (ch == '#')
4037 /* ${#var}: length of var contents */
4038 goto char_ok;
4039 else if (isdigit(ch)) {
4040 all_digits = true;
4041 goto char_ok;
4042 }
4043 }
Mike Frysinger6379bb42009-03-28 18:55:03 +00004044
Mike Frysinger7c3e52c2009-03-28 21:06:22 +00004045 if (expansion < 2 &&
4046 ((all_digits && !isdigit(ch)) ||
4047 (!all_digits && !isalnum(ch) && ch != '_')))
4048 {
Mike Frysinger6379bb42009-03-28 18:55:03 +00004049 /* handle parameter expansions
4050 * http://www.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html#tag_02_06_02
4051 */
4052 if (first_char)
4053 goto case_default;
4054 switch (ch) {
4055 case ':': /* null modifier */
4056 if (expansion == 0) {
4057 debug_printf_parse(": null modifier\n");
4058 ++expansion;
4059 break;
4060 }
4061 goto case_default;
4062
4063#if 0 /* not implemented yet :( */
4064 case '#': /* remove prefix */
4065 case '%': /* remove suffix */
4066 if (expansion == 0) {
4067 debug_printf_parse(": remove suffix/prefix\n");
4068 expansion = 2;
4069 break;
4070 }
4071 goto case_default;
4072#endif
4073
4074 case '-': /* default value */
4075 case '=': /* assign default */
4076 case '+': /* alternative */
4077 case '?': /* error indicate */
4078 debug_printf_parse(": parameter expansion\n");
4079 expansion = 2;
4080 break;
4081
4082 default:
4083 case_default:
4084 syntax("unterminated ${name}");
4085 debug_printf_parse("handle_dollar return 1: unterminated ${name}\n");
4086 return 1;
4087 }
Denis Vlasenkoe0a33672007-05-10 23:06:55 +00004088 }
Mike Frysinger7c3e52c2009-03-28 21:06:22 +00004089
4090 char_ok:
Denis Vlasenkoe0a33672007-05-10 23:06:55 +00004091 debug_printf_parse(": '%c'\n", ch);
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004092 o_addchr(dest, ch | quote_mask);
Denis Vlasenko1f4cf512007-05-16 10:39:24 +00004093 quote_mask = 0;
Mike Frysinger6379bb42009-03-28 18:55:03 +00004094 first_char = false;
Eric Andersen25f27032001-04-26 23:22:31 +00004095 }
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004096 o_addchr(dest, SPECIAL_VAR_SYMBOL);
Eric Andersen25f27032001-04-26 23:22:31 +00004097 break;
Mike Frysinger6379bb42009-03-28 18:55:03 +00004098 }
Denis Vlasenko76db5ad2008-06-12 12:58:20 +00004099 case '(': {
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004100 i_getch(input);
Mike Frysinger98c52642009-04-02 10:02:37 +00004101
4102#if ENABLE_SH_MATH_SUPPORT
4103 if (i_peek(input) == '(') {
4104 i_getch(input);
4105 o_addchr(dest, SPECIAL_VAR_SYMBOL);
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00004106 o_addchr(dest, /*quote_mask |*/ '+');
Mike Frysinger98c52642009-04-02 10:02:37 +00004107 add_till_closing_paren(dest, input, true);
4108 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4109 break;
4110 }
4111#endif
4112
4113#if ENABLE_HUSH_TICK
4114 //int pos = dest->length;
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004115 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4116 o_addchr(dest, quote_mask | '`');
Mike Frysinger98c52642009-04-02 10:02:37 +00004117 add_till_closing_paren(dest, input, false);
Denis Vlasenko30c9cc52008-06-17 07:24:29 +00004118 //debug_printf_subst("SUBST RES2 '%s'\n", dest->data + pos);
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004119 o_addchr(dest, SPECIAL_VAR_SYMBOL);
Mike Frysinger98c52642009-04-02 10:02:37 +00004120#endif
Eric Andersen25f27032001-04-26 23:22:31 +00004121 break;
Denis Vlasenko76db5ad2008-06-12 12:58:20 +00004122 }
Eric Andersen25f27032001-04-26 23:22:31 +00004123 case '_':
Denis Vlasenkod4981312008-07-31 10:34:48 +00004124 i_getch(input);
4125 ch = i_peek(input);
4126 if (isalnum(ch)) { /* it's $_name or $_123 */
4127 ch = '_';
4128 goto make_var;
4129 }
4130 /* else: it's $_ */
4131 case '-':
Eric Andersen25f27032001-04-26 23:22:31 +00004132 /* still unhandled, but should be eventually */
Denis Vlasenkofbf6dea2007-04-13 19:56:56 +00004133 bb_error_msg("unhandled syntax: $%c", ch);
Eric Andersen25f27032001-04-26 23:22:31 +00004134 return 1;
4135 break;
4136 default:
Denis Vlasenko7e3d33b2008-06-12 13:31:04 +00004137 o_addQchr(dest, '$');
Eric Andersen25f27032001-04-26 23:22:31 +00004138 }
Denis Vlasenkoe0a33672007-05-10 23:06:55 +00004139 debug_printf_parse("handle_dollar return 0\n");
Eric Andersen25f27032001-04-26 23:22:31 +00004140 return 0;
4141}
4142
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00004143static int parse_stream_dquoted(o_string *dest, struct in_str *input, int dquote_end)
4144{
4145 int ch, m;
4146 int next;
4147
4148 again:
4149 ch = i_getch(input);
4150 if (ch == dquote_end) { /* may be only '"' or EOF */
4151 dest->nonnull = 1;
4152 if (dest->o_assignment == NOT_ASSIGNMENT)
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00004153 dest->o_escape ^= 1;
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00004154 debug_printf_parse("parse_stream_dquoted return 0\n");
4155 return 0;
4156 }
4157 if (ch == EOF) {
4158 syntax("unterminated \"");
4159 debug_printf_parse("parse_stream_dquoted return 1: unterminated \"\n");
4160 return 1;
4161 }
4162 next = '\0';
4163 m = G.charmap[ch];
4164 if (ch != '\n') {
4165 next = i_peek(input);
4166 }
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00004167 debug_printf_parse(": ch=%c (%d) m=%d escape=%d\n",
4168 ch, ch, m, dest->o_escape);
Denis Vlasenkof328e002009-04-02 16:55:38 +00004169 /* Basically, checking every CHAR_SPECIAL char except '"' */
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00004170 if (ch == '\\') {
4171 if (next == EOF) {
4172 syntax("\\<eof>");
4173 debug_printf_parse("parse_stream_dquoted return 1: \\<eof>\n");
4174 return 1;
4175 }
4176 /* bash:
4177 * "The backslash retains its special meaning [in "..."]
4178 * only when followed by one of the following characters:
4179 * $, `, ", \, or <newline>. A double quote may be quoted
4180 * within double quotes by preceding it with a backslash.
4181 * If enabled, history expansion will be performed unless
4182 * an ! appearing in double quotes is escaped using
4183 * a backslash. The backslash preceding the ! is not removed."
4184 */
4185 if (strchr("$`\"\\", next) != NULL) {
4186 o_addqchr(dest, i_getch(input));
4187 } else {
4188 o_addqchr(dest, '\\');
4189 }
4190 goto again;
4191 }
4192 if (ch == '$') {
4193 if (handle_dollar(dest, input) != 0) {
4194 debug_printf_parse("parse_stream_dquoted return 1: handle_dollar returned non-0\n");
4195 return 1;
4196 }
4197 goto again;
4198 }
4199#if ENABLE_HUSH_TICK
4200 if (ch == '`') {
4201 //int pos = dest->length;
4202 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4203 o_addchr(dest, 0x80 | '`');
4204 add_till_backquote(dest, input);
4205 o_addchr(dest, SPECIAL_VAR_SYMBOL);
4206 //debug_printf_subst("SUBST RES3 '%s'\n", dest->data + pos);
Denis Vlasenkof328e002009-04-02 16:55:38 +00004207 goto again;
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00004208 }
4209#endif
Denis Vlasenkof328e002009-04-02 16:55:38 +00004210 o_addQchr(dest, ch);
4211 if (ch == '='
4212 && (dest->o_assignment == MAYBE_ASSIGNMENT
4213 || dest->o_assignment == WORD_IS_KEYWORD)
4214 && is_assignment(dest->data)
4215 ) {
4216 dest->o_assignment = DEFINITELY_ASSIGNMENT;
4217 }
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00004218 goto again;
4219}
4220
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004221/*
4222 * Scan input until EOF or end_trigger char.
4223 * Return a list of pipes to execute, or NULL on EOF
4224 * or if end_trigger character is met.
4225 * On syntax error, exit is shell is not interactive,
4226 * reset parsing machinery and start parsing anew,
4227 * or return ERR_PTR.
Denis Vlasenko027e3fd2009-04-02 22:50:40 +00004228 */
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004229static struct pipe *parse_stream(struct in_str *input, int end_trigger)
Eric Andersen25f27032001-04-26 23:22:31 +00004230{
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004231 struct parse_context ctx;
4232 o_string dest = NULL_O_STRING;
"Vladimir N. Oleynik"4ccd2b42006-01-31 09:27:48 +00004233 int ch, m;
Eric Andersen25f27032001-04-26 23:22:31 +00004234 int redir_fd;
4235 redir_type redir_style;
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00004236 int is_in_dquote;
Eric Andersen25f27032001-04-26 23:22:31 +00004237 int next;
4238
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00004239 /* Double-quote state is handled in the state variable is_in_dquote.
Eric Andersen25f27032001-04-26 23:22:31 +00004240 * A single-quote triggers a bypass of the main loop until its mate is
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00004241 * found. When recursing, quote state is passed in via dest->o_escape. */
Eric Andersen25f27032001-04-26 23:22:31 +00004242
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004243 debug_printf_parse("parse_stream entered, end_trigger='%c'\n",
4244 end_trigger ? : 'X');
Denis Vlasenkoe725bfe2007-05-03 22:45:39 +00004245
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004246 reset:
4247#if ENABLE_HUSH_INTERACTIVE
4248 input->promptmode = 0; /* PS1 */
4249#endif
4250 /* dest.o_assignment = MAYBE_ASSIGNMENT; - already is */
4251 initialize_context(&ctx);
4252 is_in_dquote = 0;
Denis Vlasenko1a735862007-05-23 00:32:25 +00004253 while (1) {
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00004254 if (is_in_dquote) {
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004255 if (parse_stream_dquoted(&dest, input, '"')) {
4256 goto parse_error;
4257 }
4258 /* We reached closing '"' */
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00004259 is_in_dquote = 0;
4260 }
Denis Vlasenko1a735862007-05-23 00:32:25 +00004261 m = CHAR_IFS;
4262 next = '\0';
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004263 ch = i_getch(input);
Denis Vlasenko1a735862007-05-23 00:32:25 +00004264 if (ch != EOF) {
Denis Vlasenko87a86552008-07-29 19:43:10 +00004265 m = G.charmap[ch];
Denis Vlasenko55789c62008-06-18 16:30:42 +00004266 if (ch != '\n') {
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004267 next = i_peek(input);
Denis Vlasenko55789c62008-06-18 16:30:42 +00004268 }
Denis Vlasenko1a735862007-05-23 00:32:25 +00004269 }
Denis Vlasenkob7aaae92009-04-02 20:17:49 +00004270 debug_printf_parse(": ch=%c (%d) m=%d escape=%d\n",
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004271 ch, ch, m, dest.o_escape);
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00004272 if (m == CHAR_ORDINARY) {
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004273 o_addQchr(&dest, ch);
4274 if ((dest.o_assignment == MAYBE_ASSIGNMENT
4275 || dest.o_assignment == WORD_IS_KEYWORD)
Denis Vlasenko55789c62008-06-18 16:30:42 +00004276 && ch == '='
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004277 && is_assignment(dest.data)
Denis Vlasenko55789c62008-06-18 16:30:42 +00004278 ) {
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004279 dest.o_assignment = DEFINITELY_ASSIGNMENT;
Denis Vlasenko55789c62008-06-18 16:30:42 +00004280 }
Denis Vlasenkobb81c582007-01-30 22:32:09 +00004281 continue;
4282 }
Denis Vlasenko240c2552009-04-03 03:45:05 +00004283
Denis Vlasenko37181682009-04-03 03:19:15 +00004284 /* m is SPECIAL ($,`), IFS, or ORDINARY_IF_QUOTED (*,#) */
Denis Vlasenko240c2552009-04-03 03:45:05 +00004285
Denis Vlasenko8f6bdb42007-05-16 09:36:55 +00004286 if (m == CHAR_IFS) {
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004287 if (ch == EOF) {
4288 struct pipe *pi;
4289 if (done_word(&dest, &ctx)) {
4290 goto parse_error;
4291 }
4292 o_free(&dest);
4293 done_pipe(&ctx, PIPE_SEQ);
4294 /* If we got nothing... */
4295 pi = ctx.list_head;
4296 if (pi->num_cmds == 0
4297 && pi->res_word == RES_NONE
4298 ) {
4299 free_pipe_list(pi, 0);
4300 pi = NULL;
4301 }
4302 debug_printf_parse("parse_stream return %p\n", pi);
4303 return pi;
4304 }
4305 if (done_word(&dest, &ctx)) {
4306 goto parse_error;
Eric Andersenaac75e52001-04-30 18:18:45 +00004307 }
Denis Vlasenko37181682009-04-03 03:19:15 +00004308 if (ch == '\n') {
Denis Vlasenkof1736072008-07-31 10:09:26 +00004309#if ENABLE_HUSH_CASE
4310 /* "case ... in <newline> word) ..." -
4311 * newlines are ignored (but ';' wouldn't be) */
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004312 if (ctx.command->argv == NULL
4313 && ctx.ctx_res_w == RES_MATCH
Denis Vlasenkof1736072008-07-31 10:09:26 +00004314 ) {
4315 continue;
4316 }
4317#endif
Denis Vlasenko240c2552009-04-03 03:45:05 +00004318 /* Treat newline as a command separator. */
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004319 done_pipe(&ctx, PIPE_SEQ);
4320 dest.o_assignment = MAYBE_ASSIGNMENT;
Denis Vlasenko240c2552009-04-03 03:45:05 +00004321 ch = ';';
4322 /* note: if (m == CHAR_IFS) continue;
4323 * will still trigger for us */
Denis Vlasenkoe725bfe2007-05-03 22:45:39 +00004324 }
Denis Vlasenkobb81c582007-01-30 22:32:09 +00004325 }
Denis Vlasenko240c2552009-04-03 03:45:05 +00004326 if (end_trigger && end_trigger == ch) {
4327//TODO: disallow "{ cmd }" without semicolon
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004328 if (done_word(&dest, &ctx)) {
4329 goto parse_error;
4330 }
4331 done_pipe(&ctx, PIPE_SEQ);
4332 dest.o_assignment = MAYBE_ASSIGNMENT;
Denis Vlasenko240c2552009-04-03 03:45:05 +00004333 /* Do we sit outside of any if's, loops or case's? */
Denis Vlasenko37181682009-04-03 03:19:15 +00004334 if (!HAS_KEYWORDS
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004335 IF_HAS_KEYWORDS(|| (ctx.ctx_res_w == RES_NONE && ctx.old_flag == 0))
Denis Vlasenko37181682009-04-03 03:19:15 +00004336 ) {
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004337 debug_printf_parse("parse_stream return %p: "
4338 "end_trigger char found\n",
4339 ctx.list_head);
4340 o_free(&dest);
4341 return ctx.list_head;
Denis Vlasenkof8d01d32008-06-14 17:13:20 +00004342 }
Denis Vlasenkobb81c582007-01-30 22:32:09 +00004343 }
Denis Vlasenko8f6bdb42007-05-16 09:36:55 +00004344 if (m == CHAR_IFS)
Denis Vlasenkobb81c582007-01-30 22:32:09 +00004345 continue;
Denis Vlasenko55789c62008-06-18 16:30:42 +00004346
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00004347 /* m is SPECIAL (e.g. $,`) or ORDINARY_IF_QUOTED (*,#) */
4348
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004349 if (dest.o_assignment == MAYBE_ASSIGNMENT) {
Denis Vlasenko55789c62008-06-18 16:30:42 +00004350 /* ch is a special char and thus this word
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00004351 * cannot be an assignment */
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004352 dest.o_assignment = NOT_ASSIGNMENT;
Denis Vlasenko55789c62008-06-18 16:30:42 +00004353 }
4354
Denis Vlasenkobb81c582007-01-30 22:32:09 +00004355 switch (ch) {
Eric Andersen25f27032001-04-26 23:22:31 +00004356 case '#':
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004357 if (dest.length == 0) {
Denis Vlasenko0c886c62007-01-30 22:30:09 +00004358 while (1) {
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004359 ch = i_peek(input);
Denis Vlasenko0c886c62007-01-30 22:30:09 +00004360 if (ch == EOF || ch == '\n')
4361 break;
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004362 i_getch(input);
Denis Vlasenko0c886c62007-01-30 22:30:09 +00004363 }
Eric Andersen25f27032001-04-26 23:22:31 +00004364 } else {
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004365 o_addQchr(&dest, ch);
Eric Andersen25f27032001-04-26 23:22:31 +00004366 }
4367 break;
4368 case '\\':
4369 if (next == EOF) {
Denis Vlasenko90e485c2007-05-23 15:22:50 +00004370 syntax("\\<eof>");
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004371 goto parse_error;
Eric Andersen25f27032001-04-26 23:22:31 +00004372 }
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004373 o_addchr(&dest, '\\');
4374 o_addchr(&dest, i_getch(input));
Eric Andersen25f27032001-04-26 23:22:31 +00004375 break;
4376 case '$':
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004377 if (handle_dollar(&dest, input) != 0) {
4378 debug_printf_parse("parse_stream parse error: handle_dollar returned non-0\n");
4379 goto parse_error;
Denis Vlasenkoe725bfe2007-05-03 22:45:39 +00004380 }
Eric Andersen25f27032001-04-26 23:22:31 +00004381 break;
4382 case '\'':
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004383 dest.nonnull = 1;
Denis Vlasenko0c886c62007-01-30 22:30:09 +00004384 while (1) {
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004385 ch = i_getch(input);
Denis Vlasenkof8d01d32008-06-14 17:13:20 +00004386 if (ch == EOF) {
4387 syntax("unterminated '");
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004388 goto parse_error;
Denis Vlasenkof8d01d32008-06-14 17:13:20 +00004389 }
4390 if (ch == '\'')
Denis Vlasenko0c886c62007-01-30 22:30:09 +00004391 break;
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004392 if (dest.o_assignment == NOT_ASSIGNMENT)
4393 o_addqchr(&dest, ch);
Denis Vlasenko55789c62008-06-18 16:30:42 +00004394 else
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004395 o_addchr(&dest, ch);
Eric Andersen25f27032001-04-26 23:22:31 +00004396 }
Eric Andersen25f27032001-04-26 23:22:31 +00004397 break;
4398 case '"':
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004399 dest.nonnull = 1;
Denis Vlasenko2f1d3942009-04-02 16:31:29 +00004400 is_in_dquote ^= 1; /* invert */
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004401 if (dest.o_assignment == NOT_ASSIGNMENT)
4402 dest.o_escape ^= 1;
Eric Andersen25f27032001-04-26 23:22:31 +00004403 break;
Denis Vlasenko14b5dd92007-05-20 21:51:38 +00004404#if ENABLE_HUSH_TICK
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00004405 case '`': {
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004406 //int pos = dest.length;
4407 o_addchr(&dest, SPECIAL_VAR_SYMBOL);
4408 o_addchr(&dest, '`');
4409 add_till_backquote(&dest, input);
4410 o_addchr(&dest, SPECIAL_VAR_SYMBOL);
4411 //debug_printf_subst("SUBST RES3 '%s'\n", dest.data + pos);
Eric Andersen25f27032001-04-26 23:22:31 +00004412 break;
Denis Vlasenko7b4f3f12008-06-10 18:04:32 +00004413 }
Denis Vlasenko14b5dd92007-05-20 21:51:38 +00004414#endif
Eric Andersen25f27032001-04-26 23:22:31 +00004415 case '>':
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004416 redir_fd = redirect_opt_num(&dest);
4417 if (done_word(&dest, &ctx)) {
4418 goto parse_error;
4419 }
Denis Vlasenkobb81c582007-01-30 22:32:09 +00004420 redir_style = REDIRECT_OVERWRITE;
Eric Andersen25f27032001-04-26 23:22:31 +00004421 if (next == '>') {
Denis Vlasenkobb81c582007-01-30 22:32:09 +00004422 redir_style = REDIRECT_APPEND;
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004423 i_getch(input);
Denis Vlasenko90e485c2007-05-23 15:22:50 +00004424 }
4425#if 0
4426 else if (next == '(') {
4427 syntax(">(process) not supported");
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004428 goto parse_error;
Eric Andersen25f27032001-04-26 23:22:31 +00004429 }
Denis Vlasenko90e485c2007-05-23 15:22:50 +00004430#endif
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004431 setup_redirect(&ctx, redir_fd, redir_style, input);
Eric Andersen25f27032001-04-26 23:22:31 +00004432 break;
4433 case '<':
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004434 redir_fd = redirect_opt_num(&dest);
4435 if (done_word(&dest, &ctx)) {
4436 goto parse_error;
4437 }
Denis Vlasenkobb81c582007-01-30 22:32:09 +00004438 redir_style = REDIRECT_INPUT;
Eric Andersen25f27032001-04-26 23:22:31 +00004439 if (next == '<') {
Denis Vlasenkobb81c582007-01-30 22:32:09 +00004440 redir_style = REDIRECT_HEREIS;
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004441 i_getch(input);
Eric Andersen25f27032001-04-26 23:22:31 +00004442 } else if (next == '>') {
Denis Vlasenkobb81c582007-01-30 22:32:09 +00004443 redir_style = REDIRECT_IO;
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004444 i_getch(input);
Denis Vlasenko90e485c2007-05-23 15:22:50 +00004445 }
4446#if 0
4447 else if (next == '(') {
4448 syntax("<(process) not supported");
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004449 goto parse_error;
Eric Andersen25f27032001-04-26 23:22:31 +00004450 }
Denis Vlasenko90e485c2007-05-23 15:22:50 +00004451#endif
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004452 setup_redirect(&ctx, redir_fd, redir_style, input);
Eric Andersen25f27032001-04-26 23:22:31 +00004453 break;
4454 case ';':
Denis Vlasenko17f02e72008-07-14 04:32:29 +00004455#if ENABLE_HUSH_CASE
4456 case_semi:
4457#endif
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004458 if (done_word(&dest, &ctx)) {
4459 goto parse_error;
4460 }
4461 done_pipe(&ctx, PIPE_SEQ);
Denis Vlasenko17f02e72008-07-14 04:32:29 +00004462#if ENABLE_HUSH_CASE
4463 /* Eat multiple semicolons, detect
4464 * whether it means something special */
4465 while (1) {
4466 ch = i_peek(input);
4467 if (ch != ';')
4468 break;
4469 i_getch(input);
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004470 if (ctx.ctx_res_w == RES_CASEI) {
4471 ctx.ctx_dsemicolon = 1;
4472 ctx.ctx_res_w = RES_MATCH;
Denis Vlasenko17f02e72008-07-14 04:32:29 +00004473 break;
4474 }
4475 }
4476#endif
Denis Vlasenko2b576b82008-08-04 00:46:07 +00004477 new_cmd:
4478 /* We just finished a cmd. New one may start
4479 * with an assignment */
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004480 dest.o_assignment = MAYBE_ASSIGNMENT;
Eric Andersen25f27032001-04-26 23:22:31 +00004481 break;
4482 case '&':
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004483 if (done_word(&dest, &ctx)) {
4484 goto parse_error;
4485 }
Denis Vlasenkobb81c582007-01-30 22:32:09 +00004486 if (next == '&') {
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004487 i_getch(input);
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004488 done_pipe(&ctx, PIPE_AND);
Eric Andersen25f27032001-04-26 23:22:31 +00004489 } else {
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004490 done_pipe(&ctx, PIPE_BG);
Eric Andersen25f27032001-04-26 23:22:31 +00004491 }
Denis Vlasenko2b576b82008-08-04 00:46:07 +00004492 goto new_cmd;
Eric Andersen25f27032001-04-26 23:22:31 +00004493 case '|':
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004494 if (done_word(&dest, &ctx)) {
4495 goto parse_error;
4496 }
Denis Vlasenkofbeeb322008-07-31 00:17:01 +00004497#if ENABLE_HUSH_CASE
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004498 if (ctx.ctx_res_w == RES_MATCH)
Denis Vlasenkof1736072008-07-31 10:09:26 +00004499 break; /* we are in case's "word | word)" */
Denis Vlasenkofbeeb322008-07-31 00:17:01 +00004500#endif
Denis Vlasenko2b576b82008-08-04 00:46:07 +00004501 if (next == '|') { /* || */
Denis Vlasenko46ccdcb2008-06-10 18:05:12 +00004502 i_getch(input);
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004503 done_pipe(&ctx, PIPE_OR);
Eric Andersen25f27032001-04-26 23:22:31 +00004504 } else {
4505 /* we could pick up a file descriptor choice here
4506 * with redirect_opt_num(), but bash doesn't do it.
4507 * "echo foo 2| cat" yields "foo 2". */
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004508 done_command(&ctx);
Eric Andersen25f27032001-04-26 23:22:31 +00004509 }
Denis Vlasenko2b576b82008-08-04 00:46:07 +00004510 goto new_cmd;
Eric Andersen25f27032001-04-26 23:22:31 +00004511 case '(':
Denis Vlasenko17f02e72008-07-14 04:32:29 +00004512#if ENABLE_HUSH_CASE
Denis Vlasenkof1736072008-07-31 10:09:26 +00004513 /* "case... in [(]word)..." - skip '(' */
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004514 if (ctx.ctx_res_w == RES_MATCH
4515 && ctx.command->argv == NULL /* not (word|(... */
4516 && dest.length == 0 /* not word(... */
4517 && dest.nonnull == 0 /* not ""(... */
Denis Vlasenko17f02e72008-07-14 04:32:29 +00004518 ) {
4519 continue;
4520 }
4521#endif
Denis Vlasenko371de4a2008-10-14 12:43:13 +00004522#if ENABLE_HUSH_FUNCTIONS
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004523 if (dest.length != 0 /* not just () but word() */
4524 && dest.nonnull == 0 /* not a"b"c() */
4525 && ctx.command->argv == NULL /* it's the first word */
Denis Vlasenko371de4a2008-10-14 12:43:13 +00004526//TODO: "func ( ) {...}" - note spaces - is valid format too in bash
Denis Vlasenkoc3735272008-10-09 12:58:26 +00004527 && i_peek(input) == ')'
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004528 && !match_reserved_word(&dest)
Denis Vlasenkoc3735272008-10-09 12:58:26 +00004529 ) {
4530 bb_error_msg("seems like a function definition");
Denis Vlasenko22d10a02008-10-13 08:53:43 +00004531 i_getch(input);
4532 do {
Denis Vlasenko371de4a2008-10-14 12:43:13 +00004533//TODO: do it properly.
Denis Vlasenko22d10a02008-10-13 08:53:43 +00004534 ch = i_getch(input);
4535 } while (ch == ' ' || ch == '\n');
4536 if (ch != '{') {
4537 syntax("was expecting {");
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004538 goto parse_error;
Denis Vlasenko22d10a02008-10-13 08:53:43 +00004539 }
Denis Vlasenko371de4a2008-10-14 12:43:13 +00004540 ch = 'F'; /* magic value */
Denis Vlasenkoc3735272008-10-09 12:58:26 +00004541 }
4542#endif
Eric Andersen25f27032001-04-26 23:22:31 +00004543 case '{':
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004544 if (parse_group(&dest, &ctx, input, ch) != 0) {
4545 goto parse_error;
Denis Vlasenkoe725bfe2007-05-03 22:45:39 +00004546 }
Denis Vlasenko2b576b82008-08-04 00:46:07 +00004547 goto new_cmd;
Eric Andersen25f27032001-04-26 23:22:31 +00004548 case ')':
Denis Vlasenko17f02e72008-07-14 04:32:29 +00004549#if ENABLE_HUSH_CASE
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004550 if (ctx.ctx_res_w == RES_MATCH)
Denis Vlasenko17f02e72008-07-14 04:32:29 +00004551 goto case_semi;
4552#endif
Eric Andersen25f27032001-04-26 23:22:31 +00004553 case '}':
Denis Vlasenkoc3735272008-10-09 12:58:26 +00004554 /* proper use of this character is caught by end_trigger:
4555 * if we see {, we call parse_group(..., end_trigger='}')
4556 * and it will match } earlier (not here). */
Denis Vlasenkoa8442002008-06-14 11:00:17 +00004557 syntax("unexpected } or )");
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004558 goto parse_error;
Eric Andersen25f27032001-04-26 23:22:31 +00004559 default:
Denis Vlasenko5ec61322008-06-24 00:50:07 +00004560 if (HUSH_DEBUG)
Denis Vlasenko90e485c2007-05-23 15:22:50 +00004561 bb_error_msg_and_die("BUG: unexpected %c\n", ch);
Eric Andersen25f27032001-04-26 23:22:31 +00004562 }
Denis Vlasenkof8d01d32008-06-14 17:13:20 +00004563 } /* while (1) */
Denis Vlasenko027e3fd2009-04-02 22:50:40 +00004564
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004565 parse_error:
4566 {
4567 struct parse_context *pctx, *p2;
4568
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
4574 */
4575 pctx = &ctx;
4576 do {
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 p2 = pctx->stack;
4586 if (pctx != &ctx) {
4587 free(pctx);
4588 }
4589 pctx = p2;
4590 } while (pctx);
4591 /* Free text, clear all dest fields */
4592 o_free(&dest);
4593 /* If we are not in top-level parse, we return,
4594 * our caller will propagate error.
4595 */
4596 if (end_trigger != ';')
4597 return ERR_PTR;
4598 /* Discard cached input, force prompt */
4599 input->p = NULL;
4600 input->promptme = 1;
4601 goto reset;
Denis Vlasenko027e3fd2009-04-02 22:50:40 +00004602 }
Eric Andersen25f27032001-04-26 23:22:31 +00004603}
4604
Denis Vlasenko8f6bdb42007-05-16 09:36:55 +00004605static void set_in_charmap(const char *set, int code)
Eric Andersen25f27032001-04-26 23:22:31 +00004606{
Denis Vlasenkof5294e12007-04-14 10:09:57 +00004607 while (*set)
Denis Vlasenko87a86552008-07-29 19:43:10 +00004608 G.charmap[(unsigned char)*set++] = code;
Eric Andersen25f27032001-04-26 23:22:31 +00004609}
4610
Denis Vlasenko8f6bdb42007-05-16 09:36:55 +00004611static void update_charmap(void)
Eric Andersen25f27032001-04-26 23:22:31 +00004612{
Denis Vlasenko87a86552008-07-29 19:43:10 +00004613 G.ifs = getenv("IFS");
4614 if (G.ifs == NULL)
4615 G.ifs = " \t\n";
Eric Andersen25f27032001-04-26 23:22:31 +00004616 /* 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.
Denis Vlasenko8f6bdb42007-05-16 09:36:55 +00004619 * The charmap[] array only really needs two bits each,
4620 * and on most machines that would be faster (reduced L1 cache use).
Eric Andersen25f27032001-04-26 23:22:31 +00004621 */
Denis Vlasenko87a86552008-07-29 19:43:10 +00004622 memset(G.charmap, CHAR_ORDINARY, sizeof(G.charmap));
Denis Vlasenko14b5dd92007-05-20 21:51:38 +00004623#if ENABLE_HUSH_TICK
Denis Vlasenko8f6bdb42007-05-16 09:36:55 +00004624 set_in_charmap("\\$\"`", CHAR_SPECIAL);
Denis Vlasenko14b5dd92007-05-20 21:51:38 +00004625#else
4626 set_in_charmap("\\$\"", CHAR_SPECIAL);
4627#endif
Denis Vlasenko8f6bdb42007-05-16 09:36:55 +00004628 set_in_charmap("<>;&|(){}#'", CHAR_ORDINARY_IF_QUOTED);
Denis Vlasenko87a86552008-07-29 19:43:10 +00004629 set_in_charmap(G.ifs, CHAR_IFS); /* are ordinary if quoted */
Eric Andersen25f27032001-04-26 23:22:31 +00004630}
4631
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004632/* 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
4637 */
4638static void parse_and_run_stream(struct in_str *inp, int end_trigger)
Eric Andersen25f27032001-04-26 23:22:31 +00004639{
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004640 while (1) {
4641 struct pipe *pipe_list;
Denis Vlasenkof8d01d32008-06-14 17:13:20 +00004642
Denis Vlasenko8f6bdb42007-05-16 09:36:55 +00004643 update_charmap();
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004644
4645 pipe_list = parse_stream(inp, end_trigger);
4646 if (!pipe_list) /* EOF */
4647 break;
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: */
4652 }
Eric Andersen25f27032001-04-26 23:22:31 +00004653}
4654
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004655static void parse_and_run_string(const char *s)
Eric Andersen25f27032001-04-26 23:22:31 +00004656{
4657 struct in_str input;
4658 setup_string_in_str(&input, s);
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004659 parse_and_run_stream(&input, '\0');
Eric Andersen25f27032001-04-26 23:22:31 +00004660}
4661
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004662static void parse_and_run_file(FILE *f)
Eric Andersen25f27032001-04-26 23:22:31 +00004663{
Eric Andersen25f27032001-04-26 23:22:31 +00004664 struct in_str input;
4665 setup_file_in_str(&input, f);
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004666 parse_and_run_stream(&input, ';');
Eric Andersen25f27032001-04-26 23:22:31 +00004667}
4668
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00004669#if ENABLE_HUSH_JOB
Eric Andersen6c947d22001-06-25 22:24:38 +00004670/* 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 */
Eric Anderseneaecbf32001-10-31 10:41:31 +00004673static void setup_job_control(void)
Eric Andersen52a97ca2001-06-22 06:49:26 +00004674{
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00004675 pid_t shell_pgrp;
4676
Denis Vlasenko87a86552008-07-29 19:43:10 +00004677 shell_pgrp = getpgrp();
Denis Vlasenkofbf6dea2007-04-13 19:56:56 +00004678
Denis Vlasenkoa6a17852007-04-28 16:42:11 +00004679 /* If we were ran as 'hush &',
4680 * sleep until we are in the foreground. */
Denis Vlasenko87a86552008-07-29 19:43:10 +00004681 while (tcgetpgrp(G.interactive_fd) != shell_pgrp) {
Denis Vlasenkob81b3df2007-04-28 16:48:04 +00004682 /* Send TTIN to ourself (should stop us) */
Denis Vlasenkoff131b92007-04-10 15:42:06 +00004683 kill(- shell_pgrp, SIGTTIN);
Denis Vlasenkoa6a17852007-04-28 16:42:11 +00004684 shell_pgrp = getpgrp();
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00004685 }
Eric Andersen52a97ca2001-06-22 06:49:26 +00004686
Denis Vlasenkoa6c467f2007-05-05 15:10:52 +00004687 /* We _must_ restore tty pgrp on fatal signals */
Denis Vlasenkoabedaac2009-03-31 12:03:40 +00004688 set_fatal_signals_to_sigexit();
Eric Andersen6c947d22001-06-25 22:24:38 +00004689
4690 /* Put ourselves in our own process group. */
Bernhard Reutner-Fischer864329d2008-09-25 10:55:05 +00004691 bb_setpgrp(); /* is the same as setpgid(our_pid, our_pid); */
Eric Andersen6c947d22001-06-25 22:24:38 +00004692 /* Grab control of the terminal. */
Denis Vlasenko87a86552008-07-29 19:43:10 +00004693 tcsetpgrp(G.interactive_fd, getpid());
Eric Andersen6c947d22001-06-25 22:24:38 +00004694}
Denis Vlasenkob81b3df2007-04-28 16:48:04 +00004695#endif
Eric Andersenada18ff2001-05-21 16:18:22 +00004696
Denis Vlasenkod5762932009-03-31 11:22:57 +00004697static int set_mode(const char cstate, const char mode)
4698{
4699 int state = (cstate == '-' ? 1 : 0);
4700 switch (mode) {
4701 case 'n': G.fake_mode = state; break;
4702 case 'x': /*G.debug_mode = state;*/ break;
4703 default: return EXIT_FAILURE;
4704 }
4705 return EXIT_SUCCESS;
4706}
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00004707
Denis Vlasenko9b49a5e2007-10-11 10:05:36 +00004708int hush_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
Matt Kraai2d91deb2001-08-01 17:21:35 +00004709int hush_main(int argc, char **argv)
Eric Andersen25f27032001-04-26 23:22:31 +00004710{
Denis Vlasenko0a83fc32007-05-25 11:12:32 +00004711 static const struct variable const_shell_ver = {
4712 .next = NULL,
Denis Vlasenkoafd7a8d2008-10-09 16:29:44 +00004713 .varstr = (char*)hush_version_str,
Denis Vlasenko0a83fc32007-05-25 11:12:32 +00004714 .max_len = 1, /* 0 can provoke free(name) */
4715 .flg_export = 1,
4716 .flg_read_only = 1,
4717 };
4718
Eric Andersen25f27032001-04-26 23:22:31 +00004719 int opt;
4720 FILE *input;
Denis Vlasenkofbf6dea2007-04-13 19:56:56 +00004721 char **e;
Denis Vlasenkod76c0492007-05-25 02:16:25 +00004722 struct variable *cur_var;
Eric Andersenbc604a22001-05-16 05:24:03 +00004723
Denis Vlasenko574f2f42008-02-27 18:41:59 +00004724 INIT_G();
Denis Vlasenkod76c0492007-05-25 02:16:25 +00004725
Denis Vlasenko87a86552008-07-29 19:43:10 +00004726 G.root_pid = getpid();
Denis Vlasenko16c2fea2008-06-17 12:28:44 +00004727
Denis Vlasenko0a83fc32007-05-25 11:12:32 +00004728 /* Deal with HUSH_VERSION */
Denis Vlasenko87a86552008-07-29 19:43:10 +00004729 G.shell_ver = const_shell_ver; /* copying struct here */
4730 G.top_var = &G.shell_ver;
Denis Vlasenkof886fd22008-10-13 12:36:05 +00004731 debug_printf_env("unsetenv '%s'\n", "HUSH_VERSION");
Denis Vlasenko0a83fc32007-05-25 11:12:32 +00004732 unsetenv("HUSH_VERSION"); /* in case it exists in initial env */
4733 /* Initialize our shell local variables with the values
Denis Vlasenkod76c0492007-05-25 02:16:25 +00004734 * currently living in the environment */
Denis Vlasenko87a86552008-07-29 19:43:10 +00004735 cur_var = G.top_var;
Denis Vlasenko0a83fc32007-05-25 11:12:32 +00004736 e = environ;
Denis Vlasenkod76c0492007-05-25 02:16:25 +00004737 if (e) while (*e) {
4738 char *value = strchr(*e, '=');
4739 if (value) { /* paranoia */
4740 cur_var->next = xzalloc(sizeof(*cur_var));
4741 cur_var = cur_var->next;
Denis Vlasenko28c0f0f2007-05-25 02:46:01 +00004742 cur_var->varstr = *e;
Denis Vlasenkod76c0492007-05-25 02:16:25 +00004743 cur_var->max_len = strlen(*e);
4744 cur_var->flg_export = 1;
4745 }
4746 e++;
4747 }
Denis Vlasenkof886fd22008-10-13 12:36:05 +00004748 debug_printf_env("putenv '%s'\n", hush_version_str);
Denis Vlasenkoafd7a8d2008-10-09 16:29:44 +00004749 putenv((char *)hush_version_str); /* reinstate HUSH_VERSION */
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +00004750
Denis Vlasenko38f63192007-01-22 09:03:07 +00004751#if ENABLE_FEATURE_EDITING
Denis Vlasenko87a86552008-07-29 19:43:10 +00004752 G.line_input_state = new_line_input_t(FOR_SHELL);
Denis Vlasenko8e1c7152007-01-22 07:21:38 +00004753#endif
Eric Andersen25f27032001-04-26 23:22:31 +00004754 /* XXX what should these be while sourcing /etc/profile? */
Denis Vlasenko87a86552008-07-29 19:43:10 +00004755 G.global_argc = argc;
4756 G.global_argv = argv;
Eric Andersen94ac2442001-05-22 19:05:18 +00004757 /* Initialize some more globals to non-zero values */
4758 set_cwd();
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00004759#if ENABLE_HUSH_INTERACTIVE
Mike Frysingerec2c6552009-03-28 12:24:44 +00004760 if (ENABLE_FEATURE_EDITING)
4761 cmdedit_set_initial_prompt();
Denis Vlasenko87a86552008-07-29 19:43:10 +00004762 G.PS2 = "> ";
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00004763#endif
Denis Vlasenkoc8be5ee2007-05-17 15:38:46 +00004764
Denis Vlasenkod76c0492007-05-25 02:16:25 +00004765 if (EXIT_SUCCESS) /* otherwise is already done */
Denis Vlasenko87a86552008-07-29 19:43:10 +00004766 G.last_return_code = EXIT_SUCCESS;
Eric Andersen25f27032001-04-26 23:22:31 +00004767
4768 if (argv[0] && argv[0][0] == '-') {
Denis Vlasenko21f0d4c2007-05-06 14:15:42 +00004769 debug_printf("sourcing /etc/profile\n");
Denis Vlasenko5415c852008-07-21 23:05:26 +00004770 input = fopen_for_read("/etc/profile");
Denis Vlasenkof03dbed2007-04-13 19:55:50 +00004771 if (input != NULL) {
Denis Vlasenkoa0898172007-10-01 09:59:01 +00004772 close_on_exec_on(fileno(input));
Denis Vlasenko170435c2007-05-23 13:01:10 +00004773 parse_and_run_file(input);
Eric Andersena90f20b2001-06-26 23:00:21 +00004774 fclose(input);
4775 }
Eric Andersen25f27032001-04-26 23:22:31 +00004776 }
Denis Vlasenkobb81c582007-01-30 22:32:09 +00004777 input = stdin;
Eric Andersenc7bda1c2004-03-15 08:29:22 +00004778
Mike Frysinger19a7ea12009-03-28 13:02:11 +00004779 /* http://www.opengroup.org/onlinepubs/9699919799/utilities/sh.html */
4780 while ((opt = getopt(argc, argv, "c:xins")) > 0) {
Eric Andersen25f27032001-04-26 23:22:31 +00004781 switch (opt) {
Denis Vlasenkofbf6dea2007-04-13 19:56:56 +00004782 case 'c':
Denis Vlasenko87a86552008-07-29 19:43:10 +00004783 G.global_argv = argv + optind;
Denis Vlasenkoa8b6dff2009-03-20 12:05:14 +00004784 if (!argv[optind]) {
4785 /* -c 'script' (no params): prevent empty $0 */
4786 *--G.global_argv = argv[0];
4787 optind--;
4788 } /* else -c 'script' PAR0 PAR1: $0 is PAR0 */
Denis Vlasenko87a86552008-07-29 19:43:10 +00004789 G.global_argc = argc - optind;
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004790 parse_and_run_string(optarg);
Denis Vlasenkofbf6dea2007-04-13 19:56:56 +00004791 goto final_return;
4792 case 'i':
Denis Vlasenkoc666f712007-05-16 22:18:54 +00004793 /* Well, we cannot just declare interactiveness,
4794 * we have to have some stuff (ctty, etc) */
Denis Vlasenko87a86552008-07-29 19:43:10 +00004795 /* G.interactive_fd++; */
Denis Vlasenkofbf6dea2007-04-13 19:56:56 +00004796 break;
Mike Frysinger19a7ea12009-03-28 13:02:11 +00004797 case 's':
4798 /* "-s" means "read from stdin", but this is how we always
4799 * operate, so simply do nothing here. */
4800 break;
Mike Frysingerad88d5a2009-03-28 13:44:51 +00004801 case 'n':
4802 case 'x':
Denis Vlasenkod5762932009-03-31 11:22:57 +00004803 if (!set_mode('-', opt))
Mike Frysingerad88d5a2009-03-28 13:44:51 +00004804 break;
Denis Vlasenkofbf6dea2007-04-13 19:56:56 +00004805 default:
Eric Andersen9ffb7dd2001-05-19 03:00:46 +00004806#ifndef BB_VER
Denis Vlasenkofbf6dea2007-04-13 19:56:56 +00004807 fprintf(stderr, "Usage: sh [FILE]...\n"
4808 " or: sh -c command [args]...\n\n");
4809 exit(EXIT_FAILURE);
Eric Andersen9ffb7dd2001-05-19 03:00:46 +00004810#else
Denis Vlasenkofbf6dea2007-04-13 19:56:56 +00004811 bb_show_usage();
Eric Andersen9ffb7dd2001-05-19 03:00:46 +00004812#endif
Eric Andersen25f27032001-04-26 23:22:31 +00004813 }
4814 }
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00004815#if ENABLE_HUSH_JOB
Denis Vlasenkofbf6dea2007-04-13 19:56:56 +00004816 /* A shell is interactive if the '-i' flag was given, or if all of
Eric Andersen25f27032001-04-26 23:22:31 +00004817 * the following conditions are met:
Denis Vlasenko55b2de72007-04-18 17:21:28 +00004818 * no -c command
Eric Andersen25f27032001-04-26 23:22:31 +00004819 * no arguments remaining or the -s flag given
4820 * standard input is a terminal
4821 * standard output is a terminal
Denis Vlasenkofbf6dea2007-04-13 19:56:56 +00004822 * Refer to Posix.2, the description of the 'sh' utility. */
Denis Vlasenkobb81c582007-01-30 22:32:09 +00004823 if (argv[optind] == NULL && input == stdin
4824 && isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)
4825 ) {
Denis Vlasenko87a86552008-07-29 19:43:10 +00004826 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) {
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00004829 /* try to dup to high fd#, >= 255 */
Denis Vlasenko87a86552008-07-29 19:43:10 +00004830 G.interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
4831 if (G.interactive_fd < 0) {
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00004832 /* try to dup to any fd */
Denis Vlasenko87a86552008-07-29 19:43:10 +00004833 G.interactive_fd = dup(STDIN_FILENO);
4834 if (G.interactive_fd < 0)
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00004835 /* give up */
Denis Vlasenko87a86552008-07-29 19:43:10 +00004836 G.interactive_fd = 0;
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00004837 }
Denis Vlasenko2f1bb362007-04-21 10:01:14 +00004838 // TODO: track & disallow any attempts of user
4839 // to (inadvertently) close/redirect it
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00004840 }
Eric Andersen25f27032001-04-26 23:22:31 +00004841 }
Denis Vlasenko7566bae2009-03-31 17:24:49 +00004842 init_signal_mask(); /* note: ensures SIGCHLD is not masked */
Denis Vlasenko87a86552008-07-29 19:43:10 +00004843 debug_printf("G.interactive_fd=%d\n", G.interactive_fd);
4844 if (G.interactive_fd) {
4845 fcntl(G.interactive_fd, F_SETFD, FD_CLOEXEC);
Eric Andersen25f27032001-04-26 23:22:31 +00004846 /* Looks like they want an interactive shell */
Eric Andersen52a97ca2001-06-22 06:49:26 +00004847 setup_job_control();
Denis Vlasenko4ecfcdc2008-02-11 08:32:31 +00004848 /* -1 is special - makes xfuncs longjmp, not exit
Denis Vlasenkoc04163a2008-02-11 08:30:53 +00004849 * (we reset die_sleep = 0 whereever we [v]fork) */
4850 die_sleep = -1;
Denis Vlasenko54e7ffb2007-04-21 00:03:36 +00004851 if (setjmp(die_jmp)) {
4852 /* xfunc has failed! die die die */
4853 hush_exit(xfunc_error_retval);
4854 }
Eric Andersenada18ff2001-05-21 16:18:22 +00004855 }
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00004856#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)
4860 ) {
Denis Vlasenko87a86552008-07-29 19:43:10 +00004861 G.interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
4862 if (G.interactive_fd < 0) {
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00004863 /* try to dup to any fd */
Denis Vlasenko87a86552008-07-29 19:43:10 +00004864 G.interactive_fd = dup(STDIN_FILENO);
4865 if (G.interactive_fd < 0)
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00004866 /* give up */
Denis Vlasenko87a86552008-07-29 19:43:10 +00004867 G.interactive_fd = 0;
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00004868 }
Denis Vlasenko87a86552008-07-29 19:43:10 +00004869 if (G.interactive_fd) {
4870 fcntl(G.interactive_fd, F_SETFD, FD_CLOEXEC);
Denis Vlasenko4830fc52008-05-25 21:50:55 +00004871 }
Denis Vlasenkoe3f2f892007-04-28 16:48:27 +00004872 }
Denis Vlasenko7566bae2009-03-31 17:24:49 +00004873 init_signal_mask(); /* note: ensures SIGCHLD is not masked */
Denis Vlasenkob81b3df2007-04-28 16:48:04 +00004874#endif
Denis Vlasenko7566bae2009-03-31 17:24:49 +00004875 /* POSIX allows shell to re-enable SIGCHLD
4876 * even if it was SIG_IGN on entry */
4877// G.count_SIGCHLD++; /* ensure it is != G.handled_SIGCHLD */
4878 signal(SIGCHLD, SIG_DFL); // SIGCHLD_handler);
Eric Andersenc7bda1c2004-03-15 08:29:22 +00004879
Denis Vlasenko701ac182009-03-28 19:22:08 +00004880#if ENABLE_HUSH_INTERACTIVE && !ENABLE_FEATURE_SH_EXTRA_QUIET
4881 if (G.interactive_fd) {
Mike Frysingerb2705e12009-03-23 08:44:02 +00004882 printf("\n\n%s hush - the humble shell v"HUSH_VER_STR"\n", bb_banner);
4883 printf("Enter 'help' for a list of built-in commands.\n\n");
4884 }
Denis Vlasenko701ac182009-03-28 19:22:08 +00004885#endif
Mike Frysingerb2705e12009-03-23 08:44:02 +00004886
Denis Vlasenkobb81c582007-01-30 22:32:09 +00004887 if (argv[optind] == NULL) {
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004888 parse_and_run_file(stdin);
Denis Vlasenko05743d72008-02-10 12:10:08 +00004889 } else {
4890 debug_printf("\nrunning script '%s'\n", argv[optind]);
Denis Vlasenko87a86552008-07-29 19:43:10 +00004891 G.global_argv = argv + optind;
4892 G.global_argc = argc - optind;
Denis Vlasenko5415c852008-07-21 23:05:26 +00004893 input = xfopen_for_read(argv[optind]);
Denis Vlasenko459a5ad2008-02-11 08:35:03 +00004894 fcntl(fileno(input), F_SETFD, FD_CLOEXEC);
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004895 parse_and_run_file(input);
Eric Andersen25f27032001-04-26 23:22:31 +00004896 }
Eric Andersen25f27032001-04-26 23:22:31 +00004897
Denis Vlasenkod76c0492007-05-25 02:16:25 +00004898 final_return:
4899
Denis Vlasenko38f63192007-01-22 09:03:07 +00004900#if ENABLE_FEATURE_CLEAN_UP
Eric Andersenaeb44c42001-05-22 20:29:00 +00004901 fclose(input);
Denis Vlasenko87a86552008-07-29 19:43:10 +00004902 if (G.cwd != bb_msg_unknown)
4903 free((char*)G.cwd);
4904 cur_var = G.top_var->next;
Denis Vlasenkod76c0492007-05-25 02:16:25 +00004905 while (cur_var) {
4906 struct variable *tmp = cur_var;
4907 if (!cur_var->max_len)
Denis Vlasenko28c0f0f2007-05-25 02:46:01 +00004908 free(cur_var->varstr);
Denis Vlasenkod76c0492007-05-25 02:16:25 +00004909 cur_var = cur_var->next;
4910 free(tmp);
Eric Andersenaeb44c42001-05-22 20:29:00 +00004911 }
Eric Andersen25f27032001-04-26 23:22:31 +00004912#endif
Denis Vlasenkob6e65562009-04-03 16:49:04 +00004913 hush_exit(G.last_return_code);
Eric Andersen25f27032001-04-26 23:22:31 +00004914}
Denis Vlasenko96702ca2007-11-23 23:28:55 +00004915
4916
4917#if ENABLE_LASH
4918int lash_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
4919int lash_main(int argc, char **argv)
4920{
4921 //bb_error_msg("lash is deprecated, please use hush instead");
4922 return hush_main(argc, argv);
4923}
4924#endif
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00004925
4926
4927/*
4928 * Built-ins
4929 */
Mike Frysinger9f8128f2009-03-29 23:49:37 +00004930static int builtin_trap(char **argv)
4931{
Denis Vlasenkod5762932009-03-31 11:22:57 +00004932 int i;
Mike Frysinger9f8128f2009-03-29 23:49:37 +00004933 int sig;
Denis Vlasenkod5762932009-03-31 11:22:57 +00004934 char *new_cmd;
Mike Frysinger9f8128f2009-03-29 23:49:37 +00004935
4936 if (!G.traps)
Denis Vlasenkod5762932009-03-31 11:22:57 +00004937 G.traps = xzalloc(sizeof(G.traps[0]) * NSIG);
Mike Frysinger9f8128f2009-03-29 23:49:37 +00004938
4939 if (!argv[1]) {
4940 /* No args: print all trapped. This isn't 100% correct as we should
4941 * be escaping the cmd so that it can be pasted back in ...
4942 */
4943 for (i = 0; i < NSIG; ++i)
Denis Vlasenkod5762932009-03-31 11:22:57 +00004944 if (G.traps[i])
4945 printf("trap -- '%s' %s\n", G.traps[i], get_signame(i));
Mike Frysinger9f8128f2009-03-29 23:49:37 +00004946 return EXIT_SUCCESS;
4947 }
4948
Denis Vlasenkod5762932009-03-31 11:22:57 +00004949 new_cmd = NULL;
4950 i = 0;
4951 /* if first arg is decimal: reset all specified */
4952 sig = bb_strtou(*++argv, NULL, 10);
Mike Frysinger9f8128f2009-03-29 23:49:37 +00004953 if (errno == 0) {
4954 int ret;
Mike Frysinger9f8128f2009-03-29 23:49:37 +00004955 set_all:
4956 ret = EXIT_SUCCESS;
Denis Vlasenkod5762932009-03-31 11:22:57 +00004957 while (*argv) {
4958 sig = get_signum(*argv++);
Mike Frysinger9f8128f2009-03-29 23:49:37 +00004959 if (sig < 0 || sig >= NSIG) {
4960 ret = EXIT_FAILURE;
Denis Vlasenkod5762932009-03-31 11:22:57 +00004961 /* mimic bash message exactly */
Mike Frysinger9f8128f2009-03-29 23:49:37 +00004962 bb_perror_msg("trap: %s: invalid signal specification", argv[i]);
4963 continue;
4964 }
4965
Denis Vlasenkod5762932009-03-31 11:22:57 +00004966 free(G.traps[sig]);
4967 G.traps[sig] = xstrdup(new_cmd);
Mike Frysinger9f8128f2009-03-29 23:49:37 +00004968
Denis Vlasenkod5762932009-03-31 11:22:57 +00004969 debug_printf("trap: setting SIG%s (%i) to '%s'",
4970 get_signame(sig), sig, G.traps[sig]);
Mike Frysinger9f8128f2009-03-29 23:49:37 +00004971
4972 /* There is no signal for 0 (EXIT) */
4973 if (sig == 0)
4974 continue;
4975
4976 if (new_cmd) {
Denis Vlasenkod5762932009-03-31 11:22:57 +00004977 sigaddset(&G.blocked_set, sig);
4978 } else {
4979 /* there was a trap handler, we are removing it
4980 * (if sig has non-DFL handling,
4981 * we don't need to do anything) */
4982 if (sig < 32 && (G.non_DFL_mask & (1 << sig)))
4983 continue;
4984 sigdelset(&G.blocked_set, sig);
4985 }
4986 sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
Mike Frysinger9f8128f2009-03-29 23:49:37 +00004987 }
4988 return ret;
4989 }
4990
4991 /* first arg is "-": reset all specified to default */
4992 /* first arg is "": ignore all specified */
4993 /* everything else: execute first arg upon signal */
Denis Vlasenkod5762932009-03-31 11:22:57 +00004994 if (!argv[1]) {
Mike Frysinger9f8128f2009-03-29 23:49:37 +00004995 bb_error_msg("trap: invalid arguments");
4996 return EXIT_FAILURE;
4997 }
Denis Vlasenkod5762932009-03-31 11:22:57 +00004998 if (LONE_DASH(*argv))
Mike Frysinger9f8128f2009-03-29 23:49:37 +00004999 /* nothing! */;
5000 else
Denis Vlasenkod5762932009-03-31 11:22:57 +00005001 new_cmd = *argv;
5002 argv++;
Mike Frysinger9f8128f2009-03-29 23:49:37 +00005003 goto set_all;
5004}
5005
Denis Vlasenkoa60f84e2008-07-05 09:18:54 +00005006static int builtin_true(char **argv UNUSED_PARAM)
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005007{
5008 return 0;
5009}
5010
5011static int builtin_test(char **argv)
5012{
5013 int argc = 0;
5014 while (*argv) {
5015 argc++;
5016 argv++;
5017 }
5018 return test_main(argc, argv - argc);
5019}
5020
5021static int builtin_echo(char **argv)
5022{
5023 int argc = 0;
5024 while (*argv) {
5025 argc++;
5026 argv++;
5027 }
5028 return echo_main(argc, argv - argc);
5029}
5030
5031static int builtin_eval(char **argv)
5032{
5033 int rcode = EXIT_SUCCESS;
5034
5035 if (argv[1]) {
5036 char *str = expand_strvec_to_string(argv + 1);
Denis Vlasenkob6e65562009-04-03 16:49:04 +00005037 /* bash:
5038 * eval "echo Hi; done" ("done" is syntax error):
5039 * "echo Hi" will not execute too.
5040 */
5041 parse_and_run_string(str);
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005042 free(str);
Denis Vlasenko87a86552008-07-29 19:43:10 +00005043 rcode = G.last_return_code;
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005044 }
5045 return rcode;
5046}
5047
5048static int builtin_cd(char **argv)
5049{
5050 const char *newdir;
5051 if (argv[1] == NULL) {
Denis Vlasenkob6e65562009-04-03 16:49:04 +00005052 /* bash does nothing (exitcode 0) if HOME is ""; if it's unset,
5053 * bash says "bash: cd: HOME not set" and does nothing (exitcode 1)
5054 */
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005055 newdir = getenv("HOME") ? : "/";
5056 } else
5057 newdir = argv[1];
5058 if (chdir(newdir)) {
5059 printf("cd: %s: %s\n", newdir, strerror(errno));
5060 return EXIT_FAILURE;
5061 }
5062 set_cwd();
5063 return EXIT_SUCCESS;
5064}
5065
5066static int builtin_exec(char **argv)
5067{
5068 if (argv[1] == NULL)
5069 return EXIT_SUCCESS; /* bash does this */
5070 {
5071#if !BB_MMU
Denis Vlasenkof886fd22008-10-13 12:36:05 +00005072 nommu_save_t dummy;
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005073#endif
5074// FIXME: if exec fails, bash does NOT exit! We do...
Denis Vlasenkof886fd22008-10-13 12:36:05 +00005075 pseudo_exec_argv(&dummy, argv + 1, 0, NULL);
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005076 /* never returns */
5077 }
5078}
5079
5080static int builtin_exit(char **argv)
5081{
5082// TODO: bash does it ONLY on top-level sh exit (+interacive only?)
5083 //puts("exit"); /* bash does it */
5084// TODO: warn if we have background jobs: "There are stopped jobs"
5085// On second consecutive 'exit', exit anyway.
5086 if (argv[1] == NULL)
Denis Vlasenko87a86552008-07-29 19:43:10 +00005087 hush_exit(G.last_return_code);
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005088 /* mimic bash: exit 123abc == exit 255 + error msg */
5089 xfunc_error_retval = 255;
5090 /* bash: exit -2 == exit 254, no error msg */
5091 hush_exit(xatoi(argv[1]) & 0xff);
5092}
5093
5094static int builtin_export(char **argv)
5095{
5096 const char *value;
5097 char *name = argv[1];
5098
5099 if (name == NULL) {
5100 // TODO:
5101 // ash emits: export VAR='VAL'
5102 // bash: declare -x VAR="VAL"
5103 // (both also escape as needed (quotes, $, etc))
5104 char **e = environ;
5105 if (e)
5106 while (*e)
5107 puts(*e++);
5108 return EXIT_SUCCESS;
5109 }
5110
5111 value = strchr(name, '=');
5112 if (!value) {
5113 /* They are exporting something without a =VALUE */
5114 struct variable *var;
5115
5116 var = get_local_var(name);
5117 if (var) {
5118 var->flg_export = 1;
Denis Vlasenkof886fd22008-10-13 12:36:05 +00005119 debug_printf_env("%s: putenv '%s'\n", __func__, var->varstr);
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005120 putenv(var->varstr);
5121 }
5122 /* bash does not return an error when trying to export
5123 * an undefined variable. Do likewise. */
5124 return EXIT_SUCCESS;
5125 }
5126
5127 set_local_var(xstrdup(name), 1);
5128 return EXIT_SUCCESS;
5129}
5130
5131#if ENABLE_HUSH_JOB
5132/* built-in 'fg' and 'bg' handler */
5133static int builtin_fg_bg(char **argv)
5134{
5135 int i, jobnum;
5136 struct pipe *pi;
5137
Denis Vlasenko87a86552008-07-29 19:43:10 +00005138 if (!G.interactive_fd)
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005139 return EXIT_FAILURE;
5140 /* If they gave us no args, assume they want the last backgrounded task */
5141 if (!argv[1]) {
Denis Vlasenko87a86552008-07-29 19:43:10 +00005142 for (pi = G.job_list; pi; pi = pi->next) {
5143 if (pi->jobid == G.last_jobid) {
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005144 goto found;
5145 }
5146 }
5147 bb_error_msg("%s: no current job", argv[0]);
5148 return EXIT_FAILURE;
5149 }
5150 if (sscanf(argv[1], "%%%d", &jobnum) != 1) {
5151 bb_error_msg("%s: bad argument '%s'", argv[0], argv[1]);
5152 return EXIT_FAILURE;
5153 }
Denis Vlasenko87a86552008-07-29 19:43:10 +00005154 for (pi = G.job_list; pi; pi = pi->next) {
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005155 if (pi->jobid == jobnum) {
5156 goto found;
5157 }
5158 }
5159 bb_error_msg("%s: %d: no such job", argv[0], jobnum);
5160 return EXIT_FAILURE;
5161 found:
5162 // TODO: bash prints a string representation
5163 // of job being foregrounded (like "sleep 1 | cat")
5164 if (*argv[0] == 'f') {
5165 /* Put the job into the foreground. */
Denis Vlasenko87a86552008-07-29 19:43:10 +00005166 tcsetpgrp(G.interactive_fd, pi->pgrp);
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005167 }
5168
5169 /* Restart the processes in the job */
Denis Vlasenko9af22c72008-10-09 12:54:58 +00005170 debug_printf_jobs("reviving %d procs, pgrp %d\n", pi->num_cmds, pi->pgrp);
5171 for (i = 0; i < pi->num_cmds; i++) {
5172 debug_printf_jobs("reviving pid %d\n", pi->cmds[i].pid);
5173 pi->cmds[i].is_stopped = 0;
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005174 }
Denis Vlasenko9af22c72008-10-09 12:54:58 +00005175 pi->stopped_cmds = 0;
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005176
5177 i = kill(- pi->pgrp, SIGCONT);
5178 if (i < 0) {
5179 if (errno == ESRCH) {
5180 delete_finished_bg_job(pi);
5181 return EXIT_SUCCESS;
5182 } else {
5183 bb_perror_msg("kill (SIGCONT)");
5184 }
5185 }
5186
5187 if (*argv[0] == 'f') {
5188 remove_bg_job(pi);
5189 return checkjobs_and_fg_shell(pi);
5190 }
5191 return EXIT_SUCCESS;
5192}
5193#endif
5194
5195#if ENABLE_HUSH_HELP
Denis Vlasenkoa60f84e2008-07-05 09:18:54 +00005196static int builtin_help(char **argv UNUSED_PARAM)
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005197{
5198 const struct built_in_command *x;
5199
5200 printf("\nBuilt-in commands:\n");
5201 printf("-------------------\n");
5202 for (x = bltins; x != &bltins[ARRAY_SIZE(bltins)]; x++) {
5203 printf("%s\t%s\n", x->cmd, x->descr);
5204 }
5205 printf("\n\n");
5206 return EXIT_SUCCESS;
5207}
5208#endif
5209
5210#if ENABLE_HUSH_JOB
Denis Vlasenkoa60f84e2008-07-05 09:18:54 +00005211static int builtin_jobs(char **argv UNUSED_PARAM)
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005212{
5213 struct pipe *job;
5214 const char *status_string;
5215
Denis Vlasenko87a86552008-07-29 19:43:10 +00005216 for (job = G.job_list; job; job = job->next) {
Denis Vlasenko9af22c72008-10-09 12:54:58 +00005217 if (job->alive_cmds == job->stopped_cmds)
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005218 status_string = "Stopped";
5219 else
5220 status_string = "Running";
5221
5222 printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->cmdtext);
5223 }
5224 return EXIT_SUCCESS;
5225}
5226#endif
5227
Denis Vlasenkoa60f84e2008-07-05 09:18:54 +00005228static int builtin_pwd(char **argv UNUSED_PARAM)
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005229{
5230 puts(set_cwd());
5231 return EXIT_SUCCESS;
5232}
5233
5234static int builtin_read(char **argv)
5235{
5236 char *string;
5237 const char *name = argv[1] ? argv[1] : "REPLY";
5238
5239 string = xmalloc_reads(STDIN_FILENO, xasprintf("%s=", name), NULL);
5240 return set_local_var(string, 0);
5241}
5242
Mike Frysingerad88d5a2009-03-28 13:44:51 +00005243/* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#set
5244 * built-in 'set' handler
Denis Vlasenko11fb7cf2009-03-20 10:13:08 +00005245 * SUSv3 says:
Mike Frysingerad88d5a2009-03-28 13:44:51 +00005246 * set [-abCefhmnuvx] [-o option] [argument...]
5247 * set [+abCefhmnuvx] [+o option] [argument...]
Denis Vlasenko11fb7cf2009-03-20 10:13:08 +00005248 * set -- [argument...]
5249 * set -o
5250 * set +o
5251 * Implementations shall support the options in both their hyphen and
5252 * plus-sign forms. These options can also be specified as options to sh.
5253 * Examples:
5254 * Write out all variables and their values: set
5255 * Set $1, $2, and $3 and set "$#" to 3: set c a b
5256 * Turn on the -x and -v options: set -xv
5257 * Unset all positional parameters: set --
5258 * Set $1 to the value of x, even if it begins with '-' or '+': set -- "$x"
5259 * Set the positional parameters to the expansion of x, even if x expands
5260 * with a leading '-' or '+': set -- $x
5261 *
Mike Frysingerad88d5a2009-03-28 13:44:51 +00005262 * So far, we only support "set -- [argument...]" and some of the short names.
Denis Vlasenko11fb7cf2009-03-20 10:13:08 +00005263 */
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005264static int builtin_set(char **argv)
5265{
Denis Vlasenko424f79b2009-03-22 14:23:34 +00005266 int n;
5267 char **pp, **g_argv;
Denis Vlasenko11fb7cf2009-03-20 10:13:08 +00005268 char *arg = *++argv;
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005269
Denis Vlasenko11fb7cf2009-03-20 10:13:08 +00005270 if (arg == NULL) {
Denis Vlasenko424f79b2009-03-22 14:23:34 +00005271 struct variable *e;
Denis Vlasenko87a86552008-07-29 19:43:10 +00005272 for (e = G.top_var; e; e = e->next)
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005273 puts(e->varstr);
Denis Vlasenko424f79b2009-03-22 14:23:34 +00005274 return EXIT_SUCCESS;
Denis Vlasenko11fb7cf2009-03-20 10:13:08 +00005275 }
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005276
Mike Frysingerad88d5a2009-03-28 13:44:51 +00005277 do {
5278 if (!strcmp(arg, "--")) {
5279 ++argv;
5280 goto set_argv;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00005281 }
Mike Frysingerad88d5a2009-03-28 13:44:51 +00005282
5283 if (arg[0] == '+' || arg[0] == '-') {
5284 for (n = 1; arg[n]; ++n)
Denis Vlasenkod5762932009-03-31 11:22:57 +00005285 if (set_mode(arg[0], arg[n]))
Mike Frysingerad88d5a2009-03-28 13:44:51 +00005286 goto error;
5287 continue;
5288 }
5289
5290 break;
Denis Vlasenko424f79b2009-03-22 14:23:34 +00005291 } while ((arg = *++argv) != NULL);
5292 /* Now argv[0] is 1st argument */
5293
Mike Frysingerad88d5a2009-03-28 13:44:51 +00005294 /* Only reset global_argv if we didn't process anything */
5295 if (arg == NULL)
5296 return EXIT_SUCCESS;
5297 set_argv:
5298
Denis Vlasenko424f79b2009-03-22 14:23:34 +00005299 /* NB: G.global_argv[0] ($0) is never freed/changed */
5300 g_argv = G.global_argv;
5301 if (G.global_args_malloced) {
5302 pp = g_argv;
5303 while (*++pp)
5304 free(*pp);
5305 g_argv[1] = NULL;
5306 } else {
5307 G.global_args_malloced = 1;
5308 pp = xzalloc(sizeof(pp[0]) * 2);
5309 pp[0] = g_argv[0]; /* retain $0 */
5310 g_argv = pp;
5311 }
5312 /* This realloc's G.global_argv */
5313 G.global_argv = pp = add_strings_to_strings(g_argv, argv, /*dup:*/ 1);
5314
5315 n = 1;
5316 while (*++pp)
5317 n++;
5318 G.global_argc = n;
5319
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005320 return EXIT_SUCCESS;
Mike Frysingerad88d5a2009-03-28 13:44:51 +00005321
5322 /* Nothing known, so abort */
5323 error:
5324 bb_error_msg("set: %s: invalid option", arg);
5325 return EXIT_FAILURE;
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005326}
5327
5328static int builtin_shift(char **argv)
5329{
5330 int n = 1;
5331 if (argv[1]) {
5332 n = atoi(argv[1]);
5333 }
Denis Vlasenko87a86552008-07-29 19:43:10 +00005334 if (n >= 0 && n < G.global_argc) {
Denis Vlasenkoe1300f62009-03-22 11:41:18 +00005335 if (G.global_args_malloced) {
5336 int m = 1;
5337 while (m <= n)
5338 free(G.global_argv[m++]);
5339 }
Denis Vlasenko87a86552008-07-29 19:43:10 +00005340 G.global_argc -= n;
Denis Vlasenkoe1300f62009-03-22 11:41:18 +00005341 memmove(&G.global_argv[1], &G.global_argv[n+1],
5342 G.global_argc * sizeof(G.global_argv[0]));
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005343 return EXIT_SUCCESS;
5344 }
5345 return EXIT_FAILURE;
5346}
5347
5348static int builtin_source(char **argv)
5349{
5350 FILE *input;
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005351
5352 if (argv[1] == NULL)
5353 return EXIT_FAILURE;
5354
5355 /* XXX search through $PATH is missing */
Denis Vlasenko5415c852008-07-21 23:05:26 +00005356 input = fopen_for_read(argv[1]);
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005357 if (!input) {
Bernhard Reutner-Fischera53de7f2008-07-21 13:46:54 +00005358 bb_error_msg("can't open '%s'", argv[1]);
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005359 return EXIT_FAILURE;
5360 }
5361 close_on_exec_on(fileno(input));
5362
5363 /* Now run the file */
Denis Vlasenko87a86552008-07-29 19:43:10 +00005364 /* XXX argv and argc are broken; need to save old G.global_argv
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005365 * (pointer only is OK!) on this stack frame,
Denis Vlasenko87a86552008-07-29 19:43:10 +00005366 * set G.global_argv=argv+1, recurse, and restore. */
Denis Vlasenkob6e65562009-04-03 16:49:04 +00005367 parse_and_run_file(input);
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005368 fclose(input);
Denis Vlasenkob6e65562009-04-03 16:49:04 +00005369 return G.last_return_code;
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005370}
5371
5372static int builtin_umask(char **argv)
5373{
5374 mode_t new_umask;
5375 const char *arg = argv[1];
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005376 if (arg) {
Mike Frysinger40b8dc42009-03-29 00:50:30 +00005377 new_umask = bb_strtou(arg, NULL, 8);
5378 if (errno)
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005379 return EXIT_FAILURE;
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005380 } else {
5381 new_umask = umask(0);
5382 printf("%.3o\n", (unsigned) new_umask);
5383 }
5384 umask(new_umask);
5385 return EXIT_SUCCESS;
5386}
5387
Mike Frysingerd690f682009-03-30 06:50:54 +00005388/* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#unset */
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005389static int builtin_unset(char **argv)
5390{
Mike Frysingerd690f682009-03-30 06:50:54 +00005391 size_t i;
5392 int ret;
5393 bool var = true;
5394
5395 if (!argv[1])
5396 return EXIT_SUCCESS;
5397
5398 i = 0;
5399 if (argv[1][0] == '-') {
5400 switch (argv[1][1]) {
5401 case 'v': break;
5402 case 'f': if (ENABLE_HUSH_FUNCTIONS) { var = false; break; }
5403 default:
5404 bb_error_msg("unset: %s: invalid option", argv[1]);
5405 return EXIT_FAILURE;
5406 }
5407 ++i;
5408 }
5409
5410 ret = EXIT_SUCCESS;
5411 while (argv[++i]) {
5412 if (var) {
5413 if (unset_local_var(argv[i]))
5414 ret = EXIT_FAILURE;
5415 }
5416#if ENABLE_HUSH_FUNCTIONS
5417 else
5418 unset_local_func(argv[i]);
5419#endif
5420 }
5421 return ret;
Denis Vlasenkoc7985b72008-06-17 05:43:38 +00005422}
Denis Vlasenkobcb25532008-07-28 23:04:34 +00005423
Mike Frysinger56bdea12009-03-28 20:01:58 +00005424/* http://www.opengroup.org/onlinepubs/9699919799/utilities/wait.html */
5425static int builtin_wait(char **argv)
5426{
5427 int ret = EXIT_SUCCESS;
Denis Vlasenko7566bae2009-03-31 17:24:49 +00005428 int status, sig;
Mike Frysinger56bdea12009-03-28 20:01:58 +00005429
Denis Vlasenko7566bae2009-03-31 17:24:49 +00005430 if (*++argv == NULL) {
5431 /* Don't care about wait results */
5432 /* Note 1: must wait until there are no more children */
5433 /* Note 2: must be interruptible */
5434 /* Examples:
5435 * $ sleep 3 & sleep 6 & wait
5436 * [1] 30934 sleep 3
5437 * [2] 30935 sleep 6
5438 * [1] Done sleep 3
5439 * [2] Done sleep 6
5440 * $ sleep 3 & sleep 6 & wait
5441 * [1] 30936 sleep 3
5442 * [2] 30937 sleep 6
5443 * [1] Done sleep 3
5444 * ^C <-- after ~4 sec from keyboard
5445 * $
5446 */
5447 sigaddset(&G.blocked_set, SIGCHLD);
5448 sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
5449 while (1) {
5450 checkjobs(NULL);
5451 if (errno == ECHILD)
5452 break;
5453 /* Wait for SIGCHLD or any other signal of interest */
5454 /* sigtimedwait with infinite timeout: */
5455 sig = sigwaitinfo(&G.blocked_set, NULL);
5456 if (sig > 0) {
5457 sig = check_and_run_traps(sig);
5458 if (sig && sig != SIGCHLD) { /* see note 2 */
5459 ret = 128 + sig;
5460 break;
5461 }
5462 }
5463 }
5464 sigdelset(&G.blocked_set, SIGCHLD);
5465 sigprocmask(SIG_SETMASK, &G.blocked_set, NULL);
5466 return ret;
5467 }
Mike Frysinger56bdea12009-03-28 20:01:58 +00005468
Denis Vlasenko7566bae2009-03-31 17:24:49 +00005469 /* This is probably buggy wrt interruptible-ness */
Denis Vlasenkod5762932009-03-31 11:22:57 +00005470 while (*argv) {
5471 pid_t pid = bb_strtou(*argv, NULL, 10);
Mike Frysinger40b8dc42009-03-29 00:50:30 +00005472 if (errno) {
Denis Vlasenkod5762932009-03-31 11:22:57 +00005473 /* mimic bash message */
5474 bb_error_msg("wait: '%s': not a pid or valid job spec", *argv);
Mike Frysinger56bdea12009-03-28 20:01:58 +00005475 return EXIT_FAILURE;
Denis Vlasenkod5762932009-03-31 11:22:57 +00005476 }
5477 if (waitpid(pid, &status, 0) == pid) {
Mike Frysinger56bdea12009-03-28 20:01:58 +00005478 if (WIFSIGNALED(status))
5479 ret = 128 + WTERMSIG(status);
5480 else if (WIFEXITED(status))
5481 ret = WEXITSTATUS(status);
Denis Vlasenkod5762932009-03-31 11:22:57 +00005482 else /* wtf? */
Mike Frysinger56bdea12009-03-28 20:01:58 +00005483 ret = EXIT_FAILURE;
5484 } else {
Denis Vlasenkod5762932009-03-31 11:22:57 +00005485 bb_perror_msg("wait %s", *argv);
Mike Frysinger56bdea12009-03-28 20:01:58 +00005486 ret = 127;
5487 }
Denis Vlasenkod5762932009-03-31 11:22:57 +00005488 argv++;
Mike Frysinger56bdea12009-03-28 20:01:58 +00005489 }
5490
5491 return ret;
5492}
5493
Denis Vlasenkodadfb492008-07-29 10:16:05 +00005494#if ENABLE_HUSH_LOOPS
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +00005495static int builtin_break(char **argv)
Denis Vlasenkobcb25532008-07-28 23:04:34 +00005496{
Denis Vlasenko87a86552008-07-29 19:43:10 +00005497 if (G.depth_of_loop == 0) {
Denis Vlasenko4f504a92008-07-29 19:48:30 +00005498 bb_error_msg("%s: only meaningful in a loop", argv[0]);
Denis Vlasenkofcf37c32008-07-29 11:37:15 +00005499 return EXIT_SUCCESS; /* bash compat */
5500 }
Denis Vlasenko87a86552008-07-29 19:43:10 +00005501 G.flag_break_continue++; /* BC_BREAK = 1 */
5502 G.depth_break_continue = 1;
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +00005503 if (argv[1]) {
Denis Vlasenko87a86552008-07-29 19:43:10 +00005504 G.depth_break_continue = bb_strtou(argv[1], NULL, 10);
5505 if (errno || !G.depth_break_continue || argv[2]) {
Denis Vlasenko4f504a92008-07-29 19:48:30 +00005506 bb_error_msg("%s: bad arguments", argv[0]);
Denis Vlasenko87a86552008-07-29 19:43:10 +00005507 G.flag_break_continue = BC_BREAK;
5508 G.depth_break_continue = UINT_MAX;
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +00005509 }
5510 }
Denis Vlasenko87a86552008-07-29 19:43:10 +00005511 if (G.depth_of_loop < G.depth_break_continue)
5512 G.depth_break_continue = G.depth_of_loop;
Denis Vlasenkobcb25532008-07-28 23:04:34 +00005513 return EXIT_SUCCESS;
5514}
5515
Denis Vlasenko6a2d40f2008-07-28 23:07:06 +00005516static int builtin_continue(char **argv)
Denis Vlasenkobcb25532008-07-28 23:04:34 +00005517{
Denis Vlasenko4f504a92008-07-29 19:48:30 +00005518 G.flag_break_continue = 1; /* BC_CONTINUE = 2 = 1+1 */
5519 return builtin_break(argv);
Denis Vlasenkobcb25532008-07-28 23:04:34 +00005520}
Denis Vlasenkodadfb492008-07-29 10:16:05 +00005521#endif