1 /* vi: set sw=4 ts=4: */
3 * lash -- the BusyBox Lame-Ass SHell
5 * Copyright (C) 2000 by Lineo, inc.
6 * Written by Erik Andersen <andersen@lineo.com>, <andersee@debian.org>
8 * Based in part on ladsh.c by Michael K. Johnson and Erik W. Troan, which is
9 * under the following liberal license: "We have placed this source code in the
10 * public domain. Use it in any project, free or commercial."
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 //This works pretty well now, and is not on by default.
30 #define BB_FEATURE_SH_ENVIRONMENT
32 //Backtick support has some problems, use at your own risk!
33 //#define BB_FEATURE_SH_BACKTICKS
35 //If, then, else, etc. support.. This should now behave basically
36 //like any other Bourne shell...
37 //#define BB_FEATURE_SH_IF_EXPRESSIONS
39 /* This is currently a little broken... */
40 //#define HANDLE_CONTINUATION_CHARS
42 //For debugging/development on the shell only...
55 #include <sys/ioctl.h>
61 #define MAX_LINE 256 /* size of input buffer for cwd data */
62 #define MAX_READ 128 /* size of input buffer for `read' builtin */
63 #define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
64 extern size_t NUM_APPLETS;
67 enum redir_type { REDIRECT_INPUT, REDIRECT_OVERWRITE,
71 static const unsigned int DEFAULT_CONTEXT=0x1;
72 static const unsigned int IF_TRUE_CONTEXT=0x2;
73 static const unsigned int IF_FALSE_CONTEXT=0x4;
74 static const unsigned int THEN_EXP_CONTEXT=0x8;
75 static const unsigned int ELSE_EXP_CONTEXT=0x10;
76 unsigned int shell_context = 0;
81 struct job *head; /* head of list of running jobs */
82 struct job *fg; /* current foreground job */
86 enum redir_type type; /* type of redirection */
87 int fd; /* file descriptor being redirected */
88 char *filename; /* file to redirect fd to */
92 pid_t pid; /* 0 if exited */
93 char **argv; /* program name and arguments */
94 int num_redirects; /* elements in redirection array */
95 struct redir_struct *redirects; /* I/O redirects */
96 glob_t glob_result; /* result of parameter globbing */
97 int free_glob; /* should we globfree(&glob_result)? */
98 int is_stopped; /* is the program currently running? */
99 struct job *family; /* pointer back to the child's parent job */
103 int jobid; /* job number */
104 int num_progs; /* total number of programs in job */
105 int running_progs; /* number of programs running */
106 char *text; /* name of job */
107 char *cmdbuf; /* buffer various argv's point into */
108 pid_t pgrp; /* process group ID for the job */
109 struct child_prog *progs; /* array of programs in job */
110 struct job *next; /* to track background commands */
111 int stopped_progs; /* number of programs alive, but stopped */
112 unsigned int job_context; /* bitmask defining current context */
113 struct jobset *job_list;
116 struct built_in_command {
117 char *cmd; /* name */
118 char *descr; /* description */
119 int (*function) (struct child_prog *); /* function ptr */
122 /* function prototypes for builtins */
123 static int builtin_cd(struct child_prog *cmd);
124 static int builtin_env(struct child_prog *dummy);
125 static int builtin_exec(struct child_prog *cmd);
126 static int builtin_exit(struct child_prog *cmd);
127 static int builtin_fg_bg(struct child_prog *cmd);
128 static int builtin_help(struct child_prog *cmd);
129 static int builtin_jobs(struct child_prog *dummy);
130 static int builtin_pwd(struct child_prog *dummy);
131 static int builtin_export(struct child_prog *cmd);
132 static int builtin_source(struct child_prog *cmd);
133 static int builtin_unset(struct child_prog *cmd);
134 static int builtin_read(struct child_prog *cmd);
135 #ifdef BB_FEATURE_SH_IF_EXPRESSIONS
136 static int builtin_if(struct child_prog *cmd);
137 static int builtin_then(struct child_prog *cmd);
138 static int builtin_else(struct child_prog *cmd);
139 static int builtin_fi(struct child_prog *cmd);
140 /* function prototypes for shell stuff */
141 static int run_command_predicate(char *cmd);
145 /* function prototypes for shell stuff */
146 static void checkjobs(struct jobset *job_list);
147 static int get_command(FILE * source, char *command);
148 static int parse_command(char **command_ptr, struct job *job, int *inbg);
149 static int run_command(struct job *newjob, int inbg, int outpipe[2]);
150 static int pseudo_exec(struct child_prog *cmd) __attribute__ ((noreturn));
151 static int busy_loop(FILE * input);
154 /* Table of built-in functions (these are non-forking builtins, meaning they
155 * can change global variables in the parent shell process but they will not
156 * work with pipes and redirects; 'unset foo | whatever' will not work) */
157 static struct built_in_command bltins[] = {
158 {"bg", "Resume a job in the background", builtin_fg_bg},
159 {"cd", "Change working directory", builtin_cd},
160 {"exec", "Exec command, replacing this shell with the exec'd process", builtin_exec},
161 {"exit", "Exit from shell()", builtin_exit},
162 {"fg", "Bring job into the foreground", builtin_fg_bg},
163 {"jobs", "Lists the active jobs", builtin_jobs},
164 {"export", "Set environment variable", builtin_export},
165 {"unset", "Unset environment variable", builtin_unset},
166 {"read", "Input environment variable", builtin_read},
167 {".", "Source-in and run commands in a file", builtin_source},
168 /* to do: add ulimit */
169 #ifdef BB_FEATURE_SH_IF_EXPRESSIONS
170 {"if", NULL, builtin_if},
171 {"then", NULL, builtin_then},
172 {"else", NULL, builtin_else},
173 {"fi", NULL, builtin_fi},
178 /* Table of forking built-in functions (things that fork cannot change global
179 * variables in the parent process, such as the current working directory) */
180 static struct built_in_command bltins_forking[] = {
181 {"env", "Print all environment variables", builtin_env},
182 {"pwd", "Print current directory", builtin_pwd},
183 {"help", "List shell built-in commands", builtin_help},
187 static char prompt[3];
189 static char *local_pending_command = NULL;
190 static char *prompt_str = NULL;
191 static struct jobset job_list = { NULL, NULL };
194 #ifdef BB_FEATURE_SH_ENVIRONMENT
195 static int last_bg_pid=-1;
196 static int last_return_code=-1;
197 static int show_x_trace=FALSE;
199 #ifdef BB_FEATURE_SH_IF_EXPRESSIONS
200 static char syntax_err[]="syntax error near unexpected token";
204 static inline void debug_printf(const char *format, ...)
207 va_start(args, format);
208 vfprintf(stderr, format, args);
212 static inline void debug_printf(const char *format, ...) { }
215 #ifdef BB_FEATURE_SH_COMMAND_EDITING
216 static inline void win_changed(int junk)
218 struct winsize win = { 0, 0, 0, 0 };
219 ioctl(0, TIOCGWINSZ, &win);
220 if (win.ws_col > 0) {
221 cmdedit_setwidth( win.ws_col - 1);
225 static inline void win_changed(int junk) {}
229 Most builtins need access to the struct child_prog that has
230 their arguments, previously coded as cmd->progs[0]. That coding
231 can exhibit a bug, if the builtin is not the first command in
232 a pipeline: "echo foo | exec sort" will attempt to exec foo.
234 builtin previous use notes
235 ------ ----------------- ---------
238 exec cmd->progs[0] squashed bug: didn't look for applets or forking builtins
240 fg_bg cmd->progs[0], job_list->head, job_list->fg
244 export cmd->progs[0] passes cmd, job_list to builtin_env(), which ignores them
248 if cmd->job_context, cmd->text
249 then cmd->job_context, cmd->text
250 else cmd->job_context, cmd->text
253 The use of cmd->text by if/then/else/fi is hopelessly hacky.
254 Would it work to increment cmd->progs[0]->argv and recurse,
255 somewhat like builtin_exec does?
257 I added "struct job *family;" to struct child_prog,
258 and switched API to builtin_foo(struct child_prog *child);
259 So cmd->text becomes child->family->text
260 cmd->job_context becomes child->family->job_context
261 cmd->progs[0] becomes *child
262 job_list becomes child->family->job_list
265 /* built-in 'cd <path>' handler */
266 static int builtin_cd(struct child_prog *child)
270 if (child->argv[1] == NULL)
271 newdir = getenv("HOME");
273 newdir = child->argv[1];
275 printf("cd: %s: %s\n", newdir, strerror(errno));
278 getcwd(cwd, sizeof(char)*MAX_LINE);
283 /* built-in 'env' handler */
284 static int builtin_env(struct child_prog *dummy)
288 for (e = environ; *e; e++) {
289 fprintf(stdout, "%s\n", *e);
294 /* built-in 'exec' handler */
295 static int builtin_exec(struct child_prog *child)
297 if (child->argv[1] == NULL)
298 return EXIT_SUCCESS; /* Really? */
304 /* built-in 'exit' handler */
305 static int builtin_exit(struct child_prog *child)
307 if (child->argv[1] == NULL)
310 exit (atoi(child->argv[1]));
313 /* built-in 'fg' and 'bg' handler */
314 static int builtin_fg_bg(struct child_prog *child)
317 struct job *job=NULL;
320 if (!child->argv[1] || child->argv[2]) {
321 error_msg("%s: exactly one argument is expected\n",
325 if (sscanf(child->argv[1], "%%%d", &jobNum) != 1) {
326 error_msg("%s: bad argument '%s'\n",
327 child->argv[0], child->argv[1]);
330 for (job = child->family->job_list->head; job; job = job->next) {
331 if (job->jobid == jobNum) {
337 error_msg("%s: unknown job %d\n",
338 child->argv[0], jobNum);
342 if (*child->argv[0] == 'f') {
343 /* Make this job the foreground job */
344 /* suppress messages when run from /linuxrc mag@sysgo.de */
345 if (tcsetpgrp(0, job->pgrp) && errno != ENOTTY)
347 child->family->job_list->fg = job;
350 /* Restart the processes in the job */
351 for (i = 0; i < job->num_progs; i++)
352 job->progs[i].is_stopped = 0;
354 kill(-job->pgrp, SIGCONT);
356 job->stopped_progs = 0;
361 /* built-in 'help' handler */
362 static int builtin_help(struct child_prog *dummy)
364 struct built_in_command *x;
366 printf("\nBuilt-in commands:\n");
367 printf("-------------------\n");
368 for (x = bltins; x->cmd; x++) {
371 printf("%s\t%s\n", x->cmd, x->descr);
373 for (x = bltins_forking; x->cmd; x++) {
376 printf("%s\t%s\n", x->cmd, x->descr);
382 /* built-in 'jobs' handler */
383 static int builtin_jobs(struct child_prog *child)
388 for (job = child->family->job_list->head; job; job = job->next) {
389 if (job->running_progs == job->stopped_progs)
390 status_string = "Stopped";
392 status_string = "Running";
394 printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text);
400 /* built-in 'pwd' handler */
401 static int builtin_pwd(struct child_prog *dummy)
403 getcwd(cwd, MAX_LINE);
404 fprintf(stdout, "%s\n", cwd);
408 /* built-in 'export VAR=value' handler */
409 static int builtin_export(struct child_prog *child)
413 if (child->argv[1] == NULL) {
414 return (builtin_env(child));
416 res = putenv(child->argv[1]);
418 fprintf(stderr, "export: %s\n", strerror(errno));
422 /* built-in 'read VAR' handler */
423 static int builtin_read(struct child_prog *child)
425 int res = 0, len, newlen;
427 char string[MAX_READ];
429 if (child->argv[1]) {
430 /* argument (VAR) given: put "VAR=" into buffer */
431 strcpy(string, child->argv[1]);
432 len = strlen(string);
435 fgets(&string[len], sizeof(string) - len, stdin); /* read string */
436 newlen = strlen(string);
438 string[--newlen] = '\0'; /* chomp trailing newline */
440 ** string should now contain "VAR=<value>"
441 ** copy it (putenv() won't do that, so we must make sure
442 ** the string resides in a static buffer!)
445 if((s = strdup(string)))
448 fprintf(stderr, "read: %s\n", strerror(errno));
451 fgets(string, sizeof(string), stdin);
456 #ifdef BB_FEATURE_SH_IF_EXPRESSIONS
457 /* Built-in handler for 'if' commands */
458 static int builtin_if(struct child_prog *child)
460 struct job *cmd = child->family;
462 char* charptr1=cmd->text+3; /* skip over the leading 'if ' */
464 /* Now run the 'if' command */
465 debug_printf( "job=%p entering builtin_if ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
466 status = run_command_predicate(charptr1);
467 debug_printf( "if test returned ");
469 debug_printf( "TRUE\n");
470 cmd->job_context |= IF_TRUE_CONTEXT;
472 debug_printf( "FALSE\n");
473 cmd->job_context |= IF_FALSE_CONTEXT;
475 debug_printf("job=%p builtin_if set job context to %x\n", cmd, cmd->job_context);
481 /* Built-in handler for 'then' (part of the 'if' command) */
482 static int builtin_then(struct child_prog *child)
484 struct job *cmd = child->family;
485 char* charptr1=cmd->text+5; /* skip over the leading 'then ' */
487 debug_printf( "job=%p entering builtin_then ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
488 if (! (cmd->job_context & (IF_TRUE_CONTEXT|IF_FALSE_CONTEXT))) {
489 shell_context = 0; /* Reset the shell's context on an error */
490 error_msg("%s `then'\n", syntax_err);
494 cmd->job_context |= THEN_EXP_CONTEXT;
495 debug_printf("job=%p builtin_then set job context to %x\n", cmd, cmd->job_context);
497 /* If the if result was FALSE, skip the 'then' stuff */
498 if (cmd->job_context & IF_FALSE_CONTEXT) {
502 /* Seems the if result was TRUE, so run the 'then' command */
503 debug_printf( "'then' now running '%s'\n", charptr1);
505 return(run_command_predicate(charptr1));
508 /* Built-in handler for 'else' (part of the 'if' command) */
509 static int builtin_else(struct child_prog *child)
511 struct job *cmd = child->family;
512 char* charptr1=cmd->text+5; /* skip over the leading 'else ' */
514 debug_printf( "job=%p entering builtin_else ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
516 if (! (cmd->job_context & THEN_EXP_CONTEXT)) {
517 shell_context = 0; /* Reset the shell's context on an error */
518 error_msg("%s `else'\n", syntax_err);
521 /* If the if result was TRUE, skip the 'else' stuff */
522 if (cmd->job_context & IF_TRUE_CONTEXT) {
526 cmd->job_context |= ELSE_EXP_CONTEXT;
527 debug_printf("job=%p builtin_else set job context to %x\n", child->family, cmd->job_context);
529 /* Now run the 'else' command */
530 debug_printf( "'else' now running '%s'\n", charptr1);
531 return(run_command_predicate(charptr1));
534 /* Built-in handler for 'fi' (part of the 'if' command) */
535 static int builtin_fi(struct child_prog *child)
537 struct job *cmd = child->family;
538 debug_printf( "job=%p entering builtin_fi ('%s')-- context=%d\n", cmd, "", cmd->job_context);
539 if (! (cmd->job_context & (IF_TRUE_CONTEXT|IF_FALSE_CONTEXT))) {
540 shell_context = 0; /* Reset the shell's context on an error */
541 error_msg("%s `fi'\n", syntax_err);
544 /* Clear out the if and then context bits */
545 cmd->job_context &= ~(IF_TRUE_CONTEXT|IF_FALSE_CONTEXT|THEN_EXP_CONTEXT|ELSE_EXP_CONTEXT);
546 debug_printf("job=%p builtin_fi set job context to %x\n", cmd, cmd->job_context);
552 /* Built-in '.' handler (read-in and execute commands from file) */
553 static int builtin_source(struct child_prog *child)
558 if (child->argv[1] == NULL)
561 input = fopen(child->argv[1], "r");
563 fprintf(stdout, "Couldn't open file '%s'\n", child->argv[1]);
567 /* Now run the file */
568 status = busy_loop(input);
573 /* built-in 'unset VAR' handler */
574 static int builtin_unset(struct child_prog *child)
576 if (child->argv[1] == NULL) {
577 fprintf(stdout, "unset: parameter required.\n");
580 unsetenv(child->argv[1]);
584 #ifdef BB_FEATURE_SH_IF_EXPRESSIONS
585 /* currently used by if/then/else.
586 * Needlessly (?) forks and reparses the command line.
587 * But pseudo_exec on the pre-parsed args doesn't have the
588 * "fork, stick around until the child exits, and find it's return code"
589 * functionality. The fork is not needed if the predicate is
590 * non-forking builtin, and maybe not even if it's a forking builtin.
591 * applets pretty clearly need the fork.
593 static int run_command_predicate(char *cmd)
596 local_pending_command = xmalloc(n+1);
597 strncpy(local_pending_command, cmd, n);
598 local_pending_command[n]='\0';
599 return( busy_loop(NULL));
603 /* free up all memory from a job */
604 static void free_job(struct job *cmd)
608 for (i = 0; i < cmd->num_progs; i++) {
609 free(cmd->progs[i].argv);
610 if (cmd->progs[i].redirects)
611 free(cmd->progs[i].redirects);
612 if (cmd->progs[i].free_glob)
613 globfree(&cmd->progs[i].glob_result);
619 memset(cmd, 0, sizeof(struct job));
622 /* remove a job from the job_list */
623 static void remove_job(struct jobset *job_list, struct job *job)
628 if (job == job_list->head) {
629 job_list->head = job->next;
631 prevjob = job_list->head;
632 while (prevjob->next != job)
633 prevjob = prevjob->next;
634 prevjob->next = job->next;
640 /* Checks to see if any background processes have exited -- if they
641 have, figure out why and see if a job has completed */
642 static void checkjobs(struct jobset *job_list)
649 while ((childpid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
650 for (job = job_list->head; job; job = job->next) {
652 while (prognum < job->num_progs &&
653 job->progs[prognum].pid != childpid) prognum++;
654 if (prognum < job->num_progs)
658 /* This happens on backticked commands */
662 if (WIFEXITED(status) || WIFSIGNALED(status)) {
664 job->running_progs--;
665 job->progs[prognum].pid = 0;
667 if (!job->running_progs) {
668 printf(JOB_STATUS_FORMAT, job->jobid, "Done", job->text);
669 remove_job(job_list, job);
673 job->stopped_progs++;
674 job->progs[prognum].is_stopped = 1;
676 if (job->stopped_progs == job->num_progs) {
677 printf(JOB_STATUS_FORMAT, job->jobid, "Stopped",
683 if (childpid == -1 && errno != ECHILD)
687 static int setup_redirects(struct child_prog *prog)
692 struct redir_struct *redir = prog->redirects;
694 for (i = 0; i < prog->num_redirects; i++, redir++) {
695 switch (redir->type) {
699 case REDIRECT_OVERWRITE:
700 mode = O_WRONLY | O_CREAT | O_TRUNC;
702 case REDIRECT_APPEND:
703 mode = O_WRONLY | O_CREAT | O_APPEND;
707 openfd = open(redir->filename, mode, 0666);
709 /* this could get lost if stderr has been redirected, but
710 bash and ash both lose it as well (though zsh doesn't!) */
711 error_msg("error opening %s: %s\n", redir->filename,
716 if (openfd != redir->fd) {
717 dup2(openfd, redir->fd);
726 static int get_command(FILE * source, char *command)
728 char user[9],buf[255],*s;
730 if (source == NULL) {
731 if (local_pending_command) {
732 /* a command specified (-c option): return it & mark it done */
733 strcpy(command, local_pending_command);
734 free(local_pending_command);
735 local_pending_command = NULL;
741 if (shell_context == 0) {
742 /* get User Name and setup prompt */
743 strcpy(prompt,( geteuid() != 0 ) ? "$ ":"# ");
744 my_getpwuid(user, geteuid());
747 gethostname(buf, 255);
748 s = strchr(buf, '.');
756 if (source == stdin) {
757 #ifdef BB_FEATURE_SH_COMMAND_EDITING
761 ** enable command line editing only while a command line
762 ** is actually being read; otherwise, we'll end up bequeathing
763 ** atexit() handlers and other unwanted stuff to our
764 ** child processes (rob@sysgo.de)
767 signal(SIGWINCH, win_changed);
768 debug_printf( "in get_command() -- job_context=%d\n", shell_context);
770 if (shell_context == 0) {
771 len=fprintf(stdout, "[%s@%s %s]%s", user, buf,
772 get_last_path_component(cwd), prompt);
774 len=fprintf(stdout, "%s", prompt);
777 prompt_str=(char*)xmalloc(sizeof(char)*(len+1));
778 if (shell_context == 0) {
779 sprintf(prompt_str, "[%s@%s %s]%s", user, buf,
780 get_last_path_component(cwd), prompt);
782 sprintf(prompt_str, "%s", prompt);
784 cmdedit_read_input(prompt_str, command);
787 signal(SIGWINCH, SIG_DFL);
793 while ((i>0) && (*(cwd+i)!='/') ) i--;
794 if (*(cwd+i)=='/') i++;
797 fprintf(stdout, "[%s@%s %s]%s",user, buf, (cwd+i), prompt);
802 if (!fgets(command, BUFSIZ - 2, source)) {
808 /* remove trailing newline */
809 command[strlen(command) - 1] = '\0';
814 #ifdef BB_FEATURE_SH_ENVIRONMENT
815 static char* itoa(register int i)
817 static char a[7]; /* Max 7 ints */
818 register char *b = a + sizeof(a) - 1;
826 *--b = '0' + (i % 10);
836 static void expand_argument(struct child_prog *prog, int *argcPtr,
837 int *argv_alloced_ptr)
839 int argc_l = *argcPtr;
840 int argv_alloced = *argv_alloced_ptr;
844 char *src, *dst, *var;
846 if (argc_l > 1) { /* cmd->glob_result is already initialized */
848 i = prog->glob_result.gl_pathc;
854 /* do shell variable substitution */
855 if(*prog->argv[argc_l - 1] == '$') {
856 if ((var = getenv(prog->argv[argc_l - 1] + 1))) {
857 prog->argv[argc_l - 1] = var;
859 #ifdef BB_FEATURE_SH_ENVIRONMENT
861 switch(*(prog->argv[argc_l - 1] + 1)) {
863 prog->argv[argc_l - 1] = itoa(last_return_code);
866 prog->argv[argc_l - 1] = itoa(getpid());
869 prog->argv[argc_l - 1] = itoa(argc-1);
873 *(prog->argv[argc_l - 1])='\0';
875 prog->argv[argc_l - 1] = itoa(last_bg_pid);
877 case '0':case '1':case '2':case '3':case '4':
878 case '5':case '6':case '7':case '8':case '9':
880 int index=*(prog->argv[argc_l - 1] + 1)-48;
882 *(prog->argv[argc_l - 1])='\0';
884 prog->argv[argc_l - 1] = argv[index];
893 if (strpbrk(prog->argv[argc_l - 1],"*[]?")!= NULL){
894 rc = glob(prog->argv[argc_l - 1], flags, NULL, &prog->glob_result);
895 if (rc == GLOB_NOSPACE) {
896 error_msg("out of space during glob operation\n");
898 } else if (rc == GLOB_NOMATCH ||
899 (!rc && (prog->glob_result.gl_pathc - i) == 1 &&
900 strcmp(prog->argv[argc_l - 1],
901 prog->glob_result.gl_pathv[i]) == 0)) {
902 /* we need to remove whatever \ quoting is still present */
903 src = dst = prog->argv[argc_l - 1];
907 *dst++ = process_escape_sequence(&src);
915 argv_alloced += (prog->glob_result.gl_pathc - i);
916 prog->argv = xrealloc(prog->argv, argv_alloced * sizeof(*prog->argv));
917 memcpy(prog->argv + (argc_l - 1), prog->glob_result.gl_pathv + i,
918 sizeof(*(prog->argv)) * (prog->glob_result.gl_pathc - i));
919 argc_l += (prog->glob_result.gl_pathc - i - 1);
922 src = dst = prog->argv[argc_l - 1];
926 *dst++ = process_escape_sequence(&src);
934 prog->glob_result.gl_pathc=0;
936 prog->glob_result.gl_pathv=NULL;
938 *argv_alloced_ptr = argv_alloced;
942 /* Return cmd->num_progs as 0 if no command is present (e.g. an empty
943 line). If a valid command is found, command_ptr is set to point to
944 the beginning of the next command (if the original command had more
945 then one job associated with it) or NULL if no more commands are
947 static int parse_command(char **command_ptr, struct job *job, int *inbg)
950 char *return_command = NULL;
951 char *src, *buf, *chptr;
958 struct child_prog *prog;
960 /* skip leading white space */
961 while (**command_ptr && isspace(**command_ptr))
964 /* this handles empty lines or leading '#' characters */
965 if (!**command_ptr || (**command_ptr == '#')) {
972 job->progs = xmalloc(sizeof(*job->progs));
974 /* We set the argv elements to point inside of this string. The
975 memory is freed by free_job(). Allocate twice the original
976 length in case we need to quote every single character.
978 Getting clean memory relieves us of the task of NULL
979 terminating things and makes the rest of this look a bit
980 cleaner (though it is, admittedly, a tad less efficient) */
981 job->cmdbuf = command = xcalloc(2*strlen(*command_ptr) + 1, sizeof(char));
985 prog->num_redirects = 0;
986 prog->redirects = NULL;
988 prog->is_stopped = 0;
992 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
993 prog->argv[0] = job->cmdbuf;
997 while (*src && !done) {
1004 error_msg("character expected after \\\n");
1009 /* in shell, "\'" should yield \' */
1010 if (*src != quote) {
1014 } else if (*src == '*' || *src == '?' || *src == '[' ||
1015 *src == ']') *buf++ = '\\';
1017 } else if (isspace(*src)) {
1018 if (*prog->argv[argc_l]) {
1020 /* +1 here leaves room for the NULL which ends argv */
1021 if ((argc_l + 1) == argv_alloced) {
1023 prog->argv = xrealloc(prog->argv,
1024 sizeof(*prog->argv) *
1027 expand_argument(prog, &argc_l, &argv_alloced);
1028 prog->argv[argc_l] = buf;
1037 case '#': /* comment */
1044 case '>': /* redirects */
1046 i = prog->num_redirects++;
1047 prog->redirects = xrealloc(prog->redirects,
1048 sizeof(*prog->redirects) *
1051 prog->redirects[i].fd = -1;
1052 if (buf != prog->argv[argc_l]) {
1053 /* the stuff before this character may be the file number
1055 prog->redirects[i].fd =
1056 strtol(prog->argv[argc_l], &chptr, 10);
1058 if (*chptr && *prog->argv[argc_l]) {
1060 expand_argument(prog, &argc_l, &argv_alloced);
1061 prog->argv[argc_l] = buf;
1065 if (prog->redirects[i].fd == -1) {
1067 prog->redirects[i].fd = 1;
1069 prog->redirects[i].fd = 0;
1072 if (*src++ == '>') {
1074 prog->redirects[i].type =
1075 REDIRECT_APPEND, src++;
1077 prog->redirects[i].type = REDIRECT_OVERWRITE;
1079 prog->redirects[i].type = REDIRECT_INPUT;
1082 /* This isn't POSIX sh compliant. Oh well. */
1084 while (isspace(*chptr))
1088 error_msg("file name expected after %c\n", *src);
1094 prog->redirects[i].filename = buf;
1095 while (*chptr && !isspace(*chptr))
1098 src = chptr - 1; /* we src++ later */
1099 prog->argv[argc_l] = ++buf;
1102 case '|': /* pipe */
1103 /* finish this command */
1104 if (*prog->argv[argc_l])
1107 error_msg("empty command in pipe\n");
1112 prog->argv[argc_l] = NULL;
1114 /* and start the next */
1116 job->progs = xrealloc(job->progs,
1117 sizeof(*job->progs) * job->num_progs);
1118 prog = job->progs + (job->num_progs - 1);
1119 prog->num_redirects = 0;
1120 prog->redirects = NULL;
1121 prog->free_glob = 0;
1122 prog->is_stopped = 0;
1127 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
1128 prog->argv[0] = ++buf;
1131 while (*src && isspace(*src))
1135 error_msg("empty command in pipe\n");
1140 src--; /* we'll ++ it at the end of the loop */
1144 case '&': /* background */
1146 case ';': /* multiple commands */
1148 return_command = *command_ptr + (src - *command_ptr) + 1;
1151 #ifdef BB_FEATURE_SH_BACKTICKS
1153 /* Exec a backtick-ed command */
1155 char* charptr1=NULL, *charptr2;
1158 struct jobset njob_list = { NULL, NULL };
1162 ptr=strchr(++src, '`');
1164 fprintf(stderr, "Unmatched '`' in command\n");
1169 /* Make some space to hold just the backticked command */
1170 charptr1 = charptr2 = xmalloc(1+ptr-src);
1171 memcpy(charptr1, src, ptr-src);
1172 charptr1[ptr-src] = '\0';
1173 newjob = xmalloc(sizeof(struct job));
1174 newjob->job_list = &njob_list;
1175 /* Now parse and run the backticked command */
1176 if (!parse_command(&charptr1, newjob, inbg)
1177 && newjob->num_progs) {
1179 run_command(newjob, 0, pipefd);
1181 checkjobs(job->job_list);
1182 free_job(newjob); /* doesn't actually free newjob,
1183 looks like a memory leak */
1186 /* Make a copy of any stuff left over in the command
1187 * line after the second backtick */
1188 charptr2 = xmalloc(strlen(ptr)+1);
1189 memcpy(charptr2, ptr+1, strlen(ptr));
1192 /* Copy the output from the backtick-ed command into the
1193 * command line, making extra room as needed */
1195 charptr1 = xmalloc(BUFSIZ);
1196 while ( (size=full_read(pipefd[0], charptr1, BUFSIZ-1)) >0) {
1197 int newsize=src - *command_ptr + size + 1 + strlen(charptr2);
1198 if (newsize > BUFSIZ) {
1199 *command_ptr=xrealloc(*command_ptr, newsize);
1201 memcpy(src, charptr1, size);
1209 /* Now paste into the *command_ptr all the stuff
1210 * leftover after the second backtick */
1211 memcpy(src, charptr2, strlen(charptr2)+1);
1214 /* Now recursively call parse_command to deal with the new
1215 * and improved version of the command line with the backtick
1216 * results expanded in place... */
1218 struct jobset *jl=job->job_list;
1222 return(parse_command(command_ptr, job, inbg));
1225 #endif // BB_FEATURE_SH_BACKTICKS
1230 /* This is currently a little broken... */
1231 #ifdef HANDLE_CONTINUATION_CHARS
1232 /* They fed us a continuation char, so continue reading stuff
1233 * on the next line, then tack that onto the end of the current
1237 printf("erik: found a continue char at EOL...\n");
1238 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1239 if (get_command(input, command)) {
1240 error_msg("character expected after \\\n");
1245 newsize = strlen(*command_ptr) + strlen(command) + 2;
1246 if (newsize > BUFSIZ) {
1247 printf("erik: doing realloc\n");
1248 *command_ptr=xrealloc(*command_ptr, newsize);
1250 printf("erik: A: *command_ptr='%s'\n", *command_ptr);
1251 memcpy(--src, command, strlen(command));
1252 printf("erik: B: *command_ptr='%s'\n", *command_ptr);
1256 error_msg("character expected after \\\n");
1262 if (*src == '*' || *src == '[' || *src == ']'
1263 || *src == '?') *buf++ = '\\';
1272 if (*prog->argv[argc_l]) {
1274 expand_argument(prog, &argc_l, &argv_alloced);
1280 prog->argv[argc_l] = NULL;
1282 if (!return_command) {
1283 job->text = xmalloc(strlen(*command_ptr) + 1);
1284 strcpy(job->text, *command_ptr);
1286 /* This leaves any trailing spaces, which is a bit sloppy */
1287 count = return_command - *command_ptr;
1288 job->text = xmalloc(count + 1);
1289 strncpy(job->text, *command_ptr, count);
1290 job->text[count] = '\0';
1293 *command_ptr = return_command;
1298 /* Run the child_prog, no matter what kind of command it uses.
1300 static int pseudo_exec(struct child_prog *child)
1302 struct built_in_command *x;
1303 #ifdef BB_FEATURE_SH_STANDALONE_SHELL
1304 struct BB_applet search_applet, *applet;
1307 /* Check if the command matches any of the forking builtins.
1308 * XXX It would probably be wise to check for non-forking builtins
1309 * here as well, since in some context the non-forking path
1310 * is disabled or bypassed. See comment in run_command.
1312 for (x = bltins_forking; x->cmd; x++) {
1313 if (strcmp(child->argv[0], x->cmd) == 0) {
1315 exit (x->function(child));
1318 #ifdef BB_FEATURE_SH_STANDALONE_SHELL
1319 /* Check if the command matches any busybox internal
1320 * commands ("applets") here. Following discussions from
1321 * November 2000 on busybox@opensource.lineo.com, don't use
1322 * get_last_path_component(). This way explicit (with
1323 * slashes) filenames will never be interpreted as an
1324 * applet, just like with builtins. This way the user can
1325 * override an applet with an explicit filename reference.
1326 * The only downside to this change is that an explicit
1327 * /bin/foo invocation will fork and exec /bin/foo, even if
1328 * /bin/foo is a symlink to busybox.
1330 search_applet.name = child->argv[0];
1332 #ifdef BB_FEATURE_SH_APPLETS_ALWAYS_WIN
1333 /* If you enable BB_FEATURE_SH_APPLETS_ALWAYS_WIN, then
1334 * if you run /bin/cat, it will use BusyBox cat even if
1335 * /bin/cat exists on the filesystem and is _not_ busybox.
1336 * Some systems want this, others do not. Choose wisely. :-)
1338 search_applet.name = get_last_path_component(search_applet.name);
1341 /* Do a binary search to find the applet entry given the name. */
1342 applet = bsearch(&search_applet, applets, NUM_APPLETS,
1343 sizeof(struct BB_applet), applet_name_compare);
1344 if (applet != NULL) {
1346 char** argv=child->argv;
1347 for(argc_l=0;*argv!=NULL; argv++, argc_l++);
1348 applet_name=applet->name;
1350 exit((*(applet->main)) (argc_l, child->argv));
1354 execvp(child->argv[0], child->argv);
1355 error_msg_and_die("%s: %s\n", child->argv[0],
1359 static void insert_job(struct job *newjob, int inbg)
1362 struct jobset *job_list=newjob->job_list;
1364 /* find the ID for thejob to use */
1366 for (thejob = job_list->head; thejob; thejob = thejob->next)
1367 if (thejob->jobid >= newjob->jobid)
1368 newjob->jobid = thejob->jobid + 1;
1370 /* add thejob to the list of running jobs */
1371 if (!job_list->head) {
1372 thejob = job_list->head = xmalloc(sizeof(*thejob));
1374 for (thejob = job_list->head; thejob->next; thejob = thejob->next) /* nothing */;
1375 thejob->next = xmalloc(sizeof(*thejob));
1376 thejob = thejob->next;
1379 *thejob = *newjob; /* physically copy the struct job */
1380 thejob->next = NULL;
1381 thejob->running_progs = thejob->num_progs;
1382 thejob->stopped_progs = 0;
1385 /* we don't wait for background thejobs to return -- append it
1386 to the list of backgrounded thejobs and leave it alone */
1387 printf("[%d] %d\n", thejob->jobid,
1388 newjob->progs[newjob->num_progs - 1].pid);
1389 #ifdef BB_FEATURE_SH_ENVIRONMENT
1390 last_bg_pid=newjob->progs[newjob->num_progs - 1].pid;
1393 newjob->job_list->fg = thejob;
1395 /* move the new process group into the foreground */
1396 /* suppress messages when run from /linuxrc mag@sysgo.de */
1397 if (tcsetpgrp(0, newjob->pgrp) && errno != ENOTTY)
1398 perror("tcsetpgrp");
1402 static int run_command(struct job *newjob, int inbg, int outpipe[2])
1404 /* struct job *thejob; */
1406 int nextin, nextout;
1407 int pipefds[2]; /* pipefd[0] is for reading */
1408 struct built_in_command *x;
1409 struct child_prog *child;
1411 nextin = 0, nextout = 1;
1412 for (i = 0; i < newjob->num_progs; i++) {
1413 child = & (newjob->progs[i]);
1415 if ((i + 1) < newjob->num_progs) {
1416 if (pipe(pipefds)<0) perror_msg_and_die("pipe");
1417 nextout = pipefds[1];
1419 if (outpipe[1]!=-1) {
1420 nextout = outpipe[1];
1426 #ifdef BB_FEATURE_SH_ENVIRONMENT
1427 if (show_x_trace==TRUE) {
1430 for (j = 0; child->argv[j]; j++) {
1432 fputs(child->argv[j], stderr);
1434 fputc('\n', stderr);
1438 /* Check if the command matches any non-forking builtins.
1439 * XXX should probably skip this test, and fork anyway, if
1440 * there redirects of some kind demand forking to work right.
1441 * pseudo_exec would then need to handle the non-forking command
1442 * in a forked context.
1444 for (x = bltins; x->cmd; x++) {
1445 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1446 return(x->function(child));
1450 if (!(child->pid = fork())) {
1451 signal(SIGTTOU, SIG_DFL);
1453 if (outpipe[1]!=-1) {
1463 dup2(nextout, 2); /* Really? */
1468 /* explicit redirects override pipes */
1469 setup_redirects(child);
1473 if (outpipe[1]!=-1) {
1477 /* put our child in the process group whose leader is the
1478 first process in this pipe */
1479 setpgid(child->pid, newjob->progs[0].pid);
1485 /* If there isn't another process, nextin is garbage
1486 but it doesn't matter */
1487 nextin = pipefds[0];
1490 newjob->pgrp = newjob->progs[0].pid;
1492 insert_job(newjob, inbg);
1497 static int busy_loop(FILE * input)
1500 char *next_command = NULL;
1506 newjob.job_list = &job_list;
1507 newjob.job_context = DEFAULT_CONTEXT;
1509 /* save current owner of TTY so we can restore it on exit */
1510 parent_pgrp = tcgetpgrp(0);
1512 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1514 /* don't pay any attention to this signal; it just confuses
1515 things and isn't really meant for shells anyway */
1516 signal(SIGTTOU, SIG_IGN);
1520 /* no job is in the foreground */
1522 /* see if any background processes have exited */
1523 checkjobs(&job_list);
1525 if (!next_command) {
1526 if (get_command(input, command))
1528 next_command = command;
1531 if (!parse_command(&next_command, &newjob, &inbg) &&
1533 int pipefds[2] = {-1,-1};
1534 debug_printf( "job=%p being fed to run_command by busy_loop()'\n", &newjob);
1535 run_command(&newjob, inbg, pipefds);
1539 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1540 next_command = NULL;
1543 /* a job is running in the foreground; wait for it */
1545 while (!job_list.fg->progs[i].pid ||
1546 job_list.fg->progs[i].is_stopped == 1) i++;
1548 waitpid(job_list.fg->progs[i].pid, &status, WUNTRACED);
1550 if (WIFEXITED(status) || WIFSIGNALED(status)) {
1551 /* the child exited */
1552 job_list.fg->running_progs--;
1553 job_list.fg->progs[i].pid = 0;
1555 #ifdef BB_FEATURE_SH_ENVIRONMENT
1556 last_return_code=WEXITSTATUS(status);
1558 debug_printf("'%s' exited -- return code %d\n",
1559 job_list.fg->text, last_return_code);
1560 if (!job_list.fg->running_progs) {
1562 remove_job(&job_list, job_list.fg);
1566 /* the child was stopped */
1567 job_list.fg->stopped_progs++;
1568 job_list.fg->progs[i].is_stopped = 1;
1570 if (job_list.fg->stopped_progs == job_list.fg->running_progs) {
1571 printf("\n" JOB_STATUS_FORMAT, job_list.fg->jobid,
1572 "Stopped", job_list.fg->text);
1578 /* move the shell to the foreground */
1579 /* suppress messages when run from /linuxrc mag@sysgo.de */
1580 if (tcsetpgrp(0, getpid()) && errno != ENOTTY)
1581 perror("tcsetpgrp");
1587 /* return controlling TTY back to parent process group before exiting */
1588 if (tcsetpgrp(0, parent_pgrp))
1589 perror("tcsetpgrp");
1591 /* return exit status if called with "-c" */
1592 if (input == NULL && WIFEXITED(status))
1593 return WEXITSTATUS(status);
1599 #ifdef BB_FEATURE_CLEAN_UP
1600 void free_memory(void)
1606 if (local_pending_command)
1607 free(local_pending_command);
1609 if (job_list.fg && !job_list.fg->running_progs) {
1610 remove_job(&job_list, job_list.fg);
1616 int shell_main(int argc_l, char **argv_l)
1618 int opt, interactive=FALSE;
1619 FILE *input = stdin;
1624 if (argv[0] && argv[0][0] == '-') {
1626 input = fopen("/etc/profile", "r");
1628 fprintf(stdout, "Couldn't open file '/etc/profile'\n");
1630 /* Now run the file */
1636 while ((opt = getopt(argc_l, argv_l, "cxi")) > 0) {
1640 if (local_pending_command != 0)
1641 error_msg_and_die("multiple -c arguments\n");
1642 local_pending_command = xstrdup(argv[optind]);
1646 #ifdef BB_FEATURE_SH_ENVIRONMENT
1648 show_x_trace = TRUE;
1658 /* A shell is interactive if the `-i' flag was given, or if all of
1659 * the following conditions are met:
1661 * no arguments remaining or the -s flag given
1662 * standard input is a terminal
1663 * standard output is a terminal
1664 * Refer to Posix.2, the description of the `sh' utility. */
1665 if (argv[optind]==NULL && input==stdin &&
1666 isatty(fileno(stdin)) && isatty(fileno(stdout))) {
1669 if (interactive==TRUE) {
1670 //fprintf(stdout, "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
1671 /* Looks like they want an interactive shell */
1672 fprintf(stdout, "\n\nBusyBox v%s (%s) Built-in shell (lash)\n", BB_VER, BB_BT);
1673 fprintf(stdout, "Enter 'help' for a list of built-in commands.\n\n");
1674 } else if (local_pending_command==NULL) {
1675 //fprintf(stdout, "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
1676 input = xfopen(argv[optind], "r");
1679 /* initialize the cwd -- this is never freed...*/
1680 cwd=(char*)xmalloc(sizeof(char)*MAX_LINE+1);
1681 getcwd(cwd, sizeof(char)*MAX_LINE);
1683 #ifdef BB_FEATURE_CLEAN_UP
1684 atexit(free_memory);
1688 return (busy_loop(input));