blob: 11016a009502d94618cad520b9d265893c61cf45 [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++;
Eric Andersen07f2f392001-03-06 20:28:22 +0000303 close_all();
Eric Andersen86349772000-12-18 20:25:50 +0000304 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]) {
Matt Kraaidd19c692001-01-31 19:00:21 +0000324 error_msg("%s: exactly one argument is expected",
Eric Andersene9f07fb2000-12-21 18:31:36 +0000325 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) {
Matt Kraaidd19c692001-01-31 19:00:21 +0000330 error_msg("%s: bad argument '%s'",
Eric Andersene9f07fb2000-12-21 18:31:36 +0000331 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) {
Matt Kraaidd19c692001-01-31 19:00:21 +0000342 error_msg("%s: unknown job %d",
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 */
Matt Kraaidd19c692001-01-31 19:00:21 +0000495 error_msg("%s `then'", 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 */
Matt Kraaidd19c692001-01-31 19:00:21 +0000523 error_msg("%s `else'", 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 */
Matt Kraaidd19c692001-01-31 19:00:21 +0000546 error_msg("%s `fi'", 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) {
Eric Andersen54851d32001-03-06 20:44:39 +0000635 mark_closed(c->fd);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000636 }
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!) */
Matt Kraaidd19c692001-01-31 19:00:21 +0000751 error_msg("error opening %s: %s", 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 Andersen22332fd2001-01-30 23:40:39 +0000782#if defined(BB_FEATURE_SH_SIMPLE_PROMPT)
783static char* setup_prompt_string(int state)
784{
785 char prompt_str[BUFSIZ];
786
787 /* Set up the prompt */
788 if (state == 0) {
789 /* simple prompt */
790 sprintf(prompt_str, "%s %s", cwd, ( geteuid() != 0 ) ? "$ ":"# ");
791 } else {
792 strcpy(prompt_str,"> ");
793 }
794
795 return(strdup(prompt_str)); /* Must free this memory */
796}
797
798#else
799
Eric Andersen09acc062001-01-04 11:10:38 +0000800static char* setup_prompt_string(int state)
Erik Andersen3522eb12000-03-12 23:49:18 +0000801{
Eric Andersenf361ac22000-12-12 23:45:36 +0000802 char user[9],buf[255],*s;
Eric Andersen09acc062001-01-04 11:10:38 +0000803 char prompt[3];
804 char prompt_str[BUFSIZ];
805
806 /* Set up the prompt */
807 if (state == 0) {
808 /* get User Name and setup prompt */
809 strcpy(prompt,( geteuid() != 0 ) ? "$ ":"# ");
810 my_getpwuid(user, geteuid());
811
812 /* get HostName */
813 gethostname(buf, 255);
814 s = strchr(buf, '.');
815 if (s) {
816 *s = 0;
817 }
818 } else {
819 strcpy(prompt,"> ");
820 }
821
822 if (state == 0) {
823 snprintf(prompt_str, BUFSIZ-1, "[%s@%s %s]%s", user, buf,
824 get_last_path_component(cwd), prompt);
825 } else {
826 sprintf(prompt_str, "%s", prompt);
827 }
828 return(strdup(prompt_str)); /* Must free this memory */
829}
830
Eric Andersen22332fd2001-01-30 23:40:39 +0000831#endif
832
Eric Andersen09acc062001-01-04 11:10:38 +0000833static int get_command(FILE * source, char *command)
834{
835 char *prompt_str;
Eric Andersen8ea28be2001-01-05 20:58:22 +0000836
Eric Andersen1c314ad2000-06-28 16:56:25 +0000837 if (source == NULL) {
838 if (local_pending_command) {
839 /* a command specified (-c option): return it & mark it done */
840 strcpy(command, local_pending_command);
841 free(local_pending_command);
842 local_pending_command = NULL;
843 return 0;
844 }
845 return 1;
846 }
847
Erik Andersen161220c2000-03-16 08:12:48 +0000848 if (source == stdin) {
Matt Kraaidefcd5e2001-01-05 02:53:11 +0000849 prompt_str = setup_prompt_string(shell_context);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000850
Erik Andersend75af992000-03-16 08:09:09 +0000851#ifdef BB_FEATURE_SH_COMMAND_EDITING
Eric Andersen501c88b2000-07-28 15:14:45 +0000852 /*
853 ** enable command line editing only while a command line
854 ** is actually being read; otherwise, we'll end up bequeathing
855 ** atexit() handlers and other unwanted stuff to our
856 ** child processes (rob@sysgo.de)
857 */
Eric Andersen86349772000-12-18 20:25:50 +0000858 cmdedit_read_input(prompt_str, command);
Eric Andersen501c88b2000-07-28 15:14:45 +0000859 cmdedit_terminate();
Eric Andersen6faae7d2001-02-16 20:09:17 +0000860 free(prompt_str);
Erik Andersen161220c2000-03-16 08:12:48 +0000861 return 0;
Erik Andersenc7c634b2000-03-19 05:28:55 +0000862#else
Eric Andersen8ea28be2001-01-05 20:58:22 +0000863 fputs(prompt_str, stdout);
864 free(prompt_str);
Erik Andersend75af992000-03-16 08:09:09 +0000865#endif
Erik Andersen161220c2000-03-16 08:12:48 +0000866 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000867
Erik Andersen161220c2000-03-16 08:12:48 +0000868 if (!fgets(command, BUFSIZ - 2, source)) {
869 if (source == stdin)
870 printf("\n");
871 return 1;
872 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000873
Erik Andersen161220c2000-03-16 08:12:48 +0000874 /* remove trailing newline */
875 command[strlen(command) - 1] = '\0';
Erik Andersen3522eb12000-03-12 23:49:18 +0000876
Erik Andersen161220c2000-03-16 08:12:48 +0000877 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000878}
879
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000880#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000881static char* itoa(register int i)
882{
Eric Andersenb558e762000-11-30 22:43:16 +0000883 static char a[7]; /* Max 7 ints */
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000884 register char *b = a + sizeof(a) - 1;
885 int sign = (i < 0);
886
887 if (sign)
888 i = -i;
889 *b = 0;
890 do
891 {
892 *--b = '0' + (i % 10);
893 i /= 10;
894 }
895 while (i);
896 if (sign)
897 *--b = '-';
898 return b;
899}
900#endif
901
Eric Andersen86349772000-12-18 20:25:50 +0000902static void expand_argument(struct child_prog *prog, int *argcPtr,
903 int *argv_alloced_ptr)
Erik Andersen3522eb12000-03-12 23:49:18 +0000904{
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000905 int argc_l = *argcPtr;
Eric Andersen86349772000-12-18 20:25:50 +0000906 int argv_alloced = *argv_alloced_ptr;
Erik Andersen161220c2000-03-16 08:12:48 +0000907 int rc;
908 int flags;
909 int i;
Eric Andersenb54833c2000-07-03 23:56:26 +0000910 char *src, *dst, *var;
Erik Andersen3522eb12000-03-12 23:49:18 +0000911
Eric Andersen86349772000-12-18 20:25:50 +0000912 if (argc_l > 1) { /* cmd->glob_result is already initialized */
Erik Andersen161220c2000-03-16 08:12:48 +0000913 flags = GLOB_APPEND;
Eric Andersen86349772000-12-18 20:25:50 +0000914 i = prog->glob_result.gl_pathc;
Erik Andersen161220c2000-03-16 08:12:48 +0000915 } else {
Eric Andersen86349772000-12-18 20:25:50 +0000916 prog->free_glob = 1;
Erik Andersen161220c2000-03-16 08:12:48 +0000917 flags = 0;
918 i = 0;
Erik Andersend75af992000-03-16 08:09:09 +0000919 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000920#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersencaeeb362001-02-20 06:38:44 +0000921 /* do shell variable substitution */
922 src = prog->argv[argc_l - 1];
923 while((dst = strchr(src,'$')) != NULL){
924 if (!(var = getenv(dst + 1))) {
925 switch(*(dst+1)) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000926 case '?':
Eric Andersencaeeb362001-02-20 06:38:44 +0000927 var = itoa(last_return_code);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000928 break;
929 case '$':
Eric Andersencaeeb362001-02-20 06:38:44 +0000930 var = itoa(getpid());
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000931 break;
932 case '#':
Eric Andersencaeeb362001-02-20 06:38:44 +0000933 var = itoa(argc-1);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000934 break;
935 case '!':
Eric Andersen86349772000-12-18 20:25:50 +0000936 if (last_bg_pid==-1)
Eric Andersencaeeb362001-02-20 06:38:44 +0000937 *(var)='\0';
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000938 else
Eric Andersencaeeb362001-02-20 06:38:44 +0000939 var = itoa(last_bg_pid);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000940 break;
941 case '0':case '1':case '2':case '3':case '4':
942 case '5':case '6':case '7':case '8':case '9':
943 {
Eric Andersencaeeb362001-02-20 06:38:44 +0000944 int index=*(dst + 1)-48;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000945 if (index >= argc) {
Eric Andersencaeeb362001-02-20 06:38:44 +0000946 var='\0';
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000947 } else {
Eric Andersencaeeb362001-02-20 06:38:44 +0000948 var = argv[index];
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000949 }
950 }
951 break;
952 }
953 }
Eric Andersencaeeb362001-02-20 06:38:44 +0000954 if (var) {
955 int offset = dst-src;
956#warning I have a memory leak which needs to be plugged somehow
957 src = (char*)xmalloc(strlen(src)-strlen(dst)+strlen(var)+1);
958 strncpy(src, prog->argv[argc_l -1], offset);
959 safe_strncpy(src+offset, var, strlen(var)+1);
960 /* If there are any remaining $ variables in the src string, put them back */
961 if ((dst = strchr(prog->argv[argc_l -1]+offset+1,'$')) != NULL) {
962 offset=strlen(src);
963 safe_strncpy(src+strlen(src), dst, strlen(dst)+1);
964 }
965 prog->argv[argc_l -1] = src;
966 } else {
967 memset(dst, 0, strlen(src)-strlen(dst));
968 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000969 }
Eric Andersencaeeb362001-02-20 06:38:44 +0000970#endif
Erik Andersen3522eb12000-03-12 23:49:18 +0000971
Eric Andersen46f0beb2000-11-14 21:59:22 +0000972 if (strpbrk(prog->argv[argc_l - 1],"*[]?")!= NULL){
Eric Andersen86349772000-12-18 20:25:50 +0000973 rc = glob(prog->argv[argc_l - 1], flags, NULL, &prog->glob_result);
Eric Andersen46f0beb2000-11-14 21:59:22 +0000974 if (rc == GLOB_NOSPACE) {
Matt Kraaidd19c692001-01-31 19:00:21 +0000975 error_msg("out of space during glob operation");
Eric Andersen46f0beb2000-11-14 21:59:22 +0000976 return;
977 } else if (rc == GLOB_NOMATCH ||
Eric Andersen86349772000-12-18 20:25:50 +0000978 (!rc && (prog->glob_result.gl_pathc - i) == 1 &&
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000979 strcmp(prog->argv[argc_l - 1],
Eric Andersen86349772000-12-18 20:25:50 +0000980 prog->glob_result.gl_pathv[i]) == 0)) {
Eric Andersen46f0beb2000-11-14 21:59:22 +0000981 /* we need to remove whatever \ quoting is still present */
982 src = dst = prog->argv[argc_l - 1];
983 while (*src) {
Eric Andersen8c2d3f42000-11-30 00:03:57 +0000984 if (*src == '\\') {
985 src++;
986 *dst++ = process_escape_sequence(&src);
987 } else {
Eric Andersen46f0beb2000-11-14 21:59:22 +0000988 *dst++ = *src;
Eric Andersen8c2d3f42000-11-30 00:03:57 +0000989 src++;
990 }
Eric Andersen46f0beb2000-11-14 21:59:22 +0000991 }
992 *dst = '\0';
993 } else if (!rc) {
Eric Andersen86349772000-12-18 20:25:50 +0000994 argv_alloced += (prog->glob_result.gl_pathc - i);
995 prog->argv = xrealloc(prog->argv, argv_alloced * sizeof(*prog->argv));
996 memcpy(prog->argv + (argc_l - 1), prog->glob_result.gl_pathv + i,
997 sizeof(*(prog->argv)) * (prog->glob_result.gl_pathc - i));
998 argc_l += (prog->glob_result.gl_pathc - i - 1);
Erik Andersen161220c2000-03-16 08:12:48 +0000999 }
Eric Andersen46f0beb2000-11-14 21:59:22 +00001000 }else{
1001 src = dst = prog->argv[argc_l - 1];
1002 while (*src) {
Eric Andersen8c2d3f42000-11-30 00:03:57 +00001003 if (*src == '\\') {
1004 src++;
1005 *dst++ = process_escape_sequence(&src);
1006 } else {
Eric Andersen46f0beb2000-11-14 21:59:22 +00001007 *dst++ = *src;
Eric Andersen8c2d3f42000-11-30 00:03:57 +00001008 src++;
1009 }
Eric Andersen46f0beb2000-11-14 21:59:22 +00001010 }
1011 *dst = '\0';
Eric Andersen8c2d3f42000-11-30 00:03:57 +00001012
Eric Andersen86349772000-12-18 20:25:50 +00001013 prog->glob_result.gl_pathc=0;
Eric Andersen46f0beb2000-11-14 21:59:22 +00001014 if (flags==0)
Eric Andersen86349772000-12-18 20:25:50 +00001015 prog->glob_result.gl_pathv=NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001016 }
Eric Andersen86349772000-12-18 20:25:50 +00001017 *argv_alloced_ptr = argv_alloced;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001018 *argcPtr = argc_l;
Erik Andersen3522eb12000-03-12 23:49:18 +00001019}
1020
Eric Andersen86349772000-12-18 20:25:50 +00001021/* Return cmd->num_progs as 0 if no command is present (e.g. an empty
1022 line). If a valid command is found, command_ptr is set to point to
Erik Andersen3522eb12000-03-12 23:49:18 +00001023 the beginning of the next command (if the original command had more
1024 then one job associated with it) or NULL if no more commands are
1025 present. */
Eric Andersen86349772000-12-18 20:25:50 +00001026static int parse_command(char **command_ptr, struct job *job, int *inbg)
Erik Andersen3522eb12000-03-12 23:49:18 +00001027{
Erik Andersen161220c2000-03-16 08:12:48 +00001028 char *command;
Eric Andersen86349772000-12-18 20:25:50 +00001029 char *return_command = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001030 char *src, *buf, *chptr;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001031 int argc_l = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001032 int done = 0;
Eric Andersen86349772000-12-18 20:25:50 +00001033 int argv_alloced;
Erik Andersen161220c2000-03-16 08:12:48 +00001034 int i;
1035 char quote = '\0';
1036 int count;
Eric Andersen86349772000-12-18 20:25:50 +00001037 struct child_prog *prog;
Erik Andersen3522eb12000-03-12 23:49:18 +00001038
Erik Andersen161220c2000-03-16 08:12:48 +00001039 /* skip leading white space */
Eric Andersen86349772000-12-18 20:25:50 +00001040 while (**command_ptr && isspace(**command_ptr))
1041 (*command_ptr)++;
Erik Andersen3522eb12000-03-12 23:49:18 +00001042
Erik Andersen161220c2000-03-16 08:12:48 +00001043 /* this handles empty lines or leading '#' characters */
Eric Andersen86349772000-12-18 20:25:50 +00001044 if (!**command_ptr || (**command_ptr == '#')) {
1045 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001046 return 0;
1047 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001048
Eric Andersen86349772000-12-18 20:25:50 +00001049 *inbg = 0;
1050 job->num_progs = 1;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001051 job->progs = xmalloc(sizeof(*job->progs));
Erik Andersen3522eb12000-03-12 23:49:18 +00001052
Erik Andersen161220c2000-03-16 08:12:48 +00001053 /* We set the argv elements to point inside of this string. The
Eric Andersen86349772000-12-18 20:25:50 +00001054 memory is freed by free_job(). Allocate twice the original
Eric Andersenb54833c2000-07-03 23:56:26 +00001055 length in case we need to quote every single character.
Erik Andersen3522eb12000-03-12 23:49:18 +00001056
Erik Andersen161220c2000-03-16 08:12:48 +00001057 Getting clean memory relieves us of the task of NULL
1058 terminating things and makes the rest of this look a bit
1059 cleaner (though it is, admittedly, a tad less efficient) */
Eric Andersen86349772000-12-18 20:25:50 +00001060 job->cmdbuf = command = xcalloc(2*strlen(*command_ptr) + 1, sizeof(char));
Erik Andersen161220c2000-03-16 08:12:48 +00001061 job->text = NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +00001062
Erik Andersen161220c2000-03-16 08:12:48 +00001063 prog = job->progs;
Eric Andersen86349772000-12-18 20:25:50 +00001064 prog->num_redirects = 0;
1065 prog->redirects = NULL;
1066 prog->free_glob = 0;
1067 prog->is_stopped = 0;
1068 prog->family = job;
Erik Andersen3522eb12000-03-12 23:49:18 +00001069
Eric Andersen86349772000-12-18 20:25:50 +00001070 argv_alloced = 5;
1071 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
1072 prog->argv[0] = job->cmdbuf;
Erik Andersen3522eb12000-03-12 23:49:18 +00001073
Erik Andersen161220c2000-03-16 08:12:48 +00001074 buf = command;
Eric Andersen86349772000-12-18 20:25:50 +00001075 src = *command_ptr;
Erik Andersen161220c2000-03-16 08:12:48 +00001076 while (*src && !done) {
1077 if (quote == *src) {
1078 quote = '\0';
1079 } else if (quote) {
1080 if (*src == '\\') {
1081 src++;
1082 if (!*src) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001083 error_msg("character expected after \\");
Eric Andersen86349772000-12-18 20:25:50 +00001084 free_job(job);
Erik Andersen161220c2000-03-16 08:12:48 +00001085 return 1;
1086 }
1087
1088 /* in shell, "\'" should yield \' */
Eric Andersenb2356f62000-12-11 19:14:40 +00001089 if (*src != quote) {
Erik Andersen161220c2000-03-16 08:12:48 +00001090 *buf++ = '\\';
Eric Andersenb2356f62000-12-11 19:14:40 +00001091 *buf++ = '\\';
1092 }
Erik Andersen161220c2000-03-16 08:12:48 +00001093 } else if (*src == '*' || *src == '?' || *src == '[' ||
1094 *src == ']') *buf++ = '\\';
1095 *buf++ = *src;
1096 } else if (isspace(*src)) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001097 if (*prog->argv[argc_l]) {
1098 buf++, argc_l++;
Erik Andersen161220c2000-03-16 08:12:48 +00001099 /* +1 here leaves room for the NULL which ends argv */
Eric Andersen86349772000-12-18 20:25:50 +00001100 if ((argc_l + 1) == argv_alloced) {
1101 argv_alloced += 5;
Matt Kraaib8907522000-09-13 02:08:21 +00001102 prog->argv = xrealloc(prog->argv,
1103 sizeof(*prog->argv) *
Eric Andersen86349772000-12-18 20:25:50 +00001104 argv_alloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001105 }
Eric Andersen86349772000-12-18 20:25:50 +00001106 expand_argument(prog, &argc_l, &argv_alloced);
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001107 prog->argv[argc_l] = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001108 }
1109 } else
1110 switch (*src) {
1111 case '"':
1112 case '\'':
1113 quote = *src;
1114 break;
1115
1116 case '#': /* comment */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001117 if (*(src-1)== '$')
1118 *buf++ = *src;
1119 else
1120 done = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001121 break;
1122
Eric Andersen86349772000-12-18 20:25:50 +00001123 case '>': /* redirects */
Erik Andersen161220c2000-03-16 08:12:48 +00001124 case '<':
Eric Andersen86349772000-12-18 20:25:50 +00001125 i = prog->num_redirects++;
1126 prog->redirects = xrealloc(prog->redirects,
1127 sizeof(*prog->redirects) *
Matt Kraaib8907522000-09-13 02:08:21 +00001128 (i + 1));
Erik Andersen161220c2000-03-16 08:12:48 +00001129
Eric Andersen86349772000-12-18 20:25:50 +00001130 prog->redirects[i].fd = -1;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001131 if (buf != prog->argv[argc_l]) {
Erik Andersen161220c2000-03-16 08:12:48 +00001132 /* the stuff before this character may be the file number
1133 being redirected */
Eric Andersen86349772000-12-18 20:25:50 +00001134 prog->redirects[i].fd =
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001135 strtol(prog->argv[argc_l], &chptr, 10);
Erik Andersen161220c2000-03-16 08:12:48 +00001136
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001137 if (*chptr && *prog->argv[argc_l]) {
1138 buf++, argc_l++;
Eric Andersen86349772000-12-18 20:25:50 +00001139 expand_argument(prog, &argc_l, &argv_alloced);
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001140 prog->argv[argc_l] = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001141 }
1142 }
1143
Eric Andersen86349772000-12-18 20:25:50 +00001144 if (prog->redirects[i].fd == -1) {
Erik Andersen161220c2000-03-16 08:12:48 +00001145 if (*src == '>')
Eric Andersen86349772000-12-18 20:25:50 +00001146 prog->redirects[i].fd = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001147 else
Eric Andersen86349772000-12-18 20:25:50 +00001148 prog->redirects[i].fd = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001149 }
1150
1151 if (*src++ == '>') {
1152 if (*src == '>')
Eric Andersen86349772000-12-18 20:25:50 +00001153 prog->redirects[i].type =
Erik Andersen161220c2000-03-16 08:12:48 +00001154 REDIRECT_APPEND, src++;
1155 else
Eric Andersen86349772000-12-18 20:25:50 +00001156 prog->redirects[i].type = REDIRECT_OVERWRITE;
Erik Andersen161220c2000-03-16 08:12:48 +00001157 } else {
Eric Andersen86349772000-12-18 20:25:50 +00001158 prog->redirects[i].type = REDIRECT_INPUT;
Erik Andersen161220c2000-03-16 08:12:48 +00001159 }
1160
1161 /* This isn't POSIX sh compliant. Oh well. */
1162 chptr = src;
1163 while (isspace(*chptr))
1164 chptr++;
1165
1166 if (!*chptr) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001167 error_msg("file name expected after %c", *src);
Eric Andersen86349772000-12-18 20:25:50 +00001168 free_job(job);
1169 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001170 return 1;
1171 }
1172
Eric Andersen86349772000-12-18 20:25:50 +00001173 prog->redirects[i].filename = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001174 while (*chptr && !isspace(*chptr))
1175 *buf++ = *chptr++;
1176
1177 src = chptr - 1; /* we src++ later */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001178 prog->argv[argc_l] = ++buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001179 break;
1180
1181 case '|': /* pipe */
1182 /* finish this command */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001183 if (*prog->argv[argc_l])
1184 argc_l++;
1185 if (!argc_l) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001186 error_msg("empty command in pipe");
Eric Andersen86349772000-12-18 20:25:50 +00001187 free_job(job);
1188 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001189 return 1;
1190 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001191 prog->argv[argc_l] = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001192
1193 /* and start the next */
Eric Andersen86349772000-12-18 20:25:50 +00001194 job->num_progs++;
Matt Kraaib8907522000-09-13 02:08:21 +00001195 job->progs = xrealloc(job->progs,
Eric Andersen86349772000-12-18 20:25:50 +00001196 sizeof(*job->progs) * job->num_progs);
1197 prog = job->progs + (job->num_progs - 1);
1198 prog->num_redirects = 0;
1199 prog->redirects = NULL;
1200 prog->free_glob = 0;
1201 prog->is_stopped = 0;
1202 prog->family = job;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001203 argc_l = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001204
Eric Andersen86349772000-12-18 20:25:50 +00001205 argv_alloced = 5;
1206 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001207 prog->argv[0] = ++buf;
1208
1209 src++;
1210 while (*src && isspace(*src))
1211 src++;
1212
1213 if (!*src) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001214 error_msg("empty command in pipe");
Eric Andersen86349772000-12-18 20:25:50 +00001215 free_job(job);
1216 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001217 return 1;
1218 }
1219 src--; /* we'll ++ it at the end of the loop */
1220
1221 break;
1222
1223 case '&': /* background */
Eric Andersen86349772000-12-18 20:25:50 +00001224 *inbg = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001225 case ';': /* multiple commands */
1226 done = 1;
Eric Andersen86349772000-12-18 20:25:50 +00001227 return_command = *command_ptr + (src - *command_ptr) + 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001228 break;
1229
Eric Andersena1d187a2000-07-17 19:14:41 +00001230#ifdef BB_FEATURE_SH_BACKTICKS
Eric Andersenec10b9d2000-07-14 01:13:11 +00001231 case '`':
1232 /* Exec a backtick-ed command */
Eric Andersen8ea28be2001-01-05 20:58:22 +00001233 /* Besides any previous brokenness, I have not
1234 * updated backtick handling for close_me support.
1235 * I don't know if it needs it or not. -- LRD */
Eric Andersenec10b9d2000-07-14 01:13:11 +00001236 {
Eric Andersena1d187a2000-07-17 19:14:41 +00001237 char* charptr1=NULL, *charptr2;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001238 char* ptr=NULL;
Eric Andersen86349772000-12-18 20:25:50 +00001239 struct job *newjob;
1240 struct jobset njob_list = { NULL, NULL };
Eric Andersena1d187a2000-07-17 19:14:41 +00001241 int pipefd[2];
1242 int size;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001243
1244 ptr=strchr(++src, '`');
1245 if (ptr==NULL) {
1246 fprintf(stderr, "Unmatched '`' in command\n");
Eric Andersen86349772000-12-18 20:25:50 +00001247 free_job(job);
Eric Andersenec10b9d2000-07-14 01:13:11 +00001248 return 1;
1249 }
1250
Eric Andersena1d187a2000-07-17 19:14:41 +00001251 /* Make some space to hold just the backticked command */
Eric Andersen6efc48c2000-07-18 08:16:39 +00001252 charptr1 = charptr2 = xmalloc(1+ptr-src);
Matt Kraai0b2da462000-09-19 06:46:44 +00001253 memcpy(charptr1, src, ptr-src);
1254 charptr1[ptr-src] = '\0';
Eric Andersen86349772000-12-18 20:25:50 +00001255 newjob = xmalloc(sizeof(struct job));
1256 newjob->job_list = &njob_list;
Eric Andersena1d187a2000-07-17 19:14:41 +00001257 /* Now parse and run the backticked command */
Eric Andersen86349772000-12-18 20:25:50 +00001258 if (!parse_command(&charptr1, newjob, inbg)
1259 && newjob->num_progs) {
Eric Andersena1d187a2000-07-17 19:14:41 +00001260 pipe(pipefd);
Eric Andersen86349772000-12-18 20:25:50 +00001261 run_command(newjob, 0, pipefd);
Eric Andersenec10b9d2000-07-14 01:13:11 +00001262 }
Eric Andersen86349772000-12-18 20:25:50 +00001263 checkjobs(job->job_list);
1264 free_job(newjob); /* doesn't actually free newjob,
1265 looks like a memory leak */
Eric Andersen6efc48c2000-07-18 08:16:39 +00001266 free(charptr2);
1267
1268 /* Make a copy of any stuff left over in the command
1269 * line after the second backtick */
1270 charptr2 = xmalloc(strlen(ptr)+1);
1271 memcpy(charptr2, ptr+1, strlen(ptr));
1272
Eric Andersenec10b9d2000-07-14 01:13:11 +00001273
Eric Andersena1d187a2000-07-17 19:14:41 +00001274 /* Copy the output from the backtick-ed command into the
1275 * command line, making extra room as needed */
1276 --src;
1277 charptr1 = xmalloc(BUFSIZ);
Mark Whitleyf57c9442000-12-07 19:56:48 +00001278 while ( (size=full_read(pipefd[0], charptr1, BUFSIZ-1)) >0) {
Eric Andersen86349772000-12-18 20:25:50 +00001279 int newsize=src - *command_ptr + size + 1 + strlen(charptr2);
1280 if (newsize > BUFSIZ) {
1281 *command_ptr=xrealloc(*command_ptr, newsize);
Eric Andersena1d187a2000-07-17 19:14:41 +00001282 }
1283 memcpy(src, charptr1, size);
1284 src+=size;
1285 }
1286 free(charptr1);
1287 close(pipefd[0]);
1288 if (*(src-1)=='\n')
1289 --src;
1290
Eric Andersen86349772000-12-18 20:25:50 +00001291 /* Now paste into the *command_ptr all the stuff
Eric Andersena1d187a2000-07-17 19:14:41 +00001292 * leftover after the second backtick */
Matt Kraaicbbe4d62000-09-14 00:26:50 +00001293 memcpy(src, charptr2, strlen(charptr2)+1);
Eric Andersena1d187a2000-07-17 19:14:41 +00001294 free(charptr2);
1295
Eric Andersen86349772000-12-18 20:25:50 +00001296 /* Now recursively call parse_command to deal with the new
Eric Andersena1d187a2000-07-17 19:14:41 +00001297 * and improved version of the command line with the backtick
1298 * results expanded in place... */
Eric Andersen86349772000-12-18 20:25:50 +00001299 {
1300 struct jobset *jl=job->job_list;
1301 free_job(job);
1302 job->job_list = jl;
1303 }
1304 return(parse_command(command_ptr, job, inbg));
Eric Andersenec10b9d2000-07-14 01:13:11 +00001305 }
1306 break;
Eric Andersena1d187a2000-07-17 19:14:41 +00001307#endif // BB_FEATURE_SH_BACKTICKS
Matt Kraai131241f2000-09-14 00:43:20 +00001308
1309 case '\\':
1310 src++;
1311 if (!*src) {
Eric Andersen86349772000-12-18 20:25:50 +00001312/* This is currently a little broken... */
1313#ifdef HANDLE_CONTINUATION_CHARS
1314 /* They fed us a continuation char, so continue reading stuff
1315 * on the next line, then tack that onto the end of the current
1316 * command */
1317 char *command;
1318 int newsize;
1319 printf("erik: found a continue char at EOL...\n");
1320 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1321 if (get_command(input, command)) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001322 error_msg("character expected after \\");
Eric Andersen86349772000-12-18 20:25:50 +00001323 free(command);
1324 free_job(job);
1325 return 1;
1326 }
1327 newsize = strlen(*command_ptr) + strlen(command) + 2;
1328 if (newsize > BUFSIZ) {
1329 printf("erik: doing realloc\n");
1330 *command_ptr=xrealloc(*command_ptr, newsize);
1331 }
1332 printf("erik: A: *command_ptr='%s'\n", *command_ptr);
1333 memcpy(--src, command, strlen(command));
1334 printf("erik: B: *command_ptr='%s'\n", *command_ptr);
1335 free(command);
1336 break;
1337#else
Matt Kraaidd19c692001-01-31 19:00:21 +00001338 error_msg("character expected after \\");
Eric Andersen86349772000-12-18 20:25:50 +00001339 free(command);
1340 free_job(job);
Matt Kraai131241f2000-09-14 00:43:20 +00001341 return 1;
Eric Andersen86349772000-12-18 20:25:50 +00001342#endif
Matt Kraai131241f2000-09-14 00:43:20 +00001343 }
1344 if (*src == '*' || *src == '[' || *src == ']'
1345 || *src == '?') *buf++ = '\\';
1346 /* fallthrough */
Erik Andersen161220c2000-03-16 08:12:48 +00001347 default:
1348 *buf++ = *src;
1349 }
1350
Erik Andersend75af992000-03-16 08:09:09 +00001351 src++;
Erik Andersen161220c2000-03-16 08:12:48 +00001352 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001353
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001354 if (*prog->argv[argc_l]) {
1355 argc_l++;
Eric Andersen86349772000-12-18 20:25:50 +00001356 expand_argument(prog, &argc_l, &argv_alloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001357 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001358 if (!argc_l) {
Eric Andersen86349772000-12-18 20:25:50 +00001359 free_job(job);
Erik Andersen161220c2000-03-16 08:12:48 +00001360 return 0;
1361 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001362 prog->argv[argc_l] = NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +00001363
Eric Andersen86349772000-12-18 20:25:50 +00001364 if (!return_command) {
1365 job->text = xmalloc(strlen(*command_ptr) + 1);
1366 strcpy(job->text, *command_ptr);
Erik Andersen161220c2000-03-16 08:12:48 +00001367 } else {
1368 /* This leaves any trailing spaces, which is a bit sloppy */
Eric Andersen86349772000-12-18 20:25:50 +00001369 count = return_command - *command_ptr;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001370 job->text = xmalloc(count + 1);
Eric Andersen86349772000-12-18 20:25:50 +00001371 strncpy(job->text, *command_ptr, count);
Erik Andersen161220c2000-03-16 08:12:48 +00001372 job->text[count] = '\0';
1373 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001374
Eric Andersen86349772000-12-18 20:25:50 +00001375 *command_ptr = return_command;
Eric Andersen46f0beb2000-11-14 21:59:22 +00001376
Erik Andersend75af992000-03-16 08:09:09 +00001377 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001378}
1379
Eric Andersen86349772000-12-18 20:25:50 +00001380/* Run the child_prog, no matter what kind of command it uses.
1381 */
1382static int pseudo_exec(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +00001383{
Eric Andersen86349772000-12-18 20:25:50 +00001384 struct built_in_command *x;
Eric Andersenb54833c2000-07-03 23:56:26 +00001385#ifdef BB_FEATURE_SH_STANDALONE_SHELL
Eric Andersenaf4ac772001-02-01 22:43:49 +00001386 char *name;
Erik Andersenbcd61772000-05-13 06:33:19 +00001387#endif
Erik Andersen3522eb12000-03-12 23:49:18 +00001388
Eric Andersene9f07fb2000-12-21 18:31:36 +00001389 /* Check if the command matches any of the non-forking builtins.
1390 * Depending on context, this might be redundant. But it's
1391 * easier to waste a few CPU cycles than it is to figure out
1392 * if this is one of those cases.
Eric Andersen86349772000-12-18 20:25:50 +00001393 */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001394 for (x = bltins; x->cmd; x++) {
1395 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1396 exit(x->function(child));
1397 }
1398 }
1399
1400 /* Check if the command matches any of the forking builtins. */
Eric Andersen86349772000-12-18 20:25:50 +00001401 for (x = bltins_forking; x->cmd; x++) {
1402 if (strcmp(child->argv[0], x->cmd) == 0) {
1403 applet_name=x->cmd;
1404 exit (x->function(child));
1405 }
1406 }
1407#ifdef BB_FEATURE_SH_STANDALONE_SHELL
1408 /* Check if the command matches any busybox internal
1409 * commands ("applets") here. Following discussions from
1410 * November 2000 on busybox@opensource.lineo.com, don't use
1411 * get_last_path_component(). This way explicit (with
1412 * slashes) filenames will never be interpreted as an
1413 * applet, just like with builtins. This way the user can
1414 * override an applet with an explicit filename reference.
1415 * The only downside to this change is that an explicit
1416 * /bin/foo invocation will fork and exec /bin/foo, even if
1417 * /bin/foo is a symlink to busybox.
1418 */
Matt Kraaif2cc2762001-02-01 19:21:20 +00001419 name = child->argv[0];
Eric Andersen86349772000-12-18 20:25:50 +00001420
1421#ifdef BB_FEATURE_SH_APPLETS_ALWAYS_WIN
1422 /* If you enable BB_FEATURE_SH_APPLETS_ALWAYS_WIN, then
1423 * if you run /bin/cat, it will use BusyBox cat even if
1424 * /bin/cat exists on the filesystem and is _not_ busybox.
1425 * Some systems want this, others do not. Choose wisely. :-)
1426 */
Matt Kraaif2cc2762001-02-01 19:21:20 +00001427 name = get_last_path_component(name);
Eric Andersen86349772000-12-18 20:25:50 +00001428#endif
1429
Eric Andersen67991cf2001-02-14 21:23:06 +00001430 {
1431 char** argv=child->argv;
1432 int argc_l;
1433 for(argc_l=0;*argv!=NULL; argv++, argc_l++);
1434 optind = 1;
1435 run_applet_by_name(name, argc_l, child->argv);
Eric Andersen86349772000-12-18 20:25:50 +00001436 }
1437#endif
1438
1439 execvp(child->argv[0], child->argv);
Eric Andersen8ea28be2001-01-05 20:58:22 +00001440 perror_msg_and_die("%s", child->argv[0]);
Eric Andersen86349772000-12-18 20:25:50 +00001441}
1442
1443static void insert_job(struct job *newjob, int inbg)
1444{
1445 struct job *thejob;
1446 struct jobset *job_list=newjob->job_list;
1447
1448 /* find the ID for thejob to use */
1449 newjob->jobid = 1;
1450 for (thejob = job_list->head; thejob; thejob = thejob->next)
1451 if (thejob->jobid >= newjob->jobid)
1452 newjob->jobid = thejob->jobid + 1;
1453
1454 /* add thejob to the list of running jobs */
1455 if (!job_list->head) {
1456 thejob = job_list->head = xmalloc(sizeof(*thejob));
1457 } else {
1458 for (thejob = job_list->head; thejob->next; thejob = thejob->next) /* nothing */;
1459 thejob->next = xmalloc(sizeof(*thejob));
1460 thejob = thejob->next;
1461 }
1462
1463 *thejob = *newjob; /* physically copy the struct job */
1464 thejob->next = NULL;
1465 thejob->running_progs = thejob->num_progs;
1466 thejob->stopped_progs = 0;
1467
1468 if (inbg) {
1469 /* we don't wait for background thejobs to return -- append it
1470 to the list of backgrounded thejobs and leave it alone */
1471 printf("[%d] %d\n", thejob->jobid,
1472 newjob->progs[newjob->num_progs - 1].pid);
1473#ifdef BB_FEATURE_SH_ENVIRONMENT
1474 last_bg_pid=newjob->progs[newjob->num_progs - 1].pid;
1475#endif
1476 } else {
1477 newjob->job_list->fg = thejob;
1478
1479 /* move the new process group into the foreground */
1480 /* suppress messages when run from /linuxrc mag@sysgo.de */
1481 if (tcsetpgrp(0, newjob->pgrp) && errno != ENOTTY)
Matt Kraaia9819b22000-12-22 01:48:07 +00001482 perror_msg("tcsetpgrp");
Eric Andersen86349772000-12-18 20:25:50 +00001483 }
1484}
1485
1486static int run_command(struct job *newjob, int inbg, int outpipe[2])
1487{
1488 /* struct job *thejob; */
1489 int i;
1490 int nextin, nextout;
1491 int pipefds[2]; /* pipefd[0] is for reading */
1492 struct built_in_command *x;
1493 struct child_prog *child;
1494
Eric Andersen6efc48c2000-07-18 08:16:39 +00001495 nextin = 0, nextout = 1;
Eric Andersen86349772000-12-18 20:25:50 +00001496 for (i = 0; i < newjob->num_progs; i++) {
1497 child = & (newjob->progs[i]);
1498
1499 if ((i + 1) < newjob->num_progs) {
1500 if (pipe(pipefds)<0) perror_msg_and_die("pipe");
Erik Andersen161220c2000-03-16 08:12:48 +00001501 nextout = pipefds[1];
1502 } else {
Eric Andersen86349772000-12-18 20:25:50 +00001503 if (outpipe[1]!=-1) {
1504 nextout = outpipe[1];
Eric Andersen6efc48c2000-07-18 08:16:39 +00001505 } else {
1506 nextout = 1;
1507 }
Erik Andersen161220c2000-03-16 08:12:48 +00001508 }
1509
Eric Andersen501c88b2000-07-28 15:14:45 +00001510#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen86349772000-12-18 20:25:50 +00001511 if (show_x_trace==TRUE) {
Eric Andersen501c88b2000-07-28 15:14:45 +00001512 int j;
Eric Andersen86349772000-12-18 20:25:50 +00001513 fputc('+', stderr);
1514 for (j = 0; child->argv[j]; j++) {
1515 fputc(' ', stderr);
1516 fputs(child->argv[j], stderr);
1517 }
1518 fputc('\n', stderr);
Eric Andersen501c88b2000-07-28 15:14:45 +00001519 }
1520#endif
1521
Eric Andersene9f07fb2000-12-21 18:31:36 +00001522 /* Check if the command matches any non-forking builtins,
1523 * but only if this is a simple command.
1524 * Non-forking builtins within pipes have to fork anyway,
1525 * and are handled in pseudo_exec. "echo foo | read bar"
1526 * is doomed to failure, and doesn't work on bash, either.
Eric Andersen86349772000-12-18 20:25:50 +00001527 */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001528 if (newjob->num_progs == 1) {
1529 for (x = bltins; x->cmd; x++) {
1530 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1531 int squirrel[] = {-1, -1, -1};
1532 int rcode;
1533 setup_redirects(child, squirrel);
1534 rcode = x->function(child);
1535 restore_redirects(squirrel);
1536 return rcode;
1537 }
Erik Andersen330fd2b2000-05-19 05:35:19 +00001538 }
1539 }
1540
Eric Andersen86349772000-12-18 20:25:50 +00001541 if (!(child->pid = fork())) {
Erik Andersen161220c2000-03-16 08:12:48 +00001542 signal(SIGTTOU, SIG_DFL);
1543
Eric Andersen8ea28be2001-01-05 20:58:22 +00001544 close_all();
1545
Eric Andersen86349772000-12-18 20:25:50 +00001546 if (outpipe[1]!=-1) {
1547 close(outpipe[0]);
Eric Andersen6efc48c2000-07-18 08:16:39 +00001548 }
1549 if (nextin != 0) {
1550 dup2(nextin, 0);
1551 close(nextin);
1552 }
1553
1554 if (nextout != 1) {
Erik Andersen161220c2000-03-16 08:12:48 +00001555 dup2(nextout, 1);
Eric Andersen86349772000-12-18 20:25:50 +00001556 dup2(nextout, 2); /* Really? */
Erik Andersen161220c2000-03-16 08:12:48 +00001557 close(nextout);
Eric Andersen501c88b2000-07-28 15:14:45 +00001558 close(pipefds[0]);
Erik Andersen161220c2000-03-16 08:12:48 +00001559 }
1560
Eric Andersen86349772000-12-18 20:25:50 +00001561 /* explicit redirects override pipes */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001562 setup_redirects(child,NULL);
Erik Andersen161220c2000-03-16 08:12:48 +00001563
Eric Andersen86349772000-12-18 20:25:50 +00001564 pseudo_exec(child);
Erik Andersen161220c2000-03-16 08:12:48 +00001565 }
Eric Andersen86349772000-12-18 20:25:50 +00001566 if (outpipe[1]!=-1) {
1567 close(outpipe[1]);
Eric Andersena1d187a2000-07-17 19:14:41 +00001568 }
Erik Andersen161220c2000-03-16 08:12:48 +00001569
1570 /* put our child in the process group whose leader is the
1571 first process in this pipe */
Eric Andersen86349772000-12-18 20:25:50 +00001572 setpgid(child->pid, newjob->progs[0].pid);
Erik Andersen161220c2000-03-16 08:12:48 +00001573 if (nextin != 0)
1574 close(nextin);
Eric Andersen6efc48c2000-07-18 08:16:39 +00001575 if (nextout != 1)
Erik Andersen161220c2000-03-16 08:12:48 +00001576 close(nextout);
1577
1578 /* If there isn't another process, nextin is garbage
1579 but it doesn't matter */
1580 nextin = pipefds[0];
1581 }
1582
Eric Andersen86349772000-12-18 20:25:50 +00001583 newjob->pgrp = newjob->progs[0].pid;
Erik Andersen161220c2000-03-16 08:12:48 +00001584
Eric Andersen86349772000-12-18 20:25:50 +00001585 insert_job(newjob, inbg);
Erik Andersen3522eb12000-03-12 23:49:18 +00001586
Erik Andersen161220c2000-03-16 08:12:48 +00001587 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001588}
1589
Erik Andersend75af992000-03-16 08:09:09 +00001590static int busy_loop(FILE * input)
Erik Andersen3522eb12000-03-12 23:49:18 +00001591{
Erik Andersen161220c2000-03-16 08:12:48 +00001592 char *command;
Eric Andersen86349772000-12-18 20:25:50 +00001593 char *next_command = NULL;
1594 struct job newjob;
Eric Andersen1c314ad2000-06-28 16:56:25 +00001595 pid_t parent_pgrp;
Erik Andersen161220c2000-03-16 08:12:48 +00001596 int i;
Eric Andersen86349772000-12-18 20:25:50 +00001597 int inbg;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001598 int status;
Eric Andersen86349772000-12-18 20:25:50 +00001599 newjob.job_list = &job_list;
1600 newjob.job_context = DEFAULT_CONTEXT;
Erik Andersen3522eb12000-03-12 23:49:18 +00001601
Eric Andersen1c314ad2000-06-28 16:56:25 +00001602 /* save current owner of TTY so we can restore it on exit */
1603 parent_pgrp = tcgetpgrp(0);
1604
Matt Kraaib8907522000-09-13 02:08:21 +00001605 command = (char *) xcalloc(BUFSIZ, sizeof(char));
Erik Andersend75af992000-03-16 08:09:09 +00001606
Erik Andersen161220c2000-03-16 08:12:48 +00001607 /* don't pay any attention to this signal; it just confuses
1608 things and isn't really meant for shells anyway */
1609 signal(SIGTTOU, SIG_IGN);
Erik Andersend75af992000-03-16 08:09:09 +00001610
Erik Andersen161220c2000-03-16 08:12:48 +00001611 while (1) {
Eric Andersen86349772000-12-18 20:25:50 +00001612 if (!job_list.fg) {
Erik Andersend75af992000-03-16 08:09:09 +00001613 /* no job is in the foreground */
Erik Andersen3522eb12000-03-12 23:49:18 +00001614
Erik Andersend75af992000-03-16 08:09:09 +00001615 /* see if any background processes have exited */
Eric Andersen86349772000-12-18 20:25:50 +00001616 checkjobs(&job_list);
Erik Andersen3522eb12000-03-12 23:49:18 +00001617
Eric Andersen86349772000-12-18 20:25:50 +00001618 if (!next_command) {
1619 if (get_command(input, command))
Erik Andersen161220c2000-03-16 08:12:48 +00001620 break;
Eric Andersen86349772000-12-18 20:25:50 +00001621 next_command = command;
Erik Andersend75af992000-03-16 08:09:09 +00001622 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001623
Eric Andersen86349772000-12-18 20:25:50 +00001624 if (!parse_command(&next_command, &newjob, &inbg) &&
1625 newjob.num_progs) {
Eric Andersena1d187a2000-07-17 19:14:41 +00001626 int pipefds[2] = {-1,-1};
Eric Andersen86349772000-12-18 20:25:50 +00001627 debug_printf( "job=%p being fed to run_command by busy_loop()'\n", &newjob);
1628 run_command(&newjob, inbg, pipefds);
Eric Andersenfad9c112000-07-25 18:06:52 +00001629 }
1630 else {
Eric Andersena1d187a2000-07-17 19:14:41 +00001631 free(command);
Matt Kraaib8907522000-09-13 02:08:21 +00001632 command = (char *) xcalloc(BUFSIZ, sizeof(char));
Eric Andersen86349772000-12-18 20:25:50 +00001633 next_command = NULL;
Erik Andersend75af992000-03-16 08:09:09 +00001634 }
1635 } else {
1636 /* a job is running in the foreground; wait for it */
1637 i = 0;
Eric Andersen86349772000-12-18 20:25:50 +00001638 while (!job_list.fg->progs[i].pid ||
1639 job_list.fg->progs[i].is_stopped == 1) i++;
Erik Andersen3522eb12000-03-12 23:49:18 +00001640
Eric Andersen8ea28be2001-01-05 20:58:22 +00001641 if (waitpid(job_list.fg->progs[i].pid, &status, WUNTRACED)<0)
1642 perror_msg_and_die("waitpid(%d)",job_list.fg->progs[i].pid);
Erik Andersen3522eb12000-03-12 23:49:18 +00001643
Erik Andersend75af992000-03-16 08:09:09 +00001644 if (WIFEXITED(status) || WIFSIGNALED(status)) {
Erik Andersen161220c2000-03-16 08:12:48 +00001645 /* the child exited */
Eric Andersen86349772000-12-18 20:25:50 +00001646 job_list.fg->running_progs--;
1647 job_list.fg->progs[i].pid = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001648
Eric Andersen501c88b2000-07-28 15:14:45 +00001649#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen86349772000-12-18 20:25:50 +00001650 last_return_code=WEXITSTATUS(status);
Eric Andersen501c88b2000-07-28 15:14:45 +00001651#endif
Eric Andersen86349772000-12-18 20:25:50 +00001652 debug_printf("'%s' exited -- return code %d\n",
1653 job_list.fg->text, last_return_code);
1654 if (!job_list.fg->running_progs) {
Erik Andersen161220c2000-03-16 08:12:48 +00001655 /* child exited */
Eric Andersen86349772000-12-18 20:25:50 +00001656 remove_job(&job_list, job_list.fg);
1657 job_list.fg = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001658 }
Erik Andersend75af992000-03-16 08:09:09 +00001659 } else {
Erik Andersen161220c2000-03-16 08:12:48 +00001660 /* the child was stopped */
Eric Andersen86349772000-12-18 20:25:50 +00001661 job_list.fg->stopped_progs++;
1662 job_list.fg->progs[i].is_stopped = 1;
Erik Andersen3522eb12000-03-12 23:49:18 +00001663
Eric Andersen86349772000-12-18 20:25:50 +00001664 if (job_list.fg->stopped_progs == job_list.fg->running_progs) {
1665 printf("\n" JOB_STATUS_FORMAT, job_list.fg->jobid,
1666 "Stopped", job_list.fg->text);
1667 job_list.fg = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001668 }
Erik Andersend75af992000-03-16 08:09:09 +00001669 }
1670
Eric Andersen86349772000-12-18 20:25:50 +00001671 if (!job_list.fg) {
Erik Andersen161220c2000-03-16 08:12:48 +00001672 /* move the shell to the foreground */
Eric Andersen1c314ad2000-06-28 16:56:25 +00001673 /* suppress messages when run from /linuxrc mag@sysgo.de */
1674 if (tcsetpgrp(0, getpid()) && errno != ENOTTY)
Matt Kraaia9819b22000-12-22 01:48:07 +00001675 perror_msg("tcsetpgrp");
Erik Andersend75af992000-03-16 08:09:09 +00001676 }
1677 }
1678 }
Erik Andersen161220c2000-03-16 08:12:48 +00001679 free(command);
Erik Andersen3522eb12000-03-12 23:49:18 +00001680
Eric Andersen1c314ad2000-06-28 16:56:25 +00001681 /* return controlling TTY back to parent process group before exiting */
1682 if (tcsetpgrp(0, parent_pgrp))
Matt Kraaia9819b22000-12-22 01:48:07 +00001683 perror_msg("tcsetpgrp");
Eric Andersenb54833c2000-07-03 23:56:26 +00001684
1685 /* return exit status if called with "-c" */
1686 if (input == NULL && WIFEXITED(status))
1687 return WEXITSTATUS(status);
1688
Erik Andersen161220c2000-03-16 08:12:48 +00001689 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001690}
1691
1692
Eric Andersenfad9c112000-07-25 18:06:52 +00001693#ifdef BB_FEATURE_CLEAN_UP
1694void free_memory(void)
1695{
Eric Andersenfad9c112000-07-25 18:06:52 +00001696 if (cwd)
1697 free(cwd);
1698 if (local_pending_command)
1699 free(local_pending_command);
1700
Eric Andersen86349772000-12-18 20:25:50 +00001701 if (job_list.fg && !job_list.fg->running_progs) {
1702 remove_job(&job_list, job_list.fg);
Eric Andersenfad9c112000-07-25 18:06:52 +00001703 }
1704}
1705#endif
1706
Eric Andersen6efc48c2000-07-18 08:16:39 +00001707
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001708int shell_main(int argc_l, char **argv_l)
Erik Andersen3522eb12000-03-12 23:49:18 +00001709{
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001710 int opt, interactive=FALSE;
Erik Andersen161220c2000-03-16 08:12:48 +00001711 FILE *input = stdin;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001712 argc = argc_l;
1713 argv = argv_l;
Erik Andersen3522eb12000-03-12 23:49:18 +00001714
Eric Andersenb0970d42001-01-05 19:34:52 +00001715 shell_context = 0;
1716 cwd=NULL;
Mark Whitley6e25f922001-01-26 19:19:23 +00001717#ifdef BB_FEATURE_SH_STANDALONE_SHELL
Eric Andersenb0970d42001-01-05 19:34:52 +00001718 /* These variables need re-initializing when recursing */
1719 local_pending_command = NULL;
1720 job_list.head = NULL;
1721 job_list.fg = NULL;
1722#ifdef BB_FEATURE_SH_ENVIRONMENT
1723 last_bg_pid=-1;
1724 last_return_code=-1;
1725 show_x_trace=FALSE;
1726#endif
1727#endif
Eric Andersen501c88b2000-07-28 15:14:45 +00001728
Eric Andersenb558e762000-11-30 22:43:16 +00001729 if (argv[0] && argv[0][0] == '-') {
Eric Andersen8ea28be2001-01-05 20:58:22 +00001730 FILE *prof_input;
1731 prof_input = fopen("/etc/profile", "r");
1732 if (!prof_input) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001733 printf( "Couldn't open file '/etc/profile'\n");
Eric Andersen8ea28be2001-01-05 20:58:22 +00001734 } else {
1735 int tmp_fd = fileno(prof_input);
1736 mark_open(tmp_fd);
1737 /* Now run the file */
1738 busy_loop(prof_input);
1739 fclose(prof_input);
1740 mark_closed(tmp_fd);
1741 }
Eric Andersenb558e762000-11-30 22:43:16 +00001742 }
Eric Andersen501c88b2000-07-28 15:14:45 +00001743
Eric Andersenf21aa842000-12-08 20:50:30 +00001744 while ((opt = getopt(argc_l, argv_l, "cxi")) > 0) {
Eric Andersen501c88b2000-07-28 15:14:45 +00001745 switch (opt) {
1746 case 'c':
1747 input = NULL;
Matt Kraai6085c722000-09-06 01:46:18 +00001748 if (local_pending_command != 0)
Matt Kraaidd19c692001-01-31 19:00:21 +00001749 error_msg_and_die("multiple -c arguments");
Matt Kraai6085c722000-09-06 01:46:18 +00001750 local_pending_command = xstrdup(argv[optind]);
1751 optind++;
1752 argv = argv+optind;
Eric Andersen501c88b2000-07-28 15:14:45 +00001753 break;
Eric Andersen1428c4f2000-07-28 15:19:30 +00001754#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen501c88b2000-07-28 15:14:45 +00001755 case 'x':
Eric Andersen86349772000-12-18 20:25:50 +00001756 show_x_trace = TRUE;
Eric Andersen501c88b2000-07-28 15:14:45 +00001757 break;
Eric Andersen1428c4f2000-07-28 15:19:30 +00001758#endif
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001759 case 'i':
1760 interactive = TRUE;
1761 break;
Eric Andersen501c88b2000-07-28 15:14:45 +00001762 default:
Eric Andersen67991cf2001-02-14 21:23:06 +00001763 show_usage();
Eric Andersen501c88b2000-07-28 15:14:45 +00001764 }
1765 }
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001766 /* A shell is interactive if the `-i' flag was given, or if all of
1767 * the following conditions are met:
1768 * no -c command
1769 * no arguments remaining or the -s flag given
1770 * standard input is a terminal
1771 * standard output is a terminal
1772 * Refer to Posix.2, the description of the `sh' utility. */
Eric Andersen86349772000-12-18 20:25:50 +00001773 if (argv[optind]==NULL && input==stdin &&
1774 isatty(fileno(stdin)) && isatty(fileno(stdout))) {
1775 interactive=TRUE;
1776 }
1777 if (interactive==TRUE) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001778 //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
Eric Andersen501c88b2000-07-28 15:14:45 +00001779 /* Looks like they want an interactive shell */
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001780 printf( "\n\nBusyBox v%s (%s) Built-in shell (lash)\n", BB_VER, BB_BT);
1781 printf( "Enter 'help' for a list of built-in commands.\n\n");
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001782 } else if (local_pending_command==NULL) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001783 //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
Matt Kraaibbaef662000-09-27 02:43:35 +00001784 input = xfopen(argv[optind], "r");
Eric Andersen8ea28be2001-01-05 20:58:22 +00001785 mark_open(fileno(input)); /* be lazy, never mark this closed */
Eric Andersen501c88b2000-07-28 15:14:45 +00001786 }
1787
Eric Andersen6efc48c2000-07-18 08:16:39 +00001788 /* initialize the cwd -- this is never freed...*/
1789 cwd=(char*)xmalloc(sizeof(char)*MAX_LINE+1);
1790 getcwd(cwd, sizeof(char)*MAX_LINE);
Erik Andersen3522eb12000-03-12 23:49:18 +00001791
Eric Andersenfad9c112000-07-25 18:06:52 +00001792#ifdef BB_FEATURE_CLEAN_UP
1793 atexit(free_memory);
1794#endif
1795
Erik Andersen161220c2000-03-16 08:12:48 +00001796 return (busy_loop(input));
Erik Andersen3522eb12000-03-12 23:49:18 +00001797}