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