]>
Commit | Line | Data |
---|---|---|
fe8c2806 WD |
1 | /* |
2 | * sh.c -- a prototype Bourne shell grammar parser | |
3 | * Intended to follow the original Thompson and Ritchie | |
4 | * "small and simple is beautiful" philosophy, which | |
5 | * incidentally is a good match to today's BusyBox. | |
6 | * | |
7 | * Copyright (C) 2000,2001 Larry Doolittle <larry@doolittle.boa.org> | |
8 | * | |
9 | * Credits: | |
10 | * The parser routines proper are all original material, first | |
11 | * written Dec 2000 and Jan 2001 by Larry Doolittle. | |
12 | * The execution engine, the builtins, and much of the underlying | |
13 | * support has been adapted from busybox-0.49pre's lash, | |
14 | * which is Copyright (C) 2000 by Lineo, Inc., and | |
15 | * written by Erik Andersen <andersen@lineo.com>, <andersee@debian.org>. | |
16 | * That, in turn, is based in part on ladsh.c, by Michael K. Johnson and | |
17 | * Erik W. Troan, which they placed in the public domain. I don't know | |
18 | * how much of the Johnson/Troan code has survived the repeated rewrites. | |
19 | * Other credits: | |
fe8c2806 WD |
20 | * b_addchr() derived from similar w_addchar function in glibc-2.2 |
21 | * setup_redirect(), redirect_opt_num(), and big chunks of main() | |
22 | * and many builtins derived from contributions by Erik Andersen | |
23 | * miscellaneous bugfixes from Matt Kraai | |
24 | * | |
25 | * There are two big (and related) architecture differences between | |
26 | * this parser and the lash parser. One is that this version is | |
27 | * actually designed from the ground up to understand nearly all | |
28 | * of the Bourne grammar. The second, consequential change is that | |
29 | * the parser and input reader have been turned inside out. Now, | |
30 | * the parser is in control, and asks for input as needed. The old | |
31 | * way had the input reader in control, and it asked for parsing to | |
32 | * take place as needed. The new way makes it much easier to properly | |
33 | * handle the recursion implicit in the various substitutions, especially | |
34 | * across continuation lines. | |
35 | * | |
36 | * Bash grammar not implemented: (how many of these were in original sh?) | |
37 | * $@ (those sure look like weird quoting rules) | |
38 | * $_ | |
39 | * ! negation operator for pipes | |
40 | * &> and >& redirection of stdout+stderr | |
41 | * Brace Expansion | |
42 | * Tilde Expansion | |
43 | * fancy forms of Parameter Expansion | |
44 | * aliases | |
45 | * Arithmetic Expansion | |
46 | * <(list) and >(list) Process Substitution | |
47 | * reserved words: case, esac, select, function | |
48 | * Here Documents ( << word ) | |
49 | * Functions | |
50 | * Major bugs: | |
51 | * job handling woefully incomplete and buggy | |
52 | * reserved word execution woefully incomplete and buggy | |
53 | * to-do: | |
54 | * port selected bugfixes from post-0.49 busybox lash - done? | |
55 | * finish implementing reserved words: for, while, until, do, done | |
56 | * change { and } from special chars to reserved words | |
57 | * builtins: break, continue, eval, return, set, trap, ulimit | |
58 | * test magic exec | |
59 | * handle children going into background | |
60 | * clean up recognition of null pipes | |
61 | * check setting of global_argc and global_argv | |
62 | * control-C handling, probably with longjmp | |
63 | * follow IFS rules more precisely, including update semantics | |
64 | * figure out what to do with backslash-newline | |
65 | * explain why we use signal instead of sigaction | |
66 | * propagate syntax errors, die on resource errors? | |
67 | * continuation lines, both explicit and implicit - done? | |
68 | * memory leak finding and plugging - done? | |
69 | * more testing, especially quoting rules and redirection | |
70 | * document how quoting rules not precisely followed for variable assignments | |
71 | * maybe change map[] to use 2-bit entries | |
72 | * (eventually) remove all the printf's | |
73 | * | |
1a459660 | 74 | * SPDX-License-Identifier: GPL-2.0+ |
fe8c2806 | 75 | */ |
1a459660 | 76 | |
fe8c2806 WD |
77 | #define __U_BOOT__ |
78 | #ifdef __U_BOOT__ | |
79 | #include <malloc.h> /* malloc, free, realloc*/ | |
80 | #include <linux/ctype.h> /* isalpha, isdigit */ | |
81 | #include <common.h> /* readline */ | |
24b852a7 | 82 | #include <console.h> |
0098e179 | 83 | #include <bootretry.h> |
18d66533 | 84 | #include <cli.h> |
eca86fad | 85 | #include <cli_hush.h> |
fe8c2806 | 86 | #include <command.h> /* find_cmd */ |
219f4788 TR |
87 | #ifndef CONFIG_SYS_PROMPT_HUSH_PS2 |
88 | #define CONFIG_SYS_PROMPT_HUSH_PS2 "> " | |
89 | #endif | |
fe8c2806 | 90 | #endif |
fe8c2806 WD |
91 | #ifndef __U_BOOT__ |
92 | #include <ctype.h> /* isalpha, isdigit */ | |
93 | #include <unistd.h> /* getpid */ | |
94 | #include <stdlib.h> /* getenv, atoi */ | |
95 | #include <string.h> /* strchr */ | |
96 | #include <stdio.h> /* popen etc. */ | |
97 | #include <glob.h> /* glob, of course */ | |
98 | #include <stdarg.h> /* va_list */ | |
99 | #include <errno.h> | |
100 | #include <fcntl.h> | |
101 | #include <getopt.h> /* should be pretty obvious */ | |
102 | ||
103 | #include <sys/stat.h> /* ulimit */ | |
104 | #include <sys/types.h> | |
105 | #include <sys/wait.h> | |
106 | #include <signal.h> | |
107 | ||
108 | /* #include <dmalloc.h> */ | |
fe8c2806 | 109 | |
d0fb80c3 | 110 | #if 1 |
fe8c2806 WD |
111 | #include "busybox.h" |
112 | #include "cmdedit.h" | |
113 | #else | |
114 | #define applet_name "hush" | |
115 | #include "standalone.h" | |
116 | #define hush_main main | |
d0fb80c3 WD |
117 | #undef CONFIG_FEATURE_SH_FANCY_PROMPT |
118 | #define BB_BANNER | |
fe8c2806 WD |
119 | #endif |
120 | #endif | |
121 | #define SPECIAL_VAR_SYMBOL 03 | |
a005f19e | 122 | #define SUBSTED_VAR_SYMBOL 04 |
fe8c2806 WD |
123 | #ifndef __U_BOOT__ |
124 | #define FLAG_EXIT_FROM_LOOP 1 | |
125 | #define FLAG_PARSE_SEMICOLON (1 << 1) /* symbol ';' is special for parser */ | |
126 | #define FLAG_REPARSING (1 << 2) /* >= 2nd pass */ | |
127 | ||
128 | #endif | |
129 | ||
130 | #ifdef __U_BOOT__ | |
d87080b7 WD |
131 | DECLARE_GLOBAL_DATA_PTR; |
132 | ||
fe8c2806 WD |
133 | #define EXIT_SUCCESS 0 |
134 | #define EOF -1 | |
135 | #define syntax() syntax_err() | |
136 | #define xstrdup strdup | |
137 | #define error_msg printf | |
138 | #else | |
139 | typedef enum { | |
140 | REDIRECT_INPUT = 1, | |
141 | REDIRECT_OVERWRITE = 2, | |
142 | REDIRECT_APPEND = 3, | |
143 | REDIRECT_HEREIS = 4, | |
144 | REDIRECT_IO = 5 | |
145 | } redir_type; | |
146 | ||
147 | /* The descrip member of this structure is only used to make debugging | |
148 | * output pretty */ | |
149 | struct {int mode; int default_fd; char *descrip;} redir_table[] = { | |
150 | { 0, 0, "()" }, | |
151 | { O_RDONLY, 0, "<" }, | |
152 | { O_CREAT|O_TRUNC|O_WRONLY, 1, ">" }, | |
153 | { O_CREAT|O_APPEND|O_WRONLY, 1, ">>" }, | |
154 | { O_RDONLY, -1, "<<" }, | |
155 | { O_RDWR, 1, "<>" } | |
156 | }; | |
157 | #endif | |
158 | ||
159 | typedef enum { | |
160 | PIPE_SEQ = 1, | |
161 | PIPE_AND = 2, | |
162 | PIPE_OR = 3, | |
163 | PIPE_BG = 4, | |
164 | } pipe_style; | |
165 | ||
166 | /* might eventually control execution */ | |
167 | typedef enum { | |
168 | RES_NONE = 0, | |
169 | RES_IF = 1, | |
170 | RES_THEN = 2, | |
171 | RES_ELIF = 3, | |
172 | RES_ELSE = 4, | |
173 | RES_FI = 5, | |
174 | RES_FOR = 6, | |
175 | RES_WHILE = 7, | |
176 | RES_UNTIL = 8, | |
177 | RES_DO = 9, | |
178 | RES_DONE = 10, | |
179 | RES_XXXX = 11, | |
180 | RES_IN = 12, | |
181 | RES_SNTX = 13 | |
182 | } reserved_style; | |
183 | #define FLAG_END (1<<RES_NONE) | |
184 | #define FLAG_IF (1<<RES_IF) | |
185 | #define FLAG_THEN (1<<RES_THEN) | |
186 | #define FLAG_ELIF (1<<RES_ELIF) | |
187 | #define FLAG_ELSE (1<<RES_ELSE) | |
188 | #define FLAG_FI (1<<RES_FI) | |
189 | #define FLAG_FOR (1<<RES_FOR) | |
190 | #define FLAG_WHILE (1<<RES_WHILE) | |
191 | #define FLAG_UNTIL (1<<RES_UNTIL) | |
192 | #define FLAG_DO (1<<RES_DO) | |
193 | #define FLAG_DONE (1<<RES_DONE) | |
194 | #define FLAG_IN (1<<RES_IN) | |
195 | #define FLAG_START (1<<RES_XXXX) | |
196 | ||
197 | /* This holds pointers to the various results of parsing */ | |
198 | struct p_context { | |
199 | struct child_prog *child; | |
200 | struct pipe *list_head; | |
201 | struct pipe *pipe; | |
202 | #ifndef __U_BOOT__ | |
203 | struct redir_struct *pending_redirect; | |
204 | #endif | |
205 | reserved_style w; | |
206 | int old_flag; /* for figuring out valid reserved words */ | |
207 | struct p_context *stack; | |
208 | int type; /* define type of parser : ";$" common or special symbol */ | |
209 | /* How about quoting status? */ | |
210 | }; | |
211 | ||
212 | #ifndef __U_BOOT__ | |
213 | struct redir_struct { | |
214 | redir_type type; /* type of redirection */ | |
215 | int fd; /* file descriptor being redirected */ | |
216 | int dup; /* -1, or file descriptor being duplicated */ | |
217 | struct redir_struct *next; /* pointer to the next redirect in the list */ | |
218 | glob_t word; /* *word.gl_pathv is the filename */ | |
219 | }; | |
220 | #endif | |
221 | ||
222 | struct child_prog { | |
223 | #ifndef __U_BOOT__ | |
224 | pid_t pid; /* 0 if exited */ | |
225 | #endif | |
226 | char **argv; /* program name and arguments */ | |
fe9ca3d3 | 227 | /* was quoted when parsed; copy of struct o_string.nonnull field */ |
eca86fad | 228 | int *argv_nonnull; |
fe8c2806 WD |
229 | #ifdef __U_BOOT__ |
230 | int argc; /* number of program arguments */ | |
231 | #endif | |
232 | struct pipe *group; /* if non-NULL, first in group or subshell */ | |
233 | #ifndef __U_BOOT__ | |
234 | int subshell; /* flag, non-zero if group must be forked */ | |
235 | struct redir_struct *redirects; /* I/O redirections */ | |
236 | glob_t glob_result; /* result of parameter globbing */ | |
237 | int is_stopped; /* is the program currently running? */ | |
238 | struct pipe *family; /* pointer back to the child's parent pipe */ | |
239 | #endif | |
240 | int sp; /* number of SPECIAL_VAR_SYMBOL */ | |
241 | int type; | |
242 | }; | |
243 | ||
244 | struct pipe { | |
245 | #ifndef __U_BOOT__ | |
246 | int jobid; /* job number */ | |
247 | #endif | |
248 | int num_progs; /* total number of programs in job */ | |
249 | #ifndef __U_BOOT__ | |
250 | int running_progs; /* number of programs running */ | |
251 | char *text; /* name of job */ | |
252 | char *cmdbuf; /* buffer various argv's point into */ | |
253 | pid_t pgrp; /* process group ID for the job */ | |
254 | #endif | |
255 | struct child_prog *progs; /* array of commands in pipe */ | |
256 | struct pipe *next; /* to track background commands */ | |
257 | #ifndef __U_BOOT__ | |
258 | int stopped_progs; /* number of programs alive, but stopped */ | |
259 | int job_context; /* bitmask defining current context */ | |
260 | #endif | |
261 | pipe_style followup; /* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */ | |
262 | reserved_style r_mode; /* supports if, for, while, until */ | |
263 | }; | |
264 | ||
265 | #ifndef __U_BOOT__ | |
266 | struct close_me { | |
267 | int fd; | |
268 | struct close_me *next; | |
269 | }; | |
270 | #endif | |
271 | ||
272 | struct variables { | |
273 | char *name; | |
274 | char *value; | |
275 | int flg_export; | |
276 | int flg_read_only; | |
277 | struct variables *next; | |
278 | }; | |
279 | ||
280 | /* globals, connect us to the outside world | |
281 | * the first three support $?, $#, and $1 */ | |
282 | #ifndef __U_BOOT__ | |
283 | char **global_argv; | |
284 | unsigned int global_argc; | |
285 | #endif | |
199adb60 | 286 | static unsigned int last_return_code; |
fe8c2806 WD |
287 | #ifndef __U_BOOT__ |
288 | extern char **environ; /* This is in <unistd.h>, but protected with __USE_GNU */ | |
289 | #endif | |
290 | ||
291 | /* "globals" within this file */ | |
77ddac94 | 292 | static uchar *ifs; |
fe8c2806 WD |
293 | static char map[256]; |
294 | #ifndef __U_BOOT__ | |
295 | static int fake_mode; | |
296 | static int interactive; | |
297 | static struct close_me *close_me_head; | |
298 | static const char *cwd; | |
299 | static struct pipe *job_list; | |
300 | static unsigned int last_bg_pid; | |
301 | static unsigned int last_jobid; | |
302 | static unsigned int shell_terminal; | |
303 | static char *PS1; | |
304 | static char *PS2; | |
305 | struct variables shell_ver = { "HUSH_VERSION", "0.01", 1, 1, 0 }; | |
306 | struct variables *top_vars = &shell_ver; | |
307 | #else | |
308 | static int flag_repeat = 0; | |
309 | static int do_repeat = 0; | |
2d5b561e | 310 | static struct variables *top_vars = NULL ; |
fe8c2806 WD |
311 | #endif /*__U_BOOT__ */ |
312 | ||
313 | #define B_CHUNK (100) | |
314 | #define B_NOSPAC 1 | |
315 | ||
316 | typedef struct { | |
317 | char *data; | |
318 | int length; | |
319 | int maxlen; | |
320 | int quote; | |
321 | int nonnull; | |
322 | } o_string; | |
323 | #define NULL_O_STRING {NULL,0,0,0,0} | |
324 | /* used for initialization: | |
325 | o_string foo = NULL_O_STRING; */ | |
326 | ||
327 | /* I can almost use ordinary FILE *. Is open_memstream() universally | |
328 | * available? Where is it documented? */ | |
329 | struct in_str { | |
330 | const char *p; | |
331 | #ifndef __U_BOOT__ | |
332 | char peek_buf[2]; | |
333 | #endif | |
334 | int __promptme; | |
335 | int promptmode; | |
336 | #ifndef __U_BOOT__ | |
337 | FILE *file; | |
338 | #endif | |
339 | int (*get) (struct in_str *); | |
340 | int (*peek) (struct in_str *); | |
341 | }; | |
342 | #define b_getch(input) ((input)->get(input)) | |
343 | #define b_peek(input) ((input)->peek(input)) | |
344 | ||
345 | #ifndef __U_BOOT__ | |
346 | #define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n" | |
347 | ||
348 | struct built_in_command { | |
349 | char *cmd; /* name */ | |
350 | char *descr; /* description */ | |
351 | int (*function) (struct child_prog *); /* function ptr */ | |
352 | }; | |
353 | #endif | |
354 | ||
4cacf7c6 SR |
355 | /* define DEBUG_SHELL for debugging output (obviously ;-)) */ |
356 | #if 0 | |
357 | #define DEBUG_SHELL | |
358 | #endif | |
359 | ||
fe8c2806 WD |
360 | /* This should be in utility.c */ |
361 | #ifdef DEBUG_SHELL | |
362 | #ifndef __U_BOOT__ | |
363 | static void debug_printf(const char *format, ...) | |
364 | { | |
365 | va_list args; | |
366 | va_start(args, format); | |
367 | vfprintf(stderr, format, args); | |
368 | va_end(args); | |
369 | } | |
370 | #else | |
4cacf7c6 | 371 | #define debug_printf(fmt,args...) printf (fmt ,##args) |
fe8c2806 WD |
372 | #endif |
373 | #else | |
374 | static inline void debug_printf(const char *format, ...) { } | |
375 | #endif | |
376 | #define final_printf debug_printf | |
377 | ||
378 | #ifdef __U_BOOT__ | |
379 | static void syntax_err(void) { | |
380 | printf("syntax error\n"); | |
381 | } | |
382 | #else | |
383 | static void __syntax(char *file, int line) { | |
384 | error_msg("syntax error %s:%d", file, line); | |
385 | } | |
386 | #define syntax() __syntax(__FILE__, __LINE__) | |
387 | #endif | |
388 | ||
389 | #ifdef __U_BOOT__ | |
390 | static void *xmalloc(size_t size); | |
391 | static void *xrealloc(void *ptr, size_t size); | |
392 | #else | |
393 | /* Index of subroutines: */ | |
394 | /* function prototypes for builtins */ | |
395 | static int builtin_cd(struct child_prog *child); | |
396 | static int builtin_env(struct child_prog *child); | |
397 | static int builtin_eval(struct child_prog *child); | |
398 | static int builtin_exec(struct child_prog *child); | |
399 | static int builtin_exit(struct child_prog *child); | |
400 | static int builtin_export(struct child_prog *child); | |
401 | static int builtin_fg_bg(struct child_prog *child); | |
402 | static int builtin_help(struct child_prog *child); | |
403 | static int builtin_jobs(struct child_prog *child); | |
404 | static int builtin_pwd(struct child_prog *child); | |
405 | static int builtin_read(struct child_prog *child); | |
406 | static int builtin_set(struct child_prog *child); | |
407 | static int builtin_shift(struct child_prog *child); | |
408 | static int builtin_source(struct child_prog *child); | |
409 | static int builtin_umask(struct child_prog *child); | |
410 | static int builtin_unset(struct child_prog *child); | |
411 | static int builtin_not_written(struct child_prog *child); | |
412 | #endif | |
413 | /* o_string manipulation: */ | |
414 | static int b_check_space(o_string *o, int len); | |
415 | static int b_addchr(o_string *o, int ch); | |
416 | static void b_reset(o_string *o); | |
417 | static int b_addqchr(o_string *o, int ch, int quote); | |
c26e454d | 418 | #ifndef __U_BOOT__ |
fe8c2806 | 419 | static int b_adduint(o_string *o, unsigned int i); |
c26e454d | 420 | #endif |
fe8c2806 WD |
421 | /* in_str manipulations: */ |
422 | static int static_get(struct in_str *i); | |
423 | static int static_peek(struct in_str *i); | |
424 | static int file_get(struct in_str *i); | |
425 | static int file_peek(struct in_str *i); | |
426 | #ifndef __U_BOOT__ | |
427 | static void setup_file_in_str(struct in_str *i, FILE *f); | |
428 | #else | |
429 | static void setup_file_in_str(struct in_str *i); | |
430 | #endif | |
431 | static void setup_string_in_str(struct in_str *i, const char *s); | |
432 | #ifndef __U_BOOT__ | |
433 | /* close_me manipulations: */ | |
434 | static void mark_open(int fd); | |
435 | static void mark_closed(int fd); | |
d0fb80c3 | 436 | static void close_all(void); |
fe8c2806 WD |
437 | #endif |
438 | /* "run" the final data structures: */ | |
439 | static char *indenter(int i); | |
440 | static int free_pipe_list(struct pipe *head, int indent); | |
441 | static int free_pipe(struct pipe *pi, int indent); | |
442 | /* really run the final data structures: */ | |
443 | #ifndef __U_BOOT__ | |
444 | static int setup_redirects(struct child_prog *prog, int squirrel[]); | |
445 | #endif | |
446 | static int run_list_real(struct pipe *pi); | |
447 | #ifndef __U_BOOT__ | |
448 | static void pseudo_exec(struct child_prog *child) __attribute__ ((noreturn)); | |
449 | #endif | |
450 | static int run_pipe_real(struct pipe *pi); | |
451 | /* extended glob support: */ | |
452 | #ifndef __U_BOOT__ | |
453 | static int globhack(const char *src, int flags, glob_t *pglob); | |
454 | static int glob_needed(const char *s); | |
455 | static int xglob(o_string *dest, int flags, glob_t *pglob); | |
456 | #endif | |
457 | /* variable assignment: */ | |
458 | static int is_assignment(const char *s); | |
459 | /* data structure manipulation: */ | |
460 | #ifndef __U_BOOT__ | |
461 | static int setup_redirect(struct p_context *ctx, int fd, redir_type style, struct in_str *input); | |
462 | #endif | |
463 | static void initialize_context(struct p_context *ctx); | |
464 | static int done_word(o_string *dest, struct p_context *ctx); | |
465 | static int done_command(struct p_context *ctx); | |
466 | static int done_pipe(struct p_context *ctx, pipe_style type); | |
467 | /* primary string parsing: */ | |
468 | #ifndef __U_BOOT__ | |
469 | static int redirect_dup_num(struct in_str *input); | |
470 | static int redirect_opt_num(o_string *o); | |
471 | static int process_command_subs(o_string *dest, struct p_context *ctx, struct in_str *input, int subst_end); | |
472 | static int parse_group(o_string *dest, struct p_context *ctx, struct in_str *input, int ch); | |
473 | #endif | |
474 | static char *lookup_param(char *src); | |
fe9ca3d3 | 475 | static char *make_string(char **inp, int *nonnull); |
fe8c2806 WD |
476 | static int handle_dollar(o_string *dest, struct p_context *ctx, struct in_str *input); |
477 | #ifndef __U_BOOT__ | |
478 | static int parse_string(o_string *dest, struct p_context *ctx, const char *src); | |
479 | #endif | |
480 | static int parse_stream(o_string *dest, struct p_context *ctx, struct in_str *input0, int end_trigger); | |
481 | /* setup: */ | |
482 | static int parse_stream_outer(struct in_str *inp, int flag); | |
483 | #ifndef __U_BOOT__ | |
484 | static int parse_string_outer(const char *s, int flag); | |
485 | static int parse_file_outer(FILE *f); | |
486 | #endif | |
487 | #ifndef __U_BOOT__ | |
488 | /* job management: */ | |
489 | static int checkjobs(struct pipe* fg_pipe); | |
490 | static void insert_bg_job(struct pipe *pi); | |
491 | static void remove_bg_job(struct pipe *pi); | |
492 | #endif | |
493 | /* local variable support */ | |
494 | static char **make_list_in(char **inp, char *name); | |
495 | static char *insert_var_value(char *inp); | |
a005f19e | 496 | static char *insert_var_value_sub(char *inp, int tag_subst); |
fe8c2806 WD |
497 | |
498 | #ifndef __U_BOOT__ | |
499 | /* Table of built-in functions. They can be forked or not, depending on | |
500 | * context: within pipes, they fork. As simple commands, they do not. | |
501 | * When used in non-forking context, they can change global variables | |
502 | * in the parent shell process. If forked, of course they can not. | |
503 | * For example, 'unset foo | whatever' will parse and run, but foo will | |
504 | * still be set at the end. */ | |
505 | static struct built_in_command bltins[] = { | |
506 | {"bg", "Resume a job in the background", builtin_fg_bg}, | |
507 | {"break", "Exit for, while or until loop", builtin_not_written}, | |
508 | {"cd", "Change working directory", builtin_cd}, | |
509 | {"continue", "Continue for, while or until loop", builtin_not_written}, | |
510 | {"env", "Print all environment variables", builtin_env}, | |
511 | {"eval", "Construct and run shell command", builtin_eval}, | |
512 | {"exec", "Exec command, replacing this shell with the exec'd process", | |
513 | builtin_exec}, | |
514 | {"exit", "Exit from shell()", builtin_exit}, | |
515 | {"export", "Set environment variable", builtin_export}, | |
516 | {"fg", "Bring job into the foreground", builtin_fg_bg}, | |
517 | {"jobs", "Lists the active jobs", builtin_jobs}, | |
518 | {"pwd", "Print current directory", builtin_pwd}, | |
519 | {"read", "Input environment variable", builtin_read}, | |
520 | {"return", "Return from a function", builtin_not_written}, | |
521 | {"set", "Set/unset shell local variables", builtin_set}, | |
522 | {"shift", "Shift positional parameters", builtin_shift}, | |
523 | {"trap", "Trap signals", builtin_not_written}, | |
524 | {"ulimit","Controls resource limits", builtin_not_written}, | |
525 | {"umask","Sets file creation mask", builtin_umask}, | |
526 | {"unset", "Unset environment variable", builtin_unset}, | |
527 | {".", "Source-in and run commands in a file", builtin_source}, | |
528 | {"help", "List shell built-in commands", builtin_help}, | |
529 | {NULL, NULL, NULL} | |
530 | }; | |
531 | ||
532 | static const char *set_cwd(void) | |
533 | { | |
534 | if(cwd==unknown) | |
535 | cwd = NULL; /* xgetcwd(arg) called free(arg) */ | |
536 | cwd = xgetcwd((char *)cwd); | |
537 | if (!cwd) | |
538 | cwd = unknown; | |
539 | return cwd; | |
540 | } | |
541 | ||
542 | /* built-in 'eval' handler */ | |
543 | static int builtin_eval(struct child_prog *child) | |
544 | { | |
545 | char *str = NULL; | |
546 | int rcode = EXIT_SUCCESS; | |
547 | ||
548 | if (child->argv[1]) { | |
549 | str = make_string(child->argv + 1); | |
550 | parse_string_outer(str, FLAG_EXIT_FROM_LOOP | | |
551 | FLAG_PARSE_SEMICOLON); | |
552 | free(str); | |
553 | rcode = last_return_code; | |
554 | } | |
555 | return rcode; | |
556 | } | |
557 | ||
558 | /* built-in 'cd <path>' handler */ | |
559 | static int builtin_cd(struct child_prog *child) | |
560 | { | |
561 | char *newdir; | |
562 | if (child->argv[1] == NULL) | |
563 | newdir = getenv("HOME"); | |
564 | else | |
565 | newdir = child->argv[1]; | |
566 | if (chdir(newdir)) { | |
567 | printf("cd: %s: %s\n", newdir, strerror(errno)); | |
568 | return EXIT_FAILURE; | |
569 | } | |
570 | set_cwd(); | |
571 | return EXIT_SUCCESS; | |
572 | } | |
573 | ||
574 | /* built-in 'env' handler */ | |
575 | static int builtin_env(struct child_prog *dummy) | |
576 | { | |
577 | char **e = environ; | |
578 | if (e == NULL) return EXIT_FAILURE; | |
579 | for (; *e; e++) { | |
580 | puts(*e); | |
581 | } | |
582 | return EXIT_SUCCESS; | |
583 | } | |
584 | ||
585 | /* built-in 'exec' handler */ | |
586 | static int builtin_exec(struct child_prog *child) | |
587 | { | |
588 | if (child->argv[1] == NULL) | |
589 | return EXIT_SUCCESS; /* Really? */ | |
590 | child->argv++; | |
591 | pseudo_exec(child); | |
592 | /* never returns */ | |
593 | } | |
594 | ||
595 | /* built-in 'exit' handler */ | |
596 | static int builtin_exit(struct child_prog *child) | |
597 | { | |
598 | if (child->argv[1] == NULL) | |
599 | exit(last_return_code); | |
600 | exit (atoi(child->argv[1])); | |
601 | } | |
602 | ||
603 | /* built-in 'export VAR=value' handler */ | |
604 | static int builtin_export(struct child_prog *child) | |
605 | { | |
606 | int res = 0; | |
607 | char *name = child->argv[1]; | |
608 | ||
609 | if (name == NULL) { | |
610 | return (builtin_env(child)); | |
611 | } | |
612 | ||
613 | name = strdup(name); | |
614 | ||
615 | if(name) { | |
616 | char *value = strchr(name, '='); | |
617 | ||
618 | if (!value) { | |
619 | char *tmp; | |
620 | /* They are exporting something without an =VALUE */ | |
621 | ||
622 | value = get_local_var(name); | |
623 | if (value) { | |
624 | size_t ln = strlen(name); | |
625 | ||
626 | tmp = realloc(name, ln+strlen(value)+2); | |
627 | if(tmp==NULL) | |
628 | res = -1; | |
629 | else { | |
630 | sprintf(tmp+ln, "=%s", value); | |
631 | name = tmp; | |
632 | } | |
633 | } else { | |
634 | /* bash does not return an error when trying to export | |
635 | * an undefined variable. Do likewise. */ | |
636 | res = 1; | |
637 | } | |
638 | } | |
639 | } | |
640 | if (res<0) | |
641 | perror_msg("export"); | |
642 | else if(res==0) | |
643 | res = set_local_var(name, 1); | |
644 | else | |
645 | res = 0; | |
646 | free(name); | |
647 | return res; | |
648 | } | |
649 | ||
650 | /* built-in 'fg' and 'bg' handler */ | |
651 | static int builtin_fg_bg(struct child_prog *child) | |
652 | { | |
653 | int i, jobnum; | |
654 | struct pipe *pi=NULL; | |
655 | ||
656 | if (!interactive) | |
657 | return EXIT_FAILURE; | |
658 | /* If they gave us no args, assume they want the last backgrounded task */ | |
659 | if (!child->argv[1]) { | |
660 | for (pi = job_list; pi; pi = pi->next) { | |
661 | if (pi->jobid == last_jobid) { | |
662 | break; | |
663 | } | |
664 | } | |
665 | if (!pi) { | |
666 | error_msg("%s: no current job", child->argv[0]); | |
667 | return EXIT_FAILURE; | |
668 | } | |
669 | } else { | |
670 | if (sscanf(child->argv[1], "%%%d", &jobnum) != 1) { | |
671 | error_msg("%s: bad argument '%s'", child->argv[0], child->argv[1]); | |
672 | return EXIT_FAILURE; | |
673 | } | |
674 | for (pi = job_list; pi; pi = pi->next) { | |
675 | if (pi->jobid == jobnum) { | |
676 | break; | |
677 | } | |
678 | } | |
679 | if (!pi) { | |
680 | error_msg("%s: %d: no such job", child->argv[0], jobnum); | |
681 | return EXIT_FAILURE; | |
682 | } | |
683 | } | |
684 | ||
685 | if (*child->argv[0] == 'f') { | |
686 | /* Put the job into the foreground. */ | |
687 | tcsetpgrp(shell_terminal, pi->pgrp); | |
688 | } | |
689 | ||
690 | /* Restart the processes in the job */ | |
691 | for (i = 0; i < pi->num_progs; i++) | |
692 | pi->progs[i].is_stopped = 0; | |
693 | ||
694 | if ( (i=kill(- pi->pgrp, SIGCONT)) < 0) { | |
695 | if (i == ESRCH) { | |
696 | remove_bg_job(pi); | |
697 | } else { | |
698 | perror_msg("kill (SIGCONT)"); | |
699 | } | |
700 | } | |
701 | ||
702 | pi->stopped_progs = 0; | |
703 | return EXIT_SUCCESS; | |
704 | } | |
705 | ||
706 | /* built-in 'help' handler */ | |
707 | static int builtin_help(struct child_prog *dummy) | |
708 | { | |
709 | struct built_in_command *x; | |
710 | ||
711 | printf("\nBuilt-in commands:\n"); | |
712 | printf("-------------------\n"); | |
713 | for (x = bltins; x->cmd; x++) { | |
714 | if (x->descr==NULL) | |
715 | continue; | |
716 | printf("%s\t%s\n", x->cmd, x->descr); | |
717 | } | |
718 | printf("\n\n"); | |
719 | return EXIT_SUCCESS; | |
720 | } | |
721 | ||
722 | /* built-in 'jobs' handler */ | |
723 | static int builtin_jobs(struct child_prog *child) | |
724 | { | |
725 | struct pipe *job; | |
726 | char *status_string; | |
727 | ||
728 | for (job = job_list; job; job = job->next) { | |
729 | if (job->running_progs == job->stopped_progs) | |
730 | status_string = "Stopped"; | |
731 | else | |
732 | status_string = "Running"; | |
733 | ||
734 | printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text); | |
735 | } | |
736 | return EXIT_SUCCESS; | |
737 | } | |
738 | ||
739 | ||
740 | /* built-in 'pwd' handler */ | |
741 | static int builtin_pwd(struct child_prog *dummy) | |
742 | { | |
743 | puts(set_cwd()); | |
744 | return EXIT_SUCCESS; | |
745 | } | |
746 | ||
747 | /* built-in 'read VAR' handler */ | |
748 | static int builtin_read(struct child_prog *child) | |
749 | { | |
750 | int res; | |
751 | ||
752 | if (child->argv[1]) { | |
753 | char string[BUFSIZ]; | |
754 | char *var = 0; | |
755 | ||
756 | string[0] = 0; /* In case stdin has only EOF */ | |
757 | /* read string */ | |
758 | fgets(string, sizeof(string), stdin); | |
759 | chomp(string); | |
760 | var = malloc(strlen(child->argv[1])+strlen(string)+2); | |
761 | if(var) { | |
762 | sprintf(var, "%s=%s", child->argv[1], string); | |
763 | res = set_local_var(var, 0); | |
764 | } else | |
765 | res = -1; | |
766 | if (res) | |
767 | fprintf(stderr, "read: %m\n"); | |
768 | free(var); /* So not move up to avoid breaking errno */ | |
769 | return res; | |
770 | } else { | |
771 | do res=getchar(); while(res!='\n' && res!=EOF); | |
772 | return 0; | |
773 | } | |
774 | } | |
775 | ||
776 | /* built-in 'set VAR=value' handler */ | |
777 | static int builtin_set(struct child_prog *child) | |
778 | { | |
779 | char *temp = child->argv[1]; | |
780 | struct variables *e; | |
781 | ||
782 | if (temp == NULL) | |
783 | for(e = top_vars; e; e=e->next) | |
784 | printf("%s=%s\n", e->name, e->value); | |
785 | else | |
786 | set_local_var(temp, 0); | |
787 | ||
788 | return EXIT_SUCCESS; | |
789 | } | |
790 | ||
791 | ||
792 | /* Built-in 'shift' handler */ | |
793 | static int builtin_shift(struct child_prog *child) | |
794 | { | |
795 | int n=1; | |
796 | if (child->argv[1]) { | |
797 | n=atoi(child->argv[1]); | |
798 | } | |
799 | if (n>=0 && n<global_argc) { | |
800 | /* XXX This probably breaks $0 */ | |
801 | global_argc -= n; | |
802 | global_argv += n; | |
803 | return EXIT_SUCCESS; | |
804 | } else { | |
805 | return EXIT_FAILURE; | |
806 | } | |
807 | } | |
808 | ||
809 | /* Built-in '.' handler (read-in and execute commands from file) */ | |
810 | static int builtin_source(struct child_prog *child) | |
811 | { | |
812 | FILE *input; | |
813 | int status; | |
814 | ||
815 | if (child->argv[1] == NULL) | |
816 | return EXIT_FAILURE; | |
817 | ||
818 | /* XXX search through $PATH is missing */ | |
819 | input = fopen(child->argv[1], "r"); | |
820 | if (!input) { | |
821 | error_msg("Couldn't open file '%s'", child->argv[1]); | |
822 | return EXIT_FAILURE; | |
823 | } | |
824 | ||
825 | /* Now run the file */ | |
826 | /* XXX argv and argc are broken; need to save old global_argv | |
827 | * (pointer only is OK!) on this stack frame, | |
828 | * set global_argv=child->argv+1, recurse, and restore. */ | |
829 | mark_open(fileno(input)); | |
830 | status = parse_file_outer(input); | |
831 | mark_closed(fileno(input)); | |
832 | fclose(input); | |
833 | return (status); | |
834 | } | |
835 | ||
836 | static int builtin_umask(struct child_prog *child) | |
837 | { | |
838 | mode_t new_umask; | |
839 | const char *arg = child->argv[1]; | |
840 | char *end; | |
841 | if (arg) { | |
842 | new_umask=strtoul(arg, &end, 8); | |
843 | if (*end!='\0' || end == arg) { | |
844 | return EXIT_FAILURE; | |
845 | } | |
846 | } else { | |
847 | printf("%.3o\n", (unsigned int) (new_umask=umask(0))); | |
848 | } | |
849 | umask(new_umask); | |
850 | return EXIT_SUCCESS; | |
851 | } | |
852 | ||
853 | /* built-in 'unset VAR' handler */ | |
854 | static int builtin_unset(struct child_prog *child) | |
855 | { | |
856 | /* bash returned already true */ | |
857 | unset_local_var(child->argv[1]); | |
858 | return EXIT_SUCCESS; | |
859 | } | |
860 | ||
861 | static int builtin_not_written(struct child_prog *child) | |
862 | { | |
863 | printf("builtin_%s not written\n",child->argv[0]); | |
864 | return EXIT_FAILURE; | |
865 | } | |
866 | #endif | |
867 | ||
868 | static int b_check_space(o_string *o, int len) | |
869 | { | |
870 | /* It would be easy to drop a more restrictive policy | |
871 | * in here, such as setting a maximum string length */ | |
872 | if (o->length + len > o->maxlen) { | |
873 | char *old_data = o->data; | |
874 | /* assert (data == NULL || o->maxlen != 0); */ | |
875 | o->maxlen += max(2*len, B_CHUNK); | |
876 | o->data = realloc(o->data, 1 + o->maxlen); | |
877 | if (o->data == NULL) { | |
878 | free(old_data); | |
879 | } | |
880 | } | |
881 | return o->data == NULL; | |
882 | } | |
883 | ||
884 | static int b_addchr(o_string *o, int ch) | |
885 | { | |
886 | debug_printf("b_addchr: %c %d %p\n", ch, o->length, o); | |
887 | if (b_check_space(o, 1)) return B_NOSPAC; | |
888 | o->data[o->length] = ch; | |
889 | o->length++; | |
890 | o->data[o->length] = '\0'; | |
891 | return 0; | |
892 | } | |
893 | ||
894 | static void b_reset(o_string *o) | |
895 | { | |
896 | o->length = 0; | |
897 | o->nonnull = 0; | |
898 | if (o->data != NULL) *o->data = '\0'; | |
899 | } | |
900 | ||
901 | static void b_free(o_string *o) | |
902 | { | |
903 | b_reset(o); | |
d0fb80c3 | 904 | free(o->data); |
fe8c2806 WD |
905 | o->data = NULL; |
906 | o->maxlen = 0; | |
907 | } | |
908 | ||
909 | /* My analysis of quoting semantics tells me that state information | |
910 | * is associated with a destination, not a source. | |
911 | */ | |
912 | static int b_addqchr(o_string *o, int ch, int quote) | |
913 | { | |
914 | if (quote && strchr("*?[\\",ch)) { | |
915 | int rc; | |
916 | rc = b_addchr(o, '\\'); | |
917 | if (rc) return rc; | |
918 | } | |
919 | return b_addchr(o, ch); | |
920 | } | |
921 | ||
c26e454d | 922 | #ifndef __U_BOOT__ |
fe8c2806 WD |
923 | static int b_adduint(o_string *o, unsigned int i) |
924 | { | |
925 | int r; | |
926 | char *p = simple_itoa(i); | |
927 | /* no escape checking necessary */ | |
928 | do r=b_addchr(o, *p++); while (r==0 && *p); | |
929 | return r; | |
930 | } | |
c26e454d | 931 | #endif |
fe8c2806 WD |
932 | |
933 | static int static_get(struct in_str *i) | |
934 | { | |
d0ff51ba | 935 | int ch = *i->p++; |
fe8c2806 WD |
936 | if (ch=='\0') return EOF; |
937 | return ch; | |
938 | } | |
939 | ||
940 | static int static_peek(struct in_str *i) | |
941 | { | |
942 | return *i->p; | |
943 | } | |
944 | ||
945 | #ifndef __U_BOOT__ | |
946 | static inline void cmdedit_set_initial_prompt(void) | |
947 | { | |
d0fb80c3 | 948 | #ifndef CONFIG_FEATURE_SH_FANCY_PROMPT |
fe8c2806 WD |
949 | PS1 = NULL; |
950 | #else | |
951 | PS1 = getenv("PS1"); | |
952 | if(PS1==0) | |
953 | PS1 = "\\w \\$ "; | |
954 | #endif | |
955 | } | |
956 | ||
957 | static inline void setup_prompt_string(int promptmode, char **prompt_str) | |
958 | { | |
959 | debug_printf("setup_prompt_string %d ",promptmode); | |
d0fb80c3 | 960 | #ifndef CONFIG_FEATURE_SH_FANCY_PROMPT |
fe8c2806 WD |
961 | /* Set up the prompt */ |
962 | if (promptmode == 1) { | |
d0fb80c3 | 963 | free(PS1); |
fe8c2806 WD |
964 | PS1=xmalloc(strlen(cwd)+4); |
965 | sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ? "$ ":"# "); | |
966 | *prompt_str = PS1; | |
967 | } else { | |
968 | *prompt_str = PS2; | |
969 | } | |
970 | #else | |
971 | *prompt_str = (promptmode==1)? PS1 : PS2; | |
972 | #endif | |
973 | debug_printf("result %s\n",*prompt_str); | |
974 | } | |
975 | #endif | |
976 | ||
977 | static void get_user_input(struct in_str *i) | |
978 | { | |
979 | #ifndef __U_BOOT__ | |
980 | char *prompt_str; | |
981 | static char the_command[BUFSIZ]; | |
982 | ||
983 | setup_prompt_string(i->promptmode, &prompt_str); | |
d0fb80c3 | 984 | #ifdef CONFIG_FEATURE_COMMAND_EDITING |
fe8c2806 WD |
985 | /* |
986 | ** enable command line editing only while a command line | |
987 | ** is actually being read; otherwise, we'll end up bequeathing | |
988 | ** atexit() handlers and other unwanted stuff to our | |
989 | ** child processes (rob@sysgo.de) | |
990 | */ | |
991 | cmdedit_read_input(prompt_str, the_command); | |
992 | #else | |
993 | fputs(prompt_str, stdout); | |
994 | fflush(stdout); | |
995 | the_command[0]=fgetc(i->file); | |
996 | the_command[1]='\0'; | |
997 | #endif | |
998 | fflush(stdout); | |
999 | i->p = the_command; | |
1000 | #else | |
fe8c2806 | 1001 | int n; |
5c50a92b | 1002 | static char the_command[CONFIG_SYS_CBSIZE + 1]; |
fe8c2806 | 1003 | |
b26440f1 | 1004 | bootretry_reset_cmd_timeout(); |
fe8c2806 WD |
1005 | i->__promptme = 1; |
1006 | if (i->promptmode == 1) { | |
e1bf824d | 1007 | n = cli_readline(CONFIG_SYS_PROMPT); |
fe8c2806 | 1008 | } else { |
e1bf824d | 1009 | n = cli_readline(CONFIG_SYS_PROMPT_HUSH_PS2); |
fe8c2806 | 1010 | } |
396387ab WD |
1011 | #ifdef CONFIG_BOOT_RETRY_TIME |
1012 | if (n == -2) { | |
1013 | puts("\nTimeout waiting for command\n"); | |
1014 | # ifdef CONFIG_RESET_TO_RETRY | |
1015 | do_reset(NULL, 0, 0, NULL); | |
1016 | # else | |
1017 | # error "This currently only works with CONFIG_RESET_TO_RETRY enabled" | |
1018 | # endif | |
1019 | } | |
1020 | #endif | |
fe8c2806 WD |
1021 | if (n == -1 ) { |
1022 | flag_repeat = 0; | |
1023 | i->__promptme = 0; | |
1024 | } | |
1025 | n = strlen(console_buffer); | |
1026 | console_buffer[n] = '\n'; | |
1027 | console_buffer[n+1]= '\0'; | |
1028 | if (had_ctrlc()) flag_repeat = 0; | |
1029 | clear_ctrlc(); | |
1030 | do_repeat = 0; | |
1031 | if (i->promptmode == 1) { | |
1032 | if (console_buffer[0] == '\n'&& flag_repeat == 0) { | |
1033 | strcpy(the_command,console_buffer); | |
1034 | } | |
1035 | else { | |
1036 | if (console_buffer[0] != '\n') { | |
1037 | strcpy(the_command,console_buffer); | |
1038 | flag_repeat = 1; | |
1039 | } | |
1040 | else { | |
1041 | do_repeat = 1; | |
1042 | } | |
1043 | } | |
1044 | i->p = the_command; | |
1045 | } | |
1046 | else { | |
8bde7f77 WD |
1047 | if (console_buffer[0] != '\n') { |
1048 | if (strlen(the_command) + strlen(console_buffer) | |
6d0f6bcf | 1049 | < CONFIG_SYS_CBSIZE) { |
8bde7f77 WD |
1050 | n = strlen(the_command); |
1051 | the_command[n-1] = ' '; | |
1052 | strcpy(&the_command[n],console_buffer); | |
fe8c2806 WD |
1053 | } |
1054 | else { | |
1055 | the_command[0] = '\n'; | |
1056 | the_command[1] = '\0'; | |
1057 | flag_repeat = 0; | |
1058 | } | |
1059 | } | |
1060 | if (i->__promptme == 0) { | |
1061 | the_command[0] = '\n'; | |
1062 | the_command[1] = '\0'; | |
1063 | } | |
1064 | i->p = console_buffer; | |
1065 | } | |
1066 | #endif | |
1067 | } | |
1068 | ||
1069 | /* This is the magic location that prints prompts | |
1070 | * and gets data back from the user */ | |
1071 | static int file_get(struct in_str *i) | |
1072 | { | |
1073 | int ch; | |
1074 | ||
1075 | ch = 0; | |
1076 | /* If there is data waiting, eat it up */ | |
1077 | if (i->p && *i->p) { | |
d0ff51ba | 1078 | ch = *i->p++; |
fe8c2806 WD |
1079 | } else { |
1080 | /* need to double check i->file because we might be doing something | |
1081 | * more complicated by now, like sourcing or substituting. */ | |
1082 | #ifndef __U_BOOT__ | |
1083 | if (i->__promptme && interactive && i->file == stdin) { | |
1084 | while(! i->p || (interactive && strlen(i->p)==0) ) { | |
1085 | #else | |
1086 | while(! i->p || strlen(i->p)==0 ) { | |
1087 | #endif | |
1088 | get_user_input(i); | |
1089 | } | |
1090 | i->promptmode=2; | |
1091 | #ifndef __U_BOOT__ | |
1092 | i->__promptme = 0; | |
1093 | #endif | |
1094 | if (i->p && *i->p) { | |
d0ff51ba | 1095 | ch = *i->p++; |
fe8c2806 WD |
1096 | } |
1097 | #ifndef __U_BOOT__ | |
1098 | } else { | |
1099 | ch = fgetc(i->file); | |
1100 | } | |
1101 | ||
1102 | #endif | |
1103 | debug_printf("b_getch: got a %d\n", ch); | |
1104 | } | |
1105 | #ifndef __U_BOOT__ | |
1106 | if (ch == '\n') i->__promptme=1; | |
1107 | #endif | |
1108 | return ch; | |
1109 | } | |
1110 | ||
1111 | /* All the callers guarantee this routine will never be | |
1112 | * used right after a newline, so prompting is not needed. | |
1113 | */ | |
1114 | static int file_peek(struct in_str *i) | |
1115 | { | |
1116 | #ifndef __U_BOOT__ | |
1117 | if (i->p && *i->p) { | |
1118 | #endif | |
1119 | return *i->p; | |
1120 | #ifndef __U_BOOT__ | |
1121 | } else { | |
1122 | i->peek_buf[0] = fgetc(i->file); | |
1123 | i->peek_buf[1] = '\0'; | |
1124 | i->p = i->peek_buf; | |
1125 | debug_printf("b_peek: got a %d\n", *i->p); | |
1126 | return *i->p; | |
1127 | } | |
1128 | #endif | |
1129 | } | |
1130 | ||
1131 | #ifndef __U_BOOT__ | |
1132 | static void setup_file_in_str(struct in_str *i, FILE *f) | |
1133 | #else | |
1134 | static void setup_file_in_str(struct in_str *i) | |
1135 | #endif | |
1136 | { | |
1137 | i->peek = file_peek; | |
1138 | i->get = file_get; | |
1139 | i->__promptme=1; | |
1140 | i->promptmode=1; | |
1141 | #ifndef __U_BOOT__ | |
1142 | i->file = f; | |
1143 | #endif | |
1144 | i->p = NULL; | |
1145 | } | |
1146 | ||
1147 | static void setup_string_in_str(struct in_str *i, const char *s) | |
1148 | { | |
1149 | i->peek = static_peek; | |
1150 | i->get = static_get; | |
1151 | i->__promptme=1; | |
1152 | i->promptmode=1; | |
1153 | i->p = s; | |
1154 | } | |
1155 | ||
1156 | #ifndef __U_BOOT__ | |
1157 | static void mark_open(int fd) | |
1158 | { | |
1159 | struct close_me *new = xmalloc(sizeof(struct close_me)); | |
1160 | new->fd = fd; | |
1161 | new->next = close_me_head; | |
1162 | close_me_head = new; | |
1163 | } | |
1164 | ||
1165 | static void mark_closed(int fd) | |
1166 | { | |
1167 | struct close_me *tmp; | |
1168 | if (close_me_head == NULL || close_me_head->fd != fd) | |
1169 | error_msg_and_die("corrupt close_me"); | |
1170 | tmp = close_me_head; | |
1171 | close_me_head = close_me_head->next; | |
1172 | free(tmp); | |
1173 | } | |
1174 | ||
d0fb80c3 | 1175 | static void close_all(void) |
fe8c2806 WD |
1176 | { |
1177 | struct close_me *c; | |
1178 | for (c=close_me_head; c; c=c->next) { | |
1179 | close(c->fd); | |
1180 | } | |
1181 | close_me_head = NULL; | |
1182 | } | |
1183 | ||
1184 | /* squirrel != NULL means we squirrel away copies of stdin, stdout, | |
1185 | * and stderr if they are redirected. */ | |
1186 | static int setup_redirects(struct child_prog *prog, int squirrel[]) | |
1187 | { | |
1188 | int openfd, mode; | |
1189 | struct redir_struct *redir; | |
1190 | ||
1191 | for (redir=prog->redirects; redir; redir=redir->next) { | |
1192 | if (redir->dup == -1 && redir->word.gl_pathv == NULL) { | |
1193 | /* something went wrong in the parse. Pretend it didn't happen */ | |
1194 | continue; | |
1195 | } | |
1196 | if (redir->dup == -1) { | |
1197 | mode=redir_table[redir->type].mode; | |
1198 | openfd = open(redir->word.gl_pathv[0], mode, 0666); | |
1199 | if (openfd < 0) { | |
1200 | /* this could get lost if stderr has been redirected, but | |
1201 | bash and ash both lose it as well (though zsh doesn't!) */ | |
1202 | perror_msg("error opening %s", redir->word.gl_pathv[0]); | |
1203 | return 1; | |
1204 | } | |
1205 | } else { | |
1206 | openfd = redir->dup; | |
1207 | } | |
1208 | ||
1209 | if (openfd != redir->fd) { | |
1210 | if (squirrel && redir->fd < 3) { | |
1211 | squirrel[redir->fd] = dup(redir->fd); | |
1212 | } | |
1213 | if (openfd == -3) { | |
1214 | close(openfd); | |
1215 | } else { | |
1216 | dup2(openfd, redir->fd); | |
1217 | if (redir->dup == -1) | |
1218 | close (openfd); | |
1219 | } | |
1220 | } | |
1221 | } | |
1222 | return 0; | |
1223 | } | |
1224 | ||
1225 | static void restore_redirects(int squirrel[]) | |
1226 | { | |
1227 | int i, fd; | |
1228 | for (i=0; i<3; i++) { | |
1229 | fd = squirrel[i]; | |
1230 | if (fd != -1) { | |
1231 | /* No error checking. I sure wouldn't know what | |
1232 | * to do with an error if I found one! */ | |
1233 | dup2(fd, i); | |
1234 | close(fd); | |
1235 | } | |
1236 | } | |
1237 | } | |
1238 | ||
1239 | /* never returns */ | |
1240 | /* XXX no exit() here. If you don't exec, use _exit instead. | |
1241 | * The at_exit handlers apparently confuse the calling process, | |
1242 | * in particular stdin handling. Not sure why? */ | |
1243 | static void pseudo_exec(struct child_prog *child) | |
1244 | { | |
1245 | int i, rcode; | |
1246 | char *p; | |
1247 | struct built_in_command *x; | |
1248 | if (child->argv) { | |
1249 | for (i=0; is_assignment(child->argv[i]); i++) { | |
1250 | debug_printf("pid %d environment modification: %s\n",getpid(),child->argv[i]); | |
1251 | p = insert_var_value(child->argv[i]); | |
1252 | putenv(strdup(p)); | |
1253 | if (p != child->argv[i]) free(p); | |
1254 | } | |
1255 | child->argv+=i; /* XXX this hack isn't so horrible, since we are about | |
8bde7f77 WD |
1256 | to exit, and therefore don't need to keep data |
1257 | structures consistent for free() use. */ | |
fe8c2806 WD |
1258 | /* If a variable is assigned in a forest, and nobody listens, |
1259 | * was it ever really set? | |
1260 | */ | |
1261 | if (child->argv[0] == NULL) { | |
1262 | _exit(EXIT_SUCCESS); | |
1263 | } | |
1264 | ||
1265 | /* | |
1266 | * Check if the command matches any of the builtins. | |
1267 | * Depending on context, this might be redundant. But it's | |
1268 | * easier to waste a few CPU cycles than it is to figure out | |
1269 | * if this is one of those cases. | |
1270 | */ | |
1271 | for (x = bltins; x->cmd; x++) { | |
1272 | if (strcmp(child->argv[0], x->cmd) == 0 ) { | |
1273 | debug_printf("builtin exec %s\n", child->argv[0]); | |
1274 | rcode = x->function(child); | |
1275 | fflush(stdout); | |
1276 | _exit(rcode); | |
1277 | } | |
1278 | } | |
1279 | ||
1280 | /* Check if the command matches any busybox internal commands | |
1281 | * ("applets") here. | |
1282 | * FIXME: This feature is not 100% safe, since | |
1283 | * BusyBox is not fully reentrant, so we have no guarantee the things | |
1284 | * from the .bss are still zeroed, or that things from .data are still | |
1285 | * at their defaults. We could exec ourself from /proc/self/exe, but I | |
1286 | * really dislike relying on /proc for things. We could exec ourself | |
1287 | * from global_argv[0], but if we are in a chroot, we may not be able | |
1288 | * to find ourself... */ | |
d0fb80c3 | 1289 | #ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL |
fe8c2806 WD |
1290 | { |
1291 | int argc_l; | |
1292 | char** argv_l=child->argv; | |
1293 | char *name = child->argv[0]; | |
1294 | ||
d0fb80c3 | 1295 | #ifdef CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN |
fe8c2806 WD |
1296 | /* Following discussions from November 2000 on the busybox mailing |
1297 | * list, the default configuration, (without | |
1298 | * get_last_path_component()) lets the user force use of an | |
1299 | * external command by specifying the full (with slashes) filename. | |
d0fb80c3 | 1300 | * If you enable CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN then applets |
fe8c2806 WD |
1301 | * _aways_ override external commands, so if you want to run |
1302 | * /bin/cat, it will use BusyBox cat even if /bin/cat exists on the | |
1303 | * filesystem and is _not_ busybox. Some systems may want this, | |
1304 | * most do not. */ | |
1305 | name = get_last_path_component(name); | |
1306 | #endif | |
1307 | /* Count argc for use in a second... */ | |
1308 | for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++); | |
1309 | optind = 1; | |
1310 | debug_printf("running applet %s\n", name); | |
1311 | run_applet_by_name(name, argc_l, child->argv); | |
1312 | } | |
1313 | #endif | |
1314 | debug_printf("exec of %s\n",child->argv[0]); | |
1315 | execvp(child->argv[0],child->argv); | |
1316 | perror_msg("couldn't exec: %s",child->argv[0]); | |
1317 | _exit(1); | |
1318 | } else if (child->group) { | |
1319 | debug_printf("runtime nesting to group\n"); | |
1320 | interactive=0; /* crucial!!!! */ | |
1321 | rcode = run_list_real(child->group); | |
1322 | /* OK to leak memory by not calling free_pipe_list, | |
1323 | * since this process is about to exit */ | |
1324 | _exit(rcode); | |
1325 | } else { | |
1326 | /* Can happen. See what bash does with ">foo" by itself. */ | |
1327 | debug_printf("trying to pseudo_exec null command\n"); | |
1328 | _exit(EXIT_SUCCESS); | |
1329 | } | |
1330 | } | |
1331 | ||
1332 | static void insert_bg_job(struct pipe *pi) | |
1333 | { | |
1334 | struct pipe *thejob; | |
1335 | ||
1336 | /* Linear search for the ID of the job to use */ | |
1337 | pi->jobid = 1; | |
1338 | for (thejob = job_list; thejob; thejob = thejob->next) | |
1339 | if (thejob->jobid >= pi->jobid) | |
1340 | pi->jobid = thejob->jobid + 1; | |
1341 | ||
1342 | /* add thejob to the list of running jobs */ | |
1343 | if (!job_list) { | |
1344 | thejob = job_list = xmalloc(sizeof(*thejob)); | |
1345 | } else { | |
1346 | for (thejob = job_list; thejob->next; thejob = thejob->next) /* nothing */; | |
1347 | thejob->next = xmalloc(sizeof(*thejob)); | |
1348 | thejob = thejob->next; | |
1349 | } | |
1350 | ||
1351 | /* physically copy the struct job */ | |
1352 | memcpy(thejob, pi, sizeof(struct pipe)); | |
1353 | thejob->next = NULL; | |
1354 | thejob->running_progs = thejob->num_progs; | |
1355 | thejob->stopped_progs = 0; | |
1356 | thejob->text = xmalloc(BUFSIZ); /* cmdedit buffer size */ | |
1357 | ||
1358 | /*if (pi->progs[0] && pi->progs[0].argv && pi->progs[0].argv[0]) */ | |
1359 | { | |
1360 | char *bar=thejob->text; | |
1361 | char **foo=pi->progs[0].argv; | |
1362 | while(foo && *foo) { | |
1363 | bar += sprintf(bar, "%s ", *foo++); | |
1364 | } | |
1365 | } | |
1366 | ||
1367 | /* we don't wait for background thejobs to return -- append it | |
1368 | to the list of backgrounded thejobs and leave it alone */ | |
1369 | printf("[%d] %d\n", thejob->jobid, thejob->progs[0].pid); | |
1370 | last_bg_pid = thejob->progs[0].pid; | |
1371 | last_jobid = thejob->jobid; | |
1372 | } | |
1373 | ||
1374 | /* remove a backgrounded job */ | |
1375 | static void remove_bg_job(struct pipe *pi) | |
1376 | { | |
1377 | struct pipe *prev_pipe; | |
1378 | ||
1379 | if (pi == job_list) { | |
1380 | job_list = pi->next; | |
1381 | } else { | |
1382 | prev_pipe = job_list; | |
1383 | while (prev_pipe->next != pi) | |
1384 | prev_pipe = prev_pipe->next; | |
1385 | prev_pipe->next = pi->next; | |
1386 | } | |
1387 | if (job_list) | |
1388 | last_jobid = job_list->jobid; | |
1389 | else | |
1390 | last_jobid = 0; | |
1391 | ||
1392 | pi->stopped_progs = 0; | |
1393 | free_pipe(pi, 0); | |
1394 | free(pi); | |
1395 | } | |
1396 | ||
1397 | /* Checks to see if any processes have exited -- if they | |
1398 | have, figure out why and see if a job has completed */ | |
1399 | static int checkjobs(struct pipe* fg_pipe) | |
1400 | { | |
1401 | int attributes; | |
1402 | int status; | |
1403 | int prognum = 0; | |
1404 | struct pipe *pi; | |
1405 | pid_t childpid; | |
1406 | ||
1407 | attributes = WUNTRACED; | |
1408 | if (fg_pipe==NULL) { | |
1409 | attributes |= WNOHANG; | |
1410 | } | |
1411 | ||
1412 | while ((childpid = waitpid(-1, &status, attributes)) > 0) { | |
1413 | if (fg_pipe) { | |
1414 | int i, rcode = 0; | |
1415 | for (i=0; i < fg_pipe->num_progs; i++) { | |
1416 | if (fg_pipe->progs[i].pid == childpid) { | |
1417 | if (i==fg_pipe->num_progs-1) | |
1418 | rcode=WEXITSTATUS(status); | |
1419 | (fg_pipe->num_progs)--; | |
1420 | return(rcode); | |
1421 | } | |
1422 | } | |
1423 | } | |
1424 | ||
1425 | for (pi = job_list; pi; pi = pi->next) { | |
1426 | prognum = 0; | |
1427 | while (prognum < pi->num_progs && pi->progs[prognum].pid != childpid) { | |
1428 | prognum++; | |
1429 | } | |
1430 | if (prognum < pi->num_progs) | |
1431 | break; | |
1432 | } | |
1433 | ||
1434 | if(pi==NULL) { | |
1435 | debug_printf("checkjobs: pid %d was not in our list!\n", childpid); | |
1436 | continue; | |
1437 | } | |
1438 | ||
1439 | if (WIFEXITED(status) || WIFSIGNALED(status)) { | |
1440 | /* child exited */ | |
1441 | pi->running_progs--; | |
1442 | pi->progs[prognum].pid = 0; | |
1443 | ||
1444 | if (!pi->running_progs) { | |
1445 | printf(JOB_STATUS_FORMAT, pi->jobid, "Done", pi->text); | |
1446 | remove_bg_job(pi); | |
1447 | } | |
1448 | } else { | |
1449 | /* child stopped */ | |
1450 | pi->stopped_progs++; | |
1451 | pi->progs[prognum].is_stopped = 1; | |
1452 | ||
1453 | #if 0 | |
1454 | /* Printing this stuff is a pain, since it tends to | |
1455 | * overwrite the prompt an inconveinient moments. So | |
1456 | * don't do that. */ | |
1457 | if (pi->stopped_progs == pi->num_progs) { | |
1458 | printf("\n"JOB_STATUS_FORMAT, pi->jobid, "Stopped", pi->text); | |
1459 | } | |
1460 | #endif | |
1461 | } | |
1462 | } | |
1463 | ||
1464 | if (childpid == -1 && errno != ECHILD) | |
1465 | perror_msg("waitpid"); | |
1466 | ||
1467 | /* move the shell to the foreground */ | |
1468 | /*if (interactive && tcsetpgrp(shell_terminal, getpgid(0))) */ | |
1469 | /* perror_msg("tcsetpgrp-2"); */ | |
1470 | return -1; | |
1471 | } | |
1472 | ||
1473 | /* Figure out our controlling tty, checking in order stderr, | |
1474 | * stdin, and stdout. If check_pgrp is set, also check that | |
1475 | * we belong to the foreground process group associated with | |
1476 | * that tty. The value of shell_terminal is needed in order to call | |
1477 | * tcsetpgrp(shell_terminal, ...); */ | |
1478 | void controlling_tty(int check_pgrp) | |
1479 | { | |
1480 | pid_t curpgrp; | |
1481 | ||
1482 | if ((curpgrp = tcgetpgrp(shell_terminal = 2)) < 0 | |
1483 | && (curpgrp = tcgetpgrp(shell_terminal = 0)) < 0 | |
1484 | && (curpgrp = tcgetpgrp(shell_terminal = 1)) < 0) | |
1485 | goto shell_terminal_error; | |
1486 | ||
1487 | if (check_pgrp && curpgrp != getpgid(0)) | |
1488 | goto shell_terminal_error; | |
1489 | ||
1490 | return; | |
1491 | ||
1492 | shell_terminal_error: | |
1493 | shell_terminal = -1; | |
1494 | return; | |
1495 | } | |
1496 | #endif | |
1497 | ||
1498 | /* run_pipe_real() starts all the jobs, but doesn't wait for anything | |
1499 | * to finish. See checkjobs(). | |
1500 | * | |
1501 | * return code is normally -1, when the caller has to wait for children | |
1502 | * to finish to determine the exit status of the pipe. If the pipe | |
1503 | * is a simple builtin command, however, the action is done by the | |
1504 | * time run_pipe_real returns, and the exit code is provided as the | |
1505 | * return value. | |
1506 | * | |
1507 | * The input of the pipe is always stdin, the output is always | |
1508 | * stdout. The outpipe[] mechanism in BusyBox-0.48 lash is bogus, | |
1509 | * because it tries to avoid running the command substitution in | |
1510 | * subshell, when that is in fact necessary. The subshell process | |
1511 | * now has its stdout directed to the input of the appropriate pipe, | |
1512 | * so this routine is noticeably simpler. | |
1513 | */ | |
1514 | static int run_pipe_real(struct pipe *pi) | |
1515 | { | |
1516 | int i; | |
1517 | #ifndef __U_BOOT__ | |
1518 | int nextin, nextout; | |
1519 | int pipefds[2]; /* pipefds[0] is for reading */ | |
1520 | struct child_prog *child; | |
1521 | struct built_in_command *x; | |
1522 | char *p; | |
d0fb80c3 WD |
1523 | # if __GNUC__ |
1524 | /* Avoid longjmp clobbering */ | |
1525 | (void) &i; | |
1526 | (void) &nextin; | |
1527 | (void) &nextout; | |
1528 | (void) &child; | |
1529 | # endif | |
fe8c2806 WD |
1530 | #else |
1531 | int nextin; | |
1532 | int flag = do_repeat ? CMD_FLAG_REPEAT : 0; | |
1533 | struct child_prog *child; | |
fe8c2806 | 1534 | char *p; |
d0fb80c3 WD |
1535 | # if __GNUC__ |
1536 | /* Avoid longjmp clobbering */ | |
1537 | (void) &i; | |
1538 | (void) &nextin; | |
1539 | (void) &child; | |
1540 | # endif | |
1541 | #endif /* __U_BOOT__ */ | |
fe8c2806 WD |
1542 | |
1543 | nextin = 0; | |
1544 | #ifndef __U_BOOT__ | |
1545 | pi->pgrp = -1; | |
1546 | #endif | |
1547 | ||
1548 | /* Check if this is a simple builtin (not part of a pipe). | |
1549 | * Builtins within pipes have to fork anyway, and are handled in | |
1550 | * pseudo_exec. "echo foo | read bar" doesn't work on bash, either. | |
1551 | */ | |
1552 | if (pi->num_progs == 1) child = & (pi->progs[0]); | |
1553 | #ifndef __U_BOOT__ | |
1554 | if (pi->num_progs == 1 && child->group && child->subshell == 0) { | |
1555 | int squirrel[] = {-1, -1, -1}; | |
1556 | int rcode; | |
1557 | debug_printf("non-subshell grouping\n"); | |
1558 | setup_redirects(child, squirrel); | |
1559 | /* XXX could we merge code with following builtin case, | |
1560 | * by creating a pseudo builtin that calls run_list_real? */ | |
1561 | rcode = run_list_real(child->group); | |
1562 | restore_redirects(squirrel); | |
1563 | #else | |
1564 | if (pi->num_progs == 1 && child->group) { | |
1565 | int rcode; | |
1566 | debug_printf("non-subshell grouping\n"); | |
1567 | rcode = run_list_real(child->group); | |
1568 | #endif | |
1569 | return rcode; | |
1570 | } else if (pi->num_progs == 1 && pi->progs[0].argv != NULL) { | |
1571 | for (i=0; is_assignment(child->argv[i]); i++) { /* nothing */ } | |
1572 | if (i!=0 && child->argv[i]==NULL) { | |
1573 | /* assignments, but no command: set the local environment */ | |
1574 | for (i=0; child->argv[i]!=NULL; i++) { | |
1575 | ||
1576 | /* Ok, this case is tricky. We have to decide if this is a | |
1577 | * local variable, or an already exported variable. If it is | |
1578 | * already exported, we have to export the new value. If it is | |
1579 | * not exported, we need only set this as a local variable. | |
1580 | * This junk is all to decide whether or not to export this | |
1581 | * variable. */ | |
1582 | int export_me=0; | |
1583 | char *name, *value; | |
1584 | name = xstrdup(child->argv[i]); | |
1585 | debug_printf("Local environment set: %s\n", name); | |
1586 | value = strchr(name, '='); | |
1587 | if (value) | |
1588 | *value=0; | |
1589 | #ifndef __U_BOOT__ | |
1590 | if ( get_local_var(name)) { | |
1591 | export_me=1; | |
1592 | } | |
1593 | #endif | |
1594 | free(name); | |
1595 | p = insert_var_value(child->argv[i]); | |
1596 | set_local_var(p, export_me); | |
1597 | if (p != child->argv[i]) free(p); | |
1598 | } | |
1599 | return EXIT_SUCCESS; /* don't worry about errors in set_local_var() yet */ | |
1600 | } | |
1601 | for (i = 0; is_assignment(child->argv[i]); i++) { | |
1602 | p = insert_var_value(child->argv[i]); | |
1603 | #ifndef __U_BOOT__ | |
1604 | putenv(strdup(p)); | |
1605 | #else | |
1606 | set_local_var(p, 0); | |
1607 | #endif | |
1608 | if (p != child->argv[i]) { | |
1609 | child->sp--; | |
1610 | free(p); | |
1611 | } | |
1612 | } | |
1613 | if (child->sp) { | |
1614 | char * str = NULL; | |
1615 | ||
fe9ca3d3 SW |
1616 | str = make_string(child->argv + i, |
1617 | child->argv_nonnull + i); | |
fe8c2806 WD |
1618 | parse_string_outer(str, FLAG_EXIT_FROM_LOOP | FLAG_REPARSING); |
1619 | free(str); | |
1620 | return last_return_code; | |
1621 | } | |
1622 | #ifndef __U_BOOT__ | |
1623 | for (x = bltins; x->cmd; x++) { | |
1624 | if (strcmp(child->argv[i], x->cmd) == 0 ) { | |
1625 | int squirrel[] = {-1, -1, -1}; | |
1626 | int rcode; | |
1627 | if (x->function == builtin_exec && child->argv[i+1]==NULL) { | |
1628 | debug_printf("magic exec\n"); | |
1629 | setup_redirects(child,NULL); | |
1630 | return EXIT_SUCCESS; | |
1631 | } | |
1632 | debug_printf("builtin inline %s\n", child->argv[0]); | |
1633 | /* XXX setup_redirects acts on file descriptors, not FILEs. | |
1634 | * This is perfect for work that comes after exec(). | |
1635 | * Is it really safe for inline use? Experimentally, | |
1636 | * things seem to work with glibc. */ | |
1637 | setup_redirects(child, squirrel); | |
7344f912 SG |
1638 | |
1639 | child->argv += i; /* XXX horrible hack */ | |
1640 | rcode = x->function(child); | |
1641 | /* XXX restore hack so free() can work right */ | |
1642 | child->argv -= i; | |
1643 | restore_redirects(squirrel); | |
1644 | } | |
1645 | return rcode; | |
1646 | } | |
fe8c2806 | 1647 | #else |
9d12d5d4 SG |
1648 | /* check ";", because ,example , argv consist from |
1649 | * "help;flinfo" must not execute | |
1650 | */ | |
1651 | if (strchr(child->argv[i], ';')) { | |
1652 | printf("Unknown command '%s' - try 'help' or use " | |
1653 | "'run' command\n", child->argv[i]); | |
1654 | return -1; | |
fe8c2806 | 1655 | } |
9d12d5d4 SG |
1656 | /* Process the command */ |
1657 | return cmd_process(flag, child->argc, child->argv, | |
34765e88 | 1658 | &flag_repeat, NULL); |
9d12d5d4 | 1659 | #endif |
fe8c2806 | 1660 | } |
9d12d5d4 | 1661 | #ifndef __U_BOOT__ |
fe8c2806 WD |
1662 | |
1663 | for (i = 0; i < pi->num_progs; i++) { | |
1664 | child = & (pi->progs[i]); | |
1665 | ||
1666 | /* pipes are inserted between pairs of commands */ | |
1667 | if ((i + 1) < pi->num_progs) { | |
1668 | if (pipe(pipefds)<0) perror_msg_and_die("pipe"); | |
1669 | nextout = pipefds[1]; | |
1670 | } else { | |
1671 | nextout=1; | |
1672 | pipefds[0] = -1; | |
1673 | } | |
1674 | ||
1675 | /* XXX test for failed fork()? */ | |
1676 | if (!(child->pid = fork())) { | |
1677 | /* Set the handling for job control signals back to the default. */ | |
1678 | signal(SIGINT, SIG_DFL); | |
1679 | signal(SIGQUIT, SIG_DFL); | |
1680 | signal(SIGTERM, SIG_DFL); | |
1681 | signal(SIGTSTP, SIG_DFL); | |
1682 | signal(SIGTTIN, SIG_DFL); | |
1683 | signal(SIGTTOU, SIG_DFL); | |
1684 | signal(SIGCHLD, SIG_DFL); | |
1685 | ||
1686 | close_all(); | |
1687 | ||
1688 | if (nextin != 0) { | |
1689 | dup2(nextin, 0); | |
1690 | close(nextin); | |
1691 | } | |
1692 | if (nextout != 1) { | |
1693 | dup2(nextout, 1); | |
1694 | close(nextout); | |
1695 | } | |
1696 | if (pipefds[0]!=-1) { | |
1697 | close(pipefds[0]); /* opposite end of our output pipe */ | |
1698 | } | |
1699 | ||
1700 | /* Like bash, explicit redirects override pipes, | |
1701 | * and the pipe fd is available for dup'ing. */ | |
1702 | setup_redirects(child,NULL); | |
1703 | ||
1704 | if (interactive && pi->followup!=PIPE_BG) { | |
1705 | /* If we (the child) win the race, put ourselves in the process | |
1706 | * group whose leader is the first process in this pipe. */ | |
1707 | if (pi->pgrp < 0) { | |
1708 | pi->pgrp = getpid(); | |
1709 | } | |
1710 | if (setpgid(0, pi->pgrp) == 0) { | |
1711 | tcsetpgrp(2, pi->pgrp); | |
1712 | } | |
1713 | } | |
1714 | ||
1715 | pseudo_exec(child); | |
1716 | } | |
1717 | ||
1718 | ||
1719 | /* put our child in the process group whose leader is the | |
1720 | first process in this pipe */ | |
1721 | if (pi->pgrp < 0) { | |
1722 | pi->pgrp = child->pid; | |
1723 | } | |
1724 | /* Don't check for errors. The child may be dead already, | |
1725 | * in which case setpgid returns error code EACCES. */ | |
1726 | setpgid(child->pid, pi->pgrp); | |
1727 | ||
1728 | if (nextin != 0) | |
1729 | close(nextin); | |
1730 | if (nextout != 1) | |
1731 | close(nextout); | |
1732 | ||
1733 | /* If there isn't another process, nextin is garbage | |
1734 | but it doesn't matter */ | |
1735 | nextin = pipefds[0]; | |
1736 | } | |
1737 | #endif | |
1738 | return -1; | |
1739 | } | |
1740 | ||
1741 | static int run_list_real(struct pipe *pi) | |
1742 | { | |
1743 | char *save_name = NULL; | |
1744 | char **list = NULL; | |
1745 | char **save_list = NULL; | |
1746 | struct pipe *rpipe; | |
1747 | int flag_rep = 0; | |
1748 | #ifndef __U_BOOT__ | |
1749 | int save_num_progs; | |
1750 | #endif | |
1751 | int rcode=0, flag_skip=1; | |
1752 | int flag_restore = 0; | |
1753 | int if_code=0, next_if_code=0; /* need double-buffer to handle elif */ | |
1754 | reserved_style rmode, skip_more_in_this_rmode=RES_XXXX; | |
1755 | /* check syntax for "for" */ | |
1756 | for (rpipe = pi; rpipe; rpipe = rpipe->next) { | |
1757 | if ((rpipe->r_mode == RES_IN || | |
1758 | rpipe->r_mode == RES_FOR) && | |
1759 | (rpipe->next == NULL)) { | |
1760 | syntax(); | |
1761 | #ifdef __U_BOOT__ | |
1762 | flag_repeat = 0; | |
1763 | #endif | |
1764 | return 1; | |
1765 | } | |
1766 | if ((rpipe->r_mode == RES_IN && | |
1767 | (rpipe->next->r_mode == RES_IN && | |
1768 | rpipe->next->progs->argv != NULL))|| | |
1769 | (rpipe->r_mode == RES_FOR && | |
1770 | rpipe->next->r_mode != RES_IN)) { | |
1771 | syntax(); | |
1772 | #ifdef __U_BOOT__ | |
1773 | flag_repeat = 0; | |
1774 | #endif | |
1775 | return 1; | |
1776 | } | |
1777 | } | |
1778 | for (; pi; pi = (flag_restore != 0) ? rpipe : pi->next) { | |
1779 | if (pi->r_mode == RES_WHILE || pi->r_mode == RES_UNTIL || | |
1780 | pi->r_mode == RES_FOR) { | |
1781 | #ifdef __U_BOOT__ | |
1782 | /* check Ctrl-C */ | |
1783 | ctrlc(); | |
1784 | if ((had_ctrlc())) { | |
1785 | return 1; | |
1786 | } | |
1787 | #endif | |
1788 | flag_restore = 0; | |
1789 | if (!rpipe) { | |
1790 | flag_rep = 0; | |
1791 | rpipe = pi; | |
1792 | } | |
1793 | } | |
1794 | rmode = pi->r_mode; | |
1795 | debug_printf("rmode=%d if_code=%d next_if_code=%d skip_more=%d\n", rmode, if_code, next_if_code, skip_more_in_this_rmode); | |
1796 | if (rmode == skip_more_in_this_rmode && flag_skip) { | |
1797 | if (pi->followup == PIPE_SEQ) flag_skip=0; | |
1798 | continue; | |
1799 | } | |
1800 | flag_skip = 1; | |
1801 | skip_more_in_this_rmode = RES_XXXX; | |
1802 | if (rmode == RES_THEN || rmode == RES_ELSE) if_code = next_if_code; | |
1803 | if (rmode == RES_THEN && if_code) continue; | |
1804 | if (rmode == RES_ELSE && !if_code) continue; | |
56b86bf0 | 1805 | if (rmode == RES_ELIF && !if_code) break; |
fe8c2806 WD |
1806 | if (rmode == RES_FOR && pi->num_progs) { |
1807 | if (!list) { | |
1808 | /* if no variable values after "in" we skip "for" */ | |
1809 | if (!pi->next->progs->argv) continue; | |
1810 | /* create list of variable values */ | |
1811 | list = make_list_in(pi->next->progs->argv, | |
1812 | pi->progs->argv[0]); | |
1813 | save_list = list; | |
1814 | save_name = pi->progs->argv[0]; | |
1815 | pi->progs->argv[0] = NULL; | |
1816 | flag_rep = 1; | |
1817 | } | |
1818 | if (!(*list)) { | |
1819 | free(pi->progs->argv[0]); | |
1820 | free(save_list); | |
1821 | list = NULL; | |
1822 | flag_rep = 0; | |
1823 | pi->progs->argv[0] = save_name; | |
1824 | #ifndef __U_BOOT__ | |
1825 | pi->progs->glob_result.gl_pathv[0] = | |
1826 | pi->progs->argv[0]; | |
1827 | #endif | |
1828 | continue; | |
1829 | } else { | |
1830 | /* insert new value from list for variable */ | |
1831 | if (pi->progs->argv[0]) | |
1832 | free(pi->progs->argv[0]); | |
1833 | pi->progs->argv[0] = *list++; | |
1834 | #ifndef __U_BOOT__ | |
1835 | pi->progs->glob_result.gl_pathv[0] = | |
1836 | pi->progs->argv[0]; | |
1837 | #endif | |
1838 | } | |
1839 | } | |
1840 | if (rmode == RES_IN) continue; | |
1841 | if (rmode == RES_DO) { | |
1842 | if (!flag_rep) continue; | |
1843 | } | |
930e4254 | 1844 | if (rmode == RES_DONE) { |
fe8c2806 WD |
1845 | if (flag_rep) { |
1846 | flag_restore = 1; | |
1847 | } else { | |
1848 | rpipe = NULL; | |
1849 | } | |
1850 | } | |
1851 | if (pi->num_progs == 0) continue; | |
1852 | #ifndef __U_BOOT__ | |
1853 | save_num_progs = pi->num_progs; /* save number of programs */ | |
1854 | #endif | |
1855 | rcode = run_pipe_real(pi); | |
1856 | debug_printf("run_pipe_real returned %d\n",rcode); | |
1857 | #ifndef __U_BOOT__ | |
1858 | if (rcode!=-1) { | |
1859 | /* We only ran a builtin: rcode was set by the return value | |
1860 | * of run_pipe_real(), and we don't need to wait for anything. */ | |
1861 | } else if (pi->followup==PIPE_BG) { | |
1862 | /* XXX check bash's behavior with nontrivial pipes */ | |
1863 | /* XXX compute jobid */ | |
1864 | /* XXX what does bash do with attempts to background builtins? */ | |
1865 | insert_bg_job(pi); | |
1866 | rcode = EXIT_SUCCESS; | |
1867 | } else { | |
1868 | if (interactive) { | |
1869 | /* move the new process group into the foreground */ | |
1870 | if (tcsetpgrp(shell_terminal, pi->pgrp) && errno != ENOTTY) | |
1871 | perror_msg("tcsetpgrp-3"); | |
1872 | rcode = checkjobs(pi); | |
1873 | /* move the shell to the foreground */ | |
1874 | if (tcsetpgrp(shell_terminal, getpgid(0)) && errno != ENOTTY) | |
1875 | perror_msg("tcsetpgrp-4"); | |
1876 | } else { | |
1877 | rcode = checkjobs(pi); | |
1878 | } | |
1879 | debug_printf("checkjobs returned %d\n",rcode); | |
1880 | } | |
1881 | last_return_code=rcode; | |
1882 | #else | |
c26e454d WD |
1883 | if (rcode < -1) { |
1884 | last_return_code = -rcode - 2; | |
1885 | return -2; /* exit */ | |
1886 | } | |
fe8c2806 WD |
1887 | last_return_code=(rcode == 0) ? 0 : 1; |
1888 | #endif | |
1889 | #ifndef __U_BOOT__ | |
1890 | pi->num_progs = save_num_progs; /* restore number of programs */ | |
1891 | #endif | |
1892 | if ( rmode == RES_IF || rmode == RES_ELIF ) | |
1893 | next_if_code=rcode; /* can be overwritten a number of times */ | |
1894 | if (rmode == RES_WHILE) | |
1895 | flag_rep = !last_return_code; | |
1896 | if (rmode == RES_UNTIL) | |
1897 | flag_rep = last_return_code; | |
1898 | if ( (rcode==EXIT_SUCCESS && pi->followup==PIPE_OR) || | |
1899 | (rcode!=EXIT_SUCCESS && pi->followup==PIPE_AND) ) | |
1900 | skip_more_in_this_rmode=rmode; | |
1901 | #ifndef __U_BOOT__ | |
1902 | checkjobs(NULL); | |
1903 | #endif | |
1904 | } | |
1905 | return rcode; | |
1906 | } | |
1907 | ||
1908 | /* broken, of course, but OK for testing */ | |
1909 | static char *indenter(int i) | |
1910 | { | |
1911 | static char blanks[]=" "; | |
1912 | return &blanks[sizeof(blanks)-i-1]; | |
1913 | } | |
1914 | ||
1915 | /* return code is the exit status of the pipe */ | |
1916 | static int free_pipe(struct pipe *pi, int indent) | |
1917 | { | |
1918 | char **p; | |
1919 | struct child_prog *child; | |
1920 | #ifndef __U_BOOT__ | |
1921 | struct redir_struct *r, *rnext; | |
1922 | #endif | |
1923 | int a, i, ret_code=0; | |
1924 | char *ind = indenter(indent); | |
1925 | ||
1926 | #ifndef __U_BOOT__ | |
1927 | if (pi->stopped_progs > 0) | |
1928 | return ret_code; | |
1929 | final_printf("%s run pipe: (pid %d)\n",ind,getpid()); | |
1930 | #endif | |
1931 | for (i=0; i<pi->num_progs; i++) { | |
1932 | child = &pi->progs[i]; | |
1933 | final_printf("%s command %d:\n",ind,i); | |
1934 | if (child->argv) { | |
1935 | for (a=0,p=child->argv; *p; a++,p++) { | |
1936 | final_printf("%s argv[%d] = %s\n",ind,a,*p); | |
1937 | } | |
1938 | #ifndef __U_BOOT__ | |
1939 | globfree(&child->glob_result); | |
1940 | #else | |
197324d7 | 1941 | for (a = 0; a < child->argc; a++) { |
8bde7f77 WD |
1942 | free(child->argv[a]); |
1943 | } | |
fe9ca3d3 SW |
1944 | free(child->argv); |
1945 | free(child->argv_nonnull); | |
8bde7f77 | 1946 | child->argc = 0; |
fe8c2806 WD |
1947 | #endif |
1948 | child->argv=NULL; | |
1949 | } else if (child->group) { | |
1950 | #ifndef __U_BOOT__ | |
1951 | final_printf("%s begin group (subshell:%d)\n",ind, child->subshell); | |
1952 | #endif | |
1953 | ret_code = free_pipe_list(child->group,indent+3); | |
1954 | final_printf("%s end group\n",ind); | |
1955 | } else { | |
1956 | final_printf("%s (nil)\n",ind); | |
1957 | } | |
1958 | #ifndef __U_BOOT__ | |
1959 | for (r=child->redirects; r; r=rnext) { | |
1960 | final_printf("%s redirect %d%s", ind, r->fd, redir_table[r->type].descrip); | |
1961 | if (r->dup == -1) { | |
1962 | /* guard against the case >$FOO, where foo is unset or blank */ | |
1963 | if (r->word.gl_pathv) { | |
1964 | final_printf(" %s\n", *r->word.gl_pathv); | |
1965 | globfree(&r->word); | |
1966 | } | |
1967 | } else { | |
1968 | final_printf("&%d\n", r->dup); | |
1969 | } | |
1970 | rnext=r->next; | |
1971 | free(r); | |
1972 | } | |
1973 | child->redirects=NULL; | |
1974 | #endif | |
1975 | } | |
1976 | free(pi->progs); /* children are an array, they get freed all at once */ | |
1977 | pi->progs=NULL; | |
1978 | return ret_code; | |
1979 | } | |
1980 | ||
1981 | static int free_pipe_list(struct pipe *head, int indent) | |
1982 | { | |
1983 | int rcode=0; /* if list has no members */ | |
1984 | struct pipe *pi, *next; | |
1985 | char *ind = indenter(indent); | |
1986 | for (pi=head; pi; pi=next) { | |
1987 | final_printf("%s pipe reserved mode %d\n", ind, pi->r_mode); | |
1988 | rcode = free_pipe(pi, indent); | |
1989 | final_printf("%s pipe followup code %d\n", ind, pi->followup); | |
1990 | next=pi->next; | |
1991 | pi->next=NULL; | |
1992 | free(pi); | |
1993 | } | |
1994 | return rcode; | |
1995 | } | |
1996 | ||
1997 | /* Select which version we will use */ | |
1998 | static int run_list(struct pipe *pi) | |
1999 | { | |
2000 | int rcode=0; | |
2001 | #ifndef __U_BOOT__ | |
2002 | if (fake_mode==0) { | |
2003 | #endif | |
2004 | rcode = run_list_real(pi); | |
2005 | #ifndef __U_BOOT__ | |
2006 | } | |
2007 | #endif | |
2008 | /* free_pipe_list has the side effect of clearing memory | |
2009 | * In the long run that function can be merged with run_list_real, | |
2010 | * but doing that now would hobble the debugging effort. */ | |
2011 | free_pipe_list(pi,0); | |
2012 | return rcode; | |
2013 | } | |
2014 | ||
2015 | /* The API for glob is arguably broken. This routine pushes a non-matching | |
2016 | * string into the output structure, removing non-backslashed backslashes. | |
2017 | * If someone can prove me wrong, by performing this function within the | |
2018 | * original glob(3) api, feel free to rewrite this routine into oblivion. | |
2019 | * Return code (0 vs. GLOB_NOSPACE) matches glob(3). | |
2020 | * XXX broken if the last character is '\\', check that before calling. | |
2021 | */ | |
2022 | #ifndef __U_BOOT__ | |
2023 | static int globhack(const char *src, int flags, glob_t *pglob) | |
2024 | { | |
2025 | int cnt=0, pathc; | |
2026 | const char *s; | |
2027 | char *dest; | |
2028 | for (cnt=1, s=src; s && *s; s++) { | |
2029 | if (*s == '\\') s++; | |
2030 | cnt++; | |
2031 | } | |
2032 | dest = malloc(cnt); | |
2033 | if (!dest) return GLOB_NOSPACE; | |
2034 | if (!(flags & GLOB_APPEND)) { | |
2035 | pglob->gl_pathv=NULL; | |
2036 | pglob->gl_pathc=0; | |
2037 | pglob->gl_offs=0; | |
2038 | pglob->gl_offs=0; | |
2039 | } | |
2040 | pathc = ++pglob->gl_pathc; | |
2041 | pglob->gl_pathv = realloc(pglob->gl_pathv, (pathc+1)*sizeof(*pglob->gl_pathv)); | |
2042 | if (pglob->gl_pathv == NULL) return GLOB_NOSPACE; | |
2043 | pglob->gl_pathv[pathc-1]=dest; | |
2044 | pglob->gl_pathv[pathc]=NULL; | |
2045 | for (s=src; s && *s; s++, dest++) { | |
2046 | if (*s == '\\') s++; | |
2047 | *dest = *s; | |
2048 | } | |
2049 | *dest='\0'; | |
2050 | return 0; | |
2051 | } | |
2052 | ||
2053 | /* XXX broken if the last character is '\\', check that before calling */ | |
2054 | static int glob_needed(const char *s) | |
2055 | { | |
2056 | for (; *s; s++) { | |
2057 | if (*s == '\\') s++; | |
2058 | if (strchr("*[?",*s)) return 1; | |
2059 | } | |
2060 | return 0; | |
2061 | } | |
2062 | ||
2063 | #if 0 | |
2064 | static void globprint(glob_t *pglob) | |
2065 | { | |
2066 | int i; | |
2067 | debug_printf("glob_t at %p:\n", pglob); | |
2068 | debug_printf(" gl_pathc=%d gl_pathv=%p gl_offs=%d gl_flags=%d\n", | |
2069 | pglob->gl_pathc, pglob->gl_pathv, pglob->gl_offs, pglob->gl_flags); | |
2070 | for (i=0; i<pglob->gl_pathc; i++) | |
2071 | debug_printf("pglob->gl_pathv[%d] = %p = %s\n", i, | |
2072 | pglob->gl_pathv[i], pglob->gl_pathv[i]); | |
2073 | } | |
2074 | #endif | |
2075 | ||
2076 | static int xglob(o_string *dest, int flags, glob_t *pglob) | |
2077 | { | |
2078 | int gr; | |
2079 | ||
8bde7f77 | 2080 | /* short-circuit for null word */ |
fe8c2806 | 2081 | /* we can code this better when the debug_printf's are gone */ |
8bde7f77 WD |
2082 | if (dest->length == 0) { |
2083 | if (dest->nonnull) { | |
2084 | /* bash man page calls this an "explicit" null */ | |
2085 | gr = globhack(dest->data, flags, pglob); | |
2086 | debug_printf("globhack returned %d\n",gr); | |
2087 | } else { | |
fe8c2806 WD |
2088 | return 0; |
2089 | } | |
8bde7f77 | 2090 | } else if (glob_needed(dest->data)) { |
fe8c2806 WD |
2091 | gr = glob(dest->data, flags, NULL, pglob); |
2092 | debug_printf("glob returned %d\n",gr); | |
2093 | if (gr == GLOB_NOMATCH) { | |
2094 | /* quote removal, or more accurately, backslash removal */ | |
2095 | gr = globhack(dest->data, flags, pglob); | |
2096 | debug_printf("globhack returned %d\n",gr); | |
2097 | } | |
2098 | } else { | |
2099 | gr = globhack(dest->data, flags, pglob); | |
2100 | debug_printf("globhack returned %d\n",gr); | |
2101 | } | |
2102 | if (gr == GLOB_NOSPACE) | |
2103 | error_msg_and_die("out of memory during glob"); | |
2104 | if (gr != 0) { /* GLOB_ABORTED ? */ | |
2105 | error_msg("glob(3) error %d",gr); | |
2106 | } | |
2107 | /* globprint(glob_target); */ | |
2108 | return gr; | |
2109 | } | |
2110 | #endif | |
2111 | ||
c26e454d WD |
2112 | #ifdef __U_BOOT__ |
2113 | static char *get_dollar_var(char ch); | |
2114 | #endif | |
2115 | ||
fe8c2806 | 2116 | /* This is used to get/check local shell variables */ |
eae3b064 | 2117 | char *get_local_var(const char *s) |
fe8c2806 WD |
2118 | { |
2119 | struct variables *cur; | |
2120 | ||
2121 | if (!s) | |
2122 | return NULL; | |
c26e454d WD |
2123 | |
2124 | #ifdef __U_BOOT__ | |
2125 | if (*s == '$') | |
2126 | return get_dollar_var(s[1]); | |
2127 | #endif | |
2128 | ||
fe8c2806 WD |
2129 | for (cur = top_vars; cur; cur=cur->next) |
2130 | if(strcmp(cur->name, s)==0) | |
2131 | return cur->value; | |
2132 | return NULL; | |
2133 | } | |
2134 | ||
2135 | /* This is used to set local shell variables | |
2136 | flg_export==0 if only local (not exporting) variable | |
2137 | flg_export==1 if "new" exporting environ | |
2138 | flg_export>1 if current startup environ (not call putenv()) */ | |
81473f67 | 2139 | int set_local_var(const char *s, int flg_export) |
fe8c2806 WD |
2140 | { |
2141 | char *name, *value; | |
2142 | int result=0; | |
2143 | struct variables *cur; | |
2144 | ||
c26e454d WD |
2145 | #ifdef __U_BOOT__ |
2146 | /* might be possible! */ | |
2147 | if (!isalpha(*s)) | |
2148 | return -1; | |
2149 | #endif | |
2150 | ||
fe8c2806 WD |
2151 | name=strdup(s); |
2152 | ||
2153 | #ifdef __U_BOOT__ | |
2154 | if (getenv(name) != NULL) { | |
2155 | printf ("ERROR: " | |
2d1a537d | 2156 | "There is a global environment variable with the same name.\n"); |
c26e454d | 2157 | free(name); |
fe8c2806 WD |
2158 | return -1; |
2159 | } | |
2160 | #endif | |
2161 | /* Assume when we enter this function that we are already in | |
2162 | * NAME=VALUE format. So the first order of business is to | |
2163 | * split 's' on the '=' into 'name' and 'value' */ | |
2164 | value = strchr(name, '='); | |
aa722529 | 2165 | if (value == NULL || *(value + 1) == 0) { |
fe8c2806 WD |
2166 | free(name); |
2167 | return -1; | |
2168 | } | |
2169 | *value++ = 0; | |
2170 | ||
2171 | for(cur = top_vars; cur; cur = cur->next) { | |
2172 | if(strcmp(cur->name, name)==0) | |
2173 | break; | |
2174 | } | |
2175 | ||
2176 | if(cur) { | |
2177 | if(strcmp(cur->value, value)==0) { | |
2178 | if(flg_export>0 && cur->flg_export==0) | |
2179 | cur->flg_export=flg_export; | |
2180 | else | |
2181 | result++; | |
2182 | } else { | |
2183 | if(cur->flg_read_only) { | |
2184 | error_msg("%s: readonly variable", name); | |
2185 | result = -1; | |
2186 | } else { | |
2187 | if(flg_export>0 || cur->flg_export>1) | |
2188 | cur->flg_export=1; | |
2189 | free(cur->value); | |
2190 | ||
2191 | cur->value = strdup(value); | |
2192 | } | |
2193 | } | |
2194 | } else { | |
2195 | cur = malloc(sizeof(struct variables)); | |
2196 | if(!cur) { | |
2197 | result = -1; | |
2198 | } else { | |
2199 | cur->name = strdup(name); | |
199adb60 | 2200 | if (cur->name == NULL) { |
fe8c2806 WD |
2201 | free(cur); |
2202 | result = -1; | |
2203 | } else { | |
2204 | struct variables *bottom = top_vars; | |
2205 | cur->value = strdup(value); | |
199adb60 | 2206 | cur->next = NULL; |
fe8c2806 WD |
2207 | cur->flg_export = flg_export; |
2208 | cur->flg_read_only = 0; | |
2209 | while(bottom->next) bottom=bottom->next; | |
2210 | bottom->next = cur; | |
2211 | } | |
2212 | } | |
2213 | } | |
2214 | ||
2215 | #ifndef __U_BOOT__ | |
2216 | if(result==0 && cur->flg_export==1) { | |
2217 | *(value-1) = '='; | |
2218 | result = putenv(name); | |
2219 | } else { | |
2220 | #endif | |
2221 | free(name); | |
2222 | #ifndef __U_BOOT__ | |
2223 | if(result>0) /* equivalent to previous set */ | |
2224 | result = 0; | |
2225 | } | |
2226 | #endif | |
2227 | return result; | |
2228 | } | |
2229 | ||
81473f67 | 2230 | void unset_local_var(const char *name) |
fe8c2806 WD |
2231 | { |
2232 | struct variables *cur; | |
2233 | ||
2234 | if (name) { | |
2235 | for (cur = top_vars; cur; cur=cur->next) { | |
2236 | if(strcmp(cur->name, name)==0) | |
2237 | break; | |
2238 | } | |
199adb60 | 2239 | if (cur != NULL) { |
fe8c2806 WD |
2240 | struct variables *next = top_vars; |
2241 | if(cur->flg_read_only) { | |
2242 | error_msg("%s: readonly variable", name); | |
2243 | return; | |
2244 | } else { | |
81473f67 | 2245 | #ifndef __U_BOOT__ |
fe8c2806 WD |
2246 | if(cur->flg_export) |
2247 | unsetenv(cur->name); | |
81473f67 | 2248 | #endif |
fe8c2806 WD |
2249 | free(cur->name); |
2250 | free(cur->value); | |
2251 | while (next->next != cur) | |
2252 | next = next->next; | |
2253 | next->next = cur->next; | |
2254 | } | |
2255 | free(cur); | |
2256 | } | |
2257 | } | |
2258 | } | |
fe8c2806 WD |
2259 | |
2260 | static int is_assignment(const char *s) | |
2261 | { | |
c26e454d WD |
2262 | if (s == NULL) |
2263 | return 0; | |
2264 | ||
2265 | if (!isalpha(*s)) return 0; | |
fe8c2806 WD |
2266 | ++s; |
2267 | while(isalnum(*s) || *s=='_') ++s; | |
2268 | return *s=='='; | |
2269 | } | |
2270 | ||
2271 | #ifndef __U_BOOT__ | |
2272 | /* the src parameter allows us to peek forward to a possible &n syntax | |
2273 | * for file descriptor duplication, e.g., "2>&1". | |
2274 | * Return code is 0 normally, 1 if a syntax error is detected in src. | |
2275 | * Resource errors (in xmalloc) cause the process to exit */ | |
2276 | static int setup_redirect(struct p_context *ctx, int fd, redir_type style, | |
2277 | struct in_str *input) | |
2278 | { | |
2279 | struct child_prog *child=ctx->child; | |
2280 | struct redir_struct *redir = child->redirects; | |
2281 | struct redir_struct *last_redir=NULL; | |
2282 | ||
2283 | /* Create a new redir_struct and drop it onto the end of the linked list */ | |
2284 | while(redir) { | |
2285 | last_redir=redir; | |
2286 | redir=redir->next; | |
2287 | } | |
2288 | redir = xmalloc(sizeof(struct redir_struct)); | |
2289 | redir->next=NULL; | |
2290 | redir->word.gl_pathv=NULL; | |
2291 | if (last_redir) { | |
2292 | last_redir->next=redir; | |
2293 | } else { | |
2294 | child->redirects=redir; | |
2295 | } | |
2296 | ||
2297 | redir->type=style; | |
2298 | redir->fd= (fd==-1) ? redir_table[style].default_fd : fd ; | |
2299 | ||
2300 | debug_printf("Redirect type %d%s\n", redir->fd, redir_table[style].descrip); | |
2301 | ||
2302 | /* Check for a '2>&1' type redirect */ | |
2303 | redir->dup = redirect_dup_num(input); | |
2304 | if (redir->dup == -2) return 1; /* syntax error */ | |
2305 | if (redir->dup != -1) { | |
2306 | /* Erik had a check here that the file descriptor in question | |
2307 | * is legit; I postpone that to "run time" | |
2308 | * A "-" representation of "close me" shows up as a -3 here */ | |
2309 | debug_printf("Duplicating redirect '%d>&%d'\n", redir->fd, redir->dup); | |
2310 | } else { | |
2311 | /* We do _not_ try to open the file that src points to, | |
2312 | * since we need to return and let src be expanded first. | |
2313 | * Set ctx->pending_redirect, so we know what to do at the | |
2314 | * end of the next parsed word. | |
2315 | */ | |
2316 | ctx->pending_redirect = redir; | |
2317 | } | |
2318 | return 0; | |
2319 | } | |
2320 | #endif | |
2321 | ||
199adb60 KP |
2322 | static struct pipe *new_pipe(void) |
2323 | { | |
fe8c2806 WD |
2324 | struct pipe *pi; |
2325 | pi = xmalloc(sizeof(struct pipe)); | |
2326 | pi->num_progs = 0; | |
2327 | pi->progs = NULL; | |
2328 | pi->next = NULL; | |
2329 | pi->followup = 0; /* invalid */ | |
e98f68be | 2330 | pi->r_mode = RES_NONE; |
fe8c2806 WD |
2331 | return pi; |
2332 | } | |
2333 | ||
2334 | static void initialize_context(struct p_context *ctx) | |
2335 | { | |
2336 | ctx->pipe=NULL; | |
2337 | #ifndef __U_BOOT__ | |
2338 | ctx->pending_redirect=NULL; | |
2339 | #endif | |
2340 | ctx->child=NULL; | |
2341 | ctx->list_head=new_pipe(); | |
2342 | ctx->pipe=ctx->list_head; | |
2343 | ctx->w=RES_NONE; | |
2344 | ctx->stack=NULL; | |
2345 | #ifdef __U_BOOT__ | |
2346 | ctx->old_flag=0; | |
2347 | #endif | |
2348 | done_command(ctx); /* creates the memory for working child */ | |
2349 | } | |
2350 | ||
2351 | /* normal return is 0 | |
2352 | * if a reserved word is found, and processed, return 1 | |
2353 | * should handle if, then, elif, else, fi, for, while, until, do, done. | |
2354 | * case, function, and select are obnoxious, save those for later. | |
2355 | */ | |
3e38691e WD |
2356 | struct reserved_combo { |
2357 | char *literal; | |
2358 | int code; | |
2359 | long flag; | |
2360 | }; | |
2361 | /* Mostly a list of accepted follow-up reserved words. | |
2362 | * FLAG_END means we are done with the sequence, and are ready | |
2363 | * to turn the compound list into a command. | |
2364 | * FLAG_START means the word must start a new compound list. | |
2365 | */ | |
2366 | static struct reserved_combo reserved_list[] = { | |
2367 | { "if", RES_IF, FLAG_THEN | FLAG_START }, | |
2368 | { "then", RES_THEN, FLAG_ELIF | FLAG_ELSE | FLAG_FI }, | |
2369 | { "elif", RES_ELIF, FLAG_THEN }, | |
2370 | { "else", RES_ELSE, FLAG_FI }, | |
2371 | { "fi", RES_FI, FLAG_END }, | |
2372 | { "for", RES_FOR, FLAG_IN | FLAG_START }, | |
2373 | { "while", RES_WHILE, FLAG_DO | FLAG_START }, | |
2374 | { "until", RES_UNTIL, FLAG_DO | FLAG_START }, | |
2375 | { "in", RES_IN, FLAG_DO }, | |
2376 | { "do", RES_DO, FLAG_DONE }, | |
2377 | { "done", RES_DONE, FLAG_END } | |
2378 | }; | |
2379 | #define NRES (sizeof(reserved_list)/sizeof(struct reserved_combo)) | |
2380 | ||
199adb60 | 2381 | static int reserved_word(o_string *dest, struct p_context *ctx) |
fe8c2806 | 2382 | { |
fe8c2806 WD |
2383 | struct reserved_combo *r; |
2384 | for (r=reserved_list; | |
fe8c2806 WD |
2385 | r<reserved_list+NRES; r++) { |
2386 | if (strcmp(dest->data, r->literal) == 0) { | |
2387 | debug_printf("found reserved word %s, code %d\n",r->literal,r->code); | |
2388 | if (r->flag & FLAG_START) { | |
2389 | struct p_context *new = xmalloc(sizeof(struct p_context)); | |
2390 | debug_printf("push stack\n"); | |
2391 | if (ctx->w == RES_IN || ctx->w == RES_FOR) { | |
2392 | syntax(); | |
2393 | free(new); | |
2394 | ctx->w = RES_SNTX; | |
2395 | b_reset(dest); | |
2396 | return 1; | |
2397 | } | |
2398 | *new = *ctx; /* physical copy */ | |
2399 | initialize_context(ctx); | |
2400 | ctx->stack=new; | |
2401 | } else if ( ctx->w == RES_NONE || ! (ctx->old_flag & (1<<r->code))) { | |
2402 | syntax(); | |
2403 | ctx->w = RES_SNTX; | |
2404 | b_reset(dest); | |
2405 | return 1; | |
2406 | } | |
2407 | ctx->w=r->code; | |
2408 | ctx->old_flag = r->flag; | |
2409 | if (ctx->old_flag & FLAG_END) { | |
2410 | struct p_context *old; | |
2411 | debug_printf("pop stack\n"); | |
2412 | done_pipe(ctx,PIPE_SEQ); | |
2413 | old = ctx->stack; | |
2414 | old->child->group = ctx->list_head; | |
2415 | #ifndef __U_BOOT__ | |
2416 | old->child->subshell = 0; | |
2417 | #endif | |
2418 | *ctx = *old; /* physical copy */ | |
2419 | free(old); | |
2420 | } | |
2421 | b_reset (dest); | |
2422 | return 1; | |
2423 | } | |
2424 | } | |
2425 | return 0; | |
2426 | } | |
2427 | ||
2428 | /* normal return is 0. | |
2429 | * Syntax or xglob errors return 1. */ | |
2430 | static int done_word(o_string *dest, struct p_context *ctx) | |
2431 | { | |
2432 | struct child_prog *child=ctx->child; | |
2433 | #ifndef __U_BOOT__ | |
2434 | glob_t *glob_target; | |
2435 | int gr, flags = 0; | |
2436 | #else | |
2437 | char *str, *s; | |
2438 | int argc, cnt; | |
2439 | #endif | |
2440 | ||
2441 | debug_printf("done_word: %s %p\n", dest->data, child); | |
2442 | if (dest->length == 0 && !dest->nonnull) { | |
2443 | debug_printf(" true null, ignored\n"); | |
2444 | return 0; | |
2445 | } | |
2446 | #ifndef __U_BOOT__ | |
2447 | if (ctx->pending_redirect) { | |
2448 | glob_target = &ctx->pending_redirect->word; | |
2449 | } else { | |
2450 | #endif | |
2451 | if (child->group) { | |
2452 | syntax(); | |
2453 | return 1; /* syntax error, groups and arglists don't mix */ | |
2454 | } | |
2455 | if (!child->argv && (ctx->type & FLAG_PARSE_SEMICOLON)) { | |
2456 | debug_printf("checking %s for reserved-ness\n",dest->data); | |
2457 | if (reserved_word(dest,ctx)) return ctx->w==RES_SNTX; | |
2458 | } | |
2459 | #ifndef __U_BOOT__ | |
2460 | glob_target = &child->glob_result; | |
8bde7f77 | 2461 | if (child->argv) flags |= GLOB_APPEND; |
fe8c2806 WD |
2462 | #else |
2463 | for (cnt = 1, s = dest->data; s && *s; s++) { | |
2464 | if (*s == '\\') s++; | |
2465 | cnt++; | |
2466 | } | |
2467 | str = malloc(cnt); | |
2468 | if (!str) return 1; | |
2469 | if ( child->argv == NULL) { | |
2470 | child->argc=0; | |
2471 | } | |
2472 | argc = ++child->argc; | |
2473 | child->argv = realloc(child->argv, (argc+1)*sizeof(*child->argv)); | |
2474 | if (child->argv == NULL) return 1; | |
fe9ca3d3 SW |
2475 | child->argv_nonnull = realloc(child->argv_nonnull, |
2476 | (argc+1)*sizeof(*child->argv_nonnull)); | |
2477 | if (child->argv_nonnull == NULL) | |
2478 | return 1; | |
fe8c2806 | 2479 | child->argv[argc-1]=str; |
fe9ca3d3 | 2480 | child->argv_nonnull[argc-1] = dest->nonnull; |
fe8c2806 | 2481 | child->argv[argc]=NULL; |
fe9ca3d3 | 2482 | child->argv_nonnull[argc] = 0; |
fe8c2806 WD |
2483 | for (s = dest->data; s && *s; s++,str++) { |
2484 | if (*s == '\\') s++; | |
2485 | *str = *s; | |
2486 | } | |
2487 | *str = '\0'; | |
2488 | #endif | |
2489 | #ifndef __U_BOOT__ | |
2490 | } | |
2491 | gr = xglob(dest, flags, glob_target); | |
2492 | if (gr != 0) return 1; | |
2493 | #endif | |
2494 | ||
2495 | b_reset(dest); | |
2496 | #ifndef __U_BOOT__ | |
2497 | if (ctx->pending_redirect) { | |
2498 | ctx->pending_redirect=NULL; | |
2499 | if (glob_target->gl_pathc != 1) { | |
2500 | error_msg("ambiguous redirect"); | |
2501 | return 1; | |
2502 | } | |
2503 | } else { | |
2504 | child->argv = glob_target->gl_pathv; | |
2505 | } | |
2506 | #endif | |
2507 | if (ctx->w == RES_FOR) { | |
2508 | done_word(dest,ctx); | |
2509 | done_pipe(ctx,PIPE_SEQ); | |
2510 | } | |
2511 | return 0; | |
2512 | } | |
2513 | ||
2514 | /* The only possible error here is out of memory, in which case | |
2515 | * xmalloc exits. */ | |
2516 | static int done_command(struct p_context *ctx) | |
2517 | { | |
2518 | /* The child is really already in the pipe structure, so | |
2519 | * advance the pipe counter and make a new, null child. | |
2520 | * Only real trickiness here is that the uncommitted | |
2521 | * child structure, to which ctx->child points, is not | |
2522 | * counted in pi->num_progs. */ | |
2523 | struct pipe *pi=ctx->pipe; | |
2524 | struct child_prog *prog=ctx->child; | |
2525 | ||
2526 | if (prog && prog->group == NULL | |
8bde7f77 | 2527 | && prog->argv == NULL |
fe8c2806 | 2528 | #ifndef __U_BOOT__ |
8bde7f77 | 2529 | && prog->redirects == NULL) { |
fe8c2806 WD |
2530 | #else |
2531 | ) { | |
2532 | #endif | |
2533 | debug_printf("done_command: skipping null command\n"); | |
2534 | return 0; | |
2535 | } else if (prog) { | |
2536 | pi->num_progs++; | |
2537 | debug_printf("done_command: num_progs incremented to %d\n",pi->num_progs); | |
2538 | } else { | |
2539 | debug_printf("done_command: initializing\n"); | |
2540 | } | |
2541 | pi->progs = xrealloc(pi->progs, sizeof(*pi->progs) * (pi->num_progs+1)); | |
2542 | ||
2543 | prog = pi->progs + pi->num_progs; | |
2544 | #ifndef __U_BOOT__ | |
2545 | prog->redirects = NULL; | |
2546 | #endif | |
2547 | prog->argv = NULL; | |
fe9ca3d3 | 2548 | prog->argv_nonnull = NULL; |
fe8c2806 WD |
2549 | #ifndef __U_BOOT__ |
2550 | prog->is_stopped = 0; | |
2551 | #endif | |
2552 | prog->group = NULL; | |
2553 | #ifndef __U_BOOT__ | |
2554 | prog->glob_result.gl_pathv = NULL; | |
2555 | prog->family = pi; | |
2556 | #endif | |
2557 | prog->sp = 0; | |
2558 | ctx->child = prog; | |
2559 | prog->type = ctx->type; | |
2560 | ||
2561 | /* but ctx->pipe and ctx->list_head remain unchanged */ | |
2562 | return 0; | |
2563 | } | |
2564 | ||
2565 | static int done_pipe(struct p_context *ctx, pipe_style type) | |
2566 | { | |
2567 | struct pipe *new_p; | |
2568 | done_command(ctx); /* implicit closure of previous command */ | |
2569 | debug_printf("done_pipe, type %d\n", type); | |
2570 | ctx->pipe->followup = type; | |
2571 | ctx->pipe->r_mode = ctx->w; | |
2572 | new_p=new_pipe(); | |
2573 | ctx->pipe->next = new_p; | |
2574 | ctx->pipe = new_p; | |
2575 | ctx->child = NULL; | |
2576 | done_command(ctx); /* set up new pipe to accept commands */ | |
2577 | return 0; | |
2578 | } | |
2579 | ||
2580 | #ifndef __U_BOOT__ | |
2581 | /* peek ahead in the in_str to find out if we have a "&n" construct, | |
2582 | * as in "2>&1", that represents duplicating a file descriptor. | |
2583 | * returns either -2 (syntax error), -1 (no &), or the number found. | |
2584 | */ | |
2585 | static int redirect_dup_num(struct in_str *input) | |
2586 | { | |
2587 | int ch, d=0, ok=0; | |
2588 | ch = b_peek(input); | |
2589 | if (ch != '&') return -1; | |
2590 | ||
2591 | b_getch(input); /* get the & */ | |
2592 | ch=b_peek(input); | |
2593 | if (ch == '-') { | |
2594 | b_getch(input); | |
2595 | return -3; /* "-" represents "close me" */ | |
2596 | } | |
2597 | while (isdigit(ch)) { | |
2598 | d = d*10+(ch-'0'); | |
2599 | ok=1; | |
2600 | b_getch(input); | |
2601 | ch = b_peek(input); | |
2602 | } | |
2603 | if (ok) return d; | |
2604 | ||
2605 | error_msg("ambiguous redirect"); | |
2606 | return -2; | |
2607 | } | |
2608 | ||
2609 | /* If a redirect is immediately preceded by a number, that number is | |
2610 | * supposed to tell which file descriptor to redirect. This routine | |
2611 | * looks for such preceding numbers. In an ideal world this routine | |
2612 | * needs to handle all the following classes of redirects... | |
2613 | * echo 2>foo # redirects fd 2 to file "foo", nothing passed to echo | |
2614 | * echo 49>foo # redirects fd 49 to file "foo", nothing passed to echo | |
2615 | * echo -2>foo # redirects fd 1 to file "foo", "-2" passed to echo | |
2616 | * echo 49x>foo # redirects fd 1 to file "foo", "49x" passed to echo | |
2617 | * A -1 output from this program means no valid number was found, so the | |
2618 | * caller should use the appropriate default for this redirection. | |
2619 | */ | |
2620 | static int redirect_opt_num(o_string *o) | |
2621 | { | |
2622 | int num; | |
2623 | ||
2624 | if (o->length==0) return -1; | |
2625 | for(num=0; num<o->length; num++) { | |
2626 | if (!isdigit(*(o->data+num))) { | |
2627 | return -1; | |
2628 | } | |
2629 | } | |
2630 | /* reuse num (and save an int) */ | |
2631 | num=atoi(o->data); | |
2632 | b_reset(o); | |
2633 | return num; | |
2634 | } | |
2635 | ||
2636 | FILE *generate_stream_from_list(struct pipe *head) | |
2637 | { | |
2638 | FILE *pf; | |
2639 | #if 1 | |
2640 | int pid, channel[2]; | |
2641 | if (pipe(channel)<0) perror_msg_and_die("pipe"); | |
2642 | pid=fork(); | |
2643 | if (pid<0) { | |
2644 | perror_msg_and_die("fork"); | |
2645 | } else if (pid==0) { | |
2646 | close(channel[0]); | |
2647 | if (channel[1] != 1) { | |
2648 | dup2(channel[1],1); | |
2649 | close(channel[1]); | |
2650 | } | |
2651 | #if 0 | |
2652 | #define SURROGATE "surrogate response" | |
2653 | write(1,SURROGATE,sizeof(SURROGATE)); | |
2654 | _exit(run_list(head)); | |
2655 | #else | |
2656 | _exit(run_list_real(head)); /* leaks memory */ | |
2657 | #endif | |
2658 | } | |
2659 | debug_printf("forked child %d\n",pid); | |
2660 | close(channel[1]); | |
2661 | pf = fdopen(channel[0],"r"); | |
2662 | debug_printf("pipe on FILE *%p\n",pf); | |
2663 | #else | |
2664 | free_pipe_list(head,0); | |
2665 | pf=popen("echo surrogate response","r"); | |
2666 | debug_printf("started fake pipe on FILE *%p\n",pf); | |
2667 | #endif | |
2668 | return pf; | |
2669 | } | |
2670 | ||
2671 | /* this version hacked for testing purposes */ | |
2672 | /* return code is exit status of the process that is run. */ | |
2673 | static int process_command_subs(o_string *dest, struct p_context *ctx, struct in_str *input, int subst_end) | |
2674 | { | |
2675 | int retcode; | |
2676 | o_string result=NULL_O_STRING; | |
2677 | struct p_context inner; | |
2678 | FILE *p; | |
2679 | struct in_str pipe_str; | |
2680 | initialize_context(&inner); | |
2681 | ||
2682 | /* recursion to generate command */ | |
2683 | retcode = parse_stream(&result, &inner, input, subst_end); | |
2684 | if (retcode != 0) return retcode; /* syntax error or EOF */ | |
2685 | done_word(&result, &inner); | |
2686 | done_pipe(&inner, PIPE_SEQ); | |
2687 | b_free(&result); | |
2688 | ||
2689 | p=generate_stream_from_list(inner.list_head); | |
2690 | if (p==NULL) return 1; | |
2691 | mark_open(fileno(p)); | |
2692 | setup_file_in_str(&pipe_str, p); | |
2693 | ||
2694 | /* now send results of command back into original context */ | |
2695 | retcode = parse_stream(dest, ctx, &pipe_str, '\0'); | |
2696 | /* XXX In case of a syntax error, should we try to kill the child? | |
2697 | * That would be tough to do right, so just read until EOF. */ | |
2698 | if (retcode == 1) { | |
2699 | while (b_getch(&pipe_str)!=EOF) { /* discard */ }; | |
2700 | } | |
2701 | ||
2702 | debug_printf("done reading from pipe, pclose()ing\n"); | |
2703 | /* This is the step that wait()s for the child. Should be pretty | |
2704 | * safe, since we just read an EOF from its stdout. We could try | |
2705 | * to better, by using wait(), and keeping track of background jobs | |
2706 | * at the same time. That would be a lot of work, and contrary | |
2707 | * to the KISS philosophy of this program. */ | |
2708 | mark_closed(fileno(p)); | |
2709 | retcode=pclose(p); | |
2710 | free_pipe_list(inner.list_head,0); | |
2711 | debug_printf("pclosed, retcode=%d\n",retcode); | |
2712 | /* XXX this process fails to trim a single trailing newline */ | |
2713 | return retcode; | |
2714 | } | |
2715 | ||
2716 | static int parse_group(o_string *dest, struct p_context *ctx, | |
2717 | struct in_str *input, int ch) | |
2718 | { | |
2719 | int rcode, endch=0; | |
2720 | struct p_context sub; | |
2721 | struct child_prog *child = ctx->child; | |
2722 | if (child->argv) { | |
2723 | syntax(); | |
2724 | return 1; /* syntax error, groups and arglists don't mix */ | |
2725 | } | |
2726 | initialize_context(&sub); | |
2727 | switch(ch) { | |
2728 | case '(': endch=')'; child->subshell=1; break; | |
2729 | case '{': endch='}'; break; | |
2730 | default: syntax(); /* really logic error */ | |
2731 | } | |
2732 | rcode=parse_stream(dest,&sub,input,endch); | |
2733 | done_word(dest,&sub); /* finish off the final word in the subcontext */ | |
2734 | done_pipe(&sub, PIPE_SEQ); /* and the final command there, too */ | |
2735 | child->group = sub.list_head; | |
2736 | return rcode; | |
2737 | /* child remains "open", available for possible redirects */ | |
2738 | } | |
2739 | #endif | |
2740 | ||
2741 | /* basically useful version until someone wants to get fancier, | |
2742 | * see the bash man page under "Parameter Expansion" */ | |
2743 | static char *lookup_param(char *src) | |
2744 | { | |
c26e454d | 2745 | char *p; |
641b0d37 JH |
2746 | char *sep; |
2747 | char *default_val = NULL; | |
2748 | int assign = 0; | |
2749 | int expand_empty = 0; | |
c26e454d WD |
2750 | |
2751 | if (!src) | |
2752 | return NULL; | |
2753 | ||
641b0d37 JH |
2754 | sep = strchr(src, ':'); |
2755 | ||
2756 | if (sep) { | |
2757 | *sep = '\0'; | |
2758 | if (*(sep + 1) == '-') | |
2759 | default_val = sep+2; | |
2760 | if (*(sep + 1) == '=') { | |
2761 | default_val = sep+2; | |
2762 | assign = 1; | |
2763 | } | |
2764 | if (*(sep + 1) == '+') { | |
2765 | default_val = sep+2; | |
2766 | expand_empty = 1; | |
2767 | } | |
2768 | } | |
2769 | ||
2770 | p = getenv(src); | |
2771 | if (!p) | |
2772 | p = get_local_var(src); | |
2773 | ||
2774 | if (!p || strlen(p) == 0) { | |
2775 | p = default_val; | |
2776 | if (assign) { | |
2777 | char *var = malloc(strlen(src)+strlen(default_val)+2); | |
2778 | if (var) { | |
2779 | sprintf(var, "%s=%s", src, default_val); | |
2780 | set_local_var(var, 0); | |
2781 | } | |
2782 | free(var); | |
2783 | } | |
2784 | } else if (expand_empty) { | |
2785 | p += strlen(p); | |
2786 | } | |
2787 | ||
2788 | if (sep) | |
2789 | *sep = ':'; | |
c26e454d | 2790 | |
fe8c2806 WD |
2791 | return p; |
2792 | } | |
2793 | ||
c26e454d WD |
2794 | #ifdef __U_BOOT__ |
2795 | static char *get_dollar_var(char ch) | |
2796 | { | |
2797 | static char buf[40]; | |
2798 | ||
2799 | buf[0] = '\0'; | |
2800 | switch (ch) { | |
2801 | case '?': | |
2802 | sprintf(buf, "%u", (unsigned int)last_return_code); | |
2803 | break; | |
2804 | default: | |
2805 | return NULL; | |
2806 | } | |
2807 | return buf; | |
2808 | } | |
2809 | #endif | |
2810 | ||
fe8c2806 WD |
2811 | /* return code: 0 for OK, 1 for syntax error */ |
2812 | static int handle_dollar(o_string *dest, struct p_context *ctx, struct in_str *input) | |
2813 | { | |
2814 | #ifndef __U_BOOT__ | |
2815 | int i, advance=0; | |
2816 | #else | |
2817 | int advance=0; | |
2818 | #endif | |
2819 | #ifndef __U_BOOT__ | |
2820 | char sep[]=" "; | |
2821 | #endif | |
2822 | int ch = input->peek(input); /* first character after the $ */ | |
2823 | debug_printf("handle_dollar: ch=%c\n",ch); | |
2824 | if (isalpha(ch)) { | |
2825 | b_addchr(dest, SPECIAL_VAR_SYMBOL); | |
2826 | ctx->child->sp++; | |
2827 | while(ch=b_peek(input),isalnum(ch) || ch=='_') { | |
2828 | b_getch(input); | |
2829 | b_addchr(dest,ch); | |
2830 | } | |
2831 | b_addchr(dest, SPECIAL_VAR_SYMBOL); | |
2832 | #ifndef __U_BOOT__ | |
2833 | } else if (isdigit(ch)) { | |
2834 | i = ch-'0'; /* XXX is $0 special? */ | |
2835 | if (i<global_argc) { | |
2836 | parse_string(dest, ctx, global_argv[i]); /* recursion */ | |
2837 | } | |
2838 | advance = 1; | |
2839 | #endif | |
2840 | } else switch (ch) { | |
2841 | #ifndef __U_BOOT__ | |
2842 | case '$': | |
2843 | b_adduint(dest,getpid()); | |
2844 | advance = 1; | |
2845 | break; | |
2846 | case '!': | |
2847 | if (last_bg_pid > 0) b_adduint(dest, last_bg_pid); | |
2848 | advance = 1; | |
2849 | break; | |
2850 | #endif | |
2851 | case '?': | |
c26e454d | 2852 | #ifndef __U_BOOT__ |
fe8c2806 | 2853 | b_adduint(dest,last_return_code); |
c26e454d WD |
2854 | #else |
2855 | ctx->child->sp++; | |
2856 | b_addchr(dest, SPECIAL_VAR_SYMBOL); | |
2857 | b_addchr(dest, '$'); | |
2858 | b_addchr(dest, '?'); | |
2859 | b_addchr(dest, SPECIAL_VAR_SYMBOL); | |
2860 | #endif | |
fe8c2806 WD |
2861 | advance = 1; |
2862 | break; | |
2863 | #ifndef __U_BOOT__ | |
2864 | case '#': | |
2865 | b_adduint(dest,global_argc ? global_argc-1 : 0); | |
2866 | advance = 1; | |
2867 | break; | |
2868 | #endif | |
2869 | case '{': | |
2870 | b_addchr(dest, SPECIAL_VAR_SYMBOL); | |
2871 | ctx->child->sp++; | |
2872 | b_getch(input); | |
2873 | /* XXX maybe someone will try to escape the '}' */ | |
2874 | while(ch=b_getch(input),ch!=EOF && ch!='}') { | |
2875 | b_addchr(dest,ch); | |
2876 | } | |
2877 | if (ch != '}') { | |
2878 | syntax(); | |
2879 | return 1; | |
2880 | } | |
2881 | b_addchr(dest, SPECIAL_VAR_SYMBOL); | |
2882 | break; | |
2883 | #ifndef __U_BOOT__ | |
2884 | case '(': | |
2885 | b_getch(input); | |
2886 | process_command_subs(dest, ctx, input, ')'); | |
2887 | break; | |
2888 | case '*': | |
2889 | sep[0]=ifs[0]; | |
2890 | for (i=1; i<global_argc; i++) { | |
2891 | parse_string(dest, ctx, global_argv[i]); | |
2892 | if (i+1 < global_argc) parse_string(dest, ctx, sep); | |
2893 | } | |
2894 | break; | |
2895 | case '@': | |
2896 | case '-': | |
2897 | case '_': | |
2898 | /* still unhandled, but should be eventually */ | |
2899 | error_msg("unhandled syntax: $%c",ch); | |
2900 | return 1; | |
2901 | break; | |
2902 | #endif | |
2903 | default: | |
2904 | b_addqchr(dest,'$',dest->quote); | |
2905 | } | |
2906 | /* Eat the character if the flag was set. If the compiler | |
2907 | * is smart enough, we could substitute "b_getch(input);" | |
2908 | * for all the "advance = 1;" above, and also end up with | |
2909 | * a nice size-optimized program. Hah! That'll be the day. | |
2910 | */ | |
2911 | if (advance) b_getch(input); | |
2912 | return 0; | |
2913 | } | |
2914 | ||
2915 | #ifndef __U_BOOT__ | |
2916 | int parse_string(o_string *dest, struct p_context *ctx, const char *src) | |
2917 | { | |
2918 | struct in_str foo; | |
2919 | setup_string_in_str(&foo, src); | |
2920 | return parse_stream(dest, ctx, &foo, '\0'); | |
2921 | } | |
2922 | #endif | |
2923 | ||
2924 | /* return code is 0 for normal exit, 1 for syntax error */ | |
199adb60 KP |
2925 | static int parse_stream(o_string *dest, struct p_context *ctx, |
2926 | struct in_str *input, int end_trigger) | |
fe8c2806 WD |
2927 | { |
2928 | unsigned int ch, m; | |
2929 | #ifndef __U_BOOT__ | |
2930 | int redir_fd; | |
2931 | redir_type redir_style; | |
2932 | #endif | |
2933 | int next; | |
2934 | ||
2935 | /* Only double-quote state is handled in the state variable dest->quote. | |
2936 | * A single-quote triggers a bypass of the main loop until its mate is | |
2937 | * found. When recursing, quote state is passed in via dest->quote. */ | |
2938 | ||
2939 | debug_printf("parse_stream, end_trigger=%d\n",end_trigger); | |
2940 | while ((ch=b_getch(input))!=EOF) { | |
2941 | m = map[ch]; | |
2942 | #ifdef __U_BOOT__ | |
2943 | if (input->__promptme == 0) return 1; | |
2944 | #endif | |
2945 | next = (ch == '\n') ? 0 : b_peek(input); | |
c26e454d WD |
2946 | |
2947 | debug_printf("parse_stream: ch=%c (%d) m=%d quote=%d - %c\n", | |
2948 | ch >= ' ' ? ch : '.', ch, m, | |
2949 | dest->quote, ctx->stack == NULL ? '*' : '.'); | |
2950 | ||
fe8c2806 WD |
2951 | if (m==0 || ((m==1 || m==2) && dest->quote)) { |
2952 | b_addqchr(dest, ch, dest->quote); | |
2953 | } else { | |
2954 | if (m==2) { /* unquoted IFS */ | |
2955 | if (done_word(dest, ctx)) { | |
2956 | return 1; | |
2957 | } | |
2958 | /* If we aren't performing a substitution, treat a newline as a | |
2959 | * command separator. */ | |
2960 | if (end_trigger != '\0' && ch=='\n') | |
2961 | done_pipe(ctx,PIPE_SEQ); | |
2962 | } | |
2963 | if (ch == end_trigger && !dest->quote && ctx->w==RES_NONE) { | |
2964 | debug_printf("leaving parse_stream (triggered)\n"); | |
2965 | return 0; | |
2966 | } | |
2967 | #if 0 | |
2968 | if (ch=='\n') { | |
2969 | /* Yahoo! Time to run with it! */ | |
2970 | done_pipe(ctx,PIPE_SEQ); | |
2971 | run_list(ctx->list_head); | |
2972 | initialize_context(ctx); | |
2973 | } | |
2974 | #endif | |
2975 | if (m!=2) switch (ch) { | |
2976 | case '#': | |
2977 | if (dest->length == 0 && !dest->quote) { | |
2978 | while(ch=b_peek(input),ch!=EOF && ch!='\n') { b_getch(input); } | |
2979 | } else { | |
2980 | b_addqchr(dest, ch, dest->quote); | |
2981 | } | |
2982 | break; | |
2983 | case '\\': | |
2984 | if (next == EOF) { | |
2985 | syntax(); | |
2986 | return 1; | |
2987 | } | |
2988 | b_addqchr(dest, '\\', dest->quote); | |
2989 | b_addqchr(dest, b_getch(input), dest->quote); | |
2990 | break; | |
2991 | case '$': | |
2992 | if (handle_dollar(dest, ctx, input)!=0) return 1; | |
2993 | break; | |
2994 | case '\'': | |
2995 | dest->nonnull = 1; | |
2996 | while(ch=b_getch(input),ch!=EOF && ch!='\'') { | |
2997 | #ifdef __U_BOOT__ | |
2998 | if(input->__promptme == 0) return 1; | |
2999 | #endif | |
3000 | b_addchr(dest,ch); | |
3001 | } | |
3002 | if (ch==EOF) { | |
3003 | syntax(); | |
3004 | return 1; | |
3005 | } | |
3006 | break; | |
3007 | case '"': | |
3008 | dest->nonnull = 1; | |
3009 | dest->quote = !dest->quote; | |
3010 | break; | |
3011 | #ifndef __U_BOOT__ | |
3012 | case '`': | |
3013 | process_command_subs(dest, ctx, input, '`'); | |
3014 | break; | |
3015 | case '>': | |
3016 | redir_fd = redirect_opt_num(dest); | |
3017 | done_word(dest, ctx); | |
3018 | redir_style=REDIRECT_OVERWRITE; | |
3019 | if (next == '>') { | |
3020 | redir_style=REDIRECT_APPEND; | |
3021 | b_getch(input); | |
3022 | } else if (next == '(') { | |
3023 | syntax(); /* until we support >(list) Process Substitution */ | |
3024 | return 1; | |
3025 | } | |
3026 | setup_redirect(ctx, redir_fd, redir_style, input); | |
3027 | break; | |
3028 | case '<': | |
3029 | redir_fd = redirect_opt_num(dest); | |
3030 | done_word(dest, ctx); | |
3031 | redir_style=REDIRECT_INPUT; | |
3032 | if (next == '<') { | |
3033 | redir_style=REDIRECT_HEREIS; | |
3034 | b_getch(input); | |
3035 | } else if (next == '>') { | |
3036 | redir_style=REDIRECT_IO; | |
3037 | b_getch(input); | |
3038 | } else if (next == '(') { | |
3039 | syntax(); /* until we support <(list) Process Substitution */ | |
3040 | return 1; | |
3041 | } | |
3042 | setup_redirect(ctx, redir_fd, redir_style, input); | |
3043 | break; | |
3044 | #endif | |
3045 | case ';': | |
3046 | done_word(dest, ctx); | |
3047 | done_pipe(ctx,PIPE_SEQ); | |
3048 | break; | |
3049 | case '&': | |
3050 | done_word(dest, ctx); | |
3051 | if (next=='&') { | |
3052 | b_getch(input); | |
3053 | done_pipe(ctx,PIPE_AND); | |
3054 | } else { | |
3055 | #ifndef __U_BOOT__ | |
3056 | done_pipe(ctx,PIPE_BG); | |
3057 | #else | |
3058 | syntax_err(); | |
3059 | return 1; | |
3060 | #endif | |
3061 | } | |
3062 | break; | |
3063 | case '|': | |
3064 | done_word(dest, ctx); | |
3065 | if (next=='|') { | |
3066 | b_getch(input); | |
3067 | done_pipe(ctx,PIPE_OR); | |
3068 | } else { | |
3069 | /* we could pick up a file descriptor choice here | |
3070 | * with redirect_opt_num(), but bash doesn't do it. | |
3071 | * "echo foo 2| cat" yields "foo 2". */ | |
3072 | #ifndef __U_BOOT__ | |
3073 | done_command(ctx); | |
3074 | #else | |
3075 | syntax_err(); | |
3076 | return 1; | |
3077 | #endif | |
3078 | } | |
3079 | break; | |
3080 | #ifndef __U_BOOT__ | |
3081 | case '(': | |
3082 | case '{': | |
3083 | if (parse_group(dest, ctx, input, ch)!=0) return 1; | |
3084 | break; | |
3085 | case ')': | |
3086 | case '}': | |
3087 | syntax(); /* Proper use of this character caught by end_trigger */ | |
3088 | return 1; | |
3089 | break; | |
3090 | #endif | |
a005f19e JH |
3091 | case SUBSTED_VAR_SYMBOL: |
3092 | dest->nonnull = 1; | |
3093 | while (ch = b_getch(input), ch != EOF && | |
3094 | ch != SUBSTED_VAR_SYMBOL) { | |
3095 | debug_printf("subst, pass=%d\n", ch); | |
3096 | if (input->__promptme == 0) | |
3097 | return 1; | |
3098 | b_addchr(dest, ch); | |
3099 | } | |
3100 | debug_printf("subst, term=%d\n", ch); | |
3101 | if (ch == EOF) { | |
3102 | syntax(); | |
3103 | return 1; | |
3104 | } | |
3105 | break; | |
fe8c2806 WD |
3106 | default: |
3107 | syntax(); /* this is really an internal logic error */ | |
3108 | return 1; | |
3109 | } | |
3110 | } | |
3111 | } | |
3112 | /* complain if quote? No, maybe we just finished a command substitution | |
3113 | * that was quoted. Example: | |
3114 | * $ echo "`cat foo` plus more" | |
3115 | * and we just got the EOF generated by the subshell that ran "cat foo" | |
3116 | * The only real complaint is if we got an EOF when end_trigger != '\0', | |
3117 | * that is, we were really supposed to get end_trigger, and never got | |
3118 | * one before the EOF. Can't use the standard "syntax error" return code, | |
3119 | * so that parse_stream_outer can distinguish the EOF and exit smoothly. */ | |
3120 | debug_printf("leaving parse_stream (EOF)\n"); | |
3121 | if (end_trigger != '\0') return -1; | |
3122 | return 0; | |
3123 | } | |
3124 | ||
199adb60 | 3125 | static void mapset(const unsigned char *set, int code) |
fe8c2806 WD |
3126 | { |
3127 | const unsigned char *s; | |
3128 | for (s=set; *s; s++) map[*s] = code; | |
3129 | } | |
3130 | ||
199adb60 | 3131 | static void update_ifs_map(void) |
fe8c2806 WD |
3132 | { |
3133 | /* char *ifs and char map[256] are both globals. */ | |
77ddac94 WD |
3134 | ifs = (uchar *)getenv("IFS"); |
3135 | if (ifs == NULL) ifs=(uchar *)" \t\n"; | |
fe8c2806 WD |
3136 | /* Precompute a list of 'flow through' behavior so it can be treated |
3137 | * quickly up front. Computation is necessary because of IFS. | |
3138 | * Special case handling of IFS == " \t\n" is not implemented. | |
3139 | * The map[] array only really needs two bits each, and on most machines | |
3140 | * that would be faster because of the reduced L1 cache footprint. | |
3141 | */ | |
3142 | memset(map,0,sizeof(map)); /* most characters flow through always */ | |
3143 | #ifndef __U_BOOT__ | |
77ddac94 WD |
3144 | mapset((uchar *)"\\$'\"`", 3); /* never flow through */ |
3145 | mapset((uchar *)"<>;&|(){}#", 1); /* flow through if quoted */ | |
fe8c2806 | 3146 | #else |
a005f19e JH |
3147 | { |
3148 | uchar subst[2] = {SUBSTED_VAR_SYMBOL, 0}; | |
3149 | mapset(subst, 3); /* never flow through */ | |
3150 | } | |
77ddac94 WD |
3151 | mapset((uchar *)"\\$'\"", 3); /* never flow through */ |
3152 | mapset((uchar *)";&|#", 1); /* flow through if quoted */ | |
fe8c2806 WD |
3153 | #endif |
3154 | mapset(ifs, 2); /* also flow through if quoted */ | |
3155 | } | |
3156 | ||
3157 | /* most recursion does not come through here, the exeception is | |
3158 | * from builtin_source() */ | |
199adb60 | 3159 | static int parse_stream_outer(struct in_str *inp, int flag) |
fe8c2806 WD |
3160 | { |
3161 | ||
3162 | struct p_context ctx; | |
3163 | o_string temp=NULL_O_STRING; | |
3164 | int rcode; | |
3165 | #ifdef __U_BOOT__ | |
2302b3ab | 3166 | int code = 1; |
fe8c2806 WD |
3167 | #endif |
3168 | do { | |
3169 | ctx.type = flag; | |
3170 | initialize_context(&ctx); | |
3171 | update_ifs_map(); | |
77ddac94 | 3172 | if (!(flag & FLAG_PARSE_SEMICOLON) || (flag & FLAG_REPARSING)) mapset((uchar *)";$&|", 0); |
fe8c2806 | 3173 | inp->promptmode=1; |
87b6398b SG |
3174 | rcode = parse_stream(&temp, &ctx, inp, |
3175 | flag & FLAG_CONT_ON_NEWLINE ? -1 : '\n'); | |
fe8c2806 WD |
3176 | #ifdef __U_BOOT__ |
3177 | if (rcode == 1) flag_repeat = 0; | |
3178 | #endif | |
3179 | if (rcode != 1 && ctx.old_flag != 0) { | |
3180 | syntax(); | |
3181 | #ifdef __U_BOOT__ | |
3182 | flag_repeat = 0; | |
3183 | #endif | |
3184 | } | |
3185 | if (rcode != 1 && ctx.old_flag == 0) { | |
3186 | done_word(&temp, &ctx); | |
3187 | done_pipe(&ctx,PIPE_SEQ); | |
3188 | #ifndef __U_BOOT__ | |
3189 | run_list(ctx.list_head); | |
3190 | #else | |
c26e454d WD |
3191 | code = run_list(ctx.list_head); |
3192 | if (code == -2) { /* exit */ | |
3193 | b_free(&temp); | |
3194 | code = 0; | |
3195 | /* XXX hackish way to not allow exit from main loop */ | |
3196 | if (inp->peek == file_peek) { | |
3197 | printf("exit not allowed from main input shell.\n"); | |
3198 | continue; | |
3199 | } | |
3200 | break; | |
3201 | } | |
3202 | if (code == -1) | |
fe8c2806 WD |
3203 | flag_repeat = 0; |
3204 | #endif | |
3205 | } else { | |
3206 | if (ctx.old_flag != 0) { | |
3207 | free(ctx.stack); | |
3208 | b_reset(&temp); | |
3209 | } | |
3210 | #ifdef __U_BOOT__ | |
3211 | if (inp->__promptme == 0) printf("<INTERRUPT>\n"); | |
3212 | inp->__promptme = 1; | |
3213 | #endif | |
3214 | temp.nonnull = 0; | |
3215 | temp.quote = 0; | |
3216 | inp->p = NULL; | |
3217 | free_pipe_list(ctx.list_head,0); | |
3218 | } | |
3219 | b_free(&temp); | |
587e1d43 | 3220 | /* loop on syntax errors, return on EOF */ |
f3a05c8f | 3221 | } while (rcode != -1 && !(flag & FLAG_EXIT_FROM_LOOP) && |
587e1d43 | 3222 | (inp->peek != static_peek || b_peek(inp))); |
fe8c2806 WD |
3223 | #ifndef __U_BOOT__ |
3224 | return 0; | |
3225 | #else | |
3226 | return (code != 0) ? 1 : 0; | |
3227 | #endif /* __U_BOOT__ */ | |
3228 | } | |
3229 | ||
3230 | #ifndef __U_BOOT__ | |
3231 | static int parse_string_outer(const char *s, int flag) | |
3232 | #else | |
c8a2079e | 3233 | int parse_string_outer(const char *s, int flag) |
fe8c2806 WD |
3234 | #endif /* __U_BOOT__ */ |
3235 | { | |
3236 | struct in_str input; | |
3237 | #ifdef __U_BOOT__ | |
3238 | char *p = NULL; | |
3239 | int rcode; | |
484408fb | 3240 | if (!s) |
fe8c2806 | 3241 | return 1; |
484408fb RV |
3242 | if (!*s) |
3243 | return 0; | |
fe8c2806 WD |
3244 | if (!(p = strchr(s, '\n')) || *++p) { |
3245 | p = xmalloc(strlen(s) + 2); | |
3246 | strcpy(p, s); | |
3247 | strcat(p, "\n"); | |
3248 | setup_string_in_str(&input, p); | |
3249 | rcode = parse_stream_outer(&input, flag); | |
3250 | free(p); | |
3251 | return rcode; | |
3252 | } else { | |
3253 | #endif | |
3254 | setup_string_in_str(&input, s); | |
3255 | return parse_stream_outer(&input, flag); | |
3256 | #ifdef __U_BOOT__ | |
3257 | } | |
3258 | #endif | |
3259 | } | |
3260 | ||
3261 | #ifndef __U_BOOT__ | |
3262 | static int parse_file_outer(FILE *f) | |
3263 | #else | |
3264 | int parse_file_outer(void) | |
3265 | #endif | |
3266 | { | |
3267 | int rcode; | |
3268 | struct in_str input; | |
3269 | #ifndef __U_BOOT__ | |
3270 | setup_file_in_str(&input, f); | |
3271 | #else | |
3272 | setup_file_in_str(&input); | |
3273 | #endif | |
3274 | rcode = parse_stream_outer(&input, FLAG_PARSE_SEMICOLON); | |
3275 | return rcode; | |
3276 | } | |
3277 | ||
3278 | #ifdef __U_BOOT__ | |
2e5167cc | 3279 | #ifdef CONFIG_NEEDS_MANUAL_RELOC |
3e38691e WD |
3280 | static void u_boot_hush_reloc(void) |
3281 | { | |
3e38691e WD |
3282 | unsigned long addr; |
3283 | struct reserved_combo *r; | |
3284 | ||
3285 | for (r=reserved_list; r<reserved_list+NRES; r++) { | |
3286 | addr = (ulong) (r->literal) + gd->reloc_off; | |
3287 | r->literal = (char *)addr; | |
3288 | } | |
3289 | } | |
521af04d | 3290 | #endif |
3e38691e | 3291 | |
fe8c2806 WD |
3292 | int u_boot_hush_start(void) |
3293 | { | |
2d5b561e WD |
3294 | if (top_vars == NULL) { |
3295 | top_vars = malloc(sizeof(struct variables)); | |
3296 | top_vars->name = "HUSH_VERSION"; | |
3297 | top_vars->value = "0.01"; | |
199adb60 | 3298 | top_vars->next = NULL; |
2d5b561e WD |
3299 | top_vars->flg_export = 0; |
3300 | top_vars->flg_read_only = 1; | |
2e5167cc | 3301 | #ifdef CONFIG_NEEDS_MANUAL_RELOC |
2d5b561e | 3302 | u_boot_hush_reloc(); |
521af04d | 3303 | #endif |
2d5b561e | 3304 | } |
fe8c2806 WD |
3305 | return 0; |
3306 | } | |
3307 | ||
3308 | static void *xmalloc(size_t size) | |
3309 | { | |
3310 | void *p = NULL; | |
3311 | ||
3312 | if (!(p = malloc(size))) { | |
3313 | printf("ERROR : memory not allocated\n"); | |
3314 | for(;;); | |
3315 | } | |
3316 | return p; | |
3317 | } | |
3318 | ||
3319 | static void *xrealloc(void *ptr, size_t size) | |
3320 | { | |
3321 | void *p = NULL; | |
3322 | ||
3323 | if (!(p = realloc(ptr, size))) { | |
3324 | printf("ERROR : memory not allocated\n"); | |
3325 | for(;;); | |
3326 | } | |
3327 | return p; | |
3328 | } | |
3329 | #endif /* __U_BOOT__ */ | |
3330 | ||
3331 | #ifndef __U_BOOT__ | |
3332 | /* Make sure we have a controlling tty. If we get started under a job | |
3333 | * aware app (like bash for example), make sure we are now in charge so | |
3334 | * we don't fight over who gets the foreground */ | |
d0fb80c3 | 3335 | static void setup_job_control(void) |
fe8c2806 WD |
3336 | { |
3337 | static pid_t shell_pgrp; | |
3338 | /* Loop until we are in the foreground. */ | |
3339 | while (tcgetpgrp (shell_terminal) != (shell_pgrp = getpgrp ())) | |
3340 | kill (- shell_pgrp, SIGTTIN); | |
3341 | ||
3342 | /* Ignore interactive and job-control signals. */ | |
3343 | signal(SIGINT, SIG_IGN); | |
3344 | signal(SIGQUIT, SIG_IGN); | |
3345 | signal(SIGTERM, SIG_IGN); | |
3346 | signal(SIGTSTP, SIG_IGN); | |
3347 | signal(SIGTTIN, SIG_IGN); | |
3348 | signal(SIGTTOU, SIG_IGN); | |
3349 | signal(SIGCHLD, SIG_IGN); | |
3350 | ||
3351 | /* Put ourselves in our own process group. */ | |
3352 | setsid(); | |
3353 | shell_pgrp = getpid (); | |
3354 | setpgid (shell_pgrp, shell_pgrp); | |
3355 | ||
3356 | /* Grab control of the terminal. */ | |
3357 | tcsetpgrp(shell_terminal, shell_pgrp); | |
3358 | } | |
3359 | ||
54841ab5 | 3360 | int hush_main(int argc, char * const *argv) |
fe8c2806 WD |
3361 | { |
3362 | int opt; | |
3363 | FILE *input; | |
3364 | char **e = environ; | |
3365 | ||
3366 | /* XXX what should these be while sourcing /etc/profile? */ | |
3367 | global_argc = argc; | |
3368 | global_argv = argv; | |
3369 | ||
3370 | /* (re?) initialize globals. Sometimes hush_main() ends up calling | |
3371 | * hush_main(), therefore we cannot rely on the BSS to zero out this | |
3372 | * stuff. Reset these to 0 every time. */ | |
3373 | ifs = NULL; | |
3374 | /* map[] is taken care of with call to update_ifs_map() */ | |
3375 | fake_mode = 0; | |
3376 | interactive = 0; | |
3377 | close_me_head = NULL; | |
3378 | last_bg_pid = 0; | |
3379 | job_list = NULL; | |
3380 | last_jobid = 0; | |
3381 | ||
3382 | /* Initialize some more globals to non-zero values */ | |
3383 | set_cwd(); | |
d0fb80c3 | 3384 | #ifdef CONFIG_FEATURE_COMMAND_EDITING |
fe8c2806 WD |
3385 | cmdedit_set_initial_prompt(); |
3386 | #else | |
3387 | PS1 = NULL; | |
3388 | #endif | |
3389 | PS2 = "> "; | |
3390 | ||
3391 | /* initialize our shell local variables with the values | |
3392 | * currently living in the environment */ | |
3393 | if (e) { | |
3394 | for (; *e; e++) | |
3395 | set_local_var(*e, 2); /* without call putenv() */ | |
3396 | } | |
3397 | ||
3398 | last_return_code=EXIT_SUCCESS; | |
3399 | ||
3400 | ||
3401 | if (argv[0] && argv[0][0] == '-') { | |
3402 | debug_printf("\nsourcing /etc/profile\n"); | |
3403 | if ((input = fopen("/etc/profile", "r")) != NULL) { | |
3404 | mark_open(fileno(input)); | |
3405 | parse_file_outer(input); | |
3406 | mark_closed(fileno(input)); | |
3407 | fclose(input); | |
3408 | } | |
3409 | } | |
3410 | input=stdin; | |
3411 | ||
3412 | while ((opt = getopt(argc, argv, "c:xif")) > 0) { | |
3413 | switch (opt) { | |
3414 | case 'c': | |
3415 | { | |
3416 | global_argv = argv+optind; | |
3417 | global_argc = argc-optind; | |
3418 | opt = parse_string_outer(optarg, FLAG_PARSE_SEMICOLON); | |
3419 | goto final_return; | |
3420 | } | |
3421 | break; | |
3422 | case 'i': | |
3423 | interactive++; | |
3424 | break; | |
3425 | case 'f': | |
3426 | fake_mode++; | |
3427 | break; | |
3428 | default: | |
3429 | #ifndef BB_VER | |
3430 | fprintf(stderr, "Usage: sh [FILE]...\n" | |
3431 | " or: sh -c command [args]...\n\n"); | |
3432 | exit(EXIT_FAILURE); | |
3433 | #else | |
3434 | show_usage(); | |
3435 | #endif | |
3436 | } | |
3437 | } | |
3438 | /* A shell is interactive if the `-i' flag was given, or if all of | |
3439 | * the following conditions are met: | |
3440 | * no -c command | |
3441 | * no arguments remaining or the -s flag given | |
3442 | * standard input is a terminal | |
3443 | * standard output is a terminal | |
3444 | * Refer to Posix.2, the description of the `sh' utility. */ | |
3445 | if (argv[optind]==NULL && input==stdin && | |
3446 | isatty(fileno(stdin)) && isatty(fileno(stdout))) { | |
3447 | interactive++; | |
3448 | } | |
3449 | ||
3450 | debug_printf("\ninteractive=%d\n", interactive); | |
3451 | if (interactive) { | |
3452 | /* Looks like they want an interactive shell */ | |
8bde7f77 | 3453 | #ifndef CONFIG_FEATURE_SH_EXTRA_QUIET |
d0fb80c3 WD |
3454 | printf( "\n\n" BB_BANNER " hush - the humble shell v0.01 (testing)\n"); |
3455 | printf( "Enter 'help' for a list of built-in commands.\n\n"); | |
3456 | #endif | |
fe8c2806 WD |
3457 | setup_job_control(); |
3458 | } | |
3459 | ||
3460 | if (argv[optind]==NULL) { | |
3461 | opt=parse_file_outer(stdin); | |
3462 | goto final_return; | |
3463 | } | |
3464 | ||
3465 | debug_printf("\nrunning script '%s'\n", argv[optind]); | |
3466 | global_argv = argv+optind; | |
3467 | global_argc = argc-optind; | |
3468 | input = xfopen(argv[optind], "r"); | |
3469 | opt = parse_file_outer(input); | |
3470 | ||
d0fb80c3 | 3471 | #ifdef CONFIG_FEATURE_CLEAN_UP |
fe8c2806 WD |
3472 | fclose(input); |
3473 | if (cwd && cwd != unknown) | |
3474 | free((char*)cwd); | |
3475 | { | |
3476 | struct variables *cur, *tmp; | |
3477 | for(cur = top_vars; cur; cur = tmp) { | |
3478 | tmp = cur->next; | |
3479 | if (!cur->flg_read_only) { | |
3480 | free(cur->name); | |
3481 | free(cur->value); | |
3482 | free(cur); | |
3483 | } | |
3484 | } | |
3485 | } | |
3486 | #endif | |
3487 | ||
3488 | final_return: | |
3489 | return(opt?opt:last_return_code); | |
3490 | } | |
3491 | #endif | |
3492 | ||
3493 | static char *insert_var_value(char *inp) | |
a005f19e JH |
3494 | { |
3495 | return insert_var_value_sub(inp, 0); | |
3496 | } | |
3497 | ||
3498 | static char *insert_var_value_sub(char *inp, int tag_subst) | |
fe8c2806 WD |
3499 | { |
3500 | int res_str_len = 0; | |
3501 | int len; | |
3502 | int done = 0; | |
3503 | char *p, *p1, *res_str = NULL; | |
3504 | ||
3505 | while ((p = strchr(inp, SPECIAL_VAR_SYMBOL))) { | |
a005f19e | 3506 | /* check the beginning of the string for normal charachters */ |
fe8c2806 | 3507 | if (p != inp) { |
a005f19e | 3508 | /* copy any charachters to the result string */ |
fe8c2806 WD |
3509 | len = p - inp; |
3510 | res_str = xrealloc(res_str, (res_str_len + len)); | |
3511 | strncpy((res_str + res_str_len), inp, len); | |
3512 | res_str_len += len; | |
3513 | } | |
3514 | inp = ++p; | |
a005f19e | 3515 | /* find the ending marker */ |
fe8c2806 WD |
3516 | p = strchr(inp, SPECIAL_VAR_SYMBOL); |
3517 | *p = '\0'; | |
a005f19e | 3518 | /* look up the value to substitute */ |
fe8c2806 | 3519 | if ((p1 = lookup_param(inp))) { |
a005f19e JH |
3520 | if (tag_subst) |
3521 | len = res_str_len + strlen(p1) + 2; | |
3522 | else | |
3523 | len = res_str_len + strlen(p1); | |
fe8c2806 | 3524 | res_str = xrealloc(res_str, (1 + len)); |
a005f19e JH |
3525 | if (tag_subst) { |
3526 | /* | |
3527 | * copy the variable value to the result | |
3528 | * string | |
3529 | */ | |
3530 | strcpy((res_str + res_str_len + 1), p1); | |
3531 | ||
3532 | /* | |
3533 | * mark the replaced text to be accepted as | |
3534 | * is | |
3535 | */ | |
3536 | res_str[res_str_len] = SUBSTED_VAR_SYMBOL; | |
3537 | res_str[res_str_len + 1 + strlen(p1)] = | |
3538 | SUBSTED_VAR_SYMBOL; | |
3539 | } else | |
3540 | /* | |
3541 | * copy the variable value to the result | |
3542 | * string | |
3543 | */ | |
3544 | strcpy((res_str + res_str_len), p1); | |
3545 | ||
fe8c2806 WD |
3546 | res_str_len = len; |
3547 | } | |
3548 | *p = SPECIAL_VAR_SYMBOL; | |
3549 | inp = ++p; | |
3550 | done = 1; | |
3551 | } | |
3552 | if (done) { | |
3553 | res_str = xrealloc(res_str, (1 + res_str_len + strlen(inp))); | |
3554 | strcpy((res_str + res_str_len), inp); | |
3555 | while ((p = strchr(res_str, '\n'))) { | |
3556 | *p = ' '; | |
3557 | } | |
3558 | } | |
3559 | return (res_str == NULL) ? inp : res_str; | |
3560 | } | |
3561 | ||
3562 | static char **make_list_in(char **inp, char *name) | |
3563 | { | |
3564 | int len, i; | |
3565 | int name_len = strlen(name); | |
3566 | int n = 0; | |
3567 | char **list; | |
3568 | char *p1, *p2, *p3; | |
3569 | ||
3570 | /* create list of variable values */ | |
3571 | list = xmalloc(sizeof(*list)); | |
3572 | for (i = 0; inp[i]; i++) { | |
3573 | p3 = insert_var_value(inp[i]); | |
3574 | p1 = p3; | |
3575 | while (*p1) { | |
930e4254 | 3576 | if (*p1 == ' ') { |
fe8c2806 WD |
3577 | p1++; |
3578 | continue; | |
3579 | } | |
3580 | if ((p2 = strchr(p1, ' '))) { | |
3581 | len = p2 - p1; | |
3582 | } else { | |
3583 | len = strlen(p1); | |
3584 | p2 = p1 + len; | |
3585 | } | |
3586 | /* we use n + 2 in realloc for list,because we add | |
3587 | * new element and then we will add NULL element */ | |
3588 | list = xrealloc(list, sizeof(*list) * (n + 2)); | |
3589 | list[n] = xmalloc(2 + name_len + len); | |
3590 | strcpy(list[n], name); | |
3591 | strcat(list[n], "="); | |
3592 | strncat(list[n], p1, len); | |
3593 | list[n++][name_len + len + 1] = '\0'; | |
3594 | p1 = p2; | |
3595 | } | |
3596 | if (p3 != inp[i]) free(p3); | |
3597 | } | |
3598 | list[n] = NULL; | |
3599 | return list; | |
3600 | } | |
3601 | ||
fe9ca3d3 SW |
3602 | /* |
3603 | * Make new string for parser | |
3604 | * inp - array of argument strings to flatten | |
3605 | * nonnull - indicates argument was quoted when originally parsed | |
3606 | */ | |
3607 | static char *make_string(char **inp, int *nonnull) | |
fe8c2806 WD |
3608 | { |
3609 | char *p; | |
3610 | char *str = NULL; | |
3611 | int n; | |
3612 | int len = 2; | |
a005f19e JH |
3613 | char *noeval_str; |
3614 | int noeval = 0; | |
fe8c2806 | 3615 | |
a005f19e JH |
3616 | noeval_str = get_local_var("HUSH_NO_EVAL"); |
3617 | if (noeval_str != NULL && *noeval_str != '0' && *noeval_str != '\0') | |
3618 | noeval = 1; | |
fe8c2806 | 3619 | for (n = 0; inp[n]; n++) { |
a005f19e | 3620 | p = insert_var_value_sub(inp[n], noeval); |
fe9ca3d3 | 3621 | str = xrealloc(str, (len + strlen(p) + (2 * nonnull[n]))); |
fe8c2806 WD |
3622 | if (n) { |
3623 | strcat(str, " "); | |
3624 | } else { | |
3625 | *str = '\0'; | |
3626 | } | |
fe9ca3d3 SW |
3627 | if (nonnull[n]) |
3628 | strcat(str, "'"); | |
fe8c2806 | 3629 | strcat(str, p); |
fe9ca3d3 SW |
3630 | if (nonnull[n]) |
3631 | strcat(str, "'"); | |
fe8c2806 WD |
3632 | len = strlen(str) + 3; |
3633 | if (p != inp[n]) free(p); | |
3634 | } | |
3635 | len = strlen(str); | |
3636 | *(str + len) = '\n'; | |
3637 | *(str + len + 1) = '\0'; | |
3638 | return str; | |
3639 | } | |
3640 | ||
81473f67 | 3641 | #ifdef __U_BOOT__ |
199adb60 KP |
3642 | static int do_showvar(cmd_tbl_t *cmdtp, int flag, int argc, |
3643 | char * const argv[]) | |
81473f67 HS |
3644 | { |
3645 | int i, k; | |
3646 | int rcode = 0; | |
3647 | struct variables *cur; | |
3648 | ||
3649 | if (argc == 1) { /* Print all env variables */ | |
3650 | for (cur = top_vars; cur; cur = cur->next) { | |
3651 | printf ("%s=%s\n", cur->name, cur->value); | |
3652 | if (ctrlc ()) { | |
3653 | puts ("\n ** Abort\n"); | |
3654 | return 1; | |
3655 | } | |
3656 | } | |
3657 | return 0; | |
3658 | } | |
3659 | for (i = 1; i < argc; ++i) { /* print single env variables */ | |
3660 | char *name = argv[i]; | |
3661 | ||
3662 | k = -1; | |
3663 | for (cur = top_vars; cur; cur = cur->next) { | |
3664 | if(strcmp (cur->name, name) == 0) { | |
3665 | k = 0; | |
3666 | printf ("%s=%s\n", cur->name, cur->value); | |
3667 | } | |
3668 | if (ctrlc ()) { | |
3669 | puts ("\n ** Abort\n"); | |
3670 | return 1; | |
3671 | } | |
3672 | } | |
3673 | if (k < 0) { | |
3674 | printf ("## Error: \"%s\" not defined\n", name); | |
3675 | rcode ++; | |
3676 | } | |
3677 | } | |
3678 | return rcode; | |
3679 | } | |
3680 | ||
3681 | U_BOOT_CMD( | |
6d0f6bcf | 3682 | showvar, CONFIG_SYS_MAXARGS, 1, do_showvar, |
2fb2604d | 3683 | "print local hushshell variables", |
81473f67 HS |
3684 | "\n - print values of all hushshell variables\n" |
3685 | "showvar name ...\n" | |
a89c33db | 3686 | " - print value of hushshell variable 'name'" |
81473f67 HS |
3687 | ); |
3688 | ||
3689 | #endif | |
fe8c2806 | 3690 | /****************************************************************************/ |