blob: bb8a456b740796dc3b1163e7f67dce21bfdae73b [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 *
5 * Copyright (C) 2000 by Lineo, inc.
6 * 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 Andersen1e7cea92000-12-06 23:47:38 +000028//
29//This works pretty well now, and is not on by default.
Eric Andersen06f64b22000-09-19 07:16:39 +000030#define BB_FEATURE_SH_ENVIRONMENT
Eric Andersen1e7cea92000-12-06 23:47:38 +000031//
32//Backtick support has some problems, use at your own risk!
33//#define BB_FEATURE_SH_BACKTICKS
34//
35//If, then, else, etc. support is really, really broken. Don't even
36//bother to mess with this yet, since you will not be happy with it.
37//#define BB_FEATURE_SH_IF_EXPRESSIONS
38//
39//For debugging/development on the shell only...
Eric Andersen501c88b2000-07-28 15:14:45 +000040//#define DEBUG_SHELL
Eric Andersena1d187a2000-07-17 19:14:41 +000041
42
Eric Andersen3570a342000-09-25 21:45:58 +000043#include "busybox.h"
Erik Andersen3522eb12000-03-12 23:49:18 +000044#include <stdio.h>
45#include <stdlib.h>
46#include <ctype.h>
47#include <errno.h>
48#include <fcntl.h>
49#include <glob.h>
50#include <signal.h>
51#include <string.h>
52#include <sys/ioctl.h>
53#include <sys/wait.h>
54#include <unistd.h>
Eric Andersen501c88b2000-07-28 15:14:45 +000055#include <getopt.h>
Erik Andersenf0657d32000-04-12 17:49:52 +000056#include "cmdedit.h"
Erik Andersen3522eb12000-03-12 23:49:18 +000057
Eric Andersen6efc48c2000-07-18 08:16:39 +000058#define MAX_LINE 256 /* size of input buffer for `read' builtin */
Eric Andersenb54833c2000-07-03 23:56:26 +000059#define 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"
Eric Andersen8c725e62000-11-30 00:27:06 +000061extern size_t NUM_APPLETS;
Erik Andersen3522eb12000-03-12 23:49:18 +000062
Erik Andersend75af992000-03-16 08:09:09 +000063
Eric Andersenb558e762000-11-30 22:43:16 +000064
65
Erik Andersend75af992000-03-16 08:09:09 +000066enum redirectionType { REDIRECT_INPUT, REDIRECT_OVERWRITE,
Erik Andersen161220c2000-03-16 08:12:48 +000067 REDIRECT_APPEND
68};
Erik Andersen3522eb12000-03-12 23:49:18 +000069
Eric Andersene92108a2000-07-26 00:53:56 +000070static const unsigned int REGULAR_JOB_CONTEXT=0x1;
Eric Andersen6a99aaf2000-07-27 00:15:20 +000071static const unsigned int IF_TRUE_CONTEXT=0x2;
72static const unsigned int IF_FALSE_CONTEXT=0x4;
73static const unsigned int THEN_EXP_CONTEXT=0x8;
74static const unsigned int ELSE_EXP_CONTEXT=0x10;
Eric Andersene92108a2000-07-26 00:53:56 +000075
Eric Andersenfad9c112000-07-25 18:06:52 +000076
Erik Andersen3522eb12000-03-12 23:49:18 +000077struct jobSet {
Erik Andersen161220c2000-03-16 08:12:48 +000078 struct job *head; /* head of list of running jobs */
79 struct job *fg; /* current foreground job */
Erik Andersen3522eb12000-03-12 23:49:18 +000080};
81
82struct redirectionSpecifier {
Erik Andersen161220c2000-03-16 08:12:48 +000083 enum redirectionType type; /* type of redirection */
84 int fd; /* file descriptor being redirected */
85 char *filename; /* file to redirect fd to */
Erik Andersen3522eb12000-03-12 23:49:18 +000086};
87
88struct childProgram {
Erik Andersen161220c2000-03-16 08:12:48 +000089 pid_t pid; /* 0 if exited */
90 char **argv; /* program name and arguments */
91 int numRedirections; /* elements in redirection array */
92 struct redirectionSpecifier *redirections; /* I/O redirections */
93 glob_t globResult; /* result of parameter globbing */
94 int freeGlob; /* should we globfree(&globResult)? */
95 int isStopped; /* is the program currently running? */
Erik Andersen3522eb12000-03-12 23:49:18 +000096};
97
98struct job {
Erik Andersen161220c2000-03-16 08:12:48 +000099 int jobId; /* job number */
100 int numProgs; /* total number of programs in job */
101 int runningProgs; /* number of programs running */
102 char *text; /* name of job */
103 char *cmdBuf; /* buffer various argv's point into */
104 pid_t pgrp; /* process group ID for the job */
105 struct childProgram *progs; /* array of programs in job */
106 struct job *next; /* to track background commands */
107 int stoppedProgs; /* number of programs alive, but stopped */
Eric Andersenfad9c112000-07-25 18:06:52 +0000108 int jobContext; /* bitmask defining current context */
Erik Andersen3522eb12000-03-12 23:49:18 +0000109};
110
111struct builtInCommand {
Erik Andersen161220c2000-03-16 08:12:48 +0000112 char *cmd; /* name */
113 char *descr; /* description */
Erik Andersen161220c2000-03-16 08:12:48 +0000114 int (*function) (struct job *, struct jobSet * jobList); /* function ptr */
Erik Andersen3522eb12000-03-12 23:49:18 +0000115};
116
Eric Andersen34e19412000-07-10 18:47:24 +0000117/* function prototypes for builtins */
118static int builtin_cd(struct job *cmd, struct jobSet *junk);
119static int builtin_env(struct job *dummy, struct jobSet *junk);
Eric Andersend2f56772000-09-21 02:48:07 +0000120static int builtin_exec(struct job *cmd, struct jobSet *junk);
Eric Andersen34e19412000-07-10 18:47:24 +0000121static int builtin_exit(struct job *cmd, struct jobSet *junk);
122static int builtin_fg_bg(struct job *cmd, struct jobSet *jobList);
123static int builtin_help(struct job *cmd, struct jobSet *junk);
124static int builtin_jobs(struct job *dummy, struct jobSet *jobList);
125static int builtin_pwd(struct job *dummy, struct jobSet *junk);
126static int builtin_export(struct job *cmd, struct jobSet *junk);
127static int builtin_source(struct job *cmd, struct jobSet *jobList);
128static int builtin_unset(struct job *cmd, struct jobSet *junk);
129static int builtin_read(struct job *cmd, struct jobSet *junk);
Eric Andersenfad9c112000-07-25 18:06:52 +0000130#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
131static int builtin_if(struct job *cmd, struct jobSet *junk);
132static int builtin_then(struct job *cmd, struct jobSet *junk);
133static int builtin_else(struct job *cmd, struct jobSet *junk);
134static int builtin_fi(struct job *cmd, struct jobSet *junk);
135#endif
Erik Andersen3522eb12000-03-12 23:49:18 +0000136
Eric Andersen34e19412000-07-10 18:47:24 +0000137
138/* function prototypes for shell stuff */
Erik Andersend75af992000-03-16 08:09:09 +0000139static void checkJobs(struct jobSet *jobList);
140static int getCommand(FILE * source, char *command);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000141static int parseCommand(char **commandPtr, struct job *job, struct jobSet *jobList, int *inBg);
Eric Andersena1d187a2000-07-17 19:14:41 +0000142static int runCommand(struct job *newJob, struct jobSet *jobList, int inBg, int outPipe[2]);
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) */
Erik Andersen3522eb12000-03-12 23:49:18 +0000149static struct builtInCommand 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 Andersen6a99aaf2000-07-27 00:15:20 +0000160#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
161 {"if", NULL, builtin_if},
162 {"then", NULL, builtin_then},
163 {"else", NULL, builtin_else},
164 {"fi", NULL, builtin_fi},
165#endif
Eric Andersenfad9c112000-07-25 18:06:52 +0000166 {NULL, NULL, NULL}
Erik Andersen330fd2b2000-05-19 05:35:19 +0000167};
168
Mark Whitley37653aa2000-07-12 23:36:17 +0000169/* Table of forking built-in functions (things that fork cannot change global
170 * variables in the parent process, such as the current working directory) */
Erik Andersen330fd2b2000-05-19 05:35:19 +0000171static struct builtInCommand bltins_forking[] = {
Eric Andersenfad9c112000-07-25 18:06:52 +0000172 {"env", "Print all environment variables", builtin_env},
173 {"pwd", "Print current directory", builtin_pwd},
Eric Andersenfad9c112000-07-25 18:06:52 +0000174 {"help", "List shell built-in commands", builtin_help},
175 {NULL, NULL, NULL}
Erik Andersen3522eb12000-03-12 23:49:18 +0000176};
177
Eric Andersenb558e762000-11-30 22:43:16 +0000178static char prompt[3];
Eric Andersen6efc48c2000-07-18 08:16:39 +0000179static char *cwd;
Eric Andersen1c314ad2000-06-28 16:56:25 +0000180static char *local_pending_command = NULL;
Eric Andersenfad9c112000-07-25 18:06:52 +0000181static char *promptStr = NULL;
182static struct jobSet jobList = { NULL, NULL };
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000183static int argc;
184static char **argv;
185#ifdef BB_FEATURE_SH_ENVIRONMENT
186static int lastBgPid=-1;
187static int lastReturnCode=-1;
Eric Andersen501c88b2000-07-28 15:14:45 +0000188static int showXtrace=FALSE;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000189#endif
Eric Andersen501c88b2000-07-28 15:14:45 +0000190
Eric Andersenb558e762000-11-30 22:43:16 +0000191#ifdef DEBUG_SHELL
192static inline void debug_printf(const char *format, ...)
193{
194 va_list args;
195 va_start(args, format);
196 vfprintf(stderr, s, p);
197 va_end(args);
198}
199#else
200static inline void debug_printf(const char *format, ...) { }
201#endif
Erik Andersen3522eb12000-03-12 23:49:18 +0000202
Erik Andersenf0657d32000-04-12 17:49:52 +0000203#ifdef BB_FEATURE_SH_COMMAND_EDITING
Eric Andersenb558e762000-11-30 22:43:16 +0000204static inline void win_changed(int junk)
Erik Andersenf0657d32000-04-12 17:49:52 +0000205{
Eric Andersenfad04fd2000-07-14 06:49:52 +0000206 struct winsize win = { 0, 0, 0, 0 };
Erik Andersenf0657d32000-04-12 17:49:52 +0000207 ioctl(0, TIOCGWINSZ, &win);
208 if (win.ws_col > 0) {
209 cmdedit_setwidth( win.ws_col - 1);
210 }
211}
Eric Andersenb558e762000-11-30 22:43:16 +0000212#else
213static inline void win_changed(int junk) {}
Erik Andersenf0657d32000-04-12 17:49:52 +0000214#endif
Erik Andersen3522eb12000-03-12 23:49:18 +0000215
Erik Andersen3522eb12000-03-12 23:49:18 +0000216
Erik Andersend75af992000-03-16 08:09:09 +0000217/* built-in 'cd <path>' handler */
Eric Andersen34e19412000-07-10 18:47:24 +0000218static int builtin_cd(struct job *cmd, struct jobSet *junk)
Erik Andersend75af992000-03-16 08:09:09 +0000219{
Erik Andersen161220c2000-03-16 08:12:48 +0000220 char *newdir;
Erik Andersend75af992000-03-16 08:09:09 +0000221
Erik Andersen161220c2000-03-16 08:12:48 +0000222 if (!cmd->progs[0].argv[1] == 1)
223 newdir = getenv("HOME");
224 else
225 newdir = cmd->progs[0].argv[1];
226 if (chdir(newdir)) {
227 printf("cd: %s: %s\n", newdir, strerror(errno));
Matt Kraai3e856ce2000-12-01 02:55:13 +0000228 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000229 }
Eric Andersen6efc48c2000-07-18 08:16:39 +0000230 getcwd(cwd, sizeof(char)*MAX_LINE);
Erik Andersen161220c2000-03-16 08:12:48 +0000231
Matt Kraai3e856ce2000-12-01 02:55:13 +0000232 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000233}
234
235/* built-in 'env' handler */
Eric Andersen34e19412000-07-10 18:47:24 +0000236static int builtin_env(struct job *dummy, struct jobSet *junk)
Erik Andersen3522eb12000-03-12 23:49:18 +0000237{
Erik Andersen161220c2000-03-16 08:12:48 +0000238 char **e;
Erik Andersen3522eb12000-03-12 23:49:18 +0000239
Erik Andersen161220c2000-03-16 08:12:48 +0000240 for (e = environ; *e; e++) {
241 fprintf(stdout, "%s\n", *e);
242 }
243 return (0);
Erik Andersen3522eb12000-03-12 23:49:18 +0000244}
245
Eric Andersend2f56772000-09-21 02:48:07 +0000246/* built-in 'exec' handler */
247static int builtin_exec(struct job *cmd, struct jobSet *junk)
248{
249 if (cmd->progs[0].argv[1])
250 {
251 cmd->progs[0].argv++;
252 execvp(cmd->progs[0].argv[0], cmd->progs[0].argv);
253 fatalError("Exec to %s failed: %s\n", cmd->progs[0].argv[0],
254 strerror(errno));
255 }
Matt Kraai3e856ce2000-12-01 02:55:13 +0000256 return EXIT_SUCCESS;
Eric Andersend2f56772000-09-21 02:48:07 +0000257}
258
Erik Andersen3522eb12000-03-12 23:49:18 +0000259/* built-in 'exit' handler */
Eric Andersen34e19412000-07-10 18:47:24 +0000260static int builtin_exit(struct job *cmd, struct jobSet *junk)
Erik Andersen3522eb12000-03-12 23:49:18 +0000261{
Erik Andersen161220c2000-03-16 08:12:48 +0000262 if (!cmd->progs[0].argv[1] == 1)
Matt Kraai3e856ce2000-12-01 02:55:13 +0000263 exit(EXIT_SUCCESS);
Erik Andersen161220c2000-03-16 08:12:48 +0000264
Pavel Roskin5f84fd72000-09-15 00:46:51 +0000265 exit (atoi(cmd->progs[0].argv[1]));
Erik Andersen3522eb12000-03-12 23:49:18 +0000266}
267
268/* built-in 'fg' and 'bg' handler */
Eric Andersen34e19412000-07-10 18:47:24 +0000269static int builtin_fg_bg(struct job *cmd, struct jobSet *jobList)
Erik Andersen3522eb12000-03-12 23:49:18 +0000270{
Erik Andersen161220c2000-03-16 08:12:48 +0000271 int i, jobNum;
Erik Andersen6273f652000-03-17 01:12:41 +0000272 struct job *job=NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +0000273
Erik Andersen161220c2000-03-16 08:12:48 +0000274 if (!jobList->head) {
275 if (!cmd->progs[0].argv[1] || cmd->progs[0].argv[2]) {
Matt Kraaid537a952000-07-14 01:51:25 +0000276 errorMsg("%s: exactly one argument is expected\n",
Erik Andersen161220c2000-03-16 08:12:48 +0000277 cmd->progs[0].argv[0]);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000278 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000279 }
280 if (sscanf(cmd->progs[0].argv[1], "%%%d", &jobNum) != 1) {
Matt Kraaid537a952000-07-14 01:51:25 +0000281 errorMsg("%s: bad argument '%s'\n",
Erik Andersen161220c2000-03-16 08:12:48 +0000282 cmd->progs[0].argv[0], cmd->progs[0].argv[1]);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000283 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000284 for (job = jobList->head; job; job = job->next) {
285 if (job->jobId == jobNum) {
286 break;
287 }
288 }
289 }
290 } else {
291 job = jobList->head;
Erik Andersend75af992000-03-16 08:09:09 +0000292 }
Erik Andersen161220c2000-03-16 08:12:48 +0000293
294 if (!job) {
Matt Kraaid537a952000-07-14 01:51:25 +0000295 errorMsg("%s: unknown job %d\n",
Erik Andersen161220c2000-03-16 08:12:48 +0000296 cmd->progs[0].argv[0], jobNum);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000297 return EXIT_FAILURE;
Erik Andersend75af992000-03-16 08:09:09 +0000298 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000299
Erik Andersen161220c2000-03-16 08:12:48 +0000300 if (*cmd->progs[0].argv[0] == 'f') {
301 /* Make this job the foreground job */
Eric Andersen1c314ad2000-06-28 16:56:25 +0000302 /* suppress messages when run from /linuxrc mag@sysgo.de */
303 if (tcsetpgrp(0, job->pgrp) && errno != ENOTTY)
304 perror("tcsetpgrp");
Erik Andersen161220c2000-03-16 08:12:48 +0000305 jobList->fg = job;
306 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000307
Erik Andersen161220c2000-03-16 08:12:48 +0000308 /* Restart the processes in the job */
309 for (i = 0; i < job->numProgs; i++)
310 job->progs[i].isStopped = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000311
Erik Andersen161220c2000-03-16 08:12:48 +0000312 kill(-job->pgrp, SIGCONT);
Erik Andersen3522eb12000-03-12 23:49:18 +0000313
Erik Andersen161220c2000-03-16 08:12:48 +0000314 job->stoppedProgs = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000315
Matt Kraai3e856ce2000-12-01 02:55:13 +0000316 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000317}
318
319/* built-in 'help' handler */
Eric Andersenfad04fd2000-07-14 06:49:52 +0000320static int builtin_help(struct job *dummy, struct jobSet *junk)
Erik Andersen3522eb12000-03-12 23:49:18 +0000321{
Erik Andersen161220c2000-03-16 08:12:48 +0000322 struct builtInCommand *x;
Erik Andersen3522eb12000-03-12 23:49:18 +0000323
Erik Andersen161220c2000-03-16 08:12:48 +0000324 fprintf(stdout, "\nBuilt-in commands:\n");
325 fprintf(stdout, "-------------------\n");
326 for (x = bltins; x->cmd; x++) {
Eric Andersenfad9c112000-07-25 18:06:52 +0000327 if (x->descr==NULL)
328 continue;
Erik Andersen161220c2000-03-16 08:12:48 +0000329 fprintf(stdout, "%s\t%s\n", x->cmd, x->descr);
330 }
Erik Andersen330fd2b2000-05-19 05:35:19 +0000331 for (x = bltins_forking; x->cmd; x++) {
Eric Andersenfad9c112000-07-25 18:06:52 +0000332 if (x->descr==NULL)
333 continue;
Erik Andersen330fd2b2000-05-19 05:35:19 +0000334 fprintf(stdout, "%s\t%s\n", x->cmd, x->descr);
335 }
Erik Andersen161220c2000-03-16 08:12:48 +0000336 fprintf(stdout, "\n\n");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000337 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000338}
339
340/* built-in 'jobs' handler */
Eric Andersen34e19412000-07-10 18:47:24 +0000341static int builtin_jobs(struct job *dummy, struct jobSet *jobList)
Erik Andersen3522eb12000-03-12 23:49:18 +0000342{
Erik Andersen161220c2000-03-16 08:12:48 +0000343 struct job *job;
344 char *statusString;
Erik Andersen3522eb12000-03-12 23:49:18 +0000345
Erik Andersen161220c2000-03-16 08:12:48 +0000346 for (job = jobList->head; job; job = job->next) {
347 if (job->runningProgs == job->stoppedProgs)
348 statusString = "Stopped";
349 else
350 statusString = "Running";
351
352 printf(JOB_STATUS_FORMAT, job->jobId, statusString, job->text);
353 }
Matt Kraai3e856ce2000-12-01 02:55:13 +0000354 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000355}
356
357
358/* built-in 'pwd' handler */
Eric Andersen34e19412000-07-10 18:47:24 +0000359static int builtin_pwd(struct job *dummy, struct jobSet *junk)
Erik Andersen3522eb12000-03-12 23:49:18 +0000360{
Eric Andersen6efc48c2000-07-18 08:16:39 +0000361 getcwd(cwd, sizeof(char)*MAX_LINE);
Erik Andersen161220c2000-03-16 08:12:48 +0000362 fprintf(stdout, "%s\n", cwd);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000363 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000364}
365
Erik Andersen6273f652000-03-17 01:12:41 +0000366/* built-in 'export VAR=value' handler */
Eric Andersen34e19412000-07-10 18:47:24 +0000367static int builtin_export(struct job *cmd, struct jobSet *junk)
Erik Andersen3522eb12000-03-12 23:49:18 +0000368{
Erik Andersen161220c2000-03-16 08:12:48 +0000369 int res;
Erik Andersen3522eb12000-03-12 23:49:18 +0000370
Erik Andersen161220c2000-03-16 08:12:48 +0000371 if (!cmd->progs[0].argv[1] == 1) {
Eric Andersen34e19412000-07-10 18:47:24 +0000372 return (builtin_env(cmd, junk));
Erik Andersen161220c2000-03-16 08:12:48 +0000373 }
374 res = putenv(cmd->progs[0].argv[1]);
375 if (res)
Erik Andersen6273f652000-03-17 01:12:41 +0000376 fprintf(stdout, "export: %s\n", strerror(errno));
Erik Andersen161220c2000-03-16 08:12:48 +0000377 return (res);
Erik Andersen3522eb12000-03-12 23:49:18 +0000378}
379
Eric Andersenb54833c2000-07-03 23:56:26 +0000380/* built-in 'read VAR' handler */
Eric Andersen34e19412000-07-10 18:47:24 +0000381static int builtin_read(struct job *cmd, struct jobSet *junk)
Eric Andersenb54833c2000-07-03 23:56:26 +0000382{
383 int res = 0, len, newlen;
384 char *s;
385 char string[MAX_READ];
386
387 if (cmd->progs[0].argv[1]) {
388 /* argument (VAR) given: put "VAR=" into buffer */
389 strcpy(string, cmd->progs[0].argv[1]);
390 len = strlen(string);
391 string[len++] = '=';
392 string[len] = '\0';
393 fgets(&string[len], sizeof(string) - len, stdin); /* read string */
394 newlen = strlen(string);
395 if(newlen > len)
396 string[--newlen] = '\0'; /* chomp trailing newline */
397 /*
398 ** string should now contain "VAR=<value>"
399 ** copy it (putenv() won't do that, so we must make sure
400 ** the string resides in a static buffer!)
401 */
402 res = -1;
403 if((s = strdup(string)))
404 res = putenv(s);
405 if (res)
406 fprintf(stdout, "read: %s\n", strerror(errno));
407 }
408 else
409 fgets(string, sizeof(string), stdin);
410
411 return (res);
412}
413
Eric Andersenfad9c112000-07-25 18:06:52 +0000414#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
415/* Built-in handler for 'if' commands */
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000416static int builtin_if(struct job *cmd, struct jobSet *jobList)
Eric Andersenfad9c112000-07-25 18:06:52 +0000417{
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000418 int status;
419 char* charptr1=cmd->text+3; /* skip over the leading 'if ' */
420
421 /* Now run the 'if' command */
422 status=strlen(charptr1);
423 local_pending_command = xmalloc(status+1);
424 strncpy(local_pending_command, charptr1, status);
Eric Andersen501c88b2000-07-28 15:14:45 +0000425 local_pending_command[status]='\0';
Eric Andersenb558e762000-11-30 22:43:16 +0000426 debug_printf(stderr, "'if' now testing '%s'\n", local_pending_command);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000427 status = busy_loop(NULL); /* Frees local_pending_command */
Eric Andersenb558e762000-11-30 22:43:16 +0000428 debug_printf(stderr, "if test returned ");
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000429 if (status == 0) {
Eric Andersenb558e762000-11-30 22:43:16 +0000430 debug_printf(stderr, "TRUE\n");
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000431 cmd->jobContext |= IF_TRUE_CONTEXT;
432 } else {
Eric Andersenb558e762000-11-30 22:43:16 +0000433 debug_printf(stderr, "FALSE\n");
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000434 cmd->jobContext |= IF_FALSE_CONTEXT;
435 }
436
437 return status;
Eric Andersenfad9c112000-07-25 18:06:52 +0000438}
439
440/* Built-in handler for 'then' (part of the 'if' command) */
441static int builtin_then(struct job *cmd, struct jobSet *junk)
442{
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000443 int status;
444 char* charptr1=cmd->text+5; /* skip over the leading 'then ' */
445
446 if (! (cmd->jobContext & (IF_TRUE_CONTEXT|IF_FALSE_CONTEXT))) {
447 errorMsg("unexpected token `then'\n");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000448 return EXIT_FAILURE;
Eric Andersenfad9c112000-07-25 18:06:52 +0000449 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000450 /* If the if result was FALSE, skip the 'then' stuff */
Eric Andersen501c88b2000-07-28 15:14:45 +0000451 if (cmd->jobContext & IF_FALSE_CONTEXT) {
Matt Kraai3e856ce2000-12-01 02:55:13 +0000452 return EXIT_SUCCESS;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000453 }
454
Eric Andersenfad9c112000-07-25 18:06:52 +0000455 cmd->jobContext |= THEN_EXP_CONTEXT;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000456 //printf("Hit an then -- jobContext=%d\n", cmd->jobContext);
457
458 /* Now run the 'then' command */
459 status=strlen(charptr1);
460 local_pending_command = xmalloc(status+1);
461 strncpy(local_pending_command, charptr1, status);
Eric Andersen501c88b2000-07-28 15:14:45 +0000462 local_pending_command[status]='\0';
Eric Andersenb558e762000-11-30 22:43:16 +0000463 debug_printf(stderr, "'then' now running '%s'\n", charptr1);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000464 return( busy_loop(NULL));
Eric Andersenfad9c112000-07-25 18:06:52 +0000465}
466
467/* Built-in handler for 'else' (part of the 'if' command) */
468static int builtin_else(struct job *cmd, struct jobSet *junk)
469{
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000470 int status;
471 char* charptr1=cmd->text+5; /* skip over the leading 'else ' */
472
473 if (! (cmd->jobContext & (IF_TRUE_CONTEXT|IF_FALSE_CONTEXT))) {
474 errorMsg("unexpected token `else'\n");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000475 return EXIT_FAILURE;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000476 }
477 /* If the if result was TRUE, skip the 'else' stuff */
Eric Andersen501c88b2000-07-28 15:14:45 +0000478 if (cmd->jobContext & IF_TRUE_CONTEXT) {
Matt Kraai3e856ce2000-12-01 02:55:13 +0000479 return EXIT_SUCCESS;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000480 }
481
Eric Andersenfad9c112000-07-25 18:06:52 +0000482 cmd->jobContext |= ELSE_EXP_CONTEXT;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000483 //printf("Hit an else -- jobContext=%d\n", cmd->jobContext);
484
485 /* Now run the 'else' command */
486 status=strlen(charptr1);
487 local_pending_command = xmalloc(status+1);
488 strncpy(local_pending_command, charptr1, status);
Eric Andersen501c88b2000-07-28 15:14:45 +0000489 local_pending_command[status]='\0';
Eric Andersenb558e762000-11-30 22:43:16 +0000490 debug_printf(stderr, "'else' now running '%s'\n", charptr1);
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000491 return( busy_loop(NULL));
Eric Andersenfad9c112000-07-25 18:06:52 +0000492}
493
494/* Built-in handler for 'fi' (part of the 'if' command) */
495static int builtin_fi(struct job *cmd, struct jobSet *junk)
496{
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000497 if (! (cmd->jobContext & (IF_TRUE_CONTEXT|IF_FALSE_CONTEXT))) {
498 errorMsg("unexpected token `fi'\n");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000499 return EXIT_FAILURE;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000500 }
501 /* Clear out the if and then context bits */
502 cmd->jobContext &= ~(IF_TRUE_CONTEXT|IF_FALSE_CONTEXT|THEN_EXP_CONTEXT|ELSE_EXP_CONTEXT);
Eric Andersenb558e762000-11-30 22:43:16 +0000503 debug_printf(stderr, "Hit an fi -- jobContext=%d\n", cmd->jobContext);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000504 return EXIT_SUCCESS;
Eric Andersenfad9c112000-07-25 18:06:52 +0000505}
506#endif
507
Erik Andersen3522eb12000-03-12 23:49:18 +0000508/* Built-in '.' handler (read-in and execute commands from file) */
Eric Andersen34e19412000-07-10 18:47:24 +0000509static int builtin_source(struct job *cmd, struct jobSet *junk)
Erik Andersen3522eb12000-03-12 23:49:18 +0000510{
Erik Andersen161220c2000-03-16 08:12:48 +0000511 FILE *input;
512 int status;
Erik Andersen3522eb12000-03-12 23:49:18 +0000513
Erik Andersen161220c2000-03-16 08:12:48 +0000514 if (!cmd->progs[0].argv[1] == 1)
Matt Kraai3e856ce2000-12-01 02:55:13 +0000515 return EXIT_FAILURE;
Erik Andersen3522eb12000-03-12 23:49:18 +0000516
Erik Andersen161220c2000-03-16 08:12:48 +0000517 input = fopen(cmd->progs[0].argv[1], "r");
518 if (!input) {
519 fprintf(stdout, "Couldn't open file '%s'\n",
520 cmd->progs[0].argv[1]);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000521 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000522 }
Erik Andersend75af992000-03-16 08:09:09 +0000523
Erik Andersen161220c2000-03-16 08:12:48 +0000524 /* Now run the file */
525 status = busy_loop(input);
Matt Kraaidd450a02000-09-13 03:43:36 +0000526 fclose(input);
Erik Andersen161220c2000-03-16 08:12:48 +0000527 return (status);
Erik Andersen3522eb12000-03-12 23:49:18 +0000528}
529
530/* built-in 'unset VAR' handler */
Eric Andersen34e19412000-07-10 18:47:24 +0000531static int builtin_unset(struct job *cmd, struct jobSet *junk)
Erik Andersen3522eb12000-03-12 23:49:18 +0000532{
Erik Andersen161220c2000-03-16 08:12:48 +0000533 if (!cmd->progs[0].argv[1] == 1) {
534 fprintf(stdout, "unset: parameter required.\n");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000535 return EXIT_FAILURE;
Erik Andersen161220c2000-03-16 08:12:48 +0000536 }
537 unsetenv(cmd->progs[0].argv[1]);
Matt Kraai3e856ce2000-12-01 02:55:13 +0000538 return EXIT_SUCCESS;
Erik Andersen3522eb12000-03-12 23:49:18 +0000539}
540
541/* free up all memory from a job */
Erik Andersend75af992000-03-16 08:09:09 +0000542static void freeJob(struct job *cmd)
Erik Andersen3522eb12000-03-12 23:49:18 +0000543{
Erik Andersen161220c2000-03-16 08:12:48 +0000544 int i;
Erik Andersen3522eb12000-03-12 23:49:18 +0000545
Erik Andersen161220c2000-03-16 08:12:48 +0000546 for (i = 0; i < cmd->numProgs; i++) {
547 free(cmd->progs[i].argv);
548 if (cmd->progs[i].redirections)
549 free(cmd->progs[i].redirections);
550 if (cmd->progs[i].freeGlob)
551 globfree(&cmd->progs[i].globResult);
552 }
553 free(cmd->progs);
554 if (cmd->text)
555 free(cmd->text);
556 free(cmd->cmdBuf);
Eric Andersenec10b9d2000-07-14 01:13:11 +0000557 memset(cmd, 0, sizeof(struct job));
Erik Andersen3522eb12000-03-12 23:49:18 +0000558}
559
560/* remove a job from the jobList */
Erik Andersend75af992000-03-16 08:09:09 +0000561static void removeJob(struct jobSet *jobList, struct job *job)
Erik Andersen3522eb12000-03-12 23:49:18 +0000562{
Erik Andersen161220c2000-03-16 08:12:48 +0000563 struct job *prevJob;
Erik Andersen3522eb12000-03-12 23:49:18 +0000564
Erik Andersen161220c2000-03-16 08:12:48 +0000565 freeJob(job);
566 if (job == jobList->head) {
567 jobList->head = job->next;
568 } else {
569 prevJob = jobList->head;
570 while (prevJob->next != job)
571 prevJob = prevJob->next;
572 prevJob->next = job->next;
573 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000574
Erik Andersen161220c2000-03-16 08:12:48 +0000575 free(job);
Erik Andersen3522eb12000-03-12 23:49:18 +0000576}
577
578/* Checks to see if any background processes have exited -- if they
579 have, figure out why and see if a job has completed */
Erik Andersend75af992000-03-16 08:09:09 +0000580static void checkJobs(struct jobSet *jobList)
Erik Andersen3522eb12000-03-12 23:49:18 +0000581{
Erik Andersen161220c2000-03-16 08:12:48 +0000582 struct job *job;
583 pid_t childpid;
584 int status;
585 int progNum = 0;
Erik Andersend75af992000-03-16 08:09:09 +0000586
Erik Andersen161220c2000-03-16 08:12:48 +0000587 while ((childpid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
588 for (job = jobList->head; job; job = job->next) {
589 progNum = 0;
590 while (progNum < job->numProgs &&
591 job->progs[progNum].pid != childpid) progNum++;
592 if (progNum < job->numProgs)
593 break;
594 }
595
Eric Andersena1d187a2000-07-17 19:14:41 +0000596 /* This happens on backticked commands */
597 if(job==NULL)
598 return;
599
Erik Andersen161220c2000-03-16 08:12:48 +0000600 if (WIFEXITED(status) || WIFSIGNALED(status)) {
601 /* child exited */
602 job->runningProgs--;
603 job->progs[progNum].pid = 0;
604
605 if (!job->runningProgs) {
606 printf(JOB_STATUS_FORMAT, job->jobId, "Done", job->text);
607 removeJob(jobList, job);
608 }
609 } else {
610 /* child stopped */
611 job->stoppedProgs++;
612 job->progs[progNum].isStopped = 1;
613
614 if (job->stoppedProgs == job->numProgs) {
615 printf(JOB_STATUS_FORMAT, job->jobId, "Stopped",
616 job->text);
617 }
618 }
Erik Andersend75af992000-03-16 08:09:09 +0000619 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000620
Erik Andersen161220c2000-03-16 08:12:48 +0000621 if (childpid == -1 && errno != ECHILD)
622 perror("waitpid");
Erik Andersen3522eb12000-03-12 23:49:18 +0000623}
624
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000625static int setupRedirections(struct childProgram *prog)
626{
627 int i;
628 int openfd;
629 int mode = O_RDONLY;
630 struct redirectionSpecifier *redir = prog->redirections;
631
632 for (i = 0; i < prog->numRedirections; i++, redir++) {
633 switch (redir->type) {
634 case REDIRECT_INPUT:
635 mode = O_RDONLY;
636 break;
637 case REDIRECT_OVERWRITE:
Eric Andersen46f0beb2000-11-14 21:59:22 +0000638 mode = O_WRONLY | O_CREAT | O_TRUNC;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000639 break;
640 case REDIRECT_APPEND:
Eric Andersen46f0beb2000-11-14 21:59:22 +0000641 mode = O_WRONLY | O_CREAT | O_APPEND;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000642 break;
643 }
644
645 openfd = open(redir->filename, mode, 0666);
646 if (openfd < 0) {
647 /* this could get lost if stderr has been redirected, but
648 bash and ash both lose it as well (though zsh doesn't!) */
649 errorMsg("error opening %s: %s\n", redir->filename,
650 strerror(errno));
651 return 1;
652 }
653
654 if (openfd != redir->fd) {
655 dup2(openfd, redir->fd);
656 close(openfd);
657 }
658 }
659
660 return 0;
661}
662
663
Erik Andersend75af992000-03-16 08:09:09 +0000664static int getCommand(FILE * source, char *command)
Erik Andersen3522eb12000-03-12 23:49:18 +0000665{
Eric Andersenb558e762000-11-30 22:43:16 +0000666 char *user,buf[255],*s;
667
Eric Andersen1c314ad2000-06-28 16:56:25 +0000668 if (source == NULL) {
669 if (local_pending_command) {
670 /* a command specified (-c option): return it & mark it done */
671 strcpy(command, local_pending_command);
672 free(local_pending_command);
673 local_pending_command = NULL;
674 return 0;
675 }
676 return 1;
677 }
678
Eric Andersenb558e762000-11-30 22:43:16 +0000679 /* get User Name and setup prompt */
680 strcpy(prompt,( geteuid() != 0 ) ? "$ ":"# ");
681 user=xcalloc(sizeof(int), 9);
682 my_getpwuid(user, geteuid());
683
684 /* get HostName */
685 gethostname(buf, 255);
686 s = strchr(buf, '.');
687 if (s)
688 *s = 0;
689
Erik Andersen161220c2000-03-16 08:12:48 +0000690 if (source == stdin) {
Erik Andersend75af992000-03-16 08:09:09 +0000691#ifdef BB_FEATURE_SH_COMMAND_EDITING
Erik Andersenc7c634b2000-03-19 05:28:55 +0000692 int len;
Eric Andersen501c88b2000-07-28 15:14:45 +0000693
694 /*
695 ** enable command line editing only while a command line
696 ** is actually being read; otherwise, we'll end up bequeathing
697 ** atexit() handlers and other unwanted stuff to our
698 ** child processes (rob@sysgo.de)
699 */
700 cmdedit_init();
701 signal(SIGWINCH, win_changed);
Eric Andersenb558e762000-11-30 22:43:16 +0000702 len=fprintf(stdout, "[%s@%s %s]%s", user, buf,
703 get_last_path_component(cwd), prompt);
Erik Andersenc7c634b2000-03-19 05:28:55 +0000704 fflush(stdout);
Eric Andersenec10b9d2000-07-14 01:13:11 +0000705 promptStr=(char*)xmalloc(sizeof(char)*(len+1));
Eric Andersenb558e762000-11-30 22:43:16 +0000706 sprintf(promptStr, "[%s@%s %s]%s", user, buf,
707 get_last_path_component(cwd), prompt);
Erik Andersenf0657d32000-04-12 17:49:52 +0000708 cmdedit_read_input(promptStr, command);
Erik Andersenc7c634b2000-03-19 05:28:55 +0000709 free( promptStr);
Eric Andersen501c88b2000-07-28 15:14:45 +0000710 cmdedit_terminate();
711 signal(SIGWINCH, SIG_DFL);
Erik Andersen161220c2000-03-16 08:12:48 +0000712 return 0;
Erik Andersenc7c634b2000-03-19 05:28:55 +0000713#else
Eric Andersenb558e762000-11-30 22:43:16 +0000714 i=strlen(cwd);
715 i--;
716 if (i>1){
717 while ((i>0) && (*(cwd+i)!='/') ) i--;
718 if (*(cwd+i)=='/') i++;
719 }
720
721 fprintf(stdout, "[%s@%s %s]%s",user, buf, (cwd+i), prompt);
Erik Andersenc7c634b2000-03-19 05:28:55 +0000722 fflush(stdout);
Erik Andersend75af992000-03-16 08:09:09 +0000723#endif
Erik Andersen161220c2000-03-16 08:12:48 +0000724 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000725
Eric Andersenb558e762000-11-30 22:43:16 +0000726 /* don't leak memory */
727 free(user);
728
Erik Andersen161220c2000-03-16 08:12:48 +0000729 if (!fgets(command, BUFSIZ - 2, source)) {
730 if (source == stdin)
731 printf("\n");
732 return 1;
733 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000734
Erik Andersen161220c2000-03-16 08:12:48 +0000735 /* remove trailing newline */
736 command[strlen(command) - 1] = '\0';
Erik Andersen3522eb12000-03-12 23:49:18 +0000737
Erik Andersen161220c2000-03-16 08:12:48 +0000738 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000739}
740
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000741#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000742static char* itoa(register int i)
743{
Eric Andersenb558e762000-11-30 22:43:16 +0000744 static char a[7]; /* Max 7 ints */
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000745 register char *b = a + sizeof(a) - 1;
746 int sign = (i < 0);
747
748 if (sign)
749 i = -i;
750 *b = 0;
751 do
752 {
753 *--b = '0' + (i % 10);
754 i /= 10;
755 }
756 while (i);
757 if (sign)
758 *--b = '-';
759 return b;
760}
761#endif
762
Erik Andersend75af992000-03-16 08:09:09 +0000763static void globLastArgument(struct childProgram *prog, int *argcPtr,
Erik Andersen161220c2000-03-16 08:12:48 +0000764 int *argcAllocedPtr)
Erik Andersen3522eb12000-03-12 23:49:18 +0000765{
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000766 int argc_l = *argcPtr;
Erik Andersen161220c2000-03-16 08:12:48 +0000767 int argcAlloced = *argcAllocedPtr;
768 int rc;
769 int flags;
770 int i;
Eric Andersenb54833c2000-07-03 23:56:26 +0000771 char *src, *dst, *var;
Erik Andersen3522eb12000-03-12 23:49:18 +0000772
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000773 if (argc_l > 1) { /* cmd->globResult is already initialized */
Erik Andersen161220c2000-03-16 08:12:48 +0000774 flags = GLOB_APPEND;
775 i = prog->globResult.gl_pathc;
776 } else {
777 prog->freeGlob = 1;
778 flags = 0;
779 i = 0;
Erik Andersend75af992000-03-16 08:09:09 +0000780 }
Eric Andersenb54833c2000-07-03 23:56:26 +0000781 /* do shell variable substitution */
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000782 if(*prog->argv[argc_l - 1] == '$') {
783 if ((var = getenv(prog->argv[argc_l - 1] + 1))) {
784 prog->argv[argc_l - 1] = var;
785 }
786#ifdef BB_FEATURE_SH_ENVIRONMENT
787 else {
788 switch(*(prog->argv[argc_l - 1] + 1)) {
789 case '?':
790 prog->argv[argc_l - 1] = itoa(lastReturnCode);
791 break;
792 case '$':
793 prog->argv[argc_l - 1] = itoa(getpid());
794 break;
795 case '#':
796 prog->argv[argc_l - 1] = itoa(argc-1);
797 break;
798 case '!':
799 if (lastBgPid==-1)
800 *(prog->argv[argc_l - 1])='\0';
801 else
802 prog->argv[argc_l - 1] = itoa(lastBgPid);
803 break;
804 case '0':case '1':case '2':case '3':case '4':
805 case '5':case '6':case '7':case '8':case '9':
806 {
807 int index=*(prog->argv[argc_l - 1] + 1)-48;
808 if (index >= argc) {
809 *(prog->argv[argc_l - 1])='\0';
810 } else {
811 prog->argv[argc_l - 1] = argv[index];
812 }
813 }
814 break;
815 }
816 }
817#endif
818 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000819
Eric Andersen46f0beb2000-11-14 21:59:22 +0000820 if (strpbrk(prog->argv[argc_l - 1],"*[]?")!= NULL){
821 rc = glob(prog->argv[argc_l - 1], flags, NULL, &prog->globResult);
822 if (rc == GLOB_NOSPACE) {
823 errorMsg("out of space during glob operation\n");
824 return;
825 } else if (rc == GLOB_NOMATCH ||
Erik Andersen161220c2000-03-16 08:12:48 +0000826 (!rc && (prog->globResult.gl_pathc - i) == 1 &&
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000827 strcmp(prog->argv[argc_l - 1],
Eric Andersene92108a2000-07-26 00:53:56 +0000828 prog->globResult.gl_pathv[i]) == 0)) {
Eric Andersen46f0beb2000-11-14 21:59:22 +0000829 /* we need to remove whatever \ quoting is still present */
830 src = dst = prog->argv[argc_l - 1];
831 while (*src) {
Eric Andersen8c2d3f42000-11-30 00:03:57 +0000832 if (*src == '\\') {
833 src++;
834 *dst++ = process_escape_sequence(&src);
835 } else {
Eric Andersen46f0beb2000-11-14 21:59:22 +0000836 *dst++ = *src;
Eric Andersen8c2d3f42000-11-30 00:03:57 +0000837 src++;
838 }
Eric Andersen46f0beb2000-11-14 21:59:22 +0000839 }
840 *dst = '\0';
841 } else if (!rc) {
842 argcAlloced += (prog->globResult.gl_pathc - i);
843 prog->argv = xrealloc(prog->argv, argcAlloced * sizeof(*prog->argv));
844 memcpy(prog->argv + (argc_l - 1), prog->globResult.gl_pathv + i,
845 sizeof(*(prog->argv)) * (prog->globResult.gl_pathc - i));
846 argc_l += (prog->globResult.gl_pathc - i - 1);
Erik Andersen161220c2000-03-16 08:12:48 +0000847 }
Eric Andersen46f0beb2000-11-14 21:59:22 +0000848 }else{
849 src = dst = prog->argv[argc_l - 1];
850 while (*src) {
Eric Andersen8c2d3f42000-11-30 00:03:57 +0000851 if (*src == '\\') {
852 src++;
853 *dst++ = process_escape_sequence(&src);
854 } else {
Eric Andersen46f0beb2000-11-14 21:59:22 +0000855 *dst++ = *src;
Eric Andersen8c2d3f42000-11-30 00:03:57 +0000856 src++;
857 }
Eric Andersen46f0beb2000-11-14 21:59:22 +0000858 }
859 *dst = '\0';
Eric Andersen8c2d3f42000-11-30 00:03:57 +0000860
Eric Andersen46f0beb2000-11-14 21:59:22 +0000861 prog->globResult.gl_pathc=0;
862 if (flags==0)
863 prog->globResult.gl_pathv=NULL;
Erik Andersen161220c2000-03-16 08:12:48 +0000864 }
Erik Andersen161220c2000-03-16 08:12:48 +0000865 *argcAllocedPtr = argcAlloced;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000866 *argcPtr = argc_l;
Erik Andersen3522eb12000-03-12 23:49:18 +0000867}
868
869/* Return cmd->numProgs as 0 if no command is present (e.g. an empty
870 line). If a valid command is found, commandPtr is set to point to
871 the beginning of the next command (if the original command had more
872 then one job associated with it) or NULL if no more commands are
873 present. */
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000874static int parseCommand(char **commandPtr, struct job *job, struct jobSet *jobList, int *inBg)
Erik Andersen3522eb12000-03-12 23:49:18 +0000875{
Erik Andersen161220c2000-03-16 08:12:48 +0000876 char *command;
877 char *returnCommand = NULL;
878 char *src, *buf, *chptr;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000879 int argc_l = 0;
Erik Andersen161220c2000-03-16 08:12:48 +0000880 int done = 0;
881 int argvAlloced;
882 int i;
883 char quote = '\0';
884 int count;
885 struct childProgram *prog;
Erik Andersen3522eb12000-03-12 23:49:18 +0000886
Erik Andersen161220c2000-03-16 08:12:48 +0000887 /* skip leading white space */
888 while (**commandPtr && isspace(**commandPtr))
889 (*commandPtr)++;
Erik Andersen3522eb12000-03-12 23:49:18 +0000890
Erik Andersen161220c2000-03-16 08:12:48 +0000891 /* this handles empty lines or leading '#' characters */
892 if (!**commandPtr || (**commandPtr == '#')) {
Eric Andersenec10b9d2000-07-14 01:13:11 +0000893 job->numProgs=0;
Erik Andersen161220c2000-03-16 08:12:48 +0000894 return 0;
895 }
Erik Andersen3522eb12000-03-12 23:49:18 +0000896
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000897 *inBg = 0;
Erik Andersen161220c2000-03-16 08:12:48 +0000898 job->numProgs = 1;
Eric Andersenec10b9d2000-07-14 01:13:11 +0000899 job->progs = xmalloc(sizeof(*job->progs));
Erik Andersen3522eb12000-03-12 23:49:18 +0000900
Erik Andersen161220c2000-03-16 08:12:48 +0000901 /* We set the argv elements to point inside of this string. The
Eric Andersenb54833c2000-07-03 23:56:26 +0000902 memory is freed by freeJob(). Allocate twice the original
903 length in case we need to quote every single character.
Erik Andersen3522eb12000-03-12 23:49:18 +0000904
Erik Andersen161220c2000-03-16 08:12:48 +0000905 Getting clean memory relieves us of the task of NULL
906 terminating things and makes the rest of this look a bit
907 cleaner (though it is, admittedly, a tad less efficient) */
Matt Kraaib8907522000-09-13 02:08:21 +0000908 job->cmdBuf = command = xcalloc(2*strlen(*commandPtr) + 1, sizeof(char));
Erik Andersen161220c2000-03-16 08:12:48 +0000909 job->text = NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +0000910
Erik Andersen161220c2000-03-16 08:12:48 +0000911 prog = job->progs;
912 prog->numRedirections = 0;
913 prog->redirections = NULL;
914 prog->freeGlob = 0;
915 prog->isStopped = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +0000916
Erik Andersen161220c2000-03-16 08:12:48 +0000917 argvAlloced = 5;
Eric Andersenec10b9d2000-07-14 01:13:11 +0000918 prog->argv = xmalloc(sizeof(*prog->argv) * argvAlloced);
Erik Andersen161220c2000-03-16 08:12:48 +0000919 prog->argv[0] = job->cmdBuf;
Erik Andersen3522eb12000-03-12 23:49:18 +0000920
Erik Andersen161220c2000-03-16 08:12:48 +0000921 buf = command;
922 src = *commandPtr;
923 while (*src && !done) {
924 if (quote == *src) {
925 quote = '\0';
926 } else if (quote) {
927 if (*src == '\\') {
928 src++;
929 if (!*src) {
Matt Kraaid537a952000-07-14 01:51:25 +0000930 errorMsg("character expected after \\\n");
Erik Andersen161220c2000-03-16 08:12:48 +0000931 freeJob(job);
932 return 1;
933 }
934
935 /* in shell, "\'" should yield \' */
936 if (*src != quote)
937 *buf++ = '\\';
938 } else if (*src == '*' || *src == '?' || *src == '[' ||
939 *src == ']') *buf++ = '\\';
940 *buf++ = *src;
941 } else if (isspace(*src)) {
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000942 if (*prog->argv[argc_l]) {
943 buf++, argc_l++;
Erik Andersen161220c2000-03-16 08:12:48 +0000944 /* +1 here leaves room for the NULL which ends argv */
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000945 if ((argc_l + 1) == argvAlloced) {
Erik Andersen161220c2000-03-16 08:12:48 +0000946 argvAlloced += 5;
Matt Kraaib8907522000-09-13 02:08:21 +0000947 prog->argv = xrealloc(prog->argv,
948 sizeof(*prog->argv) *
949 argvAlloced);
Erik Andersen161220c2000-03-16 08:12:48 +0000950 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000951 globLastArgument(prog, &argc_l, &argvAlloced);
952 prog->argv[argc_l] = buf;
Erik Andersen161220c2000-03-16 08:12:48 +0000953 }
954 } else
955 switch (*src) {
956 case '"':
957 case '\'':
958 quote = *src;
959 break;
960
961 case '#': /* comment */
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000962 if (*(src-1)== '$')
963 *buf++ = *src;
964 else
965 done = 1;
Erik Andersen161220c2000-03-16 08:12:48 +0000966 break;
967
968 case '>': /* redirections */
969 case '<':
970 i = prog->numRedirections++;
Matt Kraaib8907522000-09-13 02:08:21 +0000971 prog->redirections = xrealloc(prog->redirections,
972 sizeof(*prog->redirections) *
973 (i + 1));
Erik Andersen161220c2000-03-16 08:12:48 +0000974
975 prog->redirections[i].fd = -1;
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000976 if (buf != prog->argv[argc_l]) {
Erik Andersen161220c2000-03-16 08:12:48 +0000977 /* the stuff before this character may be the file number
978 being redirected */
979 prog->redirections[i].fd =
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000980 strtol(prog->argv[argc_l], &chptr, 10);
Erik Andersen161220c2000-03-16 08:12:48 +0000981
Eric Andersen6a99aaf2000-07-27 00:15:20 +0000982 if (*chptr && *prog->argv[argc_l]) {
983 buf++, argc_l++;
984 globLastArgument(prog, &argc_l, &argvAlloced);
985 prog->argv[argc_l] = buf;
Erik Andersen161220c2000-03-16 08:12:48 +0000986 }
987 }
988
989 if (prog->redirections[i].fd == -1) {
990 if (*src == '>')
991 prog->redirections[i].fd = 1;
992 else
993 prog->redirections[i].fd = 0;
994 }
995
996 if (*src++ == '>') {
997 if (*src == '>')
998 prog->redirections[i].type =
999 REDIRECT_APPEND, src++;
1000 else
1001 prog->redirections[i].type = REDIRECT_OVERWRITE;
1002 } else {
1003 prog->redirections[i].type = REDIRECT_INPUT;
1004 }
1005
1006 /* This isn't POSIX sh compliant. Oh well. */
1007 chptr = src;
1008 while (isspace(*chptr))
1009 chptr++;
1010
1011 if (!*chptr) {
Matt Kraaid537a952000-07-14 01:51:25 +00001012 errorMsg("file name expected after %c\n", *src);
Erik Andersen161220c2000-03-16 08:12:48 +00001013 freeJob(job);
Eric Andersenec10b9d2000-07-14 01:13:11 +00001014 job->numProgs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001015 return 1;
1016 }
1017
1018 prog->redirections[i].filename = buf;
1019 while (*chptr && !isspace(*chptr))
1020 *buf++ = *chptr++;
1021
1022 src = chptr - 1; /* we src++ later */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001023 prog->argv[argc_l] = ++buf;
Erik Andersen161220c2000-03-16 08:12:48 +00001024 break;
1025
1026 case '|': /* pipe */
1027 /* finish this command */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001028 if (*prog->argv[argc_l])
1029 argc_l++;
1030 if (!argc_l) {
Eric Andersena1d187a2000-07-17 19:14:41 +00001031 errorMsg("empty command in pipe\n");
Erik Andersen161220c2000-03-16 08:12:48 +00001032 freeJob(job);
Eric Andersenec10b9d2000-07-14 01:13:11 +00001033 job->numProgs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001034 return 1;
1035 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001036 prog->argv[argc_l] = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001037
1038 /* and start the next */
1039 job->numProgs++;
Matt Kraaib8907522000-09-13 02:08:21 +00001040 job->progs = xrealloc(job->progs,
1041 sizeof(*job->progs) * job->numProgs);
Erik Andersen161220c2000-03-16 08:12:48 +00001042 prog = job->progs + (job->numProgs - 1);
1043 prog->numRedirections = 0;
1044 prog->redirections = NULL;
1045 prog->freeGlob = 0;
Eric Andersen501c88b2000-07-28 15:14:45 +00001046 prog->isStopped = 0;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001047 argc_l = 0;
Erik Andersen161220c2000-03-16 08:12:48 +00001048
1049 argvAlloced = 5;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001050 prog->argv = xmalloc(sizeof(*prog->argv) * argvAlloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001051 prog->argv[0] = ++buf;
1052
1053 src++;
1054 while (*src && isspace(*src))
1055 src++;
1056
1057 if (!*src) {
Eric Andersena1d187a2000-07-17 19:14:41 +00001058 errorMsg("empty command in pipe\n");
Eric Andersenec10b9d2000-07-14 01:13:11 +00001059 freeJob(job);
1060 job->numProgs=0;
Erik Andersen161220c2000-03-16 08:12:48 +00001061 return 1;
1062 }
1063 src--; /* we'll ++ it at the end of the loop */
1064
1065 break;
1066
1067 case '&': /* background */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001068 *inBg = 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001069 case ';': /* multiple commands */
1070 done = 1;
1071 returnCommand = *commandPtr + (src - *commandPtr) + 1;
1072 break;
1073
Eric Andersena1d187a2000-07-17 19:14:41 +00001074#ifdef BB_FEATURE_SH_BACKTICKS
Eric Andersenec10b9d2000-07-14 01:13:11 +00001075 case '`':
1076 /* Exec a backtick-ed command */
1077 {
Eric Andersena1d187a2000-07-17 19:14:41 +00001078 char* charptr1=NULL, *charptr2;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001079 char* ptr=NULL;
Eric Andersena1d187a2000-07-17 19:14:41 +00001080 struct job *newJob;
1081 struct jobSet njobList = { NULL, NULL };
1082 int pipefd[2];
1083 int size;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001084
1085 ptr=strchr(++src, '`');
1086 if (ptr==NULL) {
1087 fprintf(stderr, "Unmatched '`' in command\n");
1088 freeJob(job);
1089 return 1;
1090 }
1091
Eric Andersena1d187a2000-07-17 19:14:41 +00001092 /* Make some space to hold just the backticked command */
Eric Andersen6efc48c2000-07-18 08:16:39 +00001093 charptr1 = charptr2 = xmalloc(1+ptr-src);
Matt Kraai0b2da462000-09-19 06:46:44 +00001094 memcpy(charptr1, src, ptr-src);
1095 charptr1[ptr-src] = '\0';
Eric Andersena1d187a2000-07-17 19:14:41 +00001096 newJob = xmalloc(sizeof(struct job));
1097 /* Now parse and run the backticked command */
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001098 if (!parseCommand(&charptr1, newJob, &njobList, inBg)
Eric Andersena1d187a2000-07-17 19:14:41 +00001099 && newJob->numProgs) {
1100 pipe(pipefd);
1101 runCommand(newJob, &njobList, 0, pipefd);
Eric Andersenec10b9d2000-07-14 01:13:11 +00001102 }
Eric Andersena1d187a2000-07-17 19:14:41 +00001103 checkJobs(jobList);
Eric Andersen6efc48c2000-07-18 08:16:39 +00001104 freeJob(newJob);
1105 free(charptr2);
1106
1107 /* Make a copy of any stuff left over in the command
1108 * line after the second backtick */
1109 charptr2 = xmalloc(strlen(ptr)+1);
1110 memcpy(charptr2, ptr+1, strlen(ptr));
1111
Eric Andersenec10b9d2000-07-14 01:13:11 +00001112
Eric Andersena1d187a2000-07-17 19:14:41 +00001113 /* Copy the output from the backtick-ed command into the
1114 * command line, making extra room as needed */
1115 --src;
1116 charptr1 = xmalloc(BUFSIZ);
1117 while ( (size=fullRead(pipefd[0], charptr1, BUFSIZ-1)) >0) {
1118 int newSize=src - *commandPtr + size + 1 + strlen(charptr2);
1119 if (newSize > BUFSIZ) {
Matt Kraaib8907522000-09-13 02:08:21 +00001120 *commandPtr=xrealloc(*commandPtr, src - *commandPtr +
Eric Andersena1d187a2000-07-17 19:14:41 +00001121 size + 1 + strlen(charptr2));
1122 }
1123 memcpy(src, charptr1, size);
1124 src+=size;
1125 }
1126 free(charptr1);
1127 close(pipefd[0]);
1128 if (*(src-1)=='\n')
1129 --src;
1130
1131 /* Now paste into the *commandPtr all the stuff
1132 * leftover after the second backtick */
Matt Kraaicbbe4d62000-09-14 00:26:50 +00001133 memcpy(src, charptr2, strlen(charptr2)+1);
Eric Andersena1d187a2000-07-17 19:14:41 +00001134 free(charptr2);
1135
Eric Andersena1d187a2000-07-17 19:14:41 +00001136 /* Now recursively call parseCommand to deal with the new
1137 * and improved version of the command line with the backtick
1138 * results expanded in place... */
Eric Andersen6efc48c2000-07-18 08:16:39 +00001139 freeJob(job);
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001140 return(parseCommand(commandPtr, job, jobList, inBg));
Eric Andersenec10b9d2000-07-14 01:13:11 +00001141 }
1142 break;
Eric Andersena1d187a2000-07-17 19:14:41 +00001143#endif // BB_FEATURE_SH_BACKTICKS
Matt Kraai131241f2000-09-14 00:43:20 +00001144
1145 case '\\':
1146 src++;
1147 if (!*src) {
1148 errorMsg("character expected after \\\n");
1149 freeJob(job);
1150 return 1;
1151 }
1152 if (*src == '*' || *src == '[' || *src == ']'
1153 || *src == '?') *buf++ = '\\';
1154 /* fallthrough */
Erik Andersen161220c2000-03-16 08:12:48 +00001155 default:
1156 *buf++ = *src;
1157 }
1158
Erik Andersend75af992000-03-16 08:09:09 +00001159 src++;
Erik Andersen161220c2000-03-16 08:12:48 +00001160 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001161
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001162 if (*prog->argv[argc_l]) {
1163 argc_l++;
1164 globLastArgument(prog, &argc_l, &argvAlloced);
Erik Andersen161220c2000-03-16 08:12:48 +00001165 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001166 if (!argc_l) {
Erik Andersen161220c2000-03-16 08:12:48 +00001167 freeJob(job);
1168 return 0;
1169 }
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001170 prog->argv[argc_l] = NULL;
Erik Andersen3522eb12000-03-12 23:49:18 +00001171
Erik Andersen161220c2000-03-16 08:12:48 +00001172 if (!returnCommand) {
Eric Andersenec10b9d2000-07-14 01:13:11 +00001173 job->text = xmalloc(strlen(*commandPtr) + 1);
Erik Andersen161220c2000-03-16 08:12:48 +00001174 strcpy(job->text, *commandPtr);
1175 } else {
1176 /* This leaves any trailing spaces, which is a bit sloppy */
Erik Andersen161220c2000-03-16 08:12:48 +00001177 count = returnCommand - *commandPtr;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001178 job->text = xmalloc(count + 1);
Erik Andersen161220c2000-03-16 08:12:48 +00001179 strncpy(job->text, *commandPtr, count);
1180 job->text[count] = '\0';
1181 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001182
Erik Andersen161220c2000-03-16 08:12:48 +00001183 *commandPtr = returnCommand;
Eric Andersen46f0beb2000-11-14 21:59:22 +00001184
Erik Andersend75af992000-03-16 08:09:09 +00001185 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001186}
1187
Eric Andersena1d187a2000-07-17 19:14:41 +00001188static int runCommand(struct job *newJob, struct jobSet *jobList, int inBg, int outPipe[2])
Erik Andersen3522eb12000-03-12 23:49:18 +00001189{
Eric Andersenfad9c112000-07-25 18:06:52 +00001190 struct job *theJob;
Erik Andersen161220c2000-03-16 08:12:48 +00001191 int i;
Eric Andersen6efc48c2000-07-18 08:16:39 +00001192 int nextin, nextout;
Erik Andersen161220c2000-03-16 08:12:48 +00001193 int pipefds[2]; /* pipefd[0] is for reading */
1194 struct builtInCommand *x;
Eric Andersenb54833c2000-07-03 23:56:26 +00001195#ifdef BB_FEATURE_SH_STANDALONE_SHELL
Eric Andersena683ee82000-11-17 18:51:45 +00001196 struct BB_applet search_applet, *applet;
Erik Andersenbcd61772000-05-13 06:33:19 +00001197#endif
Erik Andersen3522eb12000-03-12 23:49:18 +00001198
Eric Andersen6efc48c2000-07-18 08:16:39 +00001199 nextin = 0, nextout = 1;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001200 for (i = 0; i < newJob->numProgs; i++) {
1201 if ((i + 1) < newJob->numProgs) {
Erik Andersen161220c2000-03-16 08:12:48 +00001202 pipe(pipefds);
1203 nextout = pipefds[1];
1204 } else {
Eric Andersen6efc48c2000-07-18 08:16:39 +00001205 if (outPipe[1]!=-1) {
1206 nextout = outPipe[1];
1207 } else {
1208 nextout = 1;
1209 }
Erik Andersen161220c2000-03-16 08:12:48 +00001210 }
1211
Eric Andersen501c88b2000-07-28 15:14:45 +00001212#ifdef BB_FEATURE_SH_ENVIRONMENT
1213 if (showXtrace==TRUE) {
1214 int j;
1215 fprintf(stderr, "+ ");
1216 for (j = 0; newJob->progs[i].argv[j]; j++)
1217 fprintf(stderr, "%s ", newJob->progs[i].argv[j]);
1218 fprintf(stderr, "\n");
1219 }
1220#endif
1221
Eric Andersen34e19412000-07-10 18:47:24 +00001222 /* Check if the command matches any non-forking builtins */
Erik Andersen330fd2b2000-05-19 05:35:19 +00001223 for (x = bltins; x->cmd; x++) {
Eric Andersene92108a2000-07-26 00:53:56 +00001224 if (strcmp(newJob->progs[i].argv[0], x->cmd) == 0 ) {
Eric Andersen501c88b2000-07-28 15:14:45 +00001225 return(x->function(newJob, jobList));
Erik Andersen330fd2b2000-05-19 05:35:19 +00001226 }
1227 }
1228
Eric Andersenec10b9d2000-07-14 01:13:11 +00001229 if (!(newJob->progs[i].pid = fork())) {
Erik Andersen161220c2000-03-16 08:12:48 +00001230 signal(SIGTTOU, SIG_DFL);
1231
Eric Andersena1d187a2000-07-17 19:14:41 +00001232 if (outPipe[1]!=-1) {
1233 close(outPipe[0]);
Eric Andersen6efc48c2000-07-18 08:16:39 +00001234 }
1235 if (nextin != 0) {
1236 dup2(nextin, 0);
1237 close(nextin);
1238 }
1239
1240 if (nextout != 1) {
Erik Andersen161220c2000-03-16 08:12:48 +00001241 dup2(nextout, 1);
Eric Andersena1d187a2000-07-17 19:14:41 +00001242 dup2(nextout, 2);
Erik Andersen161220c2000-03-16 08:12:48 +00001243 close(nextout);
Eric Andersen501c88b2000-07-28 15:14:45 +00001244 close(pipefds[0]);
Erik Andersen161220c2000-03-16 08:12:48 +00001245 }
1246
1247 /* explicit redirections override pipes */
Eric Andersenec10b9d2000-07-14 01:13:11 +00001248 setupRedirections(newJob->progs + i);
Erik Andersen161220c2000-03-16 08:12:48 +00001249
Eric Andersen34e19412000-07-10 18:47:24 +00001250 /* Check if the command matches any of the other builtins */
Erik Andersen330fd2b2000-05-19 05:35:19 +00001251 for (x = bltins_forking; x->cmd; x++) {
Eric Andersene92108a2000-07-26 00:53:56 +00001252 if (strcmp(newJob->progs[i].argv[0], x->cmd) == 0) {
Eric Andersen501c88b2000-07-28 15:14:45 +00001253 applet_name=x->cmd;
Eric Andersenec10b9d2000-07-14 01:13:11 +00001254 exit (x->function(newJob, jobList));
Erik Andersenbcd61772000-05-13 06:33:19 +00001255 }
1256 }
Eric Andersenb54833c2000-07-03 23:56:26 +00001257#ifdef BB_FEATURE_SH_STANDALONE_SHELL
Eric Andersene5aef922000-11-17 18:25:26 +00001258 /* Check if the command matches any busybox internal
1259 * commands ("applets") here. Following discussions from
1260 * November 2000 on busybox@opensource.lineo.com, don't use
1261 * get_last_path_component(). This way explicit (with
1262 * slashes) filenames will never be interpreted as an
1263 * applet, just like with builtins. This way the user can
1264 * override an applet with an explicit filename reference.
1265 * The only downside to this change is that an explicit
1266 * /bin/foo invocation fill fork and exec /bin/foo, even if
1267 * /bin/foo is a symlink to busybox.
1268 */
1269 search_applet.name = newJob->progs[i].argv[0];
1270
Eric Andersen1d3523b2000-12-06 19:07:39 +00001271#ifdef BB_FEATURE_SH_APPLETS_ALWAYS_WIN
1272 /* If you enable BB_FEATURE_SH_APPLETS_ALWAYS_WIN, then
Eric Andersene5aef922000-11-17 18:25:26 +00001273 * if you run /bin/cat, it will use BusyBox cat even if
1274 * /bin/cat exists on the filesystem and is _not_ busybox.
1275 * Some systems want this, others do not. Choose wisely. :-)
1276 */
1277 search_applet.name = get_last_path_component(search_applet.name);
Eric Andersen50b31132000-11-17 18:07:30 +00001278#endif
Eric Andersene5aef922000-11-17 18:25:26 +00001279
1280 /* Do a binary search to find the applet entry given the name. */
1281 applet = bsearch(&search_applet, applets, NUM_APPLETS,
1282 sizeof(struct BB_applet), applet_name_compare);
1283 if (applet != NULL) {
1284 int argc_l;
1285 char** argv=newJob->progs[i].argv;
1286 for(argc_l=0;*argv!=NULL; argv++, argc_l++);
1287 applet_name=applet->name;
1288 optind = 1;
1289 exit((*(applet->main)) (argc_l, newJob->progs[i].argv));
Erik Andersenbcd61772000-05-13 06:33:19 +00001290 }
1291#endif
1292
Eric Andersenec10b9d2000-07-14 01:13:11 +00001293 execvp(newJob->progs[i].argv[0], newJob->progs[i].argv);
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001294 fatalError("%s: %s\n", newJob->progs[i].argv[0],
Eric Andersene5aef922000-11-17 18:25:26 +00001295 strerror(errno));
Erik Andersen161220c2000-03-16 08:12:48 +00001296 }
Eric Andersen6efc48c2000-07-18 08:16:39 +00001297 if (outPipe[1]!=-1) {
Eric Andersena1d187a2000-07-17 19:14:41 +00001298 close(outPipe[1]);
1299 }
Erik Andersen161220c2000-03-16 08:12:48 +00001300
1301 /* put our child in the process group whose leader is the
1302 first process in this pipe */
Eric Andersenec10b9d2000-07-14 01:13:11 +00001303 setpgid(newJob->progs[i].pid, newJob->progs[0].pid);
Erik Andersen161220c2000-03-16 08:12:48 +00001304 if (nextin != 0)
1305 close(nextin);
Eric Andersen6efc48c2000-07-18 08:16:39 +00001306 if (nextout != 1)
Erik Andersen161220c2000-03-16 08:12:48 +00001307 close(nextout);
1308
1309 /* If there isn't another process, nextin is garbage
1310 but it doesn't matter */
1311 nextin = pipefds[0];
1312 }
1313
Eric Andersenec10b9d2000-07-14 01:13:11 +00001314 newJob->pgrp = newJob->progs[0].pid;
Erik Andersen161220c2000-03-16 08:12:48 +00001315
Eric Andersenfad9c112000-07-25 18:06:52 +00001316 /* find the ID for the theJob to use */
Eric Andersenec10b9d2000-07-14 01:13:11 +00001317 newJob->jobId = 1;
Eric Andersenfad9c112000-07-25 18:06:52 +00001318 for (theJob = jobList->head; theJob; theJob = theJob->next)
1319 if (theJob->jobId >= newJob->jobId)
1320 newJob->jobId = theJob->jobId + 1;
Erik Andersen161220c2000-03-16 08:12:48 +00001321
Eric Andersenfad9c112000-07-25 18:06:52 +00001322 /* add the theJob to the list of running jobs */
Erik Andersen161220c2000-03-16 08:12:48 +00001323 if (!jobList->head) {
Matt Kraaib8907522000-09-13 02:08:21 +00001324 theJob = jobList->head = xmalloc(sizeof(*theJob));
Erik Andersend75af992000-03-16 08:09:09 +00001325 } else {
Eric Andersenfad9c112000-07-25 18:06:52 +00001326 for (theJob = jobList->head; theJob->next; theJob = theJob->next);
Matt Kraaib8907522000-09-13 02:08:21 +00001327 theJob->next = xmalloc(sizeof(*theJob));
Eric Andersenfad9c112000-07-25 18:06:52 +00001328 theJob = theJob->next;
Erik Andersend75af992000-03-16 08:09:09 +00001329 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001330
Eric Andersenfad9c112000-07-25 18:06:52 +00001331 *theJob = *newJob;
1332 theJob->next = NULL;
1333 theJob->runningProgs = theJob->numProgs;
1334 theJob->stoppedProgs = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001335
Erik Andersen161220c2000-03-16 08:12:48 +00001336 if (inBg) {
Eric Andersenfad9c112000-07-25 18:06:52 +00001337 /* we don't wait for background theJobs to return -- append it
1338 to the list of backgrounded theJobs and leave it alone */
1339 printf("[%d] %d\n", theJob->jobId,
Eric Andersenec10b9d2000-07-14 01:13:11 +00001340 newJob->progs[newJob->numProgs - 1].pid);
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001341#ifdef BB_FEATURE_SH_ENVIRONMENT
1342 lastBgPid=newJob->progs[newJob->numProgs - 1].pid;
1343#endif
Erik Andersen161220c2000-03-16 08:12:48 +00001344 } else {
Eric Andersenfad9c112000-07-25 18:06:52 +00001345 jobList->fg = theJob;
Erik Andersen3522eb12000-03-12 23:49:18 +00001346
Erik Andersen161220c2000-03-16 08:12:48 +00001347 /* move the new process group into the foreground */
Eric Andersen1c314ad2000-06-28 16:56:25 +00001348 /* suppress messages when run from /linuxrc mag@sysgo.de */
Eric Andersenec10b9d2000-07-14 01:13:11 +00001349 if (tcsetpgrp(0, newJob->pgrp) && errno != ENOTTY)
Erik Andersen161220c2000-03-16 08:12:48 +00001350 perror("tcsetpgrp");
Erik Andersend75af992000-03-16 08:09:09 +00001351 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001352
Erik Andersen161220c2000-03-16 08:12:48 +00001353 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001354}
1355
Erik Andersend75af992000-03-16 08:09:09 +00001356static int busy_loop(FILE * input)
Erik Andersen3522eb12000-03-12 23:49:18 +00001357{
Erik Andersen161220c2000-03-16 08:12:48 +00001358 char *command;
1359 char *nextCommand = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001360 struct job newJob;
Eric Andersen1c314ad2000-06-28 16:56:25 +00001361 pid_t parent_pgrp;
Erik Andersen161220c2000-03-16 08:12:48 +00001362 int i;
Erik Andersen161220c2000-03-16 08:12:48 +00001363 int inBg;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001364 int status;
1365 newJob.jobContext = REGULAR_JOB_CONTEXT;
Erik Andersen3522eb12000-03-12 23:49:18 +00001366
Eric Andersen1c314ad2000-06-28 16:56:25 +00001367 /* save current owner of TTY so we can restore it on exit */
1368 parent_pgrp = tcgetpgrp(0);
1369
Matt Kraaib8907522000-09-13 02:08:21 +00001370 command = (char *) xcalloc(BUFSIZ, sizeof(char));
Erik Andersend75af992000-03-16 08:09:09 +00001371
Erik Andersen161220c2000-03-16 08:12:48 +00001372 /* don't pay any attention to this signal; it just confuses
1373 things and isn't really meant for shells anyway */
1374 signal(SIGTTOU, SIG_IGN);
Erik Andersend75af992000-03-16 08:09:09 +00001375
Erik Andersen161220c2000-03-16 08:12:48 +00001376 while (1) {
Erik Andersend75af992000-03-16 08:09:09 +00001377 if (!jobList.fg) {
1378 /* no job is in the foreground */
Erik Andersen3522eb12000-03-12 23:49:18 +00001379
Erik Andersend75af992000-03-16 08:09:09 +00001380 /* see if any background processes have exited */
1381 checkJobs(&jobList);
Erik Andersen3522eb12000-03-12 23:49:18 +00001382
Erik Andersend75af992000-03-16 08:09:09 +00001383 if (!nextCommand) {
Erik Andersen161220c2000-03-16 08:12:48 +00001384 if (getCommand(input, command))
1385 break;
1386 nextCommand = command;
Erik Andersend75af992000-03-16 08:09:09 +00001387 }
Erik Andersen3522eb12000-03-12 23:49:18 +00001388
Eric Andersenec10b9d2000-07-14 01:13:11 +00001389 if (!parseCommand(&nextCommand, &newJob, &jobList, &inBg) &&
Erik Andersen161220c2000-03-16 08:12:48 +00001390 newJob.numProgs) {
Eric Andersena1d187a2000-07-17 19:14:41 +00001391 int pipefds[2] = {-1,-1};
1392 runCommand(&newJob, &jobList, inBg, pipefds);
Eric Andersenfad9c112000-07-25 18:06:52 +00001393 }
1394 else {
Eric Andersena1d187a2000-07-17 19:14:41 +00001395 free(command);
Matt Kraaib8907522000-09-13 02:08:21 +00001396 command = (char *) xcalloc(BUFSIZ, sizeof(char));
Eric Andersen6efc48c2000-07-18 08:16:39 +00001397 nextCommand = NULL;
Erik Andersend75af992000-03-16 08:09:09 +00001398 }
1399 } else {
1400 /* a job is running in the foreground; wait for it */
1401 i = 0;
1402 while (!jobList.fg->progs[i].pid ||
Eric Andersenfad9c112000-07-25 18:06:52 +00001403 jobList.fg->progs[i].isStopped == 1) i++;
Erik Andersen3522eb12000-03-12 23:49:18 +00001404
Erik Andersend75af992000-03-16 08:09:09 +00001405 waitpid(jobList.fg->progs[i].pid, &status, WUNTRACED);
Erik Andersen3522eb12000-03-12 23:49:18 +00001406
Erik Andersend75af992000-03-16 08:09:09 +00001407 if (WIFEXITED(status) || WIFSIGNALED(status)) {
Erik Andersen161220c2000-03-16 08:12:48 +00001408 /* the child exited */
1409 jobList.fg->runningProgs--;
1410 jobList.fg->progs[i].pid = 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001411
Eric Andersen501c88b2000-07-28 15:14:45 +00001412#ifdef BB_FEATURE_SH_ENVIRONMENT
1413 lastReturnCode=WEXITSTATUS(status);
1414#endif
Eric Andersenb558e762000-11-30 22:43:16 +00001415 debug_printf("'%s' exited -- return code %d\n", jobList.fg->text, lastReturnCode);
Erik Andersen161220c2000-03-16 08:12:48 +00001416 if (!jobList.fg->runningProgs) {
1417 /* child exited */
Erik Andersen3522eb12000-03-12 23:49:18 +00001418
Erik Andersen161220c2000-03-16 08:12:48 +00001419 removeJob(&jobList, jobList.fg);
1420 jobList.fg = NULL;
Erik Andersen161220c2000-03-16 08:12:48 +00001421 }
Erik Andersend75af992000-03-16 08:09:09 +00001422 } else {
Erik Andersen161220c2000-03-16 08:12:48 +00001423 /* the child was stopped */
1424 jobList.fg->stoppedProgs++;
1425 jobList.fg->progs[i].isStopped = 1;
Erik Andersen3522eb12000-03-12 23:49:18 +00001426
Erik Andersen161220c2000-03-16 08:12:48 +00001427 if (jobList.fg->stoppedProgs == jobList.fg->runningProgs) {
1428 printf("\n" JOB_STATUS_FORMAT, jobList.fg->jobId,
1429 "Stopped", jobList.fg->text);
1430 jobList.fg = NULL;
1431 }
Erik Andersend75af992000-03-16 08:09:09 +00001432 }
1433
1434 if (!jobList.fg) {
Erik Andersen161220c2000-03-16 08:12:48 +00001435 /* move the shell to the foreground */
Eric Andersen1c314ad2000-06-28 16:56:25 +00001436 /* suppress messages when run from /linuxrc mag@sysgo.de */
1437 if (tcsetpgrp(0, getpid()) && errno != ENOTTY)
1438 perror("tcsetpgrp");
Erik Andersend75af992000-03-16 08:09:09 +00001439 }
1440 }
1441 }
Erik Andersen161220c2000-03-16 08:12:48 +00001442 free(command);
Erik Andersen3522eb12000-03-12 23:49:18 +00001443
Eric Andersen1c314ad2000-06-28 16:56:25 +00001444 /* return controlling TTY back to parent process group before exiting */
1445 if (tcsetpgrp(0, parent_pgrp))
Eric Andersenb54833c2000-07-03 23:56:26 +00001446 perror("tcsetpgrp");
1447
1448 /* return exit status if called with "-c" */
1449 if (input == NULL && WIFEXITED(status))
1450 return WEXITSTATUS(status);
1451
Erik Andersen161220c2000-03-16 08:12:48 +00001452 return 0;
Erik Andersen3522eb12000-03-12 23:49:18 +00001453}
1454
1455
Eric Andersenfad9c112000-07-25 18:06:52 +00001456#ifdef BB_FEATURE_CLEAN_UP
1457void free_memory(void)
1458{
1459 if (promptStr)
1460 free(promptStr);
1461 if (cwd)
1462 free(cwd);
1463 if (local_pending_command)
1464 free(local_pending_command);
1465
1466 if (jobList.fg && !jobList.fg->runningProgs) {
1467 removeJob(&jobList, jobList.fg);
1468 }
1469}
1470#endif
1471
Eric Andersen6efc48c2000-07-18 08:16:39 +00001472
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001473int shell_main(int argc_l, char **argv_l)
Erik Andersen3522eb12000-03-12 23:49:18 +00001474{
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001475 int opt, interactive=FALSE;
Erik Andersen161220c2000-03-16 08:12:48 +00001476 FILE *input = stdin;
Eric Andersen6a99aaf2000-07-27 00:15:20 +00001477 argc = argc_l;
1478 argv = argv_l;
Erik Andersen3522eb12000-03-12 23:49:18 +00001479
Eric Andersen501c88b2000-07-28 15:14:45 +00001480
Eric Andersenb558e762000-11-30 22:43:16 +00001481 if (argv[0] && argv[0][0] == '-') {
1482 FILE *input;
1483 input = fopen("/etc/profile", "r");
1484 if (!input) {
1485 fprintf(stdout, "Couldn't open file '/etc/profile'\n");
1486 } else {
1487 /* Now run the file */
1488 busy_loop(input);
1489 fclose(input);
1490 }
1491 }
Eric Andersen501c88b2000-07-28 15:14:45 +00001492
Matt Kraai6085c722000-09-06 01:46:18 +00001493 while ((opt = getopt(argc_l, argv_l, "cx")) > 0) {
Eric Andersen501c88b2000-07-28 15:14:45 +00001494 switch (opt) {
1495 case 'c':
1496 input = NULL;
Matt Kraai6085c722000-09-06 01:46:18 +00001497 if (local_pending_command != 0)
1498 fatalError("multiple -c arguments\n");
1499 local_pending_command = xstrdup(argv[optind]);
1500 optind++;
1501 argv = argv+optind;
Eric Andersen501c88b2000-07-28 15:14:45 +00001502 break;
Eric Andersen1428c4f2000-07-28 15:19:30 +00001503#ifdef BB_FEATURE_SH_ENVIRONMENT
Eric Andersen501c88b2000-07-28 15:14:45 +00001504 case 'x':
1505 showXtrace = TRUE;
1506 break;
Eric Andersen1428c4f2000-07-28 15:19:30 +00001507#endif
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001508 case 'i':
1509 interactive = TRUE;
1510 break;
Eric Andersen501c88b2000-07-28 15:14:45 +00001511 default:
1512 usage(shell_usage);
1513 }
1514 }
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001515 /* A shell is interactive if the `-i' flag was given, or if all of
1516 * the following conditions are met:
1517 * no -c command
1518 * no arguments remaining or the -s flag given
1519 * standard input is a terminal
1520 * standard output is a terminal
1521 * Refer to Posix.2, the description of the `sh' utility. */
1522 if (interactive==TRUE || ( argv[optind]==NULL && input==stdin && isatty(fileno(stdin)) && isatty(fileno(stdout)))) {
Eric Andersen851ce892000-08-21 22:34:23 +00001523 //fprintf(stdout, "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
Eric Andersen501c88b2000-07-28 15:14:45 +00001524 /* Looks like they want an interactive shell */
1525 fprintf(stdout, "\n\nBusyBox v%s (%s) Built-in shell\n", BB_VER, BB_BT);
1526 fprintf(stdout, "Enter 'help' for a list of built-in commands.\n\n");
Eric Andersen6a4c33c2000-07-28 17:08:36 +00001527 } else if (local_pending_command==NULL) {
Eric Andersen851ce892000-08-21 22:34:23 +00001528 //fprintf(stdout, "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
Matt Kraaibbaef662000-09-27 02:43:35 +00001529 input = xfopen(argv[optind], "r");
Eric Andersen501c88b2000-07-28 15:14:45 +00001530 }
1531
Eric Andersen6efc48c2000-07-18 08:16:39 +00001532 /* initialize the cwd -- this is never freed...*/
1533 cwd=(char*)xmalloc(sizeof(char)*MAX_LINE+1);
1534 getcwd(cwd, sizeof(char)*MAX_LINE);
Erik Andersen3522eb12000-03-12 23:49:18 +00001535
Eric Andersenfad9c112000-07-25 18:06:52 +00001536#ifdef BB_FEATURE_CLEAN_UP
1537 atexit(free_memory);
1538#endif
1539
Erik Andersenf0657d32000-04-12 17:49:52 +00001540 win_changed(0);
Erik Andersen161220c2000-03-16 08:12:48 +00001541 return (busy_loop(input));
Erik Andersen3522eb12000-03-12 23:49:18 +00001542}