blob: 077cb1182a102bf05d53d832b026a7457a10fbde [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 *
Eric Andersen8ec10a92001-01-27 09:33:39 +00005 * Copyright (C) 1999,2000,2001 by Lineo, inc.
Erik Andersen3522eb12000-03-12 23:49:18 +00006 * 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
Erik Andersen3522eb12000-03-12 23:49:18 +000052#include <stdio.h>
53#include <stdlib.h>
54#include <ctype.h>
55#include <errno.h>
56#include <fcntl.h>
57#include <glob.h>
58#include <signal.h>
59#include <string.h>
60#include <sys/ioctl.h>
61#include <sys/wait.h>
62#include <unistd.h>
Eric Andersen501c88b2000-07-28 15:14:45 +000063#include <getopt.h>
Eric Andersencaeeb362001-02-20 06:38:44 +000064#include "busybox.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"
70
Erik Andersend75af992000-03-16 08:09:09 +000071
Eric Andersen86349772000-12-18 20:25:50 +000072enum redir_type { REDIRECT_INPUT, REDIRECT_OVERWRITE,
Erik Andersen161220c2000-03-16 08:12:48 +000073 REDIRECT_APPEND
74};
Erik Andersen3522eb12000-03-12 23:49:18 +000075
Eric Andersen86349772000-12-18 20:25:50 +000076static const unsigned int DEFAULT_CONTEXT=0x1;
Eric Andersen6a99aaf2000-07-27 00:15:20 +000077static const unsigned int IF_TRUE_CONTEXT=0x2;
78static const unsigned int IF_FALSE_CONTEXT=0x4;
79static const unsigned int THEN_EXP_CONTEXT=0x8;
80static const unsigned int ELSE_EXP_CONTEXT=0x10;
Eric Andersenfad9c112000-07-25 18:06:52 +000081
Eric Andersen86349772000-12-18 20:25:50 +000082
83struct jobset {
Erik Andersen161220c2000-03-16 08:12:48 +000084 struct job *head; /* head of list of running jobs */
85 struct job *fg; /* current foreground job */
Erik Andersen3522eb12000-03-12 23:49:18 +000086};
87
Eric Andersen86349772000-12-18 20:25:50 +000088struct redir_struct {
89 enum redir_type type; /* type of redirection */
Erik Andersen161220c2000-03-16 08:12:48 +000090 int fd; /* file descriptor being redirected */
91 char *filename; /* file to redirect fd to */
Erik Andersen3522eb12000-03-12 23:49:18 +000092};
93
Eric Andersen86349772000-12-18 20:25:50 +000094struct child_prog {
Erik Andersen161220c2000-03-16 08:12:48 +000095 pid_t pid; /* 0 if exited */
96 char **argv; /* program name and arguments */
Eric Andersen86349772000-12-18 20:25:50 +000097 int num_redirects; /* elements in redirection array */
98 struct redir_struct *redirects; /* I/O redirects */
99 glob_t glob_result; /* result of parameter globbing */
100 int free_glob; /* should we globfree(&glob_result)? */
101 int is_stopped; /* is the program currently running? */
102 struct job *family; /* pointer back to the child's parent job */
Erik Andersen3522eb12000-03-12 23:49:18 +0000103};
104
105struct job {
Eric Andersen86349772000-12-18 20:25:50 +0000106 int jobid; /* job number */
107 int num_progs; /* total number of programs in job */
108 int running_progs; /* number of programs running */
Erik Andersen161220c2000-03-16 08:12:48 +0000109 char *text; /* name of job */
Eric Andersen86349772000-12-18 20:25:50 +0000110 char *cmdbuf; /* buffer various argv's point into */
Erik Andersen161220c2000-03-16 08:12:48 +0000111 pid_t pgrp; /* process group ID for the job */
Eric Andersen86349772000-12-18 20:25:50 +0000112 struct child_prog *progs; /* array of programs in job */
Erik Andersen161220c2000-03-16 08:12:48 +0000113 struct job *next; /* to track background commands */
Eric Andersen86349772000-12-18 20:25:50 +0000114 int stopped_progs; /* number of programs alive, but stopped */
115 unsigned int job_context; /* bitmask defining current context */
116 struct jobset *job_list;
Erik Andersen3522eb12000-03-12 23:49:18 +0000117};
118
Eric Andersen86349772000-12-18 20:25:50 +0000119struct built_in_command {
Erik Andersen161220c2000-03-16 08:12:48 +0000120 char *cmd; /* name */
121 char *descr; /* description */
Eric Andersen86349772000-12-18 20:25:50 +0000122 int (*function) (struct child_prog *); /* function ptr */
Erik Andersen3522eb12000-03-12 23:49:18 +0000123};
124
Eric Andersen8ea28be2001-01-05 20:58:22 +0000125struct close_me {
126 int fd;
127 struct close_me *next;
128};
129
Eric Andersen34e19412000-07-10 18:47:24 +0000130/* function prototypes for builtins */
Eric Andersen86349772000-12-18 20:25:50 +0000131static int builtin_cd(struct child_prog *cmd);
132static int builtin_env(struct child_prog *dummy);
133static int builtin_exec(struct child_prog *cmd);
134static int builtin_exit(struct child_prog *cmd);
135static int builtin_fg_bg(struct child_prog *cmd);
136static int builtin_help(struct child_prog *cmd);
137static int builtin_jobs(struct child_prog *dummy);
138static int builtin_pwd(struct child_prog *dummy);
139static int builtin_export(struct child_prog *cmd);
140static int builtin_source(struct child_prog *cmd);
141static int builtin_unset(struct child_prog *cmd);
142static int builtin_read(struct child_prog *cmd);
Eric Andersenfad9c112000-07-25 18:06:52 +0000143#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
Eric Andersen86349772000-12-18 20:25:50 +0000144static int builtin_if(struct child_prog *cmd);
145static int builtin_then(struct child_prog *cmd);
146static int builtin_else(struct child_prog *cmd);
147static int builtin_fi(struct child_prog *cmd);
Eric Andersen70da6a62000-12-20 22:59:16 +0000148/* function prototypes for shell stuff */
149static int run_command_predicate(char *cmd);
Eric Andersenfad9c112000-07-25 18:06:52 +0000150#endif
Erik Andersen3522eb12000-03-12 23:49:18 +0000151
Eric Andersen34e19412000-07-10 18:47:24 +0000152
153/* function prototypes for shell stuff */
Eric Andersen8ea28be2001-01-05 20:58:22 +0000154static void mark_open(int fd);
155static void mark_closed(int fd);
Eric Andersen86349772000-12-18 20:25:50 +0000156static void checkjobs(struct jobset *job_list);
157static int get_command(FILE * source, char *command);
158static int parse_command(char **command_ptr, struct job *job, int *inbg);
159static int run_command(struct job *newjob, int inbg, int outpipe[2]);
160static int pseudo_exec(struct child_prog *cmd) __attribute__ ((noreturn));
Erik Andersen3522eb12000-03-12 23:49:18 +0000161static int busy_loop(FILE * input);
162
Erik Andersend75af992000-03-16 08:09:09 +0000163
Mark Whitley37653aa2000-07-12 23:36:17 +0000164/* Table of built-in functions (these are non-forking builtins, meaning they
165 * can change global variables in the parent shell process but they will not
166 * work with pipes and redirects; 'unset foo | whatever' will not work) */
Eric Andersen86349772000-12-18 20:25:50 +0000167static struct built_in_command bltins[] = {
Eric Andersenfad9c112000-07-25 18:06:52 +0000168 {"bg", "Resume a job in the background", builtin_fg_bg},
169 {"cd", "Change working directory", builtin_cd},
Eric Andersend2f56772000-09-21 02:48:07 +0000170 {"exec", "Exec command, replacing this shell with the exec'd process", builtin_exec},
Eric Andersenfad9c112000-07-25 18:06:52 +0000171 {"exit", "Exit from shell()", builtin_exit},
172 {"fg", "Bring job into the foreground", builtin_fg_bg},
173 {"jobs", "Lists the active jobs", builtin_jobs},
174 {"export", "Set environment variable", builtin_export},
175 {"unset", "Unset environment variable", builtin_unset},
176 {"read", "Input environment variable", builtin_read},
Matt Kraaidd450a02000-09-13 03:43:36 +0000177 {".", "Source-in and run commands in a file", builtin_source},
Eric Andersen86349772000-12-18 20:25:50 +0000178 /* to do: add ulimit */
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000179#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
180 {"if", NULL, builtin_if},
181 {"then", NULL, builtin_then},
182 {"else", NULL, builtin_else},
183 {"fi", NULL, builtin_fi},
184#endif
Eric Andersenfad9c112000-07-25 18:06:52 +0000185 {NULL, NULL, NULL}
Erik Andersen330fd2b2000-05-19 05:35:19 +0000186};
187
Mark Whitley37653aa2000-07-12 23:36:17 +0000188/* Table of forking built-in functions (things that fork cannot change global
189 * variables in the parent process, such as the current working directory) */
Eric Andersen86349772000-12-18 20:25:50 +0000190static struct built_in_command bltins_forking[] = {
Eric Andersenfad9c112000-07-25 18:06:52 +0000191 {"env", "Print all environment variables", builtin_env},
192 {"pwd", "Print current directory", builtin_pwd},
Eric Andersenfad9c112000-07-25 18:06:52 +0000193 {"help", "List shell built-in commands", builtin_help},
194 {NULL, NULL, NULL}
Erik Andersen3522eb12000-03-12 23:49:18 +0000195};
196
Eric Andersen0bcc8132001-01-05 19:37:32 +0000197
198/* Variables we export */
199unsigned int shell_context; /* Used in cmdedit.c to reset the
200 context when someone hits ^C */
201
202
203/* Globals that are static to this file */
Eric Andersen6efc48c2000-07-18 08:16:39 +0000204static char *cwd;
Eric Andersen744b0642001-01-05 21:23:44 +0000205static char *local_pending_command = NULL;
Eric Andersen86349772000-12-18 20:25:50 +0000206static struct jobset job_list = { NULL, NULL };
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000207static int argc;
208static char **argv;
Eric Andersen8ea28be2001-01-05 20:58:22 +0000209static struct close_me *close_me_head = NULL;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000210#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen86349772000-12-18 20:25:50 +0000211static int last_bg_pid=-1;
212static int last_return_code=-1;
213static int show_x_trace=FALSE;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000214#endif
Eric Andersen86349772000-12-18 20:25:50 +0000215#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
216static char syntax_err[]="syntax error near unexpected token";
217#endif
218
Eric Andersenb558e762000-11-30 22:43:16 +0000219#ifdef DEBUG_SHELL
220static inline void debug_printf(const char *format, ...)
221{
222 va_list args;
223 va_start(args, format);
Eric Andersen86349772000-12-18 20:25:50 +0000224 vfprintf(stderr, format, args);
Eric Andersenb558e762000-11-30 22:43:16 +0000225 va_end(args);
226}
227#else
228static inline void debug_printf(const char *format, ...) { }
229#endif
Erik Andersen3522eb12000-03-12 23:49:18 +0000230
Eric Andersen86349772000-12-18 20:25:50 +0000231/*
232 Most builtins need access to the struct child_prog that has
233 their arguments, previously coded as cmd->progs[0]. That coding
234 can exhibit a bug, if the builtin is not the first command in
235 a pipeline: "echo foo | exec sort" will attempt to exec foo.
236
237builtin previous use notes
238------ ----------------- ---------
239cd cmd->progs[0]
240env 0
241exec cmd->progs[0] squashed bug: didn't look for applets or forking builtins
242exit cmd->progs[0]
243fg_bg cmd->progs[0], job_list->head, job_list->fg
244help 0
245jobs job_list->head
246pwd 0
247export cmd->progs[0] passes cmd, job_list to builtin_env(), which ignores them
248source cmd->progs[0]
249unset cmd->progs[0]
250read cmd->progs[0]
251if cmd->job_context, cmd->text
252then cmd->job_context, cmd->text
253else cmd->job_context, cmd->text
254fi cmd->job_context
255
256The use of cmd->text by if/then/else/fi is hopelessly hacky.
257Would it work to increment cmd->progs[0]->argv and recurse,
258somewhat like builtin_exec does?
259
260I added "struct job *family;" to struct child_prog,
261and switched API to builtin_foo(struct child_prog *child);
262So cmd->text becomes child->family->text
263 cmd->job_context becomes child->family->job_context
264 cmd->progs[0] becomes *child
265 job_list becomes child->family->job_list
266 */
Erik Andersen3522eb12000-03-12 23:49:18 +0000267
Erik Andersend75af992000-03-16 08:09:09 +0000268/* built-in 'cd <path>' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000269static int builtin_cd(struct child_prog *child)
Erik Andersend75af992000-03-16 08:09:09 +0000270{
Erik Andersen161220c2000-03-16 08:12:48 +0000271 char *newdir;
Erik Andersend75af992000-03-16 08:09:09 +0000272
Eric Andersen86349772000-12-18 20:25:50 +0000273 if (child->argv[1] == NULL)
Erik Andersen161220c2000-03-16 08:12:48 +0000274 newdir = getenv("HOME");
275 else
Eric Andersen86349772000-12-18 20:25:50 +0000276 newdir = child->argv[1];
Erik Andersen161220c2000-03-16 08:12:48 +0000277 if (chdir(newdir)) {
278 printf("cd: %s: %s\n", newdir, strerror(errno));
Matt Kraai3e856ce2000-12-01 02:55:13 +0000279 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000280 }
Eric Andersen6efc48c2000-07-18 08:16:39 +0000281 getcwd(cwd, sizeof(char)*MAX_LINE);
Erik Andersen161220c2000-03-16 08:12:48 +0000282
Matt Kraai3e856ce2000-12-01 02:55:13 +0000283 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000284}
285
286/* built-in 'env' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000287static int builtin_env(struct child_prog *dummy)
Erik Andersen3522eb12000-03-12 23:49:18 +0000288{
Erik Andersen161220c2000-03-16 08:12:48 +0000289 char **e;
Erik Andersen3522eb12000-03-12 23:49:18 +0000290
Erik Andersen161220c2000-03-16 08:12:48 +0000291 for (e = environ; *e; e++) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +0000292 printf( "%s\n", *e);
Erik Andersen161220c2000-03-16 08:12:48 +0000293 }
294 return (0);
Erik Andersen3522eb12000-03-12 23:49:18 +0000295}
296
Eric Andersend2f56772000-09-21 02:48:07 +0000297/* built-in 'exec' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000298static int builtin_exec(struct child_prog *child)
Eric Andersend2f56772000-09-21 02:48:07 +0000299{
Eric Andersen86349772000-12-18 20:25:50 +0000300 if (child->argv[1] == NULL)
301 return EXIT_SUCCESS; /* Really? */
302 child->argv++;
303 pseudo_exec(child);
304 /* never returns */
Eric Andersend2f56772000-09-21 02:48:07 +0000305}
306
Erik Andersen3522eb12000-03-12 23:49:18 +0000307/* built-in 'exit' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000308static int builtin_exit(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000309{
Eric Andersen86349772000-12-18 20:25:50 +0000310 if (child->argv[1] == NULL)
Matt Kraai3e856ce2000-12-01 02:55:13 +0000311 exit(EXIT_SUCCESS);
Erik Andersen161220c2000-03-16 08:12:48 +0000312
Eric Andersen86349772000-12-18 20:25:50 +0000313 exit (atoi(child->argv[1]));
Erik Andersen3522eb12000-03-12 23:49:18 +0000314}
315
316/* built-in 'fg' and 'bg' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000317static int builtin_fg_bg(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000318{
Erik Andersen161220c2000-03-16 08:12:48 +0000319 int i, jobNum;
Erik Andersen6273f652000-03-17 01:12:41 +0000320 struct job *job=NULL;
Eric Andersen86349772000-12-18 20:25:50 +0000321
Eric Andersene9f07fb2000-12-21 18:31:36 +0000322 if (!child->argv[1] || child->argv[2]) {
Matt Kraaidd19c692001-01-31 19:00:21 +0000323 error_msg("%s: exactly one argument is expected",
Eric Andersene9f07fb2000-12-21 18:31:36 +0000324 child->argv[0]);
325 return EXIT_FAILURE;
326 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000327
Eric Andersene9f07fb2000-12-21 18:31:36 +0000328 if (sscanf(child->argv[1], "%%%d", &jobNum) != 1) {
Matt Kraaidd19c692001-01-31 19:00:21 +0000329 error_msg("%s: bad argument '%s'",
Eric Andersene9f07fb2000-12-21 18:31:36 +0000330 child->argv[0], child->argv[1]);
331 return EXIT_FAILURE;
332 }
333
334 for (job = child->family->job_list->head; job; job = job->next) {
335 if (job->jobid == jobNum) {
336 break;
Erik Andersen161220c2000-03-16 08:12:48 +0000337 }
Eric Andersene9f07fb2000-12-21 18:31:36 +0000338 }
Erik Andersen161220c2000-03-16 08:12:48 +0000339
340 if (!job) {
Matt Kraaidd19c692001-01-31 19:00:21 +0000341 error_msg("%s: unknown job %d",
Eric Andersen86349772000-12-18 20:25:50 +0000342 child->argv[0], jobNum);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000343 return EXIT_FAILURE;
Erik Andersend75af992000-03-16 08:09:09 +0000344 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000345
Eric Andersen86349772000-12-18 20:25:50 +0000346 if (*child->argv[0] == 'f') {
Erik Andersen161220c2000-03-16 08:12:48 +0000347 /* Make this job the foreground job */
Eric Andersen1c314ad2000-06-28 16:56:25 +0000348 /* suppress messages when run from /linuxrc mag@sysgo.de */
349 if (tcsetpgrp(0, job->pgrp) && errno != ENOTTY)
Matt Kraaia9819b22000-12-22 01:48:07 +0000350 perror_msg("tcsetpgrp");
Eric Andersen86349772000-12-18 20:25:50 +0000351 child->family->job_list->fg = job;
Erik Andersen161220c2000-03-16 08:12:48 +0000352 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000353
Erik Andersen161220c2000-03-16 08:12:48 +0000354 /* Restart the processes in the job */
Eric Andersen86349772000-12-18 20:25:50 +0000355 for (i = 0; i < job->num_progs; i++)
356 job->progs[i].is_stopped = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000357
Erik Andersen161220c2000-03-16 08:12:48 +0000358 kill(-job->pgrp, SIGCONT);
Erik Andersen3522eb12000-03-12 23:49:18 +0000359
Eric Andersen86349772000-12-18 20:25:50 +0000360 job->stopped_progs = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000361
Matt Kraai3e856ce2000-12-01 02:55:13 +0000362 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000363}
364
365/* built-in 'help' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000366static int builtin_help(struct child_prog *dummy)
Erik Andersen3522eb12000-03-12 23:49:18 +0000367{
Eric Andersen86349772000-12-18 20:25:50 +0000368 struct built_in_command *x;
Erik Andersen3522eb12000-03-12 23:49:18 +0000369
Eric Andersen86349772000-12-18 20:25:50 +0000370 printf("\nBuilt-in commands:\n");
371 printf("-------------------\n");
Erik Andersen161220c2000-03-16 08:12:48 +0000372 for (x = bltins; x->cmd; x++) {
Eric Andersenfad9c112000-07-25 18:06:52 +0000373 if (x->descr==NULL)
374 continue;
Eric Andersen86349772000-12-18 20:25:50 +0000375 printf("%s\t%s\n", x->cmd, x->descr);
Erik Andersen161220c2000-03-16 08:12:48 +0000376 }
Erik Andersen330fd2b2000-05-19 05:35:19 +0000377 for (x = bltins_forking; x->cmd; x++) {
Eric Andersenfad9c112000-07-25 18:06:52 +0000378 if (x->descr==NULL)
379 continue;
Eric Andersen86349772000-12-18 20:25:50 +0000380 printf("%s\t%s\n", x->cmd, x->descr);
Erik Andersen330fd2b2000-05-19 05:35:19 +0000381 }
Eric Andersen86349772000-12-18 20:25:50 +0000382 printf("\n\n");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000383 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000384}
385
386/* built-in 'jobs' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000387static int builtin_jobs(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000388{
Erik Andersen161220c2000-03-16 08:12:48 +0000389 struct job *job;
Eric Andersen86349772000-12-18 20:25:50 +0000390 char *status_string;
Erik Andersen3522eb12000-03-12 23:49:18 +0000391
Eric Andersen86349772000-12-18 20:25:50 +0000392 for (job = child->family->job_list->head; job; job = job->next) {
393 if (job->running_progs == job->stopped_progs)
394 status_string = "Stopped";
Erik Andersen161220c2000-03-16 08:12:48 +0000395 else
Eric Andersen86349772000-12-18 20:25:50 +0000396 status_string = "Running";
Erik Andersen161220c2000-03-16 08:12:48 +0000397
Eric Andersen86349772000-12-18 20:25:50 +0000398 printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text);
Erik Andersen161220c2000-03-16 08:12:48 +0000399 }
Matt Kraai3e856ce2000-12-01 02:55:13 +0000400 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000401}
402
403
404/* built-in 'pwd' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000405static int builtin_pwd(struct child_prog *dummy)
Erik Andersen3522eb12000-03-12 23:49:18 +0000406{
Eric Andersen86349772000-12-18 20:25:50 +0000407 getcwd(cwd, MAX_LINE);
Eric Andersen6f65a3a2001-01-20 01:10:07 +0000408 printf( "%s\n", cwd);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000409 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000410}
411
Erik Andersen6273f652000-03-17 01:12:41 +0000412/* built-in 'export VAR=value' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000413static int builtin_export(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000414{
Erik Andersen161220c2000-03-16 08:12:48 +0000415 int res;
Erik Andersen3522eb12000-03-12 23:49:18 +0000416
Eric Andersen86349772000-12-18 20:25:50 +0000417 if (child->argv[1] == NULL) {
418 return (builtin_env(child));
Erik Andersen161220c2000-03-16 08:12:48 +0000419 }
Eric Andersen86349772000-12-18 20:25:50 +0000420 res = putenv(child->argv[1]);
Erik Andersen161220c2000-03-16 08:12:48 +0000421 if (res)
Eric Andersen86349772000-12-18 20:25:50 +0000422 fprintf(stderr, "export: %s\n", strerror(errno));
Erik Andersen161220c2000-03-16 08:12:48 +0000423 return (res);
Erik Andersen3522eb12000-03-12 23:49:18 +0000424}
425
Eric Andersenb54833c2000-07-03 23:56:26 +0000426/* built-in 'read VAR' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000427static int builtin_read(struct child_prog *child)
Eric Andersenb54833c2000-07-03 23:56:26 +0000428{
429 int res = 0, len, newlen;
430 char *s;
431 char string[MAX_READ];
432
Eric Andersen86349772000-12-18 20:25:50 +0000433 if (child->argv[1]) {
Eric Andersenb54833c2000-07-03 23:56:26 +0000434 /* argument (VAR) given: put "VAR=" into buffer */
Eric Andersen86349772000-12-18 20:25:50 +0000435 strcpy(string, child->argv[1]);
Eric Andersenb54833c2000-07-03 23:56:26 +0000436 len = strlen(string);
437 string[len++] = '=';
438 string[len] = '\0';
439 fgets(&string[len], sizeof(string) - len, stdin); /* read string */
440 newlen = strlen(string);
441 if(newlen > len)
442 string[--newlen] = '\0'; /* chomp trailing newline */
443 /*
444 ** string should now contain "VAR=<value>"
445 ** copy it (putenv() won't do that, so we must make sure
446 ** the string resides in a static buffer!)
447 */
448 res = -1;
449 if((s = strdup(string)))
450 res = putenv(s);
451 if (res)
Eric Andersen86349772000-12-18 20:25:50 +0000452 fprintf(stderr, "read: %s\n", strerror(errno));
Eric Andersenb54833c2000-07-03 23:56:26 +0000453 }
454 else
455 fgets(string, sizeof(string), stdin);
456
457 return (res);
458}
459
Eric Andersenfad9c112000-07-25 18:06:52 +0000460#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
461/* Built-in handler for 'if' commands */
Eric Andersen86349772000-12-18 20:25:50 +0000462static int builtin_if(struct child_prog *child)
Eric Andersenfad9c112000-07-25 18:06:52 +0000463{
Eric Andersen86349772000-12-18 20:25:50 +0000464 struct job *cmd = child->family;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000465 int status;
466 char* charptr1=cmd->text+3; /* skip over the leading 'if ' */
467
468 /* Now run the 'if' command */
Eric Andersen86349772000-12-18 20:25:50 +0000469 debug_printf( "job=%p entering builtin_if ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
470 status = run_command_predicate(charptr1);
471 debug_printf( "if test returned ");
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000472 if (status == 0) {
Eric Andersen86349772000-12-18 20:25:50 +0000473 debug_printf( "TRUE\n");
474 cmd->job_context |= IF_TRUE_CONTEXT;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000475 } else {
Eric Andersen86349772000-12-18 20:25:50 +0000476 debug_printf( "FALSE\n");
477 cmd->job_context |= IF_FALSE_CONTEXT;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000478 }
Eric Andersen86349772000-12-18 20:25:50 +0000479 debug_printf("job=%p builtin_if set job context to %x\n", cmd, cmd->job_context);
480 shell_context++;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000481
482 return status;
Eric Andersenfad9c112000-07-25 18:06:52 +0000483}
484
485/* Built-in handler for 'then' (part of the 'if' command) */
Eric Andersen86349772000-12-18 20:25:50 +0000486static int builtin_then(struct child_prog *child)
Eric Andersenfad9c112000-07-25 18:06:52 +0000487{
Eric Andersen86349772000-12-18 20:25:50 +0000488 struct job *cmd = child->family;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000489 char* charptr1=cmd->text+5; /* skip over the leading 'then ' */
490
Eric Andersen86349772000-12-18 20:25:50 +0000491 debug_printf( "job=%p entering builtin_then ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
492 if (! (cmd->job_context & (IF_TRUE_CONTEXT|IF_FALSE_CONTEXT))) {
493 shell_context = 0; /* Reset the shell's context on an error */
Matt Kraaidd19c692001-01-31 19:00:21 +0000494 error_msg("%s `then'", syntax_err);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000495 return EXIT_FAILURE;
Eric Andersenfad9c112000-07-25 18:06:52 +0000496 }
Eric Andersen86349772000-12-18 20:25:50 +0000497
498 cmd->job_context |= THEN_EXP_CONTEXT;
499 debug_printf("job=%p builtin_then set job context to %x\n", cmd, cmd->job_context);
500
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000501 /* If the if result was FALSE, skip the 'then' stuff */
Eric Andersen86349772000-12-18 20:25:50 +0000502 if (cmd->job_context & IF_FALSE_CONTEXT) {
Matt Kraai3e856ce2000-12-01 02:55:13 +0000503 return EXIT_SUCCESS;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000504 }
505
Eric Andersen86349772000-12-18 20:25:50 +0000506 /* Seems the if result was TRUE, so run the 'then' command */
507 debug_printf( "'then' now running '%s'\n", charptr1);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000508
Eric Andersen86349772000-12-18 20:25:50 +0000509 return(run_command_predicate(charptr1));
Eric Andersenfad9c112000-07-25 18:06:52 +0000510}
511
512/* Built-in handler for 'else' (part of the 'if' command) */
Eric Andersen86349772000-12-18 20:25:50 +0000513static int builtin_else(struct child_prog *child)
Eric Andersenfad9c112000-07-25 18:06:52 +0000514{
Eric Andersen86349772000-12-18 20:25:50 +0000515 struct job *cmd = child->family;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000516 char* charptr1=cmd->text+5; /* skip over the leading 'else ' */
517
Eric Andersen86349772000-12-18 20:25:50 +0000518 debug_printf( "job=%p entering builtin_else ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
519
520 if (! (cmd->job_context & THEN_EXP_CONTEXT)) {
521 shell_context = 0; /* Reset the shell's context on an error */
Matt Kraaidd19c692001-01-31 19:00:21 +0000522 error_msg("%s `else'", syntax_err);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000523 return EXIT_FAILURE;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000524 }
525 /* If the if result was TRUE, skip the 'else' stuff */
Eric Andersen86349772000-12-18 20:25:50 +0000526 if (cmd->job_context & IF_TRUE_CONTEXT) {
Matt Kraai3e856ce2000-12-01 02:55:13 +0000527 return EXIT_SUCCESS;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000528 }
529
Eric Andersen86349772000-12-18 20:25:50 +0000530 cmd->job_context |= ELSE_EXP_CONTEXT;
Eric Andersene9f07fb2000-12-21 18:31:36 +0000531 debug_printf("job=%p builtin_else set job context to %x\n", cmd, cmd->job_context);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000532
533 /* Now run the 'else' command */
Eric Andersen86349772000-12-18 20:25:50 +0000534 debug_printf( "'else' now running '%s'\n", charptr1);
535 return(run_command_predicate(charptr1));
Eric Andersenfad9c112000-07-25 18:06:52 +0000536}
537
538/* Built-in handler for 'fi' (part of the 'if' command) */
Eric Andersen86349772000-12-18 20:25:50 +0000539static int builtin_fi(struct child_prog *child)
Eric Andersenfad9c112000-07-25 18:06:52 +0000540{
Eric Andersen86349772000-12-18 20:25:50 +0000541 struct job *cmd = child->family;
542 debug_printf( "job=%p entering builtin_fi ('%s')-- context=%d\n", cmd, "", cmd->job_context);
543 if (! (cmd->job_context & (IF_TRUE_CONTEXT|IF_FALSE_CONTEXT))) {
544 shell_context = 0; /* Reset the shell's context on an error */
Matt Kraaidd19c692001-01-31 19:00:21 +0000545 error_msg("%s `fi'", syntax_err);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000546 return EXIT_FAILURE;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000547 }
548 /* Clear out the if and then context bits */
Eric Andersen86349772000-12-18 20:25:50 +0000549 cmd->job_context &= ~(IF_TRUE_CONTEXT|IF_FALSE_CONTEXT|THEN_EXP_CONTEXT|ELSE_EXP_CONTEXT);
550 debug_printf("job=%p builtin_fi set job context to %x\n", cmd, cmd->job_context);
551 shell_context--;
Matt Kraai3e856ce2000-12-01 02:55:13 +0000552 return EXIT_SUCCESS;
Eric Andersenfad9c112000-07-25 18:06:52 +0000553}
554#endif
555
Erik Andersen3522eb12000-03-12 23:49:18 +0000556/* Built-in '.' handler (read-in and execute commands from file) */
Eric Andersen86349772000-12-18 20:25:50 +0000557static int builtin_source(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000558{
Erik Andersen161220c2000-03-16 08:12:48 +0000559 FILE *input;
560 int status;
Eric Andersen8ea28be2001-01-05 20:58:22 +0000561 int fd;
Erik Andersen3522eb12000-03-12 23:49:18 +0000562
Eric Andersen86349772000-12-18 20:25:50 +0000563 if (child->argv[1] == NULL)
Matt Kraai3e856ce2000-12-01 02:55:13 +0000564 return EXIT_FAILURE;
Erik Andersen3522eb12000-03-12 23:49:18 +0000565
Eric Andersen86349772000-12-18 20:25:50 +0000566 input = fopen(child->argv[1], "r");
Erik Andersen161220c2000-03-16 08:12:48 +0000567 if (!input) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +0000568 printf( "Couldn't open file '%s'\n", child->argv[1]);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000569 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000570 }
Erik Andersend75af992000-03-16 08:09:09 +0000571
Eric Andersen8ea28be2001-01-05 20:58:22 +0000572 fd=fileno(input);
573 mark_open(fd);
Erik Andersen161220c2000-03-16 08:12:48 +0000574 /* Now run the file */
575 status = busy_loop(input);
Matt Kraaidd450a02000-09-13 03:43:36 +0000576 fclose(input);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000577 mark_closed(fd);
Erik Andersen161220c2000-03-16 08:12:48 +0000578 return (status);
Erik Andersen3522eb12000-03-12 23:49:18 +0000579}
580
581/* built-in 'unset VAR' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000582static int builtin_unset(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000583{
Eric Andersen86349772000-12-18 20:25:50 +0000584 if (child->argv[1] == NULL) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +0000585 printf( "unset: parameter required.\n");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000586 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000587 }
Eric Andersen86349772000-12-18 20:25:50 +0000588 unsetenv(child->argv[1]);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000589 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000590}
591
Eric Andersen70da6a62000-12-20 22:59:16 +0000592#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
Eric Andersen86349772000-12-18 20:25:50 +0000593/* currently used by if/then/else.
Eric Andersene9f07fb2000-12-21 18:31:36 +0000594 *
595 * Reparsing the command line for this purpose is gross,
596 * incorrect, and fundamentally unfixable; in particular,
597 * think about what happens with command substitution.
598 * We really need to pull out the run, wait, return status
599 * functionality out of busy_loop so we can child->argv++
600 * and use that, without going back through parse_command.
Eric Andersen86349772000-12-18 20:25:50 +0000601 */
602static int run_command_predicate(char *cmd)
603{
604 int n=strlen(cmd);
605 local_pending_command = xmalloc(n+1);
606 strncpy(local_pending_command, cmd, n);
607 local_pending_command[n]='\0';
608 return( busy_loop(NULL));
609}
Eric Andersen70da6a62000-12-20 22:59:16 +0000610#endif
Eric Andersen86349772000-12-18 20:25:50 +0000611
Eric Andersen8ea28be2001-01-05 20:58:22 +0000612static void mark_open(int fd)
613{
614 struct close_me *new = xmalloc(sizeof(struct close_me));
615 new->fd = fd;
616 new->next = close_me_head;
617 close_me_head = new;
618}
619
620static void mark_closed(int fd)
621{
622 struct close_me *tmp;
623 if (close_me_head == NULL || close_me_head->fd != fd)
624 error_msg_and_die("corrupt close_me");
625 tmp = close_me_head;
626 close_me_head = close_me_head->next;
627 free(tmp);
628}
629
630static void close_all()
631{
632 struct close_me *c;
633 for (c=close_me_head; c; c=c->next) {
634 close(c->fd);
635 }
636 close_me_head = NULL;
637}
638
639
Erik Andersen3522eb12000-03-12 23:49:18 +0000640/* free up all memory from a job */
Eric Andersen86349772000-12-18 20:25:50 +0000641static void free_job(struct job *cmd)
Erik Andersen3522eb12000-03-12 23:49:18 +0000642{
Erik Andersen161220c2000-03-16 08:12:48 +0000643 int i;
Erik Andersen3522eb12000-03-12 23:49:18 +0000644
Eric Andersen86349772000-12-18 20:25:50 +0000645 for (i = 0; i < cmd->num_progs; i++) {
Erik Andersen161220c2000-03-16 08:12:48 +0000646 free(cmd->progs[i].argv);
Eric Andersen86349772000-12-18 20:25:50 +0000647 if (cmd->progs[i].redirects)
648 free(cmd->progs[i].redirects);
649 if (cmd->progs[i].free_glob)
650 globfree(&cmd->progs[i].glob_result);
Erik Andersen161220c2000-03-16 08:12:48 +0000651 }
652 free(cmd->progs);
653 if (cmd->text)
654 free(cmd->text);
Eric Andersen86349772000-12-18 20:25:50 +0000655 free(cmd->cmdbuf);
Eric Andersenec10b9d2000-07-14 01:13:11 +0000656 memset(cmd, 0, sizeof(struct job));
Erik Andersen3522eb12000-03-12 23:49:18 +0000657}
658
Eric Andersen86349772000-12-18 20:25:50 +0000659/* remove a job from the job_list */
660static void remove_job(struct jobset *job_list, struct job *job)
Erik Andersen3522eb12000-03-12 23:49:18 +0000661{
Eric Andersen86349772000-12-18 20:25:50 +0000662 struct job *prevjob;
Erik Andersen3522eb12000-03-12 23:49:18 +0000663
Eric Andersen86349772000-12-18 20:25:50 +0000664 free_job(job);
665 if (job == job_list->head) {
666 job_list->head = job->next;
Erik Andersen161220c2000-03-16 08:12:48 +0000667 } else {
Eric Andersen86349772000-12-18 20:25:50 +0000668 prevjob = job_list->head;
669 while (prevjob->next != job)
670 prevjob = prevjob->next;
671 prevjob->next = job->next;
Erik Andersen161220c2000-03-16 08:12:48 +0000672 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000673
Erik Andersen161220c2000-03-16 08:12:48 +0000674 free(job);
Erik Andersen3522eb12000-03-12 23:49:18 +0000675}
676
677/* Checks to see if any background processes have exited -- if they
678 have, figure out why and see if a job has completed */
Eric Andersen86349772000-12-18 20:25:50 +0000679static void checkjobs(struct jobset *job_list)
Erik Andersen3522eb12000-03-12 23:49:18 +0000680{
Erik Andersen161220c2000-03-16 08:12:48 +0000681 struct job *job;
682 pid_t childpid;
683 int status;
Eric Andersen86349772000-12-18 20:25:50 +0000684 int prognum = 0;
Erik Andersend75af992000-03-16 08:09:09 +0000685
Erik Andersen161220c2000-03-16 08:12:48 +0000686 while ((childpid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
Eric Andersen86349772000-12-18 20:25:50 +0000687 for (job = job_list->head; job; job = job->next) {
688 prognum = 0;
689 while (prognum < job->num_progs &&
690 job->progs[prognum].pid != childpid) prognum++;
691 if (prognum < job->num_progs)
Erik Andersen161220c2000-03-16 08:12:48 +0000692 break;
693 }
694
Eric Andersena1d187a2000-07-17 19:14:41 +0000695 /* This happens on backticked commands */
696 if(job==NULL)
697 return;
698
Erik Andersen161220c2000-03-16 08:12:48 +0000699 if (WIFEXITED(status) || WIFSIGNALED(status)) {
700 /* child exited */
Eric Andersen86349772000-12-18 20:25:50 +0000701 job->running_progs--;
702 job->progs[prognum].pid = 0;
Erik Andersen161220c2000-03-16 08:12:48 +0000703
Eric Andersen86349772000-12-18 20:25:50 +0000704 if (!job->running_progs) {
705 printf(JOB_STATUS_FORMAT, job->jobid, "Done", job->text);
706 remove_job(job_list, job);
Erik Andersen161220c2000-03-16 08:12:48 +0000707 }
708 } else {
709 /* child stopped */
Eric Andersen86349772000-12-18 20:25:50 +0000710 job->stopped_progs++;
711 job->progs[prognum].is_stopped = 1;
Erik Andersen161220c2000-03-16 08:12:48 +0000712
Eric Andersen86349772000-12-18 20:25:50 +0000713 if (job->stopped_progs == job->num_progs) {
714 printf(JOB_STATUS_FORMAT, job->jobid, "Stopped",
Erik Andersen161220c2000-03-16 08:12:48 +0000715 job->text);
716 }
717 }
Erik Andersend75af992000-03-16 08:09:09 +0000718 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000719
Erik Andersen161220c2000-03-16 08:12:48 +0000720 if (childpid == -1 && errno != ECHILD)
Matt Kraaia9819b22000-12-22 01:48:07 +0000721 perror_msg("waitpid");
Erik Andersen3522eb12000-03-12 23:49:18 +0000722}
723
Eric Andersene9f07fb2000-12-21 18:31:36 +0000724/* squirrel != NULL means we squirrel away copies of stdin, stdout,
725 * and stderr if they are redirected. */
726static int setup_redirects(struct child_prog *prog, int squirrel[])
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000727{
728 int i;
729 int openfd;
730 int mode = O_RDONLY;
Eric Andersen86349772000-12-18 20:25:50 +0000731 struct redir_struct *redir = prog->redirects;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000732
Eric Andersen86349772000-12-18 20:25:50 +0000733 for (i = 0; i < prog->num_redirects; i++, redir++) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000734 switch (redir->type) {
735 case REDIRECT_INPUT:
736 mode = O_RDONLY;
737 break;
738 case REDIRECT_OVERWRITE:
Eric Andersen46f0beb2000-11-14 21:59:22 +0000739 mode = O_WRONLY | O_CREAT | O_TRUNC;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000740 break;
741 case REDIRECT_APPEND:
Eric Andersen46f0beb2000-11-14 21:59:22 +0000742 mode = O_WRONLY | O_CREAT | O_APPEND;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000743 break;
744 }
745
746 openfd = open(redir->filename, mode, 0666);
747 if (openfd < 0) {
748 /* this could get lost if stderr has been redirected, but
749 bash and ash both lose it as well (though zsh doesn't!) */
Matt Kraaidd19c692001-01-31 19:00:21 +0000750 error_msg("error opening %s: %s", redir->filename,
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000751 strerror(errno));
752 return 1;
753 }
754
755 if (openfd != redir->fd) {
Eric Andersene9f07fb2000-12-21 18:31:36 +0000756 if (squirrel && redir->fd < 3) {
757 squirrel[redir->fd] = dup(redir->fd);
758 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000759 dup2(openfd, redir->fd);
760 close(openfd);
761 }
762 }
763
764 return 0;
765}
766
Eric Andersene9f07fb2000-12-21 18:31:36 +0000767static void restore_redirects(int squirrel[])
768{
769 int i, fd;
770 for (i=0; i<3; i++) {
771 fd = squirrel[i];
772 if (fd != -1) {
773 /* No error checking. I sure wouldn't know what
774 * to do with an error if I found one! */
775 dup2(fd, i);
776 close(fd);
777 }
778 }
779}
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000780
Eric Andersen22332fd2001-01-30 23:40:39 +0000781#if defined(BB_FEATURE_SH_SIMPLE_PROMPT)
782static char* setup_prompt_string(int state)
783{
784 char prompt_str[BUFSIZ];
785
786 /* Set up the prompt */
787 if (state == 0) {
788 /* simple prompt */
789 sprintf(prompt_str, "%s %s", cwd, ( geteuid() != 0 ) ? "$ ":"# ");
790 } else {
791 strcpy(prompt_str,"> ");
792 }
793
794 return(strdup(prompt_str)); /* Must free this memory */
795}
796
797#else
798
Eric Andersen09acc062001-01-04 11:10:38 +0000799static char* setup_prompt_string(int state)
Erik Andersen3522eb12000-03-12 23:49:18 +0000800{
Eric Andersenf361ac22000-12-12 23:45:36 +0000801 char user[9],buf[255],*s;
Eric Andersen09acc062001-01-04 11:10:38 +0000802 char prompt[3];
803 char prompt_str[BUFSIZ];
804
805 /* Set up the prompt */
806 if (state == 0) {
807 /* get User Name and setup prompt */
808 strcpy(prompt,( geteuid() != 0 ) ? "$ ":"# ");
809 my_getpwuid(user, geteuid());
810
811 /* get HostName */
812 gethostname(buf, 255);
813 s = strchr(buf, '.');
814 if (s) {
815 *s = 0;
816 }
817 } else {
818 strcpy(prompt,"> ");
819 }
820
821 if (state == 0) {
822 snprintf(prompt_str, BUFSIZ-1, "[%s@%s %s]%s", user, buf,
823 get_last_path_component(cwd), prompt);
824 } else {
825 sprintf(prompt_str, "%s", prompt);
826 }
827 return(strdup(prompt_str)); /* Must free this memory */
828}
829
Eric Andersen22332fd2001-01-30 23:40:39 +0000830#endif
831
Eric Andersen09acc062001-01-04 11:10:38 +0000832static int get_command(FILE * source, char *command)
833{
834 char *prompt_str;
Eric Andersen8ea28be2001-01-05 20:58:22 +0000835
Eric Andersen1c314ad2000-06-28 16:56:25 +0000836 if (source == NULL) {
837 if (local_pending_command) {
838 /* a command specified (-c option): return it & mark it done */
839 strcpy(command, local_pending_command);
840 free(local_pending_command);
841 local_pending_command = NULL;
842 return 0;
843 }
844 return 1;
845 }
846
Erik Andersen161220c2000-03-16 08:12:48 +0000847 if (source == stdin) {
Matt Kraaidefcd5e2001-01-05 02:53:11 +0000848 prompt_str = setup_prompt_string(shell_context);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000849
Erik Andersend75af992000-03-16 08:09:09 +0000850#ifdef BB_FEATURE_SH_COMMAND_EDITING
Eric Andersen501c88b2000-07-28 15:14:45 +0000851 /*
852 ** enable command line editing only while a command line
853 ** is actually being read; otherwise, we'll end up bequeathing
854 ** atexit() handlers and other unwanted stuff to our
855 ** child processes (rob@sysgo.de)
856 */
Eric Andersen86349772000-12-18 20:25:50 +0000857 cmdedit_read_input(prompt_str, command);
Eric Andersen501c88b2000-07-28 15:14:45 +0000858 cmdedit_terminate();
Eric Andersen6faae7d2001-02-16 20:09:17 +0000859 free(prompt_str);
Erik Andersen161220c2000-03-16 08:12:48 +0000860 return 0;
Erik Andersenc7c634b2000-03-19 05:28:55 +0000861#else
Eric Andersen8ea28be2001-01-05 20:58:22 +0000862 fputs(prompt_str, stdout);
863 free(prompt_str);
Erik Andersend75af992000-03-16 08:09:09 +0000864#endif
Erik Andersen161220c2000-03-16 08:12:48 +0000865 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000866
Erik Andersen161220c2000-03-16 08:12:48 +0000867 if (!fgets(command, BUFSIZ - 2, source)) {
868 if (source == stdin)
869 printf("\n");
870 return 1;
871 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000872
Erik Andersen161220c2000-03-16 08:12:48 +0000873 /* remove trailing newline */
874 command[strlen(command) - 1] = '\0';
Erik Andersen3522eb12000-03-12 23:49:18 +0000875
Erik Andersen161220c2000-03-16 08:12:48 +0000876 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000877}
878
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000879#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000880static char* itoa(register int i)
881{
Eric Andersenb558e762000-11-30 22:43:16 +0000882 static char a[7]; /* Max 7 ints */
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000883 register char *b = a + sizeof(a) - 1;
884 int sign = (i < 0);
885
886 if (sign)
887 i = -i;
888 *b = 0;
889 do
890 {
891 *--b = '0' + (i % 10);
892 i /= 10;
893 }
894 while (i);
895 if (sign)
896 *--b = '-';
897 return b;
898}
899#endif
900
Eric Andersen86349772000-12-18 20:25:50 +0000901static void expand_argument(struct child_prog *prog, int *argcPtr,
902 int *argv_alloced_ptr)
Erik Andersen3522eb12000-03-12 23:49:18 +0000903{
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000904 int argc_l = *argcPtr;
Eric Andersen86349772000-12-18 20:25:50 +0000905 int argv_alloced = *argv_alloced_ptr;
Erik Andersen161220c2000-03-16 08:12:48 +0000906 int rc;
907 int flags;
908 int i;
Eric Andersenb54833c2000-07-03 23:56:26 +0000909 char *src, *dst, *var;
Erik Andersen3522eb12000-03-12 23:49:18 +0000910
Eric Andersen86349772000-12-18 20:25:50 +0000911 if (argc_l > 1) { /* cmd->glob_result is already initialized */
Erik Andersen161220c2000-03-16 08:12:48 +0000912 flags = GLOB_APPEND;
Eric Andersen86349772000-12-18 20:25:50 +0000913 i = prog->glob_result.gl_pathc;
Erik Andersen161220c2000-03-16 08:12:48 +0000914 } else {
Eric Andersen86349772000-12-18 20:25:50 +0000915 prog->free_glob = 1;
Erik Andersen161220c2000-03-16 08:12:48 +0000916 flags = 0;
917 i = 0;
Erik Andersend75af992000-03-16 08:09:09 +0000918 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000919#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersencaeeb362001-02-20 06:38:44 +0000920 /* do shell variable substitution */
921 src = prog->argv[argc_l - 1];
922 while((dst = strchr(src,'$')) != NULL){
923 if (!(var = getenv(dst + 1))) {
924 switch(*(dst+1)) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000925 case '?':
Eric Andersencaeeb362001-02-20 06:38:44 +0000926 var = itoa(last_return_code);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000927 break;
928 case '$':
Eric Andersencaeeb362001-02-20 06:38:44 +0000929 var = itoa(getpid());
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000930 break;
931 case '#':
Eric Andersencaeeb362001-02-20 06:38:44 +0000932 var = itoa(argc-1);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000933 break;
934 case '!':
Eric Andersen86349772000-12-18 20:25:50 +0000935 if (last_bg_pid==-1)
Eric Andersencaeeb362001-02-20 06:38:44 +0000936 *(var)='\0';
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000937 else
Eric Andersencaeeb362001-02-20 06:38:44 +0000938 var = itoa(last_bg_pid);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000939 break;
940 case '0':case '1':case '2':case '3':case '4':
941 case '5':case '6':case '7':case '8':case '9':
942 {
Eric Andersencaeeb362001-02-20 06:38:44 +0000943 int index=*(dst + 1)-48;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000944 if (index >= argc) {
Eric Andersencaeeb362001-02-20 06:38:44 +0000945 var='\0';
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000946 } else {
Eric Andersencaeeb362001-02-20 06:38:44 +0000947 var = argv[index];
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000948 }
949 }
950 break;
951 }
952 }
Eric Andersencaeeb362001-02-20 06:38:44 +0000953 if (var) {
954 int offset = dst-src;
955#warning I have a memory leak which needs to be plugged somehow
956 src = (char*)xmalloc(strlen(src)-strlen(dst)+strlen(var)+1);
957 strncpy(src, prog->argv[argc_l -1], offset);
958 safe_strncpy(src+offset, var, strlen(var)+1);
959 /* If there are any remaining $ variables in the src string, put them back */
960 if ((dst = strchr(prog->argv[argc_l -1]+offset+1,'$')) != NULL) {
961 offset=strlen(src);
962 safe_strncpy(src+strlen(src), dst, strlen(dst)+1);
963 }
964 prog->argv[argc_l -1] = src;
965 } else {
966 memset(dst, 0, strlen(src)-strlen(dst));
967 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000968 }
Eric Andersencaeeb362001-02-20 06:38:44 +0000969#endif
Erik Andersen3522eb12000-03-12 23:49:18 +0000970
Eric Andersen46f0beb2000-11-14 21:59:22 +0000971 if (strpbrk(prog->argv[argc_l - 1],"*[]?")!= NULL){
Eric Andersen86349772000-12-18 20:25:50 +0000972 rc = glob(prog->argv[argc_l - 1], flags, NULL, &prog->glob_result);
Eric Andersen46f0beb2000-11-14 21:59:22 +0000973 if (rc == GLOB_NOSPACE) {
Matt Kraaidd19c692001-01-31 19:00:21 +0000974 error_msg("out of space during glob operation");
Eric Andersen46f0beb2000-11-14 21:59:22 +0000975 return;
976 } else if (rc == GLOB_NOMATCH ||
Eric Andersen86349772000-12-18 20:25:50 +0000977 (!rc && (prog->glob_result.gl_pathc - i) == 1 &&
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000978 strcmp(prog->argv[argc_l - 1],
Eric Andersen86349772000-12-18 20:25:50 +0000979 prog->glob_result.gl_pathv[i]) == 0)) {
Eric Andersen46f0beb2000-11-14 21:59:22 +0000980 /* we need to remove whatever \ quoting is still present */
981 src = dst = prog->argv[argc_l - 1];
982 while (*src) {
Eric Andersen8c2d3f42000-11-30 00:03:57 +0000983 if (*src == '\\') {
984 src++;
985 *dst++ = process_escape_sequence(&src);
986 } else {
Eric Andersen46f0beb2000-11-14 21:59:22 +0000987 *dst++ = *src;
Eric Andersen8c2d3f42000-11-30 00:03:57 +0000988 src++;
989 }
Eric Andersen46f0beb2000-11-14 21:59:22 +0000990 }
991 *dst = '\0';
992 } else if (!rc) {
Eric Andersen86349772000-12-18 20:25:50 +0000993 argv_alloced += (prog->glob_result.gl_pathc - i);
994 prog->argv = xrealloc(prog->argv, argv_alloced * sizeof(*prog->argv));
995 memcpy(prog->argv + (argc_l - 1), prog->glob_result.gl_pathv + i,
996 sizeof(*(prog->argv)) * (prog->glob_result.gl_pathc - i));
997 argc_l += (prog->glob_result.gl_pathc - i - 1);
Erik Andersen161220c2000-03-16 08:12:48 +0000998 }
Eric Andersen46f0beb2000-11-14 21:59:22 +0000999 }else{
1000 src = dst = prog->argv[argc_l - 1];
1001 while (*src) {
Eric Andersen8c2d3f42000-11-30 00:03:57 +00001002 if (*src == '\\') {
1003 src++;
1004 *dst++ = process_escape_sequence(&src);
1005 } else {
Eric Andersen46f0beb2000-11-14 21:59:22 +00001006 *dst++ = *src;
Eric Andersen8c2d3f42000-11-30 00:03:57 +00001007 src++;
1008 }
Eric Andersen46f0beb2000-11-14 21:59:22 +00001009 }
1010 *dst = '\0';
Eric Andersen8c2d3f42000-11-30 00:03:57 +00001011
Eric Andersen86349772000-12-18 20:25:50 +00001012 prog->glob_result.gl_pathc=0;
Eric Andersen46f0beb2000-11-14 21:59:22 +00001013 if (flags==0)
Eric Andersen86349772000-12-18 20:25:50 +00001014 prog->glob_result.gl_pathv=NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001015 }
Eric Andersen86349772000-12-18 20:25:50 +00001016 *argv_alloced_ptr = argv_alloced;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001017 *argcPtr = argc_l;
Erik Andersen3522eb12000-03-12 23:49:18 +00001018}
1019
Eric Andersen86349772000-12-18 20:25:50 +00001020/* Return cmd->num_progs as 0 if no command is present (e.g. an empty
1021 line). If a valid command is found, command_ptr is set to point to
Erik Andersen3522eb12000-03-12 23:49:18 +00001022 the beginning of the next command (if the original command had more
1023 then one job associated with it) or NULL if no more commands are
1024 present. */
Eric Andersen86349772000-12-18 20:25:50 +00001025static int parse_command(char **command_ptr, struct job *job, int *inbg)
Erik Andersen3522eb12000-03-12 23:49:18 +00001026{
Erik Andersen161220c2000-03-16 08:12:48 +00001027 char *command;
Eric Andersen86349772000-12-18 20:25:50 +00001028 char *return_command = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001029 char *src, *buf, *chptr;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001030 int argc_l = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001031 int done = 0;
Eric Andersen86349772000-12-18 20:25:50 +00001032 int argv_alloced;
Erik Andersen161220c2000-03-16 08:12:48 +00001033 int i;
1034 char quote = '\0';
1035 int count;
Eric Andersen86349772000-12-18 20:25:50 +00001036 struct child_prog *prog;
Erik Andersen3522eb12000-03-12 23:49:18 +00001037
Erik Andersen161220c2000-03-16 08:12:48 +00001038 /* skip leading white space */
Eric Andersen86349772000-12-18 20:25:50 +00001039 while (**command_ptr && isspace(**command_ptr))
1040 (*command_ptr)++;
Erik Andersen3522eb12000-03-12 23:49:18 +00001041
Erik Andersen161220c2000-03-16 08:12:48 +00001042 /* this handles empty lines or leading '#' characters */
Eric Andersen86349772000-12-18 20:25:50 +00001043 if (!**command_ptr || (**command_ptr == '#')) {
1044 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001045 return 0;
1046 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001047
Eric Andersen86349772000-12-18 20:25:50 +00001048 *inbg = 0;
1049 job->num_progs = 1;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001050 job->progs = xmalloc(sizeof(*job->progs));
Erik Andersen3522eb12000-03-12 23:49:18 +00001051
Erik Andersen161220c2000-03-16 08:12:48 +00001052 /* We set the argv elements to point inside of this string. The
Eric Andersen86349772000-12-18 20:25:50 +00001053 memory is freed by free_job(). Allocate twice the original
Eric Andersenb54833c2000-07-03 23:56:26 +00001054 length in case we need to quote every single character.
Erik Andersen3522eb12000-03-12 23:49:18 +00001055
Erik Andersen161220c2000-03-16 08:12:48 +00001056 Getting clean memory relieves us of the task of NULL
1057 terminating things and makes the rest of this look a bit
1058 cleaner (though it is, admittedly, a tad less efficient) */
Eric Andersen86349772000-12-18 20:25:50 +00001059 job->cmdbuf = command = xcalloc(2*strlen(*command_ptr) + 1, sizeof(char));
Erik Andersen161220c2000-03-16 08:12:48 +00001060 job->text = NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +00001061
Erik Andersen161220c2000-03-16 08:12:48 +00001062 prog = job->progs;
Eric Andersen86349772000-12-18 20:25:50 +00001063 prog->num_redirects = 0;
1064 prog->redirects = NULL;
1065 prog->free_glob = 0;
1066 prog->is_stopped = 0;
1067 prog->family = job;
Erik Andersen3522eb12000-03-12 23:49:18 +00001068
Eric Andersen86349772000-12-18 20:25:50 +00001069 argv_alloced = 5;
1070 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
1071 prog->argv[0] = job->cmdbuf;
Erik Andersen3522eb12000-03-12 23:49:18 +00001072
Erik Andersen161220c2000-03-16 08:12:48 +00001073 buf = command;
Eric Andersen86349772000-12-18 20:25:50 +00001074 src = *command_ptr;
Erik Andersen161220c2000-03-16 08:12:48 +00001075 while (*src && !done) {
1076 if (quote == *src) {
1077 quote = '\0';
1078 } else if (quote) {
1079 if (*src == '\\') {
1080 src++;
1081 if (!*src) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001082 error_msg("character expected after \\");
Eric Andersen86349772000-12-18 20:25:50 +00001083 free_job(job);
Erik Andersen161220c2000-03-16 08:12:48 +00001084 return 1;
1085 }
1086
1087 /* in shell, "\'" should yield \' */
Eric Andersenb2356f62000-12-11 19:14:40 +00001088 if (*src != quote) {
Erik Andersen161220c2000-03-16 08:12:48 +00001089 *buf++ = '\\';
Eric Andersenb2356f62000-12-11 19:14:40 +00001090 *buf++ = '\\';
1091 }
Erik Andersen161220c2000-03-16 08:12:48 +00001092 } else if (*src == '*' || *src == '?' || *src == '[' ||
1093 *src == ']') *buf++ = '\\';
1094 *buf++ = *src;
1095 } else if (isspace(*src)) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001096 if (*prog->argv[argc_l]) {
1097 buf++, argc_l++;
Erik Andersen161220c2000-03-16 08:12:48 +00001098 /* +1 here leaves room for the NULL which ends argv */
Eric Andersen86349772000-12-18 20:25:50 +00001099 if ((argc_l + 1) == argv_alloced) {
1100 argv_alloced += 5;
Matt Kraaib8907522000-09-13 02:08:21 +00001101 prog->argv = xrealloc(prog->argv,
1102 sizeof(*prog->argv) *
Eric Andersen86349772000-12-18 20:25:50 +00001103 argv_alloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001104 }
Eric Andersen86349772000-12-18 20:25:50 +00001105 expand_argument(prog, &argc_l, &argv_alloced);
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001106 prog->argv[argc_l] = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001107 }
1108 } else
1109 switch (*src) {
1110 case '"':
1111 case '\'':
1112 quote = *src;
1113 break;
1114
1115 case '#': /* comment */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001116 if (*(src-1)== '$')
1117 *buf++ = *src;
1118 else
1119 done = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001120 break;
1121
Eric Andersen86349772000-12-18 20:25:50 +00001122 case '>': /* redirects */
Erik Andersen161220c2000-03-16 08:12:48 +00001123 case '<':
Eric Andersen86349772000-12-18 20:25:50 +00001124 i = prog->num_redirects++;
1125 prog->redirects = xrealloc(prog->redirects,
1126 sizeof(*prog->redirects) *
Matt Kraaib8907522000-09-13 02:08:21 +00001127 (i + 1));
Erik Andersen161220c2000-03-16 08:12:48 +00001128
Eric Andersen86349772000-12-18 20:25:50 +00001129 prog->redirects[i].fd = -1;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001130 if (buf != prog->argv[argc_l]) {
Erik Andersen161220c2000-03-16 08:12:48 +00001131 /* the stuff before this character may be the file number
1132 being redirected */
Eric Andersen86349772000-12-18 20:25:50 +00001133 prog->redirects[i].fd =
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001134 strtol(prog->argv[argc_l], &chptr, 10);
Erik Andersen161220c2000-03-16 08:12:48 +00001135
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001136 if (*chptr && *prog->argv[argc_l]) {
1137 buf++, argc_l++;
Eric Andersen86349772000-12-18 20:25:50 +00001138 expand_argument(prog, &argc_l, &argv_alloced);
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001139 prog->argv[argc_l] = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001140 }
1141 }
1142
Eric Andersen86349772000-12-18 20:25:50 +00001143 if (prog->redirects[i].fd == -1) {
Erik Andersen161220c2000-03-16 08:12:48 +00001144 if (*src == '>')
Eric Andersen86349772000-12-18 20:25:50 +00001145 prog->redirects[i].fd = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001146 else
Eric Andersen86349772000-12-18 20:25:50 +00001147 prog->redirects[i].fd = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001148 }
1149
1150 if (*src++ == '>') {
1151 if (*src == '>')
Eric Andersen86349772000-12-18 20:25:50 +00001152 prog->redirects[i].type =
Erik Andersen161220c2000-03-16 08:12:48 +00001153 REDIRECT_APPEND, src++;
1154 else
Eric Andersen86349772000-12-18 20:25:50 +00001155 prog->redirects[i].type = REDIRECT_OVERWRITE;
Erik Andersen161220c2000-03-16 08:12:48 +00001156 } else {
Eric Andersen86349772000-12-18 20:25:50 +00001157 prog->redirects[i].type = REDIRECT_INPUT;
Erik Andersen161220c2000-03-16 08:12:48 +00001158 }
1159
1160 /* This isn't POSIX sh compliant. Oh well. */
1161 chptr = src;
1162 while (isspace(*chptr))
1163 chptr++;
1164
1165 if (!*chptr) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001166 error_msg("file name expected after %c", *src);
Eric Andersen86349772000-12-18 20:25:50 +00001167 free_job(job);
1168 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001169 return 1;
1170 }
1171
Eric Andersen86349772000-12-18 20:25:50 +00001172 prog->redirects[i].filename = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001173 while (*chptr && !isspace(*chptr))
1174 *buf++ = *chptr++;
1175
1176 src = chptr - 1; /* we src++ later */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001177 prog->argv[argc_l] = ++buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001178 break;
1179
1180 case '|': /* pipe */
1181 /* finish this command */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001182 if (*prog->argv[argc_l])
1183 argc_l++;
1184 if (!argc_l) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001185 error_msg("empty command in pipe");
Eric Andersen86349772000-12-18 20:25:50 +00001186 free_job(job);
1187 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001188 return 1;
1189 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001190 prog->argv[argc_l] = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001191
1192 /* and start the next */
Eric Andersen86349772000-12-18 20:25:50 +00001193 job->num_progs++;
Matt Kraaib8907522000-09-13 02:08:21 +00001194 job->progs = xrealloc(job->progs,
Eric Andersen86349772000-12-18 20:25:50 +00001195 sizeof(*job->progs) * job->num_progs);
1196 prog = job->progs + (job->num_progs - 1);
1197 prog->num_redirects = 0;
1198 prog->redirects = NULL;
1199 prog->free_glob = 0;
1200 prog->is_stopped = 0;
1201 prog->family = job;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001202 argc_l = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001203
Eric Andersen86349772000-12-18 20:25:50 +00001204 argv_alloced = 5;
1205 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001206 prog->argv[0] = ++buf;
1207
1208 src++;
1209 while (*src && isspace(*src))
1210 src++;
1211
1212 if (!*src) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001213 error_msg("empty command in pipe");
Eric Andersen86349772000-12-18 20:25:50 +00001214 free_job(job);
1215 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001216 return 1;
1217 }
1218 src--; /* we'll ++ it at the end of the loop */
1219
1220 break;
1221
1222 case '&': /* background */
Eric Andersen86349772000-12-18 20:25:50 +00001223 *inbg = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001224 case ';': /* multiple commands */
1225 done = 1;
Eric Andersen86349772000-12-18 20:25:50 +00001226 return_command = *command_ptr + (src - *command_ptr) + 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001227 break;
1228
Eric Andersena1d187a2000-07-17 19:14:41 +00001229#ifdef BB_FEATURE_SH_BACKTICKS
Eric Andersenec10b9d2000-07-14 01:13:11 +00001230 case '`':
1231 /* Exec a backtick-ed command */
Eric Andersen8ea28be2001-01-05 20:58:22 +00001232 /* Besides any previous brokenness, I have not
1233 * updated backtick handling for close_me support.
1234 * I don't know if it needs it or not. -- LRD */
Eric Andersenec10b9d2000-07-14 01:13:11 +00001235 {
Eric Andersena1d187a2000-07-17 19:14:41 +00001236 char* charptr1=NULL, *charptr2;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001237 char* ptr=NULL;
Eric Andersen86349772000-12-18 20:25:50 +00001238 struct job *newjob;
1239 struct jobset njob_list = { NULL, NULL };
Eric Andersena1d187a2000-07-17 19:14:41 +00001240 int pipefd[2];
1241 int size;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001242
1243 ptr=strchr(++src, '`');
1244 if (ptr==NULL) {
1245 fprintf(stderr, "Unmatched '`' in command\n");
Eric Andersen86349772000-12-18 20:25:50 +00001246 free_job(job);
Eric Andersenec10b9d2000-07-14 01:13:11 +00001247 return 1;
1248 }
1249
Eric Andersena1d187a2000-07-17 19:14:41 +00001250 /* Make some space to hold just the backticked command */
Eric Andersen6efc48c2000-07-18 08:16:39 +00001251 charptr1 = charptr2 = xmalloc(1+ptr-src);
Matt Kraai0b2da462000-09-19 06:46:44 +00001252 memcpy(charptr1, src, ptr-src);
1253 charptr1[ptr-src] = '\0';
Eric Andersen86349772000-12-18 20:25:50 +00001254 newjob = xmalloc(sizeof(struct job));
1255 newjob->job_list = &njob_list;
Eric Andersena1d187a2000-07-17 19:14:41 +00001256 /* Now parse and run the backticked command */
Eric Andersen86349772000-12-18 20:25:50 +00001257 if (!parse_command(&charptr1, newjob, inbg)
1258 && newjob->num_progs) {
Eric Andersena1d187a2000-07-17 19:14:41 +00001259 pipe(pipefd);
Eric Andersen86349772000-12-18 20:25:50 +00001260 run_command(newjob, 0, pipefd);
Eric Andersenec10b9d2000-07-14 01:13:11 +00001261 }
Eric Andersen86349772000-12-18 20:25:50 +00001262 checkjobs(job->job_list);
1263 free_job(newjob); /* doesn't actually free newjob,
1264 looks like a memory leak */
Eric Andersen6efc48c2000-07-18 08:16:39 +00001265 free(charptr2);
1266
1267 /* Make a copy of any stuff left over in the command
1268 * line after the second backtick */
1269 charptr2 = xmalloc(strlen(ptr)+1);
1270 memcpy(charptr2, ptr+1, strlen(ptr));
1271
Eric Andersenec10b9d2000-07-14 01:13:11 +00001272
Eric Andersena1d187a2000-07-17 19:14:41 +00001273 /* Copy the output from the backtick-ed command into the
1274 * command line, making extra room as needed */
1275 --src;
1276 charptr1 = xmalloc(BUFSIZ);
Mark Whitleyf57c9442000-12-07 19:56:48 +00001277 while ( (size=full_read(pipefd[0], charptr1, BUFSIZ-1)) >0) {
Eric Andersen86349772000-12-18 20:25:50 +00001278 int newsize=src - *command_ptr + size + 1 + strlen(charptr2);
1279 if (newsize > BUFSIZ) {
1280 *command_ptr=xrealloc(*command_ptr, newsize);
Eric Andersena1d187a2000-07-17 19:14:41 +00001281 }
1282 memcpy(src, charptr1, size);
1283 src+=size;
1284 }
1285 free(charptr1);
1286 close(pipefd[0]);
1287 if (*(src-1)=='\n')
1288 --src;
1289
Eric Andersen86349772000-12-18 20:25:50 +00001290 /* Now paste into the *command_ptr all the stuff
Eric Andersena1d187a2000-07-17 19:14:41 +00001291 * leftover after the second backtick */
Matt Kraaicbbe4d62000-09-14 00:26:50 +00001292 memcpy(src, charptr2, strlen(charptr2)+1);
Eric Andersena1d187a2000-07-17 19:14:41 +00001293 free(charptr2);
1294
Eric Andersen86349772000-12-18 20:25:50 +00001295 /* Now recursively call parse_command to deal with the new
Eric Andersena1d187a2000-07-17 19:14:41 +00001296 * and improved version of the command line with the backtick
1297 * results expanded in place... */
Eric Andersen86349772000-12-18 20:25:50 +00001298 {
1299 struct jobset *jl=job->job_list;
1300 free_job(job);
1301 job->job_list = jl;
1302 }
1303 return(parse_command(command_ptr, job, inbg));
Eric Andersenec10b9d2000-07-14 01:13:11 +00001304 }
1305 break;
Eric Andersena1d187a2000-07-17 19:14:41 +00001306#endif // BB_FEATURE_SH_BACKTICKS
Matt Kraai131241f2000-09-14 00:43:20 +00001307
1308 case '\\':
1309 src++;
1310 if (!*src) {
Eric Andersen86349772000-12-18 20:25:50 +00001311/* This is currently a little broken... */
1312#ifdef HANDLE_CONTINUATION_CHARS
1313 /* They fed us a continuation char, so continue reading stuff
1314 * on the next line, then tack that onto the end of the current
1315 * command */
1316 char *command;
1317 int newsize;
1318 printf("erik: found a continue char at EOL...\n");
1319 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1320 if (get_command(input, command)) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001321 error_msg("character expected after \\");
Eric Andersen86349772000-12-18 20:25:50 +00001322 free(command);
1323 free_job(job);
1324 return 1;
1325 }
1326 newsize = strlen(*command_ptr) + strlen(command) + 2;
1327 if (newsize > BUFSIZ) {
1328 printf("erik: doing realloc\n");
1329 *command_ptr=xrealloc(*command_ptr, newsize);
1330 }
1331 printf("erik: A: *command_ptr='%s'\n", *command_ptr);
1332 memcpy(--src, command, strlen(command));
1333 printf("erik: B: *command_ptr='%s'\n", *command_ptr);
1334 free(command);
1335 break;
1336#else
Matt Kraaidd19c692001-01-31 19:00:21 +00001337 error_msg("character expected after \\");
Eric Andersen86349772000-12-18 20:25:50 +00001338 free(command);
1339 free_job(job);
Matt Kraai131241f2000-09-14 00:43:20 +00001340 return 1;
Eric Andersen86349772000-12-18 20:25:50 +00001341#endif
Matt Kraai131241f2000-09-14 00:43:20 +00001342 }
1343 if (*src == '*' || *src == '[' || *src == ']'
1344 || *src == '?') *buf++ = '\\';
1345 /* fallthrough */
Erik Andersen161220c2000-03-16 08:12:48 +00001346 default:
1347 *buf++ = *src;
1348 }
1349
Erik Andersend75af992000-03-16 08:09:09 +00001350 src++;
Erik Andersen161220c2000-03-16 08:12:48 +00001351 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001352
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001353 if (*prog->argv[argc_l]) {
1354 argc_l++;
Eric Andersen86349772000-12-18 20:25:50 +00001355 expand_argument(prog, &argc_l, &argv_alloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001356 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001357 if (!argc_l) {
Eric Andersen86349772000-12-18 20:25:50 +00001358 free_job(job);
Erik Andersen161220c2000-03-16 08:12:48 +00001359 return 0;
1360 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001361 prog->argv[argc_l] = NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +00001362
Eric Andersen86349772000-12-18 20:25:50 +00001363 if (!return_command) {
1364 job->text = xmalloc(strlen(*command_ptr) + 1);
1365 strcpy(job->text, *command_ptr);
Erik Andersen161220c2000-03-16 08:12:48 +00001366 } else {
1367 /* This leaves any trailing spaces, which is a bit sloppy */
Eric Andersen86349772000-12-18 20:25:50 +00001368 count = return_command - *command_ptr;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001369 job->text = xmalloc(count + 1);
Eric Andersen86349772000-12-18 20:25:50 +00001370 strncpy(job->text, *command_ptr, count);
Erik Andersen161220c2000-03-16 08:12:48 +00001371 job->text[count] = '\0';
1372 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001373
Eric Andersen86349772000-12-18 20:25:50 +00001374 *command_ptr = return_command;
Eric Andersen46f0beb2000-11-14 21:59:22 +00001375
Erik Andersend75af992000-03-16 08:09:09 +00001376 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001377}
1378
Eric Andersen86349772000-12-18 20:25:50 +00001379/* Run the child_prog, no matter what kind of command it uses.
1380 */
1381static int pseudo_exec(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +00001382{
Eric Andersen86349772000-12-18 20:25:50 +00001383 struct built_in_command *x;
Eric Andersenb54833c2000-07-03 23:56:26 +00001384#ifdef BB_FEATURE_SH_STANDALONE_SHELL
Eric Andersenaf4ac772001-02-01 22:43:49 +00001385 char *name;
Erik Andersenbcd61772000-05-13 06:33:19 +00001386#endif
Erik Andersen3522eb12000-03-12 23:49:18 +00001387
Eric Andersene9f07fb2000-12-21 18:31:36 +00001388 /* Check if the command matches any of the non-forking builtins.
1389 * Depending on context, this might be redundant. But it's
1390 * easier to waste a few CPU cycles than it is to figure out
1391 * if this is one of those cases.
Eric Andersen86349772000-12-18 20:25:50 +00001392 */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001393 for (x = bltins; x->cmd; x++) {
1394 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1395 exit(x->function(child));
1396 }
1397 }
1398
1399 /* Check if the command matches any of the forking builtins. */
Eric Andersen86349772000-12-18 20:25:50 +00001400 for (x = bltins_forking; x->cmd; x++) {
1401 if (strcmp(child->argv[0], x->cmd) == 0) {
1402 applet_name=x->cmd;
1403 exit (x->function(child));
1404 }
1405 }
1406#ifdef BB_FEATURE_SH_STANDALONE_SHELL
1407 /* Check if the command matches any busybox internal
1408 * commands ("applets") here. Following discussions from
1409 * November 2000 on busybox@opensource.lineo.com, don't use
1410 * get_last_path_component(). This way explicit (with
1411 * slashes) filenames will never be interpreted as an
1412 * applet, just like with builtins. This way the user can
1413 * override an applet with an explicit filename reference.
1414 * The only downside to this change is that an explicit
1415 * /bin/foo invocation will fork and exec /bin/foo, even if
1416 * /bin/foo is a symlink to busybox.
1417 */
Matt Kraaif2cc2762001-02-01 19:21:20 +00001418 name = child->argv[0];
Eric Andersen86349772000-12-18 20:25:50 +00001419
1420#ifdef BB_FEATURE_SH_APPLETS_ALWAYS_WIN
1421 /* If you enable BB_FEATURE_SH_APPLETS_ALWAYS_WIN, then
1422 * if you run /bin/cat, it will use BusyBox cat even if
1423 * /bin/cat exists on the filesystem and is _not_ busybox.
1424 * Some systems want this, others do not. Choose wisely. :-)
1425 */
Matt Kraaif2cc2762001-02-01 19:21:20 +00001426 name = get_last_path_component(name);
Eric Andersen86349772000-12-18 20:25:50 +00001427#endif
1428
Eric Andersen67991cf2001-02-14 21:23:06 +00001429 {
1430 char** argv=child->argv;
1431 int argc_l;
1432 for(argc_l=0;*argv!=NULL; argv++, argc_l++);
1433 optind = 1;
1434 run_applet_by_name(name, argc_l, child->argv);
Eric Andersen86349772000-12-18 20:25:50 +00001435 }
1436#endif
1437
1438 execvp(child->argv[0], child->argv);
Eric Andersen8ea28be2001-01-05 20:58:22 +00001439 perror_msg_and_die("%s", child->argv[0]);
Eric Andersen86349772000-12-18 20:25:50 +00001440}
1441
1442static void insert_job(struct job *newjob, int inbg)
1443{
1444 struct job *thejob;
1445 struct jobset *job_list=newjob->job_list;
1446
1447 /* find the ID for thejob to use */
1448 newjob->jobid = 1;
1449 for (thejob = job_list->head; thejob; thejob = thejob->next)
1450 if (thejob->jobid >= newjob->jobid)
1451 newjob->jobid = thejob->jobid + 1;
1452
1453 /* add thejob to the list of running jobs */
1454 if (!job_list->head) {
1455 thejob = job_list->head = xmalloc(sizeof(*thejob));
1456 } else {
1457 for (thejob = job_list->head; thejob->next; thejob = thejob->next) /* nothing */;
1458 thejob->next = xmalloc(sizeof(*thejob));
1459 thejob = thejob->next;
1460 }
1461
1462 *thejob = *newjob; /* physically copy the struct job */
1463 thejob->next = NULL;
1464 thejob->running_progs = thejob->num_progs;
1465 thejob->stopped_progs = 0;
1466
1467 if (inbg) {
1468 /* we don't wait for background thejobs to return -- append it
1469 to the list of backgrounded thejobs and leave it alone */
1470 printf("[%d] %d\n", thejob->jobid,
1471 newjob->progs[newjob->num_progs - 1].pid);
1472#ifdef BB_FEATURE_SH_ENVIRONMENT
1473 last_bg_pid=newjob->progs[newjob->num_progs - 1].pid;
1474#endif
1475 } else {
1476 newjob->job_list->fg = thejob;
1477
1478 /* move the new process group into the foreground */
1479 /* suppress messages when run from /linuxrc mag@sysgo.de */
1480 if (tcsetpgrp(0, newjob->pgrp) && errno != ENOTTY)
Matt Kraaia9819b22000-12-22 01:48:07 +00001481 perror_msg("tcsetpgrp");
Eric Andersen86349772000-12-18 20:25:50 +00001482 }
1483}
1484
1485static int run_command(struct job *newjob, int inbg, int outpipe[2])
1486{
1487 /* struct job *thejob; */
1488 int i;
1489 int nextin, nextout;
1490 int pipefds[2]; /* pipefd[0] is for reading */
1491 struct built_in_command *x;
1492 struct child_prog *child;
1493
Eric Andersen6efc48c2000-07-18 08:16:39 +00001494 nextin = 0, nextout = 1;
Eric Andersen86349772000-12-18 20:25:50 +00001495 for (i = 0; i < newjob->num_progs; i++) {
1496 child = & (newjob->progs[i]);
1497
1498 if ((i + 1) < newjob->num_progs) {
1499 if (pipe(pipefds)<0) perror_msg_and_die("pipe");
Erik Andersen161220c2000-03-16 08:12:48 +00001500 nextout = pipefds[1];
1501 } else {
Eric Andersen86349772000-12-18 20:25:50 +00001502 if (outpipe[1]!=-1) {
1503 nextout = outpipe[1];
Eric Andersen6efc48c2000-07-18 08:16:39 +00001504 } else {
1505 nextout = 1;
1506 }
Erik Andersen161220c2000-03-16 08:12:48 +00001507 }
1508
Eric Andersen501c88b2000-07-28 15:14:45 +00001509#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen86349772000-12-18 20:25:50 +00001510 if (show_x_trace==TRUE) {
Eric Andersen501c88b2000-07-28 15:14:45 +00001511 int j;
Eric Andersen86349772000-12-18 20:25:50 +00001512 fputc('+', stderr);
1513 for (j = 0; child->argv[j]; j++) {
1514 fputc(' ', stderr);
1515 fputs(child->argv[j], stderr);
1516 }
1517 fputc('\n', stderr);
Eric Andersen501c88b2000-07-28 15:14:45 +00001518 }
1519#endif
1520
Eric Andersene9f07fb2000-12-21 18:31:36 +00001521 /* Check if the command matches any non-forking builtins,
1522 * but only if this is a simple command.
1523 * Non-forking builtins within pipes have to fork anyway,
1524 * and are handled in pseudo_exec. "echo foo | read bar"
1525 * is doomed to failure, and doesn't work on bash, either.
Eric Andersen86349772000-12-18 20:25:50 +00001526 */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001527 if (newjob->num_progs == 1) {
1528 for (x = bltins; x->cmd; x++) {
1529 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1530 int squirrel[] = {-1, -1, -1};
1531 int rcode;
1532 setup_redirects(child, squirrel);
1533 rcode = x->function(child);
1534 restore_redirects(squirrel);
1535 return rcode;
1536 }
Erik Andersen330fd2b2000-05-19 05:35:19 +00001537 }
1538 }
1539
Eric Andersen86349772000-12-18 20:25:50 +00001540 if (!(child->pid = fork())) {
Erik Andersen161220c2000-03-16 08:12:48 +00001541 signal(SIGTTOU, SIG_DFL);
1542
Eric Andersen8ea28be2001-01-05 20:58:22 +00001543 close_all();
1544
Eric Andersen86349772000-12-18 20:25:50 +00001545 if (outpipe[1]!=-1) {
1546 close(outpipe[0]);
Eric Andersen6efc48c2000-07-18 08:16:39 +00001547 }
1548 if (nextin != 0) {
1549 dup2(nextin, 0);
1550 close(nextin);
1551 }
1552
1553 if (nextout != 1) {
Erik Andersen161220c2000-03-16 08:12:48 +00001554 dup2(nextout, 1);
Eric Andersen86349772000-12-18 20:25:50 +00001555 dup2(nextout, 2); /* Really? */
Erik Andersen161220c2000-03-16 08:12:48 +00001556 close(nextout);
Eric Andersen501c88b2000-07-28 15:14:45 +00001557 close(pipefds[0]);
Erik Andersen161220c2000-03-16 08:12:48 +00001558 }
1559
Eric Andersen86349772000-12-18 20:25:50 +00001560 /* explicit redirects override pipes */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001561 setup_redirects(child,NULL);
Erik Andersen161220c2000-03-16 08:12:48 +00001562
Eric Andersen86349772000-12-18 20:25:50 +00001563 pseudo_exec(child);
Erik Andersen161220c2000-03-16 08:12:48 +00001564 }
Eric Andersen86349772000-12-18 20:25:50 +00001565 if (outpipe[1]!=-1) {
1566 close(outpipe[1]);
Eric Andersena1d187a2000-07-17 19:14:41 +00001567 }
Erik Andersen161220c2000-03-16 08:12:48 +00001568
1569 /* put our child in the process group whose leader is the
1570 first process in this pipe */
Eric Andersen86349772000-12-18 20:25:50 +00001571 setpgid(child->pid, newjob->progs[0].pid);
Erik Andersen161220c2000-03-16 08:12:48 +00001572 if (nextin != 0)
1573 close(nextin);
Eric Andersen6efc48c2000-07-18 08:16:39 +00001574 if (nextout != 1)
Erik Andersen161220c2000-03-16 08:12:48 +00001575 close(nextout);
1576
1577 /* If there isn't another process, nextin is garbage
1578 but it doesn't matter */
1579 nextin = pipefds[0];
1580 }
1581
Eric Andersen86349772000-12-18 20:25:50 +00001582 newjob->pgrp = newjob->progs[0].pid;
Erik Andersen161220c2000-03-16 08:12:48 +00001583
Eric Andersen86349772000-12-18 20:25:50 +00001584 insert_job(newjob, inbg);
Erik Andersen3522eb12000-03-12 23:49:18 +00001585
Erik Andersen161220c2000-03-16 08:12:48 +00001586 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001587}
1588
Erik Andersend75af992000-03-16 08:09:09 +00001589static int busy_loop(FILE * input)
Erik Andersen3522eb12000-03-12 23:49:18 +00001590{
Erik Andersen161220c2000-03-16 08:12:48 +00001591 char *command;
Eric Andersen86349772000-12-18 20:25:50 +00001592 char *next_command = NULL;
1593 struct job newjob;
Eric Andersen1c314ad2000-06-28 16:56:25 +00001594 pid_t parent_pgrp;
Erik Andersen161220c2000-03-16 08:12:48 +00001595 int i;
Eric Andersen86349772000-12-18 20:25:50 +00001596 int inbg;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001597 int status;
Eric Andersen86349772000-12-18 20:25:50 +00001598 newjob.job_list = &job_list;
1599 newjob.job_context = DEFAULT_CONTEXT;
Erik Andersen3522eb12000-03-12 23:49:18 +00001600
Eric Andersen1c314ad2000-06-28 16:56:25 +00001601 /* save current owner of TTY so we can restore it on exit */
1602 parent_pgrp = tcgetpgrp(0);
1603
Matt Kraaib8907522000-09-13 02:08:21 +00001604 command = (char *) xcalloc(BUFSIZ, sizeof(char));
Erik Andersend75af992000-03-16 08:09:09 +00001605
Erik Andersen161220c2000-03-16 08:12:48 +00001606 /* don't pay any attention to this signal; it just confuses
1607 things and isn't really meant for shells anyway */
1608 signal(SIGTTOU, SIG_IGN);
Erik Andersend75af992000-03-16 08:09:09 +00001609
Erik Andersen161220c2000-03-16 08:12:48 +00001610 while (1) {
Eric Andersen86349772000-12-18 20:25:50 +00001611 if (!job_list.fg) {
Erik Andersend75af992000-03-16 08:09:09 +00001612 /* no job is in the foreground */
Erik Andersen3522eb12000-03-12 23:49:18 +00001613
Erik Andersend75af992000-03-16 08:09:09 +00001614 /* see if any background processes have exited */
Eric Andersen86349772000-12-18 20:25:50 +00001615 checkjobs(&job_list);
Erik Andersen3522eb12000-03-12 23:49:18 +00001616
Eric Andersen86349772000-12-18 20:25:50 +00001617 if (!next_command) {
1618 if (get_command(input, command))
Erik Andersen161220c2000-03-16 08:12:48 +00001619 break;
Eric Andersen86349772000-12-18 20:25:50 +00001620 next_command = command;
Erik Andersend75af992000-03-16 08:09:09 +00001621 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001622
Eric Andersen86349772000-12-18 20:25:50 +00001623 if (!parse_command(&next_command, &newjob, &inbg) &&
1624 newjob.num_progs) {
Eric Andersena1d187a2000-07-17 19:14:41 +00001625 int pipefds[2] = {-1,-1};
Eric Andersen86349772000-12-18 20:25:50 +00001626 debug_printf( "job=%p being fed to run_command by busy_loop()'\n", &newjob);
1627 run_command(&newjob, inbg, pipefds);
Eric Andersenfad9c112000-07-25 18:06:52 +00001628 }
1629 else {
Eric Andersena1d187a2000-07-17 19:14:41 +00001630 free(command);
Matt Kraaib8907522000-09-13 02:08:21 +00001631 command = (char *) xcalloc(BUFSIZ, sizeof(char));
Eric Andersen86349772000-12-18 20:25:50 +00001632 next_command = NULL;
Erik Andersend75af992000-03-16 08:09:09 +00001633 }
1634 } else {
1635 /* a job is running in the foreground; wait for it */
1636 i = 0;
Eric Andersen86349772000-12-18 20:25:50 +00001637 while (!job_list.fg->progs[i].pid ||
1638 job_list.fg->progs[i].is_stopped == 1) i++;
Erik Andersen3522eb12000-03-12 23:49:18 +00001639
Eric Andersen8ea28be2001-01-05 20:58:22 +00001640 if (waitpid(job_list.fg->progs[i].pid, &status, WUNTRACED)<0)
1641 perror_msg_and_die("waitpid(%d)",job_list.fg->progs[i].pid);
Erik Andersen3522eb12000-03-12 23:49:18 +00001642
Erik Andersend75af992000-03-16 08:09:09 +00001643 if (WIFEXITED(status) || WIFSIGNALED(status)) {
Erik Andersen161220c2000-03-16 08:12:48 +00001644 /* the child exited */
Eric Andersen86349772000-12-18 20:25:50 +00001645 job_list.fg->running_progs--;
1646 job_list.fg->progs[i].pid = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001647
Eric Andersen501c88b2000-07-28 15:14:45 +00001648#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen86349772000-12-18 20:25:50 +00001649 last_return_code=WEXITSTATUS(status);
Eric Andersen501c88b2000-07-28 15:14:45 +00001650#endif
Eric Andersen86349772000-12-18 20:25:50 +00001651 debug_printf("'%s' exited -- return code %d\n",
1652 job_list.fg->text, last_return_code);
1653 if (!job_list.fg->running_progs) {
Erik Andersen161220c2000-03-16 08:12:48 +00001654 /* child exited */
Eric Andersen86349772000-12-18 20:25:50 +00001655 remove_job(&job_list, job_list.fg);
1656 job_list.fg = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001657 }
Erik Andersend75af992000-03-16 08:09:09 +00001658 } else {
Erik Andersen161220c2000-03-16 08:12:48 +00001659 /* the child was stopped */
Eric Andersen86349772000-12-18 20:25:50 +00001660 job_list.fg->stopped_progs++;
1661 job_list.fg->progs[i].is_stopped = 1;
Erik Andersen3522eb12000-03-12 23:49:18 +00001662
Eric Andersen86349772000-12-18 20:25:50 +00001663 if (job_list.fg->stopped_progs == job_list.fg->running_progs) {
1664 printf("\n" JOB_STATUS_FORMAT, job_list.fg->jobid,
1665 "Stopped", job_list.fg->text);
1666 job_list.fg = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001667 }
Erik Andersend75af992000-03-16 08:09:09 +00001668 }
1669
Eric Andersen86349772000-12-18 20:25:50 +00001670 if (!job_list.fg) {
Erik Andersen161220c2000-03-16 08:12:48 +00001671 /* move the shell to the foreground */
Eric Andersen1c314ad2000-06-28 16:56:25 +00001672 /* suppress messages when run from /linuxrc mag@sysgo.de */
1673 if (tcsetpgrp(0, getpid()) && errno != ENOTTY)
Matt Kraaia9819b22000-12-22 01:48:07 +00001674 perror_msg("tcsetpgrp");
Erik Andersend75af992000-03-16 08:09:09 +00001675 }
1676 }
1677 }
Erik Andersen161220c2000-03-16 08:12:48 +00001678 free(command);
Erik Andersen3522eb12000-03-12 23:49:18 +00001679
Eric Andersen1c314ad2000-06-28 16:56:25 +00001680 /* return controlling TTY back to parent process group before exiting */
1681 if (tcsetpgrp(0, parent_pgrp))
Matt Kraaia9819b22000-12-22 01:48:07 +00001682 perror_msg("tcsetpgrp");
Eric Andersenb54833c2000-07-03 23:56:26 +00001683
1684 /* return exit status if called with "-c" */
1685 if (input == NULL && WIFEXITED(status))
1686 return WEXITSTATUS(status);
1687
Erik Andersen161220c2000-03-16 08:12:48 +00001688 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001689}
1690
1691
Eric Andersenfad9c112000-07-25 18:06:52 +00001692#ifdef BB_FEATURE_CLEAN_UP
1693void free_memory(void)
1694{
Eric Andersenfad9c112000-07-25 18:06:52 +00001695 if (cwd)
1696 free(cwd);
1697 if (local_pending_command)
1698 free(local_pending_command);
1699
Eric Andersen86349772000-12-18 20:25:50 +00001700 if (job_list.fg && !job_list.fg->running_progs) {
1701 remove_job(&job_list, job_list.fg);
Eric Andersenfad9c112000-07-25 18:06:52 +00001702 }
1703}
1704#endif
1705
Eric Andersen6efc48c2000-07-18 08:16:39 +00001706
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001707int shell_main(int argc_l, char **argv_l)
Erik Andersen3522eb12000-03-12 23:49:18 +00001708{
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001709 int opt, interactive=FALSE;
Erik Andersen161220c2000-03-16 08:12:48 +00001710 FILE *input = stdin;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001711 argc = argc_l;
1712 argv = argv_l;
Erik Andersen3522eb12000-03-12 23:49:18 +00001713
Eric Andersenb0970d42001-01-05 19:34:52 +00001714 shell_context = 0;
1715 cwd=NULL;
Mark Whitley6e25f922001-01-26 19:19:23 +00001716#ifdef BB_FEATURE_SH_STANDALONE_SHELL
Eric Andersenb0970d42001-01-05 19:34:52 +00001717 /* These variables need re-initializing when recursing */
1718 local_pending_command = NULL;
1719 job_list.head = NULL;
1720 job_list.fg = NULL;
1721#ifdef BB_FEATURE_SH_ENVIRONMENT
1722 last_bg_pid=-1;
1723 last_return_code=-1;
1724 show_x_trace=FALSE;
1725#endif
1726#endif
Eric Andersen501c88b2000-07-28 15:14:45 +00001727
Eric Andersenb558e762000-11-30 22:43:16 +00001728 if (argv[0] && argv[0][0] == '-') {
Eric Andersen8ea28be2001-01-05 20:58:22 +00001729 FILE *prof_input;
1730 prof_input = fopen("/etc/profile", "r");
1731 if (!prof_input) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001732 printf( "Couldn't open file '/etc/profile'\n");
Eric Andersen8ea28be2001-01-05 20:58:22 +00001733 } else {
1734 int tmp_fd = fileno(prof_input);
1735 mark_open(tmp_fd);
1736 /* Now run the file */
1737 busy_loop(prof_input);
1738 fclose(prof_input);
1739 mark_closed(tmp_fd);
1740 }
Eric Andersenb558e762000-11-30 22:43:16 +00001741 }
Eric Andersen501c88b2000-07-28 15:14:45 +00001742
Eric Andersenf21aa842000-12-08 20:50:30 +00001743 while ((opt = getopt(argc_l, argv_l, "cxi")) > 0) {
Eric Andersen501c88b2000-07-28 15:14:45 +00001744 switch (opt) {
1745 case 'c':
1746 input = NULL;
Matt Kraai6085c722000-09-06 01:46:18 +00001747 if (local_pending_command != 0)
Matt Kraaidd19c692001-01-31 19:00:21 +00001748 error_msg_and_die("multiple -c arguments");
Matt Kraai6085c722000-09-06 01:46:18 +00001749 local_pending_command = xstrdup(argv[optind]);
1750 optind++;
1751 argv = argv+optind;
Eric Andersen501c88b2000-07-28 15:14:45 +00001752 break;
Eric Andersen1428c4f2000-07-28 15:19:30 +00001753#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen501c88b2000-07-28 15:14:45 +00001754 case 'x':
Eric Andersen86349772000-12-18 20:25:50 +00001755 show_x_trace = TRUE;
Eric Andersen501c88b2000-07-28 15:14:45 +00001756 break;
Eric Andersen1428c4f2000-07-28 15:19:30 +00001757#endif
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001758 case 'i':
1759 interactive = TRUE;
1760 break;
Eric Andersen501c88b2000-07-28 15:14:45 +00001761 default:
Eric Andersen67991cf2001-02-14 21:23:06 +00001762 show_usage();
Eric Andersen501c88b2000-07-28 15:14:45 +00001763 }
1764 }
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001765 /* A shell is interactive if the `-i' flag was given, or if all of
1766 * the following conditions are met:
1767 * no -c command
1768 * no arguments remaining or the -s flag given
1769 * standard input is a terminal
1770 * standard output is a terminal
1771 * Refer to Posix.2, the description of the `sh' utility. */
Eric Andersen86349772000-12-18 20:25:50 +00001772 if (argv[optind]==NULL && input==stdin &&
1773 isatty(fileno(stdin)) && isatty(fileno(stdout))) {
1774 interactive=TRUE;
1775 }
1776 if (interactive==TRUE) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001777 //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
Eric Andersen501c88b2000-07-28 15:14:45 +00001778 /* Looks like they want an interactive shell */
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001779 printf( "\n\nBusyBox v%s (%s) Built-in shell (lash)\n", BB_VER, BB_BT);
1780 printf( "Enter 'help' for a list of built-in commands.\n\n");
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001781 } else if (local_pending_command==NULL) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001782 //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
Matt Kraaibbaef662000-09-27 02:43:35 +00001783 input = xfopen(argv[optind], "r");
Eric Andersen8ea28be2001-01-05 20:58:22 +00001784 mark_open(fileno(input)); /* be lazy, never mark this closed */
Eric Andersen501c88b2000-07-28 15:14:45 +00001785 }
1786
Eric Andersen6efc48c2000-07-18 08:16:39 +00001787 /* initialize the cwd -- this is never freed...*/
1788 cwd=(char*)xmalloc(sizeof(char)*MAX_LINE+1);
1789 getcwd(cwd, sizeof(char)*MAX_LINE);
Erik Andersen3522eb12000-03-12 23:49:18 +00001790
Eric Andersenfad9c112000-07-25 18:06:52 +00001791#ifdef BB_FEATURE_CLEAN_UP
1792 atexit(free_memory);
1793#endif
1794
Erik Andersen161220c2000-03-16 08:12:48 +00001795 return (busy_loop(input));
Erik Andersen3522eb12000-03-12 23:49:18 +00001796}