4ce6d42353962ccff7de275cac78403d05d9de76
[people/mcb30/busybox.git] / shell / lash.c
1 /* vi: set sw=4 ts=4: */
2 /*
3  * lash -- the BusyBox Lame-Ass SHell
4  *
5  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
6  *
7  * Based in part on ladsh.c by Michael K. Johnson and Erik W. Troan, which is
8  * under the following liberal license: "We have placed this source code in the
9  * public domain. Use it in any project, free or commercial."
10  *
11  * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
12  */
13
14 /* This shell's parsing engine is officially at a dead-end.  Future
15  * work shell work should be done using hush, msh, or ash.  This is
16  * still a very useful, small shell -- it just don't need any more
17  * features beyond what it already has...
18  */
19
20 //For debugging/development on the shell only...
21 //#define DEBUG_SHELL
22
23 #include <getopt.h>
24 #include <glob.h>
25
26 #include "busybox.h" /* for struct bb_applet */
27
28 #define expand_t        glob_t
29
30 /* Always enable for the moment... */
31 #define CONFIG_LASH_PIPE_N_REDIRECTS
32 #define CONFIG_LASH_JOB_CONTROL
33 #define ENABLE_LASH_PIPE_N_REDIRECTS 1
34 #define ENABLE_LASH_JOB_CONTROL      1
35
36
37 enum { MAX_READ = 128 }; /* size of input buffer for 'read' builtin */
38 #define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
39
40
41 #if ENABLE_LASH_PIPE_N_REDIRECTS
42 enum redir_type { REDIRECT_INPUT, REDIRECT_OVERWRITE,
43         REDIRECT_APPEND
44 };
45 #endif
46
47 enum {
48         DEFAULT_CONTEXT = 0x1,
49         IF_TRUE_CONTEXT = 0x2,
50         IF_FALSE_CONTEXT = 0x4,
51         THEN_EXP_CONTEXT = 0x8,
52         ELSE_EXP_CONTEXT = 0x10
53 };
54
55 #define LASH_OPT_DONE (1)
56 #define LASH_OPT_SAW_QUOTE (2)
57
58 #if ENABLE_LASH_PIPE_N_REDIRECTS
59 struct redir_struct {
60         enum redir_type type;   /* type of redirection */
61         int fd;                                         /* file descriptor being redirected */
62         char *filename;                         /* file to redirect fd to */
63 };
64 #endif
65
66 struct child_prog {
67         pid_t pid;                                      /* 0 if exited */
68         char **argv;                            /* program name and arguments */
69         int num_redirects;                      /* elements in redirection array */
70         int is_stopped;                         /* is the program currently running? */
71         struct job *family;                     /* pointer back to the child's parent job */
72 #if ENABLE_LASH_PIPE_N_REDIRECTS
73         struct redir_struct *redirects; /* I/O redirects */
74 #endif
75 };
76
77 struct jobset {
78         struct job *head;                       /* head of list of running jobs */
79         struct job *fg;                         /* current foreground job */
80 };
81
82 struct job {
83         int jobid;                                      /* job number */
84         int num_progs;                          /* total number of programs in job */
85         int running_progs;                      /* number of programs running */
86         char *text;                                     /* name of job */
87         char *cmdbuf;                           /* buffer various argv's point into */
88         pid_t pgrp;                                     /* process group ID for the job */
89         struct child_prog *progs;       /* array of programs in job */
90         struct job *next;                       /* to track background commands */
91         int stopped_progs;                      /* number of programs alive, but stopped */
92         unsigned int job_context;       /* bitmask defining current context */
93         struct jobset *job_list;
94 };
95
96 struct built_in_command {
97         const char *cmd;   /* name */
98         const char *descr; /* description */
99         int (*function) (struct child_prog *);  /* function ptr */
100 };
101
102 /* function prototypes for builtins */
103 static int builtin_cd(struct child_prog *cmd);
104 static int builtin_exec(struct child_prog *cmd);
105 static int builtin_exit(struct child_prog *cmd);
106 static int builtin_fg_bg(struct child_prog *cmd);
107 static int builtin_help(struct child_prog *cmd);
108 static int builtin_jobs(struct child_prog *dummy);
109 static int builtin_pwd(struct child_prog *dummy);
110 static int builtin_export(struct child_prog *cmd);
111 static int builtin_source(struct child_prog *cmd);
112 static int builtin_unset(struct child_prog *cmd);
113 static int builtin_read(struct child_prog *cmd);
114
115
116 /* function prototypes for shell stuff */
117 static void checkjobs(struct jobset *job_list);
118 static void remove_job(struct jobset *j_list, struct job *job);
119 static int get_command_bufsiz(FILE * source, char *command);
120 static int parse_command(char **command_ptr, struct job *job, int *inbg);
121 static int run_command(struct job *newjob, int inbg, int outpipe[2]);
122 static int pseudo_exec(struct child_prog *cmd) ATTRIBUTE_NORETURN;
123 static int busy_loop(FILE * input);
124
125
126 /* Table of built-in functions (these are non-forking builtins, meaning they
127  * can change global variables in the parent shell process but they will not
128  * work with pipes and redirects; 'unset foo | whatever' will not work) */
129 static const struct built_in_command bltins[] = {
130         {"bg"    , "Resume a job in the background", builtin_fg_bg},
131         {"cd"    , "Change working directory", builtin_cd},
132         {"exec"  , "Exec command, replacing this shell with the exec'd process", builtin_exec},
133         {"exit"  , "Exit from shell()", builtin_exit},
134         {"fg"    , "Bring job into the foreground", builtin_fg_bg},
135         {"jobs"  , "Lists the active jobs", builtin_jobs},
136         {"export", "Set environment variable", builtin_export},
137         {"unset" , "Unset environment variable", builtin_unset},
138         {"read"  , "Input environment variable", builtin_read},
139         {"."     , "Source-in and run commands in a file", builtin_source},
140         /* These were "forked applets", but distinction was nuked */
141         /* Original comment retained: */
142         /* Table of forking built-in functions (things that fork cannot change global
143          * variables in the parent process, such as the current working directory) */
144         {"pwd"   , "Print current directory", builtin_pwd},
145         {"help"  , "List shell built-in commands", builtin_help},
146         /* to do: add ulimit */
147 };
148
149
150 #define VEC_LAST(v) v[ARRAY_SIZE(v)-1]
151
152
153 static int shell_context;  /* Type prompt trigger (PS1 or PS2) */
154
155
156 /* Globals that are static to this file */
157 static char *cwd;
158 static char *local_pending_command;
159 static struct jobset job_list = { NULL, NULL };
160 static int argc;
161 static char **argv;
162 static llist_t *close_me_list;
163 static int last_return_code;
164 static int last_bg_pid;
165 static unsigned int last_jobid;
166 static int shell_terminal;
167 static const char *PS1;
168 static const char *PS2 = "> ";
169
170
171 #ifdef DEBUG_SHELL
172 static inline void debug_printf(const char *format, ...)
173 {
174         va_list args;
175         va_start(args, format);
176         vfprintf(stderr, format, args);
177         va_end(args);
178 }
179 #else
180 static inline void debug_printf(const char ATTRIBUTE_UNUSED *format, ...) { }
181 #endif
182
183 /*
184         Most builtins need access to the struct child_prog that has
185         their arguments, previously coded as cmd->progs[0].  That coding
186         can exhibit a bug, if the builtin is not the first command in
187         a pipeline: "echo foo | exec sort" will attempt to exec foo.
188
189 builtin   previous use      notes
190 ------ -----------------  ---------
191 cd      cmd->progs[0]
192 exec    cmd->progs[0]  squashed bug: didn't look for applets or forking builtins
193 exit    cmd->progs[0]
194 fg_bg   cmd->progs[0], job_list->head, job_list->fg
195 help    0
196 jobs    job_list->head
197 pwd     0
198 export  cmd->progs[0]
199 source  cmd->progs[0]
200 unset   cmd->progs[0]
201 read    cmd->progs[0]
202
203 I added "struct job *family;" to struct child_prog,
204 and switched API to builtin_foo(struct child_prog *child);
205 So   cmd->text        becomes  child->family->text
206      cmd->job_context  becomes  child->family->job_context
207      cmd->progs[0]    becomes  *child
208      job_list          becomes  child->family->job_list
209  */
210
211
212 static void update_cwd(void)
213 {
214         cwd = xrealloc_getcwd_or_warn(cwd);
215         if (!cwd)
216                 cwd = xstrdup(bb_msg_unknown);
217 }
218
219 /* built-in 'cd <path>' handler */
220 static int builtin_cd(struct child_prog *child)
221 {
222         char *newdir;
223
224         if (child->argv[1] == NULL)
225                 newdir = getenv("HOME");
226         else
227                 newdir = child->argv[1];
228         if (chdir(newdir)) {
229                 bb_perror_msg("cd: %s", newdir);
230                 return EXIT_FAILURE;
231         }
232         update_cwd();
233         return EXIT_SUCCESS;
234 }
235
236 /* built-in 'exec' handler */
237 static int builtin_exec(struct child_prog *child)
238 {
239         if (child->argv[1] == NULL)
240                 return EXIT_SUCCESS;   /* Really? */
241         child->argv++;
242         while (close_me_list)
243                 close((long)llist_pop(&close_me_list));
244         pseudo_exec(child);
245         /* never returns */
246 }
247
248 /* built-in 'exit' handler */
249 static int builtin_exit(struct child_prog *child)
250 {
251         if (child->argv[1] == NULL)
252                 exit(EXIT_SUCCESS);
253
254         exit(atoi(child->argv[1]));
255 }
256
257 /* built-in 'fg' and 'bg' handler */
258 static int builtin_fg_bg(struct child_prog *child)
259 {
260         int i, jobnum;
261         struct job *job;
262
263         /* If they gave us no args, assume they want the last backgrounded task */
264         if (!child->argv[1]) {
265                 for (job = child->family->job_list->head; job; job = job->next) {
266                         if (job->jobid == last_jobid) {
267                                 goto found;
268                         }
269                 }
270                 bb_error_msg("%s: no current job", child->argv[0]);
271                 return EXIT_FAILURE;
272         }
273         if (sscanf(child->argv[1], "%%%d", &jobnum) != 1) {
274                 bb_error_msg(bb_msg_invalid_arg, child->argv[1], child->argv[0]);
275                 return EXIT_FAILURE;
276         }
277         for (job = child->family->job_list->head; job; job = job->next) {
278                 if (job->jobid == jobnum) {
279                         goto found;
280                 }
281         }
282         bb_error_msg("%s: %d: no such job", child->argv[0], jobnum);
283         return EXIT_FAILURE;
284  found:
285         if (*child->argv[0] == 'f') {
286                 /* Put the job into the foreground.  */
287                 tcsetpgrp(shell_terminal, job->pgrp);
288
289                 child->family->job_list->fg = job;
290         }
291
292         /* Restart the processes in the job */
293         for (i = 0; i < job->num_progs; i++)
294                 job->progs[i].is_stopped = 0;
295
296         job->stopped_progs = 0;
297
298         i = kill(- job->pgrp, SIGCONT);
299         if (i < 0) {
300                 if (errno == ESRCH) {
301                         remove_job(&job_list, job);
302                 } else {
303                         bb_perror_msg("kill (SIGCONT)");
304                 }
305         }
306
307         return EXIT_SUCCESS;
308 }
309
310 /* built-in 'help' handler */
311 static int builtin_help(struct child_prog ATTRIBUTE_UNUSED *dummy)
312 {
313         const struct built_in_command *x;
314
315         printf("\nBuilt-in commands:\n"
316                "-------------------\n");
317         for (x = bltins; x <= &VEC_LAST(bltins); x++) {
318                 if (x->descr == NULL)
319                         continue;
320                 printf("%s\t%s\n", x->cmd, x->descr);
321         }
322         bb_putchar('\n');
323         return EXIT_SUCCESS;
324 }
325
326 /* built-in 'jobs' handler */
327 static int builtin_jobs(struct child_prog *child)
328 {
329         struct job *job;
330         const char *status_string;
331
332         for (job = child->family->job_list->head; job; job = job->next) {
333                 if (job->running_progs == job->stopped_progs)
334                         status_string = "Stopped";
335                 else
336                         status_string = "Running";
337
338                 printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text);
339         }
340         return EXIT_SUCCESS;
341 }
342
343
344 /* built-in 'pwd' handler */
345 static int builtin_pwd(struct child_prog ATTRIBUTE_UNUSED *dummy)
346 {
347         update_cwd();
348         puts(cwd);
349         return EXIT_SUCCESS;
350 }
351
352 /* built-in 'export VAR=value' handler */
353 static int builtin_export(struct child_prog *child)
354 {
355         int res;
356         char *v = child->argv[1];
357
358         if (v == NULL) {
359                 char **e;
360                 for (e = environ; *e; e++) {
361                         puts(*e);
362                 }
363                 return 0;
364         }
365         res = putenv(v);
366         if (res)
367                 bb_perror_msg("export");
368 #if ENABLE_FEATURE_EDITING_FANCY_PROMPT
369         if (strncmp(v, "PS1=", 4) == 0)
370                 PS1 = getenv("PS1");
371 #endif
372
373 #if ENABLE_LOCALE_SUPPORT
374         // TODO: why getenv? "" would be just as good...
375         if (strncmp(v, "LC_ALL=", 7) == 0)
376                 setlocale(LC_ALL, getenv("LC_ALL"));
377         if (strncmp(v, "LC_CTYPE=", 9) == 0)
378                 setlocale(LC_CTYPE, getenv("LC_CTYPE"));
379 #endif
380
381         return res;
382 }
383
384 /* built-in 'read VAR' handler */
385 static int builtin_read(struct child_prog *child)
386 {
387         int res = 0, len;
388         char *s;
389         char string[MAX_READ];
390
391         if (child->argv[1]) {
392                 /* argument (VAR) given: put "VAR=" into buffer */
393                 safe_strncpy(string, child->argv[1], MAX_READ-1);
394                 len = strlen(string);
395                 string[len++] = '=';
396                 string[len]   = '\0';
397                 fgets(&string[len], sizeof(string) - len, stdin);       /* read string */
398                 res = strlen(string);
399                 if (res > len)
400                         string[--res] = '\0';   /* chomp trailing newline */
401                 /*
402                 ** string should now contain "VAR=<value>"
403                 ** copy it (putenv() won't do that, so we must make sure
404                 ** the string resides in a static buffer!)
405                 */
406                 res = -1;
407                 s = strdup(string);
408                 if (s)
409                         res = putenv(s);
410                 if (res)
411                         bb_perror_msg("read");
412         } else
413                 fgets(string, sizeof(string), stdin);
414
415         return res;
416 }
417
418 /* Built-in '.' handler (read-in and execute commands from file) */
419 static int builtin_source(struct child_prog *child)
420 {
421         FILE *input;
422         int status;
423
424         input = fopen_or_warn(child->argv[1], "r");
425         if (!input) {
426                 return EXIT_FAILURE;
427         }
428
429         llist_add_to(&close_me_list, (void *)(long)fileno(input));
430         /* Now run the file */
431         status = busy_loop(input);
432         fclose(input);
433         llist_pop(&close_me_list);
434         return status;
435 }
436
437 /* built-in 'unset VAR' handler */
438 static int builtin_unset(struct child_prog *child)
439 {
440         if (child->argv[1] == NULL) {
441                 printf(bb_msg_requires_arg, "unset");
442                 return EXIT_FAILURE;
443         }
444         unsetenv(child->argv[1]);
445         return EXIT_SUCCESS;
446 }
447
448 #if ENABLE_LASH_JOB_CONTROL
449 /* free up all memory from a job */
450 static void free_job(struct job *cmd)
451 {
452         int i;
453         struct jobset *keep;
454
455         for (i = 0; i < cmd->num_progs; i++) {
456                 free(cmd->progs[i].argv);
457 #if ENABLE_LASH_PIPE_N_REDIRECTS
458                 if (cmd->progs[i].redirects)
459                         free(cmd->progs[i].redirects);
460 #endif
461         }
462         free(cmd->progs);
463         free(cmd->text);
464         free(cmd->cmdbuf);
465         keep = cmd->job_list;
466         memset(cmd, 0, sizeof(struct job));
467         cmd->job_list = keep;
468 }
469
470 /* remove a job from a jobset */
471 static void remove_job(struct jobset *j_list, struct job *job)
472 {
473         struct job *prevjob;
474
475         free_job(job);
476         if (job == j_list->head) {
477                 j_list->head = job->next;
478         } else {
479                 prevjob = j_list->head;
480                 while (prevjob->next != job)
481                         prevjob = prevjob->next;
482                 prevjob->next = job->next;
483         }
484
485         if (j_list->head)
486                 last_jobid = j_list->head->jobid;
487         else
488                 last_jobid = 0;
489
490         free(job);
491 }
492
493 /* Checks to see if any background processes have exited -- if they
494    have, figure out why and see if a job has completed */
495 static void checkjobs(struct jobset *j_list)
496 {
497         struct job *job;
498         pid_t childpid;
499         int status;
500         int prognum = 0;
501
502         while ((childpid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
503                 for (job = j_list->head; job; job = job->next) {
504                         prognum = 0;
505                         while (prognum < job->num_progs &&
506                                    job->progs[prognum].pid != childpid) prognum++;
507                         if (prognum < job->num_progs)
508                                 break;
509                 }
510
511                 /* This happens on backticked commands */
512                 if (job == NULL)
513                         return;
514
515                 if (WIFEXITED(status) || WIFSIGNALED(status)) {
516                         /* child exited */
517                         job->running_progs--;
518                         job->progs[prognum].pid = 0;
519
520                         if (!job->running_progs) {
521                                 printf(JOB_STATUS_FORMAT, job->jobid, "Done", job->text);
522                                 last_jobid = 0;
523                                 remove_job(j_list, job);
524                         }
525                 } else {
526                         /* child stopped */
527                         job->stopped_progs++;
528                         job->progs[prognum].is_stopped = 1;
529                 }
530         }
531
532         if (childpid == -1 && errno != ECHILD)
533                 bb_perror_msg("waitpid");
534 }
535 #else
536 static void checkjobs(struct jobset *j_list)
537 {
538 }
539 static void free_job(struct job *cmd)
540 {
541 }
542 static void remove_job(struct jobset *j_list, struct job *job)
543 {
544 }
545 #endif
546
547 #if ENABLE_LASH_PIPE_N_REDIRECTS
548 /* squirrel != NULL means we squirrel away copies of stdin, stdout,
549  * and stderr if they are redirected. */
550 static int setup_redirects(struct child_prog *prog, int squirrel[])
551 {
552         int i;
553         int openfd;
554         int mode = O_RDONLY;
555         struct redir_struct *redir = prog->redirects;
556
557         for (i = 0; i < prog->num_redirects; i++, redir++) {
558                 switch (redir->type) {
559                 case REDIRECT_INPUT:
560                         mode = O_RDONLY;
561                         break;
562                 case REDIRECT_OVERWRITE:
563                         mode = O_WRONLY | O_CREAT | O_TRUNC;
564                         break;
565                 case REDIRECT_APPEND:
566                         mode = O_WRONLY | O_CREAT | O_APPEND;
567                         break;
568                 }
569
570                 openfd = open3_or_warn(redir->filename, mode, 0666);
571                 if (openfd < 0) {
572                         /* this could get lost if stderr has been redirected, but
573                            bash and ash both lose it as well (though zsh doesn't!) */
574                         return 1;
575                 }
576
577                 if (openfd != redir->fd) {
578                         if (squirrel && redir->fd < 3) {
579                                 squirrel[redir->fd] = dup(redir->fd);
580                                 fcntl(squirrel[redir->fd], F_SETFD, FD_CLOEXEC);
581                         }
582                         dup2(openfd, redir->fd);
583                         close(openfd);
584                 }
585         }
586
587         return 0;
588 }
589
590 static void restore_redirects(int squirrel[])
591 {
592         int i, fd;
593         for (i = 0; i < 3; i++) {
594                 fd = squirrel[i];
595                 if (fd != -1) {
596                         /* No error checking.  I sure wouldn't know what
597                          * to do with an error if I found one! */
598                         dup2(fd, i);
599                         close(fd);
600                 }
601         }
602 }
603 #else
604 static inline int setup_redirects(struct child_prog *prog, int squirrel[])
605 {
606         return 0;
607 }
608 static inline void restore_redirects(int squirrel[])
609 {
610 }
611 #endif
612
613 static inline void cmdedit_set_initial_prompt(void)
614 {
615 #if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
616         PS1 = NULL;
617 #else
618         PS1 = getenv("PS1");
619         if (PS1 == 0)
620                 PS1 = "\\w \\$ ";
621 #endif
622 }
623
624 static inline const char* setup_prompt_string(void)
625 {
626 #if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
627         /* Set up the prompt */
628         if (shell_context == 0) {
629                 char *ns;
630                 free((char*)PS1);
631                 ns = xmalloc(strlen(cwd)+4);
632                 sprintf(ns, "%s %c ", cwd, (geteuid() != 0) ? '$': '#');
633                 PS1 = ns;
634                 return ns;
635         } else {
636                 return PS2;
637         }
638 #else
639         return (shell_context == 0)? PS1 : PS2;
640 #endif
641 }
642
643 #if ENABLE_FEATURE_EDITING
644 static line_input_t *line_input_state;
645 #endif
646
647 static int get_command_bufsiz(FILE * source, char *command)
648 {
649         const char *prompt_str;
650
651         if (source == NULL) {
652                 if (local_pending_command) {
653                         /* a command specified (-c option): return it & mark it done */
654                         strncpy(command, local_pending_command, BUFSIZ);
655                         local_pending_command = NULL;
656                         return 0;
657                 }
658                 return 1;
659         }
660
661         if (source == stdin) {
662                 prompt_str = setup_prompt_string();
663
664 #if ENABLE_FEATURE_EDITING
665                 /*
666                 ** enable command line editing only while a command line
667                 ** is actually being read; otherwise, we'll end up bequeathing
668                 ** atexit() handlers and other unwanted stuff to our
669                 ** child processes (rob@sysgo.de)
670                 */
671                 read_line_input(prompt_str, command, BUFSIZ, line_input_state);
672                 return 0;
673 #else
674                 fputs(prompt_str, stdout);
675 #endif
676         }
677
678         if (!fgets(command, BUFSIZ - 2, source)) {
679                 if (source == stdin)
680                         bb_putchar('\n');
681                 return 1;
682         }
683
684         return 0;
685 }
686
687 static char * strsep_space(char *string, int * ix)
688 {
689         /* Short circuit the trivial case */
690         if (!string || ! string[*ix])
691                 return NULL;
692
693         /* Find the end of the token. */
694         while (string[*ix] && !isspace(string[*ix]) ) {
695                 (*ix)++;
696         }
697
698         /* Find the end of any whitespace trailing behind
699          * the token and let that be part of the token */
700         while (string[*ix] && (isspace)(string[*ix]) ) {
701                 (*ix)++;
702         }
703
704         if (!*ix) {
705                 /* Nothing useful was found */
706                 return NULL;
707         }
708
709         return xstrndup(string, *ix);
710 }
711
712 static int expand_arguments(char *command)
713 {
714         static const char out_of_space[] ALIGN1 = "out of space during expansion";
715
716         int total_length = 0, length, i, retval, ix = 0;
717         expand_t expand_result;
718         char *tmpcmd, *cmd, *cmd_copy;
719         char *src, *dst, *var;
720         int flags = GLOB_NOCHECK
721 #ifdef GLOB_BRACE
722                 | GLOB_BRACE
723 #endif
724 #ifdef GLOB_TILDE
725                 | GLOB_TILDE
726 #endif
727                 ;
728
729         /* get rid of the terminating \n */
730         chomp(command);
731
732         /* Fix up escape sequences to be the Real Thing(tm) */
733         while (command && command[ix]) {
734                 if (command[ix] == '\\') {
735                         const char *tmp = command+ix+1;
736                         command[ix] = bb_process_escape_sequence(  &tmp );
737                         memmove(command+ix + 1, tmp, strlen(tmp)+1);
738                 }
739                 ix++;
740         }
741         /* Use glob and then fixup environment variables and such */
742
743         /* It turns out that glob is very stupid.  We have to feed it one word at a
744          * time since it can't cope with a full string.  Here we convert command
745          * (char*) into cmd (char**, one word per string) */
746
747         /* We need a clean copy, so strsep can mess up the copy while
748          * we write stuff into the original (in a minute) */
749         cmd = cmd_copy = xstrdup(command);
750         *command = '\0';
751         for (ix = 0, tmpcmd = cmd;
752                         (tmpcmd = strsep_space(cmd, &ix)) != NULL; cmd += ix, ix = 0) {
753                 if (*tmpcmd == '\0')
754                         break;
755                 /* we need to trim() the result for glob! */
756                 trim(tmpcmd);
757                 retval = glob(tmpcmd, flags, NULL, &expand_result);
758                 free(tmpcmd); /* Free mem allocated by strsep_space */
759                 if (retval == GLOB_NOSPACE) {
760                         /* Mem may have been allocated... */
761                         globfree(&expand_result);
762                         bb_error_msg(out_of_space);
763                         return FALSE;
764                 } else if (retval != 0) {
765                         /* Some other error.  GLOB_NOMATCH shouldn't
766                          * happen because of the GLOB_NOCHECK flag in
767                          * the glob call. */
768                         bb_error_msg("syntax error");
769                         return FALSE;
770                 } else {
771                         /* Convert from char** (one word per string) to a simple char*,
772                          * but don't overflow command which is BUFSIZ in length */
773                         for (i = 0; i < expand_result.gl_pathc; i++) {
774                                 length = strlen(expand_result.gl_pathv[i]);
775                                 if (total_length+length+1 >= BUFSIZ) {
776                                         bb_error_msg(out_of_space);
777                                         return FALSE;
778                                 }
779                                 strcat(command+total_length, " ");
780                                 total_length += 1;
781                                 strcat(command+total_length, expand_result.gl_pathv[i]);
782                                 total_length += length;
783                         }
784                         globfree(&expand_result);
785                 }
786         }
787         free(cmd_copy);
788         trim(command);
789
790         /* Now do the shell variable substitutions which
791          * wordexp can't do for us, namely $? and $! */
792         src = command;
793         while ((dst = strchr(src,'$')) != NULL) {
794                 var = NULL;
795                 switch (*(dst+1)) {
796                         case '?':
797                                 var = itoa(last_return_code);
798                                 break;
799                         case '!':
800                                 if (last_bg_pid == -1)
801                                         *var = '\0';
802                                 else
803                                         var = itoa(last_bg_pid);
804                                 break;
805                                 /* Everything else like $$, $#, $[0-9], etc. should all be
806                                  * expanded by wordexp(), so we can in theory skip that stuff
807                                  * here, but just to be on the safe side (i.e., since uClibc
808                                  * wordexp doesn't do this stuff yet), lets leave it in for
809                                  * now. */
810                         case '$':
811                                 var = itoa(getpid());
812                                 break;
813                         case '#':
814                                 var = itoa(argc-1);
815                                 break;
816                         case '0':case '1':case '2':case '3':case '4':
817                         case '5':case '6':case '7':case '8':case '9':
818                                 {
819                                         int ixx = *(dst+1)-48+1;
820                                         if (ixx >= argc) {
821                                                 var = '\0';
822                                         } else {
823                                                 var = argv[ixx];
824                                         }
825                                 }
826                                 break;
827
828                 }
829                 if (var) {
830                         /* a single character construction was found, and
831                          * already handled in the case statement */
832                         src = dst + 2;
833                 } else {
834                         /* Looks like an environment variable */
835                         char delim_hold;
836                         int num_skip_chars = 0;
837                         int dstlen = strlen(dst);
838                         /* Is this a ${foo} type variable? */
839                         if (dstlen >= 2 && *(dst+1) == '{') {
840                                 src = strchr(dst+1, '}');
841                                 num_skip_chars = 1;
842                         } else {
843                                 src = dst + 1;
844                                 while ((isalnum)(*src) || *src == '_') src++;
845                         }
846                         if (src == NULL) {
847                                 src = dst+dstlen;
848                         }
849                         delim_hold = *src;
850                         *src = '\0';  /* temporary */
851                         var = getenv(dst + 1 + num_skip_chars);
852                         *src = delim_hold;
853                         src += num_skip_chars;
854                 }
855                 if (var == NULL) {
856                         /* Seems we got an un-expandable variable.  So delete it. */
857                         var = (char*)"";
858                 }
859                 {
860                         int subst_len = strlen(var);
861                         int trail_len = strlen(src);
862                         if (dst+subst_len+trail_len >= command+BUFSIZ) {
863                                 bb_error_msg(out_of_space);
864                                 return FALSE;
865                         }
866                         /* Move stuff to the end of the string to accommodate
867                          * filling the created gap with the new stuff */
868                         memmove(dst+subst_len, src, trail_len+1);
869                         /* Now copy in the new stuff */
870                         memcpy(dst, var, subst_len);
871                         src = dst+subst_len;
872                 }
873         }
874
875         return TRUE;
876 }
877
878 /* Return cmd->num_progs as 0 if no command is present (e.g. an empty
879    line). If a valid command is found, command_ptr is set to point to
880    the beginning of the next command (if the original command had more
881    then one job associated with it) or NULL if no more commands are
882    present. */
883 static int parse_command(char **command_ptr, struct job *job, int *inbg)
884 {
885         char *command;
886         char *return_command = NULL;
887         char *src, *buf;
888         int argc_l;
889         int flag;
890         int argv_alloced;
891         char quote = '\0';
892         struct child_prog *prog;
893 #if ENABLE_LASH_PIPE_N_REDIRECTS
894         int i;
895         char *chptr;
896 #endif
897
898         /* skip leading white space */
899         *command_ptr = skip_whitespace(*command_ptr);
900
901         /* this handles empty lines or leading '#' characters */
902         if (!**command_ptr || (**command_ptr == '#')) {
903                 job->num_progs = 0;
904                 return 0;
905         }
906
907         *inbg = 0;
908         job->num_progs = 1;
909         job->progs = xmalloc(sizeof(*job->progs));
910
911         /* We set the argv elements to point inside of this string. The
912            memory is freed by free_job(). Allocate twice the original
913            length in case we need to quote every single character.
914
915            Getting clean memory relieves us of the task of NULL
916            terminating things and makes the rest of this look a bit
917            cleaner (though it is, admittedly, a tad less efficient) */
918         job->cmdbuf = command = xzalloc(2*strlen(*command_ptr) + 1);
919         job->text = NULL;
920
921         prog = job->progs;
922         prog->num_redirects = 0;
923         prog->is_stopped = 0;
924         prog->family = job;
925 #if ENABLE_LASH_PIPE_N_REDIRECTS
926         prog->redirects = NULL;
927 #endif
928
929         argv_alloced = 5;
930         prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
931         prog->argv[0] = job->cmdbuf;
932
933         flag = argc_l = 0;
934         buf = command;
935         src = *command_ptr;
936         while (*src && !(flag & LASH_OPT_DONE)) {
937                 if (quote == *src) {
938                         quote = '\0';
939                 } else if (quote) {
940                         if (*src == '\\') {
941                                 src++;
942                                 if (!*src) {
943                                         bb_error_msg("character expected after \\");
944                                         free_job(job);
945                                         return 1;
946                                 }
947
948                                 /* in shell, "\'" should yield \' */
949                                 if (*src != quote) {
950                                         *buf++ = '\\';
951                                         *buf++ = '\\';
952                                 }
953                         } else if (*src == '*' || *src == '?' || *src == '[' ||
954                                            *src == ']') *buf++ = '\\';
955                         *buf++ = *src;
956                 } else if (isspace(*src)) {
957                         if (*prog->argv[argc_l] || (flag & LASH_OPT_SAW_QUOTE)) {
958                                 buf++, argc_l++;
959                                 /* +1 here leaves room for the NULL which ends argv */
960                                 if ((argc_l + 1) == argv_alloced) {
961                                         argv_alloced += 5;
962                                         prog->argv = xrealloc(prog->argv,
963                                                         sizeof(*prog->argv) * argv_alloced);
964                                 }
965                                 prog->argv[argc_l] = buf;
966                                 flag ^= LASH_OPT_SAW_QUOTE;
967                         }
968                 } else
969                         switch (*src) {
970                         case '"':
971                         case '\'':
972                                 quote = *src;
973                                 flag |= LASH_OPT_SAW_QUOTE;
974                                 break;
975
976                         case '#':                       /* comment */
977                                 if (*(src-1)== '$')
978                                         *buf++ = *src;
979                                 else
980                                         flag |= LASH_OPT_DONE;
981                                 break;
982
983 #if ENABLE_LASH_PIPE_N_REDIRECTS
984                         case '>':                       /* redirects */
985                         case '<':
986                                 i = prog->num_redirects++;
987                                 prog->redirects = xrealloc(prog->redirects,
988                                                 sizeof(*prog->redirects) * (i + 1));
989
990                                 prog->redirects[i].fd = -1;
991                                 if (buf != prog->argv[argc_l]) {
992                                         /* the stuff before this character may be the file number
993                                            being redirected */
994                                         prog->redirects[i].fd =
995                                                 strtol(prog->argv[argc_l], &chptr, 10);
996
997                                         if (*chptr && *prog->argv[argc_l]) {
998                                                 buf++, argc_l++;
999                                                 prog->argv[argc_l] = buf;
1000                                         }
1001                                 }
1002
1003                                 if (prog->redirects[i].fd == -1) {
1004                                         if (*src == '>')
1005                                                 prog->redirects[i].fd = 1;
1006                                         else
1007                                                 prog->redirects[i].fd = 0;
1008                                 }
1009
1010                                 if (*src++ == '>') {
1011                                         if (*src == '>')
1012                                                 prog->redirects[i].type =
1013                                                         REDIRECT_APPEND, src++;
1014                                         else
1015                                                 prog->redirects[i].type = REDIRECT_OVERWRITE;
1016                                 } else {
1017                                         prog->redirects[i].type = REDIRECT_INPUT;
1018                                 }
1019
1020                                 /* This isn't POSIX sh compliant. Oh well. */
1021                                 chptr = src;
1022                                 chptr = skip_whitespace(chptr);
1023
1024                                 if (!*chptr) {
1025                                         bb_error_msg("file name expected after %c", *(src-1));
1026                                         free_job(job);
1027                                         job->num_progs = 0;
1028                                         return 1;
1029                                 }
1030
1031                                 prog->redirects[i].filename = buf;
1032                                 while (*chptr && !isspace(*chptr))
1033                                         *buf++ = *chptr++;
1034
1035                                 src = chptr - 1;        /* we src++ later */
1036                                 prog->argv[argc_l] = ++buf;
1037                                 break;
1038
1039                         case '|':                       /* pipe */
1040                                 /* finish this command */
1041                                 if (*prog->argv[argc_l] || flag & LASH_OPT_SAW_QUOTE)
1042                                         argc_l++;
1043                                 if (!argc_l) {
1044                                         goto empty_command_in_pipe;
1045                                 }
1046                                 prog->argv[argc_l] = NULL;
1047
1048                                 /* and start the next */
1049                                 job->num_progs++;
1050                                 job->progs = xrealloc(job->progs,
1051                                                 sizeof(*job->progs) * job->num_progs);
1052                                 prog = job->progs + (job->num_progs - 1);
1053                                 prog->num_redirects = 0;
1054                                 prog->redirects = NULL;
1055                                 prog->is_stopped = 0;
1056                                 prog->family = job;
1057                                 argc_l = 0;
1058
1059                                 argv_alloced = 5;
1060                                 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
1061                                 prog->argv[0] = ++buf;
1062
1063                                 src++;
1064                                 src = skip_whitespace(src);
1065
1066                                 if (!*src) {
1067 empty_command_in_pipe:
1068                                         bb_error_msg("empty command in pipe");
1069                                         free_job(job);
1070                                         job->num_progs = 0;
1071                                         return 1;
1072                                 }
1073                                 src--;                  /* we'll ++ it at the end of the loop */
1074
1075                                 break;
1076 #endif
1077
1078 #if ENABLE_LASH_JOB_CONTROL
1079                         case '&':                       /* background */
1080                                 *inbg = 1;
1081                                 /* fallthrough */
1082 #endif
1083                         case ';':                       /* multiple commands */
1084                                 flag |= LASH_OPT_DONE;
1085                                 return_command = *command_ptr + (src - *command_ptr) + 1;
1086                                 break;
1087
1088                         case '\\':
1089                                 src++;
1090                                 if (!*src) {
1091                                         bb_error_msg("character expected after \\");
1092                                         free_job(job);
1093                                         return 1;
1094                                 }
1095                                 if (*src == '*' || *src == '[' || *src == ']'
1096                                         || *src == '?') *buf++ = '\\';
1097                                 /* fallthrough */
1098                         default:
1099                                 *buf++ = *src;
1100                         }
1101
1102                 src++;
1103         }
1104
1105         if (*prog->argv[argc_l] || flag & LASH_OPT_SAW_QUOTE) {
1106                 argc_l++;
1107         }
1108         if (!argc_l) {
1109                 free_job(job);
1110                 return 0;
1111         }
1112         prog->argv[argc_l] = NULL;
1113
1114         if (!return_command) {
1115                 job->text = xstrdup(*command_ptr);
1116         } else {
1117                 /* This leaves any trailing spaces, which is a bit sloppy */
1118                 job->text = xstrndup(*command_ptr, return_command - *command_ptr);
1119         }
1120
1121         *command_ptr = return_command;
1122
1123         return 0;
1124 }
1125
1126 /* Run the child_prog, no matter what kind of command it uses.
1127  */
1128 static int pseudo_exec(struct child_prog *child)
1129 {
1130         const struct built_in_command *x;
1131
1132         /* Check if the command matches any of the non-forking builtins.
1133          * Depending on context, this might be redundant.  But it's
1134          * easier to waste a few CPU cycles than it is to figure out
1135          * if this is one of those cases.
1136          */
1137         /* Check if the command matches any of the forking builtins. */
1138         for (x = bltins; x <= &VEC_LAST(bltins); x++) {
1139                 if (strcmp(child->argv[0], x->cmd) == 0) {
1140                         _exit(x->function(child));
1141                 }
1142         }
1143
1144         /* Check if the command matches any busybox internal
1145          * commands ("applets") here.  Following discussions from
1146          * November 2000 on busybox@busybox.net, don't use
1147          * bb_get_last_path_component_nostrip().  This way explicit
1148          * (with slashes) filenames will never be interpreted as an
1149          * applet, just like with builtins.  This way the user can
1150          * override an applet with an explicit filename reference.
1151          * The only downside to this change is that an explicit
1152          * /bin/foo invocation will fork and exec /bin/foo, even if
1153          * /bin/foo is a symlink to busybox.
1154          */
1155         if (ENABLE_FEATURE_SH_STANDALONE) {
1156                 run_applet_and_exit(child->argv[0], child->argv);
1157         }
1158
1159         execvp(child->argv[0], child->argv);
1160
1161         /* Do not use bb_perror_msg_and_die() here, since we must not
1162          * call exit() but should call _exit() instead */
1163         bb_perror_msg("%s", child->argv[0]);
1164         _exit(EXIT_FAILURE);
1165 }
1166
1167 static void insert_job(struct job *newjob, int inbg)
1168 {
1169         struct job *thejob;
1170         struct jobset *j_list = newjob->job_list;
1171
1172         /* find the ID for thejob to use */
1173         newjob->jobid = 1;
1174         for (thejob = j_list->head; thejob; thejob = thejob->next)
1175                 if (thejob->jobid >= newjob->jobid)
1176                         newjob->jobid = thejob->jobid + 1;
1177
1178         /* add thejob to the list of running jobs */
1179         if (!j_list->head) {
1180                 thejob = j_list->head = xmalloc(sizeof(*thejob));
1181         } else {
1182                 for (thejob = j_list->head; thejob->next; thejob = thejob->next) /* nothing */;
1183                 thejob->next = xmalloc(sizeof(*thejob));
1184                 thejob = thejob->next;
1185         }
1186
1187         *thejob = *newjob;   /* physically copy the struct job */
1188         thejob->next = NULL;
1189         thejob->running_progs = thejob->num_progs;
1190         thejob->stopped_progs = 0;
1191
1192 #if ENABLE_LASH_JOB_CONTROL
1193         if (inbg) {
1194                 /* we don't wait for background thejobs to return -- append it
1195                    to the list of backgrounded thejobs and leave it alone */
1196                 printf("[%d] %d\n", thejob->jobid,
1197                            newjob->progs[newjob->num_progs - 1].pid);
1198                 last_jobid = newjob->jobid;
1199                 last_bg_pid = newjob->progs[newjob->num_progs - 1].pid;
1200         } else {
1201                 newjob->job_list->fg = thejob;
1202
1203                 /* move the new process group into the foreground */
1204                 /* Ignore errors since child could have already exited */
1205                 tcsetpgrp(shell_terminal, newjob->pgrp);
1206         }
1207 #endif
1208 }
1209
1210 static int run_command(struct job *newjob, int inbg, int outpipe[2])
1211 {
1212         /* struct job *thejob; */
1213         int i;
1214         int nextin, nextout;
1215         int pipefds[2];                         /* pipefd[0] is for reading */
1216         const struct built_in_command *x;
1217         struct child_prog *child;
1218
1219         nextin = 0;
1220         for (i = 0; i < newjob->num_progs; i++) {
1221                 child = &(newjob->progs[i]);
1222
1223                 nextout = 1;
1224                 if ((i + 1) < newjob->num_progs) {
1225                         xpipe(pipefds);
1226                         nextout = pipefds[1];
1227                 } else if (outpipe[1] != -1) {
1228                         nextout = outpipe[1];
1229                 }
1230
1231                 /* Check if the command matches any non-forking builtins,
1232                  * but only if this is a simple command.
1233                  * Non-forking builtins within pipes have to fork anyway,
1234                  * and are handled in pseudo_exec.  "echo foo | read bar"
1235                  * is doomed to failure, and doesn't work on bash, either.
1236                  */
1237                 if (newjob->num_progs == 1) {
1238                         int rcode;
1239                         int squirrel[] = {-1, -1, -1};
1240
1241                         /* Check if the command sets an environment variable. */
1242                         if (strchr(child->argv[0], '=') != NULL) {
1243                                 child->argv[1] = child->argv[0];
1244                                 return builtin_export(child);
1245                         }
1246
1247                         for (x = bltins; x <= &VEC_LAST(bltins); x++) {
1248                                 if (strcmp(child->argv[0], x->cmd) == 0) {
1249                                         setup_redirects(child, squirrel);
1250                                         rcode = x->function(child);
1251                                         restore_redirects(squirrel);
1252                                         return rcode;
1253                                 }
1254                         }
1255 #if ENABLE_FEATURE_SH_STANDALONE
1256                         {
1257                                 const struct bb_applet *a = find_applet_by_name(child->argv[i]);
1258                                 if (a && a->nofork) {
1259                                         setup_redirects(child, squirrel);
1260                                         rcode = run_nofork_applet(a, child->argv + i);
1261                                         restore_redirects(squirrel);
1262                                         return rcode;
1263                                 }
1264                         }
1265 #endif
1266                 }
1267
1268 #if BB_MMU
1269                 child->pid = fork();
1270 #else
1271                 child->pid = vfork();
1272 #endif
1273                 if (!child->pid) {
1274                         /* Set the handling for job control signals back to the default.  */
1275                         signal(SIGINT, SIG_DFL);
1276                         signal(SIGQUIT, SIG_DFL);
1277                         signal(SIGTSTP, SIG_DFL);
1278                         signal(SIGTTIN, SIG_DFL);
1279                         signal(SIGTTOU, SIG_DFL);
1280                         signal(SIGCHLD, SIG_DFL);
1281
1282                         /* Close all open filehandles. */
1283                         while (close_me_list)
1284                                 close((long)llist_pop(&close_me_list));
1285
1286                         if (outpipe[1] != -1) {
1287                                 close(outpipe[0]);
1288                         }
1289                         if (nextin != 0) {
1290                                 dup2(nextin, 0);
1291                                 close(nextin);
1292                         }
1293
1294                         if (nextout != 1) {
1295                                 dup2(nextout, 1);
1296                                 dup2(nextout, 2);  /* Really? */
1297                                 close(nextout);
1298                                 close(pipefds[0]);
1299                         }
1300
1301                         /* explicit redirects override pipes */
1302                         setup_redirects(child,NULL);
1303
1304                         pseudo_exec(child);
1305                 }
1306                 if (outpipe[1] != -1) {
1307                         close(outpipe[1]);
1308                 }
1309
1310                 /* put our child in the process group whose leader is the
1311                    first process in this pipe */
1312                 setpgid(child->pid, newjob->progs[0].pid);
1313                 if (nextin != 0)
1314                         close(nextin);
1315                 if (nextout != 1)
1316                         close(nextout);
1317
1318                 /* If there isn't another process, nextin is garbage
1319                    but it doesn't matter */
1320                 nextin = pipefds[0];
1321         }
1322
1323         newjob->pgrp = newjob->progs[0].pid;
1324
1325         insert_job(newjob, inbg);
1326
1327         return 0;
1328 }
1329
1330 static int busy_loop(FILE * input)
1331 {
1332         char *command;
1333         char *next_command = NULL;
1334         struct job newjob;
1335         int i;
1336         int inbg = 0;
1337         int status;
1338 #if ENABLE_LASH_JOB_CONTROL
1339         pid_t  parent_pgrp;
1340         /* save current owner of TTY so we can restore it on exit */
1341         parent_pgrp = tcgetpgrp(shell_terminal);
1342 #endif
1343         newjob.job_list = &job_list;
1344         newjob.job_context = DEFAULT_CONTEXT;
1345
1346         command = xzalloc(BUFSIZ);
1347
1348         while (1) {
1349                 if (!job_list.fg) {
1350                         /* no job is in the foreground */
1351
1352                         /* see if any background processes have exited */
1353                         checkjobs(&job_list);
1354
1355                         if (!next_command) {
1356                                 if (get_command_bufsiz(input, command))
1357                                         break;
1358                                 next_command = command;
1359                         }
1360
1361                         if (!expand_arguments(next_command)) {
1362                                 free(command);
1363                                 command = xzalloc(BUFSIZ);
1364                                 next_command = NULL;
1365                                 continue;
1366                         }
1367
1368                         if (!parse_command(&next_command, &newjob, &inbg) &&
1369                                 newjob.num_progs) {
1370                                 int pipefds[2] = { -1, -1 };
1371                                 debug_printf("job=%p fed to run_command by busy_loop()'\n",
1372                                                 &newjob);
1373                                 run_command(&newjob, inbg, pipefds);
1374                         }
1375                         else {
1376                                 free(command);
1377                                 command = xzalloc(BUFSIZ);
1378                                 next_command = NULL;
1379                         }
1380                 } else {
1381                         /* a job is running in the foreground; wait for it */
1382                         i = 0;
1383                         while (!job_list.fg->progs[i].pid ||
1384                                    job_list.fg->progs[i].is_stopped == 1) i++;
1385
1386                         if (waitpid(job_list.fg->progs[i].pid, &status, WUNTRACED) < 0) {
1387                                 if (errno != ECHILD) {
1388                                         bb_perror_msg_and_die("waitpid(%d)", job_list.fg->progs[i].pid);
1389                                 }
1390                         }
1391
1392                         if (WIFEXITED(status) || WIFSIGNALED(status)) {
1393                                 /* the child exited */
1394                                 job_list.fg->running_progs--;
1395                                 job_list.fg->progs[i].pid = 0;
1396
1397                                 last_return_code = WEXITSTATUS(status);
1398
1399                                 if (!job_list.fg->running_progs) {
1400                                         /* child exited */
1401                                         remove_job(&job_list, job_list.fg);
1402                                         job_list.fg = NULL;
1403                                 }
1404                         }
1405 #if ENABLE_LASH_JOB_CONTROL
1406                         else {
1407                                 /* the child was stopped */
1408                                 job_list.fg->stopped_progs++;
1409                                 job_list.fg->progs[i].is_stopped = 1;
1410
1411                                 if (job_list.fg->stopped_progs == job_list.fg->running_progs) {
1412                                         printf("\n" JOB_STATUS_FORMAT, job_list.fg->jobid,
1413                                                    "Stopped", job_list.fg->text);
1414                                         job_list.fg = NULL;
1415                                 }
1416                         }
1417
1418                         if (!job_list.fg) {
1419                                 /* move the shell to the foreground */
1420                                 /* suppress messages when run from /linuxrc mag@sysgo.de */
1421                                 if (tcsetpgrp(shell_terminal, getpgrp()) && errno != ENOTTY)
1422                                         bb_perror_msg("tcsetpgrp");
1423                         }
1424 #endif
1425                 }
1426         }
1427         free(command);
1428
1429 #if ENABLE_LASH_JOB_CONTROL
1430         /* return controlling TTY back to parent process group before exiting */
1431         if (tcsetpgrp(shell_terminal, parent_pgrp) && errno != ENOTTY)
1432                 bb_perror_msg("tcsetpgrp");
1433 #endif
1434
1435         /* return exit status if called with "-c" */
1436         if (input == NULL && WIFEXITED(status))
1437                 return WEXITSTATUS(status);
1438
1439         return 0;
1440 }
1441
1442 #if ENABLE_FEATURE_CLEAN_UP
1443 static void free_memory(void)
1444 {
1445         free(cwd);
1446
1447         if (job_list.fg && !job_list.fg->running_progs) {
1448                 remove_job(&job_list, job_list.fg);
1449         }
1450 }
1451 #else
1452 void free_memory(void);
1453 #endif
1454
1455 #if ENABLE_LASH_JOB_CONTROL
1456 /* Make sure we have a controlling tty.  If we get started under a job
1457  * aware app (like bash for example), make sure we are now in charge so
1458  * we don't fight over who gets the foreground */
1459 static void setup_job_control(void)
1460 {
1461         int status;
1462         pid_t shell_pgrp;
1463
1464         /* Loop until we are in the foreground.  */
1465         while ((status = tcgetpgrp(shell_terminal)) >= 0) {
1466                 shell_pgrp = getpgrp();
1467                 if (status == shell_pgrp) {
1468                         break;
1469                 }
1470                 kill(- shell_pgrp, SIGTTIN);
1471         }
1472
1473         /* Ignore interactive and job-control signals.  */
1474         signal(SIGINT, SIG_IGN);
1475         signal(SIGQUIT, SIG_IGN);
1476         signal(SIGTSTP, SIG_IGN);
1477         signal(SIGTTIN, SIG_IGN);
1478         signal(SIGTTOU, SIG_IGN);
1479         signal(SIGCHLD, SIG_IGN);
1480
1481         /* Put ourselves in our own process group.  */
1482         setsid();
1483         shell_pgrp = getpid();
1484         setpgid(shell_pgrp, shell_pgrp);
1485
1486         /* Grab control of the terminal.  */
1487         tcsetpgrp(shell_terminal, shell_pgrp);
1488 }
1489 #else
1490 static inline void setup_job_control(void)
1491 {
1492 }
1493 #endif
1494
1495 int lash_main(int argc_l, char **argv_l);
1496 int lash_main(int argc_l, char **argv_l)
1497 {
1498         unsigned opt;
1499         FILE *input = stdin;
1500         argc = argc_l;
1501         argv = argv_l;
1502
1503 #if ENABLE_FEATURE_EDITING
1504         line_input_state = new_line_input_t(FOR_SHELL);
1505 #endif
1506
1507         /* These variables need re-initializing when recursing */
1508         last_jobid = 0;
1509         close_me_list = NULL;
1510         job_list.head = NULL;
1511         job_list.fg = NULL;
1512         last_return_code = 1;
1513
1514         if (argv[0] && argv[0][0] == '-') {
1515                 FILE *prof_input;
1516                 prof_input = fopen("/etc/profile", "r");
1517                 if (prof_input) {
1518                         llist_add_to(&close_me_list, (void *)(long)fileno(prof_input));
1519                         /* Now run the file */
1520                         busy_loop(prof_input);
1521                         fclose_if_not_stdin(prof_input);
1522                         llist_pop(&close_me_list);
1523                 }
1524         }
1525
1526         opt = getopt32(argv_l, "+ic:", &local_pending_command);
1527 #define LASH_OPT_i (1<<0)
1528 #define LASH_OPT_c (1<<1)
1529         if (opt & LASH_OPT_c) {
1530                 input = NULL;
1531                 optind++;
1532                 argv += optind;
1533         }
1534         /* A shell is interactive if the `-i' flag was given, or if all of
1535          * the following conditions are met:
1536          *        no -c command
1537          *    no arguments remaining or the -s flag given
1538          *    standard input is a terminal
1539          *    standard output is a terminal
1540          *    Refer to Posix.2, the description of the `sh' utility. */
1541         if (argv[optind] == NULL && input == stdin
1542          && isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)
1543         ) {
1544                 opt |= LASH_OPT_i;
1545         }
1546         setup_job_control();
1547         if (opt & LASH_OPT_i) {
1548                 /* Looks like they want an interactive shell */
1549                 if (!ENABLE_FEATURE_SH_EXTRA_QUIET) {
1550                         printf("\n\n%s built-in shell (lash)\n"
1551                                         "Enter 'help' for a list of built-in commands.\n\n",
1552                                         bb_banner);
1553                 }
1554         } else if (!local_pending_command && argv[optind]) {
1555                 //printf( "optind=%d  argv[optind]='%s'\n", optind, argv[optind]);
1556                 input = xfopen(argv[optind], "r");
1557                 /* be lazy, never mark this closed */
1558                 llist_add_to(&close_me_list, (void *)(long)fileno(input));
1559         }
1560
1561         /* initialize the cwd -- this is never freed...*/
1562         update_cwd();
1563
1564         if (ENABLE_FEATURE_CLEAN_UP) atexit(free_memory);
1565
1566         if (ENABLE_FEATURE_EDITING) cmdedit_set_initial_prompt();
1567         else PS1 = NULL;
1568
1569         return busy_loop(input);
1570 }