blob: 16401225edf0ea4ac09ed52babb007ab44415f06 [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 Andersenbdfd0d72001-10-24 05:00:29 +00005 * Copyright (C) 1999,2000 by Lineo, inc. and Erik Andersen
6 * Copyright (C) 1999,2000,2001 by Erik Andersen <andersee@debian.org>
Erik Andersen3522eb12000-03-12 23:49:18 +00007 *
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 Andersenbdfd0d72001-10-24 05:00:29 +000028/* This shell's parsing engine is officially at a dead-end. Future
29 * work shell work should be done using hush, msh, or ash. This is
30 * still a very useful, small shell -- it just don't need any more
31 * features beyond what it already has...
Eric Andersen8ea28be2001-01-05 20:58:22 +000032 */
Eric Andersen8a646dd2001-06-21 16:38:11 +000033
Eric Andersen1e7cea92000-12-06 23:47:38 +000034//For debugging/development on the shell only...
Eric Andersen501c88b2000-07-28 15:14:45 +000035//#define DEBUG_SHELL
Eric Andersena1d187a2000-07-17 19:14:41 +000036
37
Erik Andersen3522eb12000-03-12 23:49:18 +000038#include <stdio.h>
39#include <stdlib.h>
40#include <ctype.h>
41#include <errno.h>
42#include <fcntl.h>
Erik Andersen3522eb12000-03-12 23:49:18 +000043#include <signal.h>
44#include <string.h>
45#include <sys/ioctl.h>
46#include <sys/wait.h>
47#include <unistd.h>
Eric Andersen501c88b2000-07-28 15:14:45 +000048#include <getopt.h>
Eric Andersen2d848a42001-06-25 17:11:54 +000049#include <termios.h>
Mark Whitley4b541a82001-04-25 17:10:30 +000050#include "busybox.h"
51#include "cmdedit.h"
Eric Andersene5dfced2001-04-09 22:48:12 +000052
Eric Andersenbdfd0d72001-10-24 05:00:29 +000053#ifdef CONFIG_LOCALE_SUPPORT
Mark Whitley1c6581a2001-03-27 16:35:16 +000054#include <locale.h>
Eric Andersene5dfced2001-04-09 22:48:12 +000055#endif
Eric Andersen13d1fa12001-03-08 23:59:45 +000056
Eric Andersen13d1fa12001-03-08 23:59:45 +000057#include <glob.h>
58#define expand_t glob_t
Erik Andersen3522eb12000-03-12 23:49:18 +000059
Eric Andersen13d1fa12001-03-08 23:59:45 +000060
Mark Whitley59ab0252001-01-23 22:30:04 +000061static const int MAX_READ = 128; /* size of input buffer for `read' builtin */
Erik Andersen3522eb12000-03-12 23:49:18 +000062#define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
63
Erik Andersend75af992000-03-16 08:09:09 +000064
Eric Andersen86349772000-12-18 20:25:50 +000065enum redir_type { REDIRECT_INPUT, REDIRECT_OVERWRITE,
Erik Andersen161220c2000-03-16 08:12:48 +000066 REDIRECT_APPEND
67};
Erik Andersen3522eb12000-03-12 23:49:18 +000068
Eric Andersen86349772000-12-18 20:25:50 +000069static const unsigned int DEFAULT_CONTEXT=0x1;
Eric Andersen6a99aaf2000-07-27 00:15:20 +000070static const unsigned int IF_TRUE_CONTEXT=0x2;
71static const unsigned int IF_FALSE_CONTEXT=0x4;
72static const unsigned int THEN_EXP_CONTEXT=0x8;
73static const unsigned int ELSE_EXP_CONTEXT=0x10;
Eric Andersenfad9c112000-07-25 18:06:52 +000074
Eric Andersen86349772000-12-18 20:25:50 +000075
76struct jobset {
Erik Andersen161220c2000-03-16 08:12:48 +000077 struct job *head; /* head of list of running jobs */
78 struct job *fg; /* current foreground job */
Erik Andersen3522eb12000-03-12 23:49:18 +000079};
80
Eric Andersen86349772000-12-18 20:25:50 +000081struct redir_struct {
82 enum redir_type type; /* type of redirection */
Erik Andersen161220c2000-03-16 08:12:48 +000083 int fd; /* file descriptor being redirected */
84 char *filename; /* file to redirect fd to */
Erik Andersen3522eb12000-03-12 23:49:18 +000085};
86
Eric Andersen86349772000-12-18 20:25:50 +000087struct child_prog {
Erik Andersen161220c2000-03-16 08:12:48 +000088 pid_t pid; /* 0 if exited */
89 char **argv; /* program name and arguments */
Eric Andersen86349772000-12-18 20:25:50 +000090 int num_redirects; /* elements in redirection array */
91 struct redir_struct *redirects; /* I/O redirects */
Eric Andersen86349772000-12-18 20:25:50 +000092 int is_stopped; /* is the program currently running? */
93 struct job *family; /* pointer back to the child's parent job */
Erik Andersen3522eb12000-03-12 23:49:18 +000094};
95
96struct job {
Eric Andersen86349772000-12-18 20:25:50 +000097 int jobid; /* job number */
98 int num_progs; /* total number of programs in job */
99 int running_progs; /* number of programs running */
Erik Andersen161220c2000-03-16 08:12:48 +0000100 char *text; /* name of job */
Eric Andersen86349772000-12-18 20:25:50 +0000101 char *cmdbuf; /* buffer various argv's point into */
Erik Andersen161220c2000-03-16 08:12:48 +0000102 pid_t pgrp; /* process group ID for the job */
Eric Andersen86349772000-12-18 20:25:50 +0000103 struct child_prog *progs; /* array of programs in job */
Erik Andersen161220c2000-03-16 08:12:48 +0000104 struct job *next; /* to track background commands */
Eric Andersen86349772000-12-18 20:25:50 +0000105 int stopped_progs; /* number of programs alive, but stopped */
106 unsigned int job_context; /* bitmask defining current context */
107 struct jobset *job_list;
Erik Andersen3522eb12000-03-12 23:49:18 +0000108};
109
Eric Andersen86349772000-12-18 20:25:50 +0000110struct built_in_command {
Erik Andersen161220c2000-03-16 08:12:48 +0000111 char *cmd; /* name */
112 char *descr; /* description */
Eric Andersen86349772000-12-18 20:25:50 +0000113 int (*function) (struct child_prog *); /* function ptr */
Erik Andersen3522eb12000-03-12 23:49:18 +0000114};
115
Eric Andersen8ea28be2001-01-05 20:58:22 +0000116struct close_me {
117 int fd;
118 struct close_me *next;
119};
120
Eric Andersen34e19412000-07-10 18:47:24 +0000121/* function prototypes for builtins */
Eric Andersen86349772000-12-18 20:25:50 +0000122static int builtin_cd(struct child_prog *cmd);
Eric Andersen86349772000-12-18 20:25:50 +0000123static int builtin_exec(struct child_prog *cmd);
124static int builtin_exit(struct child_prog *cmd);
125static int builtin_fg_bg(struct child_prog *cmd);
126static int builtin_help(struct child_prog *cmd);
127static int builtin_jobs(struct child_prog *dummy);
128static int builtin_pwd(struct child_prog *dummy);
129static int builtin_export(struct child_prog *cmd);
130static int builtin_source(struct child_prog *cmd);
131static int builtin_unset(struct child_prog *cmd);
132static int builtin_read(struct child_prog *cmd);
Erik Andersen3522eb12000-03-12 23:49:18 +0000133
Eric Andersen34e19412000-07-10 18:47:24 +0000134
135/* function prototypes for shell stuff */
Eric Andersen8ea28be2001-01-05 20:58:22 +0000136static void mark_open(int fd);
137static void mark_closed(int fd);
Eric Andersen36278b92001-03-06 20:47:31 +0000138static void close_all(void);
Eric Andersen86349772000-12-18 20:25:50 +0000139static void checkjobs(struct jobset *job_list);
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000140static void remove_job(struct jobset *j_list, struct job *job);
Eric Andersen86349772000-12-18 20:25:50 +0000141static int get_command(FILE * source, char *command);
142static int parse_command(char **command_ptr, struct job *job, int *inbg);
143static int run_command(struct job *newjob, int inbg, int outpipe[2]);
144static int pseudo_exec(struct child_prog *cmd) __attribute__ ((noreturn));
Erik Andersen3522eb12000-03-12 23:49:18 +0000145static int busy_loop(FILE * input);
146
Erik Andersend75af992000-03-16 08:09:09 +0000147
Mark Whitley37653aa2000-07-12 23:36:17 +0000148/* Table of built-in functions (these are non-forking builtins, meaning they
149 * can change global variables in the parent shell process but they will not
150 * work with pipes and redirects; 'unset foo | whatever' will not work) */
Eric Andersen86349772000-12-18 20:25:50 +0000151static struct built_in_command bltins[] = {
Eric Andersenfad9c112000-07-25 18:06:52 +0000152 {"bg", "Resume a job in the background", builtin_fg_bg},
153 {"cd", "Change working directory", builtin_cd},
Eric Andersend2f56772000-09-21 02:48:07 +0000154 {"exec", "Exec command, replacing this shell with the exec'd process", builtin_exec},
Eric Andersenfad9c112000-07-25 18:06:52 +0000155 {"exit", "Exit from shell()", builtin_exit},
156 {"fg", "Bring job into the foreground", builtin_fg_bg},
157 {"jobs", "Lists the active jobs", builtin_jobs},
158 {"export", "Set environment variable", builtin_export},
159 {"unset", "Unset environment variable", builtin_unset},
160 {"read", "Input environment variable", builtin_read},
Matt Kraaidd450a02000-09-13 03:43:36 +0000161 {".", "Source-in and run commands in a file", builtin_source},
Eric Andersen86349772000-12-18 20:25:50 +0000162 /* to do: add ulimit */
Eric Andersenfad9c112000-07-25 18:06:52 +0000163 {NULL, NULL, NULL}
Erik Andersen330fd2b2000-05-19 05:35:19 +0000164};
165
Mark Whitley37653aa2000-07-12 23:36:17 +0000166/* Table of forking built-in functions (things that fork cannot change global
167 * variables in the parent process, such as the current working directory) */
Eric Andersen86349772000-12-18 20:25:50 +0000168static struct built_in_command bltins_forking[] = {
Eric Andersenfad9c112000-07-25 18:06:52 +0000169 {"pwd", "Print current directory", builtin_pwd},
Eric Andersenfad9c112000-07-25 18:06:52 +0000170 {"help", "List shell built-in commands", builtin_help},
171 {NULL, NULL, NULL}
Erik Andersen3522eb12000-03-12 23:49:18 +0000172};
173
Eric Andersen0bcc8132001-01-05 19:37:32 +0000174
Eric Andersen7467c8d2001-07-12 20:26:32 +0000175static int shell_context; /* Type prompt trigger (PS1 or PS2) */
Eric Andersen0bcc8132001-01-05 19:37:32 +0000176
177
178/* Globals that are static to this file */
Eric Andersencfa88ec2001-05-11 18:08:16 +0000179static const char *cwd;
Eric Andersen744b0642001-01-05 21:23:44 +0000180static char *local_pending_command = NULL;
Eric Andersen86349772000-12-18 20:25:50 +0000181static struct jobset job_list = { NULL, NULL };
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000182static int argc;
183static char **argv;
Eric Andersen702ec592001-03-06 22:17:29 +0000184static struct close_me *close_me_head;
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000185static int last_return_code;
186static int last_bg_pid;
Eric Andersen8a646dd2001-06-21 16:38:11 +0000187static unsigned int last_jobid;
Eric Andersen2d848a42001-06-25 17:11:54 +0000188static int shell_terminal;
189static pid_t shell_pgrp;
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000190static char *PS1;
Eric Andersene5dfced2001-04-09 22:48:12 +0000191static char *PS2 = "> ";
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000192
193
Eric Andersenb558e762000-11-30 22:43:16 +0000194#ifdef DEBUG_SHELL
195static inline void debug_printf(const char *format, ...)
196{
197 va_list args;
198 va_start(args, format);
Eric Andersen86349772000-12-18 20:25:50 +0000199 vfprintf(stderr, format, args);
Eric Andersenb558e762000-11-30 22:43:16 +0000200 va_end(args);
201}
202#else
203static inline void debug_printf(const char *format, ...) { }
204#endif
Erik Andersen3522eb12000-03-12 23:49:18 +0000205
Eric Andersen86349772000-12-18 20:25:50 +0000206/*
207 Most builtins need access to the struct child_prog that has
208 their arguments, previously coded as cmd->progs[0]. That coding
209 can exhibit a bug, if the builtin is not the first command in
210 a pipeline: "echo foo | exec sort" will attempt to exec foo.
211
212builtin previous use notes
213------ ----------------- ---------
214cd cmd->progs[0]
Eric Andersen86349772000-12-18 20:25:50 +0000215exec cmd->progs[0] squashed bug: didn't look for applets or forking builtins
216exit cmd->progs[0]
217fg_bg cmd->progs[0], job_list->head, job_list->fg
218help 0
219jobs job_list->head
220pwd 0
Eric Andersen84e229c2001-03-29 22:48:33 +0000221export cmd->progs[0]
Eric Andersen86349772000-12-18 20:25:50 +0000222source cmd->progs[0]
223unset cmd->progs[0]
224read cmd->progs[0]
Eric Andersen86349772000-12-18 20:25:50 +0000225
226I added "struct job *family;" to struct child_prog,
227and switched API to builtin_foo(struct child_prog *child);
228So cmd->text becomes child->family->text
229 cmd->job_context becomes child->family->job_context
230 cmd->progs[0] becomes *child
231 job_list becomes child->family->job_list
232 */
Erik Andersen3522eb12000-03-12 23:49:18 +0000233
Erik Andersend75af992000-03-16 08:09:09 +0000234/* built-in 'cd <path>' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000235static int builtin_cd(struct child_prog *child)
Erik Andersend75af992000-03-16 08:09:09 +0000236{
Erik Andersen161220c2000-03-16 08:12:48 +0000237 char *newdir;
Erik Andersend75af992000-03-16 08:09:09 +0000238
Eric Andersen86349772000-12-18 20:25:50 +0000239 if (child->argv[1] == NULL)
Erik Andersen161220c2000-03-16 08:12:48 +0000240 newdir = getenv("HOME");
241 else
Eric Andersen86349772000-12-18 20:25:50 +0000242 newdir = child->argv[1];
Erik Andersen161220c2000-03-16 08:12:48 +0000243 if (chdir(newdir)) {
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000244 printf("cd: %s: %m\n", newdir);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000245 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000246 }
Eric Andersencfa88ec2001-05-11 18:08:16 +0000247 cwd = xgetcwd((char *)cwd);
Eric Andersen5f265b72001-05-11 16:58:46 +0000248 if (!cwd)
249 cwd = unknown;
Matt Kraai3e856ce2000-12-01 02:55:13 +0000250 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000251}
252
Eric Andersend2f56772000-09-21 02:48:07 +0000253/* built-in 'exec' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000254static int builtin_exec(struct child_prog *child)
Eric Andersend2f56772000-09-21 02:48:07 +0000255{
Eric Andersen86349772000-12-18 20:25:50 +0000256 if (child->argv[1] == NULL)
257 return EXIT_SUCCESS; /* Really? */
258 child->argv++;
Eric Andersen07f2f392001-03-06 20:28:22 +0000259 close_all();
Eric Andersen86349772000-12-18 20:25:50 +0000260 pseudo_exec(child);
261 /* never returns */
Eric Andersend2f56772000-09-21 02:48:07 +0000262}
263
Erik Andersen3522eb12000-03-12 23:49:18 +0000264/* built-in 'exit' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000265static int builtin_exit(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000266{
Eric Andersen86349772000-12-18 20:25:50 +0000267 if (child->argv[1] == NULL)
Matt Kraai3e856ce2000-12-01 02:55:13 +0000268 exit(EXIT_SUCCESS);
Erik Andersen161220c2000-03-16 08:12:48 +0000269
Eric Andersen86349772000-12-18 20:25:50 +0000270 exit (atoi(child->argv[1]));
Erik Andersen3522eb12000-03-12 23:49:18 +0000271}
272
273/* built-in 'fg' and 'bg' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000274static int builtin_fg_bg(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000275{
Eric Andersen8a646dd2001-06-21 16:38:11 +0000276 int i, jobnum;
Erik Andersen6273f652000-03-17 01:12:41 +0000277 struct job *job=NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +0000278
Eric Andersen8a646dd2001-06-21 16:38:11 +0000279 /* If they gave us no args, assume they want the last backgrounded task */
280 if (!child->argv[1]) {
281 for (job = child->family->job_list->head; job; job = job->next) {
282 if (job->jobid == last_jobid) {
283 break;
284 }
Erik Andersen161220c2000-03-16 08:12:48 +0000285 }
Eric Andersen8a646dd2001-06-21 16:38:11 +0000286 if (!job) {
287 error_msg("%s: no current job", child->argv[0]);
288 return EXIT_FAILURE;
289 }
290 } else {
291 if (sscanf(child->argv[1], "%%%d", &jobnum) != 1) {
292 error_msg("%s: bad argument '%s'", child->argv[0], child->argv[1]);
293 return EXIT_FAILURE;
294 }
295 for (job = child->family->job_list->head; job; job = job->next) {
296 if (job->jobid == jobnum) {
297 break;
298 }
299 }
300 if (!job) {
301 error_msg("%s: %d: no such job", child->argv[0], jobnum);
302 return EXIT_FAILURE;
303 }
Erik Andersend75af992000-03-16 08:09:09 +0000304 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000305
Eric Andersen86349772000-12-18 20:25:50 +0000306 if (*child->argv[0] == 'f') {
Eric Andersen2d848a42001-06-25 17:11:54 +0000307 /* Put the job into the foreground. */
308 tcsetpgrp(shell_terminal, job->pgrp);
309
Eric Andersen86349772000-12-18 20:25:50 +0000310 child->family->job_list->fg = job;
Erik Andersen161220c2000-03-16 08:12:48 +0000311 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000312
Erik Andersen161220c2000-03-16 08:12:48 +0000313 /* Restart the processes in the job */
Eric Andersen86349772000-12-18 20:25:50 +0000314 for (i = 0; i < job->num_progs; i++)
315 job->progs[i].is_stopped = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000316
Eric Andersen86349772000-12-18 20:25:50 +0000317 job->stopped_progs = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000318
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000319 if ( (i=kill(- job->pgrp, SIGCONT)) < 0) {
320 if (i == ESRCH) {
321 remove_job(&job_list, job);
Eric Andersen07abfe22001-06-27 17:29:11 +0000322 } else {
323 perror_msg("kill (SIGCONT)");
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000324 }
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000325 }
Eric Andersen2d848a42001-06-25 17:11:54 +0000326
Matt Kraai3e856ce2000-12-01 02:55:13 +0000327 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000328}
329
330/* built-in 'help' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000331static int builtin_help(struct child_prog *dummy)
Erik Andersen3522eb12000-03-12 23:49:18 +0000332{
Eric Andersen86349772000-12-18 20:25:50 +0000333 struct built_in_command *x;
Erik Andersen3522eb12000-03-12 23:49:18 +0000334
Eric Andersen86349772000-12-18 20:25:50 +0000335 printf("\nBuilt-in commands:\n");
336 printf("-------------------\n");
Erik Andersen161220c2000-03-16 08:12:48 +0000337 for (x = bltins; x->cmd; x++) {
Eric Andersenfad9c112000-07-25 18:06:52 +0000338 if (x->descr==NULL)
339 continue;
Eric Andersen86349772000-12-18 20:25:50 +0000340 printf("%s\t%s\n", x->cmd, x->descr);
Erik Andersen161220c2000-03-16 08:12:48 +0000341 }
Erik Andersen330fd2b2000-05-19 05:35:19 +0000342 for (x = bltins_forking; x->cmd; x++) {
Eric Andersenfad9c112000-07-25 18:06:52 +0000343 if (x->descr==NULL)
344 continue;
Eric Andersen86349772000-12-18 20:25:50 +0000345 printf("%s\t%s\n", x->cmd, x->descr);
Erik Andersen330fd2b2000-05-19 05:35:19 +0000346 }
Eric Andersen86349772000-12-18 20:25:50 +0000347 printf("\n\n");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000348 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000349}
350
351/* built-in 'jobs' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000352static int builtin_jobs(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000353{
Erik Andersen161220c2000-03-16 08:12:48 +0000354 struct job *job;
Eric Andersen86349772000-12-18 20:25:50 +0000355 char *status_string;
Erik Andersen3522eb12000-03-12 23:49:18 +0000356
Eric Andersen86349772000-12-18 20:25:50 +0000357 for (job = child->family->job_list->head; job; job = job->next) {
358 if (job->running_progs == job->stopped_progs)
359 status_string = "Stopped";
Erik Andersen161220c2000-03-16 08:12:48 +0000360 else
Eric Andersen86349772000-12-18 20:25:50 +0000361 status_string = "Running";
Erik Andersen161220c2000-03-16 08:12:48 +0000362
Eric Andersen86349772000-12-18 20:25:50 +0000363 printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text);
Erik Andersen161220c2000-03-16 08:12:48 +0000364 }
Matt Kraai3e856ce2000-12-01 02:55:13 +0000365 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000366}
367
368
369/* built-in 'pwd' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000370static int builtin_pwd(struct child_prog *dummy)
Erik Andersen3522eb12000-03-12 23:49:18 +0000371{
Eric Andersencfa88ec2001-05-11 18:08:16 +0000372 cwd = xgetcwd((char *)cwd);
Eric Andersen5f265b72001-05-11 16:58:46 +0000373 if (!cwd)
374 cwd = unknown;
Matt Kraai59df6f72001-05-16 14:21:09 +0000375 puts(cwd);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000376 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000377}
378
Erik Andersen6273f652000-03-17 01:12:41 +0000379/* built-in 'export VAR=value' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000380static int builtin_export(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000381{
Erik Andersen161220c2000-03-16 08:12:48 +0000382 int res;
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000383 char *v = child->argv[1];
Erik Andersen3522eb12000-03-12 23:49:18 +0000384
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000385 if (v == NULL) {
Eric Andersen84e229c2001-03-29 22:48:33 +0000386 char **e;
387 for (e = environ; *e; e++) {
Matt Kraai59df6f72001-05-16 14:21:09 +0000388 puts(*e);
Eric Andersen84e229c2001-03-29 22:48:33 +0000389 }
Matt Kraai2129f972001-04-04 17:50:04 +0000390 return 0;
Erik Andersen161220c2000-03-16 08:12:48 +0000391 }
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000392 res = putenv(v);
Erik Andersen161220c2000-03-16 08:12:48 +0000393 if (res)
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000394 fprintf(stderr, "export: %m\n");
Eric Andersenbdfd0d72001-10-24 05:00:29 +0000395#ifdef CONFIG_FEATURE_SH_FANCY_PROMPT
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000396 if (strncmp(v, "PS1=", 4)==0)
397 PS1 = getenv("PS1");
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000398#endif
Eric Andersene5dfced2001-04-09 22:48:12 +0000399
Eric Andersenbdfd0d72001-10-24 05:00:29 +0000400#ifdef CONFIG_LOCALE_SUPPORT
Mark Whitley1c6581a2001-03-27 16:35:16 +0000401 if(strncmp(v, "LC_ALL=", 7)==0)
402 setlocale(LC_ALL, getenv("LC_ALL"));
Mark Whitleya82a0032001-03-27 17:07:15 +0000403 if(strncmp(v, "LC_CTYPE=", 9)==0)
Mark Whitley1c6581a2001-03-27 16:35:16 +0000404 setlocale(LC_CTYPE, getenv("LC_CTYPE"));
Eric Andersene5dfced2001-04-09 22:48:12 +0000405#endif
Mark Whitley1c6581a2001-03-27 16:35:16 +0000406
Erik Andersen161220c2000-03-16 08:12:48 +0000407 return (res);
Erik Andersen3522eb12000-03-12 23:49:18 +0000408}
409
Eric Andersenb54833c2000-07-03 23:56:26 +0000410/* built-in 'read VAR' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000411static int builtin_read(struct child_prog *child)
Eric Andersenb54833c2000-07-03 23:56:26 +0000412{
413 int res = 0, len, newlen;
414 char *s;
415 char string[MAX_READ];
416
Eric Andersen86349772000-12-18 20:25:50 +0000417 if (child->argv[1]) {
Eric Andersenb54833c2000-07-03 23:56:26 +0000418 /* argument (VAR) given: put "VAR=" into buffer */
Eric Andersen0d2d1eb2002-06-06 13:33:01 +0000419 safe_strncpy(string, child->argv[1], MAX_READ-1);
Eric Andersenb54833c2000-07-03 23:56:26 +0000420 len = strlen(string);
421 string[len++] = '=';
422 string[len] = '\0';
423 fgets(&string[len], sizeof(string) - len, stdin); /* read string */
424 newlen = strlen(string);
425 if(newlen > len)
426 string[--newlen] = '\0'; /* chomp trailing newline */
427 /*
428 ** string should now contain "VAR=<value>"
429 ** copy it (putenv() won't do that, so we must make sure
430 ** the string resides in a static buffer!)
431 */
432 res = -1;
433 if((s = strdup(string)))
434 res = putenv(s);
435 if (res)
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000436 fprintf(stderr, "read: %m\n");
Eric Andersenb54833c2000-07-03 23:56:26 +0000437 }
438 else
439 fgets(string, sizeof(string), stdin);
440
441 return (res);
442}
443
Erik Andersen3522eb12000-03-12 23:49:18 +0000444/* Built-in '.' handler (read-in and execute commands from file) */
Eric Andersen86349772000-12-18 20:25:50 +0000445static int builtin_source(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000446{
Erik Andersen161220c2000-03-16 08:12:48 +0000447 FILE *input;
448 int status;
Eric Andersen8ea28be2001-01-05 20:58:22 +0000449 int fd;
Erik Andersen3522eb12000-03-12 23:49:18 +0000450
Eric Andersen86349772000-12-18 20:25:50 +0000451 if (child->argv[1] == NULL)
Matt Kraai3e856ce2000-12-01 02:55:13 +0000452 return EXIT_FAILURE;
Erik Andersen3522eb12000-03-12 23:49:18 +0000453
Eric Andersen86349772000-12-18 20:25:50 +0000454 input = fopen(child->argv[1], "r");
Erik Andersen161220c2000-03-16 08:12:48 +0000455 if (!input) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +0000456 printf( "Couldn't open file '%s'\n", child->argv[1]);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000457 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000458 }
Erik Andersend75af992000-03-16 08:09:09 +0000459
Eric Andersen8ea28be2001-01-05 20:58:22 +0000460 fd=fileno(input);
461 mark_open(fd);
Erik Andersen161220c2000-03-16 08:12:48 +0000462 /* Now run the file */
463 status = busy_loop(input);
Matt Kraaidd450a02000-09-13 03:43:36 +0000464 fclose(input);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000465 mark_closed(fd);
Erik Andersen161220c2000-03-16 08:12:48 +0000466 return (status);
Erik Andersen3522eb12000-03-12 23:49:18 +0000467}
468
469/* built-in 'unset VAR' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000470static int builtin_unset(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000471{
Eric Andersen86349772000-12-18 20:25:50 +0000472 if (child->argv[1] == NULL) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +0000473 printf( "unset: parameter required.\n");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000474 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000475 }
Eric Andersen86349772000-12-18 20:25:50 +0000476 unsetenv(child->argv[1]);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000477 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000478}
479
Eric Andersen8ea28be2001-01-05 20:58:22 +0000480static void mark_open(int fd)
481{
482 struct close_me *new = xmalloc(sizeof(struct close_me));
483 new->fd = fd;
484 new->next = close_me_head;
485 close_me_head = new;
486}
487
488static void mark_closed(int fd)
489{
490 struct close_me *tmp;
491 if (close_me_head == NULL || close_me_head->fd != fd)
492 error_msg_and_die("corrupt close_me");
493 tmp = close_me_head;
494 close_me_head = close_me_head->next;
495 free(tmp);
496}
497
498static void close_all()
499{
Eric Andersen702ec592001-03-06 22:17:29 +0000500 struct close_me *c, *tmp;
501 for (c=close_me_head; c; c=tmp) {
502 close(c->fd);
503 tmp=c->next;
504 free(c);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000505 }
506 close_me_head = NULL;
507}
508
509
Erik Andersen3522eb12000-03-12 23:49:18 +0000510/* free up all memory from a job */
Eric Andersen86349772000-12-18 20:25:50 +0000511static void free_job(struct job *cmd)
Erik Andersen3522eb12000-03-12 23:49:18 +0000512{
Erik Andersen161220c2000-03-16 08:12:48 +0000513 int i;
Mark Whitley44a99142001-03-14 17:26:37 +0000514 struct jobset *keep;
Erik Andersen3522eb12000-03-12 23:49:18 +0000515
Eric Andersen86349772000-12-18 20:25:50 +0000516 for (i = 0; i < cmd->num_progs; i++) {
Erik Andersen161220c2000-03-16 08:12:48 +0000517 free(cmd->progs[i].argv);
Eric Andersen86349772000-12-18 20:25:50 +0000518 if (cmd->progs[i].redirects)
519 free(cmd->progs[i].redirects);
Erik Andersen161220c2000-03-16 08:12:48 +0000520 }
Mark Whitley44a99142001-03-14 17:26:37 +0000521 if (cmd->progs)
522 free(cmd->progs);
Erik Andersen161220c2000-03-16 08:12:48 +0000523 if (cmd->text)
524 free(cmd->text);
Mark Whitley44a99142001-03-14 17:26:37 +0000525 if (cmd->cmdbuf)
526 free(cmd->cmdbuf);
527 keep = cmd->job_list;
Eric Andersenec10b9d2000-07-14 01:13:11 +0000528 memset(cmd, 0, sizeof(struct job));
Mark Whitley44a99142001-03-14 17:26:37 +0000529 cmd->job_list = keep;
Erik Andersen3522eb12000-03-12 23:49:18 +0000530}
531
Eric Andersen1ca20a72001-03-21 07:34:27 +0000532/* remove a job from a jobset */
533static void remove_job(struct jobset *j_list, struct job *job)
Erik Andersen3522eb12000-03-12 23:49:18 +0000534{
Eric Andersen86349772000-12-18 20:25:50 +0000535 struct job *prevjob;
Erik Andersen3522eb12000-03-12 23:49:18 +0000536
Eric Andersen86349772000-12-18 20:25:50 +0000537 free_job(job);
Eric Andersen1ca20a72001-03-21 07:34:27 +0000538 if (job == j_list->head) {
539 j_list->head = job->next;
Erik Andersen161220c2000-03-16 08:12:48 +0000540 } else {
Eric Andersen1ca20a72001-03-21 07:34:27 +0000541 prevjob = j_list->head;
Eric Andersen86349772000-12-18 20:25:50 +0000542 while (prevjob->next != job)
543 prevjob = prevjob->next;
544 prevjob->next = job->next;
Erik Andersen161220c2000-03-16 08:12:48 +0000545 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000546
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000547 if (j_list->head)
548 last_jobid = j_list->head->jobid;
549 else
550 last_jobid = 0;
551
Erik Andersen161220c2000-03-16 08:12:48 +0000552 free(job);
Erik Andersen3522eb12000-03-12 23:49:18 +0000553}
554
555/* Checks to see if any background processes have exited -- if they
556 have, figure out why and see if a job has completed */
Eric Andersen1ca20a72001-03-21 07:34:27 +0000557static void checkjobs(struct jobset *j_list)
Erik Andersen3522eb12000-03-12 23:49:18 +0000558{
Erik Andersen161220c2000-03-16 08:12:48 +0000559 struct job *job;
560 pid_t childpid;
561 int status;
Eric Andersen86349772000-12-18 20:25:50 +0000562 int prognum = 0;
Erik Andersend75af992000-03-16 08:09:09 +0000563
Erik Andersen161220c2000-03-16 08:12:48 +0000564 while ((childpid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
Eric Andersen1ca20a72001-03-21 07:34:27 +0000565 for (job = j_list->head; job; job = job->next) {
Eric Andersen86349772000-12-18 20:25:50 +0000566 prognum = 0;
567 while (prognum < job->num_progs &&
568 job->progs[prognum].pid != childpid) prognum++;
569 if (prognum < job->num_progs)
Erik Andersen161220c2000-03-16 08:12:48 +0000570 break;
571 }
572
Eric Andersena1d187a2000-07-17 19:14:41 +0000573 /* This happens on backticked commands */
574 if(job==NULL)
575 return;
576
Erik Andersen161220c2000-03-16 08:12:48 +0000577 if (WIFEXITED(status) || WIFSIGNALED(status)) {
578 /* child exited */
Eric Andersen86349772000-12-18 20:25:50 +0000579 job->running_progs--;
580 job->progs[prognum].pid = 0;
Erik Andersen161220c2000-03-16 08:12:48 +0000581
Eric Andersen86349772000-12-18 20:25:50 +0000582 if (!job->running_progs) {
583 printf(JOB_STATUS_FORMAT, job->jobid, "Done", job->text);
Eric Andersen8a646dd2001-06-21 16:38:11 +0000584 last_jobid=0;
Eric Andersen1ca20a72001-03-21 07:34:27 +0000585 remove_job(j_list, job);
Erik Andersen161220c2000-03-16 08:12:48 +0000586 }
587 } else {
588 /* child stopped */
Eric Andersen86349772000-12-18 20:25:50 +0000589 job->stopped_progs++;
590 job->progs[prognum].is_stopped = 1;
Erik Andersen161220c2000-03-16 08:12:48 +0000591
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000592#if 0
593 /* Printing this stuff is a pain, since it tends to
594 * overwrite the prompt an inconveinient moments. So
595 * don't do that. */
Eric Andersen86349772000-12-18 20:25:50 +0000596 if (job->stopped_progs == job->num_progs) {
597 printf(JOB_STATUS_FORMAT, job->jobid, "Stopped",
Erik Andersen161220c2000-03-16 08:12:48 +0000598 job->text);
599 }
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000600#endif
Erik Andersen161220c2000-03-16 08:12:48 +0000601 }
Erik Andersend75af992000-03-16 08:09:09 +0000602 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000603
Erik Andersen161220c2000-03-16 08:12:48 +0000604 if (childpid == -1 && errno != ECHILD)
Matt Kraaia9819b22000-12-22 01:48:07 +0000605 perror_msg("waitpid");
Erik Andersen3522eb12000-03-12 23:49:18 +0000606}
607
Eric Andersene9f07fb2000-12-21 18:31:36 +0000608/* squirrel != NULL means we squirrel away copies of stdin, stdout,
609 * and stderr if they are redirected. */
610static int setup_redirects(struct child_prog *prog, int squirrel[])
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000611{
612 int i;
613 int openfd;
614 int mode = O_RDONLY;
Eric Andersen86349772000-12-18 20:25:50 +0000615 struct redir_struct *redir = prog->redirects;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000616
Eric Andersen86349772000-12-18 20:25:50 +0000617 for (i = 0; i < prog->num_redirects; i++, redir++) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000618 switch (redir->type) {
619 case REDIRECT_INPUT:
620 mode = O_RDONLY;
621 break;
622 case REDIRECT_OVERWRITE:
Eric Andersen46f0beb2000-11-14 21:59:22 +0000623 mode = O_WRONLY | O_CREAT | O_TRUNC;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000624 break;
625 case REDIRECT_APPEND:
Eric Andersen46f0beb2000-11-14 21:59:22 +0000626 mode = O_WRONLY | O_CREAT | O_APPEND;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000627 break;
628 }
629
630 openfd = open(redir->filename, mode, 0666);
631 if (openfd < 0) {
632 /* this could get lost if stderr has been redirected, but
633 bash and ash both lose it as well (though zsh doesn't!) */
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000634 perror_msg("error opening %s", redir->filename);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000635 return 1;
636 }
637
638 if (openfd != redir->fd) {
Eric Andersene9f07fb2000-12-21 18:31:36 +0000639 if (squirrel && redir->fd < 3) {
640 squirrel[redir->fd] = dup(redir->fd);
641 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000642 dup2(openfd, redir->fd);
643 close(openfd);
644 }
645 }
646
647 return 0;
648}
649
Eric Andersene9f07fb2000-12-21 18:31:36 +0000650static void restore_redirects(int squirrel[])
651{
652 int i, fd;
653 for (i=0; i<3; i++) {
654 fd = squirrel[i];
655 if (fd != -1) {
656 /* No error checking. I sure wouldn't know what
657 * to do with an error if I found one! */
658 dup2(fd, i);
659 close(fd);
660 }
661 }
662}
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000663
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000664static inline void cmdedit_set_initial_prompt(void)
Eric Andersen22332fd2001-01-30 23:40:39 +0000665{
Eric Andersenbdfd0d72001-10-24 05:00:29 +0000666#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000667 PS1 = NULL;
Eric Andersen22332fd2001-01-30 23:40:39 +0000668#else
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000669 PS1 = getenv("PS1");
Eric Andersene5dfced2001-04-09 22:48:12 +0000670 if(PS1==0)
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000671 PS1 = "\\w \\$ ";
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000672#endif
Eric Andersen09acc062001-01-04 11:10:38 +0000673}
674
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000675static inline void setup_prompt_string(char **prompt_str)
676{
Eric Andersenbdfd0d72001-10-24 05:00:29 +0000677#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000678 /* Set up the prompt */
679 if (shell_context == 0) {
680 if (PS1)
681 free(PS1);
682 PS1=xmalloc(strlen(cwd)+4);
683 sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ? "$ ":"# ");
684 *prompt_str = PS1;
685 } else {
686 *prompt_str = PS2;
687 }
688#else
689 *prompt_str = (shell_context==0)? PS1 : PS2;
690#endif
691}
Eric Andersen22332fd2001-01-30 23:40:39 +0000692
Eric Andersen09acc062001-01-04 11:10:38 +0000693static int get_command(FILE * source, char *command)
694{
695 char *prompt_str;
Eric Andersen8ea28be2001-01-05 20:58:22 +0000696
Eric Andersen1c314ad2000-06-28 16:56:25 +0000697 if (source == NULL) {
698 if (local_pending_command) {
699 /* a command specified (-c option): return it & mark it done */
700 strcpy(command, local_pending_command);
701 free(local_pending_command);
702 local_pending_command = NULL;
703 return 0;
704 }
705 return 1;
706 }
707
Erik Andersen161220c2000-03-16 08:12:48 +0000708 if (source == stdin) {
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000709 setup_prompt_string(&prompt_str);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000710
Eric Andersenbdfd0d72001-10-24 05:00:29 +0000711#ifdef CONFIG_FEATURE_COMMAND_EDITING
Eric Andersen501c88b2000-07-28 15:14:45 +0000712 /*
713 ** enable command line editing only while a command line
714 ** is actually being read; otherwise, we'll end up bequeathing
715 ** atexit() handlers and other unwanted stuff to our
716 ** child processes (rob@sysgo.de)
717 */
Eric Andersen86349772000-12-18 20:25:50 +0000718 cmdedit_read_input(prompt_str, command);
Erik Andersen161220c2000-03-16 08:12:48 +0000719 return 0;
Erik Andersenc7c634b2000-03-19 05:28:55 +0000720#else
Eric Andersen8ea28be2001-01-05 20:58:22 +0000721 fputs(prompt_str, stdout);
Erik Andersend75af992000-03-16 08:09:09 +0000722#endif
Erik Andersen161220c2000-03-16 08:12:48 +0000723 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000724
Erik Andersen161220c2000-03-16 08:12:48 +0000725 if (!fgets(command, BUFSIZ - 2, source)) {
726 if (source == stdin)
727 printf("\n");
728 return 1;
729 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000730
Erik Andersen161220c2000-03-16 08:12:48 +0000731 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000732}
733
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000734static char* itoa(register int i)
735{
736 static char a[7]; /* Max 7 ints */
737 register char *b = a + sizeof(a) - 1;
738 int sign = (i < 0);
739
740 if (sign)
741 i = -i;
742 *b = 0;
743 do
744 {
745 *--b = '0' + (i % 10);
746 i /= 10;
747 }
748 while (i);
749 if (sign)
750 *--b = '-';
751 return b;
752}
753
754char * strsep_space( char *string, int * ix)
755{
756 char *token, *begin;
757
758 begin = string;
759
760 /* Short circuit the trivial case */
761 if ( !string || ! string[*ix])
762 return NULL;
763
764 /* Find the end of the token. */
765 while( string && string[*ix] && !isspace(string[*ix]) ) {
766 (*ix)++;
767 }
768
769 /* Find the end of any whitespace trailing behind
770 * the token and let that be part of the token */
771 while( string && string[*ix] && isspace(string[*ix]) ) {
772 (*ix)++;
773 }
774
775 if (! string && *ix==0) {
776 /* Nothing useful was found */
777 return NULL;
778 }
779
780 token = xmalloc(*ix+1);
781 token[*ix] = '\0';
782 strncpy(token, string, *ix);
783
784 return token;
785}
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000786
Eric Andersenca604592001-03-08 17:17:13 +0000787static int expand_arguments(char *command)
788{
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000789 int total_length=0, length, i, retval, ix = 0;
790 expand_t expand_result;
791 char *tmpcmd, *cmd, *cmd_copy;
792 char *src, *dst, *var;
793 const char *out_of_space = "out of space during expansion";
794 int flags = GLOB_NOCHECK
795#ifdef GLOB_BRACE
796 | GLOB_BRACE
797#endif
798#ifdef GLOB_TILDE
799 | GLOB_TILDE
800#endif
801 ;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000802
Eric Andersenca604592001-03-08 17:17:13 +0000803 /* get rid of the terminating \n */
804 chomp(command);
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000805
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000806 /* Fix up escape sequences to be the Real Thing(tm) */
Eric Andersen1ca20a72001-03-21 07:34:27 +0000807 while( command && command[ix]) {
808 if (command[ix] == '\\') {
Eric Andersene5dfced2001-04-09 22:48:12 +0000809 const char *tmp = command+ix+1;
Eric Andersen1ca20a72001-03-21 07:34:27 +0000810 command[ix] = process_escape_sequence( &tmp );
811 memmove(command+ix + 1, tmp, strlen(tmp)+1);
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000812 }
Eric Andersen1ca20a72001-03-21 07:34:27 +0000813 ix++;
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000814 }
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000815 /* Use glob and then fixup environment variables and such */
816
817 /* It turns out that glob is very stupid. We have to feed it one word at a
818 * time since it can't cope with a full string. Here we convert command
819 * (char*) into cmd (char**, one word per string) */
820
821 /* We need a clean copy, so strsep can mess up the copy while
822 * we write stuff into the original (in a minute) */
Matt Kraaic8227632001-11-12 16:57:27 +0000823 cmd = cmd_copy = xstrdup(command);
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000824 *command = '\0';
825 for (ix = 0, tmpcmd = cmd;
826 (tmpcmd = strsep_space(cmd, &ix)) != NULL; cmd += ix, ix=0) {
827 if (*tmpcmd == '\0')
828 break;
829 /* we need to trim() the result for glob! */
830 trim(tmpcmd);
831 retval = glob(tmpcmd, flags, NULL, &expand_result);
832 free(tmpcmd); /* Free mem allocated by strsep_space */
833 if (retval == GLOB_NOSPACE) {
834 /* Mem may have been allocated... */
835 globfree (&expand_result);
836 error_msg(out_of_space);
837 return FALSE;
838 } else if (retval != 0) {
839 /* Some other error. GLOB_NOMATCH shouldn't
840 * happen because of the GLOB_NOCHECK flag in
841 * the glob call. */
842 error_msg("syntax error");
843 return FALSE;
844 } else {
845 /* Convert from char** (one word per string) to a simple char*,
846 * but don't overflow command which is BUFSIZ in length */
847 for (i=0; i < expand_result.gl_pathc; i++) {
848 length=strlen(expand_result.gl_pathv[i]);
849 if (total_length+length+1 >= BUFSIZ) {
850 error_msg(out_of_space);
851 return FALSE;
852 }
853 strcat(command+total_length, " ");
854 total_length+=1;
855 strcat(command+total_length, expand_result.gl_pathv[i]);
856 total_length+=length;
857 }
858 globfree (&expand_result);
859 }
860 }
861 free(cmd_copy);
862 trim(command);
863
864 /* Now do the shell variable substitutions which
865 * wordexp can't do for us, namely $? and $! */
866 src = command;
867 while((dst = strchr(src,'$')) != NULL){
868 var = NULL;
869 switch(*(dst+1)) {
870 case '?':
871 var = itoa(last_return_code);
872 break;
873 case '!':
874 if (last_bg_pid==-1)
875 *(var)='\0';
876 else
877 var = itoa(last_bg_pid);
878 break;
879 /* Everything else like $$, $#, $[0-9], etc. should all be
880 * expanded by wordexp(), so we can in theory skip that stuff
881 * here, but just to be on the safe side (i.e., since uClibc
882 * wordexp doesn't do this stuff yet), lets leave it in for
883 * now. */
884 case '$':
885 var = itoa(getpid());
886 break;
887 case '#':
888 var = itoa(argc-1);
889 break;
890 case '0':case '1':case '2':case '3':case '4':
891 case '5':case '6':case '7':case '8':case '9':
892 {
893 int ixx=*(dst + 1)-48;
894 if (ixx >= argc) {
895 var='\0';
896 } else {
897 var = argv[ixx];
898 }
899 }
900 break;
901
902 }
903 if (var) {
904 /* a single character construction was found, and
905 * already handled in the case statement */
906 src=dst+2;
907 } else {
908 /* Looks like an environment variable */
909 char delim_hold;
910 int num_skip_chars=0;
911 int dstlen = strlen(dst);
912 /* Is this a ${foo} type variable? */
913 if (dstlen >=2 && *(dst+1) == '{') {
914 src=strchr(dst+1, '}');
915 num_skip_chars=1;
916 } else {
917 src=dst+1;
918 while(isalnum(*src) || *src=='_') src++;
919 }
920 if (src == NULL) {
921 src = dst+dstlen;
922 }
923 delim_hold=*src;
924 *src='\0'; /* temporary */
925 var = getenv(dst + 1 + num_skip_chars);
926 *src=delim_hold;
927 src += num_skip_chars;
928 }
929 if (var == NULL) {
930 /* Seems we got an un-expandable variable. So delete it. */
931 var = "";
932 }
933 {
934 int subst_len = strlen(var);
935 int trail_len = strlen(src);
936 if (dst+subst_len+trail_len >= command+BUFSIZ) {
937 error_msg(out_of_space);
938 return FALSE;
939 }
940 /* Move stuff to the end of the string to accommodate
941 * filling the created gap with the new stuff */
942 memmove(dst+subst_len, src, trail_len+1);
943 /* Now copy in the new stuff */
944 memcpy(dst, var, subst_len);
945 src = dst+subst_len;
946 }
947 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000948
Eric Andersenca604592001-03-08 17:17:13 +0000949 return TRUE;
Erik Andersen3522eb12000-03-12 23:49:18 +0000950}
951
Eric Andersen86349772000-12-18 20:25:50 +0000952/* Return cmd->num_progs as 0 if no command is present (e.g. an empty
953 line). If a valid command is found, command_ptr is set to point to
Erik Andersen3522eb12000-03-12 23:49:18 +0000954 the beginning of the next command (if the original command had more
955 then one job associated with it) or NULL if no more commands are
956 present. */
Eric Andersen86349772000-12-18 20:25:50 +0000957static int parse_command(char **command_ptr, struct job *job, int *inbg)
Erik Andersen3522eb12000-03-12 23:49:18 +0000958{
Erik Andersen161220c2000-03-16 08:12:48 +0000959 char *command;
Eric Andersen86349772000-12-18 20:25:50 +0000960 char *return_command = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +0000961 char *src, *buf, *chptr;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000962 int argc_l = 0;
Erik Andersen161220c2000-03-16 08:12:48 +0000963 int done = 0;
Eric Andersen86349772000-12-18 20:25:50 +0000964 int argv_alloced;
Matt Kraaibe66ad32001-04-12 15:42:17 +0000965 int i, saw_quote = 0;
Erik Andersen161220c2000-03-16 08:12:48 +0000966 char quote = '\0';
967 int count;
Eric Andersen86349772000-12-18 20:25:50 +0000968 struct child_prog *prog;
Erik Andersen3522eb12000-03-12 23:49:18 +0000969
Erik Andersen161220c2000-03-16 08:12:48 +0000970 /* skip leading white space */
Eric Andersen86349772000-12-18 20:25:50 +0000971 while (**command_ptr && isspace(**command_ptr))
972 (*command_ptr)++;
Erik Andersen3522eb12000-03-12 23:49:18 +0000973
Erik Andersen161220c2000-03-16 08:12:48 +0000974 /* this handles empty lines or leading '#' characters */
Eric Andersen86349772000-12-18 20:25:50 +0000975 if (!**command_ptr || (**command_ptr == '#')) {
976 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +0000977 return 0;
978 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000979
Eric Andersen86349772000-12-18 20:25:50 +0000980 *inbg = 0;
981 job->num_progs = 1;
Eric Andersenec10b9d2000-07-14 01:13:11 +0000982 job->progs = xmalloc(sizeof(*job->progs));
Erik Andersen3522eb12000-03-12 23:49:18 +0000983
Erik Andersen161220c2000-03-16 08:12:48 +0000984 /* We set the argv elements to point inside of this string. The
Eric Andersen86349772000-12-18 20:25:50 +0000985 memory is freed by free_job(). Allocate twice the original
Eric Andersenb54833c2000-07-03 23:56:26 +0000986 length in case we need to quote every single character.
Erik Andersen3522eb12000-03-12 23:49:18 +0000987
Erik Andersen161220c2000-03-16 08:12:48 +0000988 Getting clean memory relieves us of the task of NULL
989 terminating things and makes the rest of this look a bit
990 cleaner (though it is, admittedly, a tad less efficient) */
Eric Andersen86349772000-12-18 20:25:50 +0000991 job->cmdbuf = command = xcalloc(2*strlen(*command_ptr) + 1, sizeof(char));
Erik Andersen161220c2000-03-16 08:12:48 +0000992 job->text = NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +0000993
Erik Andersen161220c2000-03-16 08:12:48 +0000994 prog = job->progs;
Eric Andersen86349772000-12-18 20:25:50 +0000995 prog->num_redirects = 0;
996 prog->redirects = NULL;
Eric Andersen86349772000-12-18 20:25:50 +0000997 prog->is_stopped = 0;
998 prog->family = job;
Erik Andersen3522eb12000-03-12 23:49:18 +0000999
Eric Andersen86349772000-12-18 20:25:50 +00001000 argv_alloced = 5;
1001 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
1002 prog->argv[0] = job->cmdbuf;
Erik Andersen3522eb12000-03-12 23:49:18 +00001003
Erik Andersen161220c2000-03-16 08:12:48 +00001004 buf = command;
Eric Andersen86349772000-12-18 20:25:50 +00001005 src = *command_ptr;
Erik Andersen161220c2000-03-16 08:12:48 +00001006 while (*src && !done) {
1007 if (quote == *src) {
1008 quote = '\0';
1009 } else if (quote) {
1010 if (*src == '\\') {
1011 src++;
1012 if (!*src) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001013 error_msg("character expected after \\");
Eric Andersen86349772000-12-18 20:25:50 +00001014 free_job(job);
Erik Andersen161220c2000-03-16 08:12:48 +00001015 return 1;
1016 }
1017
1018 /* in shell, "\'" should yield \' */
Eric Andersenb2356f62000-12-11 19:14:40 +00001019 if (*src != quote) {
Erik Andersen161220c2000-03-16 08:12:48 +00001020 *buf++ = '\\';
Eric Andersenb2356f62000-12-11 19:14:40 +00001021 *buf++ = '\\';
1022 }
Erik Andersen161220c2000-03-16 08:12:48 +00001023 } else if (*src == '*' || *src == '?' || *src == '[' ||
1024 *src == ']') *buf++ = '\\';
1025 *buf++ = *src;
1026 } else if (isspace(*src)) {
Matt Kraaibe66ad32001-04-12 15:42:17 +00001027 if (*prog->argv[argc_l] || saw_quote) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001028 buf++, argc_l++;
Erik Andersen161220c2000-03-16 08:12:48 +00001029 /* +1 here leaves room for the NULL which ends argv */
Eric Andersen86349772000-12-18 20:25:50 +00001030 if ((argc_l + 1) == argv_alloced) {
1031 argv_alloced += 5;
Matt Kraaib8907522000-09-13 02:08:21 +00001032 prog->argv = xrealloc(prog->argv,
1033 sizeof(*prog->argv) *
Eric Andersen86349772000-12-18 20:25:50 +00001034 argv_alloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001035 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001036 prog->argv[argc_l] = buf;
Matt Kraaibe66ad32001-04-12 15:42:17 +00001037 saw_quote = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001038 }
1039 } else
1040 switch (*src) {
1041 case '"':
1042 case '\'':
1043 quote = *src;
Matt Kraaibe66ad32001-04-12 15:42:17 +00001044 saw_quote = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001045 break;
1046
1047 case '#': /* comment */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001048 if (*(src-1)== '$')
1049 *buf++ = *src;
1050 else
1051 done = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001052 break;
1053
Eric Andersen86349772000-12-18 20:25:50 +00001054 case '>': /* redirects */
Erik Andersen161220c2000-03-16 08:12:48 +00001055 case '<':
Eric Andersen86349772000-12-18 20:25:50 +00001056 i = prog->num_redirects++;
1057 prog->redirects = xrealloc(prog->redirects,
1058 sizeof(*prog->redirects) *
Matt Kraaib8907522000-09-13 02:08:21 +00001059 (i + 1));
Erik Andersen161220c2000-03-16 08:12:48 +00001060
Eric Andersen86349772000-12-18 20:25:50 +00001061 prog->redirects[i].fd = -1;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001062 if (buf != prog->argv[argc_l]) {
Erik Andersen161220c2000-03-16 08:12:48 +00001063 /* the stuff before this character may be the file number
1064 being redirected */
Eric Andersen86349772000-12-18 20:25:50 +00001065 prog->redirects[i].fd =
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001066 strtol(prog->argv[argc_l], &chptr, 10);
Erik Andersen161220c2000-03-16 08:12:48 +00001067
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001068 if (*chptr && *prog->argv[argc_l]) {
1069 buf++, argc_l++;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001070 prog->argv[argc_l] = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001071 }
1072 }
1073
Eric Andersen86349772000-12-18 20:25:50 +00001074 if (prog->redirects[i].fd == -1) {
Erik Andersen161220c2000-03-16 08:12:48 +00001075 if (*src == '>')
Eric Andersen86349772000-12-18 20:25:50 +00001076 prog->redirects[i].fd = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001077 else
Eric Andersen86349772000-12-18 20:25:50 +00001078 prog->redirects[i].fd = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001079 }
1080
1081 if (*src++ == '>') {
1082 if (*src == '>')
Eric Andersen86349772000-12-18 20:25:50 +00001083 prog->redirects[i].type =
Erik Andersen161220c2000-03-16 08:12:48 +00001084 REDIRECT_APPEND, src++;
1085 else
Eric Andersen86349772000-12-18 20:25:50 +00001086 prog->redirects[i].type = REDIRECT_OVERWRITE;
Erik Andersen161220c2000-03-16 08:12:48 +00001087 } else {
Eric Andersen86349772000-12-18 20:25:50 +00001088 prog->redirects[i].type = REDIRECT_INPUT;
Erik Andersen161220c2000-03-16 08:12:48 +00001089 }
1090
1091 /* This isn't POSIX sh compliant. Oh well. */
1092 chptr = src;
1093 while (isspace(*chptr))
1094 chptr++;
1095
1096 if (!*chptr) {
Mark Whitley44a99142001-03-14 17:26:37 +00001097 error_msg("file name expected after %c", *(src-1));
Eric Andersen86349772000-12-18 20:25:50 +00001098 free_job(job);
1099 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001100 return 1;
1101 }
1102
Eric Andersen86349772000-12-18 20:25:50 +00001103 prog->redirects[i].filename = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001104 while (*chptr && !isspace(*chptr))
1105 *buf++ = *chptr++;
1106
1107 src = chptr - 1; /* we src++ later */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001108 prog->argv[argc_l] = ++buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001109 break;
1110
1111 case '|': /* pipe */
1112 /* finish this command */
Matt Kraaibe66ad32001-04-12 15:42:17 +00001113 if (*prog->argv[argc_l] || saw_quote)
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001114 argc_l++;
1115 if (!argc_l) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001116 error_msg("empty command in pipe");
Eric Andersen86349772000-12-18 20:25:50 +00001117 free_job(job);
1118 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001119 return 1;
1120 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001121 prog->argv[argc_l] = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001122
1123 /* and start the next */
Eric Andersen86349772000-12-18 20:25:50 +00001124 job->num_progs++;
Matt Kraaib8907522000-09-13 02:08:21 +00001125 job->progs = xrealloc(job->progs,
Eric Andersen86349772000-12-18 20:25:50 +00001126 sizeof(*job->progs) * job->num_progs);
1127 prog = job->progs + (job->num_progs - 1);
1128 prog->num_redirects = 0;
1129 prog->redirects = NULL;
Eric Andersen86349772000-12-18 20:25:50 +00001130 prog->is_stopped = 0;
1131 prog->family = job;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001132 argc_l = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001133
Eric Andersen86349772000-12-18 20:25:50 +00001134 argv_alloced = 5;
1135 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001136 prog->argv[0] = ++buf;
1137
1138 src++;
1139 while (*src && isspace(*src))
1140 src++;
1141
1142 if (!*src) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001143 error_msg("empty command in pipe");
Eric Andersen86349772000-12-18 20:25:50 +00001144 free_job(job);
1145 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001146 return 1;
1147 }
1148 src--; /* we'll ++ it at the end of the loop */
1149
1150 break;
1151
1152 case '&': /* background */
Eric Andersen86349772000-12-18 20:25:50 +00001153 *inbg = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001154 case ';': /* multiple commands */
1155 done = 1;
Eric Andersen86349772000-12-18 20:25:50 +00001156 return_command = *command_ptr + (src - *command_ptr) + 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001157 break;
1158
Matt Kraai131241f2000-09-14 00:43:20 +00001159 case '\\':
1160 src++;
1161 if (!*src) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001162 error_msg("character expected after \\");
Eric Andersen86349772000-12-18 20:25:50 +00001163 free_job(job);
Matt Kraai131241f2000-09-14 00:43:20 +00001164 return 1;
1165 }
1166 if (*src == '*' || *src == '[' || *src == ']'
1167 || *src == '?') *buf++ = '\\';
1168 /* fallthrough */
Erik Andersen161220c2000-03-16 08:12:48 +00001169 default:
1170 *buf++ = *src;
1171 }
1172
Erik Andersend75af992000-03-16 08:09:09 +00001173 src++;
Erik Andersen161220c2000-03-16 08:12:48 +00001174 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001175
Matt Kraaibe66ad32001-04-12 15:42:17 +00001176 if (*prog->argv[argc_l] || saw_quote) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001177 argc_l++;
Erik Andersen161220c2000-03-16 08:12:48 +00001178 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001179 if (!argc_l) {
Eric Andersen86349772000-12-18 20:25:50 +00001180 free_job(job);
Erik Andersen161220c2000-03-16 08:12:48 +00001181 return 0;
1182 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001183 prog->argv[argc_l] = NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +00001184
Eric Andersen86349772000-12-18 20:25:50 +00001185 if (!return_command) {
1186 job->text = xmalloc(strlen(*command_ptr) + 1);
1187 strcpy(job->text, *command_ptr);
Erik Andersen161220c2000-03-16 08:12:48 +00001188 } else {
1189 /* This leaves any trailing spaces, which is a bit sloppy */
Eric Andersen86349772000-12-18 20:25:50 +00001190 count = return_command - *command_ptr;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001191 job->text = xmalloc(count + 1);
Eric Andersen86349772000-12-18 20:25:50 +00001192 strncpy(job->text, *command_ptr, count);
Erik Andersen161220c2000-03-16 08:12:48 +00001193 job->text[count] = '\0';
1194 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001195
Eric Andersen86349772000-12-18 20:25:50 +00001196 *command_ptr = return_command;
Eric Andersen46f0beb2000-11-14 21:59:22 +00001197
Erik Andersend75af992000-03-16 08:09:09 +00001198 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001199}
1200
Eric Andersen86349772000-12-18 20:25:50 +00001201/* Run the child_prog, no matter what kind of command it uses.
1202 */
1203static int pseudo_exec(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +00001204{
Eric Andersen86349772000-12-18 20:25:50 +00001205 struct built_in_command *x;
Eric Andersenbdfd0d72001-10-24 05:00:29 +00001206#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
Eric Andersenaf4ac772001-02-01 22:43:49 +00001207 char *name;
Erik Andersenbcd61772000-05-13 06:33:19 +00001208#endif
Erik Andersen3522eb12000-03-12 23:49:18 +00001209
Eric Andersene9f07fb2000-12-21 18:31:36 +00001210 /* Check if the command matches any of the non-forking builtins.
1211 * Depending on context, this might be redundant. But it's
1212 * easier to waste a few CPU cycles than it is to figure out
1213 * if this is one of those cases.
Eric Andersen86349772000-12-18 20:25:50 +00001214 */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001215 for (x = bltins; x->cmd; x++) {
1216 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1217 exit(x->function(child));
1218 }
1219 }
1220
1221 /* Check if the command matches any of the forking builtins. */
Eric Andersen86349772000-12-18 20:25:50 +00001222 for (x = bltins_forking; x->cmd; x++) {
1223 if (strcmp(child->argv[0], x->cmd) == 0) {
1224 applet_name=x->cmd;
1225 exit (x->function(child));
1226 }
1227 }
Eric Andersenbdfd0d72001-10-24 05:00:29 +00001228#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
Eric Andersen86349772000-12-18 20:25:50 +00001229 /* Check if the command matches any busybox internal
1230 * commands ("applets") here. Following discussions from
Eric Andersen2423b122001-12-08 01:56:15 +00001231 * November 2000 on busybox@busybox.net, don't use
Eric Andersen86349772000-12-18 20:25:50 +00001232 * get_last_path_component(). This way explicit (with
1233 * slashes) filenames will never be interpreted as an
1234 * applet, just like with builtins. This way the user can
1235 * override an applet with an explicit filename reference.
1236 * The only downside to this change is that an explicit
1237 * /bin/foo invocation will fork and exec /bin/foo, even if
1238 * /bin/foo is a symlink to busybox.
1239 */
Matt Kraaif2cc2762001-02-01 19:21:20 +00001240 name = child->argv[0];
Eric Andersen86349772000-12-18 20:25:50 +00001241
Eric Andersenbdfd0d72001-10-24 05:00:29 +00001242#ifdef CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN
1243 /* If you enable CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN, then
Eric Andersen86349772000-12-18 20:25:50 +00001244 * if you run /bin/cat, it will use BusyBox cat even if
1245 * /bin/cat exists on the filesystem and is _not_ busybox.
1246 * Some systems want this, others do not. Choose wisely. :-)
1247 */
Matt Kraaif2cc2762001-02-01 19:21:20 +00001248 name = get_last_path_component(name);
Eric Andersen86349772000-12-18 20:25:50 +00001249#endif
1250
Eric Andersen67991cf2001-02-14 21:23:06 +00001251 {
Eric Andersen82ab8da2001-03-23 17:06:01 +00001252 char** argv_l=child->argv;
Eric Andersen67991cf2001-02-14 21:23:06 +00001253 int argc_l;
Eric Andersen82ab8da2001-03-23 17:06:01 +00001254 for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++);
Eric Andersen67991cf2001-02-14 21:23:06 +00001255 optind = 1;
1256 run_applet_by_name(name, argc_l, child->argv);
Eric Andersen86349772000-12-18 20:25:50 +00001257 }
1258#endif
1259
1260 execvp(child->argv[0], child->argv);
Eric Andersen8ea28be2001-01-05 20:58:22 +00001261 perror_msg_and_die("%s", child->argv[0]);
Eric Andersen86349772000-12-18 20:25:50 +00001262}
1263
1264static void insert_job(struct job *newjob, int inbg)
1265{
1266 struct job *thejob;
Eric Andersen1ca20a72001-03-21 07:34:27 +00001267 struct jobset *j_list=newjob->job_list;
Eric Andersen86349772000-12-18 20:25:50 +00001268
1269 /* find the ID for thejob to use */
1270 newjob->jobid = 1;
Eric Andersen1ca20a72001-03-21 07:34:27 +00001271 for (thejob = j_list->head; thejob; thejob = thejob->next)
Eric Andersen86349772000-12-18 20:25:50 +00001272 if (thejob->jobid >= newjob->jobid)
1273 newjob->jobid = thejob->jobid + 1;
1274
1275 /* add thejob to the list of running jobs */
Eric Andersen1ca20a72001-03-21 07:34:27 +00001276 if (!j_list->head) {
1277 thejob = j_list->head = xmalloc(sizeof(*thejob));
Eric Andersen86349772000-12-18 20:25:50 +00001278 } else {
Eric Andersen1ca20a72001-03-21 07:34:27 +00001279 for (thejob = j_list->head; thejob->next; thejob = thejob->next) /* nothing */;
Eric Andersen86349772000-12-18 20:25:50 +00001280 thejob->next = xmalloc(sizeof(*thejob));
1281 thejob = thejob->next;
1282 }
1283
1284 *thejob = *newjob; /* physically copy the struct job */
1285 thejob->next = NULL;
1286 thejob->running_progs = thejob->num_progs;
1287 thejob->stopped_progs = 0;
1288
1289 if (inbg) {
1290 /* we don't wait for background thejobs to return -- append it
1291 to the list of backgrounded thejobs and leave it alone */
1292 printf("[%d] %d\n", thejob->jobid,
1293 newjob->progs[newjob->num_progs - 1].pid);
Eric Andersen8a646dd2001-06-21 16:38:11 +00001294 last_jobid = newjob->jobid;
Eric Andersen4b6b5e42001-06-27 04:30:11 +00001295 last_bg_pid=newjob->progs[newjob->num_progs - 1].pid;
Eric Andersen86349772000-12-18 20:25:50 +00001296 } else {
1297 newjob->job_list->fg = thejob;
1298
1299 /* move the new process group into the foreground */
1300 /* suppress messages when run from /linuxrc mag@sysgo.de */
Eric Andersen2d848a42001-06-25 17:11:54 +00001301 if (tcsetpgrp(shell_terminal, newjob->pgrp) && errno != ENOTTY)
Matt Kraaia9819b22000-12-22 01:48:07 +00001302 perror_msg("tcsetpgrp");
Eric Andersen86349772000-12-18 20:25:50 +00001303 }
1304}
1305
1306static int run_command(struct job *newjob, int inbg, int outpipe[2])
1307{
1308 /* struct job *thejob; */
1309 int i;
1310 int nextin, nextout;
1311 int pipefds[2]; /* pipefd[0] is for reading */
1312 struct built_in_command *x;
1313 struct child_prog *child;
1314
Eric Andersen6efc48c2000-07-18 08:16:39 +00001315 nextin = 0, nextout = 1;
Eric Andersen86349772000-12-18 20:25:50 +00001316 for (i = 0; i < newjob->num_progs; i++) {
1317 child = & (newjob->progs[i]);
1318
1319 if ((i + 1) < newjob->num_progs) {
1320 if (pipe(pipefds)<0) perror_msg_and_die("pipe");
Erik Andersen161220c2000-03-16 08:12:48 +00001321 nextout = pipefds[1];
1322 } else {
Eric Andersen86349772000-12-18 20:25:50 +00001323 if (outpipe[1]!=-1) {
1324 nextout = outpipe[1];
Eric Andersen6efc48c2000-07-18 08:16:39 +00001325 } else {
1326 nextout = 1;
1327 }
Erik Andersen161220c2000-03-16 08:12:48 +00001328 }
1329
Eric Andersen501c88b2000-07-28 15:14:45 +00001330
Eric Andersene9f07fb2000-12-21 18:31:36 +00001331 /* Check if the command matches any non-forking builtins,
1332 * but only if this is a simple command.
1333 * Non-forking builtins within pipes have to fork anyway,
1334 * and are handled in pseudo_exec. "echo foo | read bar"
1335 * is doomed to failure, and doesn't work on bash, either.
Eric Andersen86349772000-12-18 20:25:50 +00001336 */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001337 if (newjob->num_progs == 1) {
1338 for (x = bltins; x->cmd; x++) {
1339 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1340 int squirrel[] = {-1, -1, -1};
1341 int rcode;
1342 setup_redirects(child, squirrel);
1343 rcode = x->function(child);
1344 restore_redirects(squirrel);
1345 return rcode;
1346 }
Erik Andersen330fd2b2000-05-19 05:35:19 +00001347 }
1348 }
1349
Eric Andersen72f9a422001-10-28 05:12:20 +00001350#if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__)
1351 if (!(child->pid = fork()))
1352#else
1353 if (!(child->pid = vfork()))
1354#endif
1355 {
Eric Andersen2d848a42001-06-25 17:11:54 +00001356 /* Set the handling for job control signals back to the default. */
1357 signal(SIGINT, SIG_DFL);
1358 signal(SIGQUIT, SIG_DFL);
1359 signal(SIGTSTP, SIG_DFL);
1360 signal(SIGTTIN, SIG_DFL);
Erik Andersen161220c2000-03-16 08:12:48 +00001361 signal(SIGTTOU, SIG_DFL);
Eric Andersen2d848a42001-06-25 17:11:54 +00001362 signal(SIGCHLD, SIG_DFL);
Erik Andersen161220c2000-03-16 08:12:48 +00001363
Eric Andersen8ea28be2001-01-05 20:58:22 +00001364 close_all();
1365
Eric Andersen86349772000-12-18 20:25:50 +00001366 if (outpipe[1]!=-1) {
1367 close(outpipe[0]);
Eric Andersen6efc48c2000-07-18 08:16:39 +00001368 }
1369 if (nextin != 0) {
1370 dup2(nextin, 0);
1371 close(nextin);
1372 }
1373
1374 if (nextout != 1) {
Erik Andersen161220c2000-03-16 08:12:48 +00001375 dup2(nextout, 1);
Eric Andersen86349772000-12-18 20:25:50 +00001376 dup2(nextout, 2); /* Really? */
Erik Andersen161220c2000-03-16 08:12:48 +00001377 close(nextout);
Eric Andersen501c88b2000-07-28 15:14:45 +00001378 close(pipefds[0]);
Erik Andersen161220c2000-03-16 08:12:48 +00001379 }
1380
Eric Andersen86349772000-12-18 20:25:50 +00001381 /* explicit redirects override pipes */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001382 setup_redirects(child,NULL);
Erik Andersen161220c2000-03-16 08:12:48 +00001383
Eric Andersen86349772000-12-18 20:25:50 +00001384 pseudo_exec(child);
Erik Andersen161220c2000-03-16 08:12:48 +00001385 }
Eric Andersen86349772000-12-18 20:25:50 +00001386 if (outpipe[1]!=-1) {
1387 close(outpipe[1]);
Eric Andersena1d187a2000-07-17 19:14:41 +00001388 }
Erik Andersen161220c2000-03-16 08:12:48 +00001389
1390 /* put our child in the process group whose leader is the
1391 first process in this pipe */
Eric Andersen86349772000-12-18 20:25:50 +00001392 setpgid(child->pid, newjob->progs[0].pid);
Erik Andersen161220c2000-03-16 08:12:48 +00001393 if (nextin != 0)
1394 close(nextin);
Eric Andersen6efc48c2000-07-18 08:16:39 +00001395 if (nextout != 1)
Erik Andersen161220c2000-03-16 08:12:48 +00001396 close(nextout);
1397
1398 /* If there isn't another process, nextin is garbage
1399 but it doesn't matter */
1400 nextin = pipefds[0];
1401 }
1402
Eric Andersen86349772000-12-18 20:25:50 +00001403 newjob->pgrp = newjob->progs[0].pid;
Erik Andersen161220c2000-03-16 08:12:48 +00001404
Eric Andersen86349772000-12-18 20:25:50 +00001405 insert_job(newjob, inbg);
Erik Andersen3522eb12000-03-12 23:49:18 +00001406
Erik Andersen161220c2000-03-16 08:12:48 +00001407 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001408}
1409
Erik Andersend75af992000-03-16 08:09:09 +00001410static int busy_loop(FILE * input)
Erik Andersen3522eb12000-03-12 23:49:18 +00001411{
Erik Andersen161220c2000-03-16 08:12:48 +00001412 char *command;
Eric Andersen86349772000-12-18 20:25:50 +00001413 char *next_command = NULL;
1414 struct job newjob;
Eric Andersen1c314ad2000-06-28 16:56:25 +00001415 pid_t parent_pgrp;
Erik Andersen161220c2000-03-16 08:12:48 +00001416 int i;
Eric Andersen86349772000-12-18 20:25:50 +00001417 int inbg;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001418 int status;
Eric Andersen86349772000-12-18 20:25:50 +00001419 newjob.job_list = &job_list;
1420 newjob.job_context = DEFAULT_CONTEXT;
Erik Andersen3522eb12000-03-12 23:49:18 +00001421
Eric Andersen1c314ad2000-06-28 16:56:25 +00001422 /* save current owner of TTY so we can restore it on exit */
Eric Andersen2d848a42001-06-25 17:11:54 +00001423 parent_pgrp = tcgetpgrp(shell_terminal);
Eric Andersen1c314ad2000-06-28 16:56:25 +00001424
Matt Kraaib8907522000-09-13 02:08:21 +00001425 command = (char *) xcalloc(BUFSIZ, sizeof(char));
Erik Andersend75af992000-03-16 08:09:09 +00001426
Erik Andersen161220c2000-03-16 08:12:48 +00001427 while (1) {
Eric Andersen86349772000-12-18 20:25:50 +00001428 if (!job_list.fg) {
Erik Andersend75af992000-03-16 08:09:09 +00001429 /* no job is in the foreground */
Erik Andersen3522eb12000-03-12 23:49:18 +00001430
Erik Andersend75af992000-03-16 08:09:09 +00001431 /* see if any background processes have exited */
Eric Andersen86349772000-12-18 20:25:50 +00001432 checkjobs(&job_list);
Erik Andersen3522eb12000-03-12 23:49:18 +00001433
Eric Andersen86349772000-12-18 20:25:50 +00001434 if (!next_command) {
1435 if (get_command(input, command))
Erik Andersen161220c2000-03-16 08:12:48 +00001436 break;
Eric Andersen86349772000-12-18 20:25:50 +00001437 next_command = command;
Erik Andersend75af992000-03-16 08:09:09 +00001438 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001439
Matt Kraai1f0c4362001-12-20 23:13:26 +00001440 if (! expand_arguments(next_command)) {
Eric Andersenca604592001-03-08 17:17:13 +00001441 free(command);
1442 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1443 next_command = NULL;
1444 continue;
1445 }
1446
Eric Andersen86349772000-12-18 20:25:50 +00001447 if (!parse_command(&next_command, &newjob, &inbg) &&
1448 newjob.num_progs) {
Eric Andersena1d187a2000-07-17 19:14:41 +00001449 int pipefds[2] = {-1,-1};
Eric Andersenb3d6e2d2001-03-13 22:57:56 +00001450 debug_printf( "job=%p fed to run_command by busy_loop()'\n",
1451 &newjob);
Eric Andersen86349772000-12-18 20:25:50 +00001452 run_command(&newjob, inbg, pipefds);
Eric Andersenfad9c112000-07-25 18:06:52 +00001453 }
1454 else {
Eric Andersena1d187a2000-07-17 19:14:41 +00001455 free(command);
Matt Kraaib8907522000-09-13 02:08:21 +00001456 command = (char *) xcalloc(BUFSIZ, sizeof(char));
Eric Andersen86349772000-12-18 20:25:50 +00001457 next_command = NULL;
Erik Andersend75af992000-03-16 08:09:09 +00001458 }
1459 } else {
1460 /* a job is running in the foreground; wait for it */
1461 i = 0;
Eric Andersen86349772000-12-18 20:25:50 +00001462 while (!job_list.fg->progs[i].pid ||
1463 job_list.fg->progs[i].is_stopped == 1) i++;
Erik Andersen3522eb12000-03-12 23:49:18 +00001464
Eric Andersen8ea28be2001-01-05 20:58:22 +00001465 if (waitpid(job_list.fg->progs[i].pid, &status, WUNTRACED)<0)
1466 perror_msg_and_die("waitpid(%d)",job_list.fg->progs[i].pid);
Erik Andersen3522eb12000-03-12 23:49:18 +00001467
Erik Andersend75af992000-03-16 08:09:09 +00001468 if (WIFEXITED(status) || WIFSIGNALED(status)) {
Erik Andersen161220c2000-03-16 08:12:48 +00001469 /* the child exited */
Eric Andersen86349772000-12-18 20:25:50 +00001470 job_list.fg->running_progs--;
1471 job_list.fg->progs[i].pid = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001472
Eric Andersen4b6b5e42001-06-27 04:30:11 +00001473 last_return_code=WEXITSTATUS(status);
1474
Eric Andersen86349772000-12-18 20:25:50 +00001475 if (!job_list.fg->running_progs) {
Erik Andersen161220c2000-03-16 08:12:48 +00001476 /* child exited */
Eric Andersen86349772000-12-18 20:25:50 +00001477 remove_job(&job_list, job_list.fg);
1478 job_list.fg = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001479 }
Erik Andersend75af992000-03-16 08:09:09 +00001480 } else {
Erik Andersen161220c2000-03-16 08:12:48 +00001481 /* the child was stopped */
Eric Andersen86349772000-12-18 20:25:50 +00001482 job_list.fg->stopped_progs++;
1483 job_list.fg->progs[i].is_stopped = 1;
Erik Andersen3522eb12000-03-12 23:49:18 +00001484
Eric Andersen86349772000-12-18 20:25:50 +00001485 if (job_list.fg->stopped_progs == job_list.fg->running_progs) {
1486 printf("\n" JOB_STATUS_FORMAT, job_list.fg->jobid,
1487 "Stopped", job_list.fg->text);
1488 job_list.fg = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001489 }
Erik Andersend75af992000-03-16 08:09:09 +00001490 }
1491
Eric Andersen86349772000-12-18 20:25:50 +00001492 if (!job_list.fg) {
Erik Andersen161220c2000-03-16 08:12:48 +00001493 /* move the shell to the foreground */
Eric Andersen1c314ad2000-06-28 16:56:25 +00001494 /* suppress messages when run from /linuxrc mag@sysgo.de */
Eric Andersen2d848a42001-06-25 17:11:54 +00001495 if (tcsetpgrp(shell_terminal, getpgrp()) && errno != ENOTTY)
Matt Kraaia9819b22000-12-22 01:48:07 +00001496 perror_msg("tcsetpgrp");
Erik Andersend75af992000-03-16 08:09:09 +00001497 }
1498 }
1499 }
Erik Andersen161220c2000-03-16 08:12:48 +00001500 free(command);
Erik Andersen3522eb12000-03-12 23:49:18 +00001501
Eric Andersen1c314ad2000-06-28 16:56:25 +00001502 /* return controlling TTY back to parent process group before exiting */
Eric Andersen2d848a42001-06-25 17:11:54 +00001503 if (tcsetpgrp(shell_terminal, parent_pgrp))
Matt Kraaia9819b22000-12-22 01:48:07 +00001504 perror_msg("tcsetpgrp");
Eric Andersenb54833c2000-07-03 23:56:26 +00001505
1506 /* return exit status if called with "-c" */
1507 if (input == NULL && WIFEXITED(status))
1508 return WEXITSTATUS(status);
1509
Erik Andersen161220c2000-03-16 08:12:48 +00001510 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001511}
1512
1513
Eric Andersenbdfd0d72001-10-24 05:00:29 +00001514#ifdef CONFIG_FEATURE_CLEAN_UP
Eric Andersenfad9c112000-07-25 18:06:52 +00001515void free_memory(void)
1516{
Eric Andersen5d60a462001-08-22 05:32:24 +00001517 if (cwd && cwd!=unknown) {
1518 free((char*)cwd);
Eric Andersene5dfced2001-04-09 22:48:12 +00001519 }
Eric Andersenfad9c112000-07-25 18:06:52 +00001520 if (local_pending_command)
1521 free(local_pending_command);
1522
Eric Andersen86349772000-12-18 20:25:50 +00001523 if (job_list.fg && !job_list.fg->running_progs) {
1524 remove_job(&job_list, job_list.fg);
Eric Andersenfad9c112000-07-25 18:06:52 +00001525 }
1526}
1527#endif
1528
Eric Andersen2d848a42001-06-25 17:11:54 +00001529/* Make sure we have a controlling tty. If we get started under a job
1530 * aware app (like bash for example), make sure we are now in charge so
1531 * we don't fight over who gets the foreground */
1532static void setup_job_control()
1533{
Eric Andersenf0a4ac82001-10-03 11:23:42 +00001534 int status;
1535
Eric Andersen2d848a42001-06-25 17:11:54 +00001536 /* Loop until we are in the foreground. */
Eric Andersenf0a4ac82001-10-03 11:23:42 +00001537 while ((status = tcgetpgrp (shell_terminal)) >= 0) {
1538 if (status == (shell_pgrp = getpgrp ())) {
1539 break;
1540 }
Eric Andersen2d848a42001-06-25 17:11:54 +00001541 kill (- shell_pgrp, SIGTTIN);
Eric Andersenf0a4ac82001-10-03 11:23:42 +00001542 }
Eric Andersen2d848a42001-06-25 17:11:54 +00001543
1544 /* Ignore interactive and job-control signals. */
1545 signal(SIGINT, SIG_IGN);
1546 signal(SIGQUIT, SIG_IGN);
1547 signal(SIGTSTP, SIG_IGN);
1548 signal(SIGTTIN, SIG_IGN);
1549 signal(SIGTTOU, SIG_IGN);
1550 signal(SIGCHLD, SIG_IGN);
1551
1552 /* Put ourselves in our own process group. */
Eric Andersen4b6b5e42001-06-27 04:30:11 +00001553 setsid();
Eric Andersen2d848a42001-06-25 17:11:54 +00001554 shell_pgrp = getpid ();
Eric Andersen4b6b5e42001-06-27 04:30:11 +00001555 setpgid (shell_pgrp, shell_pgrp);
Eric Andersen2d848a42001-06-25 17:11:54 +00001556
1557 /* Grab control of the terminal. */
1558 tcsetpgrp(shell_terminal, shell_pgrp);
1559}
Eric Andersen6efc48c2000-07-18 08:16:39 +00001560
Matt Kraai2d91deb2001-08-01 17:21:35 +00001561int lash_main(int argc_l, char **argv_l)
Erik Andersen3522eb12000-03-12 23:49:18 +00001562{
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001563 int opt, interactive=FALSE;
Erik Andersen161220c2000-03-16 08:12:48 +00001564 FILE *input = stdin;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001565 argc = argc_l;
1566 argv = argv_l;
Erik Andersen3522eb12000-03-12 23:49:18 +00001567
Eric Andersen702ec592001-03-06 22:17:29 +00001568 /* These variables need re-initializing when recursing */
Eric Andersen8a646dd2001-06-21 16:38:11 +00001569 last_jobid = 0;
Eric Andersenb0970d42001-01-05 19:34:52 +00001570 local_pending_command = NULL;
Eric Andersen702ec592001-03-06 22:17:29 +00001571 close_me_head = NULL;
Eric Andersenb0970d42001-01-05 19:34:52 +00001572 job_list.head = NULL;
1573 job_list.fg = NULL;
Eric Andersen4b6b5e42001-06-27 04:30:11 +00001574 last_return_code=1;
Eric Andersen501c88b2000-07-28 15:14:45 +00001575
Eric Andersenb558e762000-11-30 22:43:16 +00001576 if (argv[0] && argv[0][0] == '-') {
Eric Andersen8ea28be2001-01-05 20:58:22 +00001577 FILE *prof_input;
1578 prof_input = fopen("/etc/profile", "r");
Eric Andersen4b6b5e42001-06-27 04:30:11 +00001579 if (prof_input) {
Eric Andersen8ea28be2001-01-05 20:58:22 +00001580 int tmp_fd = fileno(prof_input);
1581 mark_open(tmp_fd);
1582 /* Now run the file */
1583 busy_loop(prof_input);
1584 fclose(prof_input);
1585 mark_closed(tmp_fd);
1586 }
Eric Andersenb558e762000-11-30 22:43:16 +00001587 }
Eric Andersen501c88b2000-07-28 15:14:45 +00001588
Eric Andersenf21aa842000-12-08 20:50:30 +00001589 while ((opt = getopt(argc_l, argv_l, "cxi")) > 0) {
Eric Andersen501c88b2000-07-28 15:14:45 +00001590 switch (opt) {
1591 case 'c':
1592 input = NULL;
Matt Kraai6085c722000-09-06 01:46:18 +00001593 if (local_pending_command != 0)
Matt Kraaidd19c692001-01-31 19:00:21 +00001594 error_msg_and_die("multiple -c arguments");
Matt Kraai6085c722000-09-06 01:46:18 +00001595 local_pending_command = xstrdup(argv[optind]);
1596 optind++;
1597 argv = argv+optind;
Eric Andersen501c88b2000-07-28 15:14:45 +00001598 break;
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001599 case 'i':
1600 interactive = TRUE;
1601 break;
Eric Andersen501c88b2000-07-28 15:14:45 +00001602 default:
Eric Andersen67991cf2001-02-14 21:23:06 +00001603 show_usage();
Eric Andersen501c88b2000-07-28 15:14:45 +00001604 }
1605 }
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001606 /* A shell is interactive if the `-i' flag was given, or if all of
1607 * the following conditions are met:
1608 * no -c command
1609 * no arguments remaining or the -s flag given
1610 * standard input is a terminal
1611 * standard output is a terminal
1612 * Refer to Posix.2, the description of the `sh' utility. */
Eric Andersen86349772000-12-18 20:25:50 +00001613 if (argv[optind]==NULL && input==stdin &&
1614 isatty(fileno(stdin)) && isatty(fileno(stdout))) {
1615 interactive=TRUE;
1616 }
Eric Andersen2d848a42001-06-25 17:11:54 +00001617 setup_job_control();
Eric Andersen86349772000-12-18 20:25:50 +00001618 if (interactive==TRUE) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001619 //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
Eric Andersen501c88b2000-07-28 15:14:45 +00001620 /* Looks like they want an interactive shell */
Eric Andersenbdfd0d72001-10-24 05:00:29 +00001621#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
Matt Kraai4ef40c02001-04-12 20:44:21 +00001622 printf( "\n\n" BB_BANNER " Built-in shell (lash)\n");
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001623 printf( "Enter 'help' for a list of built-in commands.\n\n");
Eric Andersend63dee42001-10-19 00:22:23 +00001624#endif
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001625 } else if (local_pending_command==NULL) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001626 //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
Matt Kraaibbaef662000-09-27 02:43:35 +00001627 input = xfopen(argv[optind], "r");
Eric Andersen8ea28be2001-01-05 20:58:22 +00001628 mark_open(fileno(input)); /* be lazy, never mark this closed */
Eric Andersen501c88b2000-07-28 15:14:45 +00001629 }
1630
Eric Andersen6efc48c2000-07-18 08:16:39 +00001631 /* initialize the cwd -- this is never freed...*/
Eric Andersene5dfced2001-04-09 22:48:12 +00001632 cwd = xgetcwd(0);
Eric Andersen5f265b72001-05-11 16:58:46 +00001633 if (!cwd)
1634 cwd = unknown;
Erik Andersen3522eb12000-03-12 23:49:18 +00001635
Eric Andersenbdfd0d72001-10-24 05:00:29 +00001636#ifdef CONFIG_FEATURE_CLEAN_UP
Eric Andersenfad9c112000-07-25 18:06:52 +00001637 atexit(free_memory);
1638#endif
1639
Eric Andersenbdfd0d72001-10-24 05:00:29 +00001640#ifdef CONFIG_FEATURE_COMMAND_EDITING
Eric Andersenb3d6e2d2001-03-13 22:57:56 +00001641 cmdedit_set_initial_prompt();
1642#else
1643 PS1 = NULL;
Eric Andersenb3d6e2d2001-03-13 22:57:56 +00001644#endif
1645
Erik Andersen161220c2000-03-16 08:12:48 +00001646 return (busy_loop(input));
Erik Andersen3522eb12000-03-12 23:49:18 +00001647}