aboutsummaryrefslogtreecommitdiff
path: root/sh.c
diff options
context:
space:
mode:
Diffstat (limited to 'sh.c')
-rw-r--r--sh.c1935
1 files changed, 0 insertions, 1935 deletions
diff --git a/sh.c b/sh.c
deleted file mode 100644
index 1d128355c..000000000
--- a/sh.c
+++ /dev/null
@@ -1,1935 +0,0 @@
1/* vi: set sw=4 ts=4: */
2/*
3 * lash -- the BusyBox Lame-Ass SHell
4 *
5 * Copyright (C) 1999,2000,2001 by Lineo, inc.
6 * Written by Erik Andersen <andersen@lineo.com>, <andersee@debian.org>
7 *
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."
11 *
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.
16 *
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.
21 *
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
25 *
26 */
27
28/* The parsing engine of this program is officially at a dead-end.
29 * Future work in that direction should move to the work posted
30 * at http://doolittle.faludi.com/~larry/parser.html .
31 * A start on the integration of that work with the rest of sh.c
32 * is at http://codepoet.org/sh.c .
33 */
34//
35//This works pretty well now, and is now on by default.
36#define BB_FEATURE_SH_ENVIRONMENT
37//
38//Backtick support has some problems, use at your own risk!
39//#define BB_FEATURE_SH_BACKTICKS
40//
41//If, then, else, etc. support.. This should now behave basically
42//like any other Bourne shell -- sortof...
43#define BB_FEATURE_SH_IF_EXPRESSIONS
44//
45/* This is currently sortof broken, only for the brave... */
46#undef HANDLE_CONTINUATION_CHARS
47//
48/* This would be great -- if wordexp wouldn't strip all quoting
49 * out from the target strings... As is, a parser needs */
50#undef BB_FEATURE_SH_WORDEXP
51//
52//For debugging/development on the shell only...
53//#define DEBUG_SHELL
54
55
56#include <stdio.h>
57#include <stdlib.h>
58#include <ctype.h>
59#include <errno.h>
60#include <fcntl.h>
61#include <signal.h>
62#include <string.h>
63#include <sys/ioctl.h>
64#include <sys/wait.h>
65#include <unistd.h>
66#include <getopt.h>
67#include "busybox.h"
68#include "cmdedit.h"
69
70#ifdef BB_LOCALE_SUPPORT
71#include <locale.h>
72#endif
73
74//#define BB_FEATURE_SH_WORDEXP
75
76#ifdef BB_FEATURE_SH_WORDEXP
77#include <wordexp.h>
78#define expand_t wordexp_t
79#undef BB_FEATURE_SH_BACKTICKS
80#else
81#include <glob.h>
82#define expand_t glob_t
83#endif
84
85
86static const int MAX_READ = 128; /* size of input buffer for `read' builtin */
87#define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
88
89
90enum redir_type { REDIRECT_INPUT, REDIRECT_OVERWRITE,
91 REDIRECT_APPEND
92};
93
94static const unsigned int DEFAULT_CONTEXT=0x1;
95static const unsigned int IF_TRUE_CONTEXT=0x2;
96static const unsigned int IF_FALSE_CONTEXT=0x4;
97static const unsigned int THEN_EXP_CONTEXT=0x8;
98static const unsigned int ELSE_EXP_CONTEXT=0x10;
99
100
101struct jobset {
102 struct job *head; /* head of list of running jobs */
103 struct job *fg; /* current foreground job */
104};
105
106struct redir_struct {
107 enum redir_type type; /* type of redirection */
108 int fd; /* file descriptor being redirected */
109 char *filename; /* file to redirect fd to */
110};
111
112struct child_prog {
113 pid_t pid; /* 0 if exited */
114 char **argv; /* program name and arguments */
115 int num_redirects; /* elements in redirection array */
116 struct redir_struct *redirects; /* I/O redirects */
117 int is_stopped; /* is the program currently running? */
118 struct job *family; /* pointer back to the child's parent job */
119};
120
121struct job {
122 int jobid; /* job number */
123 int num_progs; /* total number of programs in job */
124 int running_progs; /* number of programs running */
125 char *text; /* name of job */
126 char *cmdbuf; /* buffer various argv's point into */
127 pid_t pgrp; /* process group ID for the job */
128 struct child_prog *progs; /* array of programs in job */
129 struct job *next; /* to track background commands */
130 int stopped_progs; /* number of programs alive, but stopped */
131 unsigned int job_context; /* bitmask defining current context */
132 struct jobset *job_list;
133};
134
135struct built_in_command {
136 char *cmd; /* name */
137 char *descr; /* description */
138 int (*function) (struct child_prog *); /* function ptr */
139};
140
141struct close_me {
142 int fd;
143 struct close_me *next;
144};
145
146/* function prototypes for builtins */
147static int builtin_cd(struct child_prog *cmd);
148static int builtin_exec(struct child_prog *cmd);
149static int builtin_exit(struct child_prog *cmd);
150static int builtin_fg_bg(struct child_prog *cmd);
151static int builtin_help(struct child_prog *cmd);
152static int builtin_jobs(struct child_prog *dummy);
153static int builtin_pwd(struct child_prog *dummy);
154static int builtin_export(struct child_prog *cmd);
155static int builtin_source(struct child_prog *cmd);
156static int builtin_unset(struct child_prog *cmd);
157static int builtin_read(struct child_prog *cmd);
158#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
159static int builtin_if(struct child_prog *cmd);
160static int builtin_then(struct child_prog *cmd);
161static int builtin_else(struct child_prog *cmd);
162static int builtin_fi(struct child_prog *cmd);
163/* function prototypes for shell stuff */
164static int run_command_predicate(char *cmd);
165#endif
166
167
168/* function prototypes for shell stuff */
169static void mark_open(int fd);
170static void mark_closed(int fd);
171static void close_all(void);
172static void checkjobs(struct jobset *job_list);
173static int get_command(FILE * source, char *command);
174static int parse_command(char **command_ptr, struct job *job, int *inbg);
175static int run_command(struct job *newjob, int inbg, int outpipe[2]);
176static int pseudo_exec(struct child_prog *cmd) __attribute__ ((noreturn));
177static int busy_loop(FILE * input);
178
179
180/* Table of built-in functions (these are non-forking builtins, meaning they
181 * can change global variables in the parent shell process but they will not
182 * work with pipes and redirects; 'unset foo | whatever' will not work) */
183static struct built_in_command bltins[] = {
184 {"bg", "Resume a job in the background", builtin_fg_bg},
185 {"cd", "Change working directory", builtin_cd},
186 {"exec", "Exec command, replacing this shell with the exec'd process", builtin_exec},
187 {"exit", "Exit from shell()", builtin_exit},
188 {"fg", "Bring job into the foreground", builtin_fg_bg},
189 {"jobs", "Lists the active jobs", builtin_jobs},
190 {"export", "Set environment variable", builtin_export},
191 {"unset", "Unset environment variable", builtin_unset},
192 {"read", "Input environment variable", builtin_read},
193 {".", "Source-in and run commands in a file", builtin_source},
194 /* to do: add ulimit */
195#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
196 {"if", NULL, builtin_if},
197 {"then", NULL, builtin_then},
198 {"else", NULL, builtin_else},
199 {"fi", NULL, builtin_fi},
200#endif
201 {NULL, NULL, NULL}
202};
203
204/* Table of forking built-in functions (things that fork cannot change global
205 * variables in the parent process, such as the current working directory) */
206static struct built_in_command bltins_forking[] = {
207 {"pwd", "Print current directory", builtin_pwd},
208 {"help", "List shell built-in commands", builtin_help},
209 {NULL, NULL, NULL}
210};
211
212
213/* Variables we export */
214unsigned int shell_context; /* Used in cmdedit.c to reset the
215 context when someone hits ^C */
216
217
218/* Globals that are static to this file */
219static char *cwd;
220static char *local_pending_command = NULL;
221static struct jobset job_list = { NULL, NULL };
222static int argc;
223static char **argv;
224static struct close_me *close_me_head;
225#ifdef BB_FEATURE_SH_ENVIRONMENT
226static int last_bg_pid;
227static int last_return_code;
228static int show_x_trace;
229#endif
230#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
231static char syntax_err[]="syntax error near unexpected token";
232#endif
233
234static char *PS1;
235static char *PS2 = "> ";
236
237
238#ifdef DEBUG_SHELL
239static inline void debug_printf(const char *format, ...)
240{
241 va_list args;
242 va_start(args, format);
243 vfprintf(stderr, format, args);
244 va_end(args);
245}
246#else
247static inline void debug_printf(const char *format, ...) { }
248#endif
249
250/*
251 Most builtins need access to the struct child_prog that has
252 their arguments, previously coded as cmd->progs[0]. That coding
253 can exhibit a bug, if the builtin is not the first command in
254 a pipeline: "echo foo | exec sort" will attempt to exec foo.
255
256builtin previous use notes
257------ ----------------- ---------
258cd cmd->progs[0]
259exec cmd->progs[0] squashed bug: didn't look for applets or forking builtins
260exit cmd->progs[0]
261fg_bg cmd->progs[0], job_list->head, job_list->fg
262help 0
263jobs job_list->head
264pwd 0
265export cmd->progs[0]
266source cmd->progs[0]
267unset cmd->progs[0]
268read cmd->progs[0]
269if cmd->job_context, cmd->text
270then cmd->job_context, cmd->text
271else cmd->job_context, cmd->text
272fi cmd->job_context
273
274The use of cmd->text by if/then/else/fi is hopelessly hacky.
275Would it work to increment cmd->progs[0]->argv and recurse,
276somewhat like builtin_exec does?
277
278I added "struct job *family;" to struct child_prog,
279and switched API to builtin_foo(struct child_prog *child);
280So cmd->text becomes child->family->text
281 cmd->job_context becomes child->family->job_context
282 cmd->progs[0] becomes *child
283 job_list becomes child->family->job_list
284 */
285
286/* built-in 'cd <path>' handler */
287static int builtin_cd(struct child_prog *child)
288{
289 char *newdir;
290
291 if (child->argv[1] == NULL)
292 newdir = getenv("HOME");
293 else
294 newdir = child->argv[1];
295 if (chdir(newdir)) {
296 printf("cd: %s: %m\n", newdir);
297 return EXIT_FAILURE;
298 }
299 cwd = xgetcwd(cwd);
300
301 return EXIT_SUCCESS;
302}
303
304/* built-in 'exec' handler */
305static int builtin_exec(struct child_prog *child)
306{
307 if (child->argv[1] == NULL)
308 return EXIT_SUCCESS; /* Really? */
309 child->argv++;
310 close_all();
311 pseudo_exec(child);
312 /* never returns */
313}
314
315/* built-in 'exit' handler */
316static int builtin_exit(struct child_prog *child)
317{
318 if (child->argv[1] == NULL)
319 exit(EXIT_SUCCESS);
320
321 exit (atoi(child->argv[1]));
322}
323
324/* built-in 'fg' and 'bg' handler */
325static int builtin_fg_bg(struct child_prog *child)
326{
327 int i, jobNum;
328 struct job *job=NULL;
329
330 if (!child->argv[1] || child->argv[2]) {
331 error_msg("%s: exactly one argument is expected",
332 child->argv[0]);
333 return EXIT_FAILURE;
334 }
335
336 if (sscanf(child->argv[1], "%%%d", &jobNum) != 1) {
337 error_msg("%s: bad argument '%s'",
338 child->argv[0], child->argv[1]);
339 return EXIT_FAILURE;
340 }
341
342 for (job = child->family->job_list->head; job; job = job->next) {
343 if (job->jobid == jobNum) {
344 break;
345 }
346 }
347
348 if (!job) {
349 error_msg("%s: unknown job %d",
350 child->argv[0], jobNum);
351 return EXIT_FAILURE;
352 }
353
354 if (*child->argv[0] == 'f') {
355 /* Make this job the foreground job */
356 /* suppress messages when run from /linuxrc mag@sysgo.de */
357 if (tcsetpgrp(0, job->pgrp) && errno != ENOTTY)
358 perror_msg("tcsetpgrp");
359 child->family->job_list->fg = job;
360 }
361
362 /* Restart the processes in the job */
363 for (i = 0; i < job->num_progs; i++)
364 job->progs[i].is_stopped = 0;
365
366 kill(-job->pgrp, SIGCONT);
367
368 job->stopped_progs = 0;
369
370 return EXIT_SUCCESS;
371}
372
373/* built-in 'help' handler */
374static int builtin_help(struct child_prog *dummy)
375{
376 struct built_in_command *x;
377
378 printf("\nBuilt-in commands:\n");
379 printf("-------------------\n");
380 for (x = bltins; x->cmd; x++) {
381 if (x->descr==NULL)
382 continue;
383 printf("%s\t%s\n", x->cmd, x->descr);
384 }
385 for (x = bltins_forking; x->cmd; x++) {
386 if (x->descr==NULL)
387 continue;
388 printf("%s\t%s\n", x->cmd, x->descr);
389 }
390 printf("\n\n");
391 return EXIT_SUCCESS;
392}
393
394/* built-in 'jobs' handler */
395static int builtin_jobs(struct child_prog *child)
396{
397 struct job *job;
398 char *status_string;
399
400 for (job = child->family->job_list->head; job; job = job->next) {
401 if (job->running_progs == job->stopped_progs)
402 status_string = "Stopped";
403 else
404 status_string = "Running";
405
406 printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text);
407 }
408 return EXIT_SUCCESS;
409}
410
411
412/* built-in 'pwd' handler */
413static int builtin_pwd(struct child_prog *dummy)
414{
415 printf( "%s\n", cwd);
416 return EXIT_SUCCESS;
417}
418
419/* built-in 'export VAR=value' handler */
420static int builtin_export(struct child_prog *child)
421{
422 int res;
423 char *v = child->argv[1];
424
425 if (v == NULL) {
426 char **e;
427 for (e = environ; *e; e++) {
428 printf( "%s\n", *e);
429 }
430 return 0;
431 }
432 res = putenv(v);
433 if (res)
434 fprintf(stderr, "export: %m\n");
435#ifndef BB_FEATURE_SH_SIMPLE_PROMPT
436 if (strncmp(v, "PS1=", 4)==0)
437 PS1 = getenv("PS1");
438#endif
439
440#ifdef BB_LOCALE_SUPPORT
441 if(strncmp(v, "LC_ALL=", 7)==0)
442 setlocale(LC_ALL, getenv("LC_ALL"));
443 if(strncmp(v, "LC_CTYPE=", 9)==0)
444 setlocale(LC_CTYPE, getenv("LC_CTYPE"));
445#endif
446
447 return (res);
448}
449
450/* built-in 'read VAR' handler */
451static int builtin_read(struct child_prog *child)
452{
453 int res = 0, len, newlen;
454 char *s;
455 char string[MAX_READ];
456
457 if (child->argv[1]) {
458 /* argument (VAR) given: put "VAR=" into buffer */
459 strcpy(string, child->argv[1]);
460 len = strlen(string);
461 string[len++] = '=';
462 string[len] = '\0';
463 fgets(&string[len], sizeof(string) - len, stdin); /* read string */
464 newlen = strlen(string);
465 if(newlen > len)
466 string[--newlen] = '\0'; /* chomp trailing newline */
467 /*
468 ** string should now contain "VAR=<value>"
469 ** copy it (putenv() won't do that, so we must make sure
470 ** the string resides in a static buffer!)
471 */
472 res = -1;
473 if((s = strdup(string)))
474 res = putenv(s);
475 if (res)
476 fprintf(stderr, "read: %m\n");
477 }
478 else
479 fgets(string, sizeof(string), stdin);
480
481 return (res);
482}
483
484#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
485/* Built-in handler for 'if' commands */
486static int builtin_if(struct child_prog *child)
487{
488 struct job *cmd = child->family;
489 int status;
490 char* charptr1=cmd->text+3; /* skip over the leading 'if ' */
491
492 /* Now run the 'if' command */
493 debug_printf( "job=%p entering builtin_if ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
494 status = run_command_predicate(charptr1);
495 debug_printf( "if test returned ");
496 if (status == 0) {
497 debug_printf( "TRUE\n");
498 cmd->job_context |= IF_TRUE_CONTEXT;
499 } else {
500 debug_printf( "FALSE\n");
501 cmd->job_context |= IF_FALSE_CONTEXT;
502 }
503 debug_printf("job=%p builtin_if set job context to %x\n", cmd, cmd->job_context);
504 shell_context++;
505
506 return status;
507}
508
509/* Built-in handler for 'then' (part of the 'if' command) */
510static int builtin_then(struct child_prog *child)
511{
512 struct job *cmd = child->family;
513 char* charptr1=cmd->text+5; /* skip over the leading 'then ' */
514
515 debug_printf( "job=%p entering builtin_then ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
516 if (! (cmd->job_context & (IF_TRUE_CONTEXT|IF_FALSE_CONTEXT))) {
517 shell_context = 0; /* Reset the shell's context on an error */
518 error_msg("%s `then'", syntax_err);
519 return EXIT_FAILURE;
520 }
521
522 cmd->job_context |= THEN_EXP_CONTEXT;
523 debug_printf("job=%p builtin_then set job context to %x\n", cmd, cmd->job_context);
524
525 /* If the if result was FALSE, skip the 'then' stuff */
526 if (cmd->job_context & IF_FALSE_CONTEXT) {
527 return EXIT_SUCCESS;
528 }
529
530 /* Seems the if result was TRUE, so run the 'then' command */
531 debug_printf( "'then' now running '%s'\n", charptr1);
532
533 return(run_command_predicate(charptr1));
534}
535
536/* Built-in handler for 'else' (part of the 'if' command) */
537static int builtin_else(struct child_prog *child)
538{
539 struct job *cmd = child->family;
540 char* charptr1=cmd->text+5; /* skip over the leading 'else ' */
541
542 debug_printf( "job=%p entering builtin_else ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
543
544 if (! (cmd->job_context & THEN_EXP_CONTEXT)) {
545 shell_context = 0; /* Reset the shell's context on an error */
546 error_msg("%s `else'", syntax_err);
547 return EXIT_FAILURE;
548 }
549 /* If the if result was TRUE, skip the 'else' stuff */
550 if (cmd->job_context & IF_TRUE_CONTEXT) {
551 return EXIT_SUCCESS;
552 }
553
554 cmd->job_context |= ELSE_EXP_CONTEXT;
555 debug_printf("job=%p builtin_else set job context to %x\n", cmd, cmd->job_context);
556
557 /* Now run the 'else' command */
558 debug_printf( "'else' now running '%s'\n", charptr1);
559 return(run_command_predicate(charptr1));
560}
561
562/* Built-in handler for 'fi' (part of the 'if' command) */
563static int builtin_fi(struct child_prog *child)
564{
565 struct job *cmd = child->family;
566 debug_printf( "job=%p entering builtin_fi ('%s')-- context=%d\n", cmd, "", cmd->job_context);
567 if (! (cmd->job_context & (IF_TRUE_CONTEXT|IF_FALSE_CONTEXT))) {
568 shell_context = 0; /* Reset the shell's context on an error */
569 error_msg("%s `fi'", syntax_err);
570 return EXIT_FAILURE;
571 }
572 /* Clear out the if and then context bits */
573 cmd->job_context &= ~(IF_TRUE_CONTEXT|IF_FALSE_CONTEXT|THEN_EXP_CONTEXT|ELSE_EXP_CONTEXT);
574 debug_printf("job=%p builtin_fi set job context to %x\n", cmd, cmd->job_context);
575 shell_context--;
576 return EXIT_SUCCESS;
577}
578#endif
579
580/* Built-in '.' handler (read-in and execute commands from file) */
581static int builtin_source(struct child_prog *child)
582{
583 FILE *input;
584 int status;
585 int fd;
586
587 if (child->argv[1] == NULL)
588 return EXIT_FAILURE;
589
590 input = fopen(child->argv[1], "r");
591 if (!input) {
592 printf( "Couldn't open file '%s'\n", child->argv[1]);
593 return EXIT_FAILURE;
594 }
595
596 fd=fileno(input);
597 mark_open(fd);
598 /* Now run the file */
599 status = busy_loop(input);
600 fclose(input);
601 mark_closed(fd);
602 return (status);
603}
604
605/* built-in 'unset VAR' handler */
606static int builtin_unset(struct child_prog *child)
607{
608 if (child->argv[1] == NULL) {
609 printf( "unset: parameter required.\n");
610 return EXIT_FAILURE;
611 }
612 unsetenv(child->argv[1]);
613 return EXIT_SUCCESS;
614}
615
616#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
617/* currently used by if/then/else.
618 *
619 * Reparsing the command line for this purpose is gross,
620 * incorrect, and fundamentally unfixable; in particular,
621 * think about what happens with command substitution.
622 * We really need to pull out the run, wait, return status
623 * functionality out of busy_loop so we can child->argv++
624 * and use that, without going back through parse_command.
625 */
626static int run_command_predicate(char *cmd)
627{
628 local_pending_command = xstrdup(cmd);
629 return( busy_loop(NULL));
630}
631#endif
632
633static void mark_open(int fd)
634{
635 struct close_me *new = xmalloc(sizeof(struct close_me));
636 new->fd = fd;
637 new->next = close_me_head;
638 close_me_head = new;
639}
640
641static void mark_closed(int fd)
642{
643 struct close_me *tmp;
644 if (close_me_head == NULL || close_me_head->fd != fd)
645 error_msg_and_die("corrupt close_me");
646 tmp = close_me_head;
647 close_me_head = close_me_head->next;
648 free(tmp);
649}
650
651static void close_all()
652{
653 struct close_me *c, *tmp;
654 for (c=close_me_head; c; c=tmp) {
655 close(c->fd);
656 tmp=c->next;
657 free(c);
658 }
659 close_me_head = NULL;
660}
661
662
663/* free up all memory from a job */
664static void free_job(struct job *cmd)
665{
666 int i;
667 struct jobset *keep;
668
669 for (i = 0; i < cmd->num_progs; i++) {
670 free(cmd->progs[i].argv);
671 if (cmd->progs[i].redirects)
672 free(cmd->progs[i].redirects);
673 }
674 if (cmd->progs)
675 free(cmd->progs);
676 if (cmd->text)
677 free(cmd->text);
678 if (cmd->cmdbuf)
679 free(cmd->cmdbuf);
680 keep = cmd->job_list;
681 memset(cmd, 0, sizeof(struct job));
682 cmd->job_list = keep;
683}
684
685/* remove a job from a jobset */
686static void remove_job(struct jobset *j_list, struct job *job)
687{
688 struct job *prevjob;
689
690 free_job(job);
691 if (job == j_list->head) {
692 j_list->head = job->next;
693 } else {
694 prevjob = j_list->head;
695 while (prevjob->next != job)
696 prevjob = prevjob->next;
697 prevjob->next = job->next;
698 }
699
700 free(job);
701}
702
703/* Checks to see if any background processes have exited -- if they
704 have, figure out why and see if a job has completed */
705static void checkjobs(struct jobset *j_list)
706{
707 struct job *job;
708 pid_t childpid;
709 int status;
710 int prognum = 0;
711
712 while ((childpid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
713 for (job = j_list->head; job; job = job->next) {
714 prognum = 0;
715 while (prognum < job->num_progs &&
716 job->progs[prognum].pid != childpid) prognum++;
717 if (prognum < job->num_progs)
718 break;
719 }
720
721 /* This happens on backticked commands */
722 if(job==NULL)
723 return;
724
725 if (WIFEXITED(status) || WIFSIGNALED(status)) {
726 /* child exited */
727 job->running_progs--;
728 job->progs[prognum].pid = 0;
729
730 if (!job->running_progs) {
731 printf(JOB_STATUS_FORMAT, job->jobid, "Done", job->text);
732 remove_job(j_list, job);
733 }
734 } else {
735 /* child stopped */
736 job->stopped_progs++;
737 job->progs[prognum].is_stopped = 1;
738
739 if (job->stopped_progs == job->num_progs) {
740 printf(JOB_STATUS_FORMAT, job->jobid, "Stopped",
741 job->text);
742 }
743 }
744 }
745
746 if (childpid == -1 && errno != ECHILD)
747 perror_msg("waitpid");
748}
749
750/* squirrel != NULL means we squirrel away copies of stdin, stdout,
751 * and stderr if they are redirected. */
752static int setup_redirects(struct child_prog *prog, int squirrel[])
753{
754 int i;
755 int openfd;
756 int mode = O_RDONLY;
757 struct redir_struct *redir = prog->redirects;
758
759 for (i = 0; i < prog->num_redirects; i++, redir++) {
760 switch (redir->type) {
761 case REDIRECT_INPUT:
762 mode = O_RDONLY;
763 break;
764 case REDIRECT_OVERWRITE:
765 mode = O_WRONLY | O_CREAT | O_TRUNC;
766 break;
767 case REDIRECT_APPEND:
768 mode = O_WRONLY | O_CREAT | O_APPEND;
769 break;
770 }
771
772 openfd = open(redir->filename, mode, 0666);
773 if (openfd < 0) {
774 /* this could get lost if stderr has been redirected, but
775 bash and ash both lose it as well (though zsh doesn't!) */
776 perror_msg("error opening %s", redir->filename);
777 return 1;
778 }
779
780 if (openfd != redir->fd) {
781 if (squirrel && redir->fd < 3) {
782 squirrel[redir->fd] = dup(redir->fd);
783 }
784 dup2(openfd, redir->fd);
785 close(openfd);
786 }
787 }
788
789 return 0;
790}
791
792static void restore_redirects(int squirrel[])
793{
794 int i, fd;
795 for (i=0; i<3; i++) {
796 fd = squirrel[i];
797 if (fd != -1) {
798 /* No error checking. I sure wouldn't know what
799 * to do with an error if I found one! */
800 dup2(fd, i);
801 close(fd);
802 }
803 }
804}
805
806static inline void cmdedit_set_initial_prompt(void)
807{
808#ifdef BB_FEATURE_SH_SIMPLE_PROMPT
809 PS1 = NULL;
810#else
811 PS1 = getenv("PS1");
812 if(PS1==0)
813 PS1 = "\\w \\$ ";
814#endif
815}
816
817static inline void setup_prompt_string(char **prompt_str)
818{
819#ifdef BB_FEATURE_SH_SIMPLE_PROMPT
820 /* Set up the prompt */
821 if (shell_context == 0) {
822 if (PS1)
823 free(PS1);
824 PS1=xmalloc(strlen(cwd)+4);
825 sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ? "$ ":"# ");
826 *prompt_str = PS1;
827 } else {
828 *prompt_str = PS2;
829 }
830#else
831 *prompt_str = (shell_context==0)? PS1 : PS2;
832#endif
833}
834
835static int get_command(FILE * source, char *command)
836{
837 char *prompt_str;
838
839 if (source == NULL) {
840 if (local_pending_command) {
841 /* a command specified (-c option): return it & mark it done */
842 strcpy(command, local_pending_command);
843 free(local_pending_command);
844 local_pending_command = NULL;
845 return 0;
846 }
847 return 1;
848 }
849
850 if (source == stdin) {
851 setup_prompt_string(&prompt_str);
852
853#ifdef BB_FEATURE_COMMAND_EDITING
854 /*
855 ** enable command line editing only while a command line
856 ** is actually being read; otherwise, we'll end up bequeathing
857 ** atexit() handlers and other unwanted stuff to our
858 ** child processes (rob@sysgo.de)
859 */
860 cmdedit_read_input(prompt_str, command);
861 cmdedit_terminate();
862 return 0;
863#else
864 fputs(prompt_str, stdout);
865#endif
866 }
867
868 if (!fgets(command, BUFSIZ - 2, source)) {
869 if (source == stdin)
870 printf("\n");
871 return 1;
872 }
873
874 return 0;
875}
876
877#ifdef BB_FEATURE_SH_ENVIRONMENT
878static char* itoa(register int i)
879{
880 static char a[7]; /* Max 7 ints */
881 register char *b = a + sizeof(a) - 1;
882 int sign = (i < 0);
883
884 if (sign)
885 i = -i;
886 *b = 0;
887 do
888 {
889 *--b = '0' + (i % 10);
890 i /= 10;
891 }
892 while (i);
893 if (sign)
894 *--b = '-';
895 return b;
896}
897#endif
898
899#if defined BB_FEATURE_SH_ENVIRONMENT && ! defined BB_FEATURE_SH_WORDEXP
900char * strsep_space( char *string, int * ix)
901{
902 char *token, *begin;
903
904 begin = string;
905
906 /* Short circuit the trivial case */
907 if ( !string || ! string[*ix])
908 return NULL;
909
910 /* Find the end of the token. */
911 while( string && string[*ix] && !isspace(string[*ix]) ) {
912 (*ix)++;
913 }
914
915 /* Find the end of any whitespace trailing behind
916 * the token and let that be part of the token */
917 while( string && string[*ix] && isspace(string[*ix]) ) {
918 (*ix)++;
919 }
920
921 if (! string && *ix==0) {
922 /* Nothing useful was found */
923 return NULL;
924 }
925
926 token = xmalloc(*ix+1);
927 token[*ix] = '\0';
928 strncpy(token, string, *ix);
929
930 return token;
931}
932#endif
933
934
935static int expand_arguments(char *command)
936{
937#ifdef BB_FEATURE_SH_ENVIRONMENT
938 expand_t expand_result;
939 char *src, *dst, *var;
940 int ix = 0;
941 int i=0, length, total_length=0, retval;
942 const char *out_of_space = "out of space during expansion";
943#endif
944
945 /* get rid of the terminating \n */
946 chomp(command);
947
948 /* Fix up escape sequences to be the Real Thing(tm) */
949 while( command && command[ix]) {
950 if (command[ix] == '\\') {
951 const char *tmp = command+ix+1;
952 command[ix] = process_escape_sequence( &tmp );
953 memmove(command+ix + 1, tmp, strlen(tmp)+1);
954 }
955 ix++;
956 }
957
958#ifdef BB_FEATURE_SH_ENVIRONMENT
959
960
961#ifdef BB_FEATURE_SH_WORDEXP
962 /* This first part uses wordexp() which is a wonderful C lib
963 * function which expands nearly everything. */
964 retval = wordexp (command, &expand_result, WRDE_SHOWERR);
965 if (retval == WRDE_NOSPACE) {
966 /* Mem may have been allocated... */
967 wordfree (&expand_result);
968 error_msg(out_of_space);
969 return FALSE;
970 }
971 if (retval < 0) {
972 /* Some other error. */
973 error_msg("syntax error");
974 return FALSE;
975 }
976
977 if (expand_result.we_wordc > 0) {
978 /* Convert from char** (one word per string) to a simple char*,
979 * but don't overflow command which is BUFSIZ in length */
980 *command = '\0';
981 while (i < expand_result.we_wordc && total_length < BUFSIZ) {
982 length=strlen(expand_result.we_wordv[i])+1;
983 if (BUFSIZ-total_length-length <= 0) {
984 error_msg(out_of_space);
985 return FALSE;
986 }
987 strcat(command+total_length, expand_result.we_wordv[i++]);
988 strcat(command+total_length, " ");
989 total_length+=length;
990 }
991 wordfree (&expand_result);
992 }
993#else
994
995 /* Ok. They don't have a recent glibc and they don't have uClibc. Chances
996 * are about 100% they don't have wordexp(). So instead the best we can do
997 * is use glob and then fixup environment variables and such ourselves.
998 * This is better then nothing, but certainly not perfect */
999
1000 /* It turns out that glob is very stupid. We have to feed it one word at a
1001 * time since it can't cope with a full string. Here we convert command
1002 * (char*) into cmd (char**, one word per string) */
1003 {
1004
1005 int flags = GLOB_NOCHECK
1006#ifdef GLOB_BRACE
1007 | GLOB_BRACE
1008#endif
1009#ifdef GLOB_TILDE
1010 | GLOB_TILDE
1011#endif
1012 ;
1013 char *tmpcmd, *cmd, *cmd_copy;
1014 /* We need a clean copy, so strsep can mess up the copy while
1015 * we write stuff into the original (in a minute) */
1016 cmd = cmd_copy = strdup(command);
1017 *command = '\0';
1018 for (ix = 0, tmpcmd = cmd;
1019 (tmpcmd = strsep_space(cmd, &ix)) != NULL; cmd += ix, ix=0) {
1020 if (*tmpcmd == '\0')
1021 break;
1022 /* we need to trim() the result for glob! */
1023 trim(tmpcmd);
1024 retval = glob(tmpcmd, flags, NULL, &expand_result);
1025 free(tmpcmd); /* Free mem allocated by strsep_space */
1026 if (retval == GLOB_NOSPACE) {
1027 /* Mem may have been allocated... */
1028 globfree (&expand_result);
1029 error_msg(out_of_space);
1030 return FALSE;
1031 } else if (retval != 0) {
1032 /* Some other error. GLOB_NOMATCH shouldn't
1033 * happen because of the GLOB_NOCHECK flag in
1034 * the glob call. */
1035 error_msg("syntax error");
1036 return FALSE;
1037 } else {
1038 /* Convert from char** (one word per string) to a simple char*,
1039 * but don't overflow command which is BUFSIZ in length */
1040 for (i=0; i < expand_result.gl_pathc; i++) {
1041 length=strlen(expand_result.gl_pathv[i]);
1042 if (total_length+length+1 >= BUFSIZ) {
1043 error_msg(out_of_space);
1044 return FALSE;
1045 }
1046 strcat(command+total_length, " ");
1047 total_length+=1;
1048 strcat(command+total_length, expand_result.gl_pathv[i]);
1049 total_length+=length;
1050 }
1051 globfree (&expand_result);
1052 }
1053 }
1054 free(cmd_copy);
1055 trim(command);
1056 }
1057
1058#endif
1059
1060 /* Now do the shell variable substitutions which
1061 * wordexp can't do for us, namely $? and $! */
1062 src = command;
1063 while((dst = strchr(src,'$')) != NULL){
1064 var = NULL;
1065 switch(*(dst+1)) {
1066 case '?':
1067 var = itoa(last_return_code);
1068 break;
1069 case '!':
1070 if (last_bg_pid==-1)
1071 *(var)='\0';
1072 else
1073 var = itoa(last_bg_pid);
1074 break;
1075 /* Everything else like $$, $#, $[0-9], etc should all be
1076 * expanded by wordexp(), so we can in theory skip that stuff
1077 * here, but just to be on the safe side (i.e. since uClibc
1078 * wordexp doesn't do this stuff yet), lets leave it in for
1079 * now. */
1080 case '$':
1081 var = itoa(getpid());
1082 break;
1083 case '#':
1084 var = itoa(argc-1);
1085 break;
1086 case '0':case '1':case '2':case '3':case '4':
1087 case '5':case '6':case '7':case '8':case '9':
1088 {
1089 int ixx=*(dst + 1)-48;
1090 if (ixx >= argc) {
1091 var='\0';
1092 } else {
1093 var = argv[ixx];
1094 }
1095 }
1096 break;
1097
1098 }
1099 if (var) {
1100 /* a single character construction was found, and
1101 * already handled in the case statement */
1102 src=dst+2;
1103 } else {
1104 /* Looks like an environment variable */
1105 char delim_hold;
1106 int num_skip_chars=0;
1107 int dstlen = strlen(dst);
1108 /* Is this a ${foo} type variable? */
1109 if (dstlen >=2 && *(dst+1) == '{') {
1110 src=strchr(dst+1, '}');
1111 num_skip_chars=1;
1112 } else {
1113 src=dst+1;
1114 while(isalnum(*src) || *src=='_') src++;
1115 }
1116 if (src == NULL) {
1117 src = dst+dstlen;
1118 }
1119 delim_hold=*src;
1120 *src='\0'; /* temporary */
1121 var = getenv(dst + 1 + num_skip_chars);
1122 *src=delim_hold;
1123 src += num_skip_chars;
1124 }
1125 if (var == NULL) {
1126 /* Seems we got an un-expandable variable. So delete it. */
1127 var = "";
1128 }
1129 {
1130 int subst_len = strlen(var);
1131 int trail_len = strlen(src);
1132 if (dst+subst_len+trail_len >= command+BUFSIZ) {
1133 error_msg(out_of_space);
1134 return FALSE;
1135 }
1136 /* Move stuff to the end of the string to accommodate
1137 * filling the created gap with the new stuff */
1138 memmove(dst+subst_len, src, trail_len+1);
1139 /* Now copy in the new stuff */
1140 memcpy(dst, var, subst_len);
1141 src = dst+subst_len;
1142 }
1143 }
1144
1145#endif
1146 return TRUE;
1147}
1148
1149/* Return cmd->num_progs as 0 if no command is present (e.g. an empty
1150 line). If a valid command is found, command_ptr is set to point to
1151 the beginning of the next command (if the original command had more
1152 then one job associated with it) or NULL if no more commands are
1153 present. */
1154static int parse_command(char **command_ptr, struct job *job, int *inbg)
1155{
1156 char *command;
1157 char *return_command = NULL;
1158 char *src, *buf, *chptr;
1159 int argc_l = 0;
1160 int done = 0;
1161 int argv_alloced;
1162 int i, saw_quote = 0;
1163 char quote = '\0';
1164 int count;
1165 struct child_prog *prog;
1166
1167 /* skip leading white space */
1168 while (**command_ptr && isspace(**command_ptr))
1169 (*command_ptr)++;
1170
1171 /* this handles empty lines or leading '#' characters */
1172 if (!**command_ptr || (**command_ptr == '#')) {
1173 job->num_progs=0;
1174 return 0;
1175 }
1176
1177 *inbg = 0;
1178 job->num_progs = 1;
1179 job->progs = xmalloc(sizeof(*job->progs));
1180
1181 /* We set the argv elements to point inside of this string. The
1182 memory is freed by free_job(). Allocate twice the original
1183 length in case we need to quote every single character.
1184
1185 Getting clean memory relieves us of the task of NULL
1186 terminating things and makes the rest of this look a bit
1187 cleaner (though it is, admittedly, a tad less efficient) */
1188 job->cmdbuf = command = xcalloc(2*strlen(*command_ptr) + 1, sizeof(char));
1189 job->text = NULL;
1190
1191 prog = job->progs;
1192 prog->num_redirects = 0;
1193 prog->redirects = NULL;
1194 prog->is_stopped = 0;
1195 prog->family = job;
1196
1197 argv_alloced = 5;
1198 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
1199 prog->argv[0] = job->cmdbuf;
1200
1201 buf = command;
1202 src = *command_ptr;
1203 while (*src && !done) {
1204 if (quote == *src) {
1205 quote = '\0';
1206 } else if (quote) {
1207 if (*src == '\\') {
1208 src++;
1209 if (!*src) {
1210 error_msg("character expected after \\");
1211 free_job(job);
1212 return 1;
1213 }
1214
1215 /* in shell, "\'" should yield \' */
1216 if (*src != quote) {
1217 *buf++ = '\\';
1218 *buf++ = '\\';
1219 }
1220 } else if (*src == '*' || *src == '?' || *src == '[' ||
1221 *src == ']') *buf++ = '\\';
1222 *buf++ = *src;
1223 } else if (isspace(*src)) {
1224 if (*prog->argv[argc_l] || saw_quote) {
1225 buf++, argc_l++;
1226 /* +1 here leaves room for the NULL which ends argv */
1227 if ((argc_l + 1) == argv_alloced) {
1228 argv_alloced += 5;
1229 prog->argv = xrealloc(prog->argv,
1230 sizeof(*prog->argv) *
1231 argv_alloced);
1232 }
1233 prog->argv[argc_l] = buf;
1234 saw_quote = 0;
1235 }
1236 } else
1237 switch (*src) {
1238 case '"':
1239 case '\'':
1240 quote = *src;
1241 saw_quote = 1;
1242 break;
1243
1244 case '#': /* comment */
1245 if (*(src-1)== '$')
1246 *buf++ = *src;
1247 else
1248 done = 1;
1249 break;
1250
1251 case '>': /* redirects */
1252 case '<':
1253 i = prog->num_redirects++;
1254 prog->redirects = xrealloc(prog->redirects,
1255 sizeof(*prog->redirects) *
1256 (i + 1));
1257
1258 prog->redirects[i].fd = -1;
1259 if (buf != prog->argv[argc_l]) {
1260 /* the stuff before this character may be the file number
1261 being redirected */
1262 prog->redirects[i].fd =
1263 strtol(prog->argv[argc_l], &chptr, 10);
1264
1265 if (*chptr && *prog->argv[argc_l]) {
1266 buf++, argc_l++;
1267 prog->argv[argc_l] = buf;
1268 }
1269 }
1270
1271 if (prog->redirects[i].fd == -1) {
1272 if (*src == '>')
1273 prog->redirects[i].fd = 1;
1274 else
1275 prog->redirects[i].fd = 0;
1276 }
1277
1278 if (*src++ == '>') {
1279 if (*src == '>')
1280 prog->redirects[i].type =
1281 REDIRECT_APPEND, src++;
1282 else
1283 prog->redirects[i].type = REDIRECT_OVERWRITE;
1284 } else {
1285 prog->redirects[i].type = REDIRECT_INPUT;
1286 }
1287
1288 /* This isn't POSIX sh compliant. Oh well. */
1289 chptr = src;
1290 while (isspace(*chptr))
1291 chptr++;
1292
1293 if (!*chptr) {
1294 error_msg("file name expected after %c", *(src-1));
1295 free_job(job);
1296 job->num_progs=0;
1297 return 1;
1298 }
1299
1300 prog->redirects[i].filename = buf;
1301 while (*chptr && !isspace(*chptr))
1302 *buf++ = *chptr++;
1303
1304 src = chptr - 1; /* we src++ later */
1305 prog->argv[argc_l] = ++buf;
1306 break;
1307
1308 case '|': /* pipe */
1309 /* finish this command */
1310 if (*prog->argv[argc_l] || saw_quote)
1311 argc_l++;
1312 if (!argc_l) {
1313 error_msg("empty command in pipe");
1314 free_job(job);
1315 job->num_progs=0;
1316 return 1;
1317 }
1318 prog->argv[argc_l] = NULL;
1319
1320 /* and start the next */
1321 job->num_progs++;
1322 job->progs = xrealloc(job->progs,
1323 sizeof(*job->progs) * job->num_progs);
1324 prog = job->progs + (job->num_progs - 1);
1325 prog->num_redirects = 0;
1326 prog->redirects = NULL;
1327 prog->is_stopped = 0;
1328 prog->family = job;
1329 argc_l = 0;
1330
1331 argv_alloced = 5;
1332 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
1333 prog->argv[0] = ++buf;
1334
1335 src++;
1336 while (*src && isspace(*src))
1337 src++;
1338
1339 if (!*src) {
1340 error_msg("empty command in pipe");
1341 free_job(job);
1342 job->num_progs=0;
1343 return 1;
1344 }
1345 src--; /* we'll ++ it at the end of the loop */
1346
1347 break;
1348
1349 case '&': /* background */
1350 *inbg = 1;
1351 case ';': /* multiple commands */
1352 done = 1;
1353 return_command = *command_ptr + (src - *command_ptr) + 1;
1354 break;
1355
1356#ifdef BB_FEATURE_SH_BACKTICKS
1357 case '`':
1358 /* Exec a backtick-ed command */
1359 /* Besides any previous brokenness, I have not
1360 * updated backtick handling for close_me support.
1361 * I don't know if it needs it or not. -- LRD */
1362 {
1363 char* charptr1=NULL, *charptr2;
1364 char* ptr=NULL;
1365 struct job *newjob;
1366 struct jobset njob_list = { NULL, NULL };
1367 int pipefd[2];
1368 int size;
1369
1370 ptr=strchr(++src, '`');
1371 if (ptr==NULL) {
1372 fprintf(stderr, "Unmatched '`' in command\n");
1373 free_job(job);
1374 return 1;
1375 }
1376
1377 /* Make some space to hold just the backticked command */
1378 charptr1 = charptr2 = xmalloc(1+ptr-src);
1379 memcpy(charptr1, src, ptr-src);
1380 charptr1[ptr-src] = '\0';
1381 newjob = xmalloc(sizeof(struct job));
1382 newjob->job_list = &njob_list;
1383 /* Now parse and run the backticked command */
1384 if (!parse_command(&charptr1, newjob, inbg)
1385 && newjob->num_progs) {
1386 pipe(pipefd);
1387 run_command(newjob, 0, pipefd);
1388 }
1389 checkjobs(job->job_list);
1390 free_job(newjob); /* doesn't actually free newjob,
1391 looks like a memory leak */
1392 free(charptr2);
1393
1394 /* Make a copy of any stuff left over in the command
1395 * line after the second backtick */
1396 charptr2 = xmalloc(strlen(ptr)+1);
1397 memcpy(charptr2, ptr+1, strlen(ptr));
1398
1399
1400 /* Copy the output from the backtick-ed command into the
1401 * command line, making extra room as needed */
1402 --src;
1403 charptr1 = xmalloc(BUFSIZ);
1404 while ( (size=full_read(pipefd[0], charptr1, BUFSIZ-1)) >0) {
1405 int newsize=src - *command_ptr + size + 1 + strlen(charptr2);
1406 if (newsize > BUFSIZ) {
1407 *command_ptr=xrealloc(*command_ptr, newsize);
1408 }
1409 memcpy(src, charptr1, size);
1410 src+=size;
1411 }
1412 free(charptr1);
1413 close(pipefd[0]);
1414 if (*(src-1)=='\n')
1415 --src;
1416
1417 /* Now paste into the *command_ptr all the stuff
1418 * leftover after the second backtick */
1419 memcpy(src, charptr2, strlen(charptr2)+1);
1420 free(charptr2);
1421
1422 /* Now recursively call parse_command to deal with the new
1423 * and improved version of the command line with the backtick
1424 * results expanded in place... */
1425 {
1426 struct jobset *jl=job->job_list;
1427 free_job(job);
1428 job->job_list = jl;
1429 }
1430 return(parse_command(command_ptr, job, inbg));
1431 }
1432 break;
1433#endif // BB_FEATURE_SH_BACKTICKS
1434
1435 case '\\':
1436 src++;
1437 if (!*src) {
1438/* This is currently a little broken... */
1439#ifdef HANDLE_CONTINUATION_CHARS
1440 /* They fed us a continuation char, so continue reading stuff
1441 * on the next line, then tack that onto the end of the current
1442 * command */
1443 char *command;
1444 int newsize;
1445 printf("erik: found a continue char at EOL...\n");
1446 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1447 if (get_command(input, command)) {
1448 error_msg("character expected after \\");
1449 free(command);
1450 free_job(job);
1451 return 1;
1452 }
1453 newsize = strlen(*command_ptr) + strlen(command) + 2;
1454 if (newsize > BUFSIZ) {
1455 printf("erik: doing realloc\n");
1456 *command_ptr=xrealloc(*command_ptr, newsize);
1457 }
1458 printf("erik: A: *command_ptr='%s'\n", *command_ptr);
1459 memcpy(--src, command, strlen(command));
1460 printf("erik: B: *command_ptr='%s'\n", *command_ptr);
1461 free(command);
1462 break;
1463#else
1464 error_msg("character expected after \\");
1465 free_job(job);
1466 return 1;
1467#endif
1468 }
1469 if (*src == '*' || *src == '[' || *src == ']'
1470 || *src == '?') *buf++ = '\\';
1471 /* fallthrough */
1472 default:
1473 *buf++ = *src;
1474 }
1475
1476 src++;
1477 }
1478
1479 if (*prog->argv[argc_l] || saw_quote) {
1480 argc_l++;
1481 }
1482 if (!argc_l) {
1483 free_job(job);
1484 return 0;
1485 }
1486 prog->argv[argc_l] = NULL;
1487
1488 if (!return_command) {
1489 job->text = xmalloc(strlen(*command_ptr) + 1);
1490 strcpy(job->text, *command_ptr);
1491 } else {
1492 /* This leaves any trailing spaces, which is a bit sloppy */
1493 count = return_command - *command_ptr;
1494 job->text = xmalloc(count + 1);
1495 strncpy(job->text, *command_ptr, count);
1496 job->text[count] = '\0';
1497 }
1498
1499 *command_ptr = return_command;
1500
1501 return 0;
1502}
1503
1504/* Run the child_prog, no matter what kind of command it uses.
1505 */
1506static int pseudo_exec(struct child_prog *child)
1507{
1508 struct built_in_command *x;
1509#ifdef BB_FEATURE_SH_STANDALONE_SHELL
1510 char *name;
1511#endif
1512
1513 /* Check if the command matches any of the non-forking builtins.
1514 * Depending on context, this might be redundant. But it's
1515 * easier to waste a few CPU cycles than it is to figure out
1516 * if this is one of those cases.
1517 */
1518 for (x = bltins; x->cmd; x++) {
1519 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1520 exit(x->function(child));
1521 }
1522 }
1523
1524 /* Check if the command matches any of the forking builtins. */
1525 for (x = bltins_forking; x->cmd; x++) {
1526 if (strcmp(child->argv[0], x->cmd) == 0) {
1527 applet_name=x->cmd;
1528 exit (x->function(child));
1529 }
1530 }
1531#ifdef BB_FEATURE_SH_STANDALONE_SHELL
1532 /* Check if the command matches any busybox internal
1533 * commands ("applets") here. Following discussions from
1534 * November 2000 on busybox@opensource.lineo.com, don't use
1535 * get_last_path_component(). This way explicit (with
1536 * slashes) filenames will never be interpreted as an
1537 * applet, just like with builtins. This way the user can
1538 * override an applet with an explicit filename reference.
1539 * The only downside to this change is that an explicit
1540 * /bin/foo invocation will fork and exec /bin/foo, even if
1541 * /bin/foo is a symlink to busybox.
1542 */
1543 name = child->argv[0];
1544
1545#ifdef BB_FEATURE_SH_APPLETS_ALWAYS_WIN
1546 /* If you enable BB_FEATURE_SH_APPLETS_ALWAYS_WIN, then
1547 * if you run /bin/cat, it will use BusyBox cat even if
1548 * /bin/cat exists on the filesystem and is _not_ busybox.
1549 * Some systems want this, others do not. Choose wisely. :-)
1550 */
1551 name = get_last_path_component(name);
1552#endif
1553
1554 {
1555 char** argv_l=child->argv;
1556 int argc_l;
1557 for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++);
1558 optind = 1;
1559 run_applet_by_name(name, argc_l, child->argv);
1560 }
1561#endif
1562
1563 execvp(child->argv[0], child->argv);
1564 perror_msg_and_die("%s", child->argv[0]);
1565}
1566
1567static void insert_job(struct job *newjob, int inbg)
1568{
1569 struct job *thejob;
1570 struct jobset *j_list=newjob->job_list;
1571
1572 /* find the ID for thejob to use */
1573 newjob->jobid = 1;
1574 for (thejob = j_list->head; thejob; thejob = thejob->next)
1575 if (thejob->jobid >= newjob->jobid)
1576 newjob->jobid = thejob->jobid + 1;
1577
1578 /* add thejob to the list of running jobs */
1579 if (!j_list->head) {
1580 thejob = j_list->head = xmalloc(sizeof(*thejob));
1581 } else {
1582 for (thejob = j_list->head; thejob->next; thejob = thejob->next) /* nothing */;
1583 thejob->next = xmalloc(sizeof(*thejob));
1584 thejob = thejob->next;
1585 }
1586
1587 *thejob = *newjob; /* physically copy the struct job */
1588 thejob->next = NULL;
1589 thejob->running_progs = thejob->num_progs;
1590 thejob->stopped_progs = 0;
1591
1592 if (inbg) {
1593 /* we don't wait for background thejobs to return -- append it
1594 to the list of backgrounded thejobs and leave it alone */
1595 printf("[%d] %d\n", thejob->jobid,
1596 newjob->progs[newjob->num_progs - 1].pid);
1597#ifdef BB_FEATURE_SH_ENVIRONMENT
1598 last_bg_pid=newjob->progs[newjob->num_progs - 1].pid;
1599#endif
1600 } else {
1601 newjob->job_list->fg = thejob;
1602
1603 /* move the new process group into the foreground */
1604 /* suppress messages when run from /linuxrc mag@sysgo.de */
1605 if (tcsetpgrp(0, newjob->pgrp) && errno != ENOTTY)
1606 perror_msg("tcsetpgrp");
1607 }
1608}
1609
1610static int run_command(struct job *newjob, int inbg, int outpipe[2])
1611{
1612 /* struct job *thejob; */
1613 int i;
1614 int nextin, nextout;
1615 int pipefds[2]; /* pipefd[0] is for reading */
1616 struct built_in_command *x;
1617 struct child_prog *child;
1618
1619 nextin = 0, nextout = 1;
1620 for (i = 0; i < newjob->num_progs; i++) {
1621 child = & (newjob->progs[i]);
1622
1623 if ((i + 1) < newjob->num_progs) {
1624 if (pipe(pipefds)<0) perror_msg_and_die("pipe");
1625 nextout = pipefds[1];
1626 } else {
1627 if (outpipe[1]!=-1) {
1628 nextout = outpipe[1];
1629 } else {
1630 nextout = 1;
1631 }
1632 }
1633
1634#ifdef BB_FEATURE_SH_ENVIRONMENT
1635 if (show_x_trace==TRUE) {
1636 int j;
1637 fputc('+', stderr);
1638 for (j = 0; child->argv[j]; j++) {
1639 fputc(' ', stderr);
1640 fputs(child->argv[j], stderr);
1641 }
1642 fputc('\n', stderr);
1643 }
1644#endif
1645
1646 /* Check if the command matches any non-forking builtins,
1647 * but only if this is a simple command.
1648 * Non-forking builtins within pipes have to fork anyway,
1649 * and are handled in pseudo_exec. "echo foo | read bar"
1650 * is doomed to failure, and doesn't work on bash, either.
1651 */
1652 if (newjob->num_progs == 1) {
1653 for (x = bltins; x->cmd; x++) {
1654 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1655 int squirrel[] = {-1, -1, -1};
1656 int rcode;
1657 setup_redirects(child, squirrel);
1658 rcode = x->function(child);
1659 restore_redirects(squirrel);
1660 return rcode;
1661 }
1662 }
1663 }
1664
1665 if (!(child->pid = fork())) {
1666 signal(SIGTTOU, SIG_DFL);
1667
1668 close_all();
1669
1670 if (outpipe[1]!=-1) {
1671 close(outpipe[0]);
1672 }
1673 if (nextin != 0) {
1674 dup2(nextin, 0);
1675 close(nextin);
1676 }
1677
1678 if (nextout != 1) {
1679 dup2(nextout, 1);
1680 dup2(nextout, 2); /* Really? */
1681 close(nextout);
1682 close(pipefds[0]);
1683 }
1684
1685 /* explicit redirects override pipes */
1686 setup_redirects(child,NULL);
1687
1688 pseudo_exec(child);
1689 }
1690 if (outpipe[1]!=-1) {
1691 close(outpipe[1]);
1692 }
1693
1694 /* put our child in the process group whose leader is the
1695 first process in this pipe */
1696 setpgid(child->pid, newjob->progs[0].pid);
1697 if (nextin != 0)
1698 close(nextin);
1699 if (nextout != 1)
1700 close(nextout);
1701
1702 /* If there isn't another process, nextin is garbage
1703 but it doesn't matter */
1704 nextin = pipefds[0];
1705 }
1706
1707 newjob->pgrp = newjob->progs[0].pid;
1708
1709 insert_job(newjob, inbg);
1710
1711 return 0;
1712}
1713
1714static int busy_loop(FILE * input)
1715{
1716 char *command;
1717 char *next_command = NULL;
1718 struct job newjob;
1719 pid_t parent_pgrp;
1720 int i;
1721 int inbg;
1722 int status;
1723 newjob.job_list = &job_list;
1724 newjob.job_context = DEFAULT_CONTEXT;
1725
1726 /* save current owner of TTY so we can restore it on exit */
1727 parent_pgrp = tcgetpgrp(0);
1728
1729 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1730
1731 /* don't pay any attention to this signal; it just confuses
1732 things and isn't really meant for shells anyway */
1733 signal(SIGTTOU, SIG_IGN);
1734
1735 while (1) {
1736 if (!job_list.fg) {
1737 /* no job is in the foreground */
1738
1739 /* see if any background processes have exited */
1740 checkjobs(&job_list);
1741
1742 if (!next_command) {
1743 if (get_command(input, command))
1744 break;
1745 next_command = command;
1746 }
1747
1748 if (expand_arguments(next_command) == FALSE) {
1749 free(command);
1750 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1751 next_command = NULL;
1752 continue;
1753 }
1754
1755 if (!parse_command(&next_command, &newjob, &inbg) &&
1756 newjob.num_progs) {
1757 int pipefds[2] = {-1,-1};
1758 debug_printf( "job=%p fed to run_command by busy_loop()'\n",
1759 &newjob);
1760 run_command(&newjob, inbg, pipefds);
1761 }
1762 else {
1763 free(command);
1764 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1765 next_command = NULL;
1766 }
1767 } else {
1768 /* a job is running in the foreground; wait for it */
1769 i = 0;
1770 while (!job_list.fg->progs[i].pid ||
1771 job_list.fg->progs[i].is_stopped == 1) i++;
1772
1773 if (waitpid(job_list.fg->progs[i].pid, &status, WUNTRACED)<0)
1774 perror_msg_and_die("waitpid(%d)",job_list.fg->progs[i].pid);
1775
1776 if (WIFEXITED(status) || WIFSIGNALED(status)) {
1777 /* the child exited */
1778 job_list.fg->running_progs--;
1779 job_list.fg->progs[i].pid = 0;
1780
1781#ifdef BB_FEATURE_SH_ENVIRONMENT
1782 last_return_code=WEXITSTATUS(status);
1783 debug_printf("'%s' exited -- return code %d\n",
1784 job_list.fg->text, last_return_code);
1785#endif
1786 if (!job_list.fg->running_progs) {
1787 /* child exited */
1788 remove_job(&job_list, job_list.fg);
1789 job_list.fg = NULL;
1790 }
1791 } else {
1792 /* the child was stopped */
1793 job_list.fg->stopped_progs++;
1794 job_list.fg->progs[i].is_stopped = 1;
1795
1796 if (job_list.fg->stopped_progs == job_list.fg->running_progs) {
1797 printf("\n" JOB_STATUS_FORMAT, job_list.fg->jobid,
1798 "Stopped", job_list.fg->text);
1799 job_list.fg = NULL;
1800 }
1801 }
1802
1803 if (!job_list.fg) {
1804 /* move the shell to the foreground */
1805 /* suppress messages when run from /linuxrc mag@sysgo.de */
1806 if (tcsetpgrp(0, getpgrp()) && errno != ENOTTY)
1807 perror_msg("tcsetpgrp");
1808 }
1809 }
1810 }
1811 free(command);
1812
1813 /* return controlling TTY back to parent process group before exiting */
1814 if (tcsetpgrp(0, parent_pgrp))
1815 perror_msg("tcsetpgrp");
1816
1817 /* return exit status if called with "-c" */
1818 if (input == NULL && WIFEXITED(status))
1819 return WEXITSTATUS(status);
1820
1821 return 0;
1822}
1823
1824
1825#ifdef BB_FEATURE_CLEAN_UP
1826void free_memory(void)
1827{
1828 if (cwd) {
1829 free(cwd);
1830 cwd = NULL;
1831 }
1832 if (local_pending_command)
1833 free(local_pending_command);
1834
1835 if (job_list.fg && !job_list.fg->running_progs) {
1836 remove_job(&job_list, job_list.fg);
1837 }
1838}
1839#endif
1840
1841
1842int shell_main(int argc_l, char **argv_l)
1843{
1844 int opt, interactive=FALSE;
1845 FILE *input = stdin;
1846 argc = argc_l;
1847 argv = argv_l;
1848
1849 /* These variables need re-initializing when recursing */
1850 shell_context = 0;
1851 local_pending_command = NULL;
1852 close_me_head = NULL;
1853 job_list.head = NULL;
1854 job_list.fg = NULL;
1855#ifdef BB_FEATURE_SH_ENVIRONMENT
1856 last_bg_pid=1;
1857 last_return_code=1;
1858 show_x_trace=FALSE;
1859#endif
1860
1861 if (argv[0] && argv[0][0] == '-') {
1862 FILE *prof_input;
1863 prof_input = fopen("/etc/profile", "r");
1864 if (!prof_input) {
1865 printf( "Couldn't open file '/etc/profile'\n");
1866 } else {
1867 int tmp_fd = fileno(prof_input);
1868 mark_open(tmp_fd);
1869 /* Now run the file */
1870 busy_loop(prof_input);
1871 fclose(prof_input);
1872 mark_closed(tmp_fd);
1873 }
1874 }
1875
1876 while ((opt = getopt(argc_l, argv_l, "cxi")) > 0) {
1877 switch (opt) {
1878 case 'c':
1879 input = NULL;
1880 if (local_pending_command != 0)
1881 error_msg_and_die("multiple -c arguments");
1882 local_pending_command = xstrdup(argv[optind]);
1883 optind++;
1884 argv = argv+optind;
1885 break;
1886#ifdef BB_FEATURE_SH_ENVIRONMENT
1887 case 'x':
1888 show_x_trace = TRUE;
1889 break;
1890#endif
1891 case 'i':
1892 interactive = TRUE;
1893 break;
1894 default:
1895 show_usage();
1896 }
1897 }
1898 /* A shell is interactive if the `-i' flag was given, or if all of
1899 * the following conditions are met:
1900 * no -c command
1901 * no arguments remaining or the -s flag given
1902 * standard input is a terminal
1903 * standard output is a terminal
1904 * Refer to Posix.2, the description of the `sh' utility. */
1905 if (argv[optind]==NULL && input==stdin &&
1906 isatty(fileno(stdin)) && isatty(fileno(stdout))) {
1907 interactive=TRUE;
1908 }
1909 if (interactive==TRUE) {
1910 //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
1911 /* Looks like they want an interactive shell */
1912 printf( "\n\n" BB_BANNER " Built-in shell (lash)\n");
1913 printf( "Enter 'help' for a list of built-in commands.\n\n");
1914 } else if (local_pending_command==NULL) {
1915 //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
1916 input = xfopen(argv[optind], "r");
1917 mark_open(fileno(input)); /* be lazy, never mark this closed */
1918 }
1919
1920 /* initialize the cwd -- this is never freed...*/
1921 cwd = xgetcwd(0);
1922
1923#ifdef BB_FEATURE_CLEAN_UP
1924 atexit(free_memory);
1925#endif
1926
1927#ifdef BB_FEATURE_COMMAND_EDITING
1928 cmdedit_set_initial_prompt();
1929#else
1930 PS1 = NULL;
1931#endif
1932
1933 return (busy_loop(input));
1934}
1935
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-23 19:08:46 +0000