blob: 54d6b3ad7dd3d8dfd4d71150b6ac5457164873dc [file] [log] [blame]
Erik Andersen3522eb12000-03-12 23:49:18 +00001/* vi: set sw=4 ts=4: */
2/*
Erik Andersen6acaa402000-03-26 14:03:20 +00003 * lash -- the BusyBox Lame-Ass SHell
Erik Andersen3522eb12000-03-12 23:49:18 +00004 *
5 * Copyright (C) 2000 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
Eric Andersen8ea28be2001-01-05 20:58:22 +000028/* 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 */
Eric Andersen1e7cea92000-12-06 23:47:38 +000034//
Eric Andersene9f07fb2000-12-21 18:31:36 +000035//This works pretty well now, and is now on by default.
Eric Andersen06f64b22000-09-19 07:16:39 +000036#define BB_FEATURE_SH_ENVIRONMENT
Eric Andersen1e7cea92000-12-06 23:47:38 +000037//
38//Backtick support has some problems, use at your own risk!
39//#define BB_FEATURE_SH_BACKTICKS
40//
Eric Andersen86349772000-12-18 20:25:50 +000041//If, then, else, etc. support.. This should now behave basically
42//like any other Bourne shell...
Eric Andersene9f07fb2000-12-21 18:31:36 +000043#define BB_FEATURE_SH_IF_EXPRESSIONS
Eric Andersen1e7cea92000-12-06 23:47:38 +000044//
Eric Andersen86349772000-12-18 20:25:50 +000045/* This is currently a little broken... */
46//#define HANDLE_CONTINUATION_CHARS
47//
Eric Andersen1e7cea92000-12-06 23:47:38 +000048//For debugging/development on the shell only...
Eric Andersen501c88b2000-07-28 15:14:45 +000049//#define DEBUG_SHELL
Eric Andersena1d187a2000-07-17 19:14:41 +000050
51
Eric Andersen3570a342000-09-25 21:45:58 +000052#include "busybox.h"
Erik Andersen3522eb12000-03-12 23:49:18 +000053#include <stdio.h>
54#include <stdlib.h>
55#include <ctype.h>
56#include <errno.h>
57#include <fcntl.h>
58#include <glob.h>
59#include <signal.h>
60#include <string.h>
61#include <sys/ioctl.h>
62#include <sys/wait.h>
63#include <unistd.h>
Eric Andersen501c88b2000-07-28 15:14:45 +000064#include <getopt.h>
Erik Andersenf0657d32000-04-12 17:49:52 +000065#include "cmdedit.h"
Erik Andersen3522eb12000-03-12 23:49:18 +000066
Mark Whitley59ab0252001-01-23 22:30:04 +000067static const int MAX_LINE = 256; /* size of input buffer for cwd data */
68static const int MAX_READ = 128; /* size of input buffer for `read' builtin */
Erik Andersen3522eb12000-03-12 23:49:18 +000069#define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
Eric Andersen8c725e62000-11-30 00:27:06 +000070extern size_t NUM_APPLETS;
Erik Andersen3522eb12000-03-12 23:49:18 +000071
Erik Andersend75af992000-03-16 08:09:09 +000072
Eric Andersen86349772000-12-18 20:25:50 +000073enum redir_type { REDIRECT_INPUT, REDIRECT_OVERWRITE,
Erik Andersen161220c2000-03-16 08:12:48 +000074 REDIRECT_APPEND
75};
Erik Andersen3522eb12000-03-12 23:49:18 +000076
Eric Andersen86349772000-12-18 20:25:50 +000077static const unsigned int DEFAULT_CONTEXT=0x1;
Eric Andersen6a99aaf2000-07-27 00:15:20 +000078static const unsigned int IF_TRUE_CONTEXT=0x2;
79static const unsigned int IF_FALSE_CONTEXT=0x4;
80static const unsigned int THEN_EXP_CONTEXT=0x8;
81static const unsigned int ELSE_EXP_CONTEXT=0x10;
Eric Andersenfad9c112000-07-25 18:06:52 +000082
Eric Andersen86349772000-12-18 20:25:50 +000083
84struct jobset {
Erik Andersen161220c2000-03-16 08:12:48 +000085 struct job *head; /* head of list of running jobs */
86 struct job *fg; /* current foreground job */
Erik Andersen3522eb12000-03-12 23:49:18 +000087};
88
Eric Andersen86349772000-12-18 20:25:50 +000089struct redir_struct {
90 enum redir_type type; /* type of redirection */
Erik Andersen161220c2000-03-16 08:12:48 +000091 int fd; /* file descriptor being redirected */
92 char *filename; /* file to redirect fd to */
Erik Andersen3522eb12000-03-12 23:49:18 +000093};
94
Eric Andersen86349772000-12-18 20:25:50 +000095struct child_prog {
Erik Andersen161220c2000-03-16 08:12:48 +000096 pid_t pid; /* 0 if exited */
97 char **argv; /* program name and arguments */
Eric Andersen86349772000-12-18 20:25:50 +000098 int num_redirects; /* elements in redirection array */
99 struct redir_struct *redirects; /* I/O redirects */
100 glob_t glob_result; /* result of parameter globbing */
101 int free_glob; /* should we globfree(&glob_result)? */
102 int is_stopped; /* is the program currently running? */
103 struct job *family; /* pointer back to the child's parent job */
Erik Andersen3522eb12000-03-12 23:49:18 +0000104};
105
106struct job {
Eric Andersen86349772000-12-18 20:25:50 +0000107 int jobid; /* job number */
108 int num_progs; /* total number of programs in job */
109 int running_progs; /* number of programs running */
Erik Andersen161220c2000-03-16 08:12:48 +0000110 char *text; /* name of job */
Eric Andersen86349772000-12-18 20:25:50 +0000111 char *cmdbuf; /* buffer various argv's point into */
Erik Andersen161220c2000-03-16 08:12:48 +0000112 pid_t pgrp; /* process group ID for the job */
Eric Andersen86349772000-12-18 20:25:50 +0000113 struct child_prog *progs; /* array of programs in job */
Erik Andersen161220c2000-03-16 08:12:48 +0000114 struct job *next; /* to track background commands */
Eric Andersen86349772000-12-18 20:25:50 +0000115 int stopped_progs; /* number of programs alive, but stopped */
116 unsigned int job_context; /* bitmask defining current context */
117 struct jobset *job_list;
Erik Andersen3522eb12000-03-12 23:49:18 +0000118};
119
Eric Andersen86349772000-12-18 20:25:50 +0000120struct built_in_command {
Erik Andersen161220c2000-03-16 08:12:48 +0000121 char *cmd; /* name */
122 char *descr; /* description */
Eric Andersen86349772000-12-18 20:25:50 +0000123 int (*function) (struct child_prog *); /* function ptr */
Erik Andersen3522eb12000-03-12 23:49:18 +0000124};
125
Eric Andersen8ea28be2001-01-05 20:58:22 +0000126struct close_me {
127 int fd;
128 struct close_me *next;
129};
130
Eric Andersen34e19412000-07-10 18:47:24 +0000131/* function prototypes for builtins */
Eric Andersen86349772000-12-18 20:25:50 +0000132static int builtin_cd(struct child_prog *cmd);
133static int builtin_env(struct child_prog *dummy);
134static int builtin_exec(struct child_prog *cmd);
135static int builtin_exit(struct child_prog *cmd);
136static int builtin_fg_bg(struct child_prog *cmd);
137static int builtin_help(struct child_prog *cmd);
138static int builtin_jobs(struct child_prog *dummy);
139static int builtin_pwd(struct child_prog *dummy);
140static int builtin_export(struct child_prog *cmd);
141static int builtin_source(struct child_prog *cmd);
142static int builtin_unset(struct child_prog *cmd);
143static int builtin_read(struct child_prog *cmd);
Eric Andersenfad9c112000-07-25 18:06:52 +0000144#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
Eric Andersen86349772000-12-18 20:25:50 +0000145static int builtin_if(struct child_prog *cmd);
146static int builtin_then(struct child_prog *cmd);
147static int builtin_else(struct child_prog *cmd);
148static int builtin_fi(struct child_prog *cmd);
Eric Andersen70da6a62000-12-20 22:59:16 +0000149/* function prototypes for shell stuff */
150static int run_command_predicate(char *cmd);
Eric Andersenfad9c112000-07-25 18:06:52 +0000151#endif
Erik Andersen3522eb12000-03-12 23:49:18 +0000152
Eric Andersen34e19412000-07-10 18:47:24 +0000153
154/* function prototypes for shell stuff */
Eric Andersen8ea28be2001-01-05 20:58:22 +0000155static void mark_open(int fd);
156static void mark_closed(int fd);
Eric Andersen86349772000-12-18 20:25:50 +0000157static void checkjobs(struct jobset *job_list);
158static int get_command(FILE * source, char *command);
159static int parse_command(char **command_ptr, struct job *job, int *inbg);
160static int run_command(struct job *newjob, int inbg, int outpipe[2]);
161static int pseudo_exec(struct child_prog *cmd) __attribute__ ((noreturn));
Erik Andersen3522eb12000-03-12 23:49:18 +0000162static int busy_loop(FILE * input);
163
Erik Andersend75af992000-03-16 08:09:09 +0000164
Mark Whitley37653aa2000-07-12 23:36:17 +0000165/* Table of built-in functions (these are non-forking builtins, meaning they
166 * can change global variables in the parent shell process but they will not
167 * work with pipes and redirects; 'unset foo | whatever' will not work) */
Eric Andersen86349772000-12-18 20:25:50 +0000168static struct built_in_command bltins[] = {
Eric Andersenfad9c112000-07-25 18:06:52 +0000169 {"bg", "Resume a job in the background", builtin_fg_bg},
170 {"cd", "Change working directory", builtin_cd},
Eric Andersend2f56772000-09-21 02:48:07 +0000171 {"exec", "Exec command, replacing this shell with the exec'd process", builtin_exec},
Eric Andersenfad9c112000-07-25 18:06:52 +0000172 {"exit", "Exit from shell()", builtin_exit},
173 {"fg", "Bring job into the foreground", builtin_fg_bg},
174 {"jobs", "Lists the active jobs", builtin_jobs},
175 {"export", "Set environment variable", builtin_export},
176 {"unset", "Unset environment variable", builtin_unset},
177 {"read", "Input environment variable", builtin_read},
Matt Kraaidd450a02000-09-13 03:43:36 +0000178 {".", "Source-in and run commands in a file", builtin_source},
Eric Andersen86349772000-12-18 20:25:50 +0000179 /* to do: add ulimit */
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000180#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
181 {"if", NULL, builtin_if},
182 {"then", NULL, builtin_then},
183 {"else", NULL, builtin_else},
184 {"fi", NULL, builtin_fi},
185#endif
Eric Andersenfad9c112000-07-25 18:06:52 +0000186 {NULL, NULL, NULL}
Erik Andersen330fd2b2000-05-19 05:35:19 +0000187};
188
Mark Whitley37653aa2000-07-12 23:36:17 +0000189/* Table of forking built-in functions (things that fork cannot change global
190 * variables in the parent process, such as the current working directory) */
Eric Andersen86349772000-12-18 20:25:50 +0000191static struct built_in_command bltins_forking[] = {
Eric Andersenfad9c112000-07-25 18:06:52 +0000192 {"env", "Print all environment variables", builtin_env},
193 {"pwd", "Print current directory", builtin_pwd},
Eric Andersenfad9c112000-07-25 18:06:52 +0000194 {"help", "List shell built-in commands", builtin_help},
195 {NULL, NULL, NULL}
Erik Andersen3522eb12000-03-12 23:49:18 +0000196};
197
Eric Andersen0bcc8132001-01-05 19:37:32 +0000198
199/* Variables we export */
200unsigned int shell_context; /* Used in cmdedit.c to reset the
201 context when someone hits ^C */
202
203
204/* Globals that are static to this file */
Eric Andersen6efc48c2000-07-18 08:16:39 +0000205static char *cwd;
Eric Andersen744b0642001-01-05 21:23:44 +0000206static char *local_pending_command = NULL;
Eric Andersen86349772000-12-18 20:25:50 +0000207static struct jobset job_list = { NULL, NULL };
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000208static int argc;
209static char **argv;
Eric Andersen8ea28be2001-01-05 20:58:22 +0000210static struct close_me *close_me_head = NULL;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000211#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen86349772000-12-18 20:25:50 +0000212static int last_bg_pid=-1;
213static int last_return_code=-1;
214static int show_x_trace=FALSE;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000215#endif
Eric Andersen86349772000-12-18 20:25:50 +0000216#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
217static char syntax_err[]="syntax error near unexpected token";
218#endif
219
Eric Andersenb558e762000-11-30 22:43:16 +0000220#ifdef DEBUG_SHELL
221static inline void debug_printf(const char *format, ...)
222{
223 va_list args;
224 va_start(args, format);
Eric Andersen86349772000-12-18 20:25:50 +0000225 vfprintf(stderr, format, args);
Eric Andersenb558e762000-11-30 22:43:16 +0000226 va_end(args);
227}
228#else
229static inline void debug_printf(const char *format, ...) { }
230#endif
Erik Andersen3522eb12000-03-12 23:49:18 +0000231
Eric Andersen86349772000-12-18 20:25:50 +0000232/*
233 Most builtins need access to the struct child_prog that has
234 their arguments, previously coded as cmd->progs[0]. That coding
235 can exhibit a bug, if the builtin is not the first command in
236 a pipeline: "echo foo | exec sort" will attempt to exec foo.
237
238builtin previous use notes
239------ ----------------- ---------
240cd cmd->progs[0]
241env 0
242exec cmd->progs[0] squashed bug: didn't look for applets or forking builtins
243exit cmd->progs[0]
244fg_bg cmd->progs[0], job_list->head, job_list->fg
245help 0
246jobs job_list->head
247pwd 0
248export cmd->progs[0] passes cmd, job_list to builtin_env(), which ignores them
249source cmd->progs[0]
250unset cmd->progs[0]
251read cmd->progs[0]
252if cmd->job_context, cmd->text
253then cmd->job_context, cmd->text
254else cmd->job_context, cmd->text
255fi cmd->job_context
256
257The use of cmd->text by if/then/else/fi is hopelessly hacky.
258Would it work to increment cmd->progs[0]->argv and recurse,
259somewhat like builtin_exec does?
260
261I added "struct job *family;" to struct child_prog,
262and switched API to builtin_foo(struct child_prog *child);
263So cmd->text becomes child->family->text
264 cmd->job_context becomes child->family->job_context
265 cmd->progs[0] becomes *child
266 job_list becomes child->family->job_list
267 */
Erik Andersen3522eb12000-03-12 23:49:18 +0000268
Erik Andersend75af992000-03-16 08:09:09 +0000269/* built-in 'cd <path>' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000270static int builtin_cd(struct child_prog *child)
Erik Andersend75af992000-03-16 08:09:09 +0000271{
Erik Andersen161220c2000-03-16 08:12:48 +0000272 char *newdir;
Erik Andersend75af992000-03-16 08:09:09 +0000273
Eric Andersen86349772000-12-18 20:25:50 +0000274 if (child->argv[1] == NULL)
Erik Andersen161220c2000-03-16 08:12:48 +0000275 newdir = getenv("HOME");
276 else
Eric Andersen86349772000-12-18 20:25:50 +0000277 newdir = child->argv[1];
Erik Andersen161220c2000-03-16 08:12:48 +0000278 if (chdir(newdir)) {
279 printf("cd: %s: %s\n", newdir, strerror(errno));
Matt Kraai3e856ce2000-12-01 02:55:13 +0000280 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000281 }
Eric Andersen6efc48c2000-07-18 08:16:39 +0000282 getcwd(cwd, sizeof(char)*MAX_LINE);
Erik Andersen161220c2000-03-16 08:12:48 +0000283
Matt Kraai3e856ce2000-12-01 02:55:13 +0000284 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000285}
286
287/* built-in 'env' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000288static int builtin_env(struct child_prog *dummy)
Erik Andersen3522eb12000-03-12 23:49:18 +0000289{
Erik Andersen161220c2000-03-16 08:12:48 +0000290 char **e;
Erik Andersen3522eb12000-03-12 23:49:18 +0000291
Erik Andersen161220c2000-03-16 08:12:48 +0000292 for (e = environ; *e; e++) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +0000293 printf( "%s\n", *e);
Erik Andersen161220c2000-03-16 08:12:48 +0000294 }
295 return (0);
Erik Andersen3522eb12000-03-12 23:49:18 +0000296}
297
Eric Andersend2f56772000-09-21 02:48:07 +0000298/* built-in 'exec' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000299static int builtin_exec(struct child_prog *child)
Eric Andersend2f56772000-09-21 02:48:07 +0000300{
Eric Andersen86349772000-12-18 20:25:50 +0000301 if (child->argv[1] == NULL)
302 return EXIT_SUCCESS; /* Really? */
303 child->argv++;
304 pseudo_exec(child);
305 /* never returns */
Eric Andersend2f56772000-09-21 02:48:07 +0000306}
307
Erik Andersen3522eb12000-03-12 23:49:18 +0000308/* built-in 'exit' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000309static int builtin_exit(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000310{
Eric Andersen86349772000-12-18 20:25:50 +0000311 if (child->argv[1] == NULL)
Matt Kraai3e856ce2000-12-01 02:55:13 +0000312 exit(EXIT_SUCCESS);
Erik Andersen161220c2000-03-16 08:12:48 +0000313
Eric Andersen86349772000-12-18 20:25:50 +0000314 exit (atoi(child->argv[1]));
Erik Andersen3522eb12000-03-12 23:49:18 +0000315}
316
317/* built-in 'fg' and 'bg' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000318static int builtin_fg_bg(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000319{
Erik Andersen161220c2000-03-16 08:12:48 +0000320 int i, jobNum;
Erik Andersen6273f652000-03-17 01:12:41 +0000321 struct job *job=NULL;
Eric Andersen86349772000-12-18 20:25:50 +0000322
Eric Andersene9f07fb2000-12-21 18:31:36 +0000323 if (!child->argv[1] || child->argv[2]) {
324 error_msg("%s: exactly one argument is expected\n",
325 child->argv[0]);
326 return EXIT_FAILURE;
327 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000328
Eric Andersene9f07fb2000-12-21 18:31:36 +0000329 if (sscanf(child->argv[1], "%%%d", &jobNum) != 1) {
330 error_msg("%s: bad argument '%s'\n",
331 child->argv[0], child->argv[1]);
332 return EXIT_FAILURE;
333 }
334
335 for (job = child->family->job_list->head; job; job = job->next) {
336 if (job->jobid == jobNum) {
337 break;
Erik Andersen161220c2000-03-16 08:12:48 +0000338 }
Eric Andersene9f07fb2000-12-21 18:31:36 +0000339 }
Erik Andersen161220c2000-03-16 08:12:48 +0000340
341 if (!job) {
Mark Whitleyf57c9442000-12-07 19:56:48 +0000342 error_msg("%s: unknown job %d\n",
Eric Andersen86349772000-12-18 20:25:50 +0000343 child->argv[0], jobNum);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000344 return EXIT_FAILURE;
Erik Andersend75af992000-03-16 08:09:09 +0000345 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000346
Eric Andersen86349772000-12-18 20:25:50 +0000347 if (*child->argv[0] == 'f') {
Erik Andersen161220c2000-03-16 08:12:48 +0000348 /* Make this job the foreground job */
Eric Andersen1c314ad2000-06-28 16:56:25 +0000349 /* suppress messages when run from /linuxrc mag@sysgo.de */
350 if (tcsetpgrp(0, job->pgrp) && errno != ENOTTY)
Matt Kraaia9819b22000-12-22 01:48:07 +0000351 perror_msg("tcsetpgrp");
Eric Andersen86349772000-12-18 20:25:50 +0000352 child->family->job_list->fg = job;
Erik Andersen161220c2000-03-16 08:12:48 +0000353 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000354
Erik Andersen161220c2000-03-16 08:12:48 +0000355 /* Restart the processes in the job */
Eric Andersen86349772000-12-18 20:25:50 +0000356 for (i = 0; i < job->num_progs; i++)
357 job->progs[i].is_stopped = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000358
Erik Andersen161220c2000-03-16 08:12:48 +0000359 kill(-job->pgrp, SIGCONT);
Erik Andersen3522eb12000-03-12 23:49:18 +0000360
Eric Andersen86349772000-12-18 20:25:50 +0000361 job->stopped_progs = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000362
Matt Kraai3e856ce2000-12-01 02:55:13 +0000363 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000364}
365
366/* built-in 'help' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000367static int builtin_help(struct child_prog *dummy)
Erik Andersen3522eb12000-03-12 23:49:18 +0000368{
Eric Andersen86349772000-12-18 20:25:50 +0000369 struct built_in_command *x;
Erik Andersen3522eb12000-03-12 23:49:18 +0000370
Eric Andersen86349772000-12-18 20:25:50 +0000371 printf("\nBuilt-in commands:\n");
372 printf("-------------------\n");
Erik Andersen161220c2000-03-16 08:12:48 +0000373 for (x = bltins; x->cmd; x++) {
Eric Andersenfad9c112000-07-25 18:06:52 +0000374 if (x->descr==NULL)
375 continue;
Eric Andersen86349772000-12-18 20:25:50 +0000376 printf("%s\t%s\n", x->cmd, x->descr);
Erik Andersen161220c2000-03-16 08:12:48 +0000377 }
Erik Andersen330fd2b2000-05-19 05:35:19 +0000378 for (x = bltins_forking; x->cmd; x++) {
Eric Andersenfad9c112000-07-25 18:06:52 +0000379 if (x->descr==NULL)
380 continue;
Eric Andersen86349772000-12-18 20:25:50 +0000381 printf("%s\t%s\n", x->cmd, x->descr);
Erik Andersen330fd2b2000-05-19 05:35:19 +0000382 }
Eric Andersen86349772000-12-18 20:25:50 +0000383 printf("\n\n");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000384 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000385}
386
387/* built-in 'jobs' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000388static int builtin_jobs(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000389{
Erik Andersen161220c2000-03-16 08:12:48 +0000390 struct job *job;
Eric Andersen86349772000-12-18 20:25:50 +0000391 char *status_string;
Erik Andersen3522eb12000-03-12 23:49:18 +0000392
Eric Andersen86349772000-12-18 20:25:50 +0000393 for (job = child->family->job_list->head; job; job = job->next) {
394 if (job->running_progs == job->stopped_progs)
395 status_string = "Stopped";
Erik Andersen161220c2000-03-16 08:12:48 +0000396 else
Eric Andersen86349772000-12-18 20:25:50 +0000397 status_string = "Running";
Erik Andersen161220c2000-03-16 08:12:48 +0000398
Eric Andersen86349772000-12-18 20:25:50 +0000399 printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text);
Erik Andersen161220c2000-03-16 08:12:48 +0000400 }
Matt Kraai3e856ce2000-12-01 02:55:13 +0000401 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000402}
403
404
405/* built-in 'pwd' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000406static int builtin_pwd(struct child_prog *dummy)
Erik Andersen3522eb12000-03-12 23:49:18 +0000407{
Eric Andersen86349772000-12-18 20:25:50 +0000408 getcwd(cwd, MAX_LINE);
Eric Andersen6f65a3a2001-01-20 01:10:07 +0000409 printf( "%s\n", cwd);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000410 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000411}
412
Erik Andersen6273f652000-03-17 01:12:41 +0000413/* built-in 'export VAR=value' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000414static int builtin_export(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000415{
Erik Andersen161220c2000-03-16 08:12:48 +0000416 int res;
Erik Andersen3522eb12000-03-12 23:49:18 +0000417
Eric Andersen86349772000-12-18 20:25:50 +0000418 if (child->argv[1] == NULL) {
419 return (builtin_env(child));
Erik Andersen161220c2000-03-16 08:12:48 +0000420 }
Eric Andersen86349772000-12-18 20:25:50 +0000421 res = putenv(child->argv[1]);
Erik Andersen161220c2000-03-16 08:12:48 +0000422 if (res)
Eric Andersen86349772000-12-18 20:25:50 +0000423 fprintf(stderr, "export: %s\n", strerror(errno));
Erik Andersen161220c2000-03-16 08:12:48 +0000424 return (res);
Erik Andersen3522eb12000-03-12 23:49:18 +0000425}
426
Eric Andersenb54833c2000-07-03 23:56:26 +0000427/* built-in 'read VAR' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000428static int builtin_read(struct child_prog *child)
Eric Andersenb54833c2000-07-03 23:56:26 +0000429{
430 int res = 0, len, newlen;
431 char *s;
432 char string[MAX_READ];
433
Eric Andersen86349772000-12-18 20:25:50 +0000434 if (child->argv[1]) {
Eric Andersenb54833c2000-07-03 23:56:26 +0000435 /* argument (VAR) given: put "VAR=" into buffer */
Eric Andersen86349772000-12-18 20:25:50 +0000436 strcpy(string, child->argv[1]);
Eric Andersenb54833c2000-07-03 23:56:26 +0000437 len = strlen(string);
438 string[len++] = '=';
439 string[len] = '\0';
440 fgets(&string[len], sizeof(string) - len, stdin); /* read string */
441 newlen = strlen(string);
442 if(newlen > len)
443 string[--newlen] = '\0'; /* chomp trailing newline */
444 /*
445 ** string should now contain "VAR=<value>"
446 ** copy it (putenv() won't do that, so we must make sure
447 ** the string resides in a static buffer!)
448 */
449 res = -1;
450 if((s = strdup(string)))
451 res = putenv(s);
452 if (res)
Eric Andersen86349772000-12-18 20:25:50 +0000453 fprintf(stderr, "read: %s\n", strerror(errno));
Eric Andersenb54833c2000-07-03 23:56:26 +0000454 }
455 else
456 fgets(string, sizeof(string), stdin);
457
458 return (res);
459}
460
Eric Andersenfad9c112000-07-25 18:06:52 +0000461#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
462/* Built-in handler for 'if' commands */
Eric Andersen86349772000-12-18 20:25:50 +0000463static int builtin_if(struct child_prog *child)
Eric Andersenfad9c112000-07-25 18:06:52 +0000464{
Eric Andersen86349772000-12-18 20:25:50 +0000465 struct job *cmd = child->family;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000466 int status;
467 char* charptr1=cmd->text+3; /* skip over the leading 'if ' */
468
469 /* Now run the 'if' command */
Eric Andersen86349772000-12-18 20:25:50 +0000470 debug_printf( "job=%p entering builtin_if ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
471 status = run_command_predicate(charptr1);
472 debug_printf( "if test returned ");
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000473 if (status == 0) {
Eric Andersen86349772000-12-18 20:25:50 +0000474 debug_printf( "TRUE\n");
475 cmd->job_context |= IF_TRUE_CONTEXT;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000476 } else {
Eric Andersen86349772000-12-18 20:25:50 +0000477 debug_printf( "FALSE\n");
478 cmd->job_context |= IF_FALSE_CONTEXT;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000479 }
Eric Andersen86349772000-12-18 20:25:50 +0000480 debug_printf("job=%p builtin_if set job context to %x\n", cmd, cmd->job_context);
481 shell_context++;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000482
483 return status;
Eric Andersenfad9c112000-07-25 18:06:52 +0000484}
485
486/* Built-in handler for 'then' (part of the 'if' command) */
Eric Andersen86349772000-12-18 20:25:50 +0000487static int builtin_then(struct child_prog *child)
Eric Andersenfad9c112000-07-25 18:06:52 +0000488{
Eric Andersen86349772000-12-18 20:25:50 +0000489 struct job *cmd = child->family;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000490 char* charptr1=cmd->text+5; /* skip over the leading 'then ' */
491
Eric Andersen86349772000-12-18 20:25:50 +0000492 debug_printf( "job=%p entering builtin_then ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
493 if (! (cmd->job_context & (IF_TRUE_CONTEXT|IF_FALSE_CONTEXT))) {
494 shell_context = 0; /* Reset the shell's context on an error */
495 error_msg("%s `then'\n", syntax_err);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000496 return EXIT_FAILURE;
Eric Andersenfad9c112000-07-25 18:06:52 +0000497 }
Eric Andersen86349772000-12-18 20:25:50 +0000498
499 cmd->job_context |= THEN_EXP_CONTEXT;
500 debug_printf("job=%p builtin_then set job context to %x\n", cmd, cmd->job_context);
501
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000502 /* If the if result was FALSE, skip the 'then' stuff */
Eric Andersen86349772000-12-18 20:25:50 +0000503 if (cmd->job_context & IF_FALSE_CONTEXT) {
Matt Kraai3e856ce2000-12-01 02:55:13 +0000504 return EXIT_SUCCESS;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000505 }
506
Eric Andersen86349772000-12-18 20:25:50 +0000507 /* Seems the if result was TRUE, so run the 'then' command */
508 debug_printf( "'then' now running '%s'\n", charptr1);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000509
Eric Andersen86349772000-12-18 20:25:50 +0000510 return(run_command_predicate(charptr1));
Eric Andersenfad9c112000-07-25 18:06:52 +0000511}
512
513/* Built-in handler for 'else' (part of the 'if' command) */
Eric Andersen86349772000-12-18 20:25:50 +0000514static int builtin_else(struct child_prog *child)
Eric Andersenfad9c112000-07-25 18:06:52 +0000515{
Eric Andersen86349772000-12-18 20:25:50 +0000516 struct job *cmd = child->family;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000517 char* charptr1=cmd->text+5; /* skip over the leading 'else ' */
518
Eric Andersen86349772000-12-18 20:25:50 +0000519 debug_printf( "job=%p entering builtin_else ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
520
521 if (! (cmd->job_context & THEN_EXP_CONTEXT)) {
522 shell_context = 0; /* Reset the shell's context on an error */
523 error_msg("%s `else'\n", syntax_err);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000524 return EXIT_FAILURE;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000525 }
526 /* If the if result was TRUE, skip the 'else' stuff */
Eric Andersen86349772000-12-18 20:25:50 +0000527 if (cmd->job_context & IF_TRUE_CONTEXT) {
Matt Kraai3e856ce2000-12-01 02:55:13 +0000528 return EXIT_SUCCESS;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000529 }
530
Eric Andersen86349772000-12-18 20:25:50 +0000531 cmd->job_context |= ELSE_EXP_CONTEXT;
Eric Andersene9f07fb2000-12-21 18:31:36 +0000532 debug_printf("job=%p builtin_else set job context to %x\n", cmd, cmd->job_context);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000533
534 /* Now run the 'else' command */
Eric Andersen86349772000-12-18 20:25:50 +0000535 debug_printf( "'else' now running '%s'\n", charptr1);
536 return(run_command_predicate(charptr1));
Eric Andersenfad9c112000-07-25 18:06:52 +0000537}
538
539/* Built-in handler for 'fi' (part of the 'if' command) */
Eric Andersen86349772000-12-18 20:25:50 +0000540static int builtin_fi(struct child_prog *child)
Eric Andersenfad9c112000-07-25 18:06:52 +0000541{
Eric Andersen86349772000-12-18 20:25:50 +0000542 struct job *cmd = child->family;
543 debug_printf( "job=%p entering builtin_fi ('%s')-- context=%d\n", cmd, "", cmd->job_context);
544 if (! (cmd->job_context & (IF_TRUE_CONTEXT|IF_FALSE_CONTEXT))) {
545 shell_context = 0; /* Reset the shell's context on an error */
546 error_msg("%s `fi'\n", syntax_err);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000547 return EXIT_FAILURE;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000548 }
549 /* Clear out the if and then context bits */
Eric Andersen86349772000-12-18 20:25:50 +0000550 cmd->job_context &= ~(IF_TRUE_CONTEXT|IF_FALSE_CONTEXT|THEN_EXP_CONTEXT|ELSE_EXP_CONTEXT);
551 debug_printf("job=%p builtin_fi set job context to %x\n", cmd, cmd->job_context);
552 shell_context--;
Matt Kraai3e856ce2000-12-01 02:55:13 +0000553 return EXIT_SUCCESS;
Eric Andersenfad9c112000-07-25 18:06:52 +0000554}
555#endif
556
Erik Andersen3522eb12000-03-12 23:49:18 +0000557/* Built-in '.' handler (read-in and execute commands from file) */
Eric Andersen86349772000-12-18 20:25:50 +0000558static int builtin_source(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000559{
Erik Andersen161220c2000-03-16 08:12:48 +0000560 FILE *input;
561 int status;
Eric Andersen8ea28be2001-01-05 20:58:22 +0000562 int fd;
Erik Andersen3522eb12000-03-12 23:49:18 +0000563
Eric Andersen86349772000-12-18 20:25:50 +0000564 if (child->argv[1] == NULL)
Matt Kraai3e856ce2000-12-01 02:55:13 +0000565 return EXIT_FAILURE;
Erik Andersen3522eb12000-03-12 23:49:18 +0000566
Eric Andersen86349772000-12-18 20:25:50 +0000567 input = fopen(child->argv[1], "r");
Erik Andersen161220c2000-03-16 08:12:48 +0000568 if (!input) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +0000569 printf( "Couldn't open file '%s'\n", child->argv[1]);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000570 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000571 }
Erik Andersend75af992000-03-16 08:09:09 +0000572
Eric Andersen8ea28be2001-01-05 20:58:22 +0000573 fd=fileno(input);
574 mark_open(fd);
Erik Andersen161220c2000-03-16 08:12:48 +0000575 /* Now run the file */
576 status = busy_loop(input);
Matt Kraaidd450a02000-09-13 03:43:36 +0000577 fclose(input);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000578 mark_closed(fd);
Erik Andersen161220c2000-03-16 08:12:48 +0000579 return (status);
Erik Andersen3522eb12000-03-12 23:49:18 +0000580}
581
582/* built-in 'unset VAR' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000583static int builtin_unset(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000584{
Eric Andersen86349772000-12-18 20:25:50 +0000585 if (child->argv[1] == NULL) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +0000586 printf( "unset: parameter required.\n");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000587 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000588 }
Eric Andersen86349772000-12-18 20:25:50 +0000589 unsetenv(child->argv[1]);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000590 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000591}
592
Eric Andersen70da6a62000-12-20 22:59:16 +0000593#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
Eric Andersen86349772000-12-18 20:25:50 +0000594/* currently used by if/then/else.
Eric Andersene9f07fb2000-12-21 18:31:36 +0000595 *
596 * Reparsing the command line for this purpose is gross,
597 * incorrect, and fundamentally unfixable; in particular,
598 * think about what happens with command substitution.
599 * We really need to pull out the run, wait, return status
600 * functionality out of busy_loop so we can child->argv++
601 * and use that, without going back through parse_command.
Eric Andersen86349772000-12-18 20:25:50 +0000602 */
603static int run_command_predicate(char *cmd)
604{
605 int n=strlen(cmd);
606 local_pending_command = xmalloc(n+1);
607 strncpy(local_pending_command, cmd, n);
608 local_pending_command[n]='\0';
609 return( busy_loop(NULL));
610}
Eric Andersen70da6a62000-12-20 22:59:16 +0000611#endif
Eric Andersen86349772000-12-18 20:25:50 +0000612
Eric Andersen8ea28be2001-01-05 20:58:22 +0000613static void mark_open(int fd)
614{
615 struct close_me *new = xmalloc(sizeof(struct close_me));
616 new->fd = fd;
617 new->next = close_me_head;
618 close_me_head = new;
619}
620
621static void mark_closed(int fd)
622{
623 struct close_me *tmp;
624 if (close_me_head == NULL || close_me_head->fd != fd)
625 error_msg_and_die("corrupt close_me");
626 tmp = close_me_head;
627 close_me_head = close_me_head->next;
628 free(tmp);
629}
630
631static void close_all()
632{
633 struct close_me *c;
634 for (c=close_me_head; c; c=c->next) {
635 close(c->fd);
636 }
637 close_me_head = NULL;
638}
639
640
Erik Andersen3522eb12000-03-12 23:49:18 +0000641/* free up all memory from a job */
Eric Andersen86349772000-12-18 20:25:50 +0000642static void free_job(struct job *cmd)
Erik Andersen3522eb12000-03-12 23:49:18 +0000643{
Erik Andersen161220c2000-03-16 08:12:48 +0000644 int i;
Erik Andersen3522eb12000-03-12 23:49:18 +0000645
Eric Andersen86349772000-12-18 20:25:50 +0000646 for (i = 0; i < cmd->num_progs; i++) {
Erik Andersen161220c2000-03-16 08:12:48 +0000647 free(cmd->progs[i].argv);
Eric Andersen86349772000-12-18 20:25:50 +0000648 if (cmd->progs[i].redirects)
649 free(cmd->progs[i].redirects);
650 if (cmd->progs[i].free_glob)
651 globfree(&cmd->progs[i].glob_result);
Erik Andersen161220c2000-03-16 08:12:48 +0000652 }
653 free(cmd->progs);
654 if (cmd->text)
655 free(cmd->text);
Eric Andersen86349772000-12-18 20:25:50 +0000656 free(cmd->cmdbuf);
Eric Andersenec10b9d2000-07-14 01:13:11 +0000657 memset(cmd, 0, sizeof(struct job));
Erik Andersen3522eb12000-03-12 23:49:18 +0000658}
659
Eric Andersen86349772000-12-18 20:25:50 +0000660/* remove a job from the job_list */
661static void remove_job(struct jobset *job_list, struct job *job)
Erik Andersen3522eb12000-03-12 23:49:18 +0000662{
Eric Andersen86349772000-12-18 20:25:50 +0000663 struct job *prevjob;
Erik Andersen3522eb12000-03-12 23:49:18 +0000664
Eric Andersen86349772000-12-18 20:25:50 +0000665 free_job(job);
666 if (job == job_list->head) {
667 job_list->head = job->next;
Erik Andersen161220c2000-03-16 08:12:48 +0000668 } else {
Eric Andersen86349772000-12-18 20:25:50 +0000669 prevjob = job_list->head;
670 while (prevjob->next != job)
671 prevjob = prevjob->next;
672 prevjob->next = job->next;
Erik Andersen161220c2000-03-16 08:12:48 +0000673 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000674
Erik Andersen161220c2000-03-16 08:12:48 +0000675 free(job);
Erik Andersen3522eb12000-03-12 23:49:18 +0000676}
677
678/* Checks to see if any background processes have exited -- if they
679 have, figure out why and see if a job has completed */
Eric Andersen86349772000-12-18 20:25:50 +0000680static void checkjobs(struct jobset *job_list)
Erik Andersen3522eb12000-03-12 23:49:18 +0000681{
Erik Andersen161220c2000-03-16 08:12:48 +0000682 struct job *job;
683 pid_t childpid;
684 int status;
Eric Andersen86349772000-12-18 20:25:50 +0000685 int prognum = 0;
Erik Andersend75af992000-03-16 08:09:09 +0000686
Erik Andersen161220c2000-03-16 08:12:48 +0000687 while ((childpid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
Eric Andersen86349772000-12-18 20:25:50 +0000688 for (job = job_list->head; job; job = job->next) {
689 prognum = 0;
690 while (prognum < job->num_progs &&
691 job->progs[prognum].pid != childpid) prognum++;
692 if (prognum < job->num_progs)
Erik Andersen161220c2000-03-16 08:12:48 +0000693 break;
694 }
695
Eric Andersena1d187a2000-07-17 19:14:41 +0000696 /* This happens on backticked commands */
697 if(job==NULL)
698 return;
699
Erik Andersen161220c2000-03-16 08:12:48 +0000700 if (WIFEXITED(status) || WIFSIGNALED(status)) {
701 /* child exited */
Eric Andersen86349772000-12-18 20:25:50 +0000702 job->running_progs--;
703 job->progs[prognum].pid = 0;
Erik Andersen161220c2000-03-16 08:12:48 +0000704
Eric Andersen86349772000-12-18 20:25:50 +0000705 if (!job->running_progs) {
706 printf(JOB_STATUS_FORMAT, job->jobid, "Done", job->text);
707 remove_job(job_list, job);
Erik Andersen161220c2000-03-16 08:12:48 +0000708 }
709 } else {
710 /* child stopped */
Eric Andersen86349772000-12-18 20:25:50 +0000711 job->stopped_progs++;
712 job->progs[prognum].is_stopped = 1;
Erik Andersen161220c2000-03-16 08:12:48 +0000713
Eric Andersen86349772000-12-18 20:25:50 +0000714 if (job->stopped_progs == job->num_progs) {
715 printf(JOB_STATUS_FORMAT, job->jobid, "Stopped",
Erik Andersen161220c2000-03-16 08:12:48 +0000716 job->text);
717 }
718 }
Erik Andersend75af992000-03-16 08:09:09 +0000719 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000720
Erik Andersen161220c2000-03-16 08:12:48 +0000721 if (childpid == -1 && errno != ECHILD)
Matt Kraaia9819b22000-12-22 01:48:07 +0000722 perror_msg("waitpid");
Erik Andersen3522eb12000-03-12 23:49:18 +0000723}
724
Eric Andersene9f07fb2000-12-21 18:31:36 +0000725/* squirrel != NULL means we squirrel away copies of stdin, stdout,
726 * and stderr if they are redirected. */
727static int setup_redirects(struct child_prog *prog, int squirrel[])
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000728{
729 int i;
730 int openfd;
731 int mode = O_RDONLY;
Eric Andersen86349772000-12-18 20:25:50 +0000732 struct redir_struct *redir = prog->redirects;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000733
Eric Andersen86349772000-12-18 20:25:50 +0000734 for (i = 0; i < prog->num_redirects; i++, redir++) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000735 switch (redir->type) {
736 case REDIRECT_INPUT:
737 mode = O_RDONLY;
738 break;
739 case REDIRECT_OVERWRITE:
Eric Andersen46f0beb2000-11-14 21:59:22 +0000740 mode = O_WRONLY | O_CREAT | O_TRUNC;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000741 break;
742 case REDIRECT_APPEND:
Eric Andersen46f0beb2000-11-14 21:59:22 +0000743 mode = O_WRONLY | O_CREAT | O_APPEND;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000744 break;
745 }
746
747 openfd = open(redir->filename, mode, 0666);
748 if (openfd < 0) {
749 /* this could get lost if stderr has been redirected, but
750 bash and ash both lose it as well (though zsh doesn't!) */
Mark Whitleyf57c9442000-12-07 19:56:48 +0000751 error_msg("error opening %s: %s\n", redir->filename,
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000752 strerror(errno));
753 return 1;
754 }
755
756 if (openfd != redir->fd) {
Eric Andersene9f07fb2000-12-21 18:31:36 +0000757 if (squirrel && redir->fd < 3) {
758 squirrel[redir->fd] = dup(redir->fd);
759 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000760 dup2(openfd, redir->fd);
761 close(openfd);
762 }
763 }
764
765 return 0;
766}
767
Eric Andersene9f07fb2000-12-21 18:31:36 +0000768static void restore_redirects(int squirrel[])
769{
770 int i, fd;
771 for (i=0; i<3; i++) {
772 fd = squirrel[i];
773 if (fd != -1) {
774 /* No error checking. I sure wouldn't know what
775 * to do with an error if I found one! */
776 dup2(fd, i);
777 close(fd);
778 }
779 }
780}
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000781
Eric Andersen09acc062001-01-04 11:10:38 +0000782static char* setup_prompt_string(int state)
Erik Andersen3522eb12000-03-12 23:49:18 +0000783{
Eric Andersenf361ac22000-12-12 23:45:36 +0000784 char user[9],buf[255],*s;
Eric Andersen09acc062001-01-04 11:10:38 +0000785 char prompt[3];
786 char prompt_str[BUFSIZ];
787
788 /* Set up the prompt */
789 if (state == 0) {
790 /* get User Name and setup prompt */
791 strcpy(prompt,( geteuid() != 0 ) ? "$ ":"# ");
792 my_getpwuid(user, geteuid());
793
794 /* get HostName */
795 gethostname(buf, 255);
796 s = strchr(buf, '.');
797 if (s) {
798 *s = 0;
799 }
800 } else {
801 strcpy(prompt,"> ");
802 }
803
804 if (state == 0) {
805 snprintf(prompt_str, BUFSIZ-1, "[%s@%s %s]%s", user, buf,
806 get_last_path_component(cwd), prompt);
807 } else {
808 sprintf(prompt_str, "%s", prompt);
809 }
810 return(strdup(prompt_str)); /* Must free this memory */
811}
812
813static int get_command(FILE * source, char *command)
814{
815 char *prompt_str;
Eric Andersen8ea28be2001-01-05 20:58:22 +0000816
Eric Andersen1c314ad2000-06-28 16:56:25 +0000817 if (source == NULL) {
818 if (local_pending_command) {
819 /* a command specified (-c option): return it & mark it done */
820 strcpy(command, local_pending_command);
821 free(local_pending_command);
822 local_pending_command = NULL;
823 return 0;
824 }
825 return 1;
826 }
827
Erik Andersen161220c2000-03-16 08:12:48 +0000828 if (source == stdin) {
Matt Kraaidefcd5e2001-01-05 02:53:11 +0000829 prompt_str = setup_prompt_string(shell_context);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000830
Erik Andersend75af992000-03-16 08:09:09 +0000831#ifdef BB_FEATURE_SH_COMMAND_EDITING
Eric Andersen501c88b2000-07-28 15:14:45 +0000832 /*
833 ** enable command line editing only while a command line
834 ** is actually being read; otherwise, we'll end up bequeathing
835 ** atexit() handlers and other unwanted stuff to our
836 ** child processes (rob@sysgo.de)
837 */
838 cmdedit_init();
Eric Andersen86349772000-12-18 20:25:50 +0000839 cmdedit_read_input(prompt_str, command);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000840 free(prompt_str);
Eric Andersen501c88b2000-07-28 15:14:45 +0000841 cmdedit_terminate();
Erik Andersen161220c2000-03-16 08:12:48 +0000842 return 0;
Erik Andersenc7c634b2000-03-19 05:28:55 +0000843#else
Eric Andersen8ea28be2001-01-05 20:58:22 +0000844 fputs(prompt_str, stdout);
845 free(prompt_str);
Erik Andersend75af992000-03-16 08:09:09 +0000846#endif
Erik Andersen161220c2000-03-16 08:12:48 +0000847 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000848
Erik Andersen161220c2000-03-16 08:12:48 +0000849 if (!fgets(command, BUFSIZ - 2, source)) {
850 if (source == stdin)
851 printf("\n");
852 return 1;
853 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000854
Erik Andersen161220c2000-03-16 08:12:48 +0000855 /* remove trailing newline */
856 command[strlen(command) - 1] = '\0';
Erik Andersen3522eb12000-03-12 23:49:18 +0000857
Erik Andersen161220c2000-03-16 08:12:48 +0000858 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000859}
860
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000861#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000862static char* itoa(register int i)
863{
Eric Andersenb558e762000-11-30 22:43:16 +0000864 static char a[7]; /* Max 7 ints */
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000865 register char *b = a + sizeof(a) - 1;
866 int sign = (i < 0);
867
868 if (sign)
869 i = -i;
870 *b = 0;
871 do
872 {
873 *--b = '0' + (i % 10);
874 i /= 10;
875 }
876 while (i);
877 if (sign)
878 *--b = '-';
879 return b;
880}
881#endif
882
Eric Andersen86349772000-12-18 20:25:50 +0000883static void expand_argument(struct child_prog *prog, int *argcPtr,
884 int *argv_alloced_ptr)
Erik Andersen3522eb12000-03-12 23:49:18 +0000885{
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000886 int argc_l = *argcPtr;
Eric Andersen86349772000-12-18 20:25:50 +0000887 int argv_alloced = *argv_alloced_ptr;
Erik Andersen161220c2000-03-16 08:12:48 +0000888 int rc;
889 int flags;
890 int i;
Eric Andersenb54833c2000-07-03 23:56:26 +0000891 char *src, *dst, *var;
Erik Andersen3522eb12000-03-12 23:49:18 +0000892
Eric Andersen86349772000-12-18 20:25:50 +0000893 if (argc_l > 1) { /* cmd->glob_result is already initialized */
Erik Andersen161220c2000-03-16 08:12:48 +0000894 flags = GLOB_APPEND;
Eric Andersen86349772000-12-18 20:25:50 +0000895 i = prog->glob_result.gl_pathc;
Erik Andersen161220c2000-03-16 08:12:48 +0000896 } else {
Eric Andersen86349772000-12-18 20:25:50 +0000897 prog->free_glob = 1;
Erik Andersen161220c2000-03-16 08:12:48 +0000898 flags = 0;
899 i = 0;
Erik Andersend75af992000-03-16 08:09:09 +0000900 }
Eric Andersenb54833c2000-07-03 23:56:26 +0000901 /* do shell variable substitution */
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000902 if(*prog->argv[argc_l - 1] == '$') {
903 if ((var = getenv(prog->argv[argc_l - 1] + 1))) {
904 prog->argv[argc_l - 1] = var;
905 }
906#ifdef BB_FEATURE_SH_ENVIRONMENT
907 else {
908 switch(*(prog->argv[argc_l - 1] + 1)) {
909 case '?':
Eric Andersen86349772000-12-18 20:25:50 +0000910 prog->argv[argc_l - 1] = itoa(last_return_code);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000911 break;
912 case '$':
913 prog->argv[argc_l - 1] = itoa(getpid());
914 break;
915 case '#':
916 prog->argv[argc_l - 1] = itoa(argc-1);
917 break;
918 case '!':
Eric Andersen86349772000-12-18 20:25:50 +0000919 if (last_bg_pid==-1)
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000920 *(prog->argv[argc_l - 1])='\0';
921 else
Eric Andersen86349772000-12-18 20:25:50 +0000922 prog->argv[argc_l - 1] = itoa(last_bg_pid);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000923 break;
924 case '0':case '1':case '2':case '3':case '4':
925 case '5':case '6':case '7':case '8':case '9':
926 {
927 int index=*(prog->argv[argc_l - 1] + 1)-48;
928 if (index >= argc) {
929 *(prog->argv[argc_l - 1])='\0';
930 } else {
931 prog->argv[argc_l - 1] = argv[index];
932 }
933 }
934 break;
935 }
936 }
937#endif
938 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000939
Eric Andersen46f0beb2000-11-14 21:59:22 +0000940 if (strpbrk(prog->argv[argc_l - 1],"*[]?")!= NULL){
Eric Andersen86349772000-12-18 20:25:50 +0000941 rc = glob(prog->argv[argc_l - 1], flags, NULL, &prog->glob_result);
Eric Andersen46f0beb2000-11-14 21:59:22 +0000942 if (rc == GLOB_NOSPACE) {
Mark Whitleyf57c9442000-12-07 19:56:48 +0000943 error_msg("out of space during glob operation\n");
Eric Andersen46f0beb2000-11-14 21:59:22 +0000944 return;
945 } else if (rc == GLOB_NOMATCH ||
Eric Andersen86349772000-12-18 20:25:50 +0000946 (!rc && (prog->glob_result.gl_pathc - i) == 1 &&
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000947 strcmp(prog->argv[argc_l - 1],
Eric Andersen86349772000-12-18 20:25:50 +0000948 prog->glob_result.gl_pathv[i]) == 0)) {
Eric Andersen46f0beb2000-11-14 21:59:22 +0000949 /* we need to remove whatever \ quoting is still present */
950 src = dst = prog->argv[argc_l - 1];
951 while (*src) {
Eric Andersen8c2d3f42000-11-30 00:03:57 +0000952 if (*src == '\\') {
953 src++;
954 *dst++ = process_escape_sequence(&src);
955 } else {
Eric Andersen46f0beb2000-11-14 21:59:22 +0000956 *dst++ = *src;
Eric Andersen8c2d3f42000-11-30 00:03:57 +0000957 src++;
958 }
Eric Andersen46f0beb2000-11-14 21:59:22 +0000959 }
960 *dst = '\0';
961 } else if (!rc) {
Eric Andersen86349772000-12-18 20:25:50 +0000962 argv_alloced += (prog->glob_result.gl_pathc - i);
963 prog->argv = xrealloc(prog->argv, argv_alloced * sizeof(*prog->argv));
964 memcpy(prog->argv + (argc_l - 1), prog->glob_result.gl_pathv + i,
965 sizeof(*(prog->argv)) * (prog->glob_result.gl_pathc - i));
966 argc_l += (prog->glob_result.gl_pathc - i - 1);
Erik Andersen161220c2000-03-16 08:12:48 +0000967 }
Eric Andersen46f0beb2000-11-14 21:59:22 +0000968 }else{
969 src = dst = prog->argv[argc_l - 1];
970 while (*src) {
Eric Andersen8c2d3f42000-11-30 00:03:57 +0000971 if (*src == '\\') {
972 src++;
973 *dst++ = process_escape_sequence(&src);
974 } else {
Eric Andersen46f0beb2000-11-14 21:59:22 +0000975 *dst++ = *src;
Eric Andersen8c2d3f42000-11-30 00:03:57 +0000976 src++;
977 }
Eric Andersen46f0beb2000-11-14 21:59:22 +0000978 }
979 *dst = '\0';
Eric Andersen8c2d3f42000-11-30 00:03:57 +0000980
Eric Andersen86349772000-12-18 20:25:50 +0000981 prog->glob_result.gl_pathc=0;
Eric Andersen46f0beb2000-11-14 21:59:22 +0000982 if (flags==0)
Eric Andersen86349772000-12-18 20:25:50 +0000983 prog->glob_result.gl_pathv=NULL;
Erik Andersen161220c2000-03-16 08:12:48 +0000984 }
Eric Andersen86349772000-12-18 20:25:50 +0000985 *argv_alloced_ptr = argv_alloced;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000986 *argcPtr = argc_l;
Erik Andersen3522eb12000-03-12 23:49:18 +0000987}
988
Eric Andersen86349772000-12-18 20:25:50 +0000989/* Return cmd->num_progs as 0 if no command is present (e.g. an empty
990 line). If a valid command is found, command_ptr is set to point to
Erik Andersen3522eb12000-03-12 23:49:18 +0000991 the beginning of the next command (if the original command had more
992 then one job associated with it) or NULL if no more commands are
993 present. */
Eric Andersen86349772000-12-18 20:25:50 +0000994static int parse_command(char **command_ptr, struct job *job, int *inbg)
Erik Andersen3522eb12000-03-12 23:49:18 +0000995{
Erik Andersen161220c2000-03-16 08:12:48 +0000996 char *command;
Eric Andersen86349772000-12-18 20:25:50 +0000997 char *return_command = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +0000998 char *src, *buf, *chptr;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000999 int argc_l = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001000 int done = 0;
Eric Andersen86349772000-12-18 20:25:50 +00001001 int argv_alloced;
Erik Andersen161220c2000-03-16 08:12:48 +00001002 int i;
1003 char quote = '\0';
1004 int count;
Eric Andersen86349772000-12-18 20:25:50 +00001005 struct child_prog *prog;
Erik Andersen3522eb12000-03-12 23:49:18 +00001006
Erik Andersen161220c2000-03-16 08:12:48 +00001007 /* skip leading white space */
Eric Andersen86349772000-12-18 20:25:50 +00001008 while (**command_ptr && isspace(**command_ptr))
1009 (*command_ptr)++;
Erik Andersen3522eb12000-03-12 23:49:18 +00001010
Erik Andersen161220c2000-03-16 08:12:48 +00001011 /* this handles empty lines or leading '#' characters */
Eric Andersen86349772000-12-18 20:25:50 +00001012 if (!**command_ptr || (**command_ptr == '#')) {
1013 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001014 return 0;
1015 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001016
Eric Andersen86349772000-12-18 20:25:50 +00001017 *inbg = 0;
1018 job->num_progs = 1;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001019 job->progs = xmalloc(sizeof(*job->progs));
Erik Andersen3522eb12000-03-12 23:49:18 +00001020
Erik Andersen161220c2000-03-16 08:12:48 +00001021 /* We set the argv elements to point inside of this string. The
Eric Andersen86349772000-12-18 20:25:50 +00001022 memory is freed by free_job(). Allocate twice the original
Eric Andersenb54833c2000-07-03 23:56:26 +00001023 length in case we need to quote every single character.
Erik Andersen3522eb12000-03-12 23:49:18 +00001024
Erik Andersen161220c2000-03-16 08:12:48 +00001025 Getting clean memory relieves us of the task of NULL
1026 terminating things and makes the rest of this look a bit
1027 cleaner (though it is, admittedly, a tad less efficient) */
Eric Andersen86349772000-12-18 20:25:50 +00001028 job->cmdbuf = command = xcalloc(2*strlen(*command_ptr) + 1, sizeof(char));
Erik Andersen161220c2000-03-16 08:12:48 +00001029 job->text = NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +00001030
Erik Andersen161220c2000-03-16 08:12:48 +00001031 prog = job->progs;
Eric Andersen86349772000-12-18 20:25:50 +00001032 prog->num_redirects = 0;
1033 prog->redirects = NULL;
1034 prog->free_glob = 0;
1035 prog->is_stopped = 0;
1036 prog->family = job;
Erik Andersen3522eb12000-03-12 23:49:18 +00001037
Eric Andersen86349772000-12-18 20:25:50 +00001038 argv_alloced = 5;
1039 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
1040 prog->argv[0] = job->cmdbuf;
Erik Andersen3522eb12000-03-12 23:49:18 +00001041
Erik Andersen161220c2000-03-16 08:12:48 +00001042 buf = command;
Eric Andersen86349772000-12-18 20:25:50 +00001043 src = *command_ptr;
Erik Andersen161220c2000-03-16 08:12:48 +00001044 while (*src && !done) {
1045 if (quote == *src) {
1046 quote = '\0';
1047 } else if (quote) {
1048 if (*src == '\\') {
1049 src++;
1050 if (!*src) {
Mark Whitleyf57c9442000-12-07 19:56:48 +00001051 error_msg("character expected after \\\n");
Eric Andersen86349772000-12-18 20:25:50 +00001052 free_job(job);
Erik Andersen161220c2000-03-16 08:12:48 +00001053 return 1;
1054 }
1055
1056 /* in shell, "\'" should yield \' */
Eric Andersenb2356f62000-12-11 19:14:40 +00001057 if (*src != quote) {
Erik Andersen161220c2000-03-16 08:12:48 +00001058 *buf++ = '\\';
Eric Andersenb2356f62000-12-11 19:14:40 +00001059 *buf++ = '\\';
1060 }
Erik Andersen161220c2000-03-16 08:12:48 +00001061 } else if (*src == '*' || *src == '?' || *src == '[' ||
1062 *src == ']') *buf++ = '\\';
1063 *buf++ = *src;
1064 } else if (isspace(*src)) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001065 if (*prog->argv[argc_l]) {
1066 buf++, argc_l++;
Erik Andersen161220c2000-03-16 08:12:48 +00001067 /* +1 here leaves room for the NULL which ends argv */
Eric Andersen86349772000-12-18 20:25:50 +00001068 if ((argc_l + 1) == argv_alloced) {
1069 argv_alloced += 5;
Matt Kraaib8907522000-09-13 02:08:21 +00001070 prog->argv = xrealloc(prog->argv,
1071 sizeof(*prog->argv) *
Eric Andersen86349772000-12-18 20:25:50 +00001072 argv_alloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001073 }
Eric Andersen86349772000-12-18 20:25:50 +00001074 expand_argument(prog, &argc_l, &argv_alloced);
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001075 prog->argv[argc_l] = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001076 }
1077 } else
1078 switch (*src) {
1079 case '"':
1080 case '\'':
1081 quote = *src;
1082 break;
1083
1084 case '#': /* comment */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001085 if (*(src-1)== '$')
1086 *buf++ = *src;
1087 else
1088 done = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001089 break;
1090
Eric Andersen86349772000-12-18 20:25:50 +00001091 case '>': /* redirects */
Erik Andersen161220c2000-03-16 08:12:48 +00001092 case '<':
Eric Andersen86349772000-12-18 20:25:50 +00001093 i = prog->num_redirects++;
1094 prog->redirects = xrealloc(prog->redirects,
1095 sizeof(*prog->redirects) *
Matt Kraaib8907522000-09-13 02:08:21 +00001096 (i + 1));
Erik Andersen161220c2000-03-16 08:12:48 +00001097
Eric Andersen86349772000-12-18 20:25:50 +00001098 prog->redirects[i].fd = -1;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001099 if (buf != prog->argv[argc_l]) {
Erik Andersen161220c2000-03-16 08:12:48 +00001100 /* the stuff before this character may be the file number
1101 being redirected */
Eric Andersen86349772000-12-18 20:25:50 +00001102 prog->redirects[i].fd =
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001103 strtol(prog->argv[argc_l], &chptr, 10);
Erik Andersen161220c2000-03-16 08:12:48 +00001104
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001105 if (*chptr && *prog->argv[argc_l]) {
1106 buf++, argc_l++;
Eric Andersen86349772000-12-18 20:25:50 +00001107 expand_argument(prog, &argc_l, &argv_alloced);
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001108 prog->argv[argc_l] = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001109 }
1110 }
1111
Eric Andersen86349772000-12-18 20:25:50 +00001112 if (prog->redirects[i].fd == -1) {
Erik Andersen161220c2000-03-16 08:12:48 +00001113 if (*src == '>')
Eric Andersen86349772000-12-18 20:25:50 +00001114 prog->redirects[i].fd = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001115 else
Eric Andersen86349772000-12-18 20:25:50 +00001116 prog->redirects[i].fd = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001117 }
1118
1119 if (*src++ == '>') {
1120 if (*src == '>')
Eric Andersen86349772000-12-18 20:25:50 +00001121 prog->redirects[i].type =
Erik Andersen161220c2000-03-16 08:12:48 +00001122 REDIRECT_APPEND, src++;
1123 else
Eric Andersen86349772000-12-18 20:25:50 +00001124 prog->redirects[i].type = REDIRECT_OVERWRITE;
Erik Andersen161220c2000-03-16 08:12:48 +00001125 } else {
Eric Andersen86349772000-12-18 20:25:50 +00001126 prog->redirects[i].type = REDIRECT_INPUT;
Erik Andersen161220c2000-03-16 08:12:48 +00001127 }
1128
1129 /* This isn't POSIX sh compliant. Oh well. */
1130 chptr = src;
1131 while (isspace(*chptr))
1132 chptr++;
1133
1134 if (!*chptr) {
Mark Whitleyf57c9442000-12-07 19:56:48 +00001135 error_msg("file name expected after %c\n", *src);
Eric Andersen86349772000-12-18 20:25:50 +00001136 free_job(job);
1137 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001138 return 1;
1139 }
1140
Eric Andersen86349772000-12-18 20:25:50 +00001141 prog->redirects[i].filename = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001142 while (*chptr && !isspace(*chptr))
1143 *buf++ = *chptr++;
1144
1145 src = chptr - 1; /* we src++ later */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001146 prog->argv[argc_l] = ++buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001147 break;
1148
1149 case '|': /* pipe */
1150 /* finish this command */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001151 if (*prog->argv[argc_l])
1152 argc_l++;
1153 if (!argc_l) {
Mark Whitleyf57c9442000-12-07 19:56:48 +00001154 error_msg("empty command in pipe\n");
Eric Andersen86349772000-12-18 20:25:50 +00001155 free_job(job);
1156 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001157 return 1;
1158 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001159 prog->argv[argc_l] = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001160
1161 /* and start the next */
Eric Andersen86349772000-12-18 20:25:50 +00001162 job->num_progs++;
Matt Kraaib8907522000-09-13 02:08:21 +00001163 job->progs = xrealloc(job->progs,
Eric Andersen86349772000-12-18 20:25:50 +00001164 sizeof(*job->progs) * job->num_progs);
1165 prog = job->progs + (job->num_progs - 1);
1166 prog->num_redirects = 0;
1167 prog->redirects = NULL;
1168 prog->free_glob = 0;
1169 prog->is_stopped = 0;
1170 prog->family = job;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001171 argc_l = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001172
Eric Andersen86349772000-12-18 20:25:50 +00001173 argv_alloced = 5;
1174 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001175 prog->argv[0] = ++buf;
1176
1177 src++;
1178 while (*src && isspace(*src))
1179 src++;
1180
1181 if (!*src) {
Mark Whitleyf57c9442000-12-07 19:56:48 +00001182 error_msg("empty command in pipe\n");
Eric Andersen86349772000-12-18 20:25:50 +00001183 free_job(job);
1184 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001185 return 1;
1186 }
1187 src--; /* we'll ++ it at the end of the loop */
1188
1189 break;
1190
1191 case '&': /* background */
Eric Andersen86349772000-12-18 20:25:50 +00001192 *inbg = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001193 case ';': /* multiple commands */
1194 done = 1;
Eric Andersen86349772000-12-18 20:25:50 +00001195 return_command = *command_ptr + (src - *command_ptr) + 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001196 break;
1197
Eric Andersena1d187a2000-07-17 19:14:41 +00001198#ifdef BB_FEATURE_SH_BACKTICKS
Eric Andersenec10b9d2000-07-14 01:13:11 +00001199 case '`':
1200 /* Exec a backtick-ed command */
Eric Andersen8ea28be2001-01-05 20:58:22 +00001201 /* Besides any previous brokenness, I have not
1202 * updated backtick handling for close_me support.
1203 * I don't know if it needs it or not. -- LRD */
Eric Andersenec10b9d2000-07-14 01:13:11 +00001204 {
Eric Andersena1d187a2000-07-17 19:14:41 +00001205 char* charptr1=NULL, *charptr2;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001206 char* ptr=NULL;
Eric Andersen86349772000-12-18 20:25:50 +00001207 struct job *newjob;
1208 struct jobset njob_list = { NULL, NULL };
Eric Andersena1d187a2000-07-17 19:14:41 +00001209 int pipefd[2];
1210 int size;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001211
1212 ptr=strchr(++src, '`');
1213 if (ptr==NULL) {
1214 fprintf(stderr, "Unmatched '`' in command\n");
Eric Andersen86349772000-12-18 20:25:50 +00001215 free_job(job);
Eric Andersenec10b9d2000-07-14 01:13:11 +00001216 return 1;
1217 }
1218
Eric Andersena1d187a2000-07-17 19:14:41 +00001219 /* Make some space to hold just the backticked command */
Eric Andersen6efc48c2000-07-18 08:16:39 +00001220 charptr1 = charptr2 = xmalloc(1+ptr-src);
Matt Kraai0b2da462000-09-19 06:46:44 +00001221 memcpy(charptr1, src, ptr-src);
1222 charptr1[ptr-src] = '\0';
Eric Andersen86349772000-12-18 20:25:50 +00001223 newjob = xmalloc(sizeof(struct job));
1224 newjob->job_list = &njob_list;
Eric Andersena1d187a2000-07-17 19:14:41 +00001225 /* Now parse and run the backticked command */
Eric Andersen86349772000-12-18 20:25:50 +00001226 if (!parse_command(&charptr1, newjob, inbg)
1227 && newjob->num_progs) {
Eric Andersena1d187a2000-07-17 19:14:41 +00001228 pipe(pipefd);
Eric Andersen86349772000-12-18 20:25:50 +00001229 run_command(newjob, 0, pipefd);
Eric Andersenec10b9d2000-07-14 01:13:11 +00001230 }
Eric Andersen86349772000-12-18 20:25:50 +00001231 checkjobs(job->job_list);
1232 free_job(newjob); /* doesn't actually free newjob,
1233 looks like a memory leak */
Eric Andersen6efc48c2000-07-18 08:16:39 +00001234 free(charptr2);
1235
1236 /* Make a copy of any stuff left over in the command
1237 * line after the second backtick */
1238 charptr2 = xmalloc(strlen(ptr)+1);
1239 memcpy(charptr2, ptr+1, strlen(ptr));
1240
Eric Andersenec10b9d2000-07-14 01:13:11 +00001241
Eric Andersena1d187a2000-07-17 19:14:41 +00001242 /* Copy the output from the backtick-ed command into the
1243 * command line, making extra room as needed */
1244 --src;
1245 charptr1 = xmalloc(BUFSIZ);
Mark Whitleyf57c9442000-12-07 19:56:48 +00001246 while ( (size=full_read(pipefd[0], charptr1, BUFSIZ-1)) >0) {
Eric Andersen86349772000-12-18 20:25:50 +00001247 int newsize=src - *command_ptr + size + 1 + strlen(charptr2);
1248 if (newsize > BUFSIZ) {
1249 *command_ptr=xrealloc(*command_ptr, newsize);
Eric Andersena1d187a2000-07-17 19:14:41 +00001250 }
1251 memcpy(src, charptr1, size);
1252 src+=size;
1253 }
1254 free(charptr1);
1255 close(pipefd[0]);
1256 if (*(src-1)=='\n')
1257 --src;
1258
Eric Andersen86349772000-12-18 20:25:50 +00001259 /* Now paste into the *command_ptr all the stuff
Eric Andersena1d187a2000-07-17 19:14:41 +00001260 * leftover after the second backtick */
Matt Kraaicbbe4d62000-09-14 00:26:50 +00001261 memcpy(src, charptr2, strlen(charptr2)+1);
Eric Andersena1d187a2000-07-17 19:14:41 +00001262 free(charptr2);
1263
Eric Andersen86349772000-12-18 20:25:50 +00001264 /* Now recursively call parse_command to deal with the new
Eric Andersena1d187a2000-07-17 19:14:41 +00001265 * and improved version of the command line with the backtick
1266 * results expanded in place... */
Eric Andersen86349772000-12-18 20:25:50 +00001267 {
1268 struct jobset *jl=job->job_list;
1269 free_job(job);
1270 job->job_list = jl;
1271 }
1272 return(parse_command(command_ptr, job, inbg));
Eric Andersenec10b9d2000-07-14 01:13:11 +00001273 }
1274 break;
Eric Andersena1d187a2000-07-17 19:14:41 +00001275#endif // BB_FEATURE_SH_BACKTICKS
Matt Kraai131241f2000-09-14 00:43:20 +00001276
1277 case '\\':
1278 src++;
1279 if (!*src) {
Eric Andersen86349772000-12-18 20:25:50 +00001280/* This is currently a little broken... */
1281#ifdef HANDLE_CONTINUATION_CHARS
1282 /* They fed us a continuation char, so continue reading stuff
1283 * on the next line, then tack that onto the end of the current
1284 * command */
1285 char *command;
1286 int newsize;
1287 printf("erik: found a continue char at EOL...\n");
1288 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1289 if (get_command(input, command)) {
1290 error_msg("character expected after \\\n");
1291 free(command);
1292 free_job(job);
1293 return 1;
1294 }
1295 newsize = strlen(*command_ptr) + strlen(command) + 2;
1296 if (newsize > BUFSIZ) {
1297 printf("erik: doing realloc\n");
1298 *command_ptr=xrealloc(*command_ptr, newsize);
1299 }
1300 printf("erik: A: *command_ptr='%s'\n", *command_ptr);
1301 memcpy(--src, command, strlen(command));
1302 printf("erik: B: *command_ptr='%s'\n", *command_ptr);
1303 free(command);
1304 break;
1305#else
Mark Whitleyf57c9442000-12-07 19:56:48 +00001306 error_msg("character expected after \\\n");
Eric Andersen86349772000-12-18 20:25:50 +00001307 free(command);
1308 free_job(job);
Matt Kraai131241f2000-09-14 00:43:20 +00001309 return 1;
Eric Andersen86349772000-12-18 20:25:50 +00001310#endif
Matt Kraai131241f2000-09-14 00:43:20 +00001311 }
1312 if (*src == '*' || *src == '[' || *src == ']'
1313 || *src == '?') *buf++ = '\\';
1314 /* fallthrough */
Erik Andersen161220c2000-03-16 08:12:48 +00001315 default:
1316 *buf++ = *src;
1317 }
1318
Erik Andersend75af992000-03-16 08:09:09 +00001319 src++;
Erik Andersen161220c2000-03-16 08:12:48 +00001320 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001321
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001322 if (*prog->argv[argc_l]) {
1323 argc_l++;
Eric Andersen86349772000-12-18 20:25:50 +00001324 expand_argument(prog, &argc_l, &argv_alloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001325 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001326 if (!argc_l) {
Eric Andersen86349772000-12-18 20:25:50 +00001327 free_job(job);
Erik Andersen161220c2000-03-16 08:12:48 +00001328 return 0;
1329 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001330 prog->argv[argc_l] = NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +00001331
Eric Andersen86349772000-12-18 20:25:50 +00001332 if (!return_command) {
1333 job->text = xmalloc(strlen(*command_ptr) + 1);
1334 strcpy(job->text, *command_ptr);
Erik Andersen161220c2000-03-16 08:12:48 +00001335 } else {
1336 /* This leaves any trailing spaces, which is a bit sloppy */
Eric Andersen86349772000-12-18 20:25:50 +00001337 count = return_command - *command_ptr;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001338 job->text = xmalloc(count + 1);
Eric Andersen86349772000-12-18 20:25:50 +00001339 strncpy(job->text, *command_ptr, count);
Erik Andersen161220c2000-03-16 08:12:48 +00001340 job->text[count] = '\0';
1341 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001342
Eric Andersen86349772000-12-18 20:25:50 +00001343 *command_ptr = return_command;
Eric Andersen46f0beb2000-11-14 21:59:22 +00001344
Erik Andersend75af992000-03-16 08:09:09 +00001345 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001346}
1347
Eric Andersen86349772000-12-18 20:25:50 +00001348/* Run the child_prog, no matter what kind of command it uses.
1349 */
1350static int pseudo_exec(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +00001351{
Eric Andersen86349772000-12-18 20:25:50 +00001352 struct built_in_command *x;
Eric Andersenb54833c2000-07-03 23:56:26 +00001353#ifdef BB_FEATURE_SH_STANDALONE_SHELL
Eric Andersena683ee82000-11-17 18:51:45 +00001354 struct BB_applet search_applet, *applet;
Erik Andersenbcd61772000-05-13 06:33:19 +00001355#endif
Erik Andersen3522eb12000-03-12 23:49:18 +00001356
Eric Andersene9f07fb2000-12-21 18:31:36 +00001357 /* Check if the command matches any of the non-forking builtins.
1358 * Depending on context, this might be redundant. But it's
1359 * easier to waste a few CPU cycles than it is to figure out
1360 * if this is one of those cases.
Eric Andersen86349772000-12-18 20:25:50 +00001361 */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001362 for (x = bltins; x->cmd; x++) {
1363 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1364 exit(x->function(child));
1365 }
1366 }
1367
1368 /* Check if the command matches any of the forking builtins. */
Eric Andersen86349772000-12-18 20:25:50 +00001369 for (x = bltins_forking; x->cmd; x++) {
1370 if (strcmp(child->argv[0], x->cmd) == 0) {
1371 applet_name=x->cmd;
1372 exit (x->function(child));
1373 }
1374 }
1375#ifdef BB_FEATURE_SH_STANDALONE_SHELL
1376 /* Check if the command matches any busybox internal
1377 * commands ("applets") here. Following discussions from
1378 * November 2000 on busybox@opensource.lineo.com, don't use
1379 * get_last_path_component(). This way explicit (with
1380 * slashes) filenames will never be interpreted as an
1381 * applet, just like with builtins. This way the user can
1382 * override an applet with an explicit filename reference.
1383 * The only downside to this change is that an explicit
1384 * /bin/foo invocation will fork and exec /bin/foo, even if
1385 * /bin/foo is a symlink to busybox.
1386 */
1387 search_applet.name = child->argv[0];
1388
1389#ifdef BB_FEATURE_SH_APPLETS_ALWAYS_WIN
1390 /* If you enable BB_FEATURE_SH_APPLETS_ALWAYS_WIN, then
1391 * if you run /bin/cat, it will use BusyBox cat even if
1392 * /bin/cat exists on the filesystem and is _not_ busybox.
1393 * Some systems want this, others do not. Choose wisely. :-)
1394 */
1395 search_applet.name = get_last_path_component(search_applet.name);
1396#endif
1397
1398 /* Do a binary search to find the applet entry given the name. */
1399 applet = bsearch(&search_applet, applets, NUM_APPLETS,
1400 sizeof(struct BB_applet), applet_name_compare);
1401 if (applet != NULL) {
1402 int argc_l;
1403 char** argv=child->argv;
1404 for(argc_l=0;*argv!=NULL; argv++, argc_l++);
1405 applet_name=applet->name;
1406 optind = 1;
1407 exit((*(applet->main)) (argc_l, child->argv));
1408 }
1409#endif
1410
1411 execvp(child->argv[0], child->argv);
Eric Andersen8ea28be2001-01-05 20:58:22 +00001412 perror_msg_and_die("%s", child->argv[0]);
Eric Andersen86349772000-12-18 20:25:50 +00001413}
1414
1415static void insert_job(struct job *newjob, int inbg)
1416{
1417 struct job *thejob;
1418 struct jobset *job_list=newjob->job_list;
1419
1420 /* find the ID for thejob to use */
1421 newjob->jobid = 1;
1422 for (thejob = job_list->head; thejob; thejob = thejob->next)
1423 if (thejob->jobid >= newjob->jobid)
1424 newjob->jobid = thejob->jobid + 1;
1425
1426 /* add thejob to the list of running jobs */
1427 if (!job_list->head) {
1428 thejob = job_list->head = xmalloc(sizeof(*thejob));
1429 } else {
1430 for (thejob = job_list->head; thejob->next; thejob = thejob->next) /* nothing */;
1431 thejob->next = xmalloc(sizeof(*thejob));
1432 thejob = thejob->next;
1433 }
1434
1435 *thejob = *newjob; /* physically copy the struct job */
1436 thejob->next = NULL;
1437 thejob->running_progs = thejob->num_progs;
1438 thejob->stopped_progs = 0;
1439
1440 if (inbg) {
1441 /* we don't wait for background thejobs to return -- append it
1442 to the list of backgrounded thejobs and leave it alone */
1443 printf("[%d] %d\n", thejob->jobid,
1444 newjob->progs[newjob->num_progs - 1].pid);
1445#ifdef BB_FEATURE_SH_ENVIRONMENT
1446 last_bg_pid=newjob->progs[newjob->num_progs - 1].pid;
1447#endif
1448 } else {
1449 newjob->job_list->fg = thejob;
1450
1451 /* move the new process group into the foreground */
1452 /* suppress messages when run from /linuxrc mag@sysgo.de */
1453 if (tcsetpgrp(0, newjob->pgrp) && errno != ENOTTY)
Matt Kraaia9819b22000-12-22 01:48:07 +00001454 perror_msg("tcsetpgrp");
Eric Andersen86349772000-12-18 20:25:50 +00001455 }
1456}
1457
1458static int run_command(struct job *newjob, int inbg, int outpipe[2])
1459{
1460 /* struct job *thejob; */
1461 int i;
1462 int nextin, nextout;
1463 int pipefds[2]; /* pipefd[0] is for reading */
1464 struct built_in_command *x;
1465 struct child_prog *child;
1466
Eric Andersen6efc48c2000-07-18 08:16:39 +00001467 nextin = 0, nextout = 1;
Eric Andersen86349772000-12-18 20:25:50 +00001468 for (i = 0; i < newjob->num_progs; i++) {
1469 child = & (newjob->progs[i]);
1470
1471 if ((i + 1) < newjob->num_progs) {
1472 if (pipe(pipefds)<0) perror_msg_and_die("pipe");
Erik Andersen161220c2000-03-16 08:12:48 +00001473 nextout = pipefds[1];
1474 } else {
Eric Andersen86349772000-12-18 20:25:50 +00001475 if (outpipe[1]!=-1) {
1476 nextout = outpipe[1];
Eric Andersen6efc48c2000-07-18 08:16:39 +00001477 } else {
1478 nextout = 1;
1479 }
Erik Andersen161220c2000-03-16 08:12:48 +00001480 }
1481
Eric Andersen501c88b2000-07-28 15:14:45 +00001482#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen86349772000-12-18 20:25:50 +00001483 if (show_x_trace==TRUE) {
Eric Andersen501c88b2000-07-28 15:14:45 +00001484 int j;
Eric Andersen86349772000-12-18 20:25:50 +00001485 fputc('+', stderr);
1486 for (j = 0; child->argv[j]; j++) {
1487 fputc(' ', stderr);
1488 fputs(child->argv[j], stderr);
1489 }
1490 fputc('\n', stderr);
Eric Andersen501c88b2000-07-28 15:14:45 +00001491 }
1492#endif
1493
Eric Andersene9f07fb2000-12-21 18:31:36 +00001494 /* Check if the command matches any non-forking builtins,
1495 * but only if this is a simple command.
1496 * Non-forking builtins within pipes have to fork anyway,
1497 * and are handled in pseudo_exec. "echo foo | read bar"
1498 * is doomed to failure, and doesn't work on bash, either.
Eric Andersen86349772000-12-18 20:25:50 +00001499 */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001500 if (newjob->num_progs == 1) {
1501 for (x = bltins; x->cmd; x++) {
1502 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1503 int squirrel[] = {-1, -1, -1};
1504 int rcode;
1505 setup_redirects(child, squirrel);
1506 rcode = x->function(child);
1507 restore_redirects(squirrel);
1508 return rcode;
1509 }
Erik Andersen330fd2b2000-05-19 05:35:19 +00001510 }
1511 }
1512
Eric Andersen86349772000-12-18 20:25:50 +00001513 if (!(child->pid = fork())) {
Erik Andersen161220c2000-03-16 08:12:48 +00001514 signal(SIGTTOU, SIG_DFL);
1515
Eric Andersen8ea28be2001-01-05 20:58:22 +00001516 close_all();
1517
Eric Andersen86349772000-12-18 20:25:50 +00001518 if (outpipe[1]!=-1) {
1519 close(outpipe[0]);
Eric Andersen6efc48c2000-07-18 08:16:39 +00001520 }
1521 if (nextin != 0) {
1522 dup2(nextin, 0);
1523 close(nextin);
1524 }
1525
1526 if (nextout != 1) {
Erik Andersen161220c2000-03-16 08:12:48 +00001527 dup2(nextout, 1);
Eric Andersen86349772000-12-18 20:25:50 +00001528 dup2(nextout, 2); /* Really? */
Erik Andersen161220c2000-03-16 08:12:48 +00001529 close(nextout);
Eric Andersen501c88b2000-07-28 15:14:45 +00001530 close(pipefds[0]);
Erik Andersen161220c2000-03-16 08:12:48 +00001531 }
1532
Eric Andersen86349772000-12-18 20:25:50 +00001533 /* explicit redirects override pipes */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001534 setup_redirects(child,NULL);
Erik Andersen161220c2000-03-16 08:12:48 +00001535
Eric Andersen86349772000-12-18 20:25:50 +00001536 pseudo_exec(child);
Erik Andersen161220c2000-03-16 08:12:48 +00001537 }
Eric Andersen86349772000-12-18 20:25:50 +00001538 if (outpipe[1]!=-1) {
1539 close(outpipe[1]);
Eric Andersena1d187a2000-07-17 19:14:41 +00001540 }
Erik Andersen161220c2000-03-16 08:12:48 +00001541
1542 /* put our child in the process group whose leader is the
1543 first process in this pipe */
Eric Andersen86349772000-12-18 20:25:50 +00001544 setpgid(child->pid, newjob->progs[0].pid);
Erik Andersen161220c2000-03-16 08:12:48 +00001545 if (nextin != 0)
1546 close(nextin);
Eric Andersen6efc48c2000-07-18 08:16:39 +00001547 if (nextout != 1)
Erik Andersen161220c2000-03-16 08:12:48 +00001548 close(nextout);
1549
1550 /* If there isn't another process, nextin is garbage
1551 but it doesn't matter */
1552 nextin = pipefds[0];
1553 }
1554
Eric Andersen86349772000-12-18 20:25:50 +00001555 newjob->pgrp = newjob->progs[0].pid;
Erik Andersen161220c2000-03-16 08:12:48 +00001556
Eric Andersen86349772000-12-18 20:25:50 +00001557 insert_job(newjob, inbg);
Erik Andersen3522eb12000-03-12 23:49:18 +00001558
Erik Andersen161220c2000-03-16 08:12:48 +00001559 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001560}
1561
Erik Andersend75af992000-03-16 08:09:09 +00001562static int busy_loop(FILE * input)
Erik Andersen3522eb12000-03-12 23:49:18 +00001563{
Erik Andersen161220c2000-03-16 08:12:48 +00001564 char *command;
Eric Andersen86349772000-12-18 20:25:50 +00001565 char *next_command = NULL;
1566 struct job newjob;
Eric Andersen1c314ad2000-06-28 16:56:25 +00001567 pid_t parent_pgrp;
Erik Andersen161220c2000-03-16 08:12:48 +00001568 int i;
Eric Andersen86349772000-12-18 20:25:50 +00001569 int inbg;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001570 int status;
Eric Andersen86349772000-12-18 20:25:50 +00001571 newjob.job_list = &job_list;
1572 newjob.job_context = DEFAULT_CONTEXT;
Erik Andersen3522eb12000-03-12 23:49:18 +00001573
Eric Andersen1c314ad2000-06-28 16:56:25 +00001574 /* save current owner of TTY so we can restore it on exit */
1575 parent_pgrp = tcgetpgrp(0);
1576
Matt Kraaib8907522000-09-13 02:08:21 +00001577 command = (char *) xcalloc(BUFSIZ, sizeof(char));
Erik Andersend75af992000-03-16 08:09:09 +00001578
Erik Andersen161220c2000-03-16 08:12:48 +00001579 /* don't pay any attention to this signal; it just confuses
1580 things and isn't really meant for shells anyway */
1581 signal(SIGTTOU, SIG_IGN);
Erik Andersend75af992000-03-16 08:09:09 +00001582
Erik Andersen161220c2000-03-16 08:12:48 +00001583 while (1) {
Eric Andersen86349772000-12-18 20:25:50 +00001584 if (!job_list.fg) {
Erik Andersend75af992000-03-16 08:09:09 +00001585 /* no job is in the foreground */
Erik Andersen3522eb12000-03-12 23:49:18 +00001586
Erik Andersend75af992000-03-16 08:09:09 +00001587 /* see if any background processes have exited */
Eric Andersen86349772000-12-18 20:25:50 +00001588 checkjobs(&job_list);
Erik Andersen3522eb12000-03-12 23:49:18 +00001589
Eric Andersen86349772000-12-18 20:25:50 +00001590 if (!next_command) {
1591 if (get_command(input, command))
Erik Andersen161220c2000-03-16 08:12:48 +00001592 break;
Eric Andersen86349772000-12-18 20:25:50 +00001593 next_command = command;
Erik Andersend75af992000-03-16 08:09:09 +00001594 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001595
Eric Andersen86349772000-12-18 20:25:50 +00001596 if (!parse_command(&next_command, &newjob, &inbg) &&
1597 newjob.num_progs) {
Eric Andersena1d187a2000-07-17 19:14:41 +00001598 int pipefds[2] = {-1,-1};
Eric Andersen86349772000-12-18 20:25:50 +00001599 debug_printf( "job=%p being fed to run_command by busy_loop()'\n", &newjob);
1600 run_command(&newjob, inbg, pipefds);
Eric Andersenfad9c112000-07-25 18:06:52 +00001601 }
1602 else {
Eric Andersena1d187a2000-07-17 19:14:41 +00001603 free(command);
Matt Kraaib8907522000-09-13 02:08:21 +00001604 command = (char *) xcalloc(BUFSIZ, sizeof(char));
Eric Andersen86349772000-12-18 20:25:50 +00001605 next_command = NULL;
Erik Andersend75af992000-03-16 08:09:09 +00001606 }
1607 } else {
1608 /* a job is running in the foreground; wait for it */
1609 i = 0;
Eric Andersen86349772000-12-18 20:25:50 +00001610 while (!job_list.fg->progs[i].pid ||
1611 job_list.fg->progs[i].is_stopped == 1) i++;
Erik Andersen3522eb12000-03-12 23:49:18 +00001612
Eric Andersen8ea28be2001-01-05 20:58:22 +00001613 if (waitpid(job_list.fg->progs[i].pid, &status, WUNTRACED)<0)
1614 perror_msg_and_die("waitpid(%d)",job_list.fg->progs[i].pid);
Erik Andersen3522eb12000-03-12 23:49:18 +00001615
Erik Andersend75af992000-03-16 08:09:09 +00001616 if (WIFEXITED(status) || WIFSIGNALED(status)) {
Erik Andersen161220c2000-03-16 08:12:48 +00001617 /* the child exited */
Eric Andersen86349772000-12-18 20:25:50 +00001618 job_list.fg->running_progs--;
1619 job_list.fg->progs[i].pid = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001620
Eric Andersen501c88b2000-07-28 15:14:45 +00001621#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen86349772000-12-18 20:25:50 +00001622 last_return_code=WEXITSTATUS(status);
Eric Andersen501c88b2000-07-28 15:14:45 +00001623#endif
Eric Andersen86349772000-12-18 20:25:50 +00001624 debug_printf("'%s' exited -- return code %d\n",
1625 job_list.fg->text, last_return_code);
1626 if (!job_list.fg->running_progs) {
Erik Andersen161220c2000-03-16 08:12:48 +00001627 /* child exited */
Eric Andersen86349772000-12-18 20:25:50 +00001628 remove_job(&job_list, job_list.fg);
1629 job_list.fg = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001630 }
Erik Andersend75af992000-03-16 08:09:09 +00001631 } else {
Erik Andersen161220c2000-03-16 08:12:48 +00001632 /* the child was stopped */
Eric Andersen86349772000-12-18 20:25:50 +00001633 job_list.fg->stopped_progs++;
1634 job_list.fg->progs[i].is_stopped = 1;
Erik Andersen3522eb12000-03-12 23:49:18 +00001635
Eric Andersen86349772000-12-18 20:25:50 +00001636 if (job_list.fg->stopped_progs == job_list.fg->running_progs) {
1637 printf("\n" JOB_STATUS_FORMAT, job_list.fg->jobid,
1638 "Stopped", job_list.fg->text);
1639 job_list.fg = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001640 }
Erik Andersend75af992000-03-16 08:09:09 +00001641 }
1642
Eric Andersen86349772000-12-18 20:25:50 +00001643 if (!job_list.fg) {
Erik Andersen161220c2000-03-16 08:12:48 +00001644 /* move the shell to the foreground */
Eric Andersen1c314ad2000-06-28 16:56:25 +00001645 /* suppress messages when run from /linuxrc mag@sysgo.de */
1646 if (tcsetpgrp(0, getpid()) && errno != ENOTTY)
Matt Kraaia9819b22000-12-22 01:48:07 +00001647 perror_msg("tcsetpgrp");
Erik Andersend75af992000-03-16 08:09:09 +00001648 }
1649 }
1650 }
Erik Andersen161220c2000-03-16 08:12:48 +00001651 free(command);
Erik Andersen3522eb12000-03-12 23:49:18 +00001652
Eric Andersen1c314ad2000-06-28 16:56:25 +00001653 /* return controlling TTY back to parent process group before exiting */
1654 if (tcsetpgrp(0, parent_pgrp))
Matt Kraaia9819b22000-12-22 01:48:07 +00001655 perror_msg("tcsetpgrp");
Eric Andersenb54833c2000-07-03 23:56:26 +00001656
1657 /* return exit status if called with "-c" */
1658 if (input == NULL && WIFEXITED(status))
1659 return WEXITSTATUS(status);
1660
Erik Andersen161220c2000-03-16 08:12:48 +00001661 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001662}
1663
1664
Eric Andersenfad9c112000-07-25 18:06:52 +00001665#ifdef BB_FEATURE_CLEAN_UP
1666void free_memory(void)
1667{
Eric Andersenfad9c112000-07-25 18:06:52 +00001668 if (cwd)
1669 free(cwd);
1670 if (local_pending_command)
1671 free(local_pending_command);
1672
Eric Andersen86349772000-12-18 20:25:50 +00001673 if (job_list.fg && !job_list.fg->running_progs) {
1674 remove_job(&job_list, job_list.fg);
Eric Andersenfad9c112000-07-25 18:06:52 +00001675 }
1676}
1677#endif
1678
Eric Andersen6efc48c2000-07-18 08:16:39 +00001679
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001680int shell_main(int argc_l, char **argv_l)
Erik Andersen3522eb12000-03-12 23:49:18 +00001681{
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001682 int opt, interactive=FALSE;
Erik Andersen161220c2000-03-16 08:12:48 +00001683 FILE *input = stdin;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001684 argc = argc_l;
1685 argv = argv_l;
Erik Andersen3522eb12000-03-12 23:49:18 +00001686
Eric Andersenb0970d42001-01-05 19:34:52 +00001687 shell_context = 0;
1688 cwd=NULL;
Mark Whitley6e25f922001-01-26 19:19:23 +00001689#ifdef BB_FEATURE_SH_STANDALONE_SHELL
Eric Andersenb0970d42001-01-05 19:34:52 +00001690 /* These variables need re-initializing when recursing */
1691 local_pending_command = NULL;
1692 job_list.head = NULL;
1693 job_list.fg = NULL;
1694#ifdef BB_FEATURE_SH_ENVIRONMENT
1695 last_bg_pid=-1;
1696 last_return_code=-1;
1697 show_x_trace=FALSE;
1698#endif
1699#endif
Eric Andersen501c88b2000-07-28 15:14:45 +00001700
Eric Andersenb558e762000-11-30 22:43:16 +00001701 if (argv[0] && argv[0][0] == '-') {
Eric Andersen8ea28be2001-01-05 20:58:22 +00001702 FILE *prof_input;
1703 prof_input = fopen("/etc/profile", "r");
1704 if (!prof_input) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001705 printf( "Couldn't open file '/etc/profile'\n");
Eric Andersen8ea28be2001-01-05 20:58:22 +00001706 } else {
1707 int tmp_fd = fileno(prof_input);
1708 mark_open(tmp_fd);
1709 /* Now run the file */
1710 busy_loop(prof_input);
1711 fclose(prof_input);
1712 mark_closed(tmp_fd);
1713 }
Eric Andersenb558e762000-11-30 22:43:16 +00001714 }
Eric Andersen501c88b2000-07-28 15:14:45 +00001715
Eric Andersenf21aa842000-12-08 20:50:30 +00001716 while ((opt = getopt(argc_l, argv_l, "cxi")) > 0) {
Eric Andersen501c88b2000-07-28 15:14:45 +00001717 switch (opt) {
1718 case 'c':
1719 input = NULL;
Matt Kraai6085c722000-09-06 01:46:18 +00001720 if (local_pending_command != 0)
Mark Whitleyf57c9442000-12-07 19:56:48 +00001721 error_msg_and_die("multiple -c arguments\n");
Matt Kraai6085c722000-09-06 01:46:18 +00001722 local_pending_command = xstrdup(argv[optind]);
1723 optind++;
1724 argv = argv+optind;
Eric Andersen501c88b2000-07-28 15:14:45 +00001725 break;
Eric Andersen1428c4f2000-07-28 15:19:30 +00001726#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen501c88b2000-07-28 15:14:45 +00001727 case 'x':
Eric Andersen86349772000-12-18 20:25:50 +00001728 show_x_trace = TRUE;
Eric Andersen501c88b2000-07-28 15:14:45 +00001729 break;
Eric Andersen1428c4f2000-07-28 15:19:30 +00001730#endif
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001731 case 'i':
1732 interactive = TRUE;
1733 break;
Eric Andersen501c88b2000-07-28 15:14:45 +00001734 default:
1735 usage(shell_usage);
1736 }
1737 }
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001738 /* A shell is interactive if the `-i' flag was given, or if all of
1739 * the following conditions are met:
1740 * no -c command
1741 * no arguments remaining or the -s flag given
1742 * standard input is a terminal
1743 * standard output is a terminal
1744 * Refer to Posix.2, the description of the `sh' utility. */
Eric Andersen86349772000-12-18 20:25:50 +00001745 if (argv[optind]==NULL && input==stdin &&
1746 isatty(fileno(stdin)) && isatty(fileno(stdout))) {
1747 interactive=TRUE;
1748 }
1749 if (interactive==TRUE) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001750 //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
Eric Andersen501c88b2000-07-28 15:14:45 +00001751 /* Looks like they want an interactive shell */
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001752 printf( "\n\nBusyBox v%s (%s) Built-in shell (lash)\n", BB_VER, BB_BT);
1753 printf( "Enter 'help' for a list of built-in commands.\n\n");
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001754 } else if (local_pending_command==NULL) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001755 //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
Matt Kraaibbaef662000-09-27 02:43:35 +00001756 input = xfopen(argv[optind], "r");
Eric Andersen8ea28be2001-01-05 20:58:22 +00001757 mark_open(fileno(input)); /* be lazy, never mark this closed */
Eric Andersen501c88b2000-07-28 15:14:45 +00001758 }
1759
Eric Andersen6efc48c2000-07-18 08:16:39 +00001760 /* initialize the cwd -- this is never freed...*/
1761 cwd=(char*)xmalloc(sizeof(char)*MAX_LINE+1);
1762 getcwd(cwd, sizeof(char)*MAX_LINE);
Erik Andersen3522eb12000-03-12 23:49:18 +00001763
Eric Andersenfad9c112000-07-25 18:06:52 +00001764#ifdef BB_FEATURE_CLEAN_UP
1765 atexit(free_memory);
1766#endif
1767
Erik Andersen161220c2000-03-16 08:12:48 +00001768 return (busy_loop(input));
Erik Andersen3522eb12000-03-12 23:49:18 +00001769}