kill lash. "lash" builtin still exists, but it runs hush.

1 files changed, 1570 insertions, 0 deletions

diff --git a/shell/lash_unused.c b/shell/lash_unused.c
new file mode 100644
index 0000000..781dfdb
--- /dev/null
+++ b/shell/lash_unused.c
@@ -0,0 +1,1570 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * lash -- the BusyBox Lame-Ass SHell
+ *
+ * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.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."
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ */
+
+/* This shell's parsing engine is officially at a dead-end.  Future
+ * work shell work should be done using hush, msh, or ash.  This is
+ * still a very useful, small shell -- it just don't need any more
+ * features beyond what it already has...
+ */
+
+//For debugging/development on the shell only...
+//#define DEBUG_SHELL
+
+#include <getopt.h>
+#include <glob.h>
+
+#include "busybox.h" /* for struct bb_applet */
+
+#define expand_t	glob_t
+
+/* Always enable for the moment... */
+#define CONFIG_LASH_PIPE_N_REDIRECTS
+#define CONFIG_LASH_JOB_CONTROL
+#define ENABLE_LASH_PIPE_N_REDIRECTS 1
+#define ENABLE_LASH_JOB_CONTROL      1
+
+
+enum { MAX_READ = 128 }; /* size of input buffer for 'read' builtin */
+#define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
+
+
+#if ENABLE_LASH_PIPE_N_REDIRECTS
+enum redir_type { REDIRECT_INPUT, REDIRECT_OVERWRITE,
+	REDIRECT_APPEND
+};
+#endif
+
+enum {
+	DEFAULT_CONTEXT = 0x1,
+	IF_TRUE_CONTEXT = 0x2,
+	IF_FALSE_CONTEXT = 0x4,
+	THEN_EXP_CONTEXT = 0x8,
+	ELSE_EXP_CONTEXT = 0x10
+};
+
+#define LASH_OPT_DONE (1)
+#define LASH_OPT_SAW_QUOTE (2)
+
+#if ENABLE_LASH_PIPE_N_REDIRECTS
+struct redir_struct {
+	enum redir_type type;	/* type of redirection */
+	int fd;						/* file descriptor being redirected */
+	char *filename;				/* file to redirect fd to */
+};
+#endif
+
+struct child_prog {
+	pid_t pid;					/* 0 if exited */
+	char **argv;				/* program name and arguments */
+	int num_redirects;			/* elements in redirection array */
+	int is_stopped;				/* is the program currently running? */
+	struct job *family;			/* pointer back to the child's parent job */
+#if ENABLE_LASH_PIPE_N_REDIRECTS
+	struct redir_struct *redirects;	/* I/O redirects */
+#endif
+};
+
+struct jobset {
+	struct job *head;			/* head of list of running jobs */
+	struct job *fg;				/* current foreground 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 {
+	const char *cmd;   /* name */
+	const char *descr; /* description */
+	int (*function) (struct child_prog *);	/* function ptr */
+};
+
+/* 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 checkjobs(struct jobset *job_list);
+static void remove_job(struct jobset *j_list, struct job *job);
+static int get_command_bufsiz(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 const 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},
+	/* These were "forked applets", but distinction was nuked */
+	/* Original comment retained: */
+	/* Table of forking built-in functions (things that fork cannot change global
+	 * variables in the parent process, such as the current working directory) */
+	{"pwd"   , "Print current directory", builtin_pwd},
+	{"help"  , "List shell built-in commands", builtin_help},
+	/* to do: add ulimit */
+};
+
+
+#define VEC_LAST(v) v[ARRAY_SIZE(v)-1]
+
+
+static int shell_context;  /* Type prompt trigger (PS1 or PS2) */
+
+
+/* Globals that are static to this file */
+static char *cwd;
+static char *local_pending_command;
+static struct jobset job_list = { NULL, NULL };
+static int global_argc;
+static char **global_argv;
+static llist_t *close_me_list;
+static int last_return_code;
+static int last_bg_pid;
+static unsigned int last_jobid;
+static int shell_terminal;
+static const char *PS1;
+static const 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 ATTRIBUTE_UNUSED *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
+ */
+
+
+static void update_cwd(void)
+{
+	cwd = xrealloc_getcwd_or_warn(cwd);
+	if (!cwd)
+		cwd = xstrdup(bb_msg_unknown);
+}
+
+/* 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)) {
+		bb_perror_msg("cd: %s", newdir);
+		return EXIT_FAILURE;
+	}
+	update_cwd();
+	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++;
+	while (close_me_list)
+		close((long)llist_pop(&close_me_list));
+	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;
+
+	/* 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) {
+				goto found;
+			}
+		}
+		bb_error_msg("%s: no current job", child->argv[0]);
+		return EXIT_FAILURE;
+	}
+	if (sscanf(child->argv[1], "%%%d", &jobnum) != 1) {
+		bb_error_msg(bb_msg_invalid_arg, child->argv[1], child->argv[0]);
+		return EXIT_FAILURE;
+	}
+	for (job = child->family->job_list->head; job; job = job->next) {
+		if (job->jobid == jobnum) {
+			goto found;
+		}
+	}
+	bb_error_msg("%s: %d: no such job", child->argv[0], jobnum);
+	return EXIT_FAILURE;
+ found:
+	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;
+
+	i = kill(- job->pgrp, SIGCONT);
+	if (i < 0) {
+		if (errno == ESRCH) {
+			remove_job(&job_list, job);
+		} else {
+			bb_perror_msg("kill (SIGCONT)");
+		}
+	}
+
+	return EXIT_SUCCESS;
+}
+
+/* built-in 'help' handler */
+static int builtin_help(struct child_prog ATTRIBUTE_UNUSED *dummy)
+{
+	const struct built_in_command *x;
+
+	printf("\nBuilt-in commands:\n"
+	       "-------------------\n");
+	for (x = bltins; x <= &VEC_LAST(bltins); x++) {
+		if (x->descr == NULL)
+			continue;
+		printf("%s\t%s\n", x->cmd, x->descr);
+	}
+	bb_putchar('\n');
+	return EXIT_SUCCESS;
+}
+
+/* built-in 'jobs' handler */
+static int builtin_jobs(struct child_prog *child)
+{
+	struct job *job;
+	const 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 ATTRIBUTE_UNUSED *dummy)
+{
+	update_cwd();
+	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)
+		bb_perror_msg("export");
+#if ENABLE_FEATURE_EDITING_FANCY_PROMPT
+	if (strncmp(v, "PS1=", 4) == 0)
+		PS1 = getenv("PS1");
+#endif
+
+#if ENABLE_LOCALE_SUPPORT
+	// TODO: why getenv? "" would be just as good...
+	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;
+	char *s;
+	char string[MAX_READ];
+
+	if (child->argv[1]) {
+		/* argument (VAR) given: put "VAR=" into buffer */
+		safe_strncpy(string, child->argv[1], MAX_READ-1);
+		len = strlen(string);
+		string[len++] = '=';
+		string[len]   = '\0';
+		fgets(&string[len], sizeof(string) - len, stdin);	/* read string */
+		res = strlen(string);
+		if (res > len)
+			string[--res] = '\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;
+		s = strdup(string);
+		if (s)
+			res = putenv(s);
+		if (res)
+			bb_perror_msg("read");
+	} 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;
+
+	input = fopen_or_warn(child->argv[1], "r");
+	if (!input) {
+		return EXIT_FAILURE;
+	}
+
+	llist_add_to(&close_me_list, (void *)(long)fileno(input));
+	/* Now run the file */
+	status = busy_loop(input);
+	fclose(input);
+	llist_pop(&close_me_list);
+	return status;
+}
+
+/* built-in 'unset VAR' handler */
+static int builtin_unset(struct child_prog *child)
+{
+	if (child->argv[1] == NULL) {
+		printf(bb_msg_requires_arg, "unset");
+		return EXIT_FAILURE;
+	}
+	unsetenv(child->argv[1]);
+	return EXIT_SUCCESS;
+}
+
+#if ENABLE_LASH_JOB_CONTROL
+/* 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 ENABLE_LASH_PIPE_N_REDIRECTS
+		free(cmd->progs[i].redirects);
+#endif
+	}
+	free(cmd->progs);
+	free(cmd->text);
+	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;
+	}
+
+	if (j_list->head)
+		last_jobid = j_list->head->jobid;
+	else
+		last_jobid = 0;
+
+	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 (childpid == -1 && errno != ECHILD)
+		bb_perror_msg("waitpid");
+}
+#else
+static void checkjobs(struct jobset *j_list)
+{
+}
+static void free_job(struct job *cmd)
+{
+}
+static void remove_job(struct jobset *j_list, struct job *job)
+{
+}
+#endif
+
+#if ENABLE_LASH_PIPE_N_REDIRECTS
+/* 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 = open3_or_warn(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!) */
+			return 1;
+		}
+
+		if (openfd != redir->fd) {
+			if (squirrel && redir->fd < 3) {
+				squirrel[redir->fd] = dup(redir->fd);
+				close_on_exec_on(squirrel[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);
+		}
+	}
+}
+#else
+static inline int setup_redirects(struct child_prog *prog, int squirrel[])
+{
+	return 0;
+}
+static inline void restore_redirects(int squirrel[])
+{
+}
+#endif
+
+static inline void cmdedit_set_initial_prompt(void)
+{
+#if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
+	PS1 = NULL;
+#else
+	PS1 = getenv("PS1");
+	if (PS1 == 0)
+		PS1 = "\\w \\$ ";
+#endif
+}
+
+static inline const char* setup_prompt_string(void)
+{
+#if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
+	/* Set up the prompt */
+	if (shell_context == 0) {
+		char *ns;
+		free((char*)PS1);
+		ns = xmalloc(strlen(cwd)+4);
+		sprintf(ns, "%s %c ", cwd, (geteuid() != 0) ? '$': '#');
+		PS1 = ns;
+		return ns;
+	} else {
+		return PS2;
+	}
+#else
+	return (shell_context == 0)? PS1 : PS2;
+#endif
+}
+
+#if ENABLE_FEATURE_EDITING
+static line_input_t *line_input_state;
+#endif
+
+static int get_command_bufsiz(FILE * source, char *command)
+{
+	const char *prompt_str;
+
+	if (source == NULL) {
+		if (local_pending_command) {
+			/* a command specified (-c option): return it & mark it done */
+			strncpy(command, local_pending_command, BUFSIZ);
+			local_pending_command = NULL;
+			return 0;
+		}
+		return 1;
+	}
+
+	if (source == stdin) {
+		prompt_str = setup_prompt_string();
+
+#if ENABLE_FEATURE_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)
+		*/
+		read_line_input(prompt_str, command, BUFSIZ, line_input_state);
+		return 0;
+#else
+		fputs(prompt_str, stdout);
+#endif
+	}
+
+	if (!fgets(command, BUFSIZ - 2, source)) {
+		if (source == stdin)
+			bb_putchar('\n');
+		return 1;
+	}
+
+	return 0;
+}
+
+static char * strsep_space(char *string, int * ix)
+{
+	/* Short circuit the trivial case */
+	if (!string || ! string[*ix])
+		return NULL;
+
+	/* Find the end of the token. */
+	while (string[*ix] && !isspace(string[*ix]) ) {
+		(*ix)++;
+	}
+
+	/* Find the end of any whitespace trailing behind
+	 * the token and let that be part of the token */
+	while (string[*ix] && (isspace)(string[*ix]) ) {
+		(*ix)++;
+	}
+
+	if (!*ix) {
+		/* Nothing useful was found */
+		return NULL;
+	}
+
+	return xstrndup(string, *ix);
+}
+
+static int expand_arguments(char *command)
+{
+	static const char out_of_space[] ALIGN1 = "out of space during expansion";
+
+	int total_length = 0, length, i, retval, ix = 0;
+	expand_t expand_result;
+	char *tmpcmd, *cmd, *cmd_copy;
+	char *src, *dst, *var;
+	int flags = GLOB_NOCHECK
+#ifdef GLOB_BRACE
+		| GLOB_BRACE
+#endif
+#ifdef GLOB_TILDE
+		| GLOB_TILDE
+#endif
+		;
+
+	/* 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] = bb_process_escape_sequence(  &tmp );
+			memmove(command+ix + 1, tmp, strlen(tmp)+1);
+		}
+		ix++;
+	}
+	/* Use glob and then fixup environment variables and such */
+
+	/* It turns out that glob is very stupid.  We have to feed it one word at a
+	 * time since it can't cope with a full string.  Here we convert command
+	 * (char*) into cmd (char**, one word per string) */
+
+	/* We need a clean copy, so strsep can mess up the copy while
+	 * we write stuff into the original (in a minute) */
+	cmd = cmd_copy = xstrdup(command);
+	*command = '\0';
+	for (ix = 0, tmpcmd = cmd;
+			(tmpcmd = strsep_space(cmd, &ix)) != NULL; cmd += ix, ix = 0) {
+		if (*tmpcmd == '\0')
+			break;
+		/* we need to trim() the result for glob! */
+		trim(tmpcmd);
+		retval = glob(tmpcmd, flags, NULL, &expand_result);
+		free(tmpcmd); /* Free mem allocated by strsep_space */
+		if (retval == GLOB_NOSPACE) {
+			/* Mem may have been allocated... */
+			globfree(&expand_result);
+			bb_error_msg(out_of_space);
+			return FALSE;
+		} else if (retval != 0) {
+			/* Some other error.  GLOB_NOMATCH shouldn't
+			 * happen because of the GLOB_NOCHECK flag in
+			 * the glob call. */
+			bb_error_msg("syntax error");
+			return FALSE;
+		} else {
+			/* Convert from char** (one word per string) to a simple char*,
+			 * but don't overflow command which is BUFSIZ in length */
+			for (i = 0; i < expand_result.gl_pathc; i++) {
+				length = strlen(expand_result.gl_pathv[i]);
+				if (total_length+length+1 >= BUFSIZ) {
+					bb_error_msg(out_of_space);
+					return FALSE;
+				}
+				strcat(command+total_length, " ");
+				total_length += 1;
+				strcat(command+total_length, expand_result.gl_pathv[i]);
+				total_length += length;
+			}
+			globfree(&expand_result);
+		}
+	}
+	free(cmd_copy);
+	trim(command);
+
+	/* Now do the shell variable substitutions which
+	 * wordexp can't do for us, namely $? and $! */
+	src = command;
+	while ((dst = strchr(src,'$')) != NULL) {
+		var = NULL;
+		switch (*(dst+1)) {
+			case '?':
+				var = itoa(last_return_code);
+				break;
+			case '!':
+				if (last_bg_pid == -1)
+					*var = '\0';
+				else
+					var = itoa(last_bg_pid);
+				break;
+				/* Everything else like $$, $#, $[0-9], etc. should all be
+				 * expanded by wordexp(), so we can in theory skip that stuff
+				 * here, but just to be on the safe side (i.e., since uClibc
+				 * wordexp doesn't do this stuff yet), lets leave it in for
+				 * now. */
+			case '$':
+				var = itoa(getpid());
+				break;
+			case '#':
+				var = itoa(global_argc - 1);
+				break;
+			case '0':case '1':case '2':case '3':case '4':
+			case '5':case '6':case '7':case '8':case '9':
+				{
+					int ixx = *(dst+1)-48+1;
+					if (ixx >= global_argc) {
+						var = '\0';
+					} else {
+						var = global_argv[ixx];
+					}
+				}
+				break;
+
+		}
+		if (var) {
+			/* a single character construction was found, and
+			 * already handled in the case statement */
+			src = dst + 2;
+		} else {
+			/* Looks like an environment variable */
+			char delim_hold;
+			int num_skip_chars = 0;
+			int dstlen = strlen(dst);
+			/* Is this a ${foo} type variable? */
+			if (dstlen >= 2 && *(dst+1) == '{') {
+				src = strchr(dst+1, '}');
+				num_skip_chars = 1;
+			} else {
+				src = dst + 1;
+				while ((isalnum)(*src) || *src == '_') src++;
+			}
+			if (src == NULL) {
+				src = dst+dstlen;
+			}
+			delim_hold = *src;
+			*src = '\0';  /* temporary */
+			var = getenv(dst + 1 + num_skip_chars);
+			*src = delim_hold;
+			src += num_skip_chars;
+		}
+		if (var == NULL) {
+			/* Seems we got an un-expandable variable.  So delete it. */
+			var = (char*)"";
+		}
+		{
+			int subst_len = strlen(var);
+			int trail_len = strlen(src);
+			if (dst+subst_len+trail_len >= command+BUFSIZ) {
+				bb_error_msg(out_of_space);
+				return FALSE;
+			}
+			/* Move stuff to the end of the string to accommodate
+			 * filling the created gap with the new stuff */
+			memmove(dst+subst_len, src, trail_len+1);
+			/* Now copy in the new stuff */
+			memcpy(dst, var, subst_len);
+			src = dst+subst_len;
+		}
+	}
+
+	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;
+	int argc_l;
+	int flag;
+	int argv_alloced;
+	char quote = '\0';
+	struct child_prog *prog;
+#if ENABLE_LASH_PIPE_N_REDIRECTS
+	int i;
+	char *chptr;
+#endif
+
+	/* skip leading white space */
+	*command_ptr = skip_whitespace(*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 = xzalloc(2*strlen(*command_ptr) + 1);
+	job->text = NULL;
+
+	prog = job->progs;
+	prog->num_redirects = 0;
+	prog->is_stopped = 0;
+	prog->family = job;
+#if ENABLE_LASH_PIPE_N_REDIRECTS
+	prog->redirects = NULL;
+#endif
+
+	argv_alloced = 5;
+	prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
+	prog->argv[0] = job->cmdbuf;
+
+	flag = argc_l = 0;
+	buf = command;
+	src = *command_ptr;
+	while (*src && !(flag & LASH_OPT_DONE)) {
+		if (quote == *src) {
+			quote = '\0';
+		} else if (quote) {
+			if (*src == '\\') {
+				src++;
+				if (!*src) {
+					bb_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] || (flag & LASH_OPT_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;
+				flag ^= LASH_OPT_SAW_QUOTE;
+			}
+		} else
+			switch (*src) {
+			case '"':
+			case '\'':
+				quote = *src;
+				flag |= LASH_OPT_SAW_QUOTE;
+				break;
+
+			case '#':			/* comment */
+				if (*(src-1)== '$')
+					*buf++ = *src;
+				else
+					flag |= LASH_OPT_DONE;
+				break;
+
+#if ENABLE_LASH_PIPE_N_REDIRECTS
+			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;
+				chptr = skip_whitespace(chptr);
+
+				if (!*chptr) {
+					bb_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] || flag & LASH_OPT_SAW_QUOTE)
+					argc_l++;
+				if (!argc_l) {
+					goto empty_command_in_pipe;
+				}
+				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++;
+				src = skip_whitespace(src);
+
+				if (!*src) {
+empty_command_in_pipe:
+					bb_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;
+#endif
+
+#if ENABLE_LASH_JOB_CONTROL
+			case '&':			/* background */
+				*inbg = 1;
+				/* fallthrough */
+#endif
+			case ';':			/* multiple commands */
+				flag |= LASH_OPT_DONE;
+				return_command = *command_ptr + (src - *command_ptr) + 1;
+				break;
+
+			case '\\':
+				src++;
+				if (!*src) {
+					bb_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] || flag & LASH_OPT_SAW_QUOTE) {
+		argc_l++;
+	}
+	if (!argc_l) {
+		free_job(job);
+		return 0;
+	}
+	prog->argv[argc_l] = NULL;
+
+	if (!return_command) {
+		job->text = xstrdup(*command_ptr);
+	} else {
+		/* This leaves any trailing spaces, which is a bit sloppy */
+		job->text = xstrndup(*command_ptr, return_command - *command_ptr);
+	}
+
+	*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)
+{
+	const struct built_in_command *x;
+
+	/* 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.
+	 */
+	/* Check if the command matches any of the forking builtins. */
+	for (x = bltins; x <= &VEC_LAST(bltins); x++) {
+		if (strcmp(child->argv[0], x->cmd) == 0) {
+			_exit(x->function(child));
+		}
+	}
+
+	/* Check if the command matches any busybox internal
+	 * commands ("applets") here.  Following discussions from
+	 * November 2000 on busybox@busybox.net, don't use
+	 * bb_get_last_path_component_nostrip().  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.
+	 */
+	if (ENABLE_FEATURE_SH_STANDALONE) {
+		run_applet_and_exit(child->argv[0], child->argv);
+	}
+
+	execvp(child->argv[0], child->argv);
+
+	/* Do not use bb_perror_msg_and_die() here, since we must not
+	 * call exit() but should call _exit() instead */
+	bb_simple_perror_msg(child->argv[0]);
+	_exit(EXIT_FAILURE);
+}
+
+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 ENABLE_LASH_JOB_CONTROL
+	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;
+		last_bg_pid = newjob->progs[newjob->num_progs - 1].pid;
+	} else {
+		newjob->job_list->fg = thejob;
+
+		/* move the new process group into the foreground */
+		/* Ignore errors since child could have already exited */
+		tcsetpgrp(shell_terminal, newjob->pgrp);
+	}
+#endif
+}
+
+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 */
+	const struct built_in_command *x;
+	struct child_prog *child;
+
+	nextin = 0;
+	for (i = 0; i < newjob->num_progs; i++) {
+		child = &(newjob->progs[i]);
+
+		nextout = 1;
+		if ((i + 1) < newjob->num_progs) {
+			xpipe(pipefds);
+			nextout = pipefds[1];
+		} else if (outpipe[1] != -1) {
+			nextout = outpipe[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) {
+			int rcode;
+			int squirrel[] = {-1, -1, -1};
+
+			/* Check if the command sets an environment variable. */
+			if (strchr(child->argv[0], '=') != NULL) {
+				child->argv[1] = child->argv[0];
+				return builtin_export(child);
+			}
+
+			for (x = bltins; x <= &VEC_LAST(bltins); x++) {
+				if (strcmp(child->argv[0], x->cmd) == 0) {
+					setup_redirects(child, squirrel);
+					rcode = x->function(child);
+					restore_redirects(squirrel);
+					return rcode;
+				}
+			}
+#if ENABLE_FEATURE_SH_STANDALONE
+			{
+				const struct bb_applet *a = find_applet_by_name(child->argv[i]);
+				if (a && a->nofork) {
+					setup_redirects(child, squirrel);
+					rcode = run_nofork_applet(a, child->argv + i);
+					restore_redirects(squirrel);
+					return rcode;
+				}
+			}
+#endif
+		}
+
+#if BB_MMU
+		child->pid = fork();
+#else
+		child->pid = vfork();
+#endif
+		if (!child->pid) {
+			/* 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 open filehandles. */
+			while (close_me_list)
+				close((long)llist_pop(&close_me_list));
+
+			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;
+	int i;
+	int inbg = 0;
+	int status;
+#if ENABLE_LASH_JOB_CONTROL
+	pid_t  parent_pgrp;
+	/* save current owner of TTY so we can restore it on exit */
+	parent_pgrp = tcgetpgrp(shell_terminal);
+#endif
+	newjob.job_list = &job_list;
+	newjob.job_context = DEFAULT_CONTEXT;
+
+	command = xzalloc(BUFSIZ);
+
+	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_bufsiz(input, command))
+					break;
+				next_command = command;
+			}
+
+			if (!expand_arguments(next_command)) {
+				free(command);
+				command = xzalloc(BUFSIZ);
+				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 = xzalloc(BUFSIZ);
+				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) {
+				if (errno != ECHILD) {
+					bb_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;
+
+				last_return_code = WEXITSTATUS(status);
+
+				if (!job_list.fg->running_progs) {
+					/* child exited */
+					remove_job(&job_list, job_list.fg);
+					job_list.fg = NULL;
+				}
+			}
+#if ENABLE_LASH_JOB_CONTROL
+			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)
+					bb_perror_msg("tcsetpgrp");
+			}
+#endif
+		}
+	}
+	free(command);
+
+#if ENABLE_LASH_JOB_CONTROL
+	/* return controlling TTY back to parent process group before exiting */
+	if (tcsetpgrp(shell_terminal, parent_pgrp) && errno != ENOTTY)
+		bb_perror_msg("tcsetpgrp");
+#endif
+
+	/* return exit status if called with "-c" */
+	if (input == NULL && WIFEXITED(status))
+		return WEXITSTATUS(status);
+
+	return 0;
+}
+
+#if ENABLE_FEATURE_CLEAN_UP
+static void free_memory(void)
+{
+	free(cwd);
+
+	if (job_list.fg && !job_list.fg->running_progs) {
+		remove_job(&job_list, job_list.fg);
+	}
+}
+#else
+void free_memory(void);
+#endif
+
+#if ENABLE_LASH_JOB_CONTROL
+/* 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(void)
+{
+	int status;
+	pid_t shell_pgrp;
+
+	/* Loop until we are in the foreground.  */
+	while ((status = tcgetpgrp(shell_terminal)) >= 0) {
+		shell_pgrp = getpgrp();
+		if (status == shell_pgrp) {
+			break;
+		}
+		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.  */
+	setsid();
+	shell_pgrp = getpid();
+	setpgid(shell_pgrp, shell_pgrp);
+
+	/* Grab control of the terminal.  */
+	tcsetpgrp(shell_terminal, shell_pgrp);
+}
+#else
+static inline void setup_job_control(void)
+{
+}
+#endif
+
+int lash_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int lash_main(int argc, char **argv)
+{
+	unsigned opt;
+	FILE *input = stdin;
+
+	global_argc = argc;
+	global_argv = argv;
+
+#if ENABLE_FEATURE_EDITING
+	line_input_state = new_line_input_t(FOR_SHELL);
+#endif
+
+	/* These variables need re-initializing when recursing */
+	last_jobid = 0;
+	close_me_list = NULL;
+	job_list.head = NULL;
+	job_list.fg = NULL;
+	last_return_code = 1;
+
+	if (global_argv[0] && global_argv[0][0] == '-') {
+		FILE *prof_input;
+		prof_input = fopen("/etc/profile", "r");
+		if (prof_input) {
+			llist_add_to(&close_me_list, (void *)(long)fileno(prof_input));
+			/* Now run the file */
+			busy_loop(prof_input);
+			fclose_if_not_stdin(prof_input);
+			llist_pop(&close_me_list);
+		}
+	}
+
+	opt = getopt32(argv, "+ic:", &local_pending_command);
+#define LASH_OPT_i (1<<0)
+#define LASH_OPT_c (1<<1)
+	if (opt & LASH_OPT_c) {
+		input = NULL;
+		optind++;
+		global_argv += optind;
+	}
+	/* 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 (global_argv[optind] == NULL && input == stdin
+	 && isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)
+	) {
+		opt |= LASH_OPT_i;
+	}
+	setup_job_control();
+	if (opt & LASH_OPT_i) {
+		/* Looks like they want an interactive shell */
+		if (!ENABLE_FEATURE_SH_EXTRA_QUIET) {
+			printf("\n\n%s built-in shell (lash)\n"
+					"Enter 'help' for a list of built-in commands.\n\n",
+					bb_banner);
+		}
+	} else if (!local_pending_command && global_argv[optind]) {
+		//printf( "optind=%d  argv[optind]='%s'\n", optind, argv[optind]);
+		input = xfopen(global_argv[optind], "r");
+		/* be lazy, never mark this closed */
+		llist_add_to(&close_me_list, (void *)(long)fileno(input));
+	}
+
+	/* initialize the cwd -- this is never freed...*/
+	update_cwd();
+
+	if (ENABLE_FEATURE_CLEAN_UP) atexit(free_memory);
+
+	if (ENABLE_FEATURE_EDITING) cmdedit_set_initial_prompt();
+	else PS1 = NULL;
+
+	return busy_loop(input);
+}