aboutsummaryrefslogtreecommitdiff
path: root/shell
diff options
context:
space:
mode:
authorandersen <andersen@69ca8d6d-28ef-0310-b511-8ec308f3f277>2001-04-26 23:22:31 +0000
committerandersen <andersen@69ca8d6d-28ef-0310-b511-8ec308f3f277>2001-04-26 23:22:31 +0000
commitf19b424546f5377273ccce503e3dfefb81a34390 (patch)
tree00abde694cd250f56ed422db18db7cb2fdc4d296 /shell
parente5dedab443bcc72e957dcc77e1fab23129758f1a (diff)
downloadbusybox-w32-f19b424546f5377273ccce503e3dfefb81a34390.tar.gz
busybox-w32-f19b424546f5377273ccce503e3dfefb81a34390.tar.bz2
busybox-w32-f19b424546f5377273ccce503e3dfefb81a34390.zip
This is the initial checkin of Larry Doolittle's hush.c, using his
April 25, 2001 snapshot, adjusted a bit by me so it has cmdedit support. This checkin also removes sh.c. In the future sh.c will be a symlink to your shell of choice. For now, this symlink will default to pointing to lash.c (as in the past). If you change the symlink to point to hush.c, then thats what you will get. This symlink business is a temporary situation, which will be cleaned up Real Soon Now(tm). -Erik git-svn-id: svn://busybox.net/trunk/busybox@2466 69ca8d6d-28ef-0310-b511-8ec308f3f277
Diffstat (limited to 'shell')
-rw-r--r--shell/hush.c2191
1 files changed, 2191 insertions, 0 deletions
diff --git a/shell/hush.c b/shell/hush.c
new file mode 100644
index 000000000..f2a4ea410
--- /dev/null
+++ b/shell/hush.c
@@ -0,0 +1,2191 @@
1/* vi: set sw=4 ts=4: */
2/*
3 * sh.c -- a prototype Bourne shell grammar parser
4 * Intended to follow the original Thompson and Ritchie
5 * "small and simple is beautiful" philosophy, which
6 * incidentally is a good match to today's BusyBox.
7 *
8 * Copyright (C) 2000,2001 Larry Doolittle <larry@doolittle.boa.org>
9 *
10 * Credits:
11 * The parser routines proper are all original material, first
12 * written Dec 2000 and Jan 2001 by Larry Doolittle.
13 * The execution engine, the builtins, and much of the underlying
14 * support has been adapted from busybox-0.49pre's lash,
15 * which is Copyright (C) 2000 by Lineo, Inc., and
16 * written by Erik Andersen <andersen@lineo.com>, <andersee@debian.org>.
17 * That, in turn, is based in part on ladsh.c, by Michael K. Johnson and
18 * Erik W. Troan, which they placed in the public domain. I don't know
19 * how much of the Johnson/Troan code has survived the repeated rewrites.
20 * Other credits:
21 * simple_itoa() was lifted from boa-0.93.15
22 * b_addchr() derived from similar w_addchar function in glibc-2.2
23 * setup_redirect(), redirect_opt_num(), and big chunks of main()
24 * and many builtins derived from contributions by Erik Andersen
25 * miscellaneous bugfixes from Matt Kraai
26 *
27 * There are two big (and related) architecture differences between
28 * this parser and the lash parser. One is that this version is
29 * actually designed from the ground up to understand nearly all
30 * of the Bourne grammar. The second, consequential change is that
31 * the parser and input reader have been turned inside out. Now,
32 * the parser is in control, and asks for input as needed. The old
33 * way had the input reader in control, and it asked for parsing to
34 * take place as needed. The new way makes it much easier to properly
35 * handle the recursion implicit in the various substitutions, especially
36 * across continuation lines.
37 *
38 * Bash grammar not implemented: (how many of these were in original sh?)
39 * $@ (those sure look like weird quoting rules)
40 * $_
41 * ! negation operator for pipes
42 * &> and >& redirection of stdout+stderr
43 * Brace Expansion
44 * Tilde Expansion
45 * fancy forms of Parameter Expansion
46 * Arithmetic Expansion
47 * <(list) and >(list) Process Substitution
48 * reserved words: if, then, elif, else, fi, while, until, for,
49 * do, done, case
50 * Here Documents ( << word )
51 * Functions
52 * Major bugs:
53 * job handling woefully incomplete and buggy
54 * reserved word execution woefully incomplete and buggy
55 * incomplete reserved word sequence doesn't request more lines of input
56 * to-do:
57 * port selected bugfixes from post-0.49 busybox lash
58 * finish implementing reserved words
59 * handle children going into background
60 * clean up recognition of null pipes
61 * have builtin_exec set flag to avoid restore_redirects
62 * figure out if "echo foo}" is fixable
63 * check setting of global_argc and global_argv
64 * control-C handling, probably with longjmp
65 * VAR=value prefix for simple commands
66 * follow IFS rules more precisely, including update semantics
67 * write builtin_eval, builtin_ulimit, builtin_umask
68 * figure out what to do with backslash-newline
69 * explain why we use signal instead of sigaction
70 * propagate syntax errors, die on resource errors?
71 * continuation lines, both explicit and implicit - done?
72 * memory leak finding and plugging - done?
73 * more testing, especially quoting rules and redirection
74 * maybe change map[] to use 2-bit entries
75 * (eventually) remove all the printf's
76 * more integration with BusyBox: prompts, cmdedit, applets
77 *
78 * This program is free software; you can redistribute it and/or modify
79 * it under the terms of the GNU General Public License as published by
80 * the Free Software Foundation; either version 2 of the License, or
81 * (at your option) any later version.
82 *
83 * This program is distributed in the hope that it will be useful,
84 * but WITHOUT ANY WARRANTY; without even the implied warranty of
85 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
86 * General Public License for more details.
87 *
88 * You should have received a copy of the GNU General Public License
89 * along with this program; if not, write to the Free Software
90 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
91 */
92#include <ctype.h> /* isalpha, isdigit */
93#include <unistd.h> /* getpid */
94#include <stdlib.h> /* getenv, atoi */
95#include <string.h> /* strchr */
96#include <stdio.h> /* popen etc. */
97#include <glob.h> /* glob, of course */
98#include <stdarg.h> /* va_list */
99#include <errno.h>
100#include <fcntl.h>
101#include <getopt.h> /* should be pretty obvious */
102
103#include <sys/types.h>
104#include <sys/wait.h>
105#include <signal.h>
106
107/* #include <dmalloc.h> */
108/* #define DEBUG_SHELL */
109
110#ifdef BB_VER
111#include "busybox.h"
112#include "cmdedit.h"
113#else
114/* in place of #include "busybox.h"; much of this is indeed
115 * pasted in from the copy of busybox.h in busybox-0.49pre */
116
117#define xrealloc realloc
118#define applet_name "hush"
119#define shell_main main
120
121extern void *xmalloc(size_t size)
122{
123 void *ptr = malloc(size);
124
125 if (!ptr) {
126 fprintf(stderr, "memory_exhausted\n");
127 exit (EXIT_FAILURE);
128 }
129 return ptr;
130}
131
132extern void usage(const char *usage)
133{
134 fprintf(stderr, "Usage: %s\n", usage);
135 exit(EXIT_FAILURE);
136}
137
138static void verror_msg(const char *s, va_list p)
139{
140 fflush(stdout);
141 fprintf(stderr, "%s: ", applet_name);
142 vfprintf(stderr, s, p);
143 fflush(stderr);
144}
145
146extern void error_msg(const char *s, ...)
147{
148 va_list p;
149
150 va_start(p, s);
151 verror_msg(s, p);
152 va_end(p);
153}
154
155extern void error_msg_and_die(const char *s, ...)
156{
157 va_list p;
158
159 va_start(p, s);
160 verror_msg(s, p);
161 va_end(p);
162 exit(EXIT_FAILURE);
163}
164
165static void vperror_msg(const char *s, va_list p)
166{
167 fflush(stdout);
168 fprintf(stderr, "%s: ", applet_name);
169 if (s && *s) {
170 vfprintf(stderr, s, p);
171 fputs(": ", stderr);
172 }
173 fprintf(stderr, "%s\n", strerror(errno));
174 fflush(stderr);
175}
176
177extern void perror_msg(const char *s, ...)
178{
179 va_list p;
180
181 va_start(p, s);
182 vperror_msg(s, p);
183 va_end(p);
184}
185
186extern void perror_msg_and_die(const char *s, ...)
187{
188 va_list p;
189
190 va_start(p, s);
191 vperror_msg(s, p);
192 va_end(p);
193 exit(EXIT_FAILURE);
194}
195
196FILE *xfopen(const char *path, const char *mode)
197{
198 FILE *fp;
199 if ((fp = fopen(path, mode)) == NULL)
200 perror_msg_and_die(path);
201 return fp;
202}
203#endif /* of busybox.h replacement */
204
205typedef enum {
206 REDIRECT_INPUT = 1,
207 REDIRECT_OVERWRITE = 2,
208 REDIRECT_APPEND = 3,
209 REDIRECT_HEREIS = 4,
210 REDIRECT_IO = 5
211} redir_type;
212
213/* The descrip member of this structure is only used to make debugging
214 * output pretty */
215struct {int mode; int default_fd; char *descrip;} redir_table[] = {
216 { 0, 0, "()" },
217 { O_RDONLY, 0, "<" },
218 { O_CREAT|O_TRUNC|O_WRONLY, 1, ">" },
219 { O_CREAT|O_APPEND|O_WRONLY, 1, ">>" },
220 { O_RDONLY, -1, "<<" },
221 { O_RDWR, 1, "<>" }
222};
223
224typedef enum {
225 PIPE_SEQ = 1,
226 PIPE_AND = 2,
227 PIPE_OR = 3,
228 PIPE_BG = 4,
229} pipe_style;
230
231/* might eventually control execution */
232typedef enum {
233 RES_NONE = 0,
234 RES_IF = 1,
235 RES_THEN = 2,
236 RES_ELIF = 3,
237 RES_ELSE = 4,
238 RES_FI = 5,
239 RES_FOR = 6,
240 RES_WHILE = 7,
241 RES_UNTIL = 8,
242 RES_DO = 9,
243 RES_DONE = 10,
244 RES_XXXX = 11
245} reserved_style;
246#define FLAG_END (1<<RES_NONE)
247#define FLAG_IF (1<<RES_IF)
248#define FLAG_THEN (1<<RES_THEN)
249#define FLAG_ELIF (1<<RES_ELIF)
250#define FLAG_ELSE (1<<RES_ELSE)
251#define FLAG_FI (1<<RES_FI)
252#define FLAG_FOR (1<<RES_FOR)
253#define FLAG_WHILE (1<<RES_WHILE)
254#define FLAG_UNTIL (1<<RES_UNTIL)
255#define FLAG_DO (1<<RES_DO)
256#define FLAG_DONE (1<<RES_DONE)
257#define FLAG_START (1<<RES_XXXX)
258
259/* This holds pointers to the various results of parsing */
260struct p_context {
261 struct child_prog *child;
262 struct pipe *list_head;
263 struct pipe *pipe;
264 struct redir_struct *pending_redirect;
265 reserved_style w;
266 int old_flag; /* for figuring out valid reserved words */
267 struct p_context *stack;
268 /* How about quoting status? */
269};
270
271struct redir_struct {
272 redir_type type; /* type of redirection */
273 int fd; /* file descriptor being redirected */
274 int dup; /* -1, or file descriptor being duplicated */
275 struct redir_struct *next; /* pointer to the next redirect in the list */
276 glob_t word; /* *word.gl_pathv is the filename */
277};
278
279struct child_prog {
280 pid_t pid; /* 0 if exited */
281 char **argv; /* program name and arguments */
282 struct pipe *group; /* if non-NULL, first in group or subshell */
283 int subshell; /* flag, non-zero if group must be forked */
284 struct redir_struct *redirects; /* I/O redirections */
285 glob_t glob_result; /* result of parameter globbing */
286 int is_stopped; /* is the program currently running? */
287 struct pipe *family; /* pointer back to the child's parent pipe */
288};
289
290struct pipe {
291 int jobid; /* job number */
292 int num_progs; /* total number of programs in job */
293 int running_progs; /* number of programs running */
294 char *text; /* name of job */
295 char *cmdbuf; /* buffer various argv's point into */
296 pid_t pgrp; /* process group ID for the job */
297 struct child_prog *progs; /* array of commands in pipe */
298 struct pipe *next; /* to track background commands */
299 int stopped_progs; /* number of programs alive, but stopped */
300 int job_context; /* bitmask defining current context */
301 pipe_style followup; /* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */
302 reserved_style r_mode; /* supports if, for, while, until */
303 struct jobset *job_list;
304};
305
306struct jobset {
307 struct pipe *head; /* head of list of running jobs */
308 struct pipe *fg; /* current foreground job */
309};
310
311struct close_me {
312 int fd;
313 struct close_me *next;
314};
315
316/* globals, connect us to the outside world
317 * the first three support $?, $#, and $1 */
318char **global_argv;
319unsigned int global_argc;
320unsigned int last_return_code;
321extern char **environ; /* This is in <unistd.h>, but protected with __USE_GNU */
322
323/* Variables we export */
324unsigned int shell_context; /* Used in cmdedit.c to reset the
325 * context when someone hits ^C */
326
327/* "globals" within this file */
328static char *ifs=NULL;
329static char map[256];
330static int fake_mode=0;
331static int interactive=0;
332static struct close_me *close_me_head = NULL;
333static char *cwd;
334static struct jobset job_list = { NULL, NULL };
335static unsigned int last_bg_pid=0;
336static char *PS1;
337static char *PS2 = "> ";
338
339#define B_CHUNK (100)
340#define B_NOSPAC 1
341#define MAX_LINE 256 /* for cwd */
342#define MAX_READ 256 /* for builtin_read */
343
344typedef struct {
345 char *data;
346 int length;
347 int maxlen;
348 int quote;
349 int nonnull;
350} o_string;
351#define NULL_O_STRING {NULL,0,0,0,0}
352/* used for initialization:
353 o_string foo = NULL_O_STRING; */
354
355/* I can almost use ordinary FILE *. Is open_memstream() universally
356 * available? Where is it documented? */
357struct in_str {
358 const char *p;
359 int __promptme;
360 int promptmode;
361 FILE *file;
362 int (*get) (struct in_str *);
363 int (*peek) (struct in_str *);
364};
365#define b_getch(input) ((input)->get(input))
366#define b_peek(input) ((input)->peek(input))
367
368#define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
369
370struct built_in_command {
371 char *cmd; /* name */
372 char *descr; /* description */
373 int (*function) (struct child_prog *); /* function ptr */
374};
375
376/* belongs in busybox.h */
377static inline int max(int a, int b) {
378 return (a>b)?a:b;
379}
380
381/* This should be in utility.c */
382#ifdef DEBUG_SHELL
383static void debug_printf(const char *format, ...)
384{
385 va_list args;
386 va_start(args, format);
387 vfprintf(stderr, format, args);
388 va_end(args);
389}
390#else
391static void debug_printf(const char *format, ...) { }
392#endif
393#define final_printf debug_printf
394
395void __syntax(char *file, int line) {
396 fprintf(stderr,"syntax error %s:%d\n",file,line);
397}
398#define syntax() __syntax(__FILE__, __LINE__)
399
400/* Index of subroutines: */
401/* function prototypes for builtins */
402static int builtin_cd(struct child_prog *child);
403static int builtin_env(struct child_prog *child);
404static int builtin_exec(struct child_prog *child);
405static int builtin_exit(struct child_prog *child);
406static int builtin_export(struct child_prog *child);
407static int builtin_fg_bg(struct child_prog *child);
408static int builtin_help(struct child_prog *child);
409static int builtin_jobs(struct child_prog *child);
410static int builtin_pwd(struct child_prog *child);
411static int builtin_read(struct child_prog *child);
412static int builtin_shift(struct child_prog *child);
413static int builtin_source(struct child_prog *child);
414static int builtin_ulimit(struct child_prog *child);
415static int builtin_umask(struct child_prog *child);
416static int builtin_unset(struct child_prog *child);
417/* o_string manipulation: */
418static int b_check_space(o_string *o, int len);
419static int b_addchr(o_string *o, int ch);
420static void b_reset(o_string *o);
421static int b_addqchr(o_string *o, int ch, int quote);
422static int b_adduint(o_string *o, unsigned int i);
423/* in_str manipulations: */
424static int static_get(struct in_str *i);
425static int static_peek(struct in_str *i);
426static int file_get(struct in_str *i);
427static int file_peek(struct in_str *i);
428static void setup_file_in_str(struct in_str *i, FILE *f);
429static void setup_string_in_str(struct in_str *i, const char *s);
430/* close_me manipulations: */
431static void mark_open(int fd);
432static void mark_closed(int fd);
433static void close_all();
434/* "run" the final data structures: */
435static char *indenter(int i);
436static int run_list_test(struct pipe *head, int indent);
437static int run_pipe_test(struct pipe *pi, int indent);
438/* really run the final data structures: */
439static int setup_redirects(struct child_prog *prog, int squirrel[]);
440static int pipe_wait(struct pipe *pi);
441static int run_list_real(struct pipe *pi);
442static void pseudo_exec(struct child_prog *child) __attribute__ ((noreturn));
443static int run_pipe_real(struct pipe *pi);
444/* extended glob support: */
445static int globhack(const char *src, int flags, glob_t *pglob);
446static int glob_needed(const char *s);
447static int xglob(o_string *dest, int flags, glob_t *pglob);
448/* data structure manipulation: */
449static int setup_redirect(struct p_context *ctx, int fd, redir_type style, struct in_str *input);
450static void initialize_context(struct p_context *ctx);
451static int done_word(o_string *dest, struct p_context *ctx);
452static int done_command(struct p_context *ctx);
453static int done_pipe(struct p_context *ctx, pipe_style type);
454/* primary string parsing: */
455static int redirect_dup_num(struct in_str *input);
456static int redirect_opt_num(o_string *o);
457static int process_command_subs(o_string *dest, struct p_context *ctx, struct in_str *input, int subst_end);
458static int parse_group(o_string *dest, struct p_context *ctx, struct in_str *input, int ch);
459static void lookup_param(o_string *dest, struct p_context *ctx, o_string *src);
460static int handle_dollar(o_string *dest, struct p_context *ctx, struct in_str *input);
461static int parse_string(o_string *dest, struct p_context *ctx, const char *src);
462static int parse_stream(o_string *dest, struct p_context *ctx, struct in_str *input0, int end_trigger);
463/* setup: */
464static int parse_stream_outer(struct in_str *inp);
465static int parse_string_outer(const char *s);
466static int parse_file_outer(FILE *f);
467
468/* Table of built-in functions. They can be forked or not, depending on
469 * context: within pipes, they fork. As simple commands, they do not.
470 * When used in non-forking context, they can change global variables
471 * in the parent shell process. If forked, of course they can not.
472 * For example, 'unset foo | whatever' will parse and run, but foo will
473 * still be set at the end. */
474static struct built_in_command bltins[] = {
475 {"bg", "Resume a job in the background", builtin_fg_bg},
476 {"cd", "Change working directory", builtin_cd},
477 {"env", "Print all environment variables", builtin_env},
478 {"exec", "Exec command, replacing this shell with the exec'd process", builtin_exec},
479 {"exit", "Exit from shell()", builtin_exit},
480 {"export", "Set environment variable", builtin_export},
481 {"fg", "Bring job into the foreground", builtin_fg_bg},
482 {"jobs", "Lists the active jobs", builtin_jobs},
483 {"pwd", "Print current directory", builtin_pwd},
484 {"read", "Input environment variable", builtin_read},
485 {"shift", "Shift positional parameters", builtin_shift},
486 {"ulimit","Controls resource limits", builtin_ulimit},
487 {"umask","Sets file creation mask", builtin_umask},
488 {"unset", "Unset environment variable", builtin_unset},
489 {".", "Source-in and run commands in a file", builtin_source},
490 {"help", "List shell built-in commands", builtin_help},
491 {NULL, NULL, NULL}
492};
493
494/* built-in 'cd <path>' handler */
495static int builtin_cd(struct child_prog *child)
496{
497 char *newdir;
498 if (child->argv[1] == NULL)
499 newdir = getenv("HOME");
500 else
501 newdir = child->argv[1];
502 if (chdir(newdir)) {
503 printf("cd: %s: %s\n", newdir, strerror(errno));
504 return EXIT_FAILURE;
505 }
506 getcwd(cwd, sizeof(char)*MAX_LINE);
507 return EXIT_SUCCESS;
508}
509
510/* built-in 'env' handler */
511static int builtin_env(struct child_prog *dummy)
512{
513 char **e = environ;
514 if (e == NULL) return EXIT_FAILURE;
515 for (; *e; e++) {
516 puts(*e);
517 }
518 return EXIT_SUCCESS;
519}
520
521/* built-in 'exec' handler */
522static int builtin_exec(struct child_prog *child)
523{
524 if (child->argv[1] == NULL)
525 return EXIT_SUCCESS; /* Really? */
526 child->argv++;
527 pseudo_exec(child);
528 /* never returns */
529}
530
531/* built-in 'exit' handler */
532static int builtin_exit(struct child_prog *child)
533{
534 if (child->argv[1] == NULL)
535 exit(EXIT_SUCCESS);
536 exit (atoi(child->argv[1]));
537}
538
539/* built-in 'export VAR=value' handler */
540static int builtin_export(struct child_prog *child)
541{
542 int res;
543
544 if (child->argv[1] == NULL) {
545 return (builtin_env(child));
546 }
547 res = putenv(child->argv[1]);
548 if (res)
549 fprintf(stderr, "export: %s\n", strerror(errno));
550 return (res);
551}
552
553/* built-in 'fg' and 'bg' handler */
554static int builtin_fg_bg(struct child_prog *child)
555{
556 int i, jobNum;
557 struct pipe *job=NULL;
558
559 if (!child->argv[1] || child->argv[2]) {
560 error_msg("%s: exactly one argument is expected\n",
561 child->argv[0]);
562 return EXIT_FAILURE;
563 }
564
565 if (sscanf(child->argv[1], "%%%d", &jobNum) != 1) {
566 error_msg("%s: bad argument '%s'\n",
567 child->argv[0], child->argv[1]);
568 return EXIT_FAILURE;
569 }
570
571 for (job = child->family->job_list->head; job; job = job->next) {
572 if (job->jobid == jobNum) {
573 break;
574 }
575 }
576
577 if (!job) {
578 error_msg("%s: unknown job %d\n",
579 child->argv[0], jobNum);
580 return EXIT_FAILURE;
581 }
582
583 if (*child->argv[0] == 'f') {
584 /* Make this job the foreground job */
585 /* suppress messages when run from /linuxrc mag@sysgo.de */
586 if (tcsetpgrp(0, job->pgrp) && errno != ENOTTY)
587 perror_msg("tcsetpgrp");
588 child->family->job_list->fg = job;
589 }
590
591 /* Restart the processes in the job */
592 for (i = 0; i < job->num_progs; i++)
593 job->progs[i].is_stopped = 0;
594
595 kill(-job->pgrp, SIGCONT);
596
597 job->stopped_progs = 0;
598 return EXIT_SUCCESS;
599}
600
601/* built-in 'help' handler */
602static int builtin_help(struct child_prog *dummy)
603{
604 struct built_in_command *x;
605
606 printf("\nBuilt-in commands:\n");
607 printf("-------------------\n");
608 for (x = bltins; x->cmd; x++) {
609 if (x->descr==NULL)
610 continue;
611 printf("%s\t%s\n", x->cmd, x->descr);
612 }
613 printf("\n\n");
614 return EXIT_SUCCESS;
615}
616
617/* built-in 'jobs' handler */
618static int builtin_jobs(struct child_prog *child)
619{
620 struct pipe *job;
621 char *status_string;
622
623 for (job = child->family->job_list->head; job; job = job->next) {
624 if (job->running_progs == job->stopped_progs)
625 status_string = "Stopped";
626 else
627 status_string = "Running";
628 printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text);
629 }
630 return EXIT_SUCCESS;
631}
632
633
634/* built-in 'pwd' handler */
635static int builtin_pwd(struct child_prog *dummy)
636{
637 getcwd(cwd, MAX_LINE);
638 puts(cwd);
639 return EXIT_SUCCESS;
640}
641
642/* built-in 'read VAR' handler */
643static int builtin_read(struct child_prog *child)
644{
645 int res = 0, len, newlen;
646 char *s;
647 char string[MAX_READ];
648
649 if (child->argv[1]) {
650 /* argument (VAR) given: put "VAR=" into buffer */
651 strcpy(string, child->argv[1]);
652 len = strlen(string);
653 string[len++] = '=';
654 string[len] = '\0';
655 /* XXX would it be better to go through in_str? */
656 fgets(&string[len], sizeof(string) - len, stdin); /* read string */
657 newlen = strlen(string);
658 if(newlen > len)
659 string[--newlen] = '\0'; /* chomp trailing newline */
660 /*
661 ** string should now contain "VAR=<value>"
662 ** copy it (putenv() won't do that, so we must make sure
663 ** the string resides in a static buffer!)
664 */
665 res = -1;
666 if((s = strdup(string)))
667 res = putenv(s);
668 if (res)
669 fprintf(stderr, "read: %s\n", strerror(errno));
670 }
671 else
672 fgets(string, sizeof(string), stdin);
673
674 return (res);
675}
676
677/* Built-in 'shift' handler */
678static int builtin_shift(struct child_prog *child)
679{
680 int n=1;
681 if (child->argv[1]) {
682 n=atoi(child->argv[1]);
683 }
684 if (n>=0 && n<global_argc) {
685 /* XXX This probably breaks $0 */
686 global_argc -= n;
687 global_argv += n;
688 return EXIT_SUCCESS;
689 } else {
690 return EXIT_FAILURE;
691 }
692}
693
694/* Built-in '.' handler (read-in and execute commands from file) */
695static int builtin_source(struct child_prog *child)
696{
697 FILE *input;
698 int status;
699
700 if (child->argv[1] == NULL)
701 return EXIT_FAILURE;
702
703 /* XXX search through $PATH is missing */
704 input = fopen(child->argv[1], "r");
705 if (!input) {
706 fprintf(stderr, "Couldn't open file '%s'\n", child->argv[1]);
707 return EXIT_FAILURE;
708 }
709
710 /* Now run the file */
711 /* XXX argv and argc are broken; need to save old global_argv
712 * (pointer only is OK!) on this stack frame,
713 * set global_argv=child->argv+1, recurse, and restore. */
714 mark_open(fileno(input));
715 status = parse_file_outer(input);
716 mark_closed(fileno(input));
717 fclose(input);
718 return (status);
719}
720
721static int builtin_ulimit(struct child_prog *child)
722{
723 printf("builtin_ulimit not written\n");
724 return EXIT_FAILURE;
725}
726
727static int builtin_umask(struct child_prog *child)
728{
729 printf("builtin_umask not written\n");
730 return EXIT_FAILURE;
731}
732
733/* built-in 'unset VAR' handler */
734static int builtin_unset(struct child_prog *child)
735{
736 if (child->argv[1] == NULL) {
737 fprintf(stderr, "unset: parameter required.\n");
738 return EXIT_FAILURE;
739 }
740 unsetenv(child->argv[1]);
741 return EXIT_SUCCESS;
742}
743
744static int b_check_space(o_string *o, int len)
745{
746 /* It would be easy to drop a more restrictive policy
747 * in here, such as setting a maximum string length */
748 if (o->length + len > o->maxlen) {
749 char *old_data = o->data;
750 /* assert (data == NULL || o->maxlen != 0); */
751 o->maxlen += max(2*len, B_CHUNK);
752 o->data = realloc(o->data, 1 + o->maxlen);
753 if (o->data == NULL) {
754 free(old_data);
755 }
756 }
757 return o->data == NULL;
758}
759
760static int b_addchr(o_string *o, int ch)
761{
762 debug_printf("b_addchr: %c %d %p\n", ch, o->length, o);
763 if (b_check_space(o, 1)) return B_NOSPAC;
764 o->data[o->length] = ch;
765 o->length++;
766 o->data[o->length] = '\0';
767 return 0;
768}
769
770static void b_reset(o_string *o)
771{
772 o->length = 0;
773 o->nonnull = 0;
774 if (o->data != NULL) *o->data = '\0';
775}
776
777static void b_free(o_string *o)
778{
779 b_reset(o);
780 if (o->data != NULL) free(o->data);
781 o->data = NULL;
782 o->maxlen = 0;
783}
784
785/* My analysis of quoting semantics tells me that state information
786 * is associated with a destination, not a source.
787 */
788static int b_addqchr(o_string *o, int ch, int quote)
789{
790 if (quote && strchr("*?[\\",ch)) {
791 int rc;
792 rc = b_addchr(o, '\\');
793 if (rc) return rc;
794 }
795 return b_addchr(o, ch);
796}
797
798/* belongs in utility.c */
799char *simple_itoa(unsigned int i)
800{
801 /* 21 digits plus null terminator, good for 64-bit or smaller ints */
802 static char local[22];
803 char *p = &local[21];
804 *p-- = '\0';
805 do {
806 *p-- = '0' + i % 10;
807 i /= 10;
808 } while (i > 0);
809 return p + 1;
810}
811
812static int b_adduint(o_string *o, unsigned int i)
813{
814 int r;
815 char *p = simple_itoa(i);
816 /* no escape checking necessary */
817 do r=b_addchr(o, *p++); while (r==0 && *p);
818 return r;
819}
820
821static int static_get(struct in_str *i)
822{
823 int ch=*i->p++;
824 if (ch=='\0') return EOF;
825 return ch;
826}
827
828static int static_peek(struct in_str *i)
829{
830 return *i->p;
831}
832
833static inline void cmdedit_set_initial_prompt(void)
834{
835#ifdef BB_FEATURE_SH_SIMPLE_PROMPT
836 PS1 = NULL;
837#else
838 PS1 = getenv("PS1");
839 if(PS1==0)
840 PS1 = "\\w \\$ ";
841#endif
842}
843
844static inline void setup_prompt_string(int promptmode, char **prompt_str)
845{
846#ifdef BB_FEATURE_SH_SIMPLE_PROMPT
847 /* Set up the prompt */
848 if (promptmode == 1) {
849 if (PS1)
850 free(PS1);
851 PS1=xmalloc(strlen(cwd)+4);
852 sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ? "$ ":"# ");
853 *prompt_str = PS1;
854 } else {
855 *prompt_str = PS2;
856 }
857#else
858 *prompt_str = (promptmode==0)? PS1 : PS2;
859#endif
860}
861
862static void get_user_input(struct in_str *i)
863{
864 char *prompt_str;
865 static char the_command[MAX_LINE];
866
867 setup_prompt_string(i->promptmode, &prompt_str);
868#ifdef BB_FEATURE_COMMAND_EDITING
869 /*
870 ** enable command line editing only while a command line
871 ** is actually being read; otherwise, we'll end up bequeathing
872 ** atexit() handlers and other unwanted stuff to our
873 ** child processes (rob@sysgo.de)
874 */
875 cmdedit_read_input(prompt_str, the_command);
876 cmdedit_terminate();
877#else
878 fputs(prompt_str, stdout);
879 fflush(stdout);
880 the_command[0]=fgetc(i->file);
881 the_command[1]='\0';
882#endif
883 i->p = the_command;
884}
885
886/* This is the magic location that prints prompts
887 * and gets data back from the user */
888static int file_get(struct in_str *i)
889{
890 int ch;
891
892 ch = 0;
893 /* If there is data waiting, eat it up */
894 if (i->p && *i->p) {
895 ch=*i->p++;
896 } else {
897 /* need to double check i->file because we might be doing something
898 * more complicated by now, like sourcing or substituting. */
899 if (i->__promptme && interactive && i->file == stdin) {
900 get_user_input(i);
901 i->promptmode=2;
902 }
903 i->__promptme = 0;
904
905 if (i->p && *i->p) {
906 ch=*i->p++;
907 }
908 debug_printf("b_getch: got a %d\n", ch);
909 }
910 if (ch == '\n') i->__promptme=1;
911 return ch;
912}
913
914/* All the callers guarantee this routine will never be
915 * used right after a newline, so prompting is not needed.
916 */
917static int file_peek(struct in_str *i)
918{
919 if (i->p && *i->p) {
920 return *i->p;
921 } else {
922 static char buffer;
923 buffer = fgetc(i->file);
924 i->p = &buffer;
925 debug_printf("b_peek: got a %d\n", *i->p);
926 return *i->p;
927 }
928}
929
930static void setup_file_in_str(struct in_str *i, FILE *f)
931{
932 i->peek = file_peek;
933 i->get = file_get;
934 i->__promptme=1;
935 i->promptmode=1;
936 i->file = f;
937 i->p = NULL;
938}
939
940static void setup_string_in_str(struct in_str *i, const char *s)
941{
942 i->peek = static_peek;
943 i->get = static_get;
944 i->__promptme=1;
945 i->promptmode=1;
946 i->p = s;
947}
948
949static void mark_open(int fd)
950{
951 struct close_me *new = xmalloc(sizeof(struct close_me));
952 new->fd = fd;
953 new->next = close_me_head;
954 close_me_head = new;
955}
956
957static void mark_closed(int fd)
958{
959 struct close_me *tmp;
960 if (close_me_head == NULL || close_me_head->fd != fd)
961 error_msg_and_die("corrupt close_me");
962 tmp = close_me_head;
963 close_me_head = close_me_head->next;
964 free(tmp);
965}
966
967static void close_all()
968{
969 struct close_me *c;
970 for (c=close_me_head; c; c=c->next) {
971 close(c->fd);
972 }
973 close_me_head = NULL;
974}
975
976/* squirrel != NULL means we squirrel away copies of stdin, stdout,
977 * and stderr if they are redirected. */
978static int setup_redirects(struct child_prog *prog, int squirrel[])
979{
980 int openfd, mode;
981 struct redir_struct *redir;
982
983 for (redir=prog->redirects; redir; redir=redir->next) {
984 if (redir->dup == -1) {
985 mode=redir_table[redir->type].mode;
986 openfd = open(redir->word.gl_pathv[0], mode, 0666);
987 if (openfd < 0) {
988 /* this could get lost if stderr has been redirected, but
989 bash and ash both lose it as well (though zsh doesn't!) */
990 fprintf(stderr,"error opening %s: %s\n", redir->word.gl_pathv[0],
991 strerror(errno));
992 return 1;
993 }
994 } else {
995 openfd = redir->dup;
996 }
997
998 if (openfd != redir->fd) {
999 if (squirrel && redir->fd < 3) {
1000 squirrel[redir->fd] = dup(redir->fd);
1001 }
1002 dup2(openfd, redir->fd);
1003 close(openfd);
1004 }
1005 }
1006 return 0;
1007}
1008
1009static void restore_redirects(int squirrel[])
1010{
1011 int i, fd;
1012 for (i=0; i<3; i++) {
1013 fd = squirrel[i];
1014 if (fd != -1) {
1015 /* No error checking. I sure wouldn't know what
1016 * to do with an error if I found one! */
1017 dup2(fd, i);
1018 close(fd);
1019 }
1020 }
1021}
1022
1023/* XXX this definitely needs some more thought, work, and
1024 * cribbing from other shells */
1025static int pipe_wait(struct pipe *pi)
1026{
1027 int rcode=0, i, pid, running, status;
1028 running = pi->num_progs;
1029 while (running) {
1030 pid=waitpid(-1, &status, 0);
1031 if (pid < 0) perror_msg_and_die("waitpid");
1032 for (i=0; i < pi->num_progs; i++) {
1033 if (pi->progs[i].pid == pid) {
1034 if (i==pi->num_progs-1) rcode=WEXITSTATUS(status);
1035 pi->progs[i].pid = 0;
1036 running--;
1037 break;
1038 }
1039 }
1040 }
1041 return rcode;
1042}
1043
1044/* very simple version for testing */
1045static void pseudo_exec(struct child_prog *child)
1046{
1047 int rcode;
1048 struct built_in_command *x;
1049 if (child->argv) {
1050 /*
1051 * Check if the command matches any of the builtins.
1052 * Depending on context, this might be redundant. But it's
1053 * easier to waste a few CPU cycles than it is to figure out
1054 * if this is one of those cases.
1055 */
1056 for (x = bltins; x->cmd; x++) {
1057 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1058 debug_printf("builtin exec %s\n", child->argv[0]);
1059 exit(x->function(child));
1060 }
1061 }
1062 debug_printf("exec of %s\n",child->argv[0]);
1063 execvp(child->argv[0],child->argv);
1064 perror("execvp");
1065 exit(1);
1066 } else if (child->group) {
1067 debug_printf("runtime nesting to group\n");
1068 interactive=0; /* crucial!!!! */
1069 rcode = run_list_real(child->group);
1070 /* OK to leak memory by not calling run_list_test,
1071 * since this process is about to exit */
1072 exit(rcode);
1073 } else {
1074 /* Can happen. See what bash does with ">foo" by itself. */
1075 debug_printf("trying to pseudo_exec null command\n");
1076 exit(EXIT_SUCCESS);
1077 }
1078}
1079
1080/* run_pipe_real() starts all the jobs, but doesn't wait for anything
1081 * to finish. See pipe_wait().
1082 *
1083 * return code is normally -1, when the caller has to wait for children
1084 * to finish to determine the exit status of the pipe. If the pipe
1085 * is a simple builtin command, however, the action is done by the
1086 * time run_pipe_real returns, and the exit code is provided as the
1087 * return value.
1088 *
1089 * The input of the pipe is always stdin, the output is always
1090 * stdout. The outpipe[] mechanism in BusyBox-0.48 lash is bogus,
1091 * because it tries to avoid running the command substitution in
1092 * subshell, when that is in fact necessary. The subshell process
1093 * now has its stdout directed to the input of the appropriate pipe,
1094 * so this routine is noticeably simpler.
1095 */
1096static int run_pipe_real(struct pipe *pi)
1097{
1098 int i;
1099 int nextin, nextout;
1100 int pipefds[2]; /* pipefds[0] is for reading */
1101 struct child_prog *child;
1102 struct built_in_command *x;
1103
1104 nextin = 0;
1105 pi->pgrp = 0;
1106
1107 /* Check if this is a simple builtin (not part of a pipe).
1108 * Builtins within pipes have to fork anyway, and are handled in
1109 * pseudo_exec. "echo foo | read bar" doesn't work on bash, either.
1110 */
1111 if (pi->num_progs == 1 && pi->progs[0].argv != NULL) {
1112 child = & (pi->progs[0]);
1113 if (child->group && ! child->subshell) {
1114 int squirrel[] = {-1, -1, -1};
1115 int rcode;
1116 debug_printf("non-subshell grouping\n");
1117 setup_redirects(child, squirrel);
1118 /* XXX could we merge code with following builtin case,
1119 * by creating a pseudo builtin that calls run_list_real? */
1120 rcode = run_list_real(child->group);
1121 restore_redirects(squirrel);
1122 return rcode;
1123 }
1124 for (x = bltins; x->cmd; x++) {
1125 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1126 int squirrel[] = {-1, -1, -1};
1127 int rcode;
1128 debug_printf("builtin inline %s\n", child->argv[0]);
1129 /* XXX setup_redirects acts on file descriptors, not FILEs.
1130 * This is perfect for work that comes after exec().
1131 * Is it really safe for inline use? Experimentally,
1132 * things seem to work with glibc. */
1133 setup_redirects(child, squirrel);
1134 rcode = x->function(child);
1135 restore_redirects(squirrel);
1136 return rcode;
1137 }
1138 }
1139 }
1140
1141 for (i = 0; i < pi->num_progs; i++) {
1142 child = & (pi->progs[i]);
1143
1144 /* pipes are inserted between pairs of commands */
1145 if ((i + 1) < pi->num_progs) {
1146 if (pipe(pipefds)<0) perror_msg_and_die("pipe");
1147 nextout = pipefds[1];
1148 } else {
1149 nextout=1;
1150 pipefds[0] = -1;
1151 }
1152
1153 /* XXX test for failed fork()? */
1154 if (!(child->pid = fork())) {
1155 close_all();
1156
1157 if (nextin != 0) {
1158 dup2(nextin, 0);
1159 close(nextin);
1160 }
1161 if (nextout != 1) {
1162 dup2(nextout, 1);
1163 close(nextout);
1164 }
1165 if (pipefds[0]!=-1) {
1166 close(pipefds[0]); /* opposite end of our output pipe */
1167 }
1168
1169 /* Like bash, explicit redirects override pipes,
1170 * and the pipe fd is available for dup'ing. */
1171 setup_redirects(child,NULL);
1172
1173 pseudo_exec(child);
1174 }
1175 if (interactive) {
1176 /* Put our child in the process group whose leader is the
1177 * first process in this pipe. */
1178 if (pi->pgrp==0) {
1179 pi->pgrp = child->pid;
1180 }
1181 /* Don't check for errors. The child may be dead already,
1182 * in which case setpgid returns error code EACCES. */
1183 setpgid(child->pid, pi->pgrp);
1184 }
1185 /* In the non-interactive case, do nothing. Leave the children
1186 * with the process group that they inherited from us. */
1187
1188 if (nextin != 0)
1189 close(nextin);
1190 if (nextout != 1)
1191 close(nextout);
1192
1193 /* If there isn't another process, nextin is garbage
1194 but it doesn't matter */
1195 nextin = pipefds[0];
1196 }
1197 return -1;
1198}
1199
1200static int run_list_real(struct pipe *pi)
1201{
1202 int rcode=0;
1203 int if_code=0, next_if_code=0; /* need double-buffer to handle elif */
1204 reserved_style rmode=RES_NONE;
1205 for (;pi;pi=pi->next) {
1206 rmode = pi->r_mode;
1207 debug_printf("rmode=%d if_code=%d next_if_code=%d\n", rmode, if_code, next_if_code);
1208 if (rmode == RES_THEN || rmode == RES_ELSE) if_code = next_if_code;
1209 if (rmode == RES_THEN && if_code) continue;
1210 if (rmode == RES_ELSE && !if_code) continue;
1211 if (rmode == RES_ELIF && !if_code) continue;
1212 if (pi->num_progs == 0) break;
1213 rcode = run_pipe_real(pi);
1214 if (rcode!=-1) {
1215 /* We only ran a builtin: rcode was set by the return value
1216 * of run_pipe_real(), and we don't need to wait for anything. */
1217 } else if (pi->followup==PIPE_BG) {
1218 /* XXX check bash's behavior with nontrivial pipes */
1219 /* XXX compute jobid */
1220 /* XXX what does bash do with attempts to background builtins? */
1221 printf("[%d] %d\n", pi->jobid, pi->pgrp);
1222 last_bg_pid = pi->pgrp;
1223 rcode = EXIT_SUCCESS;
1224 } else {
1225 if (interactive) {
1226 /* move the new process group into the foreground */
1227 /* suppress messages when run from /linuxrc mag@sysgo.de */
1228 signal(SIGTTIN, SIG_IGN);
1229 signal(SIGTTOU, SIG_IGN);
1230 if (tcsetpgrp(0, pi->pgrp) && errno != ENOTTY)
1231 perror_msg("tcsetpgrp");
1232 rcode = pipe_wait(pi);
1233 if (tcsetpgrp(0, getpid()) && errno != ENOTTY)
1234 perror_msg("tcsetpgrp");
1235 signal(SIGTTIN, SIG_DFL);
1236 signal(SIGTTOU, SIG_DFL);
1237 } else {
1238 rcode = pipe_wait(pi);
1239 }
1240 }
1241 last_return_code=rcode;
1242 if ( rmode == RES_IF || rmode == RES_ELIF )
1243 next_if_code=rcode; /* can be overwritten a number of times */
1244 if ( (rcode==EXIT_SUCCESS && pi->followup==PIPE_OR) ||
1245 (rcode!=EXIT_SUCCESS && pi->followup==PIPE_AND) )
1246 return rcode; /* XXX broken if list is part of if/then/else */
1247 }
1248 return rcode;
1249}
1250
1251/* broken, of course, but OK for testing */
1252static char *indenter(int i)
1253{
1254 static char blanks[]=" ";
1255 return &blanks[sizeof(blanks)-i-1];
1256}
1257
1258/* return code is the exit status of the pipe */
1259static int run_pipe_test(struct pipe *pi, int indent)
1260{
1261 char **p;
1262 struct child_prog *child;
1263 struct redir_struct *r, *rnext;
1264 int a, i, ret_code=0;
1265 char *ind = indenter(indent);
1266 final_printf("%s run pipe: (pid %d)\n",ind,getpid());
1267 for (i=0; i<pi->num_progs; i++) {
1268 child = &pi->progs[i];
1269 final_printf("%s command %d:\n",ind,i);
1270 if (child->argv) {
1271 for (a=0,p=child->argv; *p; a++,p++) {
1272 final_printf("%s argv[%d] = %s\n",ind,a,*p);
1273 }
1274 globfree(&child->glob_result);
1275 child->argv=NULL;
1276 } else if (child->group) {
1277 final_printf("%s begin group (subshell:%d)\n",ind, child->subshell);
1278 ret_code = run_list_test(child->group,indent+3);
1279 final_printf("%s end group\n",ind);
1280 } else {
1281 final_printf("%s (nil)\n",ind);
1282 }
1283 for (r=child->redirects; r; r=rnext) {
1284 final_printf("%s redirect %d%s", ind, r->fd, redir_table[r->type].descrip);
1285 if (r->dup == -1) {
1286 final_printf(" %s\n", *r->word.gl_pathv);
1287 globfree(&r->word);
1288 } else {
1289 final_printf("&%d\n", r->dup);
1290 }
1291 rnext=r->next;
1292 free(r);
1293 }
1294 child->redirects=NULL;
1295 }
1296 free(pi->progs); /* children are an array, they get freed all at once */
1297 pi->progs=NULL;
1298 return ret_code;
1299}
1300
1301static int run_list_test(struct pipe *head, int indent)
1302{
1303 int rcode=0; /* if list has no members */
1304 struct pipe *pi, *next;
1305 char *ind = indenter(indent);
1306 for (pi=head; pi; pi=next) {
1307 if (pi->num_progs == 0) break;
1308 final_printf("%s pipe reserved mode %d\n", ind, pi->r_mode);
1309 rcode = run_pipe_test(pi, indent);
1310 final_printf("%s pipe followup code %d\n", ind, pi->followup);
1311 next=pi->next;
1312 pi->next=NULL;
1313 free(pi);
1314 }
1315 return rcode;
1316}
1317
1318/* Select which version we will use */
1319static int run_list(struct pipe *pi)
1320{
1321 int rcode=0;
1322 if (fake_mode==0) {
1323 rcode = run_list_real(pi);
1324 }
1325 /* run_list_test has the side effect of clearing memory
1326 * In the long run that function can be merged with run_list_real,
1327 * but doing that now would hobble the debugging effort. */
1328 run_list_test(pi,0);
1329 return rcode;
1330}
1331
1332/* The API for glob is arguably broken. This routine pushes a non-matching
1333 * string into the output structure, removing non-backslashed backslashes.
1334 * If someone can prove me wrong, by performing this function within the
1335 * original glob(3) api, feel free to rewrite this routine into oblivion.
1336 * Return code (0 vs. GLOB_NOSPACE) matches glob(3).
1337 * XXX broken if the last character is '\\', check that before calling.
1338 */
1339static int globhack(const char *src, int flags, glob_t *pglob)
1340{
1341 int cnt, pathc;
1342 const char *s;
1343 char *dest;
1344 for (cnt=1, s=src; *s; s++) {
1345 if (*s == '\\') s++;
1346 cnt++;
1347 }
1348 dest = malloc(cnt);
1349 if (!dest) return GLOB_NOSPACE;
1350 if (!(flags & GLOB_APPEND)) {
1351 pglob->gl_pathv=NULL;
1352 pglob->gl_pathc=0;
1353 pglob->gl_offs=0;
1354 pglob->gl_offs=0;
1355 }
1356 pathc = ++pglob->gl_pathc;
1357 pglob->gl_pathv = realloc(pglob->gl_pathv, (pathc+1)*sizeof(*pglob->gl_pathv));
1358 if (pglob->gl_pathv == NULL) return GLOB_NOSPACE;
1359 pglob->gl_pathv[pathc-1]=dest;
1360 pglob->gl_pathv[pathc]=NULL;
1361 for (s=src; *s; s++, dest++) {
1362 if (*s == '\\') s++;
1363 *dest = *s;
1364 }
1365 *dest='\0';
1366 return 0;
1367}
1368
1369/* XXX broken if the last character is '\\', check that before calling */
1370static int glob_needed(const char *s)
1371{
1372 for (; *s; s++) {
1373 if (*s == '\\') s++;
1374 if (strchr("*[?",*s)) return 1;
1375 }
1376 return 0;
1377}
1378
1379#if 0
1380static void globprint(glob_t *pglob)
1381{
1382 int i;
1383 debug_printf("glob_t at %p:\n", pglob);
1384 debug_printf(" gl_pathc=%d gl_pathv=%p gl_offs=%d gl_flags=%d\n",
1385 pglob->gl_pathc, pglob->gl_pathv, pglob->gl_offs, pglob->gl_flags);
1386 for (i=0; i<pglob->gl_pathc; i++)
1387 debug_printf("pglob->gl_pathv[%d] = %p = %s\n", i,
1388 pglob->gl_pathv[i], pglob->gl_pathv[i]);
1389}
1390#endif
1391
1392static int xglob(o_string *dest, int flags, glob_t *pglob)
1393{
1394 int gr;
1395
1396 /* short-circuit for null word */
1397 /* we can code this better when the debug_printf's are gone */
1398 if (dest->length == 0) {
1399 if (dest->nonnull) {
1400 /* bash man page calls this an "explicit" null */
1401 gr = globhack(dest->data, flags, pglob);
1402 debug_printf("globhack returned %d\n",gr);
1403 } else {
1404 return 0;
1405 }
1406 } else if (glob_needed(dest->data)) {
1407 gr = glob(dest->data, flags, NULL, pglob);
1408 debug_printf("glob returned %d\n",gr);
1409 if (gr == GLOB_NOMATCH) {
1410 /* quote removal, or more accurately, backslash removal */
1411 gr = globhack(dest->data, flags, pglob);
1412 debug_printf("globhack returned %d\n",gr);
1413 }
1414 } else {
1415 gr = globhack(dest->data, flags, pglob);
1416 debug_printf("globhack returned %d\n",gr);
1417 }
1418 if (gr == GLOB_NOSPACE) {
1419 fprintf(stderr,"out of memory during glob\n");
1420 exit(1);
1421 }
1422 if (gr != 0) { /* GLOB_ABORTED ? */
1423 fprintf(stderr,"glob(3) error %d\n",gr);
1424 }
1425 /* globprint(glob_target); */
1426 return gr;
1427}
1428
1429/* the src parameter allows us to peek forward to a possible &n syntax
1430 * for file descriptor duplication, e.g., "2>&1".
1431 * Return code is 0 normally, 1 if a syntax error is detected in src.
1432 * Resource errors (in xmalloc) cause the process to exit */
1433static int setup_redirect(struct p_context *ctx, int fd, redir_type style,
1434 struct in_str *input)
1435{
1436 struct child_prog *child=ctx->child;
1437 struct redir_struct *redir = child->redirects;
1438 struct redir_struct *last_redir=NULL;
1439
1440 /* Create a new redir_struct and drop it onto the end of the linked list */
1441 while(redir) {
1442 last_redir=redir;
1443 redir=redir->next;
1444 }
1445 redir = xmalloc(sizeof(struct redir_struct));
1446 redir->next=NULL;
1447 if (last_redir) {
1448 last_redir->next=redir;
1449 } else {
1450 child->redirects=redir;
1451 }
1452
1453 redir->type=style;
1454 redir->fd= (fd==-1) ? redir_table[style].default_fd : fd ;
1455
1456 debug_printf("Redirect type %d%s\n", redir->fd, redir_table[style].descrip);
1457
1458 /* Check for a '2>&1' type redirect */
1459 redir->dup = redirect_dup_num(input);
1460 if (redir->dup == -2) return 1; /* syntax error */
1461 if (redir->dup != -1) {
1462 /* Erik had a check here that the file descriptor in question
1463 * is legit; I postpone that to "run time" */
1464 debug_printf("Duplicating redirect '%d>&%d'\n", redir->fd, redir->dup);
1465 } else {
1466 /* We do _not_ try to open the file that src points to,
1467 * since we need to return and let src be expanded first.
1468 * Set ctx->pending_redirect, so we know what to do at the
1469 * end of the next parsed word.
1470 */
1471 ctx->pending_redirect = redir;
1472 }
1473 return 0;
1474}
1475
1476struct pipe *new_pipe(void) {
1477 struct pipe *pi;
1478 pi = xmalloc(sizeof(struct pipe));
1479 pi->num_progs = 0;
1480 pi->progs = NULL;
1481 pi->next = NULL;
1482 pi->followup = 0; /* invalid */
1483 return pi;
1484}
1485
1486static void initialize_context(struct p_context *ctx)
1487{
1488 ctx->pipe=NULL;
1489 ctx->pending_redirect=NULL;
1490 ctx->child=NULL;
1491 ctx->list_head=new_pipe();
1492 ctx->pipe=ctx->list_head;
1493 ctx->w=RES_NONE;
1494 ctx->stack=NULL;
1495 done_command(ctx); /* creates the memory for working child */
1496}
1497
1498/* normal return is 0
1499 * if a reserved word is found, and processed, return 1
1500 * should handle if, then, elif, else, fi, for, while, until, do, done.
1501 * case, function, and select are obnoxious, save those for later.
1502 */
1503int reserved_word(o_string *dest, struct p_context *ctx)
1504{
1505 struct reserved_combo {
1506 char *literal;
1507 int code;
1508 long flag;
1509 };
1510 /* Mostly a list of accepted follow-up reserved words.
1511 * FLAG_END means we are done with the sequence, and are ready
1512 * to turn the compound list into a command.
1513 * FLAG_START means the word must start a new compound list.
1514 */
1515 static struct reserved_combo reserved_list[] = {
1516 { "if", RES_IF, FLAG_THEN | FLAG_START },
1517 { "then", RES_THEN, FLAG_ELIF | FLAG_ELSE | FLAG_FI },
1518 { "elif", RES_ELIF, FLAG_THEN },
1519 { "else", RES_ELSE, FLAG_FI },
1520 { "fi", RES_FI, FLAG_END },
1521 { "for", RES_FOR, FLAG_DO | FLAG_START },
1522 { "while", RES_WHILE, FLAG_DO | FLAG_START },
1523 { "until", RES_UNTIL, FLAG_DO | FLAG_START },
1524 { "do", RES_DO, FLAG_DONE },
1525 { "done", RES_DONE, FLAG_END }
1526 };
1527 struct reserved_combo *r;
1528 for (r=reserved_list;
1529#define NRES sizeof(reserved_list)/sizeof(struct reserved_combo)
1530 r<reserved_list+NRES; r++) {
1531 if (strcmp(dest->data, r->literal) == 0) {
1532 debug_printf("found reserved word %s, code %d\n",r->literal,r->code);
1533 if (r->flag & FLAG_START) {
1534 struct p_context *new = xmalloc(sizeof(struct p_context));
1535 debug_printf("push stack\n");
1536 *new = *ctx; /* physical copy */
1537 initialize_context(ctx);
1538 ctx->stack=new;
1539 } else if ( ctx->w == RES_NONE || ! (ctx->old_flag & (1<<r->code))) {
1540 syntax(); /* XXX how do we get out? */
1541 }
1542 ctx->w=r->code;
1543 ctx->old_flag = r->flag;
1544 if (ctx->old_flag & FLAG_END) {
1545 struct p_context *old;
1546 debug_printf("pop stack\n");
1547 old = ctx->stack;
1548 old->child->group = ctx->list_head;
1549 *ctx = *old; /* physical copy */
1550 free(old);
1551 ctx->w=RES_NONE;
1552 }
1553 b_reset (dest);
1554 return 1;
1555 }
1556 }
1557 return 0;
1558}
1559
1560/* normal return is 0.
1561 * Syntax or xglob errors return 1. */
1562static int done_word(o_string *dest, struct p_context *ctx)
1563{
1564 struct child_prog *child=ctx->child;
1565 glob_t *glob_target;
1566 int gr, flags = 0;
1567
1568 debug_printf("done_word: %s %p\n", dest->data, child);
1569 if (dest->length == 0 && !dest->nonnull) {
1570 debug_printf(" true null, ignored\n");
1571 return 0;
1572 }
1573 if (ctx->pending_redirect) {
1574 glob_target = &ctx->pending_redirect->word;
1575 } else {
1576 if (child->group) {
1577 syntax();
1578 return 1; /* syntax error, groups and arglists don't mix */
1579 }
1580 if (!child->argv) {
1581 debug_printf("checking %s for reserved-ness\n",dest->data);
1582 if (reserved_word(dest,ctx)) return 0;
1583 }
1584 glob_target = &child->glob_result;
1585 if (child->argv) flags |= GLOB_APPEND;
1586 }
1587 gr = xglob(dest, flags, glob_target);
1588 if (gr != 0) return 1;
1589
1590 b_reset(dest);
1591 if (ctx->pending_redirect) {
1592 ctx->pending_redirect=NULL;
1593 if (glob_target->gl_pathc != 1) {
1594 fprintf(stderr, "ambiguous redirect\n");
1595 return 1;
1596 }
1597 } else {
1598 child->argv = glob_target->gl_pathv;
1599 }
1600 return 0;
1601}
1602
1603/* The only possible error here is out of memory, in which case
1604 * xmalloc exits. */
1605static int done_command(struct p_context *ctx)
1606{
1607 /* The child is really already in the pipe structure, so
1608 * advance the pipe counter and make a new, null child.
1609 * Only real trickiness here is that the uncommitted
1610 * child structure, to which ctx->child points, is not
1611 * counted in pi->num_progs. */
1612 struct pipe *pi=ctx->pipe;
1613 struct child_prog *prog=ctx->child;
1614
1615 if (prog && prog->group == NULL
1616 && prog->argv == NULL
1617 && prog->redirects == NULL) {
1618 debug_printf("done_command: skipping null command\n");
1619 return 0;
1620 } else if (prog) {
1621 pi->num_progs++;
1622 debug_printf("done_command: num_progs incremented to %d\n",pi->num_progs);
1623 } else {
1624 debug_printf("done_command: initializing\n");
1625 }
1626 pi->progs = xrealloc(pi->progs, sizeof(*pi->progs) * (pi->num_progs+1));
1627
1628 prog = pi->progs + pi->num_progs;
1629 prog->redirects = NULL;
1630 prog->argv = NULL;
1631 prog->is_stopped = 0;
1632 prog->group = NULL;
1633 prog->glob_result.gl_pathv = NULL;
1634 prog->family = pi;
1635
1636 ctx->child=prog;
1637 /* but ctx->pipe and ctx->list_head remain unchanged */
1638 return 0;
1639}
1640
1641static int done_pipe(struct p_context *ctx, pipe_style type)
1642{
1643 struct pipe *new_p;
1644 done_command(ctx); /* implicit closure of previous command */
1645 debug_printf("done_pipe, type %d\n", type);
1646 ctx->pipe->followup = type;
1647 ctx->pipe->r_mode = ctx->w;
1648 new_p=new_pipe();
1649 ctx->pipe->next = new_p;
1650 ctx->pipe = new_p;
1651 ctx->child = NULL;
1652 done_command(ctx); /* set up new pipe to accept commands */
1653 return 0;
1654}
1655
1656/* peek ahead in the in_str to find out if we have a "&n" construct,
1657 * as in "2>&1", that represents duplicating a file descriptor.
1658 * returns either -2 (syntax error), -1 (no &), or the number found.
1659 */
1660static int redirect_dup_num(struct in_str *input)
1661{
1662 int ch, d=0, ok=0;
1663 ch = b_peek(input);
1664 if (ch != '&') return -1;
1665
1666 b_getch(input); /* get the & */
1667 while (ch=b_peek(input),isdigit(ch)) {
1668 d = d*10+(ch-'0');
1669 ok=1;
1670 b_getch(input);
1671 }
1672 if (ok) return d;
1673
1674 fprintf(stderr, "ambiguous redirect\n");
1675 return -2;
1676}
1677
1678/* If a redirect is immediately preceded by a number, that number is
1679 * supposed to tell which file descriptor to redirect. This routine
1680 * looks for such preceding numbers. In an ideal world this routine
1681 * needs to handle all the following classes of redirects...
1682 * echo 2>foo # redirects fd 2 to file "foo", nothing passed to echo
1683 * echo 49>foo # redirects fd 49 to file "foo", nothing passed to echo
1684 * echo -2>foo # redirects fd 1 to file "foo", "-2" passed to echo
1685 * echo 49x>foo # redirects fd 1 to file "foo", "49x" passed to echo
1686 * A -1 output from this program means no valid number was found, so the
1687 * caller should use the appropriate default for this redirection.
1688 */
1689static int redirect_opt_num(o_string *o)
1690{
1691 int num;
1692
1693 if (o->length==0) return -1;
1694 for(num=0; num<o->length; num++) {
1695 if (!isdigit(*(o->data+num))) {
1696 return -1;
1697 }
1698 }
1699 /* reuse num (and save an int) */
1700 num=atoi(o->data);
1701 b_reset(o);
1702 return num;
1703}
1704
1705FILE *generate_stream_from_list(struct pipe *head)
1706{
1707 FILE *pf;
1708#if 1
1709 int pid, channel[2];
1710 if (pipe(channel)<0) perror_msg_and_die("pipe");
1711 pid=fork();
1712 if (pid<0) {
1713 perror_msg_and_die("fork");
1714 } else if (pid==0) {
1715 close(channel[0]);
1716 if (channel[1] != 1) {
1717 dup2(channel[1],1);
1718 close(channel[1]);
1719 }
1720#if 0
1721#define SURROGATE "surrogate response"
1722 write(1,SURROGATE,sizeof(SURROGATE));
1723 exit(run_list(head));
1724#else
1725 exit(run_list_real(head)); /* leaks memory */
1726#endif
1727 }
1728 debug_printf("forked child %d\n",pid);
1729 close(channel[1]);
1730 pf = fdopen(channel[0],"r");
1731 debug_printf("pipe on FILE *%p\n",pf);
1732#else
1733 run_list_test(head,0);
1734 pf=popen("echo surrogate response","r");
1735 debug_printf("started fake pipe on FILE *%p\n",pf);
1736#endif
1737 return pf;
1738}
1739
1740/* this version hacked for testing purposes */
1741/* return code is exit status of the process that is run. */
1742static int process_command_subs(o_string *dest, struct p_context *ctx, struct in_str *input, int subst_end)
1743{
1744 int retcode;
1745 o_string result=NULL_O_STRING;
1746 struct p_context inner;
1747 FILE *p;
1748 struct in_str pipe_str;
1749 initialize_context(&inner);
1750
1751 /* recursion to generate command */
1752 retcode = parse_stream(&result, &inner, input, subst_end);
1753 if (retcode != 0) return retcode; /* syntax error or EOF */
1754 done_word(&result, &inner);
1755 done_pipe(&inner, PIPE_SEQ);
1756 b_free(&result);
1757
1758 p=generate_stream_from_list(inner.list_head);
1759 if (p==NULL) return 1;
1760 mark_open(fileno(p));
1761 setup_file_in_str(&pipe_str, p);
1762
1763 /* now send results of command back into original context */
1764 retcode = parse_stream(dest, ctx, &pipe_str, '\0');
1765 /* XXX In case of a syntax error, should we try to kill the child?
1766 * That would be tough to do right, so just read until EOF. */
1767 if (retcode == 1) {
1768 while (b_getch(&pipe_str)!=EOF) { /* discard */ };
1769 }
1770
1771 debug_printf("done reading from pipe, pclose()ing\n");
1772 /* This is the step that wait()s for the child. Should be pretty
1773 * safe, since we just read an EOF from its stdout. We could try
1774 * to better, by using wait(), and keeping track of background jobs
1775 * at the same time. That would be a lot of work, and contrary
1776 * to the KISS philosophy of this program. */
1777 mark_closed(fileno(p));
1778 retcode=pclose(p);
1779 debug_printf("pclosed, retcode=%d\n",retcode);
1780 /* XXX this process fails to trim a single trailing newline */
1781 return retcode;
1782}
1783
1784static int parse_group(o_string *dest, struct p_context *ctx,
1785 struct in_str *input, int ch)
1786{
1787 int rcode, endch=0;
1788 struct p_context sub;
1789 struct child_prog *child = ctx->child;
1790 if (child->argv) {
1791 syntax();
1792 return 1; /* syntax error, groups and arglists don't mix */
1793 }
1794 initialize_context(&sub);
1795 switch(ch) {
1796 case '(': endch=')'; child->subshell=1; break;
1797 case '{': endch='}'; break;
1798 default: syntax(); /* really logic error */
1799 }
1800 rcode=parse_stream(dest,&sub,input,endch);
1801 done_word(dest,&sub); /* finish off the final word in the subcontext */
1802 done_pipe(&sub, PIPE_SEQ); /* and the final command there, too */
1803 child->group = sub.list_head;
1804 return rcode;
1805 /* child remains "open", available for possible redirects */
1806}
1807
1808/* basically useful version until someone wants to get fancier,
1809 * see the bash man page under "Parameter Expansion" */
1810static void lookup_param(o_string *dest, struct p_context *ctx, o_string *src)
1811{
1812 const char *p=NULL;
1813 if (src->data) p = getenv(src->data);
1814 if (p) parse_string(dest, ctx, p); /* recursion */
1815 b_free(src);
1816}
1817
1818/* return code: 0 for OK, 1 for syntax error */
1819static int handle_dollar(o_string *dest, struct p_context *ctx, struct in_str *input)
1820{
1821 int i, advance=0;
1822 o_string alt=NULL_O_STRING;
1823 char sep[]=" ";
1824 int ch = input->peek(input); /* first character after the $ */
1825 debug_printf("handle_dollar: ch=%c\n",ch);
1826 if (isalpha(ch)) {
1827 while(ch=b_peek(input),isalnum(ch) || ch=='_') {
1828 b_getch(input);
1829 b_addchr(&alt,ch);
1830 }
1831 lookup_param(dest, ctx, &alt);
1832 } else if (isdigit(ch)) {
1833 i = ch-'0'; /* XXX is $0 special? */
1834 if (i<global_argc) {
1835 parse_string(dest, ctx, global_argv[i]); /* recursion */
1836 }
1837 advance = 1;
1838 } else switch (ch) {
1839 case '$':
1840 b_adduint(dest,getpid());
1841 advance = 1;
1842 break;
1843 case '!':
1844 if (last_bg_pid > 0) b_adduint(dest, last_bg_pid);
1845 advance = 1;
1846 break;
1847 case '?':
1848 b_adduint(dest,last_return_code);
1849 advance = 1;
1850 break;
1851 case '#':
1852 b_adduint(dest,global_argc ? global_argc-1 : 0);
1853 advance = 1;
1854 break;
1855 case '{':
1856 b_getch(input);
1857 /* XXX maybe someone will try to escape the '}' */
1858 while(ch=b_getch(input),ch!=EOF && ch!='}') {
1859 b_addchr(&alt,ch);
1860 }
1861 if (ch != '}') {
1862 syntax();
1863 return 1;
1864 }
1865 lookup_param(dest, ctx, &alt);
1866 break;
1867 case '(':
1868 process_command_subs(dest, ctx, input, ')');
1869 break;
1870 case '*':
1871 sep[0]=ifs[0];
1872 for (i=1; i<global_argc; i++) {
1873 parse_string(dest, ctx, global_argv[i]);
1874 if (i+1 < global_argc) parse_string(dest, ctx, sep);
1875 }
1876 break;
1877 case '@':
1878 case '-':
1879 case '_':
1880 /* still unhandled, but should be eventually */
1881 fprintf(stderr,"unhandled syntax: $%c\n",ch);
1882 return 1;
1883 break;
1884 default:
1885 b_addqchr(dest,'$',dest->quote);
1886 }
1887 /* Eat the character if the flag was set. If the compiler
1888 * is smart enough, we could substitute "b_getch(input);"
1889 * for all the "advance = 1;" above, and also end up with
1890 * a nice size-optimized program. Hah! That'll be the day.
1891 */
1892 if (advance) b_getch(input);
1893 return 0;
1894}
1895
1896int parse_string(o_string *dest, struct p_context *ctx, const char *src)
1897{
1898 struct in_str foo;
1899 setup_string_in_str(&foo, src);
1900 return parse_stream(dest, ctx, &foo, '\0');
1901}
1902
1903/* return code is 0 for normal exit, 1 for syntax error */
1904int parse_stream(o_string *dest, struct p_context *ctx,
1905 struct in_str *input, int end_trigger)
1906{
1907 unsigned int ch, m;
1908 int redir_fd;
1909 redir_type redir_style;
1910 int next;
1911
1912 /* Only double-quote state is handled in the state variable dest->quote.
1913 * A single-quote triggers a bypass of the main loop until its mate is
1914 * found. When recursing, quote state is passed in via dest->quote. */
1915
1916 debug_printf("parse_stream, end_trigger=%d\n",end_trigger);
1917 while ((ch=b_getch(input))!=EOF) {
1918 m = map[ch];
1919 next = (ch == '\n') ? 0 : b_peek(input);
1920 debug_printf("parse_stream: ch=%c (%d) m=%d quote=%d\n",
1921 ch,ch,m,dest->quote);
1922 if (m==0 || ((m==1 || m==2) && dest->quote)) {
1923 b_addqchr(dest, ch, dest->quote);
1924 } else if (ch == end_trigger && !dest->quote) {
1925 debug_printf("leaving parse_stream\n");
1926 return 0;
1927 } else if (m==2 && !dest->quote) { /* IFS */
1928 done_word(dest, ctx);
1929#if 0
1930 if (ch=='\n') {
1931 /* Yahoo! Time to run with it! */
1932 done_pipe(ctx,PIPE_SEQ);
1933 run_list(ctx->list_head);
1934 initialize_context(ctx);
1935 }
1936#endif
1937 } else switch (ch) {
1938 case '#':
1939 if (dest->length == 0 && !dest->quote) {
1940 while(ch=b_peek(input),ch!=EOF && ch!='\n') { b_getch(input); }
1941 } else {
1942 b_addqchr(dest, ch, dest->quote);
1943 }
1944 break;
1945 case '\\':
1946 if (next == EOF) {
1947 syntax();
1948 return 1;
1949 }
1950 b_addqchr(dest, '\\', dest->quote);
1951 b_addqchr(dest, b_getch(input), dest->quote);
1952 break;
1953 case '$':
1954 if (handle_dollar(dest, ctx, input)!=0) return 1;
1955 break;
1956 case '\'':
1957 dest->nonnull = 1;
1958 while(ch=b_getch(input),ch!=EOF && ch!='\'') {
1959 b_addchr(dest,ch);
1960 }
1961 if (ch==EOF) {
1962 syntax();
1963 return 1;
1964 }
1965 break;
1966 case '"':
1967 dest->nonnull = 1;
1968 dest->quote = !dest->quote;
1969 break;
1970 case '`':
1971 process_command_subs(dest, ctx, input, '`');
1972 break;
1973 case '>':
1974 redir_fd = redirect_opt_num(dest);
1975 done_word(dest, ctx);
1976 redir_style=REDIRECT_OVERWRITE;
1977 if (next == '>') {
1978 redir_style=REDIRECT_APPEND;
1979 b_getch(input);
1980 } else if (next == '(') {
1981 syntax(); /* until we support >(list) Process Substitution */
1982 return 1;
1983 }
1984 setup_redirect(ctx, redir_fd, redir_style, input);
1985 break;
1986 case '<':
1987 redir_fd = redirect_opt_num(dest);
1988 done_word(dest, ctx);
1989 redir_style=REDIRECT_INPUT;
1990 if (next == '<') {
1991 redir_style=REDIRECT_HEREIS;
1992 b_getch(input);
1993 } else if (next == '>') {
1994 redir_style=REDIRECT_IO;
1995 b_getch(input);
1996 } else if (next == '(') {
1997 syntax(); /* until we support <(list) Process Substitution */
1998 return 1;
1999 }
2000 setup_redirect(ctx, redir_fd, redir_style, input);
2001 break;
2002 case ';':
2003 done_word(dest, ctx);
2004 done_pipe(ctx,PIPE_SEQ);
2005 break;
2006 case '&':
2007 done_word(dest, ctx);
2008 if (next=='&') {
2009 b_getch(input);
2010 done_pipe(ctx,PIPE_AND);
2011 } else {
2012 done_pipe(ctx,PIPE_BG);
2013 }
2014 break;
2015 case '|':
2016 done_word(dest, ctx);
2017 if (next=='|') {
2018 b_getch(input);
2019 done_pipe(ctx,PIPE_OR);
2020 } else {
2021 /* we could pick up a file descriptor choice here
2022 * with redirect_opt_num(), but bash doesn't do it.
2023 * "echo foo 2| cat" yields "foo 2". */
2024 done_command(ctx);
2025 }
2026 break;
2027 case '(':
2028 case '{':
2029 if (parse_group(dest, ctx, input, ch)!=0) return 1;
2030 break;
2031 case ')':
2032 case '}':
2033 syntax(); /* Proper use of this character caught by end_trigger */
2034 return 1;
2035 break;
2036 default:
2037 syntax(); /* this is really an internal logic error */
2038 return 1;
2039 }
2040 }
2041 /* complain if quote? No, maybe we just finished a command substitution
2042 * that was quoted. Example:
2043 * $ echo "`cat foo` plus more"
2044 * and we just got the EOF generated by the subshell that ran "cat foo"
2045 * The only real complaint is if we got an EOF when end_trigger != '\0',
2046 * that is, we were really supposed to get end_trigger, and never got
2047 * one before the EOF. Can't use the standard "syntax error" return code,
2048 * so that parse_stream_outer can distinguish the EOF and exit smoothly. */
2049 if (end_trigger != '\0') return -1;
2050 return 0;
2051}
2052
2053void mapset(const unsigned char *set, int code)
2054{
2055 const unsigned char *s;
2056 for (s=set; *s; s++) map[*s] = code;
2057}
2058
2059void update_ifs_map(void)
2060{
2061 /* char *ifs and char map[256] are both globals. */
2062 ifs = getenv("IFS");
2063 if (ifs == NULL) ifs=" \t\n";
2064 /* Precompute a list of 'flow through' behavior so it can be treated
2065 * quickly up front. Computation is necessary because of IFS.
2066 * Special case handling of IFS == " \t\n" is not implemented.
2067 * The map[] array only really needs two bits each, and on most machines
2068 * that would be faster because of the reduced L1 cache footprint.
2069 */
2070 memset(map,0,256); /* most characters flow through always */
2071 mapset("\\$'\"`", 3); /* never flow through */
2072 mapset("<>;&|(){}#", 1); /* flow through if quoted */
2073 mapset(ifs, 2); /* also flow through if quoted */
2074}
2075
2076/* most recursion does not come through here, the exeception is
2077 * from builtin_source() */
2078int parse_stream_outer(struct in_str *inp)
2079{
2080
2081 struct p_context ctx;
2082 o_string temp=NULL_O_STRING;
2083 int rcode;
2084 do {
2085 initialize_context(&ctx);
2086 update_ifs_map();
2087 inp->promptmode=1;
2088 rcode = parse_stream(&temp, &ctx, inp, '\n');
2089 done_word(&temp, &ctx);
2090 done_pipe(&ctx,PIPE_SEQ);
2091 run_list(ctx.list_head);
2092 } while (rcode != -1); /* loop on syntax errors, return on EOF */
2093 return 0;
2094}
2095
2096static int parse_string_outer(const char *s)
2097{
2098 struct in_str input;
2099 setup_string_in_str(&input, s);
2100 return parse_stream_outer(&input);
2101}
2102
2103static int parse_file_outer(FILE *f)
2104{
2105 int rcode;
2106 struct in_str input;
2107 setup_file_in_str(&input, f);
2108 rcode = parse_stream_outer(&input);
2109 return rcode;
2110}
2111
2112int shell_main(int argc, char **argv)
2113{
2114 int opt;
2115 FILE *input;
2116
2117 /* XXX what should these be while sourcing /etc/profile? */
2118 global_argc = argc;
2119 global_argv = argv;
2120
2121 if (argv[0] && argv[0][0] == '-') {
2122 debug_printf("\nsourcing /etc/profile\n");
2123 input = xfopen("/etc/profile", "r");
2124 mark_open(fileno(input));
2125 parse_file_outer(input);
2126 mark_closed(fileno(input));
2127 fclose(input);
2128 }
2129 input=stdin;
2130
2131 /* initialize the cwd -- this is never freed...*/
2132 cwd = xgetcwd(0);
2133#ifdef BB_FEATURE_COMMAND_EDITING
2134 cmdedit_set_initial_prompt();
2135#else
2136 PS1 = NULL;
2137#endif
2138
2139 while ((opt = getopt(argc, argv, "c:xif")) > 0) {
2140 switch (opt) {
2141 case 'c':
2142 {
2143 global_argv = argv+optind;
2144 global_argc = argc-optind;
2145 opt = parse_string_outer(optarg);
2146 exit(opt);
2147 }
2148 break;
2149 case 'i':
2150 interactive++;
2151 break;
2152 case 'f':
2153 fake_mode++;
2154 break;
2155 default:
2156 fprintf(stderr, "Usage: sh [FILE]...\n"
2157 " or: sh -c command [args]...\n\n");
2158 exit(EXIT_FAILURE);
2159 }
2160 }
2161 /* A shell is interactive if the `-i' flag was given, or if all of
2162 * the following conditions are met:
2163 * no -c command
2164 * no arguments remaining or the -s flag given
2165 * standard input is a terminal
2166 * standard output is a terminal
2167 * Refer to Posix.2, the description of the `sh' utility. */
2168 if (argv[optind]==NULL && input==stdin &&
2169 isatty(fileno(stdin)) && isatty(fileno(stdout))) {
2170 interactive++;
2171 }
2172
2173 if (interactive) {
2174 /* Looks like they want an interactive shell */
2175 fprintf(stdout, "\nhush -- the humble shell v0.01 (testing)\n\n");
2176 exit(parse_file_outer(stdin));
2177 }
2178 debug_printf("\ninteractive=%d\n", interactive);
2179
2180 debug_printf("\nrunning script '%s'\n", argv[optind]);
2181 global_argv = argv+optind;
2182 global_argc = argc-optind;
2183 input = xfopen(argv[optind], "r");
2184 opt = parse_file_outer(input);
2185
2186#ifdef BB_FEATURE_CLEAN_UP
2187 fclose(input.file);
2188#endif
2189
2190 return(opt);
2191}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-24 12:26:59 +0000