blob: ffdec8781f5a5c69eb9d1eada0b10f9400ea7884 [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 Andersen8a646dd2001-06-21 16:38:11 +000028/* This shell's parsing engine is officially at a dead-end.
29 * Future work shell work should be done using hush.c
Eric Andersen8ea28be2001-01-05 20:58:22 +000030 */
Eric Andersen8a646dd2001-06-21 16:38:11 +000031
Eric Andersen1e7cea92000-12-06 23:47:38 +000032//For debugging/development on the shell only...
Eric Andersen501c88b2000-07-28 15:14:45 +000033//#define DEBUG_SHELL
Eric Andersena1d187a2000-07-17 19:14:41 +000034
35
Erik Andersen3522eb12000-03-12 23:49:18 +000036#include <stdio.h>
37#include <stdlib.h>
38#include <ctype.h>
39#include <errno.h>
40#include <fcntl.h>
Erik Andersen3522eb12000-03-12 23:49:18 +000041#include <signal.h>
42#include <string.h>
43#include <sys/ioctl.h>
44#include <sys/wait.h>
45#include <unistd.h>
Eric Andersen501c88b2000-07-28 15:14:45 +000046#include <getopt.h>
Eric Andersen2d848a42001-06-25 17:11:54 +000047#include <termios.h>
Mark Whitley4b541a82001-04-25 17:10:30 +000048#include "busybox.h"
49#include "cmdedit.h"
Eric Andersene5dfced2001-04-09 22:48:12 +000050
51#ifdef BB_LOCALE_SUPPORT
Mark Whitley1c6581a2001-03-27 16:35:16 +000052#include <locale.h>
Eric Andersene5dfced2001-04-09 22:48:12 +000053#endif
Eric Andersen13d1fa12001-03-08 23:59:45 +000054
Eric Andersen13d1fa12001-03-08 23:59:45 +000055#include <glob.h>
56#define expand_t glob_t
Erik Andersen3522eb12000-03-12 23:49:18 +000057
Eric Andersen13d1fa12001-03-08 23:59:45 +000058
Mark Whitley59ab0252001-01-23 22:30:04 +000059static const int MAX_READ = 128; /* size of input buffer for `read' builtin */
Erik Andersen3522eb12000-03-12 23:49:18 +000060#define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
61
Erik Andersend75af992000-03-16 08:09:09 +000062
Eric Andersen86349772000-12-18 20:25:50 +000063enum redir_type { REDIRECT_INPUT, REDIRECT_OVERWRITE,
Erik Andersen161220c2000-03-16 08:12:48 +000064 REDIRECT_APPEND
65};
Erik Andersen3522eb12000-03-12 23:49:18 +000066
Eric Andersen86349772000-12-18 20:25:50 +000067static const unsigned int DEFAULT_CONTEXT=0x1;
Eric Andersen6a99aaf2000-07-27 00:15:20 +000068static const unsigned int IF_TRUE_CONTEXT=0x2;
69static const unsigned int IF_FALSE_CONTEXT=0x4;
70static const unsigned int THEN_EXP_CONTEXT=0x8;
71static const unsigned int ELSE_EXP_CONTEXT=0x10;
Eric Andersenfad9c112000-07-25 18:06:52 +000072
Eric Andersen86349772000-12-18 20:25:50 +000073
74struct jobset {
Erik Andersen161220c2000-03-16 08:12:48 +000075 struct job *head; /* head of list of running jobs */
76 struct job *fg; /* current foreground job */
Erik Andersen3522eb12000-03-12 23:49:18 +000077};
78
Eric Andersen86349772000-12-18 20:25:50 +000079struct redir_struct {
80 enum redir_type type; /* type of redirection */
Erik Andersen161220c2000-03-16 08:12:48 +000081 int fd; /* file descriptor being redirected */
82 char *filename; /* file to redirect fd to */
Erik Andersen3522eb12000-03-12 23:49:18 +000083};
84
Eric Andersen86349772000-12-18 20:25:50 +000085struct child_prog {
Erik Andersen161220c2000-03-16 08:12:48 +000086 pid_t pid; /* 0 if exited */
87 char **argv; /* program name and arguments */
Eric Andersen86349772000-12-18 20:25:50 +000088 int num_redirects; /* elements in redirection array */
89 struct redir_struct *redirects; /* I/O redirects */
Eric Andersen86349772000-12-18 20:25:50 +000090 int is_stopped; /* is the program currently running? */
91 struct job *family; /* pointer back to the child's parent job */
Erik Andersen3522eb12000-03-12 23:49:18 +000092};
93
94struct job {
Eric Andersen86349772000-12-18 20:25:50 +000095 int jobid; /* job number */
96 int num_progs; /* total number of programs in job */
97 int running_progs; /* number of programs running */
Erik Andersen161220c2000-03-16 08:12:48 +000098 char *text; /* name of job */
Eric Andersen86349772000-12-18 20:25:50 +000099 char *cmdbuf; /* buffer various argv's point into */
Erik Andersen161220c2000-03-16 08:12:48 +0000100 pid_t pgrp; /* process group ID for the job */
Eric Andersen86349772000-12-18 20:25:50 +0000101 struct child_prog *progs; /* array of programs in job */
Erik Andersen161220c2000-03-16 08:12:48 +0000102 struct job *next; /* to track background commands */
Eric Andersen86349772000-12-18 20:25:50 +0000103 int stopped_progs; /* number of programs alive, but stopped */
104 unsigned int job_context; /* bitmask defining current context */
105 struct jobset *job_list;
Erik Andersen3522eb12000-03-12 23:49:18 +0000106};
107
Eric Andersen86349772000-12-18 20:25:50 +0000108struct built_in_command {
Erik Andersen161220c2000-03-16 08:12:48 +0000109 char *cmd; /* name */
110 char *descr; /* description */
Eric Andersen86349772000-12-18 20:25:50 +0000111 int (*function) (struct child_prog *); /* function ptr */
Erik Andersen3522eb12000-03-12 23:49:18 +0000112};
113
Eric Andersen8ea28be2001-01-05 20:58:22 +0000114struct close_me {
115 int fd;
116 struct close_me *next;
117};
118
Eric Andersen34e19412000-07-10 18:47:24 +0000119/* function prototypes for builtins */
Eric Andersen86349772000-12-18 20:25:50 +0000120static int builtin_cd(struct child_prog *cmd);
Eric Andersen86349772000-12-18 20:25:50 +0000121static int builtin_exec(struct child_prog *cmd);
122static int builtin_exit(struct child_prog *cmd);
123static int builtin_fg_bg(struct child_prog *cmd);
124static int builtin_help(struct child_prog *cmd);
125static int builtin_jobs(struct child_prog *dummy);
126static int builtin_pwd(struct child_prog *dummy);
127static int builtin_export(struct child_prog *cmd);
128static int builtin_source(struct child_prog *cmd);
129static int builtin_unset(struct child_prog *cmd);
130static int builtin_read(struct child_prog *cmd);
Erik Andersen3522eb12000-03-12 23:49:18 +0000131
Eric Andersen34e19412000-07-10 18:47:24 +0000132
133/* function prototypes for shell stuff */
Eric Andersen8ea28be2001-01-05 20:58:22 +0000134static void mark_open(int fd);
135static void mark_closed(int fd);
Eric Andersen36278b92001-03-06 20:47:31 +0000136static void close_all(void);
Eric Andersen86349772000-12-18 20:25:50 +0000137static void checkjobs(struct jobset *job_list);
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000138static void remove_job(struct jobset *j_list, struct job *job);
Eric Andersen86349772000-12-18 20:25:50 +0000139static int get_command(FILE * source, char *command);
140static int parse_command(char **command_ptr, struct job *job, int *inbg);
141static int run_command(struct job *newjob, int inbg, int outpipe[2]);
142static int pseudo_exec(struct child_prog *cmd) __attribute__ ((noreturn));
Erik Andersen3522eb12000-03-12 23:49:18 +0000143static int busy_loop(FILE * input);
144
Erik Andersend75af992000-03-16 08:09:09 +0000145
Mark Whitley37653aa2000-07-12 23:36:17 +0000146/* Table of built-in functions (these are non-forking builtins, meaning they
147 * can change global variables in the parent shell process but they will not
148 * work with pipes and redirects; 'unset foo | whatever' will not work) */
Eric Andersen86349772000-12-18 20:25:50 +0000149static struct built_in_command bltins[] = {
Eric Andersenfad9c112000-07-25 18:06:52 +0000150 {"bg", "Resume a job in the background", builtin_fg_bg},
151 {"cd", "Change working directory", builtin_cd},
Eric Andersend2f56772000-09-21 02:48:07 +0000152 {"exec", "Exec command, replacing this shell with the exec'd process", builtin_exec},
Eric Andersenfad9c112000-07-25 18:06:52 +0000153 {"exit", "Exit from shell()", builtin_exit},
154 {"fg", "Bring job into the foreground", builtin_fg_bg},
155 {"jobs", "Lists the active jobs", builtin_jobs},
156 {"export", "Set environment variable", builtin_export},
157 {"unset", "Unset environment variable", builtin_unset},
158 {"read", "Input environment variable", builtin_read},
Matt Kraaidd450a02000-09-13 03:43:36 +0000159 {".", "Source-in and run commands in a file", builtin_source},
Eric Andersen86349772000-12-18 20:25:50 +0000160 /* to do: add ulimit */
Eric Andersenfad9c112000-07-25 18:06:52 +0000161 {NULL, NULL, NULL}
Erik Andersen330fd2b2000-05-19 05:35:19 +0000162};
163
Mark Whitley37653aa2000-07-12 23:36:17 +0000164/* Table of forking built-in functions (things that fork cannot change global
165 * variables in the parent process, such as the current working directory) */
Eric Andersen86349772000-12-18 20:25:50 +0000166static struct built_in_command bltins_forking[] = {
Eric Andersenfad9c112000-07-25 18:06:52 +0000167 {"pwd", "Print current directory", builtin_pwd},
Eric Andersenfad9c112000-07-25 18:06:52 +0000168 {"help", "List shell built-in commands", builtin_help},
169 {NULL, NULL, NULL}
Erik Andersen3522eb12000-03-12 23:49:18 +0000170};
171
Eric Andersen0bcc8132001-01-05 19:37:32 +0000172
Eric Andersen7467c8d2001-07-12 20:26:32 +0000173static int shell_context; /* Type prompt trigger (PS1 or PS2) */
Eric Andersen0bcc8132001-01-05 19:37:32 +0000174
175
176/* Globals that are static to this file */
Eric Andersencfa88ec2001-05-11 18:08:16 +0000177static const char *cwd;
Eric Andersen744b0642001-01-05 21:23:44 +0000178static char *local_pending_command = NULL;
Eric Andersen86349772000-12-18 20:25:50 +0000179static struct jobset job_list = { NULL, NULL };
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000180static int argc;
181static char **argv;
Eric Andersen702ec592001-03-06 22:17:29 +0000182static struct close_me *close_me_head;
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000183static int last_return_code;
184static int last_bg_pid;
Eric Andersen8a646dd2001-06-21 16:38:11 +0000185static unsigned int last_jobid;
Eric Andersen2d848a42001-06-25 17:11:54 +0000186static int shell_terminal;
187static pid_t shell_pgrp;
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000188static char *PS1;
Eric Andersene5dfced2001-04-09 22:48:12 +0000189static char *PS2 = "> ";
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000190
191
Eric Andersenb558e762000-11-30 22:43:16 +0000192#ifdef DEBUG_SHELL
193static inline void debug_printf(const char *format, ...)
194{
195 va_list args;
196 va_start(args, format);
Eric Andersen86349772000-12-18 20:25:50 +0000197 vfprintf(stderr, format, args);
Eric Andersenb558e762000-11-30 22:43:16 +0000198 va_end(args);
199}
200#else
201static inline void debug_printf(const char *format, ...) { }
202#endif
Erik Andersen3522eb12000-03-12 23:49:18 +0000203
Eric Andersen86349772000-12-18 20:25:50 +0000204/*
205 Most builtins need access to the struct child_prog that has
206 their arguments, previously coded as cmd->progs[0]. That coding
207 can exhibit a bug, if the builtin is not the first command in
208 a pipeline: "echo foo | exec sort" will attempt to exec foo.
209
210builtin previous use notes
211------ ----------------- ---------
212cd cmd->progs[0]
Eric Andersen86349772000-12-18 20:25:50 +0000213exec cmd->progs[0] squashed bug: didn't look for applets or forking builtins
214exit cmd->progs[0]
215fg_bg cmd->progs[0], job_list->head, job_list->fg
216help 0
217jobs job_list->head
218pwd 0
Eric Andersen84e229c2001-03-29 22:48:33 +0000219export cmd->progs[0]
Eric Andersen86349772000-12-18 20:25:50 +0000220source cmd->progs[0]
221unset cmd->progs[0]
222read cmd->progs[0]
Eric Andersen86349772000-12-18 20:25:50 +0000223
224I added "struct job *family;" to struct child_prog,
225and switched API to builtin_foo(struct child_prog *child);
226So cmd->text becomes child->family->text
227 cmd->job_context becomes child->family->job_context
228 cmd->progs[0] becomes *child
229 job_list becomes child->family->job_list
230 */
Erik Andersen3522eb12000-03-12 23:49:18 +0000231
Erik Andersend75af992000-03-16 08:09:09 +0000232/* built-in 'cd <path>' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000233static int builtin_cd(struct child_prog *child)
Erik Andersend75af992000-03-16 08:09:09 +0000234{
Erik Andersen161220c2000-03-16 08:12:48 +0000235 char *newdir;
Erik Andersend75af992000-03-16 08:09:09 +0000236
Eric Andersen86349772000-12-18 20:25:50 +0000237 if (child->argv[1] == NULL)
Erik Andersen161220c2000-03-16 08:12:48 +0000238 newdir = getenv("HOME");
239 else
Eric Andersen86349772000-12-18 20:25:50 +0000240 newdir = child->argv[1];
Erik Andersen161220c2000-03-16 08:12:48 +0000241 if (chdir(newdir)) {
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000242 printf("cd: %s: %m\n", newdir);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000243 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000244 }
Eric Andersencfa88ec2001-05-11 18:08:16 +0000245 cwd = xgetcwd((char *)cwd);
Eric Andersen5f265b72001-05-11 16:58:46 +0000246 if (!cwd)
247 cwd = unknown;
Matt Kraai3e856ce2000-12-01 02:55:13 +0000248 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000249}
250
Eric Andersend2f56772000-09-21 02:48:07 +0000251/* built-in 'exec' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000252static int builtin_exec(struct child_prog *child)
Eric Andersend2f56772000-09-21 02:48:07 +0000253{
Eric Andersen86349772000-12-18 20:25:50 +0000254 if (child->argv[1] == NULL)
255 return EXIT_SUCCESS; /* Really? */
256 child->argv++;
Eric Andersen07f2f392001-03-06 20:28:22 +0000257 close_all();
Eric Andersen86349772000-12-18 20:25:50 +0000258 pseudo_exec(child);
259 /* never returns */
Eric Andersend2f56772000-09-21 02:48:07 +0000260}
261
Erik Andersen3522eb12000-03-12 23:49:18 +0000262/* built-in 'exit' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000263static int builtin_exit(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000264{
Eric Andersen86349772000-12-18 20:25:50 +0000265 if (child->argv[1] == NULL)
Matt Kraai3e856ce2000-12-01 02:55:13 +0000266 exit(EXIT_SUCCESS);
Erik Andersen161220c2000-03-16 08:12:48 +0000267
Eric Andersen86349772000-12-18 20:25:50 +0000268 exit (atoi(child->argv[1]));
Erik Andersen3522eb12000-03-12 23:49:18 +0000269}
270
271/* built-in 'fg' and 'bg' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000272static int builtin_fg_bg(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000273{
Eric Andersen8a646dd2001-06-21 16:38:11 +0000274 int i, jobnum;
Erik Andersen6273f652000-03-17 01:12:41 +0000275 struct job *job=NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +0000276
Eric Andersen8a646dd2001-06-21 16:38:11 +0000277 /* If they gave us no args, assume they want the last backgrounded task */
278 if (!child->argv[1]) {
279 for (job = child->family->job_list->head; job; job = job->next) {
280 if (job->jobid == last_jobid) {
281 break;
282 }
Erik Andersen161220c2000-03-16 08:12:48 +0000283 }
Eric Andersen8a646dd2001-06-21 16:38:11 +0000284 if (!job) {
285 error_msg("%s: no current job", child->argv[0]);
286 return EXIT_FAILURE;
287 }
288 } else {
289 if (sscanf(child->argv[1], "%%%d", &jobnum) != 1) {
290 error_msg("%s: bad argument '%s'", child->argv[0], child->argv[1]);
291 return EXIT_FAILURE;
292 }
293 for (job = child->family->job_list->head; job; job = job->next) {
294 if (job->jobid == jobnum) {
295 break;
296 }
297 }
298 if (!job) {
299 error_msg("%s: %d: no such job", child->argv[0], jobnum);
300 return EXIT_FAILURE;
301 }
Erik Andersend75af992000-03-16 08:09:09 +0000302 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000303
Eric Andersen86349772000-12-18 20:25:50 +0000304 if (*child->argv[0] == 'f') {
Eric Andersen2d848a42001-06-25 17:11:54 +0000305 /* Put the job into the foreground. */
306 tcsetpgrp(shell_terminal, job->pgrp);
307
Eric Andersen86349772000-12-18 20:25:50 +0000308 child->family->job_list->fg = job;
Erik Andersen161220c2000-03-16 08:12:48 +0000309 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000310
Erik Andersen161220c2000-03-16 08:12:48 +0000311 /* Restart the processes in the job */
Eric Andersen86349772000-12-18 20:25:50 +0000312 for (i = 0; i < job->num_progs; i++)
313 job->progs[i].is_stopped = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000314
Eric Andersen86349772000-12-18 20:25:50 +0000315 job->stopped_progs = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000316
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000317 if ( (i=kill(- job->pgrp, SIGCONT)) < 0) {
318 if (i == ESRCH) {
319 remove_job(&job_list, job);
Eric Andersen07abfe22001-06-27 17:29:11 +0000320 } else {
321 perror_msg("kill (SIGCONT)");
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000322 }
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000323 }
Eric Andersen2d848a42001-06-25 17:11:54 +0000324
Matt Kraai3e856ce2000-12-01 02:55:13 +0000325 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000326}
327
328/* built-in 'help' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000329static int builtin_help(struct child_prog *dummy)
Erik Andersen3522eb12000-03-12 23:49:18 +0000330{
Eric Andersen86349772000-12-18 20:25:50 +0000331 struct built_in_command *x;
Erik Andersen3522eb12000-03-12 23:49:18 +0000332
Eric Andersen86349772000-12-18 20:25:50 +0000333 printf("\nBuilt-in commands:\n");
334 printf("-------------------\n");
Erik Andersen161220c2000-03-16 08:12:48 +0000335 for (x = bltins; x->cmd; x++) {
Eric Andersenfad9c112000-07-25 18:06:52 +0000336 if (x->descr==NULL)
337 continue;
Eric Andersen86349772000-12-18 20:25:50 +0000338 printf("%s\t%s\n", x->cmd, x->descr);
Erik Andersen161220c2000-03-16 08:12:48 +0000339 }
Erik Andersen330fd2b2000-05-19 05:35:19 +0000340 for (x = bltins_forking; x->cmd; x++) {
Eric Andersenfad9c112000-07-25 18:06:52 +0000341 if (x->descr==NULL)
342 continue;
Eric Andersen86349772000-12-18 20:25:50 +0000343 printf("%s\t%s\n", x->cmd, x->descr);
Erik Andersen330fd2b2000-05-19 05:35:19 +0000344 }
Eric Andersen86349772000-12-18 20:25:50 +0000345 printf("\n\n");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000346 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000347}
348
349/* built-in 'jobs' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000350static int builtin_jobs(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000351{
Erik Andersen161220c2000-03-16 08:12:48 +0000352 struct job *job;
Eric Andersen86349772000-12-18 20:25:50 +0000353 char *status_string;
Erik Andersen3522eb12000-03-12 23:49:18 +0000354
Eric Andersen86349772000-12-18 20:25:50 +0000355 for (job = child->family->job_list->head; job; job = job->next) {
356 if (job->running_progs == job->stopped_progs)
357 status_string = "Stopped";
Erik Andersen161220c2000-03-16 08:12:48 +0000358 else
Eric Andersen86349772000-12-18 20:25:50 +0000359 status_string = "Running";
Erik Andersen161220c2000-03-16 08:12:48 +0000360
Eric Andersen86349772000-12-18 20:25:50 +0000361 printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text);
Erik Andersen161220c2000-03-16 08:12:48 +0000362 }
Matt Kraai3e856ce2000-12-01 02:55:13 +0000363 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000364}
365
366
367/* built-in 'pwd' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000368static int builtin_pwd(struct child_prog *dummy)
Erik Andersen3522eb12000-03-12 23:49:18 +0000369{
Eric Andersencfa88ec2001-05-11 18:08:16 +0000370 cwd = xgetcwd((char *)cwd);
Eric Andersen5f265b72001-05-11 16:58:46 +0000371 if (!cwd)
372 cwd = unknown;
Matt Kraai59df6f72001-05-16 14:21:09 +0000373 puts(cwd);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000374 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000375}
376
Erik Andersen6273f652000-03-17 01:12:41 +0000377/* built-in 'export VAR=value' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000378static int builtin_export(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000379{
Erik Andersen161220c2000-03-16 08:12:48 +0000380 int res;
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000381 char *v = child->argv[1];
Erik Andersen3522eb12000-03-12 23:49:18 +0000382
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000383 if (v == NULL) {
Eric Andersen84e229c2001-03-29 22:48:33 +0000384 char **e;
385 for (e = environ; *e; e++) {
Matt Kraai59df6f72001-05-16 14:21:09 +0000386 puts(*e);
Eric Andersen84e229c2001-03-29 22:48:33 +0000387 }
Matt Kraai2129f972001-04-04 17:50:04 +0000388 return 0;
Erik Andersen161220c2000-03-16 08:12:48 +0000389 }
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000390 res = putenv(v);
Erik Andersen161220c2000-03-16 08:12:48 +0000391 if (res)
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000392 fprintf(stderr, "export: %m\n");
Eric Andersen004015e2001-05-21 20:30:51 +0000393#ifdef BB_FEATURE_SH_FANCY_PROMPT
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000394 if (strncmp(v, "PS1=", 4)==0)
395 PS1 = getenv("PS1");
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000396#endif
Eric Andersene5dfced2001-04-09 22:48:12 +0000397
398#ifdef BB_LOCALE_SUPPORT
Mark Whitley1c6581a2001-03-27 16:35:16 +0000399 if(strncmp(v, "LC_ALL=", 7)==0)
400 setlocale(LC_ALL, getenv("LC_ALL"));
Mark Whitleya82a0032001-03-27 17:07:15 +0000401 if(strncmp(v, "LC_CTYPE=", 9)==0)
Mark Whitley1c6581a2001-03-27 16:35:16 +0000402 setlocale(LC_CTYPE, getenv("LC_CTYPE"));
Eric Andersene5dfced2001-04-09 22:48:12 +0000403#endif
Mark Whitley1c6581a2001-03-27 16:35:16 +0000404
Erik Andersen161220c2000-03-16 08:12:48 +0000405 return (res);
Erik Andersen3522eb12000-03-12 23:49:18 +0000406}
407
Eric Andersenb54833c2000-07-03 23:56:26 +0000408/* built-in 'read VAR' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000409static int builtin_read(struct child_prog *child)
Eric Andersenb54833c2000-07-03 23:56:26 +0000410{
411 int res = 0, len, newlen;
412 char *s;
413 char string[MAX_READ];
414
Eric Andersen86349772000-12-18 20:25:50 +0000415 if (child->argv[1]) {
Eric Andersenb54833c2000-07-03 23:56:26 +0000416 /* argument (VAR) given: put "VAR=" into buffer */
Eric Andersen86349772000-12-18 20:25:50 +0000417 strcpy(string, child->argv[1]);
Eric Andersenb54833c2000-07-03 23:56:26 +0000418 len = strlen(string);
419 string[len++] = '=';
420 string[len] = '\0';
421 fgets(&string[len], sizeof(string) - len, stdin); /* read string */
422 newlen = strlen(string);
423 if(newlen > len)
424 string[--newlen] = '\0'; /* chomp trailing newline */
425 /*
426 ** string should now contain "VAR=<value>"
427 ** copy it (putenv() won't do that, so we must make sure
428 ** the string resides in a static buffer!)
429 */
430 res = -1;
431 if((s = strdup(string)))
432 res = putenv(s);
433 if (res)
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000434 fprintf(stderr, "read: %m\n");
Eric Andersenb54833c2000-07-03 23:56:26 +0000435 }
436 else
437 fgets(string, sizeof(string), stdin);
438
439 return (res);
440}
441
Erik Andersen3522eb12000-03-12 23:49:18 +0000442/* Built-in '.' handler (read-in and execute commands from file) */
Eric Andersen86349772000-12-18 20:25:50 +0000443static int builtin_source(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000444{
Erik Andersen161220c2000-03-16 08:12:48 +0000445 FILE *input;
446 int status;
Eric Andersen8ea28be2001-01-05 20:58:22 +0000447 int fd;
Erik Andersen3522eb12000-03-12 23:49:18 +0000448
Eric Andersen86349772000-12-18 20:25:50 +0000449 if (child->argv[1] == NULL)
Matt Kraai3e856ce2000-12-01 02:55:13 +0000450 return EXIT_FAILURE;
Erik Andersen3522eb12000-03-12 23:49:18 +0000451
Eric Andersen86349772000-12-18 20:25:50 +0000452 input = fopen(child->argv[1], "r");
Erik Andersen161220c2000-03-16 08:12:48 +0000453 if (!input) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +0000454 printf( "Couldn't open file '%s'\n", child->argv[1]);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000455 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000456 }
Erik Andersend75af992000-03-16 08:09:09 +0000457
Eric Andersen8ea28be2001-01-05 20:58:22 +0000458 fd=fileno(input);
459 mark_open(fd);
Erik Andersen161220c2000-03-16 08:12:48 +0000460 /* Now run the file */
461 status = busy_loop(input);
Matt Kraaidd450a02000-09-13 03:43:36 +0000462 fclose(input);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000463 mark_closed(fd);
Erik Andersen161220c2000-03-16 08:12:48 +0000464 return (status);
Erik Andersen3522eb12000-03-12 23:49:18 +0000465}
466
467/* built-in 'unset VAR' handler */
Eric Andersen86349772000-12-18 20:25:50 +0000468static int builtin_unset(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +0000469{
Eric Andersen86349772000-12-18 20:25:50 +0000470 if (child->argv[1] == NULL) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +0000471 printf( "unset: parameter required.\n");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000472 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000473 }
Eric Andersen86349772000-12-18 20:25:50 +0000474 unsetenv(child->argv[1]);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000475 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000476}
477
Eric Andersen8ea28be2001-01-05 20:58:22 +0000478static void mark_open(int fd)
479{
480 struct close_me *new = xmalloc(sizeof(struct close_me));
481 new->fd = fd;
482 new->next = close_me_head;
483 close_me_head = new;
484}
485
486static void mark_closed(int fd)
487{
488 struct close_me *tmp;
489 if (close_me_head == NULL || close_me_head->fd != fd)
490 error_msg_and_die("corrupt close_me");
491 tmp = close_me_head;
492 close_me_head = close_me_head->next;
493 free(tmp);
494}
495
496static void close_all()
497{
Eric Andersen702ec592001-03-06 22:17:29 +0000498 struct close_me *c, *tmp;
499 for (c=close_me_head; c; c=tmp) {
500 close(c->fd);
501 tmp=c->next;
502 free(c);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000503 }
504 close_me_head = NULL;
505}
506
507
Erik Andersen3522eb12000-03-12 23:49:18 +0000508/* free up all memory from a job */
Eric Andersen86349772000-12-18 20:25:50 +0000509static void free_job(struct job *cmd)
Erik Andersen3522eb12000-03-12 23:49:18 +0000510{
Erik Andersen161220c2000-03-16 08:12:48 +0000511 int i;
Mark Whitley44a99142001-03-14 17:26:37 +0000512 struct jobset *keep;
Erik Andersen3522eb12000-03-12 23:49:18 +0000513
Eric Andersen86349772000-12-18 20:25:50 +0000514 for (i = 0; i < cmd->num_progs; i++) {
Erik Andersen161220c2000-03-16 08:12:48 +0000515 free(cmd->progs[i].argv);
Eric Andersen86349772000-12-18 20:25:50 +0000516 if (cmd->progs[i].redirects)
517 free(cmd->progs[i].redirects);
Erik Andersen161220c2000-03-16 08:12:48 +0000518 }
Mark Whitley44a99142001-03-14 17:26:37 +0000519 if (cmd->progs)
520 free(cmd->progs);
Erik Andersen161220c2000-03-16 08:12:48 +0000521 if (cmd->text)
522 free(cmd->text);
Mark Whitley44a99142001-03-14 17:26:37 +0000523 if (cmd->cmdbuf)
524 free(cmd->cmdbuf);
525 keep = cmd->job_list;
Eric Andersenec10b9d2000-07-14 01:13:11 +0000526 memset(cmd, 0, sizeof(struct job));
Mark Whitley44a99142001-03-14 17:26:37 +0000527 cmd->job_list = keep;
Erik Andersen3522eb12000-03-12 23:49:18 +0000528}
529
Eric Andersen1ca20a72001-03-21 07:34:27 +0000530/* remove a job from a jobset */
531static void remove_job(struct jobset *j_list, struct job *job)
Erik Andersen3522eb12000-03-12 23:49:18 +0000532{
Eric Andersen86349772000-12-18 20:25:50 +0000533 struct job *prevjob;
Erik Andersen3522eb12000-03-12 23:49:18 +0000534
Eric Andersen86349772000-12-18 20:25:50 +0000535 free_job(job);
Eric Andersen1ca20a72001-03-21 07:34:27 +0000536 if (job == j_list->head) {
537 j_list->head = job->next;
Erik Andersen161220c2000-03-16 08:12:48 +0000538 } else {
Eric Andersen1ca20a72001-03-21 07:34:27 +0000539 prevjob = j_list->head;
Eric Andersen86349772000-12-18 20:25:50 +0000540 while (prevjob->next != job)
541 prevjob = prevjob->next;
542 prevjob->next = job->next;
Erik Andersen161220c2000-03-16 08:12:48 +0000543 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000544
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000545 if (j_list->head)
546 last_jobid = j_list->head->jobid;
547 else
548 last_jobid = 0;
549
Erik Andersen161220c2000-03-16 08:12:48 +0000550 free(job);
Erik Andersen3522eb12000-03-12 23:49:18 +0000551}
552
553/* Checks to see if any background processes have exited -- if they
554 have, figure out why and see if a job has completed */
Eric Andersen1ca20a72001-03-21 07:34:27 +0000555static void checkjobs(struct jobset *j_list)
Erik Andersen3522eb12000-03-12 23:49:18 +0000556{
Erik Andersen161220c2000-03-16 08:12:48 +0000557 struct job *job;
558 pid_t childpid;
559 int status;
Eric Andersen86349772000-12-18 20:25:50 +0000560 int prognum = 0;
Erik Andersend75af992000-03-16 08:09:09 +0000561
Erik Andersen161220c2000-03-16 08:12:48 +0000562 while ((childpid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
Eric Andersen1ca20a72001-03-21 07:34:27 +0000563 for (job = j_list->head; job; job = job->next) {
Eric Andersen86349772000-12-18 20:25:50 +0000564 prognum = 0;
565 while (prognum < job->num_progs &&
566 job->progs[prognum].pid != childpid) prognum++;
567 if (prognum < job->num_progs)
Erik Andersen161220c2000-03-16 08:12:48 +0000568 break;
569 }
570
Eric Andersena1d187a2000-07-17 19:14:41 +0000571 /* This happens on backticked commands */
572 if(job==NULL)
573 return;
574
Erik Andersen161220c2000-03-16 08:12:48 +0000575 if (WIFEXITED(status) || WIFSIGNALED(status)) {
576 /* child exited */
Eric Andersen86349772000-12-18 20:25:50 +0000577 job->running_progs--;
578 job->progs[prognum].pid = 0;
Erik Andersen161220c2000-03-16 08:12:48 +0000579
Eric Andersen86349772000-12-18 20:25:50 +0000580 if (!job->running_progs) {
581 printf(JOB_STATUS_FORMAT, job->jobid, "Done", job->text);
Eric Andersen8a646dd2001-06-21 16:38:11 +0000582 last_jobid=0;
Eric Andersen1ca20a72001-03-21 07:34:27 +0000583 remove_job(j_list, job);
Erik Andersen161220c2000-03-16 08:12:48 +0000584 }
585 } else {
586 /* child stopped */
Eric Andersen86349772000-12-18 20:25:50 +0000587 job->stopped_progs++;
588 job->progs[prognum].is_stopped = 1;
Erik Andersen161220c2000-03-16 08:12:48 +0000589
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000590#if 0
591 /* Printing this stuff is a pain, since it tends to
592 * overwrite the prompt an inconveinient moments. So
593 * don't do that. */
Eric Andersen86349772000-12-18 20:25:50 +0000594 if (job->stopped_progs == job->num_progs) {
595 printf(JOB_STATUS_FORMAT, job->jobid, "Stopped",
Erik Andersen161220c2000-03-16 08:12:48 +0000596 job->text);
597 }
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000598#endif
Erik Andersen161220c2000-03-16 08:12:48 +0000599 }
Erik Andersend75af992000-03-16 08:09:09 +0000600 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000601
Erik Andersen161220c2000-03-16 08:12:48 +0000602 if (childpid == -1 && errno != ECHILD)
Matt Kraaia9819b22000-12-22 01:48:07 +0000603 perror_msg("waitpid");
Erik Andersen3522eb12000-03-12 23:49:18 +0000604}
605
Eric Andersene9f07fb2000-12-21 18:31:36 +0000606/* squirrel != NULL means we squirrel away copies of stdin, stdout,
607 * and stderr if they are redirected. */
608static int setup_redirects(struct child_prog *prog, int squirrel[])
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000609{
610 int i;
611 int openfd;
612 int mode = O_RDONLY;
Eric Andersen86349772000-12-18 20:25:50 +0000613 struct redir_struct *redir = prog->redirects;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000614
Eric Andersen86349772000-12-18 20:25:50 +0000615 for (i = 0; i < prog->num_redirects; i++, redir++) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000616 switch (redir->type) {
617 case REDIRECT_INPUT:
618 mode = O_RDONLY;
619 break;
620 case REDIRECT_OVERWRITE:
Eric Andersen46f0beb2000-11-14 21:59:22 +0000621 mode = O_WRONLY | O_CREAT | O_TRUNC;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000622 break;
623 case REDIRECT_APPEND:
Eric Andersen46f0beb2000-11-14 21:59:22 +0000624 mode = O_WRONLY | O_CREAT | O_APPEND;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000625 break;
626 }
627
628 openfd = open(redir->filename, mode, 0666);
629 if (openfd < 0) {
630 /* this could get lost if stderr has been redirected, but
631 bash and ash both lose it as well (though zsh doesn't!) */
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000632 perror_msg("error opening %s", redir->filename);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000633 return 1;
634 }
635
636 if (openfd != redir->fd) {
Eric Andersene9f07fb2000-12-21 18:31:36 +0000637 if (squirrel && redir->fd < 3) {
638 squirrel[redir->fd] = dup(redir->fd);
639 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000640 dup2(openfd, redir->fd);
641 close(openfd);
642 }
643 }
644
645 return 0;
646}
647
Eric Andersene9f07fb2000-12-21 18:31:36 +0000648static void restore_redirects(int squirrel[])
649{
650 int i, fd;
651 for (i=0; i<3; i++) {
652 fd = squirrel[i];
653 if (fd != -1) {
654 /* No error checking. I sure wouldn't know what
655 * to do with an error if I found one! */
656 dup2(fd, i);
657 close(fd);
658 }
659 }
660}
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000661
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000662static inline void cmdedit_set_initial_prompt(void)
Eric Andersen22332fd2001-01-30 23:40:39 +0000663{
Eric Andersen004015e2001-05-21 20:30:51 +0000664#ifndef BB_FEATURE_SH_FANCY_PROMPT
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000665 PS1 = NULL;
Eric Andersen22332fd2001-01-30 23:40:39 +0000666#else
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000667 PS1 = getenv("PS1");
Eric Andersene5dfced2001-04-09 22:48:12 +0000668 if(PS1==0)
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000669 PS1 = "\\w \\$ ";
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000670#endif
Eric Andersen09acc062001-01-04 11:10:38 +0000671}
672
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000673static inline void setup_prompt_string(char **prompt_str)
674{
Eric Andersen004015e2001-05-21 20:30:51 +0000675#ifndef BB_FEATURE_SH_FANCY_PROMPT
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000676 /* Set up the prompt */
677 if (shell_context == 0) {
678 if (PS1)
679 free(PS1);
680 PS1=xmalloc(strlen(cwd)+4);
681 sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ? "$ ":"# ");
682 *prompt_str = PS1;
683 } else {
684 *prompt_str = PS2;
685 }
686#else
687 *prompt_str = (shell_context==0)? PS1 : PS2;
688#endif
689}
Eric Andersen22332fd2001-01-30 23:40:39 +0000690
Eric Andersen09acc062001-01-04 11:10:38 +0000691static int get_command(FILE * source, char *command)
692{
693 char *prompt_str;
Eric Andersen8ea28be2001-01-05 20:58:22 +0000694
Eric Andersen1c314ad2000-06-28 16:56:25 +0000695 if (source == NULL) {
696 if (local_pending_command) {
697 /* a command specified (-c option): return it & mark it done */
698 strcpy(command, local_pending_command);
699 free(local_pending_command);
700 local_pending_command = NULL;
701 return 0;
702 }
703 return 1;
704 }
705
Erik Andersen161220c2000-03-16 08:12:48 +0000706 if (source == stdin) {
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000707 setup_prompt_string(&prompt_str);
Eric Andersen8ea28be2001-01-05 20:58:22 +0000708
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000709#ifdef BB_FEATURE_COMMAND_EDITING
Eric Andersen501c88b2000-07-28 15:14:45 +0000710 /*
711 ** enable command line editing only while a command line
712 ** is actually being read; otherwise, we'll end up bequeathing
713 ** atexit() handlers and other unwanted stuff to our
714 ** child processes (rob@sysgo.de)
715 */
Eric Andersen86349772000-12-18 20:25:50 +0000716 cmdedit_read_input(prompt_str, command);
Erik Andersen161220c2000-03-16 08:12:48 +0000717 return 0;
Erik Andersenc7c634b2000-03-19 05:28:55 +0000718#else
Eric Andersen8ea28be2001-01-05 20:58:22 +0000719 fputs(prompt_str, stdout);
Erik Andersend75af992000-03-16 08:09:09 +0000720#endif
Erik Andersen161220c2000-03-16 08:12:48 +0000721 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000722
Erik Andersen161220c2000-03-16 08:12:48 +0000723 if (!fgets(command, BUFSIZ - 2, source)) {
724 if (source == stdin)
725 printf("\n");
726 return 1;
727 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000728
Erik Andersen161220c2000-03-16 08:12:48 +0000729 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000730}
731
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000732static char* itoa(register int i)
733{
734 static char a[7]; /* Max 7 ints */
735 register char *b = a + sizeof(a) - 1;
736 int sign = (i < 0);
737
738 if (sign)
739 i = -i;
740 *b = 0;
741 do
742 {
743 *--b = '0' + (i % 10);
744 i /= 10;
745 }
746 while (i);
747 if (sign)
748 *--b = '-';
749 return b;
750}
751
752char * strsep_space( char *string, int * ix)
753{
754 char *token, *begin;
755
756 begin = string;
757
758 /* Short circuit the trivial case */
759 if ( !string || ! string[*ix])
760 return NULL;
761
762 /* Find the end of the token. */
763 while( string && string[*ix] && !isspace(string[*ix]) ) {
764 (*ix)++;
765 }
766
767 /* Find the end of any whitespace trailing behind
768 * the token and let that be part of the token */
769 while( string && string[*ix] && isspace(string[*ix]) ) {
770 (*ix)++;
771 }
772
773 if (! string && *ix==0) {
774 /* Nothing useful was found */
775 return NULL;
776 }
777
778 token = xmalloc(*ix+1);
779 token[*ix] = '\0';
780 strncpy(token, string, *ix);
781
782 return token;
783}
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000784
Eric Andersenca604592001-03-08 17:17:13 +0000785static int expand_arguments(char *command)
786{
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000787 int total_length=0, length, i, retval, ix = 0;
788 expand_t expand_result;
789 char *tmpcmd, *cmd, *cmd_copy;
790 char *src, *dst, *var;
791 const char *out_of_space = "out of space during expansion";
792 int flags = GLOB_NOCHECK
793#ifdef GLOB_BRACE
794 | GLOB_BRACE
795#endif
796#ifdef GLOB_TILDE
797 | GLOB_TILDE
798#endif
799 ;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000800
Eric Andersenca604592001-03-08 17:17:13 +0000801 /* get rid of the terminating \n */
802 chomp(command);
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000803
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000804 /* Fix up escape sequences to be the Real Thing(tm) */
Eric Andersen1ca20a72001-03-21 07:34:27 +0000805 while( command && command[ix]) {
806 if (command[ix] == '\\') {
Eric Andersene5dfced2001-04-09 22:48:12 +0000807 const char *tmp = command+ix+1;
Eric Andersen1ca20a72001-03-21 07:34:27 +0000808 command[ix] = process_escape_sequence( &tmp );
809 memmove(command+ix + 1, tmp, strlen(tmp)+1);
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000810 }
Eric Andersen1ca20a72001-03-21 07:34:27 +0000811 ix++;
Eric Andersenb3d6e2d2001-03-13 22:57:56 +0000812 }
Eric Andersen4b6b5e42001-06-27 04:30:11 +0000813 /* Use glob and then fixup environment variables and such */
814
815 /* It turns out that glob is very stupid. We have to feed it one word at a
816 * time since it can't cope with a full string. Here we convert command
817 * (char*) into cmd (char**, one word per string) */
818
819 /* We need a clean copy, so strsep can mess up the copy while
820 * we write stuff into the original (in a minute) */
821 cmd = cmd_copy = strdup(command);
822 *command = '\0';
823 for (ix = 0, tmpcmd = cmd;
824 (tmpcmd = strsep_space(cmd, &ix)) != NULL; cmd += ix, ix=0) {
825 if (*tmpcmd == '\0')
826 break;
827 /* we need to trim() the result for glob! */
828 trim(tmpcmd);
829 retval = glob(tmpcmd, flags, NULL, &expand_result);
830 free(tmpcmd); /* Free mem allocated by strsep_space */
831 if (retval == GLOB_NOSPACE) {
832 /* Mem may have been allocated... */
833 globfree (&expand_result);
834 error_msg(out_of_space);
835 return FALSE;
836 } else if (retval != 0) {
837 /* Some other error. GLOB_NOMATCH shouldn't
838 * happen because of the GLOB_NOCHECK flag in
839 * the glob call. */
840 error_msg("syntax error");
841 return FALSE;
842 } else {
843 /* Convert from char** (one word per string) to a simple char*,
844 * but don't overflow command which is BUFSIZ in length */
845 for (i=0; i < expand_result.gl_pathc; i++) {
846 length=strlen(expand_result.gl_pathv[i]);
847 if (total_length+length+1 >= BUFSIZ) {
848 error_msg(out_of_space);
849 return FALSE;
850 }
851 strcat(command+total_length, " ");
852 total_length+=1;
853 strcat(command+total_length, expand_result.gl_pathv[i]);
854 total_length+=length;
855 }
856 globfree (&expand_result);
857 }
858 }
859 free(cmd_copy);
860 trim(command);
861
862 /* Now do the shell variable substitutions which
863 * wordexp can't do for us, namely $? and $! */
864 src = command;
865 while((dst = strchr(src,'$')) != NULL){
866 var = NULL;
867 switch(*(dst+1)) {
868 case '?':
869 var = itoa(last_return_code);
870 break;
871 case '!':
872 if (last_bg_pid==-1)
873 *(var)='\0';
874 else
875 var = itoa(last_bg_pid);
876 break;
877 /* Everything else like $$, $#, $[0-9], etc. should all be
878 * expanded by wordexp(), so we can in theory skip that stuff
879 * here, but just to be on the safe side (i.e., since uClibc
880 * wordexp doesn't do this stuff yet), lets leave it in for
881 * now. */
882 case '$':
883 var = itoa(getpid());
884 break;
885 case '#':
886 var = itoa(argc-1);
887 break;
888 case '0':case '1':case '2':case '3':case '4':
889 case '5':case '6':case '7':case '8':case '9':
890 {
891 int ixx=*(dst + 1)-48;
892 if (ixx >= argc) {
893 var='\0';
894 } else {
895 var = argv[ixx];
896 }
897 }
898 break;
899
900 }
901 if (var) {
902 /* a single character construction was found, and
903 * already handled in the case statement */
904 src=dst+2;
905 } else {
906 /* Looks like an environment variable */
907 char delim_hold;
908 int num_skip_chars=0;
909 int dstlen = strlen(dst);
910 /* Is this a ${foo} type variable? */
911 if (dstlen >=2 && *(dst+1) == '{') {
912 src=strchr(dst+1, '}');
913 num_skip_chars=1;
914 } else {
915 src=dst+1;
916 while(isalnum(*src) || *src=='_') src++;
917 }
918 if (src == NULL) {
919 src = dst+dstlen;
920 }
921 delim_hold=*src;
922 *src='\0'; /* temporary */
923 var = getenv(dst + 1 + num_skip_chars);
924 *src=delim_hold;
925 src += num_skip_chars;
926 }
927 if (var == NULL) {
928 /* Seems we got an un-expandable variable. So delete it. */
929 var = "";
930 }
931 {
932 int subst_len = strlen(var);
933 int trail_len = strlen(src);
934 if (dst+subst_len+trail_len >= command+BUFSIZ) {
935 error_msg(out_of_space);
936 return FALSE;
937 }
938 /* Move stuff to the end of the string to accommodate
939 * filling the created gap with the new stuff */
940 memmove(dst+subst_len, src, trail_len+1);
941 /* Now copy in the new stuff */
942 memcpy(dst, var, subst_len);
943 src = dst+subst_len;
944 }
945 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000946
Eric Andersenca604592001-03-08 17:17:13 +0000947 return TRUE;
Erik Andersen3522eb12000-03-12 23:49:18 +0000948}
949
Eric Andersen86349772000-12-18 20:25:50 +0000950/* Return cmd->num_progs as 0 if no command is present (e.g. an empty
951 line). If a valid command is found, command_ptr is set to point to
Erik Andersen3522eb12000-03-12 23:49:18 +0000952 the beginning of the next command (if the original command had more
953 then one job associated with it) or NULL if no more commands are
954 present. */
Eric Andersen86349772000-12-18 20:25:50 +0000955static int parse_command(char **command_ptr, struct job *job, int *inbg)
Erik Andersen3522eb12000-03-12 23:49:18 +0000956{
Erik Andersen161220c2000-03-16 08:12:48 +0000957 char *command;
Eric Andersen86349772000-12-18 20:25:50 +0000958 char *return_command = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +0000959 char *src, *buf, *chptr;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000960 int argc_l = 0;
Erik Andersen161220c2000-03-16 08:12:48 +0000961 int done = 0;
Eric Andersen86349772000-12-18 20:25:50 +0000962 int argv_alloced;
Matt Kraaibe66ad32001-04-12 15:42:17 +0000963 int i, saw_quote = 0;
Erik Andersen161220c2000-03-16 08:12:48 +0000964 char quote = '\0';
965 int count;
Eric Andersen86349772000-12-18 20:25:50 +0000966 struct child_prog *prog;
Erik Andersen3522eb12000-03-12 23:49:18 +0000967
Erik Andersen161220c2000-03-16 08:12:48 +0000968 /* skip leading white space */
Eric Andersen86349772000-12-18 20:25:50 +0000969 while (**command_ptr && isspace(**command_ptr))
970 (*command_ptr)++;
Erik Andersen3522eb12000-03-12 23:49:18 +0000971
Erik Andersen161220c2000-03-16 08:12:48 +0000972 /* this handles empty lines or leading '#' characters */
Eric Andersen86349772000-12-18 20:25:50 +0000973 if (!**command_ptr || (**command_ptr == '#')) {
974 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +0000975 return 0;
976 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000977
Eric Andersen86349772000-12-18 20:25:50 +0000978 *inbg = 0;
979 job->num_progs = 1;
Eric Andersenec10b9d2000-07-14 01:13:11 +0000980 job->progs = xmalloc(sizeof(*job->progs));
Erik Andersen3522eb12000-03-12 23:49:18 +0000981
Erik Andersen161220c2000-03-16 08:12:48 +0000982 /* We set the argv elements to point inside of this string. The
Eric Andersen86349772000-12-18 20:25:50 +0000983 memory is freed by free_job(). Allocate twice the original
Eric Andersenb54833c2000-07-03 23:56:26 +0000984 length in case we need to quote every single character.
Erik Andersen3522eb12000-03-12 23:49:18 +0000985
Erik Andersen161220c2000-03-16 08:12:48 +0000986 Getting clean memory relieves us of the task of NULL
987 terminating things and makes the rest of this look a bit
988 cleaner (though it is, admittedly, a tad less efficient) */
Eric Andersen86349772000-12-18 20:25:50 +0000989 job->cmdbuf = command = xcalloc(2*strlen(*command_ptr) + 1, sizeof(char));
Erik Andersen161220c2000-03-16 08:12:48 +0000990 job->text = NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +0000991
Erik Andersen161220c2000-03-16 08:12:48 +0000992 prog = job->progs;
Eric Andersen86349772000-12-18 20:25:50 +0000993 prog->num_redirects = 0;
994 prog->redirects = NULL;
Eric Andersen86349772000-12-18 20:25:50 +0000995 prog->is_stopped = 0;
996 prog->family = job;
Erik Andersen3522eb12000-03-12 23:49:18 +0000997
Eric Andersen86349772000-12-18 20:25:50 +0000998 argv_alloced = 5;
999 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
1000 prog->argv[0] = job->cmdbuf;
Erik Andersen3522eb12000-03-12 23:49:18 +00001001
Erik Andersen161220c2000-03-16 08:12:48 +00001002 buf = command;
Eric Andersen86349772000-12-18 20:25:50 +00001003 src = *command_ptr;
Erik Andersen161220c2000-03-16 08:12:48 +00001004 while (*src && !done) {
1005 if (quote == *src) {
1006 quote = '\0';
1007 } else if (quote) {
1008 if (*src == '\\') {
1009 src++;
1010 if (!*src) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001011 error_msg("character expected after \\");
Eric Andersen86349772000-12-18 20:25:50 +00001012 free_job(job);
Erik Andersen161220c2000-03-16 08:12:48 +00001013 return 1;
1014 }
1015
1016 /* in shell, "\'" should yield \' */
Eric Andersenb2356f62000-12-11 19:14:40 +00001017 if (*src != quote) {
Erik Andersen161220c2000-03-16 08:12:48 +00001018 *buf++ = '\\';
Eric Andersenb2356f62000-12-11 19:14:40 +00001019 *buf++ = '\\';
1020 }
Erik Andersen161220c2000-03-16 08:12:48 +00001021 } else if (*src == '*' || *src == '?' || *src == '[' ||
1022 *src == ']') *buf++ = '\\';
1023 *buf++ = *src;
1024 } else if (isspace(*src)) {
Matt Kraaibe66ad32001-04-12 15:42:17 +00001025 if (*prog->argv[argc_l] || saw_quote) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001026 buf++, argc_l++;
Erik Andersen161220c2000-03-16 08:12:48 +00001027 /* +1 here leaves room for the NULL which ends argv */
Eric Andersen86349772000-12-18 20:25:50 +00001028 if ((argc_l + 1) == argv_alloced) {
1029 argv_alloced += 5;
Matt Kraaib8907522000-09-13 02:08:21 +00001030 prog->argv = xrealloc(prog->argv,
1031 sizeof(*prog->argv) *
Eric Andersen86349772000-12-18 20:25:50 +00001032 argv_alloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001033 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001034 prog->argv[argc_l] = buf;
Matt Kraaibe66ad32001-04-12 15:42:17 +00001035 saw_quote = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001036 }
1037 } else
1038 switch (*src) {
1039 case '"':
1040 case '\'':
1041 quote = *src;
Matt Kraaibe66ad32001-04-12 15:42:17 +00001042 saw_quote = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001043 break;
1044
1045 case '#': /* comment */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001046 if (*(src-1)== '$')
1047 *buf++ = *src;
1048 else
1049 done = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001050 break;
1051
Eric Andersen86349772000-12-18 20:25:50 +00001052 case '>': /* redirects */
Erik Andersen161220c2000-03-16 08:12:48 +00001053 case '<':
Eric Andersen86349772000-12-18 20:25:50 +00001054 i = prog->num_redirects++;
1055 prog->redirects = xrealloc(prog->redirects,
1056 sizeof(*prog->redirects) *
Matt Kraaib8907522000-09-13 02:08:21 +00001057 (i + 1));
Erik Andersen161220c2000-03-16 08:12:48 +00001058
Eric Andersen86349772000-12-18 20:25:50 +00001059 prog->redirects[i].fd = -1;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001060 if (buf != prog->argv[argc_l]) {
Erik Andersen161220c2000-03-16 08:12:48 +00001061 /* the stuff before this character may be the file number
1062 being redirected */
Eric Andersen86349772000-12-18 20:25:50 +00001063 prog->redirects[i].fd =
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001064 strtol(prog->argv[argc_l], &chptr, 10);
Erik Andersen161220c2000-03-16 08:12:48 +00001065
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001066 if (*chptr && *prog->argv[argc_l]) {
1067 buf++, argc_l++;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001068 prog->argv[argc_l] = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001069 }
1070 }
1071
Eric Andersen86349772000-12-18 20:25:50 +00001072 if (prog->redirects[i].fd == -1) {
Erik Andersen161220c2000-03-16 08:12:48 +00001073 if (*src == '>')
Eric Andersen86349772000-12-18 20:25:50 +00001074 prog->redirects[i].fd = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001075 else
Eric Andersen86349772000-12-18 20:25:50 +00001076 prog->redirects[i].fd = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001077 }
1078
1079 if (*src++ == '>') {
1080 if (*src == '>')
Eric Andersen86349772000-12-18 20:25:50 +00001081 prog->redirects[i].type =
Erik Andersen161220c2000-03-16 08:12:48 +00001082 REDIRECT_APPEND, src++;
1083 else
Eric Andersen86349772000-12-18 20:25:50 +00001084 prog->redirects[i].type = REDIRECT_OVERWRITE;
Erik Andersen161220c2000-03-16 08:12:48 +00001085 } else {
Eric Andersen86349772000-12-18 20:25:50 +00001086 prog->redirects[i].type = REDIRECT_INPUT;
Erik Andersen161220c2000-03-16 08:12:48 +00001087 }
1088
1089 /* This isn't POSIX sh compliant. Oh well. */
1090 chptr = src;
1091 while (isspace(*chptr))
1092 chptr++;
1093
1094 if (!*chptr) {
Mark Whitley44a99142001-03-14 17:26:37 +00001095 error_msg("file name expected after %c", *(src-1));
Eric Andersen86349772000-12-18 20:25:50 +00001096 free_job(job);
1097 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001098 return 1;
1099 }
1100
Eric Andersen86349772000-12-18 20:25:50 +00001101 prog->redirects[i].filename = buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001102 while (*chptr && !isspace(*chptr))
1103 *buf++ = *chptr++;
1104
1105 src = chptr - 1; /* we src++ later */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001106 prog->argv[argc_l] = ++buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001107 break;
1108
1109 case '|': /* pipe */
1110 /* finish this command */
Matt Kraaibe66ad32001-04-12 15:42:17 +00001111 if (*prog->argv[argc_l] || saw_quote)
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001112 argc_l++;
1113 if (!argc_l) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001114 error_msg("empty command in pipe");
Eric Andersen86349772000-12-18 20:25:50 +00001115 free_job(job);
1116 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001117 return 1;
1118 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001119 prog->argv[argc_l] = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001120
1121 /* and start the next */
Eric Andersen86349772000-12-18 20:25:50 +00001122 job->num_progs++;
Matt Kraaib8907522000-09-13 02:08:21 +00001123 job->progs = xrealloc(job->progs,
Eric Andersen86349772000-12-18 20:25:50 +00001124 sizeof(*job->progs) * job->num_progs);
1125 prog = job->progs + (job->num_progs - 1);
1126 prog->num_redirects = 0;
1127 prog->redirects = NULL;
Eric Andersen86349772000-12-18 20:25:50 +00001128 prog->is_stopped = 0;
1129 prog->family = job;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001130 argc_l = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001131
Eric Andersen86349772000-12-18 20:25:50 +00001132 argv_alloced = 5;
1133 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001134 prog->argv[0] = ++buf;
1135
1136 src++;
1137 while (*src && isspace(*src))
1138 src++;
1139
1140 if (!*src) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001141 error_msg("empty command in pipe");
Eric Andersen86349772000-12-18 20:25:50 +00001142 free_job(job);
1143 job->num_progs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001144 return 1;
1145 }
1146 src--; /* we'll ++ it at the end of the loop */
1147
1148 break;
1149
1150 case '&': /* background */
Eric Andersen86349772000-12-18 20:25:50 +00001151 *inbg = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001152 case ';': /* multiple commands */
1153 done = 1;
Eric Andersen86349772000-12-18 20:25:50 +00001154 return_command = *command_ptr + (src - *command_ptr) + 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001155 break;
1156
Matt Kraai131241f2000-09-14 00:43:20 +00001157 case '\\':
1158 src++;
1159 if (!*src) {
Matt Kraaidd19c692001-01-31 19:00:21 +00001160 error_msg("character expected after \\");
Eric Andersen86349772000-12-18 20:25:50 +00001161 free_job(job);
Matt Kraai131241f2000-09-14 00:43:20 +00001162 return 1;
1163 }
1164 if (*src == '*' || *src == '[' || *src == ']'
1165 || *src == '?') *buf++ = '\\';
1166 /* fallthrough */
Erik Andersen161220c2000-03-16 08:12:48 +00001167 default:
1168 *buf++ = *src;
1169 }
1170
Erik Andersend75af992000-03-16 08:09:09 +00001171 src++;
Erik Andersen161220c2000-03-16 08:12:48 +00001172 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001173
Matt Kraaibe66ad32001-04-12 15:42:17 +00001174 if (*prog->argv[argc_l] || saw_quote) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001175 argc_l++;
Erik Andersen161220c2000-03-16 08:12:48 +00001176 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001177 if (!argc_l) {
Eric Andersen86349772000-12-18 20:25:50 +00001178 free_job(job);
Erik Andersen161220c2000-03-16 08:12:48 +00001179 return 0;
1180 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001181 prog->argv[argc_l] = NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +00001182
Eric Andersen86349772000-12-18 20:25:50 +00001183 if (!return_command) {
1184 job->text = xmalloc(strlen(*command_ptr) + 1);
1185 strcpy(job->text, *command_ptr);
Erik Andersen161220c2000-03-16 08:12:48 +00001186 } else {
1187 /* This leaves any trailing spaces, which is a bit sloppy */
Eric Andersen86349772000-12-18 20:25:50 +00001188 count = return_command - *command_ptr;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001189 job->text = xmalloc(count + 1);
Eric Andersen86349772000-12-18 20:25:50 +00001190 strncpy(job->text, *command_ptr, count);
Erik Andersen161220c2000-03-16 08:12:48 +00001191 job->text[count] = '\0';
1192 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001193
Eric Andersen86349772000-12-18 20:25:50 +00001194 *command_ptr = return_command;
Eric Andersen46f0beb2000-11-14 21:59:22 +00001195
Erik Andersend75af992000-03-16 08:09:09 +00001196 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001197}
1198
Eric Andersen86349772000-12-18 20:25:50 +00001199/* Run the child_prog, no matter what kind of command it uses.
1200 */
1201static int pseudo_exec(struct child_prog *child)
Erik Andersen3522eb12000-03-12 23:49:18 +00001202{
Eric Andersen86349772000-12-18 20:25:50 +00001203 struct built_in_command *x;
Eric Andersenb54833c2000-07-03 23:56:26 +00001204#ifdef BB_FEATURE_SH_STANDALONE_SHELL
Eric Andersenaf4ac772001-02-01 22:43:49 +00001205 char *name;
Erik Andersenbcd61772000-05-13 06:33:19 +00001206#endif
Erik Andersen3522eb12000-03-12 23:49:18 +00001207
Eric Andersene9f07fb2000-12-21 18:31:36 +00001208 /* Check if the command matches any of the non-forking builtins.
1209 * Depending on context, this might be redundant. But it's
1210 * easier to waste a few CPU cycles than it is to figure out
1211 * if this is one of those cases.
Eric Andersen86349772000-12-18 20:25:50 +00001212 */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001213 for (x = bltins; x->cmd; x++) {
1214 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1215 exit(x->function(child));
1216 }
1217 }
1218
1219 /* Check if the command matches any of the forking builtins. */
Eric Andersen86349772000-12-18 20:25:50 +00001220 for (x = bltins_forking; x->cmd; x++) {
1221 if (strcmp(child->argv[0], x->cmd) == 0) {
1222 applet_name=x->cmd;
1223 exit (x->function(child));
1224 }
1225 }
1226#ifdef BB_FEATURE_SH_STANDALONE_SHELL
1227 /* Check if the command matches any busybox internal
1228 * commands ("applets") here. Following discussions from
1229 * November 2000 on busybox@opensource.lineo.com, don't use
1230 * get_last_path_component(). This way explicit (with
1231 * slashes) filenames will never be interpreted as an
1232 * applet, just like with builtins. This way the user can
1233 * override an applet with an explicit filename reference.
1234 * The only downside to this change is that an explicit
1235 * /bin/foo invocation will fork and exec /bin/foo, even if
1236 * /bin/foo is a symlink to busybox.
1237 */
Matt Kraaif2cc2762001-02-01 19:21:20 +00001238 name = child->argv[0];
Eric Andersen86349772000-12-18 20:25:50 +00001239
1240#ifdef BB_FEATURE_SH_APPLETS_ALWAYS_WIN
1241 /* If you enable BB_FEATURE_SH_APPLETS_ALWAYS_WIN, then
1242 * if you run /bin/cat, it will use BusyBox cat even if
1243 * /bin/cat exists on the filesystem and is _not_ busybox.
1244 * Some systems want this, others do not. Choose wisely. :-)
1245 */
Matt Kraaif2cc2762001-02-01 19:21:20 +00001246 name = get_last_path_component(name);
Eric Andersen86349772000-12-18 20:25:50 +00001247#endif
1248
Eric Andersen67991cf2001-02-14 21:23:06 +00001249 {
Eric Andersen82ab8da2001-03-23 17:06:01 +00001250 char** argv_l=child->argv;
Eric Andersen67991cf2001-02-14 21:23:06 +00001251 int argc_l;
Eric Andersen82ab8da2001-03-23 17:06:01 +00001252 for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++);
Eric Andersen67991cf2001-02-14 21:23:06 +00001253 optind = 1;
1254 run_applet_by_name(name, argc_l, child->argv);
Eric Andersen86349772000-12-18 20:25:50 +00001255 }
1256#endif
1257
1258 execvp(child->argv[0], child->argv);
Eric Andersen8ea28be2001-01-05 20:58:22 +00001259 perror_msg_and_die("%s", child->argv[0]);
Eric Andersen86349772000-12-18 20:25:50 +00001260}
1261
1262static void insert_job(struct job *newjob, int inbg)
1263{
1264 struct job *thejob;
Eric Andersen1ca20a72001-03-21 07:34:27 +00001265 struct jobset *j_list=newjob->job_list;
Eric Andersen86349772000-12-18 20:25:50 +00001266
1267 /* find the ID for thejob to use */
1268 newjob->jobid = 1;
Eric Andersen1ca20a72001-03-21 07:34:27 +00001269 for (thejob = j_list->head; thejob; thejob = thejob->next)
Eric Andersen86349772000-12-18 20:25:50 +00001270 if (thejob->jobid >= newjob->jobid)
1271 newjob->jobid = thejob->jobid + 1;
1272
1273 /* add thejob to the list of running jobs */
Eric Andersen1ca20a72001-03-21 07:34:27 +00001274 if (!j_list->head) {
1275 thejob = j_list->head = xmalloc(sizeof(*thejob));
Eric Andersen86349772000-12-18 20:25:50 +00001276 } else {
Eric Andersen1ca20a72001-03-21 07:34:27 +00001277 for (thejob = j_list->head; thejob->next; thejob = thejob->next) /* nothing */;
Eric Andersen86349772000-12-18 20:25:50 +00001278 thejob->next = xmalloc(sizeof(*thejob));
1279 thejob = thejob->next;
1280 }
1281
1282 *thejob = *newjob; /* physically copy the struct job */
1283 thejob->next = NULL;
1284 thejob->running_progs = thejob->num_progs;
1285 thejob->stopped_progs = 0;
1286
1287 if (inbg) {
1288 /* we don't wait for background thejobs to return -- append it
1289 to the list of backgrounded thejobs and leave it alone */
1290 printf("[%d] %d\n", thejob->jobid,
1291 newjob->progs[newjob->num_progs - 1].pid);
Eric Andersen8a646dd2001-06-21 16:38:11 +00001292 last_jobid = newjob->jobid;
Eric Andersen4b6b5e42001-06-27 04:30:11 +00001293 last_bg_pid=newjob->progs[newjob->num_progs - 1].pid;
Eric Andersen86349772000-12-18 20:25:50 +00001294 } else {
1295 newjob->job_list->fg = thejob;
1296
1297 /* move the new process group into the foreground */
1298 /* suppress messages when run from /linuxrc mag@sysgo.de */
Eric Andersen2d848a42001-06-25 17:11:54 +00001299 if (tcsetpgrp(shell_terminal, newjob->pgrp) && errno != ENOTTY)
Matt Kraaia9819b22000-12-22 01:48:07 +00001300 perror_msg("tcsetpgrp");
Eric Andersen86349772000-12-18 20:25:50 +00001301 }
1302}
1303
1304static int run_command(struct job *newjob, int inbg, int outpipe[2])
1305{
1306 /* struct job *thejob; */
1307 int i;
1308 int nextin, nextout;
1309 int pipefds[2]; /* pipefd[0] is for reading */
1310 struct built_in_command *x;
1311 struct child_prog *child;
1312
Eric Andersen6efc48c2000-07-18 08:16:39 +00001313 nextin = 0, nextout = 1;
Eric Andersen86349772000-12-18 20:25:50 +00001314 for (i = 0; i < newjob->num_progs; i++) {
1315 child = & (newjob->progs[i]);
1316
1317 if ((i + 1) < newjob->num_progs) {
1318 if (pipe(pipefds)<0) perror_msg_and_die("pipe");
Erik Andersen161220c2000-03-16 08:12:48 +00001319 nextout = pipefds[1];
1320 } else {
Eric Andersen86349772000-12-18 20:25:50 +00001321 if (outpipe[1]!=-1) {
1322 nextout = outpipe[1];
Eric Andersen6efc48c2000-07-18 08:16:39 +00001323 } else {
1324 nextout = 1;
1325 }
Erik Andersen161220c2000-03-16 08:12:48 +00001326 }
1327
Eric Andersen501c88b2000-07-28 15:14:45 +00001328
Eric Andersene9f07fb2000-12-21 18:31:36 +00001329 /* Check if the command matches any non-forking builtins,
1330 * but only if this is a simple command.
1331 * Non-forking builtins within pipes have to fork anyway,
1332 * and are handled in pseudo_exec. "echo foo | read bar"
1333 * is doomed to failure, and doesn't work on bash, either.
Eric Andersen86349772000-12-18 20:25:50 +00001334 */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001335 if (newjob->num_progs == 1) {
1336 for (x = bltins; x->cmd; x++) {
1337 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1338 int squirrel[] = {-1, -1, -1};
1339 int rcode;
1340 setup_redirects(child, squirrel);
1341 rcode = x->function(child);
1342 restore_redirects(squirrel);
1343 return rcode;
1344 }
Erik Andersen330fd2b2000-05-19 05:35:19 +00001345 }
1346 }
1347
Eric Andersen86349772000-12-18 20:25:50 +00001348 if (!(child->pid = fork())) {
Eric Andersen2d848a42001-06-25 17:11:54 +00001349 /* Set the handling for job control signals back to the default. */
1350 signal(SIGINT, SIG_DFL);
1351 signal(SIGQUIT, SIG_DFL);
1352 signal(SIGTSTP, SIG_DFL);
1353 signal(SIGTTIN, SIG_DFL);
Erik Andersen161220c2000-03-16 08:12:48 +00001354 signal(SIGTTOU, SIG_DFL);
Eric Andersen2d848a42001-06-25 17:11:54 +00001355 signal(SIGCHLD, SIG_DFL);
Erik Andersen161220c2000-03-16 08:12:48 +00001356
Eric Andersen8ea28be2001-01-05 20:58:22 +00001357 close_all();
1358
Eric Andersen86349772000-12-18 20:25:50 +00001359 if (outpipe[1]!=-1) {
1360 close(outpipe[0]);
Eric Andersen6efc48c2000-07-18 08:16:39 +00001361 }
1362 if (nextin != 0) {
1363 dup2(nextin, 0);
1364 close(nextin);
1365 }
1366
1367 if (nextout != 1) {
Erik Andersen161220c2000-03-16 08:12:48 +00001368 dup2(nextout, 1);
Eric Andersen86349772000-12-18 20:25:50 +00001369 dup2(nextout, 2); /* Really? */
Erik Andersen161220c2000-03-16 08:12:48 +00001370 close(nextout);
Eric Andersen501c88b2000-07-28 15:14:45 +00001371 close(pipefds[0]);
Erik Andersen161220c2000-03-16 08:12:48 +00001372 }
1373
Eric Andersen86349772000-12-18 20:25:50 +00001374 /* explicit redirects override pipes */
Eric Andersene9f07fb2000-12-21 18:31:36 +00001375 setup_redirects(child,NULL);
Erik Andersen161220c2000-03-16 08:12:48 +00001376
Eric Andersen86349772000-12-18 20:25:50 +00001377 pseudo_exec(child);
Erik Andersen161220c2000-03-16 08:12:48 +00001378 }
Eric Andersen86349772000-12-18 20:25:50 +00001379 if (outpipe[1]!=-1) {
1380 close(outpipe[1]);
Eric Andersena1d187a2000-07-17 19:14:41 +00001381 }
Erik Andersen161220c2000-03-16 08:12:48 +00001382
1383 /* put our child in the process group whose leader is the
1384 first process in this pipe */
Eric Andersen86349772000-12-18 20:25:50 +00001385 setpgid(child->pid, newjob->progs[0].pid);
Erik Andersen161220c2000-03-16 08:12:48 +00001386 if (nextin != 0)
1387 close(nextin);
Eric Andersen6efc48c2000-07-18 08:16:39 +00001388 if (nextout != 1)
Erik Andersen161220c2000-03-16 08:12:48 +00001389 close(nextout);
1390
1391 /* If there isn't another process, nextin is garbage
1392 but it doesn't matter */
1393 nextin = pipefds[0];
1394 }
1395
Eric Andersen86349772000-12-18 20:25:50 +00001396 newjob->pgrp = newjob->progs[0].pid;
Erik Andersen161220c2000-03-16 08:12:48 +00001397
Eric Andersen86349772000-12-18 20:25:50 +00001398 insert_job(newjob, inbg);
Erik Andersen3522eb12000-03-12 23:49:18 +00001399
Erik Andersen161220c2000-03-16 08:12:48 +00001400 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001401}
1402
Erik Andersend75af992000-03-16 08:09:09 +00001403static int busy_loop(FILE * input)
Erik Andersen3522eb12000-03-12 23:49:18 +00001404{
Erik Andersen161220c2000-03-16 08:12:48 +00001405 char *command;
Eric Andersen86349772000-12-18 20:25:50 +00001406 char *next_command = NULL;
1407 struct job newjob;
Eric Andersen1c314ad2000-06-28 16:56:25 +00001408 pid_t parent_pgrp;
Erik Andersen161220c2000-03-16 08:12:48 +00001409 int i;
Eric Andersen86349772000-12-18 20:25:50 +00001410 int inbg;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001411 int status;
Eric Andersen86349772000-12-18 20:25:50 +00001412 newjob.job_list = &job_list;
1413 newjob.job_context = DEFAULT_CONTEXT;
Erik Andersen3522eb12000-03-12 23:49:18 +00001414
Eric Andersen1c314ad2000-06-28 16:56:25 +00001415 /* save current owner of TTY so we can restore it on exit */
Eric Andersen2d848a42001-06-25 17:11:54 +00001416 parent_pgrp = tcgetpgrp(shell_terminal);
Eric Andersen1c314ad2000-06-28 16:56:25 +00001417
Matt Kraaib8907522000-09-13 02:08:21 +00001418 command = (char *) xcalloc(BUFSIZ, sizeof(char));
Erik Andersend75af992000-03-16 08:09:09 +00001419
Erik Andersen161220c2000-03-16 08:12:48 +00001420 while (1) {
Eric Andersen86349772000-12-18 20:25:50 +00001421 if (!job_list.fg) {
Erik Andersend75af992000-03-16 08:09:09 +00001422 /* no job is in the foreground */
Erik Andersen3522eb12000-03-12 23:49:18 +00001423
Erik Andersend75af992000-03-16 08:09:09 +00001424 /* see if any background processes have exited */
Eric Andersen86349772000-12-18 20:25:50 +00001425 checkjobs(&job_list);
Erik Andersen3522eb12000-03-12 23:49:18 +00001426
Eric Andersen86349772000-12-18 20:25:50 +00001427 if (!next_command) {
1428 if (get_command(input, command))
Erik Andersen161220c2000-03-16 08:12:48 +00001429 break;
Eric Andersen86349772000-12-18 20:25:50 +00001430 next_command = command;
Erik Andersend75af992000-03-16 08:09:09 +00001431 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001432
Eric Andersenca604592001-03-08 17:17:13 +00001433 if (expand_arguments(next_command) == FALSE) {
1434 free(command);
1435 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1436 next_command = NULL;
1437 continue;
1438 }
1439
Eric Andersen86349772000-12-18 20:25:50 +00001440 if (!parse_command(&next_command, &newjob, &inbg) &&
1441 newjob.num_progs) {
Eric Andersena1d187a2000-07-17 19:14:41 +00001442 int pipefds[2] = {-1,-1};
Eric Andersenb3d6e2d2001-03-13 22:57:56 +00001443 debug_printf( "job=%p fed to run_command by busy_loop()'\n",
1444 &newjob);
Eric Andersen86349772000-12-18 20:25:50 +00001445 run_command(&newjob, inbg, pipefds);
Eric Andersenfad9c112000-07-25 18:06:52 +00001446 }
1447 else {
Eric Andersena1d187a2000-07-17 19:14:41 +00001448 free(command);
Matt Kraaib8907522000-09-13 02:08:21 +00001449 command = (char *) xcalloc(BUFSIZ, sizeof(char));
Eric Andersen86349772000-12-18 20:25:50 +00001450 next_command = NULL;
Erik Andersend75af992000-03-16 08:09:09 +00001451 }
1452 } else {
1453 /* a job is running in the foreground; wait for it */
1454 i = 0;
Eric Andersen86349772000-12-18 20:25:50 +00001455 while (!job_list.fg->progs[i].pid ||
1456 job_list.fg->progs[i].is_stopped == 1) i++;
Erik Andersen3522eb12000-03-12 23:49:18 +00001457
Eric Andersen8ea28be2001-01-05 20:58:22 +00001458 if (waitpid(job_list.fg->progs[i].pid, &status, WUNTRACED)<0)
1459 perror_msg_and_die("waitpid(%d)",job_list.fg->progs[i].pid);
Erik Andersen3522eb12000-03-12 23:49:18 +00001460
Erik Andersend75af992000-03-16 08:09:09 +00001461 if (WIFEXITED(status) || WIFSIGNALED(status)) {
Erik Andersen161220c2000-03-16 08:12:48 +00001462 /* the child exited */
Eric Andersen86349772000-12-18 20:25:50 +00001463 job_list.fg->running_progs--;
1464 job_list.fg->progs[i].pid = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001465
Eric Andersen4b6b5e42001-06-27 04:30:11 +00001466 last_return_code=WEXITSTATUS(status);
1467
Eric Andersen86349772000-12-18 20:25:50 +00001468 if (!job_list.fg->running_progs) {
Erik Andersen161220c2000-03-16 08:12:48 +00001469 /* child exited */
Eric Andersen86349772000-12-18 20:25:50 +00001470 remove_job(&job_list, job_list.fg);
1471 job_list.fg = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001472 }
Erik Andersend75af992000-03-16 08:09:09 +00001473 } else {
Erik Andersen161220c2000-03-16 08:12:48 +00001474 /* the child was stopped */
Eric Andersen86349772000-12-18 20:25:50 +00001475 job_list.fg->stopped_progs++;
1476 job_list.fg->progs[i].is_stopped = 1;
Erik Andersen3522eb12000-03-12 23:49:18 +00001477
Eric Andersen86349772000-12-18 20:25:50 +00001478 if (job_list.fg->stopped_progs == job_list.fg->running_progs) {
1479 printf("\n" JOB_STATUS_FORMAT, job_list.fg->jobid,
1480 "Stopped", job_list.fg->text);
1481 job_list.fg = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001482 }
Erik Andersend75af992000-03-16 08:09:09 +00001483 }
1484
Eric Andersen86349772000-12-18 20:25:50 +00001485 if (!job_list.fg) {
Erik Andersen161220c2000-03-16 08:12:48 +00001486 /* move the shell to the foreground */
Eric Andersen1c314ad2000-06-28 16:56:25 +00001487 /* suppress messages when run from /linuxrc mag@sysgo.de */
Eric Andersen2d848a42001-06-25 17:11:54 +00001488 if (tcsetpgrp(shell_terminal, getpgrp()) && errno != ENOTTY)
Matt Kraaia9819b22000-12-22 01:48:07 +00001489 perror_msg("tcsetpgrp");
Erik Andersend75af992000-03-16 08:09:09 +00001490 }
1491 }
1492 }
Erik Andersen161220c2000-03-16 08:12:48 +00001493 free(command);
Erik Andersen3522eb12000-03-12 23:49:18 +00001494
Eric Andersen1c314ad2000-06-28 16:56:25 +00001495 /* return controlling TTY back to parent process group before exiting */
Eric Andersen2d848a42001-06-25 17:11:54 +00001496 if (tcsetpgrp(shell_terminal, parent_pgrp))
Matt Kraaia9819b22000-12-22 01:48:07 +00001497 perror_msg("tcsetpgrp");
Eric Andersenb54833c2000-07-03 23:56:26 +00001498
1499 /* return exit status if called with "-c" */
1500 if (input == NULL && WIFEXITED(status))
1501 return WEXITSTATUS(status);
1502
Erik Andersen161220c2000-03-16 08:12:48 +00001503 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001504}
1505
1506
Eric Andersenfad9c112000-07-25 18:06:52 +00001507#ifdef BB_FEATURE_CLEAN_UP
1508void free_memory(void)
1509{
Eric Andersen5d60a462001-08-22 05:32:24 +00001510 if (cwd && cwd!=unknown) {
1511 free((char*)cwd);
Eric Andersene5dfced2001-04-09 22:48:12 +00001512 }
Eric Andersenfad9c112000-07-25 18:06:52 +00001513 if (local_pending_command)
1514 free(local_pending_command);
1515
Eric Andersen86349772000-12-18 20:25:50 +00001516 if (job_list.fg && !job_list.fg->running_progs) {
1517 remove_job(&job_list, job_list.fg);
Eric Andersenfad9c112000-07-25 18:06:52 +00001518 }
1519}
1520#endif
1521
Eric Andersen2d848a42001-06-25 17:11:54 +00001522/* Make sure we have a controlling tty. If we get started under a job
1523 * aware app (like bash for example), make sure we are now in charge so
1524 * we don't fight over who gets the foreground */
1525static void setup_job_control()
1526{
Eric Andersenf0a4ac82001-10-03 11:23:42 +00001527 int status;
1528
Eric Andersen2d848a42001-06-25 17:11:54 +00001529 /* Loop until we are in the foreground. */
Eric Andersenf0a4ac82001-10-03 11:23:42 +00001530 while ((status = tcgetpgrp (shell_terminal)) >= 0) {
1531 if (status == (shell_pgrp = getpgrp ())) {
1532 break;
1533 }
Eric Andersen2d848a42001-06-25 17:11:54 +00001534 kill (- shell_pgrp, SIGTTIN);
Eric Andersenf0a4ac82001-10-03 11:23:42 +00001535 }
Eric Andersen2d848a42001-06-25 17:11:54 +00001536
1537 /* Ignore interactive and job-control signals. */
1538 signal(SIGINT, SIG_IGN);
1539 signal(SIGQUIT, SIG_IGN);
1540 signal(SIGTSTP, SIG_IGN);
1541 signal(SIGTTIN, SIG_IGN);
1542 signal(SIGTTOU, SIG_IGN);
1543 signal(SIGCHLD, SIG_IGN);
1544
1545 /* Put ourselves in our own process group. */
Eric Andersen4b6b5e42001-06-27 04:30:11 +00001546 setsid();
Eric Andersen2d848a42001-06-25 17:11:54 +00001547 shell_pgrp = getpid ();
Eric Andersen4b6b5e42001-06-27 04:30:11 +00001548 setpgid (shell_pgrp, shell_pgrp);
Eric Andersen2d848a42001-06-25 17:11:54 +00001549
1550 /* Grab control of the terminal. */
1551 tcsetpgrp(shell_terminal, shell_pgrp);
1552}
Eric Andersen6efc48c2000-07-18 08:16:39 +00001553
Matt Kraai2d91deb2001-08-01 17:21:35 +00001554int lash_main(int argc_l, char **argv_l)
Erik Andersen3522eb12000-03-12 23:49:18 +00001555{
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001556 int opt, interactive=FALSE;
Erik Andersen161220c2000-03-16 08:12:48 +00001557 FILE *input = stdin;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001558 argc = argc_l;
1559 argv = argv_l;
Erik Andersen3522eb12000-03-12 23:49:18 +00001560
Eric Andersen702ec592001-03-06 22:17:29 +00001561 /* These variables need re-initializing when recursing */
Eric Andersen8a646dd2001-06-21 16:38:11 +00001562 last_jobid = 0;
Eric Andersenb0970d42001-01-05 19:34:52 +00001563 local_pending_command = NULL;
Eric Andersen702ec592001-03-06 22:17:29 +00001564 close_me_head = NULL;
Eric Andersenb0970d42001-01-05 19:34:52 +00001565 job_list.head = NULL;
1566 job_list.fg = NULL;
Eric Andersen4b6b5e42001-06-27 04:30:11 +00001567 last_return_code=1;
Eric Andersen501c88b2000-07-28 15:14:45 +00001568
Eric Andersenb558e762000-11-30 22:43:16 +00001569 if (argv[0] && argv[0][0] == '-') {
Eric Andersen8ea28be2001-01-05 20:58:22 +00001570 FILE *prof_input;
1571 prof_input = fopen("/etc/profile", "r");
Eric Andersen4b6b5e42001-06-27 04:30:11 +00001572 if (prof_input) {
Eric Andersen8ea28be2001-01-05 20:58:22 +00001573 int tmp_fd = fileno(prof_input);
1574 mark_open(tmp_fd);
1575 /* Now run the file */
1576 busy_loop(prof_input);
1577 fclose(prof_input);
1578 mark_closed(tmp_fd);
1579 }
Eric Andersenb558e762000-11-30 22:43:16 +00001580 }
Eric Andersen501c88b2000-07-28 15:14:45 +00001581
Eric Andersenf21aa842000-12-08 20:50:30 +00001582 while ((opt = getopt(argc_l, argv_l, "cxi")) > 0) {
Eric Andersen501c88b2000-07-28 15:14:45 +00001583 switch (opt) {
1584 case 'c':
1585 input = NULL;
Matt Kraai6085c722000-09-06 01:46:18 +00001586 if (local_pending_command != 0)
Matt Kraaidd19c692001-01-31 19:00:21 +00001587 error_msg_and_die("multiple -c arguments");
Matt Kraai6085c722000-09-06 01:46:18 +00001588 local_pending_command = xstrdup(argv[optind]);
1589 optind++;
1590 argv = argv+optind;
Eric Andersen501c88b2000-07-28 15:14:45 +00001591 break;
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001592 case 'i':
1593 interactive = TRUE;
1594 break;
Eric Andersen501c88b2000-07-28 15:14:45 +00001595 default:
Eric Andersen67991cf2001-02-14 21:23:06 +00001596 show_usage();
Eric Andersen501c88b2000-07-28 15:14:45 +00001597 }
1598 }
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001599 /* A shell is interactive if the `-i' flag was given, or if all of
1600 * the following conditions are met:
1601 * no -c command
1602 * no arguments remaining or the -s flag given
1603 * standard input is a terminal
1604 * standard output is a terminal
1605 * Refer to Posix.2, the description of the `sh' utility. */
Eric Andersen86349772000-12-18 20:25:50 +00001606 if (argv[optind]==NULL && input==stdin &&
1607 isatty(fileno(stdin)) && isatty(fileno(stdout))) {
1608 interactive=TRUE;
1609 }
Eric Andersen2d848a42001-06-25 17:11:54 +00001610 setup_job_control();
Eric Andersen86349772000-12-18 20:25:50 +00001611 if (interactive==TRUE) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001612 //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
Eric Andersen501c88b2000-07-28 15:14:45 +00001613 /* Looks like they want an interactive shell */
Eric Andersend63dee42001-10-19 00:22:23 +00001614#ifndef BB_FEATURE_SH_EXTRA_QUIET
Matt Kraai4ef40c02001-04-12 20:44:21 +00001615 printf( "\n\n" BB_BANNER " Built-in shell (lash)\n");
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001616 printf( "Enter 'help' for a list of built-in commands.\n\n");
Eric Andersend63dee42001-10-19 00:22:23 +00001617#endif
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001618 } else if (local_pending_command==NULL) {
Eric Andersen6f65a3a2001-01-20 01:10:07 +00001619 //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
Matt Kraaibbaef662000-09-27 02:43:35 +00001620 input = xfopen(argv[optind], "r");
Eric Andersen8ea28be2001-01-05 20:58:22 +00001621 mark_open(fileno(input)); /* be lazy, never mark this closed */
Eric Andersen501c88b2000-07-28 15:14:45 +00001622 }
1623
Eric Andersen6efc48c2000-07-18 08:16:39 +00001624 /* initialize the cwd -- this is never freed...*/
Eric Andersene5dfced2001-04-09 22:48:12 +00001625 cwd = xgetcwd(0);
Eric Andersen5f265b72001-05-11 16:58:46 +00001626 if (!cwd)
1627 cwd = unknown;
Erik Andersen3522eb12000-03-12 23:49:18 +00001628
Eric Andersenfad9c112000-07-25 18:06:52 +00001629#ifdef BB_FEATURE_CLEAN_UP
1630 atexit(free_memory);
1631#endif
1632
Eric Andersenb3d6e2d2001-03-13 22:57:56 +00001633#ifdef BB_FEATURE_COMMAND_EDITING
1634 cmdedit_set_initial_prompt();
1635#else
1636 PS1 = NULL;
Eric Andersenb3d6e2d2001-03-13 22:57:56 +00001637#endif
1638
Erik Andersen161220c2000-03-16 08:12:48 +00001639 return (busy_loop(input));
Erik Andersen3522eb12000-03-12 23:49:18 +00001640}