blob: 28015cbb33451bc4f9aea661ab82bd1aac900658 [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
Eric Andersenb3d6e2d2001-03-13 22:57:56 +000042//like any other Bourne shell -- sortof...
Eric Andersene9f07fb2000-12-21 18:31:36 +000043#define BB_FEATURE_SH_IF_EXPRESSIONS
Eric Andersen1e7cea92000-12-06 23:47:38 +000044//
Eric Andersenb3d6e2d2001-03-13 22:57:56 +000045/* This is currently sortof broken, only for the brave... */
46#undef HANDLE_CONTINUATION_CHARS
47//
48/* This would be great -- if wordexp wouldn't strip all quoting
49 * out from the target strings... As is, a parser needs */
50#undef BB_FEATURE_SH_WORDEXP
Eric Andersen86349772000-12-18 20:25:50 +000051//
Eric Andersen1e7cea92000-12-06 23:47:38 +000052//For debugging/development on the shell only...
Eric Andersen501c88b2000-07-28 15:14:45 +000053//#define DEBUG_SHELL
Eric Andersena1d187a2000-07-17 19:14:41 +000054
55
Erik Andersen3522eb12000-03-12 23:49:18 +000056#include <stdio.h>
57#include <stdlib.h>
58#include <ctype.h>
59#include <errno.h>
60#include <fcntl.h>
Erik Andersen3522eb12000-03-12 23:49:18 +000061#include <signal.h>
62#include <string.h>
63#include <sys/ioctl.h>
64#include <sys/wait.h>
65#include <unistd.h>
Eric Andersen501c88b2000-07-28 15:14:45 +000066#include <getopt.h>
Mark Whitley1c6581a2001-03-27 16:35:16 +000067#include <locale.h>
Eric Andersen13d1fa12001-03-08 23:59:45 +000068
Eric Andersen34174472001-03-17 00:20:10 +000069//#define BB_FEATURE_SH_WORDEXP
Eric Andersenb180dd92001-03-09 00:42:46 +000070
Eric Andersen34174472001-03-17 00:20:10 +000071#ifdef BB_FEATURE_SH_WORDEXP
Eric Andersen13d1fa12001-03-08 23:59:45 +000072#include <wordexp.h>
73#define expand_t wordexp_t
74#undef BB_FEATURE_SH_BACKTICKS
75#else
76#include <glob.h>
77#define expand_t glob_t
78#endif
Eric Andersencaeeb362001-02-20 06:38:44 +000079#include "busybox.h"
Erik Andersenf0657d32000-04-12 17:49:52 +000080#include "cmdedit.h"
Erik Andersen3522eb12000-03-12 23:49:18 +000081
Eric Andersen13d1fa12001-03-08 23:59:45 +000082
Mark Whitley59ab0252001-01-23 22:30:04 +000083static const int MAX_LINE = 256; /* size of input buffer for cwd data */
84static const int MAX_READ = 128; /* size of input buffer for `read' builtin */
Erik Andersen3522eb12000-03-12 23:49:18 +000085#define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
86
Erik Andersend75af992000-03-16 08:09:09 +000087
Eric Andersen86349772000-12-18 20:25:50 +000088enum redir_type { REDIRECT_INPUT, REDIRECT_OVERWRITE,
Erik Andersen161220c2000-03-16 08:12:48 +000089 REDIRECT_APPEND
90};
Erik Andersen3522eb12000-03-12 23:49:18 +000091
Eric Andersen86349772000-12-18 20:25:50 +000092static const unsigned int DEFAULT_CONTEXT=0x1;
Eric Andersen6a99aaf2000-07-27 00:15:20 +000093static const unsigned int IF_TRUE_CONTEXT=0x2;
94static const unsigned int IF_FALSE_CONTEXT=0x4;
95static const unsigned int THEN_EXP_CONTEXT=0x8;
96static const unsigned int ELSE_EXP_CONTEXT=0x10;
Eric Andersenfad9c112000-07-25 18:06:52 +000097
Eric Andersen86349772000-12-18 20:25:50 +000098
99struct jobset {
Erik Andersen161220c2000-03-16 08:12:48 +0000100 struct job *head; /* head of list of running jobs */
101 struct job *fg; /* current foreground job */
Erik Andersen3522eb12000-03-12 23:49:18 +0000102};
103
Eric Andersen86349772000-12-18 20:25:50 +0000104struct redir_struct {
105 enum redir_type type; /* type of redirection */
Erik Andersen161220c2000-03-16 08:12:48 +0000106 int fd; /* file descriptor being redirected */
107 char *filename; /* file to redirect fd to */
Erik Andersen3522eb12000-03-12 23:49:18 +0000108};
109
Eric Andersen86349772000-12-18 20:25:50 +0000110struct child_prog {
Erik Andersen161220c2000-03-16 08:12:48 +0000111 pid_t pid; /* 0 if exited */
112 char **argv; /* program name and arguments */
Eric Andersen86349772000-12-18 20:25:50 +0000113 int num_redirects; /* elements in redirection array */
114 struct redir_struct *redirects; /* I/O redirects */
Eric Andersen86349772000-12-18 20:25:50 +0000115 int is_stopped; /* is the program currently running? */
116 struct job *family; /* pointer back to the child's parent job */
Erik Andersen3522eb12000-03-12 23:49:18 +0000117};
118
119struct job {
Eric Andersen86349772000-12-18 20:25:50 +0000120 int jobid; /* job number */
121 int num_progs; /* total number of programs in job */
122 int running_progs; /* number of programs running */
Erik Andersen161220c2000-03-16 08:12:48 +0000123 char *text; /* name of job */
Eric Andersen86349772000-12-18 20:25:50 +0000124 char *cmdbuf; /* buffer various argv's point into */
Erik Andersen161220c2000-03-16 08:12:48 +0000125 pid_t pgrp; /* process group ID for the job */
Eric Andersen86349772000-12-18 20:25:50 +0000126 struct child_prog *progs; /* array of programs in job */
Erik Andersen161220c2000-03-16 08:12:48 +0000127 struct job *next; /* to track background commands */
Eric Andersen86349772000-12-18 20:25:50 +0000128 int stopped_progs; /* number of programs alive, but stopped */
129 unsigned int job_context; /* bitmask defining current context */
130 struct jobset *job_list;
Erik Andersen3522eb12000-03-12 23:49:18 +0000131};
132
Eric Andersen86349772000-12-18 20:25:50 +0000133struct built_in_command {
Erik Andersen161220c2000-03-16 08:12:48 +0000134 char *cmd; /* name */
135 char *descr; /* description */
Eric Andersen86349772000-12-18 20:25:50 +0000136 int (*function) (struct child_prog *); /* function ptr */
Erik Andersen3522eb12000-03-12 23:49:18 +0000137};
138
Eric Andersen8ea28be2001-01-05 20:58:22 +0000139struct close_me {
140 int fd;
141 struct close_me *next;
142};
143
Eric Andersen34e19412000-07-10 18:47:24 +0000144/* function prototypes for builtins */
Eric Andersen86349772000-12-18 20:25:50 +0000145static int builtin_cd(struct child_prog *cmd);
Eric Andersen86349772000-12-18 20:25:50 +0000146static int builtin_exec(struct child_prog *cmd);
147static int builtin_exit(struct child_prog *cmd);
148static int builtin_fg_bg(struct child_prog *cmd);
149static int builtin_help(struct child_prog *cmd);
150static int builtin_jobs(struct child_prog *dummy);
151static int builtin_pwd(struct child_prog *dummy);
152static int builtin_export(struct child_prog *cmd);
153static int builtin_source(struct child_prog *cmd);
154static int builtin_unset(struct child_prog *cmd);
155static int builtin_read(struct child_prog *cmd);
Eric Andersenfad9c112000-07-25 18:06:52 +0000156#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
Eric Andersen86349772000-12-18 20:25:50 +0000157static int builtin_if(struct child_prog *cmd);
158static int builtin_then(struct child_prog *cmd);
159static int builtin_else(struct child_prog *cmd);
160static int builtin_fi(struct child_prog *cmd);
Eric Andersen70da6a62000-12-20 22:59:16 +0000161/* function prototypes for shell stuff */
162static int run_command_predicate(char *cmd);
Eric Andersenfad9c112000-07-25 18:06:52 +0000163#endif
Erik Andersen3522eb12000-03-12 23:49:18 +0000164
Eric Andersen34e19412000-07-10 18:47:24 +0000165
166/* function prototypes for shell stuff */
Eric Andersen8ea28be2001-01-05 20:58:22 +0000167static void mark_open(int fd);
168static void mark_closed(int fd);
Eric Andersen36278b92001-03-06 20:47:31 +0000169static void close_all(void);
Eric Andersen86349772000-12-18 20:25:50 +0000170static void checkjobs(struct jobset *job_list);
171static int get_command(FILE * source, char *command);
172static int parse_command(char **command_ptr, struct job *job, int *inbg);
173static int run_command(struct job *newjob, int inbg, int outpipe[2]);
174static int pseudo_exec(struct child_prog *cmd) __attribute__ ((noreturn));
Erik Andersen3522eb12000-03-12 23:49:18 +0000175static int busy_loop(FILE * input);
176
Erik Andersend75af992000-03-16 08:09:09 +0000177
Mark Whitley37653aa2000-07-12 23:36:17 +0000178/* Table of built-in functions (these are non-forking builtins, meaning they
179 * can change global variables in the parent shell process but they will not
180 * work with pipes and redirects; 'unset foo | whatever' will not work) */
Eric Andersen86349772000-12-18 20:25:50 +0000181static struct built_in_command bltins[] = {
Eric Andersenfad9c112000-07-25 18:06:52 +0000182 {"bg", "Resume a job in the background", builtin_fg_bg},
183 {"cd", "Change working directory", builtin_cd},
Eric Andersend2f56772000-09-21 02:48:07 +0000184 {"exec", "Exec command, replacing this shell with the exec'd process", builtin_exec},
Eric Andersenfad9c112000-07-25 18:06:52 +0000185 {"exit", "Exit from shell()", builtin_exit},
186 {"fg", "Bring job into the foreground", builtin_fg_bg},
187 {"jobs", "Lists the active jobs", builtin_jobs},
188 {"export", "Set environment variable", builtin_export},
189 {"unset", "Unset environment variable", builtin_unset},
190 {"read", "Input environment variable", builtin_read},
Matt Kraaidd450a02000-09-13 03:43:36 +0000191 {".", "Source-in and run commands in a file", builtin_source},
Eric Andersen86349772000-12-18 20:25:50 +0000192 /* to do: add ulimit */
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000193#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
194 {"if", NULL, builtin_if},
195 {"then", NULL, builtin_then},
196 {"else", NULL, builtin_else},
197 {"fi", NULL, builtin_fi},
198#endif
Eric Andersenfad9c112000-07-25 18:06:52 +0000199 {NULL, NULL, NULL}
Erik Andersen330fd2b2000-05-19 05:35:19 +0000200};
201
Mark Whitley37653aa2000-07-12 23:36:17 +0000202/* Table of forking built-in functions (things that fork cannot change global
203 * variables in the parent process, such as the current working directory) */
Eric Andersen86349772000-12-18 20:25:50 +0000204static struct built_in_command bltins_forking[] = {
Eric Andersenfad9c112000-07-25 18:06:52 +0000205 {"pwd", "Print current directory", builtin_pwd},
Eric Andersenfad9c112000-07-25 18:06:52 +0000206 {"help", "List shell built-in commands", builtin_help},
207 {NULL, NULL, NULL}
Erik Andersen3522eb12000-03-12 23:49:18 +0000208};
209
Eric Andersen0bcc8132001-01-05 19:37:32 +0000210
211/* Variables we export */
212unsigned int shell_context; /* Used in cmdedit.c to reset the
213 context when someone hits ^C */
214
215
216/* Globals that are static to this file */
Eric Andersen6efc48c2000-07-18 08:16:39 +0000217static char *cwd;
Eric Andersen744b0642001-01-05 21:23:44 +0000218static char *local_pending_command = NULL;
Eric Andersen86349772000-12-18 20:25:50 +0000219static struct jobset job_list = { NULL, NULL };
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000220static int argc;
221static char **argv;
Eric Andersen702ec592001-03-06 22:17:29 +0000222static struct close_me *close_me_head;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000223#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersenca604592001-03-08 17:17:13 +0000224static int last_bg_pid;
225static int last_return_code;
226static int show_x_trace;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000227#endif
Eric Andersen86349772000-12-18 20:25:50 +0000228#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
229static char syntax_err[]="syntax error near unexpected token";
230#endif
231
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000232static char *PS1;
233static char *PS2;
234
235
Eric Andersenb558e762000-11-30 22:43:16 +0000236#ifdef DEBUG_SHELL
237static inline void debug_printf(const char *format, ...)
238{
239 va_list args;
240 va_start(args, format);
Eric Andersen86349772000-12-18 20:25:50 +0000241 vfprintf(stderr, format, args);
Eric Andersenb558e762000-11-30 22:43:16 +0000242 va_end(args);
243}
244#else
245static inline void debug_printf(const char *format, ...) { }
246#endif
Erik Andersen3522eb12000-03-12 23:49:18 +0000247
Eric Andersen86349772000-12-18 20:25:50 +0000248/*
249 Most builtins need access to the struct child_prog that has
250 their arguments, previously coded as cmd->progs[0]. That coding
251 can exhibit a bug, if the builtin is not the first command in
252 a pipeline: "echo foo | exec sort" will attempt to exec foo.
253
254builtin previous use notes
255------ ----------------- ---------
256cd cmd->progs[0]
Eric Andersen86349772000-12-18 20:25:50 +0000257exec cmd->progs[0] squashed bug: didn't look for applets or forking builtins
258exit cmd->progs[0]
259fg_bg cmd->progs[0], job_list->head, job_list->fg
260help 0
261jobs job_list->head
262pwd 0
Eric Andersen84e229c2001-03-29 22:48:33 +0000263export cmd->progs[0]
Eric Andersen86349772000-12-18 20:25:50 +0000264source cmd->progs[0]
265unset cmd->progs[0]
266read cmd->progs[0]
267if cmd->job_context, cmd->text
268then cmd->job_context, cmd->text
269else cmd->job_context, cmd->text
270fi cmd->job_context
271
272The use of cmd->text by if/then/else/fi is hopelessly hacky.
273Would it work to increment cmd->progs[0]->argv and recurse,
274somewhat like builtin_exec does?
275
276I added "struct job *family;" to struct child_prog,
277and switched API to builtin_foo(struct child_prog *child);
278So cmd->text becomes child->family->text
279 cmd->job_context becomes child->family->job_context
280 cmd->progs[0] becomes *child
281 job_list becomes child->family->job_list
282 */
Erik Andersen3522eb12000-03-12 23:49:18 +0000283
Erik Andersend75af992000-03-16 08:09:09 +0000284/* built-in 'cd <path>' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000285static int builtin_cd(struct child_prog *child)
Erik Andersend75af992000-03-16 08:09:09 +0000286{
Erik Andersen161220c2000-03-16 08:12:48 +0000287 char *newdir;
Erik Andersend75af992000-03-16 08:09:09 +0000288
Eric Andersen86349772000-12-18 20:25:50 +0000289 if (child->argv[1] == NULL)
Erik Andersen161220c2000-03-16 08:12:48 +0000290 newdir = getenv("HOME");
291 else
Eric Andersen86349772000-12-18 20:25:50 +0000292 newdir = child->argv[1];
Erik Andersen161220c2000-03-16 08:12:48 +0000293 if (chdir(newdir)) {
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000294 printf("cd: %s: %m\n", newdir);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000295 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000296 }
Eric Andersen6efc48c2000-07-18 08:16:39 +0000297 getcwd(cwd, sizeof(char)*MAX_LINE);
Erik Andersen161220c2000-03-16 08:12:48 +0000298
Matt Kraai3e856ce2000-12-01 02:55:13 +0000299 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000300}
301
Eric Andersend2f56772000-09-21 02:48:07 +0000302/* built-in 'exec' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000303static int builtin_exec(struct child_prog *child)
Eric Andersend2f56772000-09-21 02:48:07 +0000304{
Eric Andersen86349772000-12-18 20:25:50 +0000305 if (child->argv[1] == NULL)
306 return EXIT_SUCCESS; /* Really? */
307 child->argv++;
Eric Andersen07f2f392001-03-06 20:28:22 +0000308 close_all();
Eric Andersen86349772000-12-18 20:25:50 +0000309 pseudo_exec(child);
310 /* never returns */
Eric Andersend2f56772000-09-21 02:48:07 +0000311}
312
Erik Andersen3522eb12000-03-12 23:49:18 +0000313/* built-in 'exit' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000314static int builtin_exit(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000315{
Eric Andersen86349772000-12-18 20:25:50 +0000316 if (child->argv[1] == NULL)
Matt Kraai3e856ce2000-12-01 02:55:13 +0000317 exit(EXIT_SUCCESS);
Erik Andersen161220c2000-03-16 08:12:48 +0000318
Eric Andersen86349772000-12-18 20:25:50 +0000319 exit (atoi(child->argv[1]));
Erik Andersen3522eb12000-03-12 23:49:18 +0000320}
321
322/* built-in 'fg' and 'bg' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000323static int builtin_fg_bg(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000324{
Erik Andersen161220c2000-03-16 08:12:48 +0000325 int i, jobNum;
Erik Andersen6273f652000-03-17 01:12:41 +0000326 struct job *job=NULL;
Eric Andersen86349772000-12-18 20:25:50 +0000327
Eric Andersene9f07fb2000-12-21 18:31:36 +0000328 if (!child->argv[1] || child->argv[2]) {
Matt Kraaidd19c692001-01-31 19:00:21 +0000329 error_msg("%s: exactly one argument is expected",
Eric Andersene9f07fb2000-12-21 18:31:36 +0000330 child->argv[0]);
331 return EXIT_FAILURE;
332 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000333
Eric Andersene9f07fb2000-12-21 18:31:36 +0000334 if (sscanf(child->argv[1], "%%%d", &jobNum) != 1) {
Matt Kraaidd19c692001-01-31 19:00:21 +0000335 error_msg("%s: bad argument '%s'",
Eric Andersene9f07fb2000-12-21 18:31:36 +0000336 child->argv[0], child->argv[1]);
337 return EXIT_FAILURE;
338 }
339
340 for (job = child->family->job_list->head; job; job = job->next) {
341 if (job->jobid == jobNum) {
342 break;
Erik Andersen161220c2000-03-16 08:12:48 +0000343 }
Eric Andersene9f07fb2000-12-21 18:31:36 +0000344 }
Erik Andersen161220c2000-03-16 08:12:48 +0000345
346 if (!job) {
Matt Kraaidd19c692001-01-31 19:00:21 +0000347 error_msg("%s: unknown job %d",
Eric Andersen86349772000-12-18 20:25:50 +0000348 child->argv[0], jobNum);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000349 return EXIT_FAILURE;
Erik Andersend75af992000-03-16 08:09:09 +0000350 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000351
Eric Andersen86349772000-12-18 20:25:50 +0000352 if (*child->argv[0] == 'f') {
Erik Andersen161220c2000-03-16 08:12:48 +0000353 /* Make this job the foreground job */
Eric Andersen1c314ad2000-06-28 16:56:25 +0000354 /* suppress messages when run from /linuxrc mag@sysgo.de */
355 if (tcsetpgrp(0, job->pgrp) && errno != ENOTTY)
Matt Kraaia9819b22000-12-22 01:48:07 +0000356 perror_msg("tcsetpgrp");
Eric Andersen86349772000-12-18 20:25:50 +0000357 child->family->job_list->fg = job;
Erik Andersen161220c2000-03-16 08:12:48 +0000358 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000359
Erik Andersen161220c2000-03-16 08:12:48 +0000360 /* Restart the processes in the job */
Eric Andersen86349772000-12-18 20:25:50 +0000361 for (i = 0; i < job->num_progs; i++)
362 job->progs[i].is_stopped = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000363
Erik Andersen161220c2000-03-16 08:12:48 +0000364 kill(-job->pgrp, SIGCONT);
Erik Andersen3522eb12000-03-12 23:49:18 +0000365
Eric Andersen86349772000-12-18 20:25:50 +0000366 job->stopped_progs = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000367
Matt Kraai3e856ce2000-12-01 02:55:13 +0000368 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000369}
370
371/* built-in 'help' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000372static int builtin_help(struct child_prog *dummy)
Erik Andersen3522eb12000-03-12 23:49:18 +0000373{
Eric Andersen86349772000-12-18 20:25:50 +0000374 struct built_in_command *x;
Erik Andersen3522eb12000-03-12 23:49:18 +0000375
Eric Andersen86349772000-12-18 20:25:50 +0000376 printf("\nBuilt-in commands:\n");
377 printf("-------------------\n");
Erik Andersen161220c2000-03-16 08:12:48 +0000378 for (x = bltins; 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 Andersen161220c2000-03-16 08:12:48 +0000382 }
Erik Andersen330fd2b2000-05-19 05:35:19 +0000383 for (x = bltins_forking; x->cmd; x++) {
Eric Andersenfad9c112000-07-25 18:06:52 +0000384 if (x->descr==NULL)
385 continue;
Eric Andersen86349772000-12-18 20:25:50 +0000386 printf("%s\t%s\n", x->cmd, x->descr);
Erik Andersen330fd2b2000-05-19 05:35:19 +0000387 }
Eric Andersen86349772000-12-18 20:25:50 +0000388 printf("\n\n");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000389 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000390}
391
392/* built-in 'jobs' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000393static int builtin_jobs(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000394{
Erik Andersen161220c2000-03-16 08:12:48 +0000395 struct job *job;
Eric Andersen86349772000-12-18 20:25:50 +0000396 char *status_string;
Erik Andersen3522eb12000-03-12 23:49:18 +0000397
Eric Andersen86349772000-12-18 20:25:50 +0000398 for (job = child->family->job_list->head; job; job = job->next) {
399 if (job->running_progs == job->stopped_progs)
400 status_string = "Stopped";
Erik Andersen161220c2000-03-16 08:12:48 +0000401 else
Eric Andersen86349772000-12-18 20:25:50 +0000402 status_string = "Running";
Erik Andersen161220c2000-03-16 08:12:48 +0000403
Eric Andersen86349772000-12-18 20:25:50 +0000404 printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text);
Erik Andersen161220c2000-03-16 08:12:48 +0000405 }
Matt Kraai3e856ce2000-12-01 02:55:13 +0000406 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000407}
408
409
410/* built-in 'pwd' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000411static int builtin_pwd(struct child_prog *dummy)
Erik Andersen3522eb12000-03-12 23:49:18 +0000412{
Eric Andersen86349772000-12-18 20:25:50 +0000413 getcwd(cwd, MAX_LINE);
Eric Andersen6f65a3a2001-01-20 01:10:07 +0000414 printf( "%s\n", cwd);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000415 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000416}
417
Erik Andersen6273f652000-03-17 01:12:41 +0000418/* built-in 'export VAR=value' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000419static int builtin_export(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000420{
Erik Andersen161220c2000-03-16 08:12:48 +0000421 int res;
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000422 char *v = child->argv[1];
Erik Andersen3522eb12000-03-12 23:49:18 +0000423
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000424 if (v == NULL) {
Eric Andersen84e229c2001-03-29 22:48:33 +0000425 char **e;
426 for (e = environ; *e; e++) {
427 printf( "%s\n", *e);
428 }
Erik Andersen161220c2000-03-16 08:12:48 +0000429 }
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000430 res = putenv(v);
Erik Andersen161220c2000-03-16 08:12:48 +0000431 if (res)
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000432 fprintf(stderr, "export: %m\n");
Mark Whitleyf5949862001-03-14 00:29:14 +0000433#ifndef BB_FEATURE_SH_SIMPLE_PROMPT
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000434 if (strncmp(v, "PS1=", 4)==0)
435 PS1 = getenv("PS1");
436 else if (strncmp(v, "PS2=", 4)==0)
437 PS2 = getenv("PS2");
438#endif
Mark Whitley1c6581a2001-03-27 16:35:16 +0000439 if(strncmp(v, "LC_ALL=", 7)==0)
440 setlocale(LC_ALL, getenv("LC_ALL"));
Mark Whitleya82a0032001-03-27 17:07:15 +0000441 if(strncmp(v, "LC_CTYPE=", 9)==0)
Mark Whitley1c6581a2001-03-27 16:35:16 +0000442 setlocale(LC_CTYPE, getenv("LC_CTYPE"));
443
Erik Andersen161220c2000-03-16 08:12:48 +0000444 return (res);
Erik Andersen3522eb12000-03-12 23:49:18 +0000445}
446
Eric Andersenb54833c2000-07-03 23:56:26 +0000447/* built-in 'read VAR' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000448static int builtin_read(struct child_prog *child)
Eric Andersenb54833c2000-07-03 23:56:26 +0000449{
450 int res = 0, len, newlen;
451 char *s;
452 char string[MAX_READ];
453
Eric Andersen86349772000-12-18 20:25:50 +0000454 if (child->argv[1]) {
Eric Andersenb54833c2000-07-03 23:56:26 +0000455 /* argument (VAR) given: put "VAR=" into buffer */
Eric Andersen86349772000-12-18 20:25:50 +0000456 strcpy(string, child->argv[1]);
Eric Andersenb54833c2000-07-03 23:56:26 +0000457 len = strlen(string);
458 string[len++] = '=';
459 string[len] = '\0';
460 fgets(&string[len], sizeof(string) - len, stdin); /* read string */
461 newlen = strlen(string);
462 if(newlen > len)
463 string[--newlen] = '\0'; /* chomp trailing newline */
464 /*
465 ** string should now contain "VAR=<value>"
466 ** copy it (putenv() won't do that, so we must make sure
467 ** the string resides in a static buffer!)
468 */
469 res = -1;
470 if((s = strdup(string)))
471 res = putenv(s);
472 if (res)
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000473 fprintf(stderr, "read: %m\n");
Eric Andersenb54833c2000-07-03 23:56:26 +0000474 }
475 else
476 fgets(string, sizeof(string), stdin);
477
478 return (res);
479}
480
Eric Andersenfad9c112000-07-25 18:06:52 +0000481#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
482/* Built-in handler for 'if' commands */
Eric Andersen86349772000-12-18 20:25:50 +0000483static int builtin_if(struct child_prog *child)
Eric Andersenfad9c112000-07-25 18:06:52 +0000484{
Eric Andersen86349772000-12-18 20:25:50 +0000485 struct job *cmd = child->family;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000486 int status;
487 char* charptr1=cmd->text+3; /* skip over the leading 'if ' */
488
489 /* Now run the 'if' command */
Eric Andersen86349772000-12-18 20:25:50 +0000490 debug_printf( "job=%p entering builtin_if ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
491 status = run_command_predicate(charptr1);
492 debug_printf( "if test returned ");
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000493 if (status == 0) {
Eric Andersen86349772000-12-18 20:25:50 +0000494 debug_printf( "TRUE\n");
495 cmd->job_context |= IF_TRUE_CONTEXT;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000496 } else {
Eric Andersen86349772000-12-18 20:25:50 +0000497 debug_printf( "FALSE\n");
498 cmd->job_context |= IF_FALSE_CONTEXT;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000499 }
Eric Andersen86349772000-12-18 20:25:50 +0000500 debug_printf("job=%p builtin_if set job context to %x\n", cmd, cmd->job_context);
501 shell_context++;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000502
503 return status;
Eric Andersenfad9c112000-07-25 18:06:52 +0000504}
505
506/* Built-in handler for 'then' (part of the 'if' command) */
Eric Andersen86349772000-12-18 20:25:50 +0000507static int builtin_then(struct child_prog *child)
Eric Andersenfad9c112000-07-25 18:06:52 +0000508{
Eric Andersen86349772000-12-18 20:25:50 +0000509 struct job *cmd = child->family;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000510 char* charptr1=cmd->text+5; /* skip over the leading 'then ' */
511
Eric Andersen86349772000-12-18 20:25:50 +0000512 debug_printf( "job=%p entering builtin_then ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
513 if (! (cmd->job_context & (IF_TRUE_CONTEXT|IF_FALSE_CONTEXT))) {
514 shell_context = 0; /* Reset the shell's context on an error */
Matt Kraaidd19c692001-01-31 19:00:21 +0000515 error_msg("%s `then'", syntax_err);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000516 return EXIT_FAILURE;
Eric Andersenfad9c112000-07-25 18:06:52 +0000517 }
Eric Andersen86349772000-12-18 20:25:50 +0000518
519 cmd->job_context |= THEN_EXP_CONTEXT;
520 debug_printf("job=%p builtin_then set job context to %x\n", cmd, cmd->job_context);
521
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000522 /* If the if result was FALSE, skip the 'then' stuff */
Eric Andersen86349772000-12-18 20:25:50 +0000523 if (cmd->job_context & IF_FALSE_CONTEXT) {
Matt Kraai3e856ce2000-12-01 02:55:13 +0000524 return EXIT_SUCCESS;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000525 }
526
Eric Andersen86349772000-12-18 20:25:50 +0000527 /* Seems the if result was TRUE, so run the 'then' command */
528 debug_printf( "'then' now running '%s'\n", charptr1);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000529
Eric Andersen86349772000-12-18 20:25:50 +0000530 return(run_command_predicate(charptr1));
Eric Andersenfad9c112000-07-25 18:06:52 +0000531}
532
533/* Built-in handler for 'else' (part of the 'if' command) */
Eric Andersen86349772000-12-18 20:25:50 +0000534static int builtin_else(struct child_prog *child)
Eric Andersenfad9c112000-07-25 18:06:52 +0000535{
Eric Andersen86349772000-12-18 20:25:50 +0000536 struct job *cmd = child->family;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000537 char* charptr1=cmd->text+5; /* skip over the leading 'else ' */
538
Eric Andersen86349772000-12-18 20:25:50 +0000539 debug_printf( "job=%p entering builtin_else ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
540
541 if (! (cmd->job_context & THEN_EXP_CONTEXT)) {
542 shell_context = 0; /* Reset the shell's context on an error */
Matt Kraaidd19c692001-01-31 19:00:21 +0000543 error_msg("%s `else'", syntax_err);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000544 return EXIT_FAILURE;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000545 }
546 /* If the if result was TRUE, skip the 'else' stuff */
Eric Andersen86349772000-12-18 20:25:50 +0000547 if (cmd->job_context & IF_TRUE_CONTEXT) {
Matt Kraai3e856ce2000-12-01 02:55:13 +0000548 return EXIT_SUCCESS;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000549 }
550
Eric Andersen86349772000-12-18 20:25:50 +0000551 cmd->job_context |= ELSE_EXP_CONTEXT;
Eric Andersene9f07fb2000-12-21 18:31:36 +0000552 debug_printf("job=%p builtin_else set job context to %x\n", cmd, cmd->job_context);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000553
554 /* Now run the 'else' command */
Eric Andersen86349772000-12-18 20:25:50 +0000555 debug_printf( "'else' now running '%s'\n", charptr1);
556 return(run_command_predicate(charptr1));
Eric Andersenfad9c112000-07-25 18:06:52 +0000557}
558
559/* Built-in handler for 'fi' (part of the 'if' command) */
Eric Andersen86349772000-12-18 20:25:50 +0000560static int builtin_fi(struct child_prog *child)
Eric Andersenfad9c112000-07-25 18:06:52 +0000561{
Eric Andersen86349772000-12-18 20:25:50 +0000562 struct job *cmd = child->family;
563 debug_printf( "job=%p entering builtin_fi ('%s')-- context=%d\n", cmd, "", cmd->job_context);
564 if (! (cmd->job_context & (IF_TRUE_CONTEXT|IF_FALSE_CONTEXT))) {
565 shell_context = 0; /* Reset the shell's context on an error */
Matt Kraaidd19c692001-01-31 19:00:21 +0000566 error_msg("%s `fi'", syntax_err);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000567 return EXIT_FAILURE;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000568 }
569 /* Clear out the if and then context bits */
Eric Andersen86349772000-12-18 20:25:50 +0000570 cmd->job_context &= ~(IF_TRUE_CONTEXT|IF_FALSE_CONTEXT|THEN_EXP_CONTEXT|ELSE_EXP_CONTEXT);
571 debug_printf("job=%p builtin_fi set job context to %x\n", cmd, cmd->job_context);
572 shell_context--;
Matt Kraai3e856ce2000-12-01 02:55:13 +0000573 return EXIT_SUCCESS;
Eric Andersenfad9c112000-07-25 18:06:52 +0000574}
575#endif
576
Erik Andersen3522eb12000-03-12 23:49:18 +0000577/* Built-in '.' handler (read-in and execute commands from file) */
Eric Andersen86349772000-12-18 20:25:50 +0000578static int builtin_source(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000579{
Erik Andersen161220c2000-03-16 08:12:48 +0000580 FILE *input;
581 int status;
Eric Andersen8ea28be2001-01-05 20:58:22 +0000582 int fd;
Erik Andersen3522eb12000-03-12 23:49:18 +0000583
Eric Andersen86349772000-12-18 20:25:50 +0000584 if (child->argv[1] == NULL)
Matt Kraai3e856ce2000-12-01 02:55:13 +0000585 return EXIT_FAILURE;
Erik Andersen3522eb12000-03-12 23:49:18 +0000586
Eric Andersen86349772000-12-18 20:25:50 +0000587 input = fopen(child->argv[1], "r");
Erik Andersen161220c2000-03-16 08:12:48 +0000588 if (!input) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +0000589 printf( "Couldn't open file '%s'\n", child->argv[1]);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000590 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000591 }
Erik Andersend75af992000-03-16 08:09:09 +0000592
Eric Andersen8ea28be2001-01-05 20:58:22 +0000593 fd=fileno(input);
594 mark_open(fd);
Erik Andersen161220c2000-03-16 08:12:48 +0000595 /* Now run the file */
596 status = busy_loop(input);
Matt Kraaidd450a02000-09-13 03:43:36 +0000597 fclose(input);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000598 mark_closed(fd);
Erik Andersen161220c2000-03-16 08:12:48 +0000599 return (status);
Erik Andersen3522eb12000-03-12 23:49:18 +0000600}
601
602/* built-in 'unset VAR' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000603static int builtin_unset(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000604{
Eric Andersen86349772000-12-18 20:25:50 +0000605 if (child->argv[1] == NULL) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +0000606 printf( "unset: parameter required.\n");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000607 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000608 }
Eric Andersen86349772000-12-18 20:25:50 +0000609 unsetenv(child->argv[1]);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000610 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000611}
612
Eric Andersen70da6a62000-12-20 22:59:16 +0000613#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
Eric Andersen86349772000-12-18 20:25:50 +0000614/* currently used by if/then/else.
Eric Andersene9f07fb2000-12-21 18:31:36 +0000615 *
616 * Reparsing the command line for this purpose is gross,
617 * incorrect, and fundamentally unfixable; in particular,
618 * think about what happens with command substitution.
619 * We really need to pull out the run, wait, return status
620 * functionality out of busy_loop so we can child->argv++
621 * and use that, without going back through parse_command.
Eric Andersen86349772000-12-18 20:25:50 +0000622 */
623static int run_command_predicate(char *cmd)
624{
625 int n=strlen(cmd);
626 local_pending_command = xmalloc(n+1);
627 strncpy(local_pending_command, cmd, n);
628 local_pending_command[n]='\0';
629 return( busy_loop(NULL));
630}
Eric Andersen70da6a62000-12-20 22:59:16 +0000631#endif
Eric Andersen86349772000-12-18 20:25:50 +0000632
Eric Andersen8ea28be2001-01-05 20:58:22 +0000633static void mark_open(int fd)
634{
635 struct close_me *new = xmalloc(sizeof(struct close_me));
636 new->fd = fd;
637 new->next = close_me_head;
638 close_me_head = new;
639}
640
641static void mark_closed(int fd)
642{
643 struct close_me *tmp;
644 if (close_me_head == NULL || close_me_head->fd != fd)
645 error_msg_and_die("corrupt close_me");
646 tmp = close_me_head;
647 close_me_head = close_me_head->next;
648 free(tmp);
649}
650
651static void close_all()
652{
Eric Andersen702ec592001-03-06 22:17:29 +0000653 struct close_me *c, *tmp;
654 for (c=close_me_head; c; c=tmp) {
655 close(c->fd);
656 tmp=c->next;
657 free(c);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000658 }
659 close_me_head = NULL;
660}
661
662
Erik Andersen3522eb12000-03-12 23:49:18 +0000663/* free up all memory from a job */
Eric Andersen86349772000-12-18 20:25:50 +0000664static void free_job(struct job *cmd)
Erik Andersen3522eb12000-03-12 23:49:18 +0000665{
Erik Andersen161220c2000-03-16 08:12:48 +0000666 int i;
Mark Whitley44a99142001-03-14 17:26:37 +0000667 struct jobset *keep;
Erik Andersen3522eb12000-03-12 23:49:18 +0000668
Eric Andersen86349772000-12-18 20:25:50 +0000669 for (i = 0; i < cmd->num_progs; i++) {
Erik Andersen161220c2000-03-16 08:12:48 +0000670 free(cmd->progs[i].argv);
Eric Andersen86349772000-12-18 20:25:50 +0000671 if (cmd->progs[i].redirects)
672 free(cmd->progs[i].redirects);
Erik Andersen161220c2000-03-16 08:12:48 +0000673 }
Mark Whitley44a99142001-03-14 17:26:37 +0000674 if (cmd->progs)
675 free(cmd->progs);
Erik Andersen161220c2000-03-16 08:12:48 +0000676 if (cmd->text)
677 free(cmd->text);
Mark Whitley44a99142001-03-14 17:26:37 +0000678 if (cmd->cmdbuf)
679 free(cmd->cmdbuf);
680 keep = cmd->job_list;
Eric Andersenec10b9d2000-07-14 01:13:11 +0000681 memset(cmd, 0, sizeof(struct job));
Mark Whitley44a99142001-03-14 17:26:37 +0000682 cmd->job_list = keep;
Erik Andersen3522eb12000-03-12 23:49:18 +0000683}
684
Eric Andersen1ca20a72001-03-21 07:34:27 +0000685/* remove a job from a jobset */
686static void remove_job(struct jobset *j_list, struct job *job)
Erik Andersen3522eb12000-03-12 23:49:18 +0000687{
Eric Andersen86349772000-12-18 20:25:50 +0000688 struct job *prevjob;
Erik Andersen3522eb12000-03-12 23:49:18 +0000689
Eric Andersen86349772000-12-18 20:25:50 +0000690 free_job(job);
Eric Andersen1ca20a72001-03-21 07:34:27 +0000691 if (job == j_list->head) {
692 j_list->head = job->next;
Erik Andersen161220c2000-03-16 08:12:48 +0000693 } else {
Eric Andersen1ca20a72001-03-21 07:34:27 +0000694 prevjob = j_list->head;
Eric Andersen86349772000-12-18 20:25:50 +0000695 while (prevjob->next != job)
696 prevjob = prevjob->next;
697 prevjob->next = job->next;
Erik Andersen161220c2000-03-16 08:12:48 +0000698 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000699
Erik Andersen161220c2000-03-16 08:12:48 +0000700 free(job);
Erik Andersen3522eb12000-03-12 23:49:18 +0000701}
702
703/* Checks to see if any background processes have exited -- if they
704 have, figure out why and see if a job has completed */
Eric Andersen1ca20a72001-03-21 07:34:27 +0000705static void checkjobs(struct jobset *j_list)
Erik Andersen3522eb12000-03-12 23:49:18 +0000706{
Erik Andersen161220c2000-03-16 08:12:48 +0000707 struct job *job;
708 pid_t childpid;
709 int status;
Eric Andersen86349772000-12-18 20:25:50 +0000710 int prognum = 0;
Erik Andersend75af992000-03-16 08:09:09 +0000711
Erik Andersen161220c2000-03-16 08:12:48 +0000712 while ((childpid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
Eric Andersen1ca20a72001-03-21 07:34:27 +0000713 for (job = j_list->head; job; job = job->next) {
Eric Andersen86349772000-12-18 20:25:50 +0000714 prognum = 0;
715 while (prognum < job->num_progs &&
716 job->progs[prognum].pid != childpid) prognum++;
717 if (prognum < job->num_progs)
Erik Andersen161220c2000-03-16 08:12:48 +0000718 break;
719 }
720
Eric Andersena1d187a2000-07-17 19:14:41 +0000721 /* This happens on backticked commands */
722 if(job==NULL)
723 return;
724
Erik Andersen161220c2000-03-16 08:12:48 +0000725 if (WIFEXITED(status) || WIFSIGNALED(status)) {
726 /* child exited */
Eric Andersen86349772000-12-18 20:25:50 +0000727 job->running_progs--;
728 job->progs[prognum].pid = 0;
Erik Andersen161220c2000-03-16 08:12:48 +0000729
Eric Andersen86349772000-12-18 20:25:50 +0000730 if (!job->running_progs) {
731 printf(JOB_STATUS_FORMAT, job->jobid, "Done", job->text);
Eric Andersen1ca20a72001-03-21 07:34:27 +0000732 remove_job(j_list, job);
Erik Andersen161220c2000-03-16 08:12:48 +0000733 }
734 } else {
735 /* child stopped */
Eric Andersen86349772000-12-18 20:25:50 +0000736 job->stopped_progs++;
737 job->progs[prognum].is_stopped = 1;
Erik Andersen161220c2000-03-16 08:12:48 +0000738
Eric Andersen86349772000-12-18 20:25:50 +0000739 if (job->stopped_progs == job->num_progs) {
740 printf(JOB_STATUS_FORMAT, job->jobid, "Stopped",
Erik Andersen161220c2000-03-16 08:12:48 +0000741 job->text);
742 }
743 }
Erik Andersend75af992000-03-16 08:09:09 +0000744 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000745
Erik Andersen161220c2000-03-16 08:12:48 +0000746 if (childpid == -1 && errno != ECHILD)
Matt Kraaia9819b22000-12-22 01:48:07 +0000747 perror_msg("waitpid");
Erik Andersen3522eb12000-03-12 23:49:18 +0000748}
749
Eric Andersene9f07fb2000-12-21 18:31:36 +0000750/* squirrel != NULL means we squirrel away copies of stdin, stdout,
751 * and stderr if they are redirected. */
752static int setup_redirects(struct child_prog *prog, int squirrel[])
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000753{
754 int i;
755 int openfd;
756 int mode = O_RDONLY;
Eric Andersen86349772000-12-18 20:25:50 +0000757 struct redir_struct *redir = prog->redirects;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000758
Eric Andersen86349772000-12-18 20:25:50 +0000759 for (i = 0; i < prog->num_redirects; i++, redir++) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000760 switch (redir->type) {
761 case REDIRECT_INPUT:
762 mode = O_RDONLY;
763 break;
764 case REDIRECT_OVERWRITE:
Eric Andersen46f0beb2000-11-14 21:59:22 +0000765 mode = O_WRONLY | O_CREAT | O_TRUNC;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000766 break;
767 case REDIRECT_APPEND:
Eric Andersen46f0beb2000-11-14 21:59:22 +0000768 mode = O_WRONLY | O_CREAT | O_APPEND;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000769 break;
770 }
771
772 openfd = open(redir->filename, mode, 0666);
773 if (openfd < 0) {
774 /* this could get lost if stderr has been redirected, but
775 bash and ash both lose it as well (though zsh doesn't!) */
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000776 perror_msg("error opening %s", redir->filename);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000777 return 1;
778 }
779
780 if (openfd != redir->fd) {
Eric Andersene9f07fb2000-12-21 18:31:36 +0000781 if (squirrel && redir->fd < 3) {
782 squirrel[redir->fd] = dup(redir->fd);
783 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000784 dup2(openfd, redir->fd);
785 close(openfd);
786 }
787 }
788
789 return 0;
790}
791
Eric Andersene9f07fb2000-12-21 18:31:36 +0000792static void restore_redirects(int squirrel[])
793{
794 int i, fd;
795 for (i=0; i<3; i++) {
796 fd = squirrel[i];
797 if (fd != -1) {
798 /* No error checking. I sure wouldn't know what
799 * to do with an error if I found one! */
800 dup2(fd, i);
801 close(fd);
802 }
803 }
804}
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000805
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000806static inline void cmdedit_set_initial_prompt(void)
Eric Andersen22332fd2001-01-30 23:40:39 +0000807{
Mark Whitleyf5949862001-03-14 00:29:14 +0000808#ifdef BB_FEATURE_SH_SIMPLE_PROMPT
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000809 PS1 = NULL;
810 PS2 = "> ";
Eric Andersen22332fd2001-01-30 23:40:39 +0000811#else
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000812 PS1 = getenv("PS1");
813 if(PS1==0) {
814 PS1 = "\\w \\$ ";
Eric Andersen09acc062001-01-04 11:10:38 +0000815 }
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000816 PS2 = getenv("PS2");
817 if(PS2==0)
818 PS2 = "> ";
819#endif
Eric Andersen09acc062001-01-04 11:10:38 +0000820}
821
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000822static inline void setup_prompt_string(char **prompt_str)
823{
Mark Whitleyf5949862001-03-14 00:29:14 +0000824#ifdef BB_FEATURE_SH_SIMPLE_PROMPT
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000825 /* Set up the prompt */
826 if (shell_context == 0) {
827 if (PS1)
828 free(PS1);
829 PS1=xmalloc(strlen(cwd)+4);
830 sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ? "$ ":"# ");
831 *prompt_str = PS1;
832 } else {
833 *prompt_str = PS2;
834 }
835#else
836 *prompt_str = (shell_context==0)? PS1 : PS2;
837#endif
838}
Eric Andersen22332fd2001-01-30 23:40:39 +0000839
Eric Andersen09acc062001-01-04 11:10:38 +0000840static int get_command(FILE * source, char *command)
841{
842 char *prompt_str;
Eric Andersen8ea28be2001-01-05 20:58:22 +0000843
Eric Andersen1c314ad2000-06-28 16:56:25 +0000844 if (source == NULL) {
845 if (local_pending_command) {
846 /* a command specified (-c option): return it & mark it done */
847 strcpy(command, local_pending_command);
848 free(local_pending_command);
849 local_pending_command = NULL;
850 return 0;
851 }
852 return 1;
853 }
854
Erik Andersen161220c2000-03-16 08:12:48 +0000855 if (source == stdin) {
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000856 setup_prompt_string(&prompt_str);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000857
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000858#ifdef BB_FEATURE_COMMAND_EDITING
Eric Andersen501c88b2000-07-28 15:14:45 +0000859 /*
860 ** enable command line editing only while a command line
861 ** is actually being read; otherwise, we'll end up bequeathing
862 ** atexit() handlers and other unwanted stuff to our
863 ** child processes (rob@sysgo.de)
864 */
Eric Andersen86349772000-12-18 20:25:50 +0000865 cmdedit_read_input(prompt_str, command);
Eric Andersen501c88b2000-07-28 15:14:45 +0000866 cmdedit_terminate();
Erik Andersen161220c2000-03-16 08:12:48 +0000867 return 0;
Erik Andersenc7c634b2000-03-19 05:28:55 +0000868#else
Eric Andersen8ea28be2001-01-05 20:58:22 +0000869 fputs(prompt_str, stdout);
Erik Andersend75af992000-03-16 08:09:09 +0000870#endif
Erik Andersen161220c2000-03-16 08:12:48 +0000871 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000872
Erik Andersen161220c2000-03-16 08:12:48 +0000873 if (!fgets(command, BUFSIZ - 2, source)) {
874 if (source == stdin)
875 printf("\n");
876 return 1;
877 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000878
Erik Andersen161220c2000-03-16 08:12:48 +0000879 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000880}
881
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000882#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000883static char* itoa(register int i)
884{
Eric Andersenb558e762000-11-30 22:43:16 +0000885 static char a[7]; /* Max 7 ints */
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000886 register char *b = a + sizeof(a) - 1;
887 int sign = (i < 0);
888
889 if (sign)
890 i = -i;
891 *b = 0;
892 do
893 {
894 *--b = '0' + (i % 10);
895 i /= 10;
896 }
897 while (i);
898 if (sign)
899 *--b = '-';
900 return b;
901}
Eric Andersenca604592001-03-08 17:17:13 +0000902#endif
903
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000904#if defined BB_FEATURE_SH_ENVIRONMENT && ! defined BB_FEATURE_SH_WORDEXP
Eric Andersen1ca20a72001-03-21 07:34:27 +0000905char * strsep_space( char *string, int * ix)
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000906{
907 char *token, *begin;
908
909 begin = string;
910
911 /* Short circuit the trivial case */
Eric Andersen1ca20a72001-03-21 07:34:27 +0000912 if ( !string || ! string[*ix])
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000913 return NULL;
914
915 /* Find the end of the token. */
Eric Andersen1ca20a72001-03-21 07:34:27 +0000916 while( string && string[*ix] && !isspace(string[*ix]) ) {
917 (*ix)++;
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000918 }
919
920 /* Find the end of any whitespace trailing behind
921 * the token and let that be part of the token */
Eric Andersen1ca20a72001-03-21 07:34:27 +0000922 while( string && string[*ix] && isspace(string[*ix]) ) {
923 (*ix)++;
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000924 }
925
Eric Andersen1ca20a72001-03-21 07:34:27 +0000926 if (! string && *ix==0) {
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000927 /* Nothing useful was found */
928 return NULL;
929 }
930
Eric Andersen1ca20a72001-03-21 07:34:27 +0000931 token = xmalloc(*ix+1);
932 token[*ix] = '\0';
933 strncpy(token, string, *ix);
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000934
935 return token;
936}
937#endif
938
939
Eric Andersenca604592001-03-08 17:17:13 +0000940static int expand_arguments(char *command)
941{
942#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen13d1fa12001-03-08 23:59:45 +0000943 expand_t expand_result;
Eric Andersenca604592001-03-08 17:17:13 +0000944 char *src, *dst, *var;
Eric Andersen1ca20a72001-03-21 07:34:27 +0000945 int ix = 0;
Eric Andersenca604592001-03-08 17:17:13 +0000946 int i=0, length, total_length=0, retval;
Eric Andersen195743f2001-03-09 19:21:37 +0000947 const char *out_of_space = "out of space during expansion";
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000948#endif
949
Eric Andersenca604592001-03-08 17:17:13 +0000950 /* get rid of the terminating \n */
951 chomp(command);
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000952
953 /* Fix up escape sequences to be the Real Thing(tm) */
Eric Andersen1ca20a72001-03-21 07:34:27 +0000954 while( command && command[ix]) {
955 if (command[ix] == '\\') {
956 char *tmp = command+ix+1;
957 command[ix] = process_escape_sequence( &tmp );
958 memmove(command+ix + 1, tmp, strlen(tmp)+1);
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000959 }
Eric Andersen1ca20a72001-03-21 07:34:27 +0000960 ix++;
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000961 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000962
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000963#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersenca604592001-03-08 17:17:13 +0000964
Eric Andersen13d1fa12001-03-08 23:59:45 +0000965
Eric Andersen34174472001-03-17 00:20:10 +0000966#ifdef BB_FEATURE_SH_WORDEXP
Eric Andersenca604592001-03-08 17:17:13 +0000967 /* This first part uses wordexp() which is a wonderful C lib
968 * function which expands nearly everything. */
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000969 retval = wordexp (command, &expand_result, WRDE_SHOWERR);
Eric Andersenca604592001-03-08 17:17:13 +0000970 if (retval == WRDE_NOSPACE) {
971 /* Mem may have been allocated... */
Eric Andersen13d1fa12001-03-08 23:59:45 +0000972 wordfree (&expand_result);
Eric Andersen195743f2001-03-09 19:21:37 +0000973 error_msg(out_of_space);
Eric Andersenca604592001-03-08 17:17:13 +0000974 return FALSE;
975 }
976 if (retval < 0) {
977 /* Some other error. */
978 error_msg("syntax error");
979 return FALSE;
980 }
981
Eric Andersen1365bb72001-03-10 07:12:12 +0000982 if (expand_result.we_wordc > 0) {
983 /* Convert from char** (one word per string) to a simple char*,
984 * but don't overflow command which is BUFSIZ in length */
985 *command = '\0';
986 while (i < expand_result.we_wordc && total_length < BUFSIZ) {
987 length=strlen(expand_result.we_wordv[i])+1;
988 if (BUFSIZ-total_length-length <= 0) {
989 error_msg(out_of_space);
990 return FALSE;
991 }
992 strcat(command+total_length, expand_result.we_wordv[i++]);
993 strcat(command+total_length, " ");
994 total_length+=length;
Eric Andersenca604592001-03-08 17:17:13 +0000995 }
Eric Andersen1365bb72001-03-10 07:12:12 +0000996 wordfree (&expand_result);
Eric Andersenca604592001-03-08 17:17:13 +0000997 }
Eric Andersen13d1fa12001-03-08 23:59:45 +0000998#else
999
Eric Andersen195743f2001-03-09 19:21:37 +00001000 /* Ok. They don't have a recent glibc and they don't have uClibc. Chances
1001 * are about 100% they don't have wordexp(). So instead the best we can do
1002 * is use glob and then fixup environment variables and such ourselves.
1003 * This is better then nothing, but certainly not perfect */
Eric Andersen13d1fa12001-03-08 23:59:45 +00001004
Eric Andersen195743f2001-03-09 19:21:37 +00001005 /* It turns out that glob is very stupid. We have to feed it one word at a
1006 * time since it can't cope with a full string. Here we convert command
1007 * (char*) into cmd (char**, one word per string) */
Eric Andersen13d1fa12001-03-08 23:59:45 +00001008 {
1009
Eric Andersen4e7244e2001-03-14 00:49:52 +00001010 int flags = GLOB_NOCHECK
1011#ifdef GLOB_BRACE
1012 | GLOB_BRACE
1013#endif
1014#ifdef GLOB_TILDE
1015 | GLOB_TILDE
1016#endif
1017 ;
Eric Andersenb3d6e2d2001-03-13 22:57:56 +00001018 char *tmpcmd, *cmd, *cmd_copy;
Eric Andersen13d1fa12001-03-08 23:59:45 +00001019 /* We need a clean copy, so strsep can mess up the copy while
Eric Andersen195743f2001-03-09 19:21:37 +00001020 * we write stuff into the original (in a minute) */
Eric Andersen4987bbf2001-03-12 21:36:49 +00001021 cmd = cmd_copy = strdup(command);
Eric Andersen195743f2001-03-09 19:21:37 +00001022 *command = '\0';
Eric Andersen1ca20a72001-03-21 07:34:27 +00001023 for (ix = 0, tmpcmd = cmd;
1024 (tmpcmd = strsep_space(cmd, &ix)) != NULL; cmd += ix, ix=0) {
Eric Andersen13d1fa12001-03-08 23:59:45 +00001025 if (*tmpcmd == '\0')
1026 break;
1027 retval = glob(tmpcmd, flags, NULL, &expand_result);
Eric Andersenb3d6e2d2001-03-13 22:57:56 +00001028 free(tmpcmd); /* Free mem allocated by strsep_space */
Eric Andersen13d1fa12001-03-08 23:59:45 +00001029 if (retval == GLOB_NOSPACE) {
1030 /* Mem may have been allocated... */
1031 globfree (&expand_result);
Eric Andersen195743f2001-03-09 19:21:37 +00001032 error_msg(out_of_space);
Eric Andersen13d1fa12001-03-08 23:59:45 +00001033 return FALSE;
Eric Andersen195743f2001-03-09 19:21:37 +00001034 } else if (retval != 0) {
1035 /* Some other error. GLOB_NOMATCH shouldn't
1036 * happen because of the GLOB_NOCHECK flag in
1037 * the glob call. */
Eric Andersen13d1fa12001-03-08 23:59:45 +00001038 error_msg("syntax error");
1039 return FALSE;
Eric Andersen195743f2001-03-09 19:21:37 +00001040 } else {
Eric Andersen13d1fa12001-03-08 23:59:45 +00001041 /* Convert from char** (one word per string) to a simple char*,
1042 * but don't overflow command which is BUFSIZ in length */
Eric Andersen195743f2001-03-09 19:21:37 +00001043 for (i=0; i < expand_result.gl_pathc; i++) {
Eric Andersen1ef92682001-03-14 19:33:45 +00001044 length=strlen(expand_result.gl_pathv[i]);
Eric Andersen4aaefc22001-03-15 23:01:19 +00001045 if (total_length+length+1 >= BUFSIZ) {
Eric Andersen195743f2001-03-09 19:21:37 +00001046 error_msg(out_of_space);
Eric Andersen13d1fa12001-03-08 23:59:45 +00001047 return FALSE;
1048 }
Eric Andersen4aaefc22001-03-15 23:01:19 +00001049 if (i>0) {
1050 strcat(command+total_length, " ");
1051 total_length+=1;
1052 }
Eric Andersen195743f2001-03-09 19:21:37 +00001053 strcat(command+total_length, expand_result.gl_pathv[i]);
Eric Andersen13d1fa12001-03-08 23:59:45 +00001054 total_length+=length;
1055 }
Eric Andersen195743f2001-03-09 19:21:37 +00001056 globfree (&expand_result);
Eric Andersen13d1fa12001-03-08 23:59:45 +00001057 }
1058 }
Eric Andersen4987bbf2001-03-12 21:36:49 +00001059 free(cmd_copy);
Eric Andersen195743f2001-03-09 19:21:37 +00001060 trim(command);
Eric Andersen13d1fa12001-03-08 23:59:45 +00001061 }
Eric Andersenca604592001-03-08 17:17:13 +00001062
Eric Andersen13d1fa12001-03-08 23:59:45 +00001063#endif
Eric Andersen195743f2001-03-09 19:21:37 +00001064
Eric Andersenca604592001-03-08 17:17:13 +00001065 /* Now do the shell variable substitutions which
1066 * wordexp can't do for us, namely $? and $! */
1067 src = command;
Eric Andersencaeeb362001-02-20 06:38:44 +00001068 while((dst = strchr(src,'$')) != NULL){
Eric Andersen195743f2001-03-09 19:21:37 +00001069 var = NULL;
1070 switch(*(dst+1)) {
1071 case '?':
1072 var = itoa(last_return_code);
1073 break;
1074 case '!':
1075 if (last_bg_pid==-1)
1076 *(var)='\0';
1077 else
1078 var = itoa(last_bg_pid);
1079 break;
Eric Andersen32f8c172001-03-08 17:44:37 +00001080 /* Everything else like $$, $#, $[0-9], etc should all be
1081 * expanded by wordexp(), so we can in theory skip that stuff
1082 * here, but just to be on the safe side (i.e. since uClibc
1083 * wordexp doesn't do this stuff yet), lets leave it in for
1084 * now. */
Eric Andersen195743f2001-03-09 19:21:37 +00001085 case '$':
1086 var = itoa(getpid());
1087 break;
1088 case '#':
1089 var = itoa(argc-1);
1090 break;
1091 case '0':case '1':case '2':case '3':case '4':
1092 case '5':case '6':case '7':case '8':case '9':
1093 {
Eric Andersen1ca20a72001-03-21 07:34:27 +00001094 int ixx=*(dst + 1)-48;
1095 if (ixx >= argc) {
Eric Andersen195743f2001-03-09 19:21:37 +00001096 var='\0';
1097 } else {
Eric Andersen1ca20a72001-03-21 07:34:27 +00001098 var = argv[ixx];
Eric Andersen32f8c172001-03-08 17:44:37 +00001099 }
Eric Andersen195743f2001-03-09 19:21:37 +00001100 }
1101 break;
Eric Andersen32f8c172001-03-08 17:44:37 +00001102
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001103 }
Eric Andersencaeeb362001-02-20 06:38:44 +00001104 if (var) {
Eric Andersen195743f2001-03-09 19:21:37 +00001105 /* a single character construction was found, and
1106 * already handled in the case statement */
1107 src=dst+2;
Eric Andersen32f8c172001-03-08 17:44:37 +00001108 } else {
Eric Andersen195743f2001-03-09 19:21:37 +00001109 /* Looks like an environment variable */
1110 char delim_hold;
Eric Andersen34174472001-03-17 00:20:10 +00001111 int num_skip_chars=0;
Eric Andersen74e056b2001-03-09 20:34:46 +00001112 int dstlen = strlen(dst);
1113 /* Is this a ${foo} type variable? */
1114 if (dstlen >=2 && *(dst+1) == '{') {
1115 src=strchr(dst+1, '}');
Eric Andersen34174472001-03-17 00:20:10 +00001116 num_skip_chars=1;
Eric Andersen74e056b2001-03-09 20:34:46 +00001117 } else {
Eric Andersen34174472001-03-17 00:20:10 +00001118 src=dst+1;
1119 while(isalnum(*src) || *src=='_') src++;
Eric Andersen74e056b2001-03-09 20:34:46 +00001120 }
Eric Andersen195743f2001-03-09 19:21:37 +00001121 if (src == NULL) {
Eric Andersen74e056b2001-03-09 20:34:46 +00001122 src = dst+dstlen;
Eric Andersen32f8c172001-03-08 17:44:37 +00001123 }
Eric Andersen195743f2001-03-09 19:21:37 +00001124 delim_hold=*src;
1125 *src='\0'; /* temporary */
Eric Andersen34174472001-03-17 00:20:10 +00001126 var = getenv(dst + 1 + num_skip_chars);
Eric Andersen195743f2001-03-09 19:21:37 +00001127 *src=delim_hold;
Eric Andersen34174472001-03-17 00:20:10 +00001128 src += num_skip_chars;
Eric Andersen195743f2001-03-09 19:21:37 +00001129 }
1130 if (var == NULL) {
1131 /* Seems we got an un-expandable variable. So delete it. */
1132 var = "";
1133 }
1134 {
1135 int subst_len = strlen(var);
1136 int trail_len = strlen(src);
1137 if (dst+subst_len+trail_len >= command+BUFSIZ) {
1138 error_msg(out_of_space);
1139 return FALSE;
1140 }
1141 /* Move stuff to the end of the string to accommodate
1142 * filling the created gap with the new stuff */
Eric Andersen34174472001-03-17 00:20:10 +00001143 memmove(dst+subst_len, src, trail_len+1);
Eric Andersen195743f2001-03-09 19:21:37 +00001144 /* Now copy in the new stuff */
1145 memcpy(dst, var, subst_len);
1146 src = dst+subst_len;
Eric Andersencaeeb362001-02-20 06:38:44 +00001147 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001148 }
Eric Andersenca604592001-03-08 17:17:13 +00001149
1150#endif
1151 return TRUE;
Erik Andersen3522eb12000-03-12 23:49:18 +00001152}
1153
Eric Andersen86349772000-12-18 20:25:50 +00001154/* Return cmd->num_progs as 0 if no command is present (e.g. an empty
1155 line). If a valid command is found, command_ptr is set to point to
Erik Andersen3522eb12000-03-12 23:49:18 +00001156 the beginning of the next command (if the original command had more
1157 then one job associated with it) or NULL if no more commands are
1158 present. */
Eric Andersen86349772000-12-18 20:25:50 +00001159static int parse_command(char **command_ptr, struct job *job, int *inbg)
Erik Andersen3522eb12000-03-12 23:49:18 +00001160{
Erik Andersen161220c2000-03-16 08:12:48 +00001161 char *command;
Eric Andersen86349772000-12-18 20:25:50 +00001162 char *return_command = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001163 char *src, *buf, *chptr;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001164 int argc_l = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001165 int done = 0;
Eric Andersen86349772000-12-18 20:25:50 +00001166 int argv_alloced;
Erik Andersen161220c2000-03-16 08:12:48 +00001167 int i;
1168 char quote = '\0';
1169 int count;
Eric Andersen86349772000-12-18 20:25:50 +00001170 struct child_prog *prog;
Erik Andersen3522eb12000-03-12 23:49:18 +00001171
Erik Andersen161220c2000-03-16 08:12:48 +00001172 /* skip leading white space */
Eric Andersen86349772000-12-18 20:25:50 +00001173 while (**command_ptr && isspace(**command_ptr))
1174 (*command_ptr)++;
Erik Andersen3522eb12000-03-12 23:49:18 +00001175
Erik Andersen161220c2000-03-16 08:12:48 +00001176 /* this handles empty lines or leading '#' characters */
Eric Andersen86349772000-12-18 20:25:50 +00001177 if (!**command_ptr || (**command_ptr == '#')) {
1178 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001179 return 0;
1180 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001181
Eric Andersen86349772000-12-18 20:25:50 +00001182 *inbg = 0;
1183 job->num_progs = 1;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001184 job->progs = xmalloc(sizeof(*job->progs));
Erik Andersen3522eb12000-03-12 23:49:18 +00001185
Erik Andersen161220c2000-03-16 08:12:48 +00001186 /* We set the argv elements to point inside of this string. The
Eric Andersen86349772000-12-18 20:25:50 +00001187 memory is freed by free_job(). Allocate twice the original
Eric Andersenb54833c2000-07-03 23:56:26 +00001188 length in case we need to quote every single character.
Erik Andersen3522eb12000-03-12 23:49:18 +00001189
Erik Andersen161220c2000-03-16 08:12:48 +00001190 Getting clean memory relieves us of the task of NULL
1191 terminating things and makes the rest of this look a bit
1192 cleaner (though it is, admittedly, a tad less efficient) */
Eric Andersen86349772000-12-18 20:25:50 +00001193 job->cmdbuf = command = xcalloc(2*strlen(*command_ptr) + 1, sizeof(char));
Erik Andersen161220c2000-03-16 08:12:48 +00001194 job->text = NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +00001195
Erik Andersen161220c2000-03-16 08:12:48 +00001196 prog = job->progs;
Eric Andersen86349772000-12-18 20:25:50 +00001197 prog->num_redirects = 0;
1198 prog->redirects = NULL;
Eric Andersen86349772000-12-18 20:25:50 +00001199 prog->is_stopped = 0;
1200 prog->family = job;
Erik Andersen3522eb12000-03-12 23:49:18 +00001201
Eric Andersen86349772000-12-18 20:25:50 +00001202 argv_alloced = 5;
1203 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
1204 prog->argv[0] = job->cmdbuf;
Erik Andersen3522eb12000-03-12 23:49:18 +00001205
Erik Andersen161220c2000-03-16 08:12:48 +00001206 buf = command;
Eric Andersen86349772000-12-18 20:25:50 +00001207 src = *command_ptr;
Erik Andersen161220c2000-03-16 08:12:48 +00001208 while (*src && !done) {
1209 if (quote == *src) {
1210 quote = '\0';
1211 } else if (quote) {
1212 if (*src == '\\') {
1213 src++;
1214 if (!*src) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001215 error_msg("character expected after \\");
Eric Andersen86349772000-12-18 20:25:50 +00001216 free_job(job);
Erik Andersen161220c2000-03-16 08:12:48 +00001217 return 1;
1218 }
1219
1220 /* in shell, "\'" should yield \' */
Eric Andersenb2356f62000-12-11 19:14:40 +00001221 if (*src != quote) {
Erik Andersen161220c2000-03-16 08:12:48 +00001222 *buf++ = '\\';
Eric Andersenb2356f62000-12-11 19:14:40 +00001223 *buf++ = '\\';
1224 }
Erik Andersen161220c2000-03-16 08:12:48 +00001225 } else if (*src == '*' || *src == '?' || *src == '[' ||
1226 *src == ']') *buf++ = '\\';
1227 *buf++ = *src;
1228 } else if (isspace(*src)) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001229 if (*prog->argv[argc_l]) {
1230 buf++, argc_l++;
Erik Andersen161220c2000-03-16 08:12:48 +00001231 /* +1 here leaves room for the NULL which ends argv */
Eric Andersen86349772000-12-18 20:25:50 +00001232 if ((argc_l + 1) == argv_alloced) {
1233 argv_alloced += 5;
Matt Kraaib8907522000-09-13 02:08:21 +00001234 prog->argv = xrealloc(prog->argv,
1235 sizeof(*prog->argv) *
Eric Andersen86349772000-12-18 20:25:50 +00001236 argv_alloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001237 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001238 prog->argv[argc_l] = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001239 }
1240 } else
1241 switch (*src) {
1242 case '"':
1243 case '\'':
1244 quote = *src;
1245 break;
1246
1247 case '#': /* comment */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001248 if (*(src-1)== '$')
1249 *buf++ = *src;
1250 else
1251 done = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001252 break;
1253
Eric Andersen86349772000-12-18 20:25:50 +00001254 case '>': /* redirects */
Erik Andersen161220c2000-03-16 08:12:48 +00001255 case '<':
Eric Andersen86349772000-12-18 20:25:50 +00001256 i = prog->num_redirects++;
1257 prog->redirects = xrealloc(prog->redirects,
1258 sizeof(*prog->redirects) *
Matt Kraaib8907522000-09-13 02:08:21 +00001259 (i + 1));
Erik Andersen161220c2000-03-16 08:12:48 +00001260
Eric Andersen86349772000-12-18 20:25:50 +00001261 prog->redirects[i].fd = -1;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001262 if (buf != prog->argv[argc_l]) {
Erik Andersen161220c2000-03-16 08:12:48 +00001263 /* the stuff before this character may be the file number
1264 being redirected */
Eric Andersen86349772000-12-18 20:25:50 +00001265 prog->redirects[i].fd =
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001266 strtol(prog->argv[argc_l], &chptr, 10);
Erik Andersen161220c2000-03-16 08:12:48 +00001267
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001268 if (*chptr && *prog->argv[argc_l]) {
1269 buf++, argc_l++;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001270 prog->argv[argc_l] = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001271 }
1272 }
1273
Eric Andersen86349772000-12-18 20:25:50 +00001274 if (prog->redirects[i].fd == -1) {
Erik Andersen161220c2000-03-16 08:12:48 +00001275 if (*src == '>')
Eric Andersen86349772000-12-18 20:25:50 +00001276 prog->redirects[i].fd = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001277 else
Eric Andersen86349772000-12-18 20:25:50 +00001278 prog->redirects[i].fd = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001279 }
1280
1281 if (*src++ == '>') {
1282 if (*src == '>')
Eric Andersen86349772000-12-18 20:25:50 +00001283 prog->redirects[i].type =
Erik Andersen161220c2000-03-16 08:12:48 +00001284 REDIRECT_APPEND, src++;
1285 else
Eric Andersen86349772000-12-18 20:25:50 +00001286 prog->redirects[i].type = REDIRECT_OVERWRITE;
Erik Andersen161220c2000-03-16 08:12:48 +00001287 } else {
Eric Andersen86349772000-12-18 20:25:50 +00001288 prog->redirects[i].type = REDIRECT_INPUT;
Erik Andersen161220c2000-03-16 08:12:48 +00001289 }
1290
1291 /* This isn't POSIX sh compliant. Oh well. */
1292 chptr = src;
1293 while (isspace(*chptr))
1294 chptr++;
1295
1296 if (!*chptr) {
Mark Whitley44a99142001-03-14 17:26:37 +00001297 error_msg("file name expected after %c", *(src-1));
Eric Andersen86349772000-12-18 20:25:50 +00001298 free_job(job);
1299 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001300 return 1;
1301 }
1302
Eric Andersen86349772000-12-18 20:25:50 +00001303 prog->redirects[i].filename = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001304 while (*chptr && !isspace(*chptr))
1305 *buf++ = *chptr++;
1306
1307 src = chptr - 1; /* we src++ later */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001308 prog->argv[argc_l] = ++buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001309 break;
1310
1311 case '|': /* pipe */
1312 /* finish this command */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001313 if (*prog->argv[argc_l])
1314 argc_l++;
1315 if (!argc_l) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001316 error_msg("empty command in pipe");
Eric Andersen86349772000-12-18 20:25:50 +00001317 free_job(job);
1318 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001319 return 1;
1320 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001321 prog->argv[argc_l] = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001322
1323 /* and start the next */
Eric Andersen86349772000-12-18 20:25:50 +00001324 job->num_progs++;
Matt Kraaib8907522000-09-13 02:08:21 +00001325 job->progs = xrealloc(job->progs,
Eric Andersen86349772000-12-18 20:25:50 +00001326 sizeof(*job->progs) * job->num_progs);
1327 prog = job->progs + (job->num_progs - 1);
1328 prog->num_redirects = 0;
1329 prog->redirects = NULL;
Eric Andersen86349772000-12-18 20:25:50 +00001330 prog->is_stopped = 0;
1331 prog->family = job;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001332 argc_l = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001333
Eric Andersen86349772000-12-18 20:25:50 +00001334 argv_alloced = 5;
1335 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001336 prog->argv[0] = ++buf;
1337
1338 src++;
1339 while (*src && isspace(*src))
1340 src++;
1341
1342 if (!*src) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001343 error_msg("empty command in pipe");
Eric Andersen86349772000-12-18 20:25:50 +00001344 free_job(job);
1345 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001346 return 1;
1347 }
1348 src--; /* we'll ++ it at the end of the loop */
1349
1350 break;
1351
1352 case '&': /* background */
Eric Andersen86349772000-12-18 20:25:50 +00001353 *inbg = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001354 case ';': /* multiple commands */
1355 done = 1;
Eric Andersen86349772000-12-18 20:25:50 +00001356 return_command = *command_ptr + (src - *command_ptr) + 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001357 break;
1358
Eric Andersena1d187a2000-07-17 19:14:41 +00001359#ifdef BB_FEATURE_SH_BACKTICKS
Eric Andersenec10b9d2000-07-14 01:13:11 +00001360 case '`':
1361 /* Exec a backtick-ed command */
Eric Andersen8ea28be2001-01-05 20:58:22 +00001362 /* Besides any previous brokenness, I have not
1363 * updated backtick handling for close_me support.
1364 * I don't know if it needs it or not. -- LRD */
Eric Andersenec10b9d2000-07-14 01:13:11 +00001365 {
Eric Andersena1d187a2000-07-17 19:14:41 +00001366 char* charptr1=NULL, *charptr2;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001367 char* ptr=NULL;
Eric Andersen86349772000-12-18 20:25:50 +00001368 struct job *newjob;
1369 struct jobset njob_list = { NULL, NULL };
Eric Andersena1d187a2000-07-17 19:14:41 +00001370 int pipefd[2];
1371 int size;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001372
1373 ptr=strchr(++src, '`');
1374 if (ptr==NULL) {
1375 fprintf(stderr, "Unmatched '`' in command\n");
Eric Andersen86349772000-12-18 20:25:50 +00001376 free_job(job);
Eric Andersenec10b9d2000-07-14 01:13:11 +00001377 return 1;
1378 }
1379
Eric Andersena1d187a2000-07-17 19:14:41 +00001380 /* Make some space to hold just the backticked command */
Eric Andersen6efc48c2000-07-18 08:16:39 +00001381 charptr1 = charptr2 = xmalloc(1+ptr-src);
Matt Kraai0b2da462000-09-19 06:46:44 +00001382 memcpy(charptr1, src, ptr-src);
1383 charptr1[ptr-src] = '\0';
Eric Andersen86349772000-12-18 20:25:50 +00001384 newjob = xmalloc(sizeof(struct job));
1385 newjob->job_list = &njob_list;
Eric Andersena1d187a2000-07-17 19:14:41 +00001386 /* Now parse and run the backticked command */
Eric Andersen86349772000-12-18 20:25:50 +00001387 if (!parse_command(&charptr1, newjob, inbg)
1388 && newjob->num_progs) {
Eric Andersena1d187a2000-07-17 19:14:41 +00001389 pipe(pipefd);
Eric Andersen86349772000-12-18 20:25:50 +00001390 run_command(newjob, 0, pipefd);
Eric Andersenec10b9d2000-07-14 01:13:11 +00001391 }
Eric Andersen86349772000-12-18 20:25:50 +00001392 checkjobs(job->job_list);
1393 free_job(newjob); /* doesn't actually free newjob,
1394 looks like a memory leak */
Eric Andersen6efc48c2000-07-18 08:16:39 +00001395 free(charptr2);
1396
1397 /* Make a copy of any stuff left over in the command
1398 * line after the second backtick */
1399 charptr2 = xmalloc(strlen(ptr)+1);
1400 memcpy(charptr2, ptr+1, strlen(ptr));
1401
Eric Andersenec10b9d2000-07-14 01:13:11 +00001402
Eric Andersena1d187a2000-07-17 19:14:41 +00001403 /* Copy the output from the backtick-ed command into the
1404 * command line, making extra room as needed */
1405 --src;
1406 charptr1 = xmalloc(BUFSIZ);
Mark Whitleyf57c9442000-12-07 19:56:48 +00001407 while ( (size=full_read(pipefd[0], charptr1, BUFSIZ-1)) >0) {
Eric Andersen86349772000-12-18 20:25:50 +00001408 int newsize=src - *command_ptr + size + 1 + strlen(charptr2);
1409 if (newsize > BUFSIZ) {
1410 *command_ptr=xrealloc(*command_ptr, newsize);
Eric Andersena1d187a2000-07-17 19:14:41 +00001411 }
1412 memcpy(src, charptr1, size);
1413 src+=size;
1414 }
1415 free(charptr1);
1416 close(pipefd[0]);
1417 if (*(src-1)=='\n')
1418 --src;
1419
Eric Andersen86349772000-12-18 20:25:50 +00001420 /* Now paste into the *command_ptr all the stuff
Eric Andersena1d187a2000-07-17 19:14:41 +00001421 * leftover after the second backtick */
Matt Kraaicbbe4d62000-09-14 00:26:50 +00001422 memcpy(src, charptr2, strlen(charptr2)+1);
Eric Andersena1d187a2000-07-17 19:14:41 +00001423 free(charptr2);
1424
Eric Andersen86349772000-12-18 20:25:50 +00001425 /* Now recursively call parse_command to deal with the new
Eric Andersena1d187a2000-07-17 19:14:41 +00001426 * and improved version of the command line with the backtick
1427 * results expanded in place... */
Eric Andersen86349772000-12-18 20:25:50 +00001428 {
1429 struct jobset *jl=job->job_list;
1430 free_job(job);
1431 job->job_list = jl;
1432 }
1433 return(parse_command(command_ptr, job, inbg));
Eric Andersenec10b9d2000-07-14 01:13:11 +00001434 }
1435 break;
Eric Andersena1d187a2000-07-17 19:14:41 +00001436#endif // BB_FEATURE_SH_BACKTICKS
Matt Kraai131241f2000-09-14 00:43:20 +00001437
1438 case '\\':
1439 src++;
1440 if (!*src) {
Eric Andersen86349772000-12-18 20:25:50 +00001441/* This is currently a little broken... */
1442#ifdef HANDLE_CONTINUATION_CHARS
1443 /* They fed us a continuation char, so continue reading stuff
1444 * on the next line, then tack that onto the end of the current
1445 * command */
1446 char *command;
1447 int newsize;
1448 printf("erik: found a continue char at EOL...\n");
1449 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1450 if (get_command(input, command)) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001451 error_msg("character expected after \\");
Eric Andersen86349772000-12-18 20:25:50 +00001452 free(command);
1453 free_job(job);
1454 return 1;
1455 }
1456 newsize = strlen(*command_ptr) + strlen(command) + 2;
1457 if (newsize > BUFSIZ) {
1458 printf("erik: doing realloc\n");
1459 *command_ptr=xrealloc(*command_ptr, newsize);
1460 }
1461 printf("erik: A: *command_ptr='%s'\n", *command_ptr);
1462 memcpy(--src, command, strlen(command));
1463 printf("erik: B: *command_ptr='%s'\n", *command_ptr);
1464 free(command);
1465 break;
1466#else
Matt Kraaidd19c692001-01-31 19:00:21 +00001467 error_msg("character expected after \\");
Eric Andersen86349772000-12-18 20:25:50 +00001468 free_job(job);
Matt Kraai131241f2000-09-14 00:43:20 +00001469 return 1;
Eric Andersen86349772000-12-18 20:25:50 +00001470#endif
Matt Kraai131241f2000-09-14 00:43:20 +00001471 }
1472 if (*src == '*' || *src == '[' || *src == ']'
1473 || *src == '?') *buf++ = '\\';
1474 /* fallthrough */
Erik Andersen161220c2000-03-16 08:12:48 +00001475 default:
1476 *buf++ = *src;
1477 }
1478
Erik Andersend75af992000-03-16 08:09:09 +00001479 src++;
Erik Andersen161220c2000-03-16 08:12:48 +00001480 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001481
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001482 if (*prog->argv[argc_l]) {
1483 argc_l++;
Erik Andersen161220c2000-03-16 08:12:48 +00001484 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001485 if (!argc_l) {
Eric Andersen86349772000-12-18 20:25:50 +00001486 free_job(job);
Erik Andersen161220c2000-03-16 08:12:48 +00001487 return 0;
1488 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001489 prog->argv[argc_l] = NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +00001490
Eric Andersen86349772000-12-18 20:25:50 +00001491 if (!return_command) {
1492 job->text = xmalloc(strlen(*command_ptr) + 1);
1493 strcpy(job->text, *command_ptr);
Erik Andersen161220c2000-03-16 08:12:48 +00001494 } else {
1495 /* This leaves any trailing spaces, which is a bit sloppy */
Eric Andersen86349772000-12-18 20:25:50 +00001496 count = return_command - *command_ptr;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001497 job->text = xmalloc(count + 1);
Eric Andersen86349772000-12-18 20:25:50 +00001498 strncpy(job->text, *command_ptr, count);
Erik Andersen161220c2000-03-16 08:12:48 +00001499 job->text[count] = '\0';
1500 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001501
Eric Andersen86349772000-12-18 20:25:50 +00001502 *command_ptr = return_command;
Eric Andersen46f0beb2000-11-14 21:59:22 +00001503
Erik Andersend75af992000-03-16 08:09:09 +00001504 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001505}
1506
Eric Andersen86349772000-12-18 20:25:50 +00001507/* Run the child_prog, no matter what kind of command it uses.
1508 */
1509static int pseudo_exec(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +00001510{
Eric Andersen86349772000-12-18 20:25:50 +00001511 struct built_in_command *x;
Eric Andersenb54833c2000-07-03 23:56:26 +00001512#ifdef BB_FEATURE_SH_STANDALONE_SHELL
Eric Andersenaf4ac772001-02-01 22:43:49 +00001513 char *name;
Erik Andersenbcd61772000-05-13 06:33:19 +00001514#endif
Erik Andersen3522eb12000-03-12 23:49:18 +00001515
Eric Andersene9f07fb2000-12-21 18:31:36 +00001516 /* Check if the command matches any of the non-forking builtins.
1517 * Depending on context, this might be redundant. But it's
1518 * easier to waste a few CPU cycles than it is to figure out
1519 * if this is one of those cases.
Eric Andersen86349772000-12-18 20:25:50 +00001520 */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001521 for (x = bltins; x->cmd; x++) {
1522 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1523 exit(x->function(child));
1524 }
1525 }
1526
1527 /* Check if the command matches any of the forking builtins. */
Eric Andersen86349772000-12-18 20:25:50 +00001528 for (x = bltins_forking; x->cmd; x++) {
1529 if (strcmp(child->argv[0], x->cmd) == 0) {
1530 applet_name=x->cmd;
1531 exit (x->function(child));
1532 }
1533 }
1534#ifdef BB_FEATURE_SH_STANDALONE_SHELL
1535 /* Check if the command matches any busybox internal
1536 * commands ("applets") here. Following discussions from
1537 * November 2000 on busybox@opensource.lineo.com, don't use
1538 * get_last_path_component(). This way explicit (with
1539 * slashes) filenames will never be interpreted as an
1540 * applet, just like with builtins. This way the user can
1541 * override an applet with an explicit filename reference.
1542 * The only downside to this change is that an explicit
1543 * /bin/foo invocation will fork and exec /bin/foo, even if
1544 * /bin/foo is a symlink to busybox.
1545 */
Matt Kraaif2cc2762001-02-01 19:21:20 +00001546 name = child->argv[0];
Eric Andersen86349772000-12-18 20:25:50 +00001547
1548#ifdef BB_FEATURE_SH_APPLETS_ALWAYS_WIN
1549 /* If you enable BB_FEATURE_SH_APPLETS_ALWAYS_WIN, then
1550 * if you run /bin/cat, it will use BusyBox cat even if
1551 * /bin/cat exists on the filesystem and is _not_ busybox.
1552 * Some systems want this, others do not. Choose wisely. :-)
1553 */
Matt Kraaif2cc2762001-02-01 19:21:20 +00001554 name = get_last_path_component(name);
Eric Andersen86349772000-12-18 20:25:50 +00001555#endif
1556
Eric Andersen67991cf2001-02-14 21:23:06 +00001557 {
Eric Andersen82ab8da2001-03-23 17:06:01 +00001558 char** argv_l=child->argv;
Eric Andersen67991cf2001-02-14 21:23:06 +00001559 int argc_l;
Eric Andersen82ab8da2001-03-23 17:06:01 +00001560 for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++);
Eric Andersen67991cf2001-02-14 21:23:06 +00001561 optind = 1;
1562 run_applet_by_name(name, argc_l, child->argv);
Eric Andersen86349772000-12-18 20:25:50 +00001563 }
1564#endif
1565
1566 execvp(child->argv[0], child->argv);
Eric Andersen8ea28be2001-01-05 20:58:22 +00001567 perror_msg_and_die("%s", child->argv[0]);
Eric Andersen86349772000-12-18 20:25:50 +00001568}
1569
1570static void insert_job(struct job *newjob, int inbg)
1571{
1572 struct job *thejob;
Eric Andersen1ca20a72001-03-21 07:34:27 +00001573 struct jobset *j_list=newjob->job_list;
Eric Andersen86349772000-12-18 20:25:50 +00001574
1575 /* find the ID for thejob to use */
1576 newjob->jobid = 1;
Eric Andersen1ca20a72001-03-21 07:34:27 +00001577 for (thejob = j_list->head; thejob; thejob = thejob->next)
Eric Andersen86349772000-12-18 20:25:50 +00001578 if (thejob->jobid >= newjob->jobid)
1579 newjob->jobid = thejob->jobid + 1;
1580
1581 /* add thejob to the list of running jobs */
Eric Andersen1ca20a72001-03-21 07:34:27 +00001582 if (!j_list->head) {
1583 thejob = j_list->head = xmalloc(sizeof(*thejob));
Eric Andersen86349772000-12-18 20:25:50 +00001584 } else {
Eric Andersen1ca20a72001-03-21 07:34:27 +00001585 for (thejob = j_list->head; thejob->next; thejob = thejob->next) /* nothing */;
Eric Andersen86349772000-12-18 20:25:50 +00001586 thejob->next = xmalloc(sizeof(*thejob));
1587 thejob = thejob->next;
1588 }
1589
1590 *thejob = *newjob; /* physically copy the struct job */
1591 thejob->next = NULL;
1592 thejob->running_progs = thejob->num_progs;
1593 thejob->stopped_progs = 0;
1594
1595 if (inbg) {
1596 /* we don't wait for background thejobs to return -- append it
1597 to the list of backgrounded thejobs and leave it alone */
1598 printf("[%d] %d\n", thejob->jobid,
1599 newjob->progs[newjob->num_progs - 1].pid);
1600#ifdef BB_FEATURE_SH_ENVIRONMENT
1601 last_bg_pid=newjob->progs[newjob->num_progs - 1].pid;
1602#endif
1603 } else {
1604 newjob->job_list->fg = thejob;
1605
1606 /* move the new process group into the foreground */
1607 /* suppress messages when run from /linuxrc mag@sysgo.de */
1608 if (tcsetpgrp(0, newjob->pgrp) && errno != ENOTTY)
Matt Kraaia9819b22000-12-22 01:48:07 +00001609 perror_msg("tcsetpgrp");
Eric Andersen86349772000-12-18 20:25:50 +00001610 }
1611}
1612
1613static int run_command(struct job *newjob, int inbg, int outpipe[2])
1614{
1615 /* struct job *thejob; */
1616 int i;
1617 int nextin, nextout;
1618 int pipefds[2]; /* pipefd[0] is for reading */
1619 struct built_in_command *x;
1620 struct child_prog *child;
1621
Eric Andersen6efc48c2000-07-18 08:16:39 +00001622 nextin = 0, nextout = 1;
Eric Andersen86349772000-12-18 20:25:50 +00001623 for (i = 0; i < newjob->num_progs; i++) {
1624 child = & (newjob->progs[i]);
1625
1626 if ((i + 1) < newjob->num_progs) {
1627 if (pipe(pipefds)<0) perror_msg_and_die("pipe");
Erik Andersen161220c2000-03-16 08:12:48 +00001628 nextout = pipefds[1];
1629 } else {
Eric Andersen86349772000-12-18 20:25:50 +00001630 if (outpipe[1]!=-1) {
1631 nextout = outpipe[1];
Eric Andersen6efc48c2000-07-18 08:16:39 +00001632 } else {
1633 nextout = 1;
1634 }
Erik Andersen161220c2000-03-16 08:12:48 +00001635 }
1636
Eric Andersen501c88b2000-07-28 15:14:45 +00001637#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen86349772000-12-18 20:25:50 +00001638 if (show_x_trace==TRUE) {
Eric Andersen501c88b2000-07-28 15:14:45 +00001639 int j;
Eric Andersen86349772000-12-18 20:25:50 +00001640 fputc('+', stderr);
1641 for (j = 0; child->argv[j]; j++) {
1642 fputc(' ', stderr);
1643 fputs(child->argv[j], stderr);
1644 }
1645 fputc('\n', stderr);
Eric Andersen501c88b2000-07-28 15:14:45 +00001646 }
1647#endif
1648
Eric Andersene9f07fb2000-12-21 18:31:36 +00001649 /* Check if the command matches any non-forking builtins,
1650 * but only if this is a simple command.
1651 * Non-forking builtins within pipes have to fork anyway,
1652 * and are handled in pseudo_exec. "echo foo | read bar"
1653 * is doomed to failure, and doesn't work on bash, either.
Eric Andersen86349772000-12-18 20:25:50 +00001654 */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001655 if (newjob->num_progs == 1) {
1656 for (x = bltins; x->cmd; x++) {
1657 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1658 int squirrel[] = {-1, -1, -1};
1659 int rcode;
1660 setup_redirects(child, squirrel);
1661 rcode = x->function(child);
1662 restore_redirects(squirrel);
1663 return rcode;
1664 }
Erik Andersen330fd2b2000-05-19 05:35:19 +00001665 }
1666 }
1667
Eric Andersen86349772000-12-18 20:25:50 +00001668 if (!(child->pid = fork())) {
Erik Andersen161220c2000-03-16 08:12:48 +00001669 signal(SIGTTOU, SIG_DFL);
1670
Eric Andersen8ea28be2001-01-05 20:58:22 +00001671 close_all();
1672
Eric Andersen86349772000-12-18 20:25:50 +00001673 if (outpipe[1]!=-1) {
1674 close(outpipe[0]);
Eric Andersen6efc48c2000-07-18 08:16:39 +00001675 }
1676 if (nextin != 0) {
1677 dup2(nextin, 0);
1678 close(nextin);
1679 }
1680
1681 if (nextout != 1) {
Erik Andersen161220c2000-03-16 08:12:48 +00001682 dup2(nextout, 1);
Eric Andersen86349772000-12-18 20:25:50 +00001683 dup2(nextout, 2); /* Really? */
Erik Andersen161220c2000-03-16 08:12:48 +00001684 close(nextout);
Eric Andersen501c88b2000-07-28 15:14:45 +00001685 close(pipefds[0]);
Erik Andersen161220c2000-03-16 08:12:48 +00001686 }
1687
Eric Andersen86349772000-12-18 20:25:50 +00001688 /* explicit redirects override pipes */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001689 setup_redirects(child,NULL);
Erik Andersen161220c2000-03-16 08:12:48 +00001690
Eric Andersen86349772000-12-18 20:25:50 +00001691 pseudo_exec(child);
Erik Andersen161220c2000-03-16 08:12:48 +00001692 }
Eric Andersen86349772000-12-18 20:25:50 +00001693 if (outpipe[1]!=-1) {
1694 close(outpipe[1]);
Eric Andersena1d187a2000-07-17 19:14:41 +00001695 }
Erik Andersen161220c2000-03-16 08:12:48 +00001696
1697 /* put our child in the process group whose leader is the
1698 first process in this pipe */
Eric Andersen86349772000-12-18 20:25:50 +00001699 setpgid(child->pid, newjob->progs[0].pid);
Erik Andersen161220c2000-03-16 08:12:48 +00001700 if (nextin != 0)
1701 close(nextin);
Eric Andersen6efc48c2000-07-18 08:16:39 +00001702 if (nextout != 1)
Erik Andersen161220c2000-03-16 08:12:48 +00001703 close(nextout);
1704
1705 /* If there isn't another process, nextin is garbage
1706 but it doesn't matter */
1707 nextin = pipefds[0];
1708 }
1709
Eric Andersen86349772000-12-18 20:25:50 +00001710 newjob->pgrp = newjob->progs[0].pid;
Erik Andersen161220c2000-03-16 08:12:48 +00001711
Eric Andersen86349772000-12-18 20:25:50 +00001712 insert_job(newjob, inbg);
Erik Andersen3522eb12000-03-12 23:49:18 +00001713
Erik Andersen161220c2000-03-16 08:12:48 +00001714 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001715}
1716
Erik Andersend75af992000-03-16 08:09:09 +00001717static int busy_loop(FILE * input)
Erik Andersen3522eb12000-03-12 23:49:18 +00001718{
Erik Andersen161220c2000-03-16 08:12:48 +00001719 char *command;
Eric Andersen86349772000-12-18 20:25:50 +00001720 char *next_command = NULL;
1721 struct job newjob;
Eric Andersen1c314ad2000-06-28 16:56:25 +00001722 pid_t parent_pgrp;
Erik Andersen161220c2000-03-16 08:12:48 +00001723 int i;
Eric Andersen86349772000-12-18 20:25:50 +00001724 int inbg;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001725 int status;
Eric Andersen86349772000-12-18 20:25:50 +00001726 newjob.job_list = &job_list;
1727 newjob.job_context = DEFAULT_CONTEXT;
Erik Andersen3522eb12000-03-12 23:49:18 +00001728
Eric Andersen1c314ad2000-06-28 16:56:25 +00001729 /* save current owner of TTY so we can restore it on exit */
1730 parent_pgrp = tcgetpgrp(0);
1731
Matt Kraaib8907522000-09-13 02:08:21 +00001732 command = (char *) xcalloc(BUFSIZ, sizeof(char));
Erik Andersend75af992000-03-16 08:09:09 +00001733
Erik Andersen161220c2000-03-16 08:12:48 +00001734 /* don't pay any attention to this signal; it just confuses
1735 things and isn't really meant for shells anyway */
1736 signal(SIGTTOU, SIG_IGN);
Erik Andersend75af992000-03-16 08:09:09 +00001737
Erik Andersen161220c2000-03-16 08:12:48 +00001738 while (1) {
Eric Andersen86349772000-12-18 20:25:50 +00001739 if (!job_list.fg) {
Erik Andersend75af992000-03-16 08:09:09 +00001740 /* no job is in the foreground */
Erik Andersen3522eb12000-03-12 23:49:18 +00001741
Erik Andersend75af992000-03-16 08:09:09 +00001742 /* see if any background processes have exited */
Eric Andersen86349772000-12-18 20:25:50 +00001743 checkjobs(&job_list);
Erik Andersen3522eb12000-03-12 23:49:18 +00001744
Eric Andersen86349772000-12-18 20:25:50 +00001745 if (!next_command) {
1746 if (get_command(input, command))
Erik Andersen161220c2000-03-16 08:12:48 +00001747 break;
Eric Andersen86349772000-12-18 20:25:50 +00001748 next_command = command;
Erik Andersend75af992000-03-16 08:09:09 +00001749 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001750
Eric Andersenca604592001-03-08 17:17:13 +00001751 if (expand_arguments(next_command) == FALSE) {
1752 free(command);
1753 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1754 next_command = NULL;
1755 continue;
1756 }
1757
Eric Andersen86349772000-12-18 20:25:50 +00001758 if (!parse_command(&next_command, &newjob, &inbg) &&
1759 newjob.num_progs) {
Eric Andersena1d187a2000-07-17 19:14:41 +00001760 int pipefds[2] = {-1,-1};
Eric Andersenb3d6e2d2001-03-13 22:57:56 +00001761 debug_printf( "job=%p fed to run_command by busy_loop()'\n",
1762 &newjob);
Eric Andersen86349772000-12-18 20:25:50 +00001763 run_command(&newjob, inbg, pipefds);
Eric Andersenfad9c112000-07-25 18:06:52 +00001764 }
1765 else {
Eric Andersena1d187a2000-07-17 19:14:41 +00001766 free(command);
Matt Kraaib8907522000-09-13 02:08:21 +00001767 command = (char *) xcalloc(BUFSIZ, sizeof(char));
Eric Andersen86349772000-12-18 20:25:50 +00001768 next_command = NULL;
Erik Andersend75af992000-03-16 08:09:09 +00001769 }
1770 } else {
1771 /* a job is running in the foreground; wait for it */
1772 i = 0;
Eric Andersen86349772000-12-18 20:25:50 +00001773 while (!job_list.fg->progs[i].pid ||
1774 job_list.fg->progs[i].is_stopped == 1) i++;
Erik Andersen3522eb12000-03-12 23:49:18 +00001775
Eric Andersen8ea28be2001-01-05 20:58:22 +00001776 if (waitpid(job_list.fg->progs[i].pid, &status, WUNTRACED)<0)
1777 perror_msg_and_die("waitpid(%d)",job_list.fg->progs[i].pid);
Erik Andersen3522eb12000-03-12 23:49:18 +00001778
Erik Andersend75af992000-03-16 08:09:09 +00001779 if (WIFEXITED(status) || WIFSIGNALED(status)) {
Erik Andersen161220c2000-03-16 08:12:48 +00001780 /* the child exited */
Eric Andersen86349772000-12-18 20:25:50 +00001781 job_list.fg->running_progs--;
1782 job_list.fg->progs[i].pid = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001783
Eric Andersen501c88b2000-07-28 15:14:45 +00001784#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen86349772000-12-18 20:25:50 +00001785 last_return_code=WEXITSTATUS(status);
Eric Andersen86349772000-12-18 20:25:50 +00001786 debug_printf("'%s' exited -- return code %d\n",
1787 job_list.fg->text, last_return_code);
Eric Andersenb180dd92001-03-09 00:42:46 +00001788#endif
Eric Andersen86349772000-12-18 20:25:50 +00001789 if (!job_list.fg->running_progs) {
Erik Andersen161220c2000-03-16 08:12:48 +00001790 /* child exited */
Eric Andersen86349772000-12-18 20:25:50 +00001791 remove_job(&job_list, job_list.fg);
1792 job_list.fg = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001793 }
Erik Andersend75af992000-03-16 08:09:09 +00001794 } else {
Erik Andersen161220c2000-03-16 08:12:48 +00001795 /* the child was stopped */
Eric Andersen86349772000-12-18 20:25:50 +00001796 job_list.fg->stopped_progs++;
1797 job_list.fg->progs[i].is_stopped = 1;
Erik Andersen3522eb12000-03-12 23:49:18 +00001798
Eric Andersen86349772000-12-18 20:25:50 +00001799 if (job_list.fg->stopped_progs == job_list.fg->running_progs) {
1800 printf("\n" JOB_STATUS_FORMAT, job_list.fg->jobid,
1801 "Stopped", job_list.fg->text);
1802 job_list.fg = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001803 }
Erik Andersend75af992000-03-16 08:09:09 +00001804 }
1805
Eric Andersen86349772000-12-18 20:25:50 +00001806 if (!job_list.fg) {
Erik Andersen161220c2000-03-16 08:12:48 +00001807 /* move the shell to the foreground */
Eric Andersen1c314ad2000-06-28 16:56:25 +00001808 /* suppress messages when run from /linuxrc mag@sysgo.de */
1809 if (tcsetpgrp(0, getpid()) && errno != ENOTTY)
Matt Kraaia9819b22000-12-22 01:48:07 +00001810 perror_msg("tcsetpgrp");
Erik Andersend75af992000-03-16 08:09:09 +00001811 }
1812 }
1813 }
Erik Andersen161220c2000-03-16 08:12:48 +00001814 free(command);
Erik Andersen3522eb12000-03-12 23:49:18 +00001815
Eric Andersen1c314ad2000-06-28 16:56:25 +00001816 /* return controlling TTY back to parent process group before exiting */
1817 if (tcsetpgrp(0, parent_pgrp))
Matt Kraaia9819b22000-12-22 01:48:07 +00001818 perror_msg("tcsetpgrp");
Eric Andersenb54833c2000-07-03 23:56:26 +00001819
1820 /* return exit status if called with "-c" */
1821 if (input == NULL && WIFEXITED(status))
1822 return WEXITSTATUS(status);
1823
Erik Andersen161220c2000-03-16 08:12:48 +00001824 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001825}
1826
1827
Eric Andersenfad9c112000-07-25 18:06:52 +00001828#ifdef BB_FEATURE_CLEAN_UP
1829void free_memory(void)
1830{
Eric Andersenfad9c112000-07-25 18:06:52 +00001831 if (cwd)
1832 free(cwd);
1833 if (local_pending_command)
1834 free(local_pending_command);
1835
Eric Andersen86349772000-12-18 20:25:50 +00001836 if (job_list.fg && !job_list.fg->running_progs) {
1837 remove_job(&job_list, job_list.fg);
Eric Andersenfad9c112000-07-25 18:06:52 +00001838 }
1839}
1840#endif
1841
Eric Andersen6efc48c2000-07-18 08:16:39 +00001842
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001843int shell_main(int argc_l, char **argv_l)
Erik Andersen3522eb12000-03-12 23:49:18 +00001844{
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001845 int opt, interactive=FALSE;
Erik Andersen161220c2000-03-16 08:12:48 +00001846 FILE *input = stdin;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001847 argc = argc_l;
1848 argv = argv_l;
Erik Andersen3522eb12000-03-12 23:49:18 +00001849
Eric Andersen702ec592001-03-06 22:17:29 +00001850 /* These variables need re-initializing when recursing */
Eric Andersenb0970d42001-01-05 19:34:52 +00001851 shell_context = 0;
1852 cwd=NULL;
Eric Andersenb0970d42001-01-05 19:34:52 +00001853 local_pending_command = NULL;
Eric Andersen702ec592001-03-06 22:17:29 +00001854 close_me_head = NULL;
Eric Andersenb0970d42001-01-05 19:34:52 +00001855 job_list.head = NULL;
1856 job_list.fg = NULL;
1857#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersenca604592001-03-08 17:17:13 +00001858 last_bg_pid=1;
1859 last_return_code=1;
Eric Andersenb0970d42001-01-05 19:34:52 +00001860 show_x_trace=FALSE;
1861#endif
Eric Andersen501c88b2000-07-28 15:14:45 +00001862
Eric Andersenb558e762000-11-30 22:43:16 +00001863 if (argv[0] && argv[0][0] == '-') {
Eric Andersen8ea28be2001-01-05 20:58:22 +00001864 FILE *prof_input;
1865 prof_input = fopen("/etc/profile", "r");
1866 if (!prof_input) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001867 printf( "Couldn't open file '/etc/profile'\n");
Eric Andersen8ea28be2001-01-05 20:58:22 +00001868 } else {
1869 int tmp_fd = fileno(prof_input);
1870 mark_open(tmp_fd);
1871 /* Now run the file */
1872 busy_loop(prof_input);
1873 fclose(prof_input);
1874 mark_closed(tmp_fd);
1875 }
Eric Andersenb558e762000-11-30 22:43:16 +00001876 }
Eric Andersen501c88b2000-07-28 15:14:45 +00001877
Eric Andersenf21aa842000-12-08 20:50:30 +00001878 while ((opt = getopt(argc_l, argv_l, "cxi")) > 0) {
Eric Andersen501c88b2000-07-28 15:14:45 +00001879 switch (opt) {
1880 case 'c':
1881 input = NULL;
Matt Kraai6085c722000-09-06 01:46:18 +00001882 if (local_pending_command != 0)
Matt Kraaidd19c692001-01-31 19:00:21 +00001883 error_msg_and_die("multiple -c arguments");
Matt Kraai6085c722000-09-06 01:46:18 +00001884 local_pending_command = xstrdup(argv[optind]);
1885 optind++;
1886 argv = argv+optind;
Eric Andersen501c88b2000-07-28 15:14:45 +00001887 break;
Eric Andersen1428c4f2000-07-28 15:19:30 +00001888#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen501c88b2000-07-28 15:14:45 +00001889 case 'x':
Eric Andersen86349772000-12-18 20:25:50 +00001890 show_x_trace = TRUE;
Eric Andersen501c88b2000-07-28 15:14:45 +00001891 break;
Eric Andersen1428c4f2000-07-28 15:19:30 +00001892#endif
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001893 case 'i':
1894 interactive = TRUE;
1895 break;
Eric Andersen501c88b2000-07-28 15:14:45 +00001896 default:
Eric Andersen67991cf2001-02-14 21:23:06 +00001897 show_usage();
Eric Andersen501c88b2000-07-28 15:14:45 +00001898 }
1899 }
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001900 /* A shell is interactive if the `-i' flag was given, or if all of
1901 * the following conditions are met:
1902 * no -c command
1903 * no arguments remaining or the -s flag given
1904 * standard input is a terminal
1905 * standard output is a terminal
1906 * Refer to Posix.2, the description of the `sh' utility. */
Eric Andersen86349772000-12-18 20:25:50 +00001907 if (argv[optind]==NULL && input==stdin &&
1908 isatty(fileno(stdin)) && isatty(fileno(stdout))) {
1909 interactive=TRUE;
1910 }
1911 if (interactive==TRUE) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001912 //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
Eric Andersen501c88b2000-07-28 15:14:45 +00001913 /* Looks like they want an interactive shell */
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001914 printf( "\n\nBusyBox v%s (%s) Built-in shell (lash)\n", BB_VER, BB_BT);
1915 printf( "Enter 'help' for a list of built-in commands.\n\n");
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001916 } else if (local_pending_command==NULL) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001917 //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
Matt Kraaibbaef662000-09-27 02:43:35 +00001918 input = xfopen(argv[optind], "r");
Eric Andersen8ea28be2001-01-05 20:58:22 +00001919 mark_open(fileno(input)); /* be lazy, never mark this closed */
Eric Andersen501c88b2000-07-28 15:14:45 +00001920 }
1921
Eric Andersen6efc48c2000-07-18 08:16:39 +00001922 /* initialize the cwd -- this is never freed...*/
1923 cwd=(char*)xmalloc(sizeof(char)*MAX_LINE+1);
1924 getcwd(cwd, sizeof(char)*MAX_LINE);
Erik Andersen3522eb12000-03-12 23:49:18 +00001925
Eric Andersenfad9c112000-07-25 18:06:52 +00001926#ifdef BB_FEATURE_CLEAN_UP
1927 atexit(free_memory);
1928#endif
1929
Eric Andersenb3d6e2d2001-03-13 22:57:56 +00001930#ifdef BB_FEATURE_COMMAND_EDITING
1931 cmdedit_set_initial_prompt();
1932#else
1933 PS1 = NULL;
1934 PS2 = "> ";
1935#endif
1936
Erik Andersen161220c2000-03-16 08:12:48 +00001937 return (busy_loop(input));
Erik Andersen3522eb12000-03-12 23:49:18 +00001938}
Eric Andersenb3d6e2d2001-03-13 22:57:56 +00001939