busybox/shell/lash.c
Eric Andersen 2d848a476a This should finish off the job control issues with lash. Make certain
we have a controlling terminal...
 -Erik
2001-06-25 17:11:54 +00:00

1422 lines
35 KiB
C

/* vi: set sw=4 ts=4: */
/*
* lash -- the BusyBox Lame-Ass SHell
*
* Copyright (C) 1999,2000,2001 by Lineo, inc.
* Written by Erik Andersen <andersen@lineo.com>, <andersee@debian.org>
*
* Based in part on ladsh.c by Michael K. Johnson and Erik W. Troan, which is
* under the following liberal license: "We have placed this source code in the
* public domain. Use it in any project, free or commercial."
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
/* This shell's parsing engine is officially at a dead-end.
* Future work shell work should be done using hush.c
*/
//For debugging/development on the shell only...
//#define DEBUG_SHELL
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <unistd.h>
#include <getopt.h>
#include <termios.h>
#include "busybox.h"
#include "cmdedit.h"
#ifdef BB_LOCALE_SUPPORT
#include <locale.h>
#endif
#include <glob.h>
#define expand_t glob_t
static const int MAX_READ = 128; /* size of input buffer for `read' builtin */
#define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
enum redir_type { REDIRECT_INPUT, REDIRECT_OVERWRITE,
REDIRECT_APPEND
};
static const unsigned int DEFAULT_CONTEXT=0x1;
static const unsigned int IF_TRUE_CONTEXT=0x2;
static const unsigned int IF_FALSE_CONTEXT=0x4;
static const unsigned int THEN_EXP_CONTEXT=0x8;
static const unsigned int ELSE_EXP_CONTEXT=0x10;
struct jobset {
struct job *head; /* head of list of running jobs */
struct job *fg; /* current foreground job */
};
struct redir_struct {
enum redir_type type; /* type of redirection */
int fd; /* file descriptor being redirected */
char *filename; /* file to redirect fd to */
};
struct child_prog {
pid_t pid; /* 0 if exited */
char **argv; /* program name and arguments */
int num_redirects; /* elements in redirection array */
struct redir_struct *redirects; /* I/O redirects */
int is_stopped; /* is the program currently running? */
struct job *family; /* pointer back to the child's parent job */
};
struct job {
int jobid; /* job number */
int num_progs; /* total number of programs in job */
int running_progs; /* number of programs running */
char *text; /* name of job */
char *cmdbuf; /* buffer various argv's point into */
pid_t pgrp; /* process group ID for the job */
struct child_prog *progs; /* array of programs in job */
struct job *next; /* to track background commands */
int stopped_progs; /* number of programs alive, but stopped */
unsigned int job_context; /* bitmask defining current context */
struct jobset *job_list;
};
struct built_in_command {
char *cmd; /* name */
char *descr; /* description */
int (*function) (struct child_prog *); /* function ptr */
};
struct close_me {
int fd;
struct close_me *next;
};
/* function prototypes for builtins */
static int builtin_cd(struct child_prog *cmd);
static int builtin_exec(struct child_prog *cmd);
static int builtin_exit(struct child_prog *cmd);
static int builtin_fg_bg(struct child_prog *cmd);
static int builtin_help(struct child_prog *cmd);
static int builtin_jobs(struct child_prog *dummy);
static int builtin_pwd(struct child_prog *dummy);
static int builtin_export(struct child_prog *cmd);
static int builtin_source(struct child_prog *cmd);
static int builtin_unset(struct child_prog *cmd);
static int builtin_read(struct child_prog *cmd);
/* function prototypes for shell stuff */
static void mark_open(int fd);
static void mark_closed(int fd);
static void close_all(void);
static void checkjobs(struct jobset *job_list);
static int get_command(FILE * source, char *command);
static int parse_command(char **command_ptr, struct job *job, int *inbg);
static int run_command(struct job *newjob, int inbg, int outpipe[2]);
static int pseudo_exec(struct child_prog *cmd) __attribute__ ((noreturn));
static int busy_loop(FILE * input);
/* Table of built-in functions (these are non-forking builtins, meaning they
* can change global variables in the parent shell process but they will not
* work with pipes and redirects; 'unset foo | whatever' will not work) */
static struct built_in_command bltins[] = {
{"bg", "Resume a job in the background", builtin_fg_bg},
{"cd", "Change working directory", builtin_cd},
{"exec", "Exec command, replacing this shell with the exec'd process", builtin_exec},
{"exit", "Exit from shell()", builtin_exit},
{"fg", "Bring job into the foreground", builtin_fg_bg},
{"jobs", "Lists the active jobs", builtin_jobs},
{"export", "Set environment variable", builtin_export},
{"unset", "Unset environment variable", builtin_unset},
{"read", "Input environment variable", builtin_read},
{".", "Source-in and run commands in a file", builtin_source},
/* to do: add ulimit */
{NULL, NULL, NULL}
};
/* Table of forking built-in functions (things that fork cannot change global
* variables in the parent process, such as the current working directory) */
static struct built_in_command bltins_forking[] = {
{"pwd", "Print current directory", builtin_pwd},
{"help", "List shell built-in commands", builtin_help},
{NULL, NULL, NULL}
};
/* Variables we export */
unsigned int shell_context; /* Used in cmdedit.c to reset the
context when someone hits ^C */
/* Globals that are static to this file */
static const char *cwd;
static char *local_pending_command = NULL;
static struct jobset job_list = { NULL, NULL };
static int argc;
static char **argv;
static struct close_me *close_me_head;
static unsigned int last_jobid;
static int shell_terminal;
static pid_t shell_pgrp;
static char *PS1;
static char *PS2 = "> ";
#ifdef DEBUG_SHELL
static inline void debug_printf(const char *format, ...)
{
va_list args;
va_start(args, format);
vfprintf(stderr, format, args);
va_end(args);
}
#else
static inline void debug_printf(const char *format, ...) { }
#endif
/*
Most builtins need access to the struct child_prog that has
their arguments, previously coded as cmd->progs[0]. That coding
can exhibit a bug, if the builtin is not the first command in
a pipeline: "echo foo | exec sort" will attempt to exec foo.
builtin previous use notes
------ ----------------- ---------
cd cmd->progs[0]
exec cmd->progs[0] squashed bug: didn't look for applets or forking builtins
exit cmd->progs[0]
fg_bg cmd->progs[0], job_list->head, job_list->fg
help 0
jobs job_list->head
pwd 0
export cmd->progs[0]
source cmd->progs[0]
unset cmd->progs[0]
read cmd->progs[0]
I added "struct job *family;" to struct child_prog,
and switched API to builtin_foo(struct child_prog *child);
So cmd->text becomes child->family->text
cmd->job_context becomes child->family->job_context
cmd->progs[0] becomes *child
job_list becomes child->family->job_list
*/
/* built-in 'cd <path>' handler */
static int builtin_cd(struct child_prog *child)
{
char *newdir;
if (child->argv[1] == NULL)
newdir = getenv("HOME");
else
newdir = child->argv[1];
if (chdir(newdir)) {
printf("cd: %s: %m\n", newdir);
return EXIT_FAILURE;
}
cwd = xgetcwd((char *)cwd);
if (!cwd)
cwd = unknown;
return EXIT_SUCCESS;
}
/* built-in 'exec' handler */
static int builtin_exec(struct child_prog *child)
{
if (child->argv[1] == NULL)
return EXIT_SUCCESS; /* Really? */
child->argv++;
close_all();
pseudo_exec(child);
/* never returns */
}
/* built-in 'exit' handler */
static int builtin_exit(struct child_prog *child)
{
if (child->argv[1] == NULL)
exit(EXIT_SUCCESS);
exit (atoi(child->argv[1]));
}
/* built-in 'fg' and 'bg' handler */
static int builtin_fg_bg(struct child_prog *child)
{
int i, jobnum;
struct job *job=NULL;
/* If they gave us no args, assume they want the last backgrounded task */
if (!child->argv[1]) {
for (job = child->family->job_list->head; job; job = job->next) {
if (job->jobid == last_jobid) {
break;
}
}
if (!job) {
error_msg("%s: no current job", child->argv[0]);
return EXIT_FAILURE;
}
} else {
if (sscanf(child->argv[1], "%%%d", &jobnum) != 1) {
error_msg("%s: bad argument '%s'", child->argv[0], child->argv[1]);
return EXIT_FAILURE;
}
for (job = child->family->job_list->head; job; job = job->next) {
if (job->jobid == jobnum) {
break;
}
}
if (!job) {
error_msg("%s: %d: no such job", child->argv[0], jobnum);
return EXIT_FAILURE;
}
}
if (*child->argv[0] == 'f') {
/* Put the job into the foreground. */
tcsetpgrp(shell_terminal, job->pgrp);
child->family->job_list->fg = job;
}
/* Restart the processes in the job */
for (i = 0; i < job->num_progs; i++)
job->progs[i].is_stopped = 0;
job->stopped_progs = 0;
if (kill(- job->pgrp, SIGCONT) < 0)
perror_msg("kill (SIGCONT)");
return EXIT_SUCCESS;
}
/* built-in 'help' handler */
static int builtin_help(struct child_prog *dummy)
{
struct built_in_command *x;
printf("\nBuilt-in commands:\n");
printf("-------------------\n");
for (x = bltins; x->cmd; x++) {
if (x->descr==NULL)
continue;
printf("%s\t%s\n", x->cmd, x->descr);
}
for (x = bltins_forking; x->cmd; x++) {
if (x->descr==NULL)
continue;
printf("%s\t%s\n", x->cmd, x->descr);
}
printf("\n\n");
return EXIT_SUCCESS;
}
/* built-in 'jobs' handler */
static int builtin_jobs(struct child_prog *child)
{
struct job *job;
char *status_string;
for (job = child->family->job_list->head; job; job = job->next) {
if (job->running_progs == job->stopped_progs)
status_string = "Stopped";
else
status_string = "Running";
printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text);
}
return EXIT_SUCCESS;
}
/* built-in 'pwd' handler */
static int builtin_pwd(struct child_prog *dummy)
{
cwd = xgetcwd((char *)cwd);
if (!cwd)
cwd = unknown;
puts(cwd);
return EXIT_SUCCESS;
}
/* built-in 'export VAR=value' handler */
static int builtin_export(struct child_prog *child)
{
int res;
char *v = child->argv[1];
if (v == NULL) {
char **e;
for (e = environ; *e; e++) {
puts(*e);
}
return 0;
}
res = putenv(v);
if (res)
fprintf(stderr, "export: %m\n");
#ifdef BB_FEATURE_SH_FANCY_PROMPT
if (strncmp(v, "PS1=", 4)==0)
PS1 = getenv("PS1");
#endif
#ifdef BB_LOCALE_SUPPORT
if(strncmp(v, "LC_ALL=", 7)==0)
setlocale(LC_ALL, getenv("LC_ALL"));
if(strncmp(v, "LC_CTYPE=", 9)==0)
setlocale(LC_CTYPE, getenv("LC_CTYPE"));
#endif
return (res);
}
/* built-in 'read VAR' handler */
static int builtin_read(struct child_prog *child)
{
int res = 0, len, newlen;
char *s;
char string[MAX_READ];
if (child->argv[1]) {
/* argument (VAR) given: put "VAR=" into buffer */
strcpy(string, child->argv[1]);
len = strlen(string);
string[len++] = '=';
string[len] = '\0';
fgets(&string[len], sizeof(string) - len, stdin); /* read string */
newlen = strlen(string);
if(newlen > len)
string[--newlen] = '\0'; /* chomp trailing newline */
/*
** string should now contain "VAR=<value>"
** copy it (putenv() won't do that, so we must make sure
** the string resides in a static buffer!)
*/
res = -1;
if((s = strdup(string)))
res = putenv(s);
if (res)
fprintf(stderr, "read: %m\n");
}
else
fgets(string, sizeof(string), stdin);
return (res);
}
/* Built-in '.' handler (read-in and execute commands from file) */
static int builtin_source(struct child_prog *child)
{
FILE *input;
int status;
int fd;
if (child->argv[1] == NULL)
return EXIT_FAILURE;
input = fopen(child->argv[1], "r");
if (!input) {
printf( "Couldn't open file '%s'\n", child->argv[1]);
return EXIT_FAILURE;
}
fd=fileno(input);
mark_open(fd);
/* Now run the file */
status = busy_loop(input);
fclose(input);
mark_closed(fd);
return (status);
}
/* built-in 'unset VAR' handler */
static int builtin_unset(struct child_prog *child)
{
if (child->argv[1] == NULL) {
printf( "unset: parameter required.\n");
return EXIT_FAILURE;
}
unsetenv(child->argv[1]);
return EXIT_SUCCESS;
}
static void mark_open(int fd)
{
struct close_me *new = xmalloc(sizeof(struct close_me));
new->fd = fd;
new->next = close_me_head;
close_me_head = new;
}
static void mark_closed(int fd)
{
struct close_me *tmp;
if (close_me_head == NULL || close_me_head->fd != fd)
error_msg_and_die("corrupt close_me");
tmp = close_me_head;
close_me_head = close_me_head->next;
free(tmp);
}
static void close_all()
{
struct close_me *c, *tmp;
for (c=close_me_head; c; c=tmp) {
close(c->fd);
tmp=c->next;
free(c);
}
close_me_head = NULL;
}
/* free up all memory from a job */
static void free_job(struct job *cmd)
{
int i;
struct jobset *keep;
for (i = 0; i < cmd->num_progs; i++) {
free(cmd->progs[i].argv);
if (cmd->progs[i].redirects)
free(cmd->progs[i].redirects);
}
if (cmd->progs)
free(cmd->progs);
if (cmd->text)
free(cmd->text);
if (cmd->cmdbuf)
free(cmd->cmdbuf);
keep = cmd->job_list;
memset(cmd, 0, sizeof(struct job));
cmd->job_list = keep;
}
/* remove a job from a jobset */
static void remove_job(struct jobset *j_list, struct job *job)
{
struct job *prevjob;
free_job(job);
if (job == j_list->head) {
j_list->head = job->next;
} else {
prevjob = j_list->head;
while (prevjob->next != job)
prevjob = prevjob->next;
prevjob->next = job->next;
}
free(job);
}
/* Checks to see if any background processes have exited -- if they
have, figure out why and see if a job has completed */
static void checkjobs(struct jobset *j_list)
{
struct job *job;
pid_t childpid;
int status;
int prognum = 0;
while ((childpid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
for (job = j_list->head; job; job = job->next) {
prognum = 0;
while (prognum < job->num_progs &&
job->progs[prognum].pid != childpid) prognum++;
if (prognum < job->num_progs)
break;
}
/* This happens on backticked commands */
if(job==NULL)
return;
if (WIFEXITED(status) || WIFSIGNALED(status)) {
/* child exited */
job->running_progs--;
job->progs[prognum].pid = 0;
if (!job->running_progs) {
printf(JOB_STATUS_FORMAT, job->jobid, "Done", job->text);
last_jobid=0;
remove_job(j_list, job);
}
} else {
/* child stopped */
job->stopped_progs++;
job->progs[prognum].is_stopped = 1;
if (job->stopped_progs == job->num_progs) {
printf(JOB_STATUS_FORMAT, job->jobid, "Stopped",
job->text);
}
}
}
if (childpid == -1 && errno != ECHILD)
perror_msg("waitpid");
}
/* squirrel != NULL means we squirrel away copies of stdin, stdout,
* and stderr if they are redirected. */
static int setup_redirects(struct child_prog *prog, int squirrel[])
{
int i;
int openfd;
int mode = O_RDONLY;
struct redir_struct *redir = prog->redirects;
for (i = 0; i < prog->num_redirects; i++, redir++) {
switch (redir->type) {
case REDIRECT_INPUT:
mode = O_RDONLY;
break;
case REDIRECT_OVERWRITE:
mode = O_WRONLY | O_CREAT | O_TRUNC;
break;
case REDIRECT_APPEND:
mode = O_WRONLY | O_CREAT | O_APPEND;
break;
}
openfd = open(redir->filename, mode, 0666);
if (openfd < 0) {
/* this could get lost if stderr has been redirected, but
bash and ash both lose it as well (though zsh doesn't!) */
perror_msg("error opening %s", redir->filename);
return 1;
}
if (openfd != redir->fd) {
if (squirrel && redir->fd < 3) {
squirrel[redir->fd] = dup(redir->fd);
}
dup2(openfd, redir->fd);
close(openfd);
}
}
return 0;
}
static void restore_redirects(int squirrel[])
{
int i, fd;
for (i=0; i<3; i++) {
fd = squirrel[i];
if (fd != -1) {
/* No error checking. I sure wouldn't know what
* to do with an error if I found one! */
dup2(fd, i);
close(fd);
}
}
}
static inline void cmdedit_set_initial_prompt(void)
{
#ifndef BB_FEATURE_SH_FANCY_PROMPT
PS1 = NULL;
#else
PS1 = getenv("PS1");
if(PS1==0)
PS1 = "\\w \\$ ";
#endif
}
static inline void setup_prompt_string(char **prompt_str)
{
#ifndef BB_FEATURE_SH_FANCY_PROMPT
/* Set up the prompt */
if (shell_context == 0) {
if (PS1)
free(PS1);
PS1=xmalloc(strlen(cwd)+4);
sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ? "$ ":"# ");
*prompt_str = PS1;
} else {
*prompt_str = PS2;
}
#else
*prompt_str = (shell_context==0)? PS1 : PS2;
#endif
}
static int get_command(FILE * source, char *command)
{
char *prompt_str;
if (source == NULL) {
if (local_pending_command) {
/* a command specified (-c option): return it & mark it done */
strcpy(command, local_pending_command);
free(local_pending_command);
local_pending_command = NULL;
return 0;
}
return 1;
}
if (source == stdin) {
setup_prompt_string(&prompt_str);
#ifdef BB_FEATURE_COMMAND_EDITING
/*
** enable command line editing only while a command line
** is actually being read; otherwise, we'll end up bequeathing
** atexit() handlers and other unwanted stuff to our
** child processes (rob@sysgo.de)
*/
cmdedit_read_input(prompt_str, command);
cmdedit_terminate();
return 0;
#else
fputs(prompt_str, stdout);
#endif
}
if (!fgets(command, BUFSIZ - 2, source)) {
if (source == stdin)
printf("\n");
return 1;
}
return 0;
}
static int expand_arguments(char *command)
{
int ix = 0;
/* get rid of the terminating \n */
chomp(command);
/* Fix up escape sequences to be the Real Thing(tm) */
while( command && command[ix]) {
if (command[ix] == '\\') {
const char *tmp = command+ix+1;
command[ix] = process_escape_sequence( &tmp );
memmove(command+ix + 1, tmp, strlen(tmp)+1);
}
ix++;
}
return TRUE;
}
/* Return cmd->num_progs as 0 if no command is present (e.g. an empty
line). If a valid command is found, command_ptr is set to point to
the beginning of the next command (if the original command had more
then one job associated with it) or NULL if no more commands are
present. */
static int parse_command(char **command_ptr, struct job *job, int *inbg)
{
char *command;
char *return_command = NULL;
char *src, *buf, *chptr;
int argc_l = 0;
int done = 0;
int argv_alloced;
int i, saw_quote = 0;
char quote = '\0';
int count;
struct child_prog *prog;
/* skip leading white space */
while (**command_ptr && isspace(**command_ptr))
(*command_ptr)++;
/* this handles empty lines or leading '#' characters */
if (!**command_ptr || (**command_ptr == '#')) {
job->num_progs=0;
return 0;
}
*inbg = 0;
job->num_progs = 1;
job->progs = xmalloc(sizeof(*job->progs));
/* We set the argv elements to point inside of this string. The
memory is freed by free_job(). Allocate twice the original
length in case we need to quote every single character.
Getting clean memory relieves us of the task of NULL
terminating things and makes the rest of this look a bit
cleaner (though it is, admittedly, a tad less efficient) */
job->cmdbuf = command = xcalloc(2*strlen(*command_ptr) + 1, sizeof(char));
job->text = NULL;
prog = job->progs;
prog->num_redirects = 0;
prog->redirects = NULL;
prog->is_stopped = 0;
prog->family = job;
argv_alloced = 5;
prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
prog->argv[0] = job->cmdbuf;
buf = command;
src = *command_ptr;
while (*src && !done) {
if (quote == *src) {
quote = '\0';
} else if (quote) {
if (*src == '\\') {
src++;
if (!*src) {
error_msg("character expected after \\");
free_job(job);
return 1;
}
/* in shell, "\'" should yield \' */
if (*src != quote) {
*buf++ = '\\';
*buf++ = '\\';
}
} else if (*src == '*' || *src == '?' || *src == '[' ||
*src == ']') *buf++ = '\\';
*buf++ = *src;
} else if (isspace(*src)) {
if (*prog->argv[argc_l] || saw_quote) {
buf++, argc_l++;
/* +1 here leaves room for the NULL which ends argv */
if ((argc_l + 1) == argv_alloced) {
argv_alloced += 5;
prog->argv = xrealloc(prog->argv,
sizeof(*prog->argv) *
argv_alloced);
}
prog->argv[argc_l] = buf;
saw_quote = 0;
}
} else
switch (*src) {
case '"':
case '\'':
quote = *src;
saw_quote = 1;
break;
case '#': /* comment */
if (*(src-1)== '$')
*buf++ = *src;
else
done = 1;
break;
case '>': /* redirects */
case '<':
i = prog->num_redirects++;
prog->redirects = xrealloc(prog->redirects,
sizeof(*prog->redirects) *
(i + 1));
prog->redirects[i].fd = -1;
if (buf != prog->argv[argc_l]) {
/* the stuff before this character may be the file number
being redirected */
prog->redirects[i].fd =
strtol(prog->argv[argc_l], &chptr, 10);
if (*chptr && *prog->argv[argc_l]) {
buf++, argc_l++;
prog->argv[argc_l] = buf;
}
}
if (prog->redirects[i].fd == -1) {
if (*src == '>')
prog->redirects[i].fd = 1;
else
prog->redirects[i].fd = 0;
}
if (*src++ == '>') {
if (*src == '>')
prog->redirects[i].type =
REDIRECT_APPEND, src++;
else
prog->redirects[i].type = REDIRECT_OVERWRITE;
} else {
prog->redirects[i].type = REDIRECT_INPUT;
}
/* This isn't POSIX sh compliant. Oh well. */
chptr = src;
while (isspace(*chptr))
chptr++;
if (!*chptr) {
error_msg("file name expected after %c", *(src-1));
free_job(job);
job->num_progs=0;
return 1;
}
prog->redirects[i].filename = buf;
while (*chptr && !isspace(*chptr))
*buf++ = *chptr++;
src = chptr - 1; /* we src++ later */
prog->argv[argc_l] = ++buf;
break;
case '|': /* pipe */
/* finish this command */
if (*prog->argv[argc_l] || saw_quote)
argc_l++;
if (!argc_l) {
error_msg("empty command in pipe");
free_job(job);
job->num_progs=0;
return 1;
}
prog->argv[argc_l] = NULL;
/* and start the next */
job->num_progs++;
job->progs = xrealloc(job->progs,
sizeof(*job->progs) * job->num_progs);
prog = job->progs + (job->num_progs - 1);
prog->num_redirects = 0;
prog->redirects = NULL;
prog->is_stopped = 0;
prog->family = job;
argc_l = 0;
argv_alloced = 5;
prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
prog->argv[0] = ++buf;
src++;
while (*src && isspace(*src))
src++;
if (!*src) {
error_msg("empty command in pipe");
free_job(job);
job->num_progs=0;
return 1;
}
src--; /* we'll ++ it at the end of the loop */
break;
case '&': /* background */
*inbg = 1;
case ';': /* multiple commands */
done = 1;
return_command = *command_ptr + (src - *command_ptr) + 1;
break;
case '\\':
src++;
if (!*src) {
error_msg("character expected after \\");
free_job(job);
return 1;
}
if (*src == '*' || *src == '[' || *src == ']'
|| *src == '?') *buf++ = '\\';
/* fallthrough */
default:
*buf++ = *src;
}
src++;
}
if (*prog->argv[argc_l] || saw_quote) {
argc_l++;
}
if (!argc_l) {
free_job(job);
return 0;
}
prog->argv[argc_l] = NULL;
if (!return_command) {
job->text = xmalloc(strlen(*command_ptr) + 1);
strcpy(job->text, *command_ptr);
} else {
/* This leaves any trailing spaces, which is a bit sloppy */
count = return_command - *command_ptr;
job->text = xmalloc(count + 1);
strncpy(job->text, *command_ptr, count);
job->text[count] = '\0';
}
*command_ptr = return_command;
return 0;
}
/* Run the child_prog, no matter what kind of command it uses.
*/
static int pseudo_exec(struct child_prog *child)
{
struct built_in_command *x;
#ifdef BB_FEATURE_SH_STANDALONE_SHELL
char *name;
#endif
/* Check if the command matches any of the non-forking builtins.
* Depending on context, this might be redundant. But it's
* easier to waste a few CPU cycles than it is to figure out
* if this is one of those cases.
*/
for (x = bltins; x->cmd; x++) {
if (strcmp(child->argv[0], x->cmd) == 0 ) {
exit(x->function(child));
}
}
/* Check if the command matches any of the forking builtins. */
for (x = bltins_forking; x->cmd; x++) {
if (strcmp(child->argv[0], x->cmd) == 0) {
applet_name=x->cmd;
exit (x->function(child));
}
}
#ifdef BB_FEATURE_SH_STANDALONE_SHELL
/* Check if the command matches any busybox internal
* commands ("applets") here. Following discussions from
* November 2000 on busybox@opensource.lineo.com, don't use
* get_last_path_component(). This way explicit (with
* slashes) filenames will never be interpreted as an
* applet, just like with builtins. This way the user can
* override an applet with an explicit filename reference.
* The only downside to this change is that an explicit
* /bin/foo invocation will fork and exec /bin/foo, even if
* /bin/foo is a symlink to busybox.
*/
name = child->argv[0];
#ifdef BB_FEATURE_SH_APPLETS_ALWAYS_WIN
/* If you enable BB_FEATURE_SH_APPLETS_ALWAYS_WIN, then
* if you run /bin/cat, it will use BusyBox cat even if
* /bin/cat exists on the filesystem and is _not_ busybox.
* Some systems want this, others do not. Choose wisely. :-)
*/
name = get_last_path_component(name);
#endif
{
char** argv_l=child->argv;
int argc_l;
for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++);
optind = 1;
run_applet_by_name(name, argc_l, child->argv);
}
#endif
execvp(child->argv[0], child->argv);
perror_msg_and_die("%s", child->argv[0]);
}
static void insert_job(struct job *newjob, int inbg)
{
struct job *thejob;
struct jobset *j_list=newjob->job_list;
/* find the ID for thejob to use */
newjob->jobid = 1;
for (thejob = j_list->head; thejob; thejob = thejob->next)
if (thejob->jobid >= newjob->jobid)
newjob->jobid = thejob->jobid + 1;
/* add thejob to the list of running jobs */
if (!j_list->head) {
thejob = j_list->head = xmalloc(sizeof(*thejob));
} else {
for (thejob = j_list->head; thejob->next; thejob = thejob->next) /* nothing */;
thejob->next = xmalloc(sizeof(*thejob));
thejob = thejob->next;
}
*thejob = *newjob; /* physically copy the struct job */
thejob->next = NULL;
thejob->running_progs = thejob->num_progs;
thejob->stopped_progs = 0;
if (inbg) {
/* we don't wait for background thejobs to return -- append it
to the list of backgrounded thejobs and leave it alone */
printf("[%d] %d\n", thejob->jobid,
newjob->progs[newjob->num_progs - 1].pid);
last_jobid = newjob->jobid;
} else {
newjob->job_list->fg = thejob;
/* move the new process group into the foreground */
/* suppress messages when run from /linuxrc mag@sysgo.de */
if (tcsetpgrp(shell_terminal, newjob->pgrp) && errno != ENOTTY)
perror_msg("tcsetpgrp");
}
}
static int run_command(struct job *newjob, int inbg, int outpipe[2])
{
/* struct job *thejob; */
int i;
int nextin, nextout;
int pipefds[2]; /* pipefd[0] is for reading */
struct built_in_command *x;
struct child_prog *child;
nextin = 0, nextout = 1;
for (i = 0; i < newjob->num_progs; i++) {
child = & (newjob->progs[i]);
if ((i + 1) < newjob->num_progs) {
if (pipe(pipefds)<0) perror_msg_and_die("pipe");
nextout = pipefds[1];
} else {
if (outpipe[1]!=-1) {
nextout = outpipe[1];
} else {
nextout = 1;
}
}
/* Check if the command matches any non-forking builtins,
* but only if this is a simple command.
* Non-forking builtins within pipes have to fork anyway,
* and are handled in pseudo_exec. "echo foo | read bar"
* is doomed to failure, and doesn't work on bash, either.
*/
if (newjob->num_progs == 1) {
for (x = bltins; x->cmd; x++) {
if (strcmp(child->argv[0], x->cmd) == 0 ) {
int squirrel[] = {-1, -1, -1};
int rcode;
setup_redirects(child, squirrel);
rcode = x->function(child);
restore_redirects(squirrel);
return rcode;
}
}
}
if (!(child->pid = fork())) {
/* Set the handling for job control signals back to the default. */
signal(SIGINT, SIG_DFL);
signal(SIGQUIT, SIG_DFL);
signal(SIGTSTP, SIG_DFL);
signal(SIGTTIN, SIG_DFL);
signal(SIGTTOU, SIG_DFL);
signal(SIGCHLD, SIG_DFL);
close_all();
if (outpipe[1]!=-1) {
close(outpipe[0]);
}
if (nextin != 0) {
dup2(nextin, 0);
close(nextin);
}
if (nextout != 1) {
dup2(nextout, 1);
dup2(nextout, 2); /* Really? */
close(nextout);
close(pipefds[0]);
}
/* explicit redirects override pipes */
setup_redirects(child,NULL);
pseudo_exec(child);
}
if (outpipe[1]!=-1) {
close(outpipe[1]);
}
/* put our child in the process group whose leader is the
first process in this pipe */
setpgid(child->pid, newjob->progs[0].pid);
if (nextin != 0)
close(nextin);
if (nextout != 1)
close(nextout);
/* If there isn't another process, nextin is garbage
but it doesn't matter */
nextin = pipefds[0];
}
newjob->pgrp = newjob->progs[0].pid;
insert_job(newjob, inbg);
return 0;
}
static int busy_loop(FILE * input)
{
char *command;
char *next_command = NULL;
struct job newjob;
pid_t parent_pgrp;
int i;
int inbg;
int status;
newjob.job_list = &job_list;
newjob.job_context = DEFAULT_CONTEXT;
/* save current owner of TTY so we can restore it on exit */
parent_pgrp = tcgetpgrp(shell_terminal);
command = (char *) xcalloc(BUFSIZ, sizeof(char));
while (1) {
if (!job_list.fg) {
/* no job is in the foreground */
/* see if any background processes have exited */
checkjobs(&job_list);
if (!next_command) {
if (get_command(input, command))
break;
next_command = command;
}
if (expand_arguments(next_command) == FALSE) {
free(command);
command = (char *) xcalloc(BUFSIZ, sizeof(char));
next_command = NULL;
continue;
}
if (!parse_command(&next_command, &newjob, &inbg) &&
newjob.num_progs) {
int pipefds[2] = {-1,-1};
debug_printf( "job=%p fed to run_command by busy_loop()'\n",
&newjob);
run_command(&newjob, inbg, pipefds);
}
else {
free(command);
command = (char *) xcalloc(BUFSIZ, sizeof(char));
next_command = NULL;
}
} else {
/* a job is running in the foreground; wait for it */
i = 0;
while (!job_list.fg->progs[i].pid ||
job_list.fg->progs[i].is_stopped == 1) i++;
if (waitpid(job_list.fg->progs[i].pid, &status, WUNTRACED)<0)
perror_msg_and_die("waitpid(%d)",job_list.fg->progs[i].pid);
if (WIFEXITED(status) || WIFSIGNALED(status)) {
/* the child exited */
job_list.fg->running_progs--;
job_list.fg->progs[i].pid = 0;
if (!job_list.fg->running_progs) {
/* child exited */
remove_job(&job_list, job_list.fg);
job_list.fg = NULL;
}
} else {
/* the child was stopped */
job_list.fg->stopped_progs++;
job_list.fg->progs[i].is_stopped = 1;
if (job_list.fg->stopped_progs == job_list.fg->running_progs) {
printf("\n" JOB_STATUS_FORMAT, job_list.fg->jobid,
"Stopped", job_list.fg->text);
job_list.fg = NULL;
}
}
if (!job_list.fg) {
/* move the shell to the foreground */
/* suppress messages when run from /linuxrc mag@sysgo.de */
if (tcsetpgrp(shell_terminal, getpgrp()) && errno != ENOTTY)
perror_msg("tcsetpgrp");
}
}
}
free(command);
/* return controlling TTY back to parent process group before exiting */
if (tcsetpgrp(shell_terminal, parent_pgrp))
perror_msg("tcsetpgrp");
/* return exit status if called with "-c" */
if (input == NULL && WIFEXITED(status))
return WEXITSTATUS(status);
return 0;
}
#ifdef BB_FEATURE_CLEAN_UP
void free_memory(void)
{
if (cwd) {
free(cwd);
}
if (local_pending_command)
free(local_pending_command);
if (job_list.fg && !job_list.fg->running_progs) {
remove_job(&job_list, job_list.fg);
}
}
#endif
/* Make sure we have a controlling tty. If we get started under a job
* aware app (like bash for example), make sure we are now in charge so
* we don't fight over who gets the foreground */
static void setup_job_control()
{
/* Loop until we are in the foreground. */
while (tcgetpgrp (shell_terminal) != (shell_pgrp = getpgrp ()))
kill (- shell_pgrp, SIGTTIN);
/* Ignore interactive and job-control signals. */
signal(SIGINT, SIG_IGN);
signal(SIGQUIT, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
signal(SIGTTIN, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
/* Put ourselves in our own process group. */
shell_pgrp = getpid ();
if (setpgid (shell_pgrp, shell_pgrp) < 0) {
perror_msg_and_die("Couldn't put the shell in its own process group");
}
/* Grab control of the terminal. */
tcsetpgrp(shell_terminal, shell_pgrp);
}
int shell_main(int argc_l, char **argv_l)
{
int opt, interactive=FALSE;
FILE *input = stdin;
argc = argc_l;
argv = argv_l;
/* These variables need re-initializing when recursing */
last_jobid = 0;
shell_context = 0;
local_pending_command = NULL;
close_me_head = NULL;
job_list.head = NULL;
job_list.fg = NULL;
if (argv[0] && argv[0][0] == '-') {
FILE *prof_input;
prof_input = fopen("/etc/profile", "r");
if (!prof_input) {
printf( "Couldn't open file '/etc/profile'\n");
} else {
int tmp_fd = fileno(prof_input);
mark_open(tmp_fd);
/* Now run the file */
busy_loop(prof_input);
fclose(prof_input);
mark_closed(tmp_fd);
}
}
while ((opt = getopt(argc_l, argv_l, "cxi")) > 0) {
switch (opt) {
case 'c':
input = NULL;
if (local_pending_command != 0)
error_msg_and_die("multiple -c arguments");
local_pending_command = xstrdup(argv[optind]);
optind++;
argv = argv+optind;
break;
case 'i':
interactive = TRUE;
break;
default:
show_usage();
}
}
/* A shell is interactive if the `-i' flag was given, or if all of
* the following conditions are met:
* no -c command
* no arguments remaining or the -s flag given
* standard input is a terminal
* standard output is a terminal
* Refer to Posix.2, the description of the `sh' utility. */
if (argv[optind]==NULL && input==stdin &&
isatty(fileno(stdin)) && isatty(fileno(stdout))) {
interactive=TRUE;
}
setup_job_control();
if (interactive==TRUE) {
//printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
/* Looks like they want an interactive shell */
printf( "\n\n" BB_BANNER " Built-in shell (lash)\n");
printf( "Enter 'help' for a list of built-in commands.\n\n");
} else if (local_pending_command==NULL) {
//printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
input = xfopen(argv[optind], "r");
mark_open(fileno(input)); /* be lazy, never mark this closed */
}
/* initialize the cwd -- this is never freed...*/
cwd = xgetcwd(0);
if (!cwd)
cwd = unknown;
#ifdef BB_FEATURE_CLEAN_UP
atexit(free_memory);
#endif
#ifdef BB_FEATURE_COMMAND_EDITING
cmdedit_set_initial_prompt();
#else
PS1 = NULL;
#endif
return (busy_loop(input));
}