X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=hush.c;h=134404251d4cf4cc142fc70ae59b6c8936821496;hb=51ded05b3bf4df6f126420d39a40d27ea0728aa9;hp=722dcf7ac27ec05f21adbfd76235bf665516b042;hpb=004015e9c4e8ff98bcbaf955cf42147218204da4;p=oweals%2Fbusybox.git

diff --git a/hush.c b/hush.c
index 722dcf7ac..134404251 100644
--- a/hush.c
+++ b/hush.c
@@ -217,11 +217,6 @@ struct pipe {
 	reserved_style r_mode;		/* supports if, for, while, until */
 };
 
-struct jobset {
-	struct pipe *head;			/* head of list of running jobs */
-	struct pipe *fg;			/* current foreground job */
-};
-
 struct close_me {
 	int fd;
 	struct close_me *next;
@@ -242,10 +237,6 @@ unsigned int global_argc;
 unsigned int last_return_code;
 extern char **environ; /* This is in <unistd.h>, but protected with __USE_GNU */
  
-/* Variables we export */
-unsigned int shell_context;  /* Used in cmdedit.c to reset the
-                              * context when someone hits ^C */
-
 /* "globals" within this file */
 static char *ifs;
 static char map[256];
@@ -253,15 +244,16 @@ static int fake_mode;
 static int interactive;
 static struct close_me *close_me_head;
 static const char *cwd;
-static struct jobset *job_list;
+static struct pipe *job_list;
 static unsigned int last_bg_pid;
+static unsigned int last_jobid;
+static unsigned int shell_terminal;
 static char *PS1;
-static char PS2[] = "> ";
-
+static char *PS2;
 struct variables shell_ver = { "HUSH_VERSION", "0.01", 1, 1, 0 };
-
 struct variables *top_vars = &shell_ver;
 
+
 #define B_CHUNK (100)
 #define B_NOSPAC 1
 
@@ -280,6 +272,7 @@ typedef struct {
  * available?  Where is it documented? */
 struct in_str {
 	const char *p;
+	char peek_buf[2];
 	int __promptme;
 	int promptmode;
 	FILE *file;
@@ -358,14 +351,12 @@ static void mark_closed(int fd);
 static void close_all();
 /*  "run" the final data structures: */
 static char *indenter(int i);
-static int run_list_test(struct pipe *head, int indent);
-static int run_pipe_test(struct pipe *pi, int indent);
+static int free_pipe_list(struct pipe *head, int indent);
+static int free_pipe(struct pipe *pi, int indent);
 /*  really run the final data structures: */
 static int setup_redirects(struct child_prog *prog, int squirrel[]);
-static int pipe_wait(struct pipe *pi);
 static int run_list_real(struct pipe *pi);
 static void pseudo_exec(struct child_prog *child) __attribute__ ((noreturn));
-int controlling_tty(int check_pgrp);
 static int run_pipe_real(struct pipe *pi);
 /*   extended glob support: */
 static int globhack(const char *src, int flags, glob_t *pglob);
@@ -393,16 +384,14 @@ static int parse_stream_outer(struct in_str *inp);
 static int parse_string_outer(const char *s);
 static int parse_file_outer(FILE *f);
 /*   job management: */
-static void checkjobs();
+static int checkjobs(struct pipe* fg_pipe);
 static void insert_bg_job(struct pipe *pi);
 static void remove_bg_job(struct pipe *pi);
-static void free_pipe(struct pipe *pi);
 /*     local variable support */
 static char *get_local_var(const char *var);
 static void  unset_local_var(const char *name);
 static int set_local_var(const char *s, int flg_export);
 
-
 /* Table of built-in functions.  They can be forked or not, depending on
  * context: within pipes, they fork.  As simple commands, they do not.
  * When used in non-forking context, they can change global variables
@@ -505,29 +494,29 @@ static int builtin_export(struct child_prog *child)
 	name = strdup(name);
 
 	if(name) {
-	    char *value = strchr(name, '=');
-
-	if (!value) {
-		char *tmp;
-		/* They are exporting something without an =VALUE */
-
-		value = get_local_var(name);
-		if (value) {
-			size_t ln = strlen(name);
-
-			tmp = realloc(name, ln+strlen(value)+2);
-			if(tmp==NULL)
-				res = -1;
-			else {
-				sprintf(tmp+ln, "=%s", value);
-				name = tmp;
+		char *value = strchr(name, '=');
+
+		if (!value) {
+			char *tmp;
+			/* They are exporting something without an =VALUE */
+
+			value = get_local_var(name);
+			if (value) {
+				size_t ln = strlen(name);
+
+				tmp = realloc(name, ln+strlen(value)+2);
+				if(tmp==NULL)
+					res = -1;
+				else {
+					sprintf(tmp+ln, "=%s", value);
+					name = tmp;
+				}
+			} else {
+				/* bash does not return an error when trying to export
+				 * an undefined variable.  Do likewise. */
+				res = 1;
 			}
-		} else {
-			/* bash not put error and set error code
-			   if exporting not defined variable */
-			res = 1;
 		}
-	    }
 	}
 	if (res<0)
 		perror_msg("export");
@@ -545,10 +534,12 @@ static int builtin_fg_bg(struct child_prog *child)
 	int i, jobnum;
 	struct pipe *pi=NULL;
 
+	if (!interactive)
+		return EXIT_FAILURE;
 	/* If they gave us no args, assume they want the last backgrounded task */
 	if (!child->argv[1]) {
-		for (pi = job_list->head; pi; pi = pi->next) {
-			if (pi->progs && pi->progs->pid == last_bg_pid) {
+		for (pi = job_list; pi; pi = pi->next) {
+			if (pi->jobid == last_jobid) {
 				break;
 			}
 		}
@@ -561,8 +552,7 @@ static int builtin_fg_bg(struct child_prog *child)
 			error_msg("%s: bad argument '%s'", child->argv[0], child->argv[1]);
 			return EXIT_FAILURE;
 		}
-
-		for (pi = job_list->head; pi; pi = pi->next) {
+		for (pi = job_list; pi; pi = pi->next) {
 			if (pi->jobid == jobnum) {
 				break;
 			}
@@ -572,21 +562,23 @@ static int builtin_fg_bg(struct child_prog *child)
 			return EXIT_FAILURE;
 		}
 	}
+
 	if (*child->argv[0] == 'f') {
-		/* Make this job the foreground job */
-		signal(SIGTTOU, SIG_IGN);
-		/* suppress messages when run from /linuxrc mag@sysgo.de */
-		if (tcsetpgrp(0, pi->pgrp) && errno != ENOTTY)
-			perror_msg("tcsetpgrp-1"); 
-		signal(SIGTTOU, SIG_DFL);
-		job_list->fg = pi;
+		/* Put the job into the foreground.  */
+		tcsetpgrp(shell_terminal, pi->pgrp);
 	}
 
 	/* Restart the processes in the job */
 	for (i = 0; i < pi->num_progs; i++)
 		pi->progs[i].is_stopped = 0;
 
-	kill(-pi->pgrp, SIGCONT);
+	if ( (i=kill(- pi->pgrp, SIGCONT)) < 0) {
+		if (i == ESRCH) {
+			remove_bg_job(pi);
+		} else {
+			perror_msg("kill (SIGCONT)");
+		}
+	}
 
 	pi->stopped_progs = 0;
 	return EXIT_SUCCESS;
@@ -614,11 +606,12 @@ static int builtin_jobs(struct child_prog *child)
 	struct pipe *job;
 	char *status_string;
 
-	for (job = job_list->head; job; job = job->next) {
+	for (job = job_list; 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;
@@ -641,7 +634,7 @@ static int builtin_read(struct child_prog *child)
 		char string[BUFSIZ];
 		char *var = 0;
 
-		string[0] = 0;  /* for correct work if stdin have "only EOF" */
+		string[0] = 0;  /* In case stdin has only EOF */
 		/* read string */
 		fgets(string, sizeof(string), stdin);
 		chomp(string);
@@ -650,10 +643,10 @@ static int builtin_read(struct child_prog *child)
 			sprintf(var, "%s=%s", child->argv[1], string);
 			res = set_local_var(var, 0);
 		} else
-		res = -1;
+			res = -1;
 		if (res)
 			fprintf(stderr, "read: %m\n");
-		free(var);      /* not move up - saved errno */
+		free(var);      /* So not move up to avoid breaking errno */
 		return res;
 	} else {
 		do res=getchar(); while(res!='\n' && res!=EOF);
@@ -867,7 +860,7 @@ static inline void setup_prompt_string(int promptmode, char **prompt_str)
 		*prompt_str = PS2;
 	}
 #else
-	*prompt_str = (promptmode==0)? PS1 : PS2;
+	*prompt_str = (promptmode==1)? PS1 : PS2;
 #endif
 	debug_printf("result %s\n",*prompt_str);
 }
@@ -886,13 +879,13 @@ static void get_user_input(struct in_str *i)
 	 ** child processes (rob@sysgo.de)
 	 */
 	cmdedit_read_input(prompt_str, the_command);
-	cmdedit_terminate();
 #else
 	fputs(prompt_str, stdout);
 	fflush(stdout);
 	the_command[0]=fgetc(i->file);
 	the_command[1]='\0';
 #endif
+	fflush(stdout);
 	i->p = the_command;
 }
 
@@ -910,7 +903,9 @@ static int file_get(struct in_str *i)
 		/* need to double check i->file because we might be doing something
 		 * more complicated by now, like sourcing or substituting. */
 		if (i->__promptme && interactive && i->file == stdin) {
-			get_user_input(i);
+			while(! i->p || (interactive && strlen(i->p)==0) ) {
+				get_user_input(i);
+			}
 			i->promptmode=2;
 			i->__promptme = 0;
 			if (i->p && *i->p) {
@@ -934,12 +929,11 @@ static int file_peek(struct in_str *i)
 	if (i->p && *i->p) {
 		return *i->p;
 	} else {
-		static char buffer[2];
-		buffer[0] = fgetc(i->file);
-		buffer[1] = '\0';
-		i->p = buffer;
+		i->peek_buf[0] = fgetc(i->file);
+		i->peek_buf[1] = '\0';
+		i->p = i->peek_buf;
 		debug_printf("b_peek: got a %d\n", *i->p);
-		return *i->p; 
+		return *i->p;
 	}
 }
 
@@ -997,6 +991,10 @@ static int setup_redirects(struct child_prog *prog, int squirrel[])
 	struct redir_struct *redir;
 
 	for (redir=prog->redirects; redir; redir=redir->next) {
+		if (redir->dup == -1 && redir->word.gl_pathv == NULL) {
+			/* something went wrong in the parse.  Pretend it didn't happen */
+			continue;
+		}
 		if (redir->dup == -1) {
 			mode=redir_table[redir->type].mode;
 			openfd = open(redir->word.gl_pathv[0], mode, 0666);
@@ -1018,7 +1016,8 @@ static int setup_redirects(struct child_prog *prog, int squirrel[])
 				close(openfd);
 			} else {
 				dup2(openfd, redir->fd);
-				close(openfd);
+				if (redir->dup == -1)
+					close (openfd);
 			}
 		}
 	}
@@ -1039,28 +1038,10 @@ static void restore_redirects(int squirrel[])
 	}
 }
 
-/* XXX this definitely needs some more thought, work, and
- * cribbing from other shells */
-static int pipe_wait(struct pipe *pi)
-{
-	int rcode=0, i, pid, running, status;
-	running = pi->num_progs;
-	while (running) {
-		pid=waitpid(-1, &status, 0);
-		if (pid < 0) perror_msg_and_die("waitpid");
-		for (i=0; i < pi->num_progs; i++) {
-			if (pi->progs[i].pid == pid) {
-				if (i==pi->num_progs-1) rcode=WEXITSTATUS(status);
-				pi->progs[i].pid = 0;
-				running--;
-				break;
-			}
-		}
-	}
-	return rcode;
-}
-
 /* never returns */
+/* XXX no exit() here.  If you don't exec, use _exit instead.
+ * The at_exit handlers apparently confuse the calling process,
+ * in particular stdin handling.  Not sure why? */
 static void pseudo_exec(struct child_prog *child)
 {
 	int i, rcode;
@@ -1076,7 +1057,9 @@ static void pseudo_exec(struct child_prog *child)
 		/* If a variable is assigned in a forest, and nobody listens,
 		 * was it ever really set?
 		 */
-		if (child->argv[0] == NULL) exit(EXIT_SUCCESS);
+		if (child->argv[0] == NULL) {
+			_exit(EXIT_SUCCESS);
+		}
 
 		/*
 		 * Check if the command matches any of the builtins.
@@ -1087,7 +1070,9 @@ static void pseudo_exec(struct child_prog *child)
 		for (x = bltins; x->cmd; x++) {
 			if (strcmp(child->argv[0], x->cmd) == 0 ) {
 				debug_printf("builtin exec %s\n", child->argv[0]);
-				exit(x->function(child));
+				rcode = x->function(child);
+				fflush(stdout);
+				_exit(rcode);
 			}
 		}
 
@@ -1128,18 +1113,18 @@ static void pseudo_exec(struct child_prog *child)
 		debug_printf("exec of %s\n",child->argv[0]);
 		execvp(child->argv[0],child->argv);
 		perror_msg("couldn't exec: %s",child->argv[0]);
-		exit(1);
+		_exit(1);
 	} else if (child->group) {
 		debug_printf("runtime nesting to group\n");
 		interactive=0;    /* crucial!!!! */
 		rcode = run_list_real(child->group);
-		/* OK to leak memory by not calling run_list_test,
+		/* OK to leak memory by not calling free_pipe_list,
 		 * since this process is about to exit */
-		exit(rcode);
+		_exit(rcode);
 	} else {
 		/* Can happen.  See what bash does with ">foo" by itself. */
 		debug_printf("trying to pseudo_exec null command\n");
-		exit(EXIT_SUCCESS);
+		_exit(EXIT_SUCCESS);
 	}
 }
 
@@ -1149,15 +1134,15 @@ static void insert_bg_job(struct pipe *pi)
 
 	/* Linear search for the ID of the job to use */
 	pi->jobid = 1;
-	for (thejob = job_list->head; thejob; thejob = thejob->next)
+	for (thejob = job_list; thejob; thejob = thejob->next)
 		if (thejob->jobid >= pi->jobid)
 			pi->jobid = thejob->jobid + 1;
 
 	/* add thejob to the list of running jobs */
-	if (!job_list->head) {
-		thejob = job_list->head = xmalloc(sizeof(*thejob));
+	if (!job_list) {
+		thejob = job_list = xmalloc(sizeof(*thejob));
 	} else {
-		for (thejob = job_list->head; thejob->next; thejob = thejob->next) /* nothing */;
+		for (thejob = job_list; thejob->next; thejob = thejob->next) /* nothing */;
 		thejob->next = xmalloc(sizeof(*thejob));
 		thejob = thejob->next;
 	}
@@ -1182,64 +1167,74 @@ static void insert_bg_job(struct pipe *pi)
 	   to the list of backgrounded thejobs and leave it alone */
 	printf("[%d] %d\n", thejob->jobid, thejob->progs[0].pid);
 	last_bg_pid = thejob->progs[0].pid;
+	last_jobid = thejob->jobid;
 }
 
-/* remove a backgrounded job from a jobset */
+/* remove a backgrounded job */
 static void remove_bg_job(struct pipe *pi)
 {
 	struct pipe *prev_pipe;
 
-	if (pi == job_list->head) {
-		job_list->head = pi->next;
+	if (pi == job_list) {
+		job_list = pi->next;
 	} else {
-		prev_pipe = job_list->head;
+		prev_pipe = job_list;
 		while (prev_pipe->next != pi)
 			prev_pipe = prev_pipe->next;
 		prev_pipe->next = pi->next;
 	}
+	if (job_list)
+		last_jobid = job_list->jobid;
+	else
+		last_jobid = 0;
 
-	free_pipe(pi);
+	pi->stopped_progs = 0;
+	free_pipe(pi, 0);
 	free(pi);
 }
 
-/* free up all memory from a pipe */
-static void free_pipe(struct pipe *pi)
-{
-	int i;
-
-	for (i = 0; i < pi->num_progs; i++) {
-		free(pi->progs[i].argv);
-		if (pi->progs[i].redirects)
-			free(pi->progs[i].redirects);
-	}
-	if (pi->progs)
-		free(pi->progs);
-	if (pi->text)
-		free(pi->text);
-	if (pi->cmdbuf)
-		free(pi->cmdbuf);
-	memset(pi, 0, sizeof(struct pipe));
-}
-
-
-/* Checks to see if any background processes have exited -- if they 
+/* Checks to see if any processes have exited -- if they 
    have, figure out why and see if a job has completed */
-static void checkjobs()
+static int checkjobs(struct pipe* fg_pipe)
 {
-	int status, ctty;
+	int attributes;
+	int status;
 	int prognum = 0;
 	struct pipe *pi;
 	pid_t childpid;
 
-	while ((childpid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
-		for (pi = job_list->head; pi; pi = pi->next) {
+	attributes = WUNTRACED;
+	if (fg_pipe==NULL) {
+		attributes |= WNOHANG;
+	}
+
+	while ((childpid = waitpid(-1, &status, attributes)) > 0) {
+		if (fg_pipe) {
+			int i, rcode = 0;
+			for (i=0; i < fg_pipe->num_progs; i++) {
+				if (fg_pipe->progs[i].pid == childpid) {
+					if (i==fg_pipe->num_progs-1) 
+						rcode=WEXITSTATUS(status);
+					(fg_pipe->num_progs)--;
+					return(rcode);
+				}
+			}
+		}
+
+		for (pi = job_list; pi; pi = pi->next) {
 			prognum = 0;
-			while (prognum < pi->num_progs &&
-				   pi->progs[prognum].pid != childpid) prognum++;
+			while (prognum < pi->num_progs && pi->progs[prognum].pid != childpid) {
+				prognum++;
+			}
 			if (prognum < pi->num_progs)
 				break;
 		}
 
+		if(pi==NULL) {
+			debug_printf("checkjobs: pid %d was not in our list!\n", childpid);
+			continue;
+		}
+
 		if (WIFEXITED(status) || WIFSIGNALED(status)) {
 			/* child exited */
 			pi->running_progs--;
@@ -1250,15 +1245,18 @@ static void checkjobs()
 				remove_bg_job(pi);
 			}
 		} else {
-			if(pi==NULL)
-				break;
 			/* child stopped */
 			pi->stopped_progs++;
 			pi->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 (pi->stopped_progs == pi->num_progs) {
-				printf(JOB_STATUS_FORMAT, pi->jobid, "Stopped", pi->text);
+				printf("\n"JOB_STATUS_FORMAT, pi->jobid, "Stopped", pi->text);
 			}
+#endif	
 		}
 	}
 
@@ -1266,35 +1264,37 @@ static void checkjobs()
 		perror_msg("waitpid");
 
 	/* move the shell to the foreground */
-	if (interactive && (ctty=controlling_tty(0))!=-1) {
-		if (tcsetpgrp(ctty, getpgrp()))
-			perror_msg("tcsetpgrp-2");
-	}
+	//if (interactive && tcsetpgrp(shell_terminal, getpgid(0)))
+	//	perror_msg("tcsetpgrp-2");
+	return -1;
 }
 
 /* Figure out our controlling tty, checking in order stderr,
  * stdin, and stdout.  If check_pgrp is set, also check that
  * we belong to the foreground process group associated with
- * that tty.  The value of ctty is needed in order to call
- * tcsetpgrp(ctty, ...); */
-int controlling_tty(int check_pgrp)
+ * that tty.  The value of shell_terminal is needed in order to call
+ * tcsetpgrp(shell_terminal, ...); */
+void controlling_tty(int check_pgrp)
 {
 	pid_t curpgrp;
-	int ctty;
 
-	if ((curpgrp = tcgetpgrp(ctty = 2)) < 0
-		&& (curpgrp = tcgetpgrp(ctty = 0)) < 0
-		&& (curpgrp = tcgetpgrp(ctty = 1)) < 0)
-		return errno = ENOTTY, -1;
+	if ((curpgrp = tcgetpgrp(shell_terminal = 2)) < 0
+			&& (curpgrp = tcgetpgrp(shell_terminal = 0)) < 0
+			&& (curpgrp = tcgetpgrp(shell_terminal = 1)) < 0)
+		goto shell_terminal_error;
 
-	if (check_pgrp && curpgrp != getpgrp())
-		return errno = EPERM, -1;
+	if (check_pgrp && curpgrp != getpgid(0))
+		goto shell_terminal_error;
 
-	return ctty;
+	return;
+
+shell_terminal_error:
+		shell_terminal = -1;
+		return;
 }
 
 /* run_pipe_real() starts all the jobs, but doesn't wait for anything
- * to finish.  See pipe_wait().
+ * to finish.  See checkjobs().
  *
  * return code is normally -1, when the caller has to wait for children
  * to finish to determine the exit status of the pipe.  If the pipe
@@ -1312,43 +1312,53 @@ int controlling_tty(int check_pgrp)
 static int run_pipe_real(struct pipe *pi)
 {
 	int i;
-	int ctty;
 	int nextin, nextout;
 	int pipefds[2];				/* pipefds[0] is for reading */
 	struct child_prog *child;
 	struct built_in_command *x;
 
-	ctty = -1;
 	nextin = 0;
 	pi->pgrp = -1;
 
-	/* Check if we are supposed to run in the foreground */
-	if (interactive && pi->followup!=PIPE_BG) {
-		if ((ctty = controlling_tty(pi->pgrp<0)) < 0) return -1;
-	}
-
 	/* Check if this is a simple builtin (not part of a pipe).
 	 * Builtins within pipes have to fork anyway, and are handled in
 	 * pseudo_exec.  "echo foo | read bar" doesn't work on bash, either.
 	 */
-	if (pi->num_progs == 1 && pi->progs[0].argv != NULL) {
-		child = & (pi->progs[0]);
-		if (child->group && ! child->subshell) {
-			int squirrel[] = {-1, -1, -1};
-			int rcode;
-			debug_printf("non-subshell grouping\n");
-			setup_redirects(child, squirrel);
-			/* XXX could we merge code with following builtin case,
-			 * by creating a pseudo builtin that calls run_list_real? */
-			rcode = run_list_real(child->group);
-			restore_redirects(squirrel);
-			return rcode;
-		}
+	if (pi->num_progs == 1) child = & (pi->progs[0]);
+	if (pi->num_progs == 1 && child->group && child->subshell == 0) {
+		int squirrel[] = {-1, -1, -1};
+		int rcode;
+		debug_printf("non-subshell grouping\n");
+		setup_redirects(child, squirrel);
+		/* XXX could we merge code with following builtin case,
+		 * by creating a pseudo builtin that calls run_list_real? */
+		rcode = run_list_real(child->group);
+		restore_redirects(squirrel);
+		return rcode;
+	} else if (pi->num_progs == 1 && pi->progs[0].argv != NULL) {
 		for (i=0; is_assignment(child->argv[i]); i++) { /* nothing */ }
 		if (i!=0 && child->argv[i]==NULL) {
 			/* assignments, but no command: set the local environment */
 			for (i=0; child->argv[i]!=NULL; i++) {
-				set_local_var(child->argv[i], 0);
+
+				/* Ok, this case is tricky.  We have to decide if this is a
+				 * local variable, or an already exported variable.  If it is
+				 * already exported, we have to export the new value.  If it is
+				 * not exported, we need only set this as a local variable. 
+				 * This junk is all to decide whether or not to export this
+				 * variable. */
+				int export_me=0;
+				char *name, *value;
+				name = xstrdup(child->argv[i]);
+				debug_printf("Local environment set: %s\n", name);
+				value = strchr(name, '=');
+				if (value)
+					*value=0;
+				if ( get_local_var(name)) {
+					export_me=1;
+				}
+				free(name);
+				set_local_var(child->argv[i], export_me);
 			}
 			return EXIT_SUCCESS;   /* don't worry about errors in set_local_var() yet */
 		}
@@ -1393,8 +1403,14 @@ static int run_pipe_real(struct pipe *pi)
 
 		/* XXX test for failed fork()? */
 		if (!(child->pid = fork())) {
-
+			/* Set the handling for job control signals back to the default.  */
+			signal(SIGINT, SIG_DFL);
+			signal(SIGQUIT, SIG_DFL);
+			signal(SIGTERM, SIG_DFL);
+			signal(SIGTSTP, SIG_DFL);
+			signal(SIGTTIN, SIG_DFL);
 			signal(SIGTTOU, SIG_DFL);
+			signal(SIGCHLD, SIG_DFL);
 			
 			close_all();
 
@@ -1413,7 +1429,7 @@ static int run_pipe_real(struct pipe *pi)
 			/* Like bash, explicit redirects override pipes,
 			 * and the pipe fd is available for dup'ing. */
 			setup_redirects(child,NULL);
-			
+
 			if (interactive && pi->followup!=PIPE_BG) {
 				/* If we (the child) win the race, put ourselves in the process
 				 * group whose leader is the first process in this pipe. */
@@ -1421,16 +1437,16 @@ static int run_pipe_real(struct pipe *pi)
 					pi->pgrp = getpid();
 				}
 				if (setpgid(0, pi->pgrp) == 0) {
-					signal(SIGTTOU, SIG_IGN);
-					tcsetpgrp(ctty, pi->pgrp);
-					signal(SIGTTOU, SIG_DFL);
+					tcsetpgrp(2, pi->pgrp);
 				}
 			}
 
 			pseudo_exec(child);
 		}
-		/* Put our child in the process group whose leader is the
-		 * first process in this pipe. */
+		
+
+		/* put our child in the process group whose leader is the
+		   first process in this pipe */
 		if (pi->pgrp < 0) {
 			pi->pgrp = child->pid;
 		}
@@ -1466,6 +1482,7 @@ static int run_list_real(struct pipe *pi)
 		if (rmode == RES_ELIF && !if_code) continue;
 		if (pi->num_progs == 0) continue;
 		rcode = run_pipe_real(pi);
+		debug_printf("run_pipe_real returned %d\n",rcode);
 		if (rcode!=-1) {
 			/* We only ran a builtin: rcode was set by the return value
 			 * of run_pipe_real(), and we don't need to wait for anything. */
@@ -1476,20 +1493,18 @@ static int run_list_real(struct pipe *pi)
 			insert_bg_job(pi);
 			rcode = EXIT_SUCCESS;
 		} else {
-
 			if (interactive) {
 				/* move the new process group into the foreground */
-				/* suppress messages when run from /linuxrc mag@sysgo.de */
-				/* XXX probably this "0" should come from controlling_tty() */
-				if (tcsetpgrp(0, pi->pgrp) && errno != ENOTTY)
+				if (tcsetpgrp(shell_terminal, pi->pgrp) && errno != ENOTTY)
 					perror_msg("tcsetpgrp-3");
-				rcode = pipe_wait(pi);
-				if (tcsetpgrp(0, getpgrp()) && errno != ENOTTY)
+				rcode = checkjobs(pi);
+				/* move the shell to the foreground */
+				if (tcsetpgrp(shell_terminal, getpgid(0)) && errno != ENOTTY)
 					perror_msg("tcsetpgrp-4");
 			} else {
-				rcode = pipe_wait(pi);
-				debug_printf("pipe_wait returned %d\n",rcode);
+				rcode = checkjobs(pi);
 			}
+			debug_printf("checkjobs returned %d\n",rcode);
 		}
 		last_return_code=rcode;
 		if ( rmode == RES_IF || rmode == RES_ELIF )
@@ -1497,8 +1512,8 @@ static int run_list_real(struct pipe *pi)
 		if ( (rcode==EXIT_SUCCESS && pi->followup==PIPE_OR) ||
 		     (rcode!=EXIT_SUCCESS && pi->followup==PIPE_AND) )
 			skip_more_in_this_rmode=rmode;
+		checkjobs(NULL);
 	}
-	checkjobs();
 	return rcode;
 }
 
@@ -1510,13 +1525,16 @@ static char *indenter(int i)
 }
 
 /* return code is the exit status of the pipe */
-static int run_pipe_test(struct pipe *pi, int indent)
+static int free_pipe(struct pipe *pi, int indent)
 {
 	char **p;
 	struct child_prog *child;
 	struct redir_struct *r, *rnext;
 	int a, i, ret_code=0;
 	char *ind = indenter(indent);
+
+	if (pi->stopped_progs > 0)
+		return ret_code;
 	final_printf("%s run pipe: (pid %d)\n",ind,getpid());
 	for (i=0; i<pi->num_progs; i++) {
 		child = &pi->progs[i];
@@ -1529,7 +1547,7 @@ static int run_pipe_test(struct pipe *pi, int indent)
 			child->argv=NULL;
 		} else if (child->group) {
 			final_printf("%s   begin group (subshell:%d)\n",ind, child->subshell);
-			ret_code = run_list_test(child->group,indent+3);
+			ret_code = free_pipe_list(child->group,indent+3);
 			final_printf("%s   end group\n",ind);
 		} else {
 			final_printf("%s   (nil)\n",ind);
@@ -1537,8 +1555,11 @@ static int run_pipe_test(struct pipe *pi, int indent)
 		for (r=child->redirects; r; r=rnext) {
 			final_printf("%s   redirect %d%s", ind, r->fd, redir_table[r->type].descrip);
 			if (r->dup == -1) {
-				final_printf(" %s\n", *r->word.gl_pathv);
-				globfree(&r->word);
+				/* guard against the case >$FOO, where foo is unset or blank */
+				if (r->word.gl_pathv) {
+					final_printf(" %s\n", *r->word.gl_pathv);
+					globfree(&r->word);
+				}
 			} else {
 				final_printf("&%d\n", r->dup);
 			}
@@ -1552,15 +1573,14 @@ static int run_pipe_test(struct pipe *pi, int indent)
 	return ret_code;
 }
 
-static int run_list_test(struct pipe *head, int indent)
+static int free_pipe_list(struct pipe *head, int indent)
 {
 	int rcode=0;   /* if list has no members */
 	struct pipe *pi, *next;
 	char *ind = indenter(indent);
 	for (pi=head; pi; pi=next) {
-		if (pi->num_progs == 0) break;
 		final_printf("%s pipe reserved mode %d\n", ind, pi->r_mode);
-		rcode = run_pipe_test(pi, indent);
+		rcode = free_pipe(pi, indent);
 		final_printf("%s pipe followup code %d\n", ind, pi->followup);
 		next=pi->next;
 		pi->next=NULL;
@@ -1576,10 +1596,10 @@ static int run_list(struct pipe *pi)
 	if (fake_mode==0) {
 		rcode = run_list_real(pi);
 	} 
-	/* run_list_test has the side effect of clearing memory
+	/* free_pipe_list has the side effect of clearing memory
 	 * In the long run that function can be merged with run_list_real,
 	 * but doing that now would hobble the debugging effort. */
-	run_list_test(pi,0);
+	free_pipe_list(pi,0);
 	return rcode;
 }
 
@@ -1592,10 +1612,10 @@ static int run_list(struct pipe *pi)
  */
 static int globhack(const char *src, int flags, glob_t *pglob)
 {
-	int cnt, pathc;
+	int cnt=0, pathc;
 	const char *s;
 	char *dest;
-	for (cnt=1, s=src; *s; s++) {
+	for (cnt=1, s=src; s && *s; s++) {
 		if (*s == '\\') s++;
 		cnt++;
 	}
@@ -1612,7 +1632,7 @@ static int globhack(const char *src, int flags, glob_t *pglob)
 	if (pglob->gl_pathv == NULL) return GLOB_NOSPACE;
 	pglob->gl_pathv[pathc-1]=dest;
 	pglob->gl_pathv[pathc]=NULL;
-	for (s=src; *s; s++, dest++) {
+	for (s=src; s && *s; s++, dest++) {
 		if (*s == '\\') s++;
 		*dest = *s;
 	}
@@ -1700,7 +1720,6 @@ static int set_local_var(const char *s, int flg_export)
 	char *name, *value;
 	int result=0;
 	struct variables *cur;
-	char *newval = 0;
 
 	name=strdup(s);
 
@@ -1708,61 +1727,64 @@ static int set_local_var(const char *s, int flg_export)
 	 * NAME=VALUE format.  So the first order of business is to
 	 * split 's' on the '=' into 'name' and 'value' */ 
 	value = strchr(name, '=');
-	if (value==0 || (newval = strdup(value+1))==0) {
-		result = -1;
-	} else {
-		*value++ = 0;
+	if (value==0 && ++value==0) {
+		free(name);
+		return -1;
+	}
+	*value++ = 0;
 
-		for(cur = top_vars; cur; cur = cur->next)
-			if(strcmp(cur->name, name)==0)
+	for(cur = top_vars; cur; cur = cur->next) {
+		if(strcmp(cur->name, name)==0)
 			break;
+	}
 
-		if(cur) {
-			if(strcmp(cur->value, value)==0) {
-				result = cur->flg_export == flg_export;
+	if(cur) {
+		if(strcmp(cur->value, value)==0) {
+			if(flg_export>0 && cur->flg_export==0)
+				cur->flg_export=flg_export;
+			else
+				result++;
+		} else {
+			if(cur->flg_read_only) {
+				error_msg("%s: readonly variable", name);
+				result = -1;
 			} else {
-				if(cur->flg_read_only) {
-			result = -1;
-					error_msg("%s: readonly variable", name);
-				} else {
-					free(cur->value);
-					cur->value = newval;
-					newval = 0; /* protect free */
+				if(flg_export>0 || cur->flg_export>1)
+					cur->flg_export=1;
+				free(cur->value);
+
+				cur->value = strdup(value);
+			}
 		}
-	}
+	} else {
+		cur = malloc(sizeof(struct variables));
+		if(!cur) {
+			result = -1;
 		} else {
-			cur = malloc(sizeof(struct variables));
-			if(cur==0) {
+			cur->name = strdup(name);
+			if(cur->name == 0) {
+				free(cur);
 				result = -1;
 			} else {
-				cur->name = strdup(name);
-				if(cur->name == 0) {
-					free(cur);
-				result = -1;
-				} else {
-					struct variables *bottom = top_vars;
-
-					cur->value = newval;
-					newval = 0;     /* protect free */
-					cur->next = 0;
-					cur->flg_export = flg_export;
-					cur->flg_read_only = 0;
-					while(bottom->next) bottom=bottom->next;
-					bottom->next = cur;
+				struct variables *bottom = top_vars;
+				cur->value = strdup(value);
+				cur->next = 0;
+				cur->flg_export = flg_export;
+				cur->flg_read_only = 0;
+				while(bottom->next) bottom=bottom->next;
+				bottom->next = cur;
 			}
 		}
 	}
-	}
 
-	if((result==0 && flg_export==1) || (result>0 && cur->flg_export>0)) {
+	if(result==0 && cur->flg_export==1) {
 		*(value-1) = '=';
 		result = putenv(name);
 	} else {
-	free(name);
+		free(name);
 		if(result>0)            /* equivalent to previous set */
 			result = 0;
 	}
-	free(newval);
 	return result;
 }
 
@@ -1771,14 +1793,16 @@ static void unset_local_var(const char *name)
 	struct variables *cur;
 
 	if (name) {
-		for (cur = top_vars; cur; cur=cur->next)
+		for (cur = top_vars; cur; cur=cur->next) {
 			if(strcmp(cur->name, name)==0)
 				break;
+		}
 		if(cur!=0) {
 			struct variables *next = top_vars;
-			if(cur==next)
-		return;
-			else {
+			if(cur->flg_read_only) {
+				error_msg("%s: readonly variable", name);
+				return;
+			} else {
 				if(cur->flg_export)
 					unsetenv(cur->name);
 				free(cur->name);
@@ -1818,6 +1842,7 @@ static int setup_redirect(struct p_context *ctx, int fd, redir_type style,
 	}
 	redir = xmalloc(sizeof(struct redir_struct));
 	redir->next=NULL;
+	redir->word.gl_pathv=NULL;
 	if (last_redir) {
 		last_redir->next=redir;
 	} else {
@@ -1924,6 +1949,7 @@ int reserved_word(o_string *dest, struct p_context *ctx)
 				debug_printf("pop stack\n");
 				old = ctx->stack;
 				old->child->group = ctx->list_head;
+				old->child->subshell = 0;
 				*ctx = *old;   /* physical copy */
 				free(old);
 			}
@@ -2103,9 +2129,9 @@ FILE *generate_stream_from_list(struct pipe *head)
 #if 0
 #define SURROGATE "surrogate response"
 		write(1,SURROGATE,sizeof(SURROGATE));
-		exit(run_list(head));
+		_exit(run_list(head));
 #else
-		exit(run_list_real(head));   /* leaks memory */
+		_exit(run_list_real(head));   /* leaks memory */
 #endif
 	}
 	debug_printf("forked child %d\n",pid);
@@ -2113,7 +2139,7 @@ FILE *generate_stream_from_list(struct pipe *head)
 	pf = fdopen(channel[0],"r");
 	debug_printf("pipe on FILE *%p\n",pf);
 #else
-	run_list_test(head,0);
+	free_pipe_list(head,0);
 	pf=popen("echo surrogate response","r");
 	debug_printf("started fake pipe on FILE *%p\n",pf);
 #endif
@@ -2159,6 +2185,7 @@ static int process_command_subs(o_string *dest, struct p_context *ctx, struct in
 	 * to the KISS philosophy of this program. */
 	mark_closed(fileno(p));
 	retcode=pclose(p);
+	free_pipe_list(inner.list_head,0);
 	debug_printf("pclosed, retcode=%d\n",retcode);
 	/* XXX this process fails to trim a single trailing newline */
 	return retcode;
@@ -2318,7 +2345,7 @@ int parse_stream(o_string *dest, struct p_context *ctx,
 					done_pipe(ctx,PIPE_SEQ);
 			}
 			if (ch == end_trigger && !dest->quote && ctx->w==RES_NONE) {
-				debug_printf("leaving parse_stream\n");
+				debug_printf("leaving parse_stream (triggered)\n");
 				return 0;
 			}
 #if 0
@@ -2442,6 +2469,7 @@ int parse_stream(o_string *dest, struct p_context *ctx,
 	 * that is, we were really supposed to get end_trigger, and never got
 	 * one before the EOF.  Can't use the standard "syntax error" return code,
 	 * so that parse_stream_outer can distinguish the EOF and exit smoothly. */
+	debug_printf("leaving parse_stream (EOF)\n");
 	if (end_trigger != '\0') return -1;
 	return 0;
 }
@@ -2463,10 +2491,10 @@ void update_ifs_map(void)
 	 * The map[] array only really needs two bits each, and on most machines
 	 * that would be faster because of the reduced L1 cache footprint.
 	 */
-	memset(map,0,256);        /* most characters flow through always */
-	mapset("\\$'\"`", 3);     /* never flow through */
-	mapset("<>;&|(){}#", 1);  /* flow through if quoted */
-	mapset(ifs, 2);           /* also flow through if quoted */
+	memset(map,0,sizeof(map)); /* most characters flow through always */
+	mapset("\\$'\"`", 3);      /* never flow through */
+	mapset("<>;&|(){}#", 1);   /* flow through if quoted */
+	mapset(ifs, 2);            /* also flow through if quoted */
 }
 
 /* most recursion does not come through here, the exeception is
@@ -2485,6 +2513,7 @@ int parse_stream_outer(struct in_str *inp)
 		done_word(&temp, &ctx);
 		done_pipe(&ctx,PIPE_SEQ);
 		run_list(ctx.list_head);
+		b_free(&temp);
 	} while (rcode != -1);   /* loop on syntax errors, return on EOF */
 	return 0;
 }
@@ -2505,74 +2534,86 @@ static int parse_file_outer(FILE *f)
 	return rcode;
 }
 
-
-/* I think Erik wrote this.  It looks imperfect at best */
-void grab_tty_control(void)
+/* 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()
 {
-	pid_t initialpgrp;
-	do {
-		initialpgrp = tcgetpgrp(fileno(stderr));
-		if (initialpgrp < 0) {
-			error_msg("sh: can't access tty; job control disabled\n");
-		}
-		if (initialpgrp == -1)
-			initialpgrp = getpgrp();
-		else if (initialpgrp != getpgrp()) {
-			killpg(initialpgrp, SIGTTIN);
-			continue;
-		}
-	} while (0);
+	static pid_t shell_pgrp;
+	/* 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(SIGTERM, 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 shell_main(int argc, char **argv)
 {
 	int opt;
 	FILE *input;
-	struct jobset joblist_end = { NULL, NULL };
 	char **e = environ;
 
-	/* initialize globals */
+	/* XXX what should these be while sourcing /etc/profile? */
+	global_argc = argc;
+	global_argv = argv;
+	
+	/* (re?) initialize globals.  Sometimes shell_main() ends up calling
+	 * shell_main(), therefore we cannot rely on the BSS to zero out this 
+	 * stuff.  Reset these to 0 every time. */
+	ifs = NULL;
+	/* map[] is taken care of with call to update_ifs_map() */
+	fake_mode = 0;
+	interactive = 0;
+	close_me_head = NULL;
+	last_bg_pid = 0;
+	job_list = NULL;
+	last_jobid = 0;
+
+	/* Initialize some more globals to non-zero values */
+	set_cwd();
+#ifdef BB_FEATURE_COMMAND_EDITING
+	cmdedit_set_initial_prompt();
+#else
+	PS1 = NULL;
+#endif
+	PS2 = "> ";
+
+	/* initialize our shell local variables with the values 
+	 * currently living in the environment */
 	if (e) {
 		for (; *e; e++)
 			set_local_var(*e, 2);   /* without call putenv() */
 	}
-	job_list = &joblist_end;
 
 	last_return_code=EXIT_SUCCESS;
 
-	/* XXX what should these be while sourcing /etc/profile? */
-	global_argc = argc;
-	global_argv = argv;
-
-	/* 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 */
-	/* don't pay any attention to this signal; it just confuses 
-	   things and isn't really meant for shells anyway */
-	signal(SIGTTOU, SIG_IGN);
-	setpgid(0, getpid());
-	tcsetpgrp(fileno(stderr), getpid());
 
 	if (argv[0] && argv[0][0] == '-') {
 		debug_printf("\nsourcing /etc/profile\n");
-		input = xfopen("/etc/profile", "r");
-		mark_open(fileno(input));
-		parse_file_outer(input);
-		mark_closed(fileno(input));
-		fclose(input);
+		if ((input = fopen("/etc/profile", "r")) != NULL) {
+			mark_open(fileno(input));
+			parse_file_outer(input);
+			mark_closed(fileno(input));
+			fclose(input);
+		}
 	}
 	input=stdin;
 	
-	/* initialize the cwd -- this is never freed...*/
-	cwd = xgetcwd(0);
-	if (!cwd)
-		cwd = unknown;
-#ifdef BB_FEATURE_COMMAND_EDITING
-	cmdedit_set_initial_prompt();
-#else
-	PS1 = NULL;
-#endif
-	
 	while ((opt = getopt(argc, argv, "c:xif")) > 0) {
 		switch (opt) {
 			case 'c':
@@ -2615,8 +2656,9 @@ int shell_main(int argc, char **argv)
 	if (interactive) {
 		/* Looks like they want an interactive shell */
 		fprintf(stdout, "\nhush -- the humble shell v0.01 (testing)\n\n");
-		grab_tty_control();
+		setup_job_control();
 	}
+	
 	if (argv[optind]==NULL) {
 		opt=parse_file_outer(stdin);
 		goto final_return;
@@ -2629,7 +2671,20 @@ int shell_main(int argc, char **argv)
 	opt = parse_file_outer(input);
 
 #ifdef BB_FEATURE_CLEAN_UP
-	fclose(input.file);
+	fclose(input);
+	if (cwd && cwd != unknown)
+		free((char*)cwd);
+	{
+		struct variables *cur, *tmp;
+		for(cur = top_vars; cur; cur = tmp) {
+			tmp = cur->next;
+			if (!cur->flg_read_only) {
+				free(cur->name);
+				free(cur->value);
+				free(cur);
+			}
+		}
+	}
 #endif
 
 final_return: