X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=shell%2Flash.c;h=1fcd63bdf5f731d6af2c55257a049a07913daa59;hb=1dc0ccafddf9b5f540008b7cabbf3ab1f4f53ee3;hp=d321c929bb785fafae6b88b41dbc1978c26647d1;hpb=1365bb786155439041b7777d31bcfadb5276e824;p=oweals%2Fbusybox.git

diff --git a/shell/lash.c b/shell/lash.c
index d321c929b..1fcd63bdf 100644
--- a/shell/lash.c
+++ b/shell/lash.c
@@ -2,8 +2,7 @@
 /*
  * lash -- the BusyBox Lame-Ass SHell
  *
- * Copyright (C) 1999,2000,2001 by Lineo, inc.
- * Written by Erik Andersen <andersen@lineo.com>, <andersee@debian.org>
+ * Copyright (C) 1999-2003 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
@@ -25,26 +24,12 @@
  *
  */
 
-/* The parsing engine of this program is officially at a dead-end.
- * Future work in that direction should move to the work posted
- * at http://doolittle.faludi.com/~larry/parser.html .
- * A start on the integration of that work with the rest of sh.c
- * is at http://codepoet.org/sh.c .
+/* 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...
  */
-//
-//This works pretty well now, and is now on by default.
-#define BB_FEATURE_SH_ENVIRONMENT
-//
-//Backtick support has some problems, use at your own risk!
-//#define BB_FEATURE_SH_BACKTICKS
-//
-//If, then, else, etc. support..  This should now behave basically
-//like any other Bourne shell...
-#define BB_FEATURE_SH_IF_EXPRESSIONS
-//
-/* This is currently a little broken... */
-//#define HANDLE_CONTINUATION_CHARS
-//
+
 //For debugging/development on the shell only...
 //#define DEBUG_SHELL
 
@@ -60,23 +45,18 @@
 #include <sys/wait.h>
 #include <unistd.h>
 #include <getopt.h>
+#include <termios.h>
+#include "busybox.h"
+#include "cmdedit.h"
 
-//#undef __GLIBC__
-//#undef __UCLIBC__
+#ifdef CONFIG_LOCALE_SUPPORT
+#include <locale.h>
+#endif
 
-#if ( (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1) ) || defined (__UCLIBC__) 
-#include <wordexp.h>
-#define expand_t	wordexp_t
-#undef BB_FEATURE_SH_BACKTICKS
-#else
 #include <glob.h>
 #define expand_t	glob_t
-#endif	
-#include "busybox.h"
-#include "cmdedit.h"
 
 
-static const int MAX_LINE = 256;	/* size of input buffer for cwd data */
 static const int MAX_READ = 128;	/* size of input buffer for `read' builtin */
 #define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
 
@@ -139,7 +119,6 @@ struct close_me {
 
 /* function prototypes for builtins */
 static int builtin_cd(struct child_prog *cmd);
-static int builtin_env(struct child_prog *dummy);
 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);
@@ -150,14 +129,6 @@ 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);
-#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
-static int builtin_if(struct child_prog *cmd);
-static int builtin_then(struct child_prog *cmd);
-static int builtin_else(struct child_prog *cmd);
-static int builtin_fi(struct child_prog *cmd);
-/* function prototypes for shell stuff */
-static int run_command_predicate(char *cmd);
-#endif
 
 
 /* function prototypes for shell stuff */
@@ -165,6 +136,7 @@ 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 void remove_job(struct jobset *j_list, struct job *job);
 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]);
@@ -187,45 +159,36 @@ static struct built_in_command bltins[] = {
 	{"read", "Input environment variable", builtin_read},
 	{".", "Source-in and run commands in a file", builtin_source},
 	/* to do: add ulimit */
-#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
-	{"if", NULL, builtin_if},
-	{"then", NULL, builtin_then},
-	{"else", NULL, builtin_else},
-	{"fi", NULL, builtin_fi},
-#endif
 	{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[] = {
-	{"env", "Print all environment variables", builtin_env},
 	{"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 */
+static int shell_context;  /* Type prompt trigger (PS1 or PS2) */
 
 
 /* Globals that are static to this file */
-static char *cwd;
+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;
-#ifdef BB_FEATURE_SH_ENVIRONMENT
-static int last_bg_pid;
 static int last_return_code;
-static int show_x_trace;
-#endif
-#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
-static char syntax_err[]="syntax error near unexpected token";
-#endif
+static int last_bg_pid;
+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, ...)
@@ -248,25 +211,16 @@ static inline void debug_printf(const char *format, ...) { }
 builtin   previous use      notes
 ------ -----------------  ---------
 cd      cmd->progs[0]
-env     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]  passes cmd, job_list to builtin_env(), which ignores them
+export  cmd->progs[0]
 source  cmd->progs[0]
 unset   cmd->progs[0]
 read    cmd->progs[0]
-if      cmd->job_context,  cmd->text
-then    cmd->job_context,  cmd->text
-else    cmd->job_context,  cmd->text
-fi      cmd->job_context
-
-The use of cmd->text by if/then/else/fi is hopelessly hacky.
-Would it work to increment cmd->progs[0]->argv and recurse,
-somewhat like builtin_exec does?
 
 I added "struct job *family;" to struct child_prog,
 and switched API to builtin_foo(struct child_prog *child);
@@ -286,25 +240,15 @@ static int builtin_cd(struct child_prog *child)
 	else
 		newdir = child->argv[1];
 	if (chdir(newdir)) {
-		printf("cd: %s: %s\n", newdir, strerror(errno));
+		printf("cd: %s: %m\n", newdir);
 		return EXIT_FAILURE;
 	}
-	getcwd(cwd, sizeof(char)*MAX_LINE);
-
+	cwd = xgetcwd((char *)cwd);
+	if (!cwd)
+		cwd = bb_msg_unknown;
 	return EXIT_SUCCESS;
 }
 
-/* built-in 'env' handler */
-static int builtin_env(struct child_prog *dummy)
-{
-	char **e;
-
-	for (e = environ; *e; e++) {
-		printf( "%s\n", *e);
-	}
-	return (0);
-}
-
 /* built-in 'exec' handler */
 static int builtin_exec(struct child_prog *child)
 {
@@ -328,38 +272,40 @@ static int builtin_exit(struct child_prog *child)
 /* built-in 'fg' and 'bg' handler */
 static int builtin_fg_bg(struct child_prog *child)
 {
-	int i, jobNum;
+	int i, jobnum;
 	struct job *job=NULL;
-	
-	if (!child->argv[1] || child->argv[2]) {
-		error_msg("%s: exactly one argument is expected",
-				child->argv[0]);
-		return EXIT_FAILURE;
-	}
 
-	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 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) {
+			bb_error_msg("%s: no current job", child->argv[0]);
+			return EXIT_FAILURE;
+		}
+	} else {
+		if (sscanf(child->argv[1], "%%%d", &jobnum) != 1) {
+			bb_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) {
+			bb_error_msg("%s: %d: no such job", child->argv[0], jobnum);
+			return EXIT_FAILURE;
 		}
-	}
-
-	if (!job) {
-		error_msg("%s: unknown job %d",
-				child->argv[0], jobNum);
-		return EXIT_FAILURE;
 	}
 
 	if (*child->argv[0] == 'f') {
-		/* Make this job the foreground job */
-		/* suppress messages when run from /linuxrc mag@sysgo.de */
-		if (tcsetpgrp(0, job->pgrp) && errno != ENOTTY)
-			perror_msg("tcsetpgrp"); 
+		/* Put the job into the foreground.  */
+		tcsetpgrp(shell_terminal, job->pgrp);
+
 		child->family->job_list->fg = job;
 	}
 
@@ -367,10 +313,16 @@ static int builtin_fg_bg(struct child_prog *child)
 	for (i = 0; i < job->num_progs; i++)
 		job->progs[i].is_stopped = 0;
 
-	kill(-job->pgrp, SIGCONT);
-
 	job->stopped_progs = 0;
 
+	if ( (i=kill(- job->pgrp, SIGCONT)) < 0) {
+		if (i == ESRCH) {
+			remove_job(&job_list, job);
+		} else {
+			bb_perror_msg("kill (SIGCONT)");
+		}
+	}
+
 	return EXIT_SUCCESS;
 }
 
@@ -416,8 +368,10 @@ static int builtin_jobs(struct child_prog *child)
 /* built-in 'pwd' handler */
 static int builtin_pwd(struct child_prog *dummy)
 {
-	getcwd(cwd, MAX_LINE);
-	printf( "%s\n", cwd);
+	cwd = xgetcwd((char *)cwd);
+	if (!cwd)
+		cwd = bb_msg_unknown;
+	puts(cwd);
 	return EXIT_SUCCESS;
 }
 
@@ -425,13 +379,30 @@ static int builtin_pwd(struct child_prog *dummy)
 static int builtin_export(struct child_prog *child)
 {
 	int res;
+	char *v = child->argv[1];
 
-	if (child->argv[1] == NULL) {
-		return (builtin_env(child));
+	if (v == NULL) {
+		char **e;
+		for (e = environ; *e; e++) {
+			puts(*e);
+		}
+		return 0;
 	}
-	res = putenv(child->argv[1]);
+	res = putenv(v);
 	if (res)
-		fprintf(stderr, "export: %s\n", strerror(errno));
+		fprintf(stderr, "export: %m\n");
+#ifdef CONFIG_FEATURE_SH_FANCY_PROMPT
+	if (strncmp(v, "PS1=", 4)==0)
+		PS1 = getenv("PS1");
+#endif
+
+#ifdef CONFIG_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);
 }
 
@@ -444,7 +415,7 @@ static int builtin_read(struct child_prog *child)
 
 	if (child->argv[1]) {
 		/* argument (VAR) given: put "VAR=" into buffer */
-		strcpy(string, child->argv[1]);
+		safe_strncpy(string, child->argv[1], MAX_READ-1);
 		len = strlen(string);
 		string[len++] = '=';
 		string[len]   = '\0';
@@ -461,7 +432,7 @@ static int builtin_read(struct child_prog *child)
 		if((s = strdup(string)))
 			res = putenv(s);
 		if (res)
-			fprintf(stderr, "read: %s\n", strerror(errno));
+			fprintf(stderr, "read: %m\n");
 	}
 	else
 		fgets(string, sizeof(string), stdin);
@@ -469,102 +440,6 @@ static int builtin_read(struct child_prog *child)
 	return (res);
 }
 
-#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
-/* Built-in handler for 'if' commands */
-static int builtin_if(struct child_prog *child)
-{
-	struct job *cmd = child->family;
-	int status;
-	char* charptr1=cmd->text+3; /* skip over the leading 'if ' */
-
-	/* Now run the 'if' command */
-	debug_printf( "job=%p entering builtin_if ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
-	status = run_command_predicate(charptr1);
-	debug_printf( "if test returned ");
-	if (status == 0) {
-		debug_printf( "TRUE\n");
-		cmd->job_context |= IF_TRUE_CONTEXT;
-	} else {
-		debug_printf( "FALSE\n");
-		cmd->job_context |= IF_FALSE_CONTEXT;
-	}
-	debug_printf("job=%p builtin_if set job context to %x\n", cmd, cmd->job_context);
-	shell_context++;
-
-	return status;
-}
-
-/* Built-in handler for 'then' (part of the 'if' command) */
-static int builtin_then(struct child_prog *child)
-{
-	struct job *cmd = child->family;
-	char* charptr1=cmd->text+5; /* skip over the leading 'then ' */
-
-	debug_printf( "job=%p entering builtin_then ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
-	if (! (cmd->job_context & (IF_TRUE_CONTEXT|IF_FALSE_CONTEXT))) {
-		shell_context = 0; /* Reset the shell's context on an error */
-		error_msg("%s `then'", syntax_err);
-		return EXIT_FAILURE;
-	}
-
-	cmd->job_context |= THEN_EXP_CONTEXT;
-	debug_printf("job=%p builtin_then set job context to %x\n", cmd, cmd->job_context);
-
-	/* If the if result was FALSE, skip the 'then' stuff */
-	if (cmd->job_context & IF_FALSE_CONTEXT) {
-		return EXIT_SUCCESS;
-	}
-
-	/* Seems the if result was TRUE, so run the 'then' command */
-	debug_printf( "'then' now running '%s'\n", charptr1);
-
-	return(run_command_predicate(charptr1));
-}
-
-/* Built-in handler for 'else' (part of the 'if' command) */
-static int builtin_else(struct child_prog *child)
-{
-	struct job *cmd = child->family;
-	char* charptr1=cmd->text+5; /* skip over the leading 'else ' */
-
-	debug_printf( "job=%p entering builtin_else ('%s')-- context=%d\n", cmd, charptr1, cmd->job_context);
-
-	if (! (cmd->job_context & THEN_EXP_CONTEXT)) {
-		shell_context = 0; /* Reset the shell's context on an error */
-		error_msg("%s `else'", syntax_err);
-		return EXIT_FAILURE;
-	}
-	/* If the if result was TRUE, skip the 'else' stuff */
-	if (cmd->job_context & IF_TRUE_CONTEXT) {
-		return EXIT_SUCCESS;
-	}
-
-	cmd->job_context |= ELSE_EXP_CONTEXT;
-	debug_printf("job=%p builtin_else set job context to %x\n", cmd, cmd->job_context);
-
-	/* Now run the 'else' command */
-	debug_printf( "'else' now running '%s'\n", charptr1);
-	return(run_command_predicate(charptr1));
-}
-
-/* Built-in handler for 'fi' (part of the 'if' command) */
-static int builtin_fi(struct child_prog *child)
-{
-	struct job *cmd = child->family;
-	debug_printf( "job=%p entering builtin_fi ('%s')-- context=%d\n", cmd, "", cmd->job_context);
-	if (! (cmd->job_context & (IF_TRUE_CONTEXT|IF_FALSE_CONTEXT))) {
-		shell_context = 0; /* Reset the shell's context on an error */
-		error_msg("%s `fi'", syntax_err);
-		return EXIT_FAILURE;
-	}
-	/* Clear out the if and then context bits */
-	cmd->job_context &= ~(IF_TRUE_CONTEXT|IF_FALSE_CONTEXT|THEN_EXP_CONTEXT|ELSE_EXP_CONTEXT);
-	debug_printf("job=%p builtin_fi set job context to %x\n", cmd, cmd->job_context);
-	shell_context--;
-	return EXIT_SUCCESS;
-}
-#endif
-
 /* Built-in '.' handler (read-in and execute commands from file) */
 static int builtin_source(struct child_prog *child)
 {
@@ -601,26 +476,6 @@ static int builtin_unset(struct child_prog *child)
 	return EXIT_SUCCESS;
 }
 
-#ifdef BB_FEATURE_SH_IF_EXPRESSIONS
-/* currently used by if/then/else.
- *
- * Reparsing the command line for this purpose is gross,
- * incorrect, and fundamentally unfixable; in particular,
- * think about what happens with command substitution.
- * We really need to pull out the run, wait, return status
- * functionality out of busy_loop so we can child->argv++
- * and use that, without going back through parse_command.
- */
-static int run_command_predicate(char *cmd)
-{
-	int n=strlen(cmd);
-	local_pending_command = xmalloc(n+1);
-	strncpy(local_pending_command, cmd, n); 
-	local_pending_command[n]='\0';
-	return( busy_loop(NULL));
-}
-#endif
-
 static void mark_open(int fd)
 {
 	struct close_me *new = xmalloc(sizeof(struct close_me));
@@ -633,7 +488,7 @@ 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");
+		bb_error_msg_and_die("corrupt close_me");
 	tmp = close_me_head;
 	close_me_head = close_me_head->next;
 	free(tmp);
@@ -655,6 +510,7 @@ static void close_all()
 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);
@@ -662,33 +518,39 @@ static void free_job(struct job *cmd)
 			free(cmd->progs[i].redirects);
 	}
 	free(cmd->progs);
-	if (cmd->text)
-		free(cmd->text);
+	free(cmd->text);
 	free(cmd->cmdbuf);
+	keep = cmd->job_list;
 	memset(cmd, 0, sizeof(struct job));
+	cmd->job_list = keep;
 }
 
-/* remove a job from the job_list */
-static void remove_job(struct jobset *job_list, struct job *job)
+/* 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 == job_list->head) {
-		job_list->head = job->next;
+	if (job == j_list->head) {
+		j_list->head = job->next;
 	} else {
-		prevjob = job_list->head;
+		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 *job_list)
+static void checkjobs(struct jobset *j_list)
 {
 	struct job *job;
 	pid_t childpid;
@@ -696,7 +558,7 @@ static void checkjobs(struct jobset *job_list)
 	int prognum = 0;
 
 	while ((childpid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
-		for (job = job_list->head; job; job = job->next) {
+		for (job = j_list->head; job; job = job->next) {
 			prognum = 0;
 			while (prognum < job->num_progs &&
 				   job->progs[prognum].pid != childpid) prognum++;
@@ -715,22 +577,28 @@ static void checkjobs(struct jobset *job_list)
 
 			if (!job->running_progs) {
 				printf(JOB_STATUS_FORMAT, job->jobid, "Done", job->text);
-				remove_job(job_list, job);
+				last_jobid=0;
+				remove_job(j_list, job);
 			}
 		} else {
 			/* child stopped */
 			job->stopped_progs++;
 			job->progs[prognum].is_stopped = 1;
 
+#if 0
+			/* Printing this stuff is a pain, since it tends to
+			 * overwrite the prompt an inconveinient moments.  So
+			 * don't do that.  */
 			if (job->stopped_progs == job->num_progs) {
 				printf(JOB_STATUS_FORMAT, job->jobid, "Stopped",
 					   job->text);
 			}
+#endif	
 		}
 	}
 
 	if (childpid == -1 && errno != ECHILD)
-		perror_msg("waitpid");
+		bb_perror_msg("waitpid");
 }
 
 /* squirrel != NULL means we squirrel away copies of stdin, stdout,
@@ -759,8 +627,7 @@ static int setup_redirects(struct child_prog *prog, int squirrel[])
 		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!) */
-			error_msg("error opening %s: %s", redir->filename,
-					strerror(errno));
+			bb_perror_msg("error opening %s", redir->filename);
 			return 1;
 		}
 
@@ -790,57 +657,34 @@ static void restore_redirects(int squirrel[])
 	}
 }
 
-#if defined(BB_FEATURE_SH_SIMPLE_PROMPT)
-static char* setup_prompt_string(int state)
+static inline void cmdedit_set_initial_prompt(void)
 {
-       char prompt_str[BUFSIZ];
-
-       /* Set up the prompt */
-       if (state == 0) {
-               /* simple prompt */
-               sprintf(prompt_str, "%s %s", cwd, ( geteuid() != 0 ) ?  "$ ":"# ");
-       } else {
-               strcpy(prompt_str,"> ");
-       }
-
-       return(strdup(prompt_str));  /* Must free this memory */
-}
-
+#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
+	PS1 = NULL;
 #else
+	PS1 = getenv("PS1");
+	if(PS1==0)
+		PS1 = "\\w \\$ ";
+#endif	
+}
 
-static char* setup_prompt_string(int state)
+static inline void setup_prompt_string(char **prompt_str)
 {
-	char user[9],buf[255],*s;
-	char prompt[3];
-	char prompt_str[BUFSIZ];
-
+#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
 	/* Set up the prompt */
-	if (state == 0) {
-		/* get User Name and setup prompt */
-		strcpy(prompt,( geteuid() != 0 ) ? "$ ":"# ");
-		my_getpwuid(user, geteuid());
-
-		/* get HostName */
-		gethostname(buf, 255);
-		s = strchr(buf, '.');
-		if (s) {
-			*s = 0;
-		}
+	if (shell_context == 0) {
+		free(PS1);
+		PS1=xmalloc(strlen(cwd)+4);
+		sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ?  "$ ":"# ");
+		*prompt_str = PS1;
 	} else {
-		strcpy(prompt,"> ");
+		*prompt_str = PS2;
 	}
-
-	if (state == 0) {
-		snprintf(prompt_str, BUFSIZ-1, "[%s@%s %s]%s", user, buf, 
-				get_last_path_component(cwd), prompt);
-	} else {
-		sprintf(prompt_str, "%s", prompt);
-	}
-	return(strdup(prompt_str));  /* Must free this memory */
+#else
+	*prompt_str = (shell_context==0)? PS1 : PS2;
+#endif	
 }
 
-#endif 
-
 static int get_command(FILE * source, char *command)
 {
 	char *prompt_str;
@@ -857,9 +701,9 @@ static int get_command(FILE * source, char *command)
 	}
 
 	if (source == stdin) {
-		prompt_str = setup_prompt_string(shell_context);
+		setup_prompt_string(&prompt_str);
 
-#ifdef BB_FEATURE_SH_COMMAND_EDITING
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
 		/*
 		** enable command line editing only while a command line
 		** is actually being read; otherwise, we'll end up bequeathing
@@ -867,12 +711,9 @@ static int get_command(FILE * source, char *command)
 		** child processes (rob@sysgo.de)
 		*/
 		cmdedit_read_input(prompt_str, command);
-		cmdedit_terminate();
-		free(prompt_str);
 		return 0;
 #else
 		fputs(prompt_str, stdout);
-		free(prompt_str);
 #endif
 	}
 
@@ -882,13 +723,9 @@ static int get_command(FILE * source, char *command)
 		return 1;
 	}
 
-	/* remove trailing newline */
-	chomp(command);
-
 	return 0;
 }
 
-#ifdef BB_FEATURE_SH_ENVIRONMENT
 static char* itoa(register int i)
 {
 	static char a[7]; /* Max 7 ints */
@@ -908,109 +745,116 @@ static char* itoa(register int i)
 		*--b = '-';
 	return b;
 }
-#endif	
+
+char * strsep_space( char *string, int * ix)
+{
+	char *token, *begin;
+
+	begin = string;
+
+	/* Short circuit the trivial case */
+	if ( !string || ! string[*ix])
+		return NULL;
+
+	/* Find the end of the token. */
+	while( string && 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 && string[*ix] && isspace(string[*ix]) ) {
+		(*ix)++;
+	}
+
+	if (! string && *ix==0) {
+		/* Nothing useful was found */
+		return NULL;
+	}
+
+	token = xmalloc(*ix+1);
+	token[*ix] = '\0';
+	strncpy(token, string,  *ix); 
+
+	return token;
+}
 
 static int expand_arguments(char *command)
 {
-#ifdef BB_FEATURE_SH_ENVIRONMENT
+	int total_length=0, length, i, retval, ix = 0;
 	expand_t expand_result;
+	char *tmpcmd, *cmd, *cmd_copy;
 	char *src, *dst, *var;
-	int i=0, length, total_length=0, retval;
-	const char *out_of_space = "out of space during expansion"; 
-#endif
+	const char *out_of_space = "out of space during expansion";
+	int flags = GLOB_NOCHECK
+#ifdef GLOB_BRACE
+		| GLOB_BRACE
+#endif	
+#ifdef GLOB_TILDE
+		| GLOB_TILDE
+#endif	
+		;
 
 	/* get rid of the terminating \n */
 	chomp(command);
 
-#ifdef BB_FEATURE_SH_ENVIRONMENT
-
-
-#if ( (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1) ) || defined (__UCLIBC__) 
-	/* This first part uses wordexp() which is a wonderful C lib 
-	 * function which expands nearly everything.  */ 
-	retval = wordexp (command, &expand_result, 0);
-	if (retval == WRDE_NOSPACE) {
-		/* Mem may have been allocated... */
-		wordfree (&expand_result);
-		error_msg(out_of_space);
-		return FALSE;
-	}
-	if (retval < 0) {
-		/* Some other error.  */
-		error_msg("syntax error");
-		return FALSE;
-	}
-	
-	if (expand_result.we_wordc > 0) {
-		/* Convert from char** (one word per string) to a simple char*,
-		 * but don't overflow command which is BUFSIZ in length */
-		*command = '\0';
-		while (i < expand_result.we_wordc && total_length < BUFSIZ) {
-			length=strlen(expand_result.we_wordv[i])+1;
-			if (BUFSIZ-total_length-length <= 0) {
-				error_msg(out_of_space);
-				return FALSE;
-			}
-			strcat(command+total_length, expand_result.we_wordv[i++]);
-			strcat(command+total_length, " ");
-			total_length+=length;
+	/* 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);
 		}
-		wordfree (&expand_result);
+		ix++;
 	}
-#else
-
-	/* Ok.  They don't have a recent glibc and they don't have uClibc.  Chances
-	 * are about 100% they don't have wordexp(). So instead the best we can do
-	 * is use glob and then fixup environment variables and such ourselves.
-	 * This is better then nothing, but certainly not perfect */
+	/* 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) */
-	{
-        
-		int flags = GLOB_NOCHECK|GLOB_BRACE|GLOB_TILDE;
-		char * tmpcmd;
-		/* We need a clean copy, so strsep can mess up the copy while
-		 * we write stuff into the original (in a minute) */
-		char * cmd = strdup(command);
-		*command = '\0';
-		for (tmpcmd = cmd; (tmpcmd = strsep(&cmd, " \t")) != NULL;) {
-			if (*tmpcmd == '\0')
-				break;
-			retval = glob(tmpcmd, flags, NULL, &expand_result);
-			if (retval == GLOB_NOSPACE) {
-				/* Mem may have been allocated... */
-				globfree (&expand_result);
-				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. */
-				error_msg("syntax error");
-				return FALSE;
-			} else {
+
+	/* 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 = bb_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])+1;
-					if (BUFSIZ-total_length-length <= 0) {
-						error_msg(out_of_space);
-						return FALSE;
-					}
-					strcat(command+total_length, expand_result.gl_pathv[i]);
-					strcat(command+total_length, " ");
-					total_length+=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;
 				}
-				globfree (&expand_result);
+				strcat(command+total_length, " ");
+				total_length+=1;
+				strcat(command+total_length, expand_result.gl_pathv[i]);
+				total_length+=length;
 			}
+			globfree (&expand_result);
 		}
-		free(cmd);
-		trim(command);
 	}
-	
-#endif	
+	free(cmd_copy);
+	trim(command);
 
 	/* Now do the shell variable substitutions which 
 	 * wordexp can't do for us, namely $? and $! */
@@ -1027,9 +871,9 @@ static int expand_arguments(char *command)
 				else
 					var = itoa(last_bg_pid);
 				break;
-				/* Everything else like $$, $#, $[0-9], etc should all be
+				/* 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
+				 * 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 '$':
@@ -1041,11 +885,11 @@ static int expand_arguments(char *command)
 			case '0':case '1':case '2':case '3':case '4':
 			case '5':case '6':case '7':case '8':case '9':
 				{
-					int index=*(dst + 1)-48;
-					if (index >= argc) {
+					int ixx=*(dst+1)-48+1;
+					if (ixx >= argc) {
 						var='\0';
 					} else {
-						var = argv[index];
+						var = argv[ixx];
 					}
 				}
 				break;
@@ -1058,25 +902,24 @@ static int expand_arguments(char *command)
 		} else {
 			/* Looks like an environment variable */
 			char delim_hold;
-			int num_skip_chars=1;
+			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=2;
+				num_skip_chars=1;
 			} else {
-				src=strpbrk(dst+1, " \t~`!$^&*()=|\\[];\"'<>?./");
+				src=dst+1;
+				while(isalnum(*src) || *src=='_') src++;
 			}
 			if (src == NULL) {
 				src = dst+dstlen;
 			}
 			delim_hold=*src;
 			*src='\0';  /* temporary */
-			var = getenv(dst + num_skip_chars);
+			var = getenv(dst + 1 + num_skip_chars);
 			*src=delim_hold;
-			if (num_skip_chars==2) {
-				src++;
-			}
+			src += num_skip_chars;
 		}
 		if (var == NULL) {
 			/* Seems we got an un-expandable variable.  So delete it. */
@@ -1086,20 +929,18 @@ static int expand_arguments(char *command)
 			int subst_len = strlen(var);
 			int trail_len = strlen(src);
 			if (dst+subst_len+trail_len >= command+BUFSIZ) {
-				error_msg(out_of_space);
+				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);
-			*(dst+subst_len+trail_len)='\0';
+			memmove(dst+subst_len, src, trail_len+1);
 			/* Now copy in the new stuff */
 			memcpy(dst, var, subst_len);
 			src = dst+subst_len;
 		}
 	}
 
-#endif	
 	return TRUE;
 }
 
@@ -1116,7 +957,7 @@ static int parse_command(char **command_ptr, struct job *job, int *inbg)
 	int argc_l = 0;
 	int done = 0;
 	int argv_alloced;
-	int i;
+	int i, saw_quote = 0;
 	char quote = '\0';
 	int count;
 	struct child_prog *prog;
@@ -1164,7 +1005,7 @@ static int parse_command(char **command_ptr, struct job *job, int *inbg)
 			if (*src == '\\') {
 				src++;
 				if (!*src) {
-					error_msg("character expected after \\");
+					bb_error_msg("character expected after \\");
 					free_job(job);
 					return 1;
 				}
@@ -1178,7 +1019,7 @@ static int parse_command(char **command_ptr, struct job *job, int *inbg)
 					   *src == ']') *buf++ = '\\';
 			*buf++ = *src;
 		} else if (isspace(*src)) {
-			if (*prog->argv[argc_l]) {
+			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) {
@@ -1188,12 +1029,14 @@ static int parse_command(char **command_ptr, struct job *job, int *inbg)
 										  argv_alloced);
 				}
 				prog->argv[argc_l] = buf;
+				saw_quote = 0;
 			}
 		} else
 			switch (*src) {
 			case '"':
 			case '\'':
 				quote = *src;
+				saw_quote = 1;
 				break;
 
 			case '#':			/* comment */
@@ -1246,7 +1089,7 @@ static int parse_command(char **command_ptr, struct job *job, int *inbg)
 					chptr++;
 
 				if (!*chptr) {
-					error_msg("file name expected after %c", *src);
+					bb_error_msg("file name expected after %c", *(src-1));
 					free_job(job);
 					job->num_progs=0;
 					return 1;
@@ -1262,10 +1105,10 @@ static int parse_command(char **command_ptr, struct job *job, int *inbg)
 
 			case '|':			/* pipe */
 				/* finish this command */
-				if (*prog->argv[argc_l])
+				if (*prog->argv[argc_l] || saw_quote)
 					argc_l++;
 				if (!argc_l) {
-					error_msg("empty command in pipe");
+					bb_error_msg("empty command in pipe");
 					free_job(job);
 					job->num_progs=0;
 					return 1;
@@ -1292,7 +1135,7 @@ static int parse_command(char **command_ptr, struct job *job, int *inbg)
 					src++;
 
 				if (!*src) {
-					error_msg("empty command in pipe");
+					bb_error_msg("empty command in pipe");
 					free_job(job);
 					job->num_progs=0;
 					return 1;
@@ -1308,119 +1151,12 @@ static int parse_command(char **command_ptr, struct job *job, int *inbg)
 				return_command = *command_ptr + (src - *command_ptr) + 1;
 				break;
 
-#ifdef BB_FEATURE_SH_BACKTICKS
-			case '`':
-				/* Exec a backtick-ed command */
-				/* Besides any previous brokenness, I have not
-				 * updated backtick handling for close_me support.
-				 * I don't know if it needs it or not.  -- LRD */
-				{
-					char* charptr1=NULL, *charptr2;
-					char* ptr=NULL;
-					struct job *newjob;
-					struct jobset njob_list = { NULL, NULL };
-					int pipefd[2];
-					int size;
-
-					ptr=strchr(++src, '`');
-					if (ptr==NULL) {
-						fprintf(stderr, "Unmatched '`' in command\n");
-						free_job(job);
-						return 1;
-					}
-
-					/* Make some space to hold just the backticked command */
-					charptr1 = charptr2 = xmalloc(1+ptr-src);
-					memcpy(charptr1, src, ptr-src);
-					charptr1[ptr-src] = '\0';
-					newjob = xmalloc(sizeof(struct job));
-					newjob->job_list = &njob_list;
-					/* Now parse and run the backticked command */
-					if (!parse_command(&charptr1, newjob, inbg) 
-							&& newjob->num_progs) {
-						pipe(pipefd);
-						run_command(newjob, 0, pipefd);
-					}
-					checkjobs(job->job_list);
-					free_job(newjob);  /* doesn't actually free newjob,
-					                     looks like a memory leak */
-					free(charptr2);
-					
-					/* Make a copy of any stuff left over in the command 
-					 * line after the second backtick */
-					charptr2 = xmalloc(strlen(ptr)+1);
-					memcpy(charptr2, ptr+1, strlen(ptr));
-
-
-					/* Copy the output from the backtick-ed command into the
-					 * command line, making extra room as needed  */
-					--src;
-					charptr1 = xmalloc(BUFSIZ);
-					while ( (size=full_read(pipefd[0], charptr1, BUFSIZ-1)) >0) {
-						int newsize=src - *command_ptr + size + 1 + strlen(charptr2);
-						if (newsize > BUFSIZ) {
-							*command_ptr=xrealloc(*command_ptr, newsize);
-						}
-						memcpy(src, charptr1, size); 
-						src+=size;
-					}
-					free(charptr1);
-					close(pipefd[0]);
-					if (*(src-1)=='\n')
-						--src;
-
-					/* Now paste into the *command_ptr all the stuff 
-					 * leftover after the second backtick */
-					memcpy(src, charptr2, strlen(charptr2)+1);
-					free(charptr2);
-
-					/* Now recursively call parse_command to deal with the new
-					 * and improved version of the command line with the backtick
-					 * results expanded in place... */
-					{
-						struct jobset *jl=job->job_list;
-						free_job(job);
-						job->job_list = jl;
-					}
-					return(parse_command(command_ptr, job, inbg));
-				}
-				break;
-#endif // BB_FEATURE_SH_BACKTICKS
-
 			case '\\':
 				src++;
 				if (!*src) {
-/* This is currently a little broken... */
-#ifdef HANDLE_CONTINUATION_CHARS
-					/* They fed us a continuation char, so continue reading stuff
-					 * on the next line, then tack that onto the end of the current
-					 * command */
-					char *command;
-					int newsize;
-					printf("erik: found a continue char at EOL...\n");
-					command = (char *) xcalloc(BUFSIZ, sizeof(char));
-					if (get_command(input, command)) {
-						error_msg("character expected after \\");
-						free(command);
-						free_job(job);
-						return 1;
-					}
-					newsize = strlen(*command_ptr) + strlen(command) + 2;
-					if (newsize > BUFSIZ) {
-						printf("erik: doing realloc\n");
-						*command_ptr=xrealloc(*command_ptr, newsize);
-					}
-					printf("erik: A: *command_ptr='%s'\n", *command_ptr);
-					memcpy(--src, command, strlen(command)); 
-					printf("erik: B: *command_ptr='%s'\n", *command_ptr);
-					free(command);
-					break;
-#else
-					error_msg("character expected after \\");
-					free(command);
+					bb_error_msg("character expected after \\");
 					free_job(job);
 					return 1;
-#endif
 				}
 				if (*src == '*' || *src == '[' || *src == ']'
 					|| *src == '?') *buf++ = '\\';
@@ -1432,7 +1168,7 @@ static int parse_command(char **command_ptr, struct job *job, int *inbg)
 		src++;
 	}
 
-	if (*prog->argv[argc_l]) {
+	if (*prog->argv[argc_l] || saw_quote) {
 		argc_l++;
 	}
 	if (!argc_l) {
@@ -1462,7 +1198,7 @@ static int parse_command(char **command_ptr, struct job *job, int *inbg)
 static int pseudo_exec(struct child_prog *child)
 {
 	struct built_in_command *x;
-#ifdef BB_FEATURE_SH_STANDALONE_SHELL
+#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
 	char *name;
 #endif
 
@@ -1473,22 +1209,22 @@ static int pseudo_exec(struct child_prog *child)
 	 */
 	for (x = bltins; x->cmd; x++) {
 		if (strcmp(child->argv[0], x->cmd) == 0 ) {
-			exit(x->function(child));
+			_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));
+			bb_applet_name=x->cmd;
+			_exit (x->function(child));
 		}
 	}
-#ifdef BB_FEATURE_SH_STANDALONE_SHELL
+#ifdef CONFIG_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
+	 * November 2000 on busybox@busybox.net, don't use
+	 * bb_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.
@@ -1498,44 +1234,48 @@ static int pseudo_exec(struct child_prog *child)
 	 */
 	name = child->argv[0];
 
-#ifdef BB_FEATURE_SH_APPLETS_ALWAYS_WIN
-	/* If you enable BB_FEATURE_SH_APPLETS_ALWAYS_WIN, then
+#ifdef CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN
+	/* If you enable CONFIG_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);
+	name = bb_get_last_path_component(name);
 #endif
 
 	{
-	    char** argv=child->argv;
+	    char** argv_l=child->argv;
 	    int argc_l;
-	    for(argc_l=0;*argv!=NULL; argv++, 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]);
+
+	/* Do not use bb_perror_msg_and_die() here, since we must not 
+	 * call exit() but should call _exit() instead */
+	fprintf(stderr, "%s: %m\n", child->argv[0]);
+	_exit(EXIT_FAILURE);
 }
 
 static void insert_job(struct job *newjob, int inbg)
 {
 	struct job *thejob;
-	struct jobset *job_list=newjob->job_list;
+	struct jobset *j_list=newjob->job_list;
 
 	/* find the ID for thejob to use */
 	newjob->jobid = 1;
-	for (thejob = job_list->head; thejob; thejob = thejob->next)
+	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 (!job_list->head) {
-		thejob = job_list->head = xmalloc(sizeof(*thejob));
+	if (!j_list->head) {
+		thejob = j_list->head = xmalloc(sizeof(*thejob));
 	} else {
-		for (thejob = job_list->head; thejob->next; thejob = thejob->next) /* nothing */;
+		for (thejob = j_list->head; thejob->next; thejob = thejob->next) /* nothing */;
 		thejob->next = xmalloc(sizeof(*thejob));
 		thejob = thejob->next;
 	}
@@ -1550,16 +1290,15 @@ static void insert_job(struct job *newjob, int inbg)
 		   to the list of backgrounded thejobs and leave it alone */
 		printf("[%d] %d\n", thejob->jobid,
 			   newjob->progs[newjob->num_progs - 1].pid);
-#ifdef BB_FEATURE_SH_ENVIRONMENT
+		last_jobid = newjob->jobid;
 		last_bg_pid=newjob->progs[newjob->num_progs - 1].pid;
-#endif
 	} 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(0, newjob->pgrp) && errno != ENOTTY)
-			perror_msg("tcsetpgrp");
+		if (tcsetpgrp(shell_terminal, newjob->pgrp) && errno != ENOTTY)
+			bb_perror_msg("tcsetpgrp");
 	}
 }
 
@@ -1577,7 +1316,7 @@ static int run_command(struct job *newjob, int inbg, int outpipe[2])
 		child = & (newjob->progs[i]);
 
 		if ((i + 1) < newjob->num_progs) {
-			if (pipe(pipefds)<0) perror_msg_and_die("pipe");
+			if (pipe(pipefds)<0) bb_perror_msg_and_die("pipe");
 			nextout = pipefds[1];
 		} else {
 			if (outpipe[1]!=-1) {
@@ -1587,17 +1326,6 @@ static int run_command(struct job *newjob, int inbg, int outpipe[2])
 			}
 		}
 
-#ifdef BB_FEATURE_SH_ENVIRONMENT
-		if (show_x_trace==TRUE) {
-			int j;
-			fputc('+', stderr);
-			for (j = 0; child->argv[j]; j++) {
-				fputc(' ', stderr);
-				fputs(child->argv[j], stderr);
-			}
-			fputc('\n', stderr);
-		}
-#endif
 
 		/* Check if the command matches any non-forking builtins,
 		 * but only if this is a simple command.
@@ -1618,8 +1346,19 @@ static int run_command(struct job *newjob, int inbg, int outpipe[2])
 			}
 		}
 
-		if (!(child->pid = fork())) {
+#if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__)
+		if (!(child->pid = fork())) 
+#else
+		if (!(child->pid = vfork())) 
+#endif
+		{
+			/* 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();
 
@@ -1680,14 +1419,10 @@ static int busy_loop(FILE * input)
 	newjob.job_context = DEFAULT_CONTEXT;
 
 	/* save current owner of TTY so we can restore it on exit */
-	parent_pgrp = tcgetpgrp(0);
+	parent_pgrp = tcgetpgrp(shell_terminal);
 
 	command = (char *) xcalloc(BUFSIZ, sizeof(char));
 
-	/* don't pay any attention to this signal; it just confuses 
-	   things and isn't really meant for shells anyway */
-	signal(SIGTTOU, SIG_IGN);
-
 	while (1) {
 		if (!job_list.fg) {
 			/* no job is in the foreground */
@@ -1701,7 +1436,7 @@ static int busy_loop(FILE * input)
 				next_command = command;
 			}
 
-			if (expand_arguments(next_command) == FALSE) {
+			if (! expand_arguments(next_command)) {
 				free(command);
 				command = (char *) xcalloc(BUFSIZ, sizeof(char));
 				next_command = NULL;
@@ -1711,7 +1446,8 @@ static int busy_loop(FILE * input)
 			if (!parse_command(&next_command, &newjob, &inbg) &&
 				newjob.num_progs) {
 				int pipefds[2] = {-1,-1};
-				debug_printf( "job=%p being fed to run_command by busy_loop()'\n", &newjob);
+				debug_printf( "job=%p fed to run_command by busy_loop()'\n", 
+						&newjob);
 				run_command(&newjob, inbg, pipefds);
 			}
 			else {
@@ -1725,19 +1461,19 @@ static int busy_loop(FILE * input)
 			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 (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;
 
-#ifdef BB_FEATURE_SH_ENVIRONMENT
 				last_return_code=WEXITSTATUS(status);
-				debug_printf("'%s' exited -- return code %d\n",
-						job_list.fg->text, last_return_code);
-#endif
+
 				if (!job_list.fg->running_progs) {
 					/* child exited */
 					remove_job(&job_list, job_list.fg);
@@ -1758,16 +1494,16 @@ static int busy_loop(FILE * input)
 			if (!job_list.fg) {
 				/* move the shell to the foreground */
 				/* suppress messages when run from /linuxrc mag@sysgo.de */
-				if (tcsetpgrp(0, getpid()) && errno != ENOTTY)
-					perror_msg("tcsetpgrp"); 
+				if (tcsetpgrp(shell_terminal, getpgrp()) && errno != ENOTTY)
+					bb_perror_msg("tcsetpgrp"); 
 			}
 		}
 	}
 	free(command);
 
 	/* return controlling TTY back to parent process group before exiting */
-	if (tcsetpgrp(0, parent_pgrp))
-		perror_msg("tcsetpgrp");
+	if (tcsetpgrp(shell_terminal, parent_pgrp) && errno != ENOTTY)
+		bb_perror_msg("tcsetpgrp");
 
 	/* return exit status if called with "-c" */
 	if (input == NULL && WIFEXITED(status))
@@ -1777,11 +1513,12 @@ static int busy_loop(FILE * input)
 }
 
 
-#ifdef BB_FEATURE_CLEAN_UP
+#ifdef CONFIG_FEATURE_CLEAN_UP
 void free_memory(void)
 {
-	if (cwd)
-		free(cwd);
+	if (cwd && cwd!=bb_msg_unknown) {
+		free((char*)cwd);
+	}
 	if (local_pending_command)
 		free(local_pending_command);
 
@@ -1791,8 +1528,39 @@ void free_memory(void)
 }
 #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(void)
+{
+	int status;
+	
+	/* Loop until we are in the foreground.  */
+	while ((status = tcgetpgrp (shell_terminal)) >= 0) {
+		if (status == (shell_pgrp = getpgrp ())) {
+			break;
+		}
+		kill (- shell_pgrp, SIGTTIN);
+	}
 
-int shell_main(int argc_l, char **argv_l)
+	/* 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);
+}
+
+int lash_main(int argc_l, char **argv_l)
 {
 	int opt, interactive=FALSE;
 	FILE *input = stdin;
@@ -1800,24 +1568,17 @@ int shell_main(int argc_l, char **argv_l)
 	argv = argv_l;
 
 	/* These variables need re-initializing when recursing */
-	shell_context = 0;
-	cwd=NULL;
+	last_jobid = 0;
 	local_pending_command = NULL;
 	close_me_head = NULL;
 	job_list.head = NULL;
 	job_list.fg = NULL;
-#ifdef BB_FEATURE_SH_ENVIRONMENT
-	last_bg_pid=1;
 	last_return_code=1;
-	show_x_trace=FALSE;
-#endif
 
 	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 {
+		if (prof_input) {
 			int tmp_fd = fileno(prof_input);
 			mark_open(tmp_fd);	
 			/* Now run the file */
@@ -1832,21 +1593,16 @@ int shell_main(int argc_l, char **argv_l)
 			case 'c':
 				input = NULL;
 				if (local_pending_command != 0)
-					error_msg_and_die("multiple -c arguments");
-				local_pending_command = xstrdup(argv[optind]);
+					bb_error_msg_and_die("multiple -c arguments");
+				local_pending_command = bb_xstrdup(argv[optind]);
 				optind++;
 				argv = argv+optind;
 				break;
-#ifdef BB_FEATURE_SH_ENVIRONMENT
-			case 'x':
-				show_x_trace = TRUE;
-				break;
-#endif
 			case 'i':
 				interactive = TRUE;
 				break;
 			default:
-				show_usage();
+				bb_show_usage();
 		}
 	}
 	/* A shell is interactive if the `-i' flag was given, or if all of
@@ -1860,24 +1616,34 @@ int shell_main(int argc_l, char **argv_l)
 			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\nBusyBox v%s (%s) Built-in shell (lash)\n", BB_VER, BB_BT);
+#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET 
+		printf( "\n\n" BB_BANNER " Built-in shell (lash)\n");
 		printf( "Enter 'help' for a list of built-in commands.\n\n");
+#endif
 	} else if (local_pending_command==NULL) {
 		//printf( "optind=%d  argv[optind]='%s'\n", optind, argv[optind]);
-		input = xfopen(argv[optind], "r");
+		input = bb_xfopen(argv[optind], "r");
 		mark_open(fileno(input));  /* be lazy, never mark this closed */
 	}
 
 	/* initialize the cwd -- this is never freed...*/
-	cwd=(char*)xmalloc(sizeof(char)*MAX_LINE+1);
-	getcwd(cwd, sizeof(char)*MAX_LINE);
+	cwd = xgetcwd(0);
+	if (!cwd)
+		cwd = bb_msg_unknown;
 
-#ifdef BB_FEATURE_CLEAN_UP
+#ifdef CONFIG_FEATURE_CLEAN_UP
 	atexit(free_memory);
 #endif
 
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+	cmdedit_set_initial_prompt();
+#else
+	PS1 = NULL;
+#endif
+	
 	return (busy_loop(input));
 }