diff --git a/job.c b/job.c
new file mode 100644
index 00000000..50192024
--- /dev/null
+++ b/job.c
@@ -0,0 +1,1461 @@
+/* Job execution and handling for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Make is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Make; see the file COPYING. If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include "make.h"
+#include "commands.h"
+#include "job.h"
+#include "file.h"
+#include "variable.h"
+#include <errno.h>
+
+/* Default path to search for executables. */
+static char default_path[] = ":/bin:/usr/bin";
+
+/* Default shell to use. */
+char default_shell[] = "/bin/sh";
+
+extern int errno;
+
+#if defined(POSIX) || defined(__GNU_LIBRARY__)
+#include <limits.h>
+#include <unistd.h>
+#define GET_NGROUPS_MAX sysconf (_SC_NGROUPS_MAX)
+#else /* Not POSIX. */
+#ifndef USG
+#include <sys/param.h>
+#define NGROUPS_MAX NGROUPS
+#endif /* Not USG. */
+#endif /* POSIX. */
+
+#ifdef POSIX
+#include <sys/wait.h>
+
+#define WAIT_NOHANG(status) waitpid(-1, (status), WNOHANG)
+
+#else /* Not POSIX. */
+
+#if defined(HAVE_SYS_WAIT) || !defined(USG)
+#include <sys/wait.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+
+#ifndef wait3
+extern int wait3 ();
+#endif
+#define WAIT_NOHANG(status) \
+ wait3((union wait *) (status), WNOHANG, (struct rusage *) 0)
+
+#if !defined (wait) && !defined (POSIX)
+extern int wait ();
+#endif
+#endif /* HAVE_SYS_WAIT || !USG */
+#endif /* POSIX. */
+
+#if defined(WTERMSIG) || (defined(USG) && !defined(HAVE_SYS_WAIT))
+#define WAIT_T int
+
+#ifndef WTERMSIG
+#define WTERMSIG(x) ((x) & 0x7f)
+#endif
+#ifndef WCOREDUMP
+#define WCOREDUMP(x) ((x) & 0x80)
+#endif
+#ifndef WEXITSTATUS
+#define WEXITSTATUS(x) (((x) >> 8) & 0xff)
+#endif
+#ifndef WIFSIGNALED
+#define WIFSIGNALED(x) (WTERMSIG (x) != 0)
+#endif
+#ifndef WIFEXITED
+#define WIFEXITED(x) (WTERMSIG (x) == 0)
+#endif
+
+#else /* WTERMSIG not defined and have <sys/wait.h> or not USG. */
+
+#define WAIT_T union wait
+#define WTERMSIG(x) ((x).w_termsig)
+#define WCOREDUMP(x) ((x).w_coredump)
+#define WEXITSTATUS(x) ((x).w_retcode)
+#ifndef WIFSIGNALED
+#define WIFSIGNALED(x) (WTERMSIG(x) != 0)
+#endif
+#ifndef WIFEXITED
+#define WIFEXITED(x) (WTERMSIG(x) == 0)
+#endif
+
+#endif /* WTERMSIG defined or USG and don't have <sys/wait.h>. */
+
+
+#if defined(__GNU_LIBRARY__) || defined(POSIX)
+
+#include <sys/types.h>
+#define GID_T gid_t
+
+#else /* Not GNU C library. */
+
+#define GID_T int
+
+extern int dup2 ();
+extern int execve ();
+extern void _exit ();
+extern int geteuid (), getegid ();
+extern int setgid (), getgid ();
+#endif /* GNU C library. */
+
+#ifndef USG
+extern int getdtablesize ();
+#else
+#include <sys/param.h>
+#define getdtablesize() NOFILE
+#endif
+
+extern void wait_to_start_job ();
+extern int start_remote_job_p ();
+extern int start_remote_job (), remote_status ();
+
+
+#if (defined(USG) && !defined(HAVE_SIGLIST)) || defined(DGUX)
+static char *sys_siglist[NSIG];
+void init_siglist ();
+#else /* Not (USG and HAVE_SIGLIST), or DGUX. */
+extern char *sys_siglist[];
+#endif /* USG and not HAVE_SIGLIST, or DGUX. */
+
+int child_handler ();
+static void free_child (), start_job ();
+
+/* Chain of all children. */
+
+struct child *children = 0;
+
+/* Number of children currently running. */
+
+unsigned int job_slots_used = 0;
+
+/* Nonzero if the `good' standard input is in use. */
+
+static int good_stdin_used = 0;
+
+/* Write an error message describing the exit status given in
+ EXIT_CODE, EXIT_SIG, and COREDUMP, for the target TARGET_NAME.
+ Append "(ignored)" if IGNORED is nonzero. */
+
+static void
+child_error (target_name, exit_code, exit_sig, coredump, ignored)
+ char *target_name;
+ int exit_code, exit_sig, coredump;
+ int ignored;
+{
+ char *ignore_string = ignored ? " (ignored)" : "";
+
+ if (exit_sig == 0)
+ error ("*** [%s] Error %d%s", target_name, exit_code, ignore_string);
+ else
+ {
+ char *coredump_string = coredump ? " (core dumped)" : "";
+ if (exit_sig > 0 && exit_sig < NSIG)
+ error ("*** [%s] %s%s",
+ target_name, sys_siglist[exit_sig], coredump_string);
+ else
+ error ("*** [%s] Signal %d%s", target_name, exit_sig, coredump_string);
+ }
+}
+
+extern void block_remote_children (), unblock_remote_children ();
+
+extern int fatal_signal_mask;
+
+#ifdef USG
+/* Set nonzero in the interval when it's possible that we may see a dead
+ child that's not in the `children' chain. */
+static int unknown_children_possible = 0;
+#endif
+
+
+/* Block the child termination signal and fatal signals. */
+
+static void
+block_signals ()
+{
+#ifdef USG
+
+ /* Tell child_handler that it might see children that aren't yet
+ in the `children' chain. */
+ unknown_children_possible = 1;
+
+ /* Ignoring SIGCLD makes wait always return -1.
+ Using the default action does the right thing. */
+ (void) SIGNAL (SIGCLD, SIG_DFL);
+
+#else /* Not USG. */
+
+ /* Block the signals. */
+ (void) sigblock (fatal_signal_mask | sigmask (SIGCHLD));
+
+#endif
+
+ block_remote_children ();
+}
+
+/* Unblock the child termination signal and fatal signals. */
+static void
+unblock_signals ()
+{
+#ifdef USG
+
+ (void) SIGNAL (SIGCLD, child_handler);
+
+ /* It should no longer be possible for children not in the chain to die. */
+ unknown_children_possible = 0;
+
+#else /* Not USG. */
+
+ /* Unblock the signals. */
+ (void) sigsetmask (sigblock (0) & ~(fatal_signal_mask | sigmask (SIGCHLD)));
+
+#endif
+
+ unblock_remote_children ();
+}
+
+static char *signals_blocked_p_stack = 0;
+static unsigned int signals_blocked_p_max;
+static unsigned int signals_blocked_p_depth;
+
+/* Make signals blocked in FLAG is nonzero, unblocked if FLAG is zero.
+ Push this setting on the signals_blocked_p_stack, so it can be
+ popped off by pop_signals_blocked_p. */
+
+void
+push_signals_blocked_p (flag)
+ int flag;
+{
+ int blocked;
+
+ if (signals_blocked_p_stack == 0)
+ {
+ signals_blocked_p_max = 8;
+ signals_blocked_p_stack = (char *) xmalloc (8);
+ signals_blocked_p_depth = 1;
+ signals_blocked_p_stack[0] = flag;
+
+ blocked = 0;
+ }
+ else
+ {
+ if (signals_blocked_p_depth == signals_blocked_p_max)
+ {
+ signals_blocked_p_max += 8;
+ signals_blocked_p_stack
+ = (char *) xrealloc(signals_blocked_p_stack,
+ signals_blocked_p_max);
+ }
+
+ blocked = (signals_blocked_p_depth > 0
+ && signals_blocked_p_stack[signals_blocked_p_depth - 1]);
+
+ signals_blocked_p_stack[++signals_blocked_p_depth - 1] = flag;
+ }
+
+ if (blocked && !flag)
+ unblock_signals ();
+ else if (flag && !blocked)
+ block_signals ();
+}
+
+/* Pop the signals_blocked_p setting from the stack
+ and block or unblock signals as appropriate. */
+
+void
+pop_signals_blocked_p ()
+{
+ int blocked, block;
+
+ blocked = (signals_blocked_p_depth > 0
+ && signals_blocked_p_stack[signals_blocked_p_depth-- - 1]);
+
+ block = (signals_blocked_p_depth > 0
+ && signals_blocked_p_stack[signals_blocked_p_depth - 1]);
+
+ if (block && !blocked)
+ block_signals ();
+ else if (blocked && !block)
+ unblock_signals ();
+}
+
+extern int shell_function_pid, shell_function_completed;
+
+/* Handle a child-termination signal (SIGCHLD, or SIGCLD for USG),
+ storing the returned status and the new command state (`cs_finished')
+ in the `file' member of the `struct child' for the dead child,
+ and removing the child from the chain.
+
+ If we were called as a signal handler, SIG should be SIGCHLD
+ (SIGCLD for USG). If instead it is zero, we were called explicitly
+ and should block waiting for running children.
+ If SIG is < 0, - SIG is the maximum number of children to bury (record
+ status of and remove from the chain). */
+
+int
+child_handler (sig)
+ int sig;
+{
+ WAIT_T status;
+ unsigned int dead_children = 0;
+
+ if (sig > 0)
+ block_signals ();
+
+ while (1)
+ {
+ int remote = 0;
+ register int pid;
+ int exit_code, exit_sig, coredump;
+ register struct child *lastc, *c;
+ int child_failed;
+
+ /* First, check for remote children. */
+ pid = remote_status (&exit_code, &exit_sig, &coredump, 0);
+ if (pid < 0)
+ {
+ /* No remote children. Check for local children. */
+
+#ifdef WAIT_NOHANG
+ if (sig > 0)
+ pid = WAIT_NOHANG (&status);
+ else
+ pid = wait (&status);
+#else /* USG and don't HAVE_SYS_WAIT. */
+ /* System V cannot do non-blocking waits, so we have two
+ choices if called as a signal handler: handle only one
+ child (there may be more if the signal was blocked),
+ or block waiting for more. The latter option makes
+ parallelism useless, so we must choose the former. */
+ pid = wait (&status);
+#endif /* HAVE_SYS_WAIT or not USG. */
+
+ if (pid <= 0)
+ /* No local children. */
+ break;
+ else
+ {
+ /* Chop the status word up. */
+ exit_code = WEXITSTATUS (status);
+ exit_sig = WIFSIGNALED (status) ? WTERMSIG (status) : 0;
+ coredump = WCOREDUMP (status);
+ }
+ }
+ else
+ /* We got a remote child. */
+ remote = 1;
+
+ /* Check if this is the child of the `shell' function. */
+ if (!remote && pid == shell_function_pid)
+ {
+ /* It is. Leave an indicator for the `shell' function. */
+ if (exit_sig == 0 && exit_code == 127)
+ shell_function_completed = -1;
+ else
+ shell_function_completed = 1;
+
+ /* Check if we have reached our quota of children. */
+ ++dead_children;
+ if (sig < 0 && dead_children == -sig)
+ break;
+#if defined(USG) && !defined(HAVE_SYS_WAIT)
+ else if (sig > 0)
+ break;
+#endif
+ else
+ continue;
+ }
+
+ child_failed = exit_sig != 0 || exit_code != 0;
+
+ /* Search for a child matching the deceased one. */
+ lastc = 0;
+ for (c = children; c != 0; lastc = c, c = c->next)
+ if (c->remote == remote && c->pid == pid)
+ break;
+
+ if (c == 0)
+ {
+ /* An unknown child died. */
+#ifdef USG
+ if (!unknown_children_possible)
+ {
+#endif
+ char buf[100];
+ sprintf (buf, "Unknown%s job %d", remote ? " remote" : "", pid);
+ if (child_failed)
+ child_error (buf, exit_code, exit_sig, coredump,
+ ignore_errors_flag);
+ else
+ error ("%s finished.", buf);
+#ifdef USG
+ }
+#endif
+ }
+ else
+ {
+ /* If this child had the good stdin, say it is now free. */
+ if (c->good_stdin)
+ good_stdin_used = 0;
+
+ if (child_failed && !c->noerror && !ignore_errors_flag)
+ {
+ /* The commands failed. Write an error message,
+ delete non-precious targets, and abort. */
+ child_error (c->file->name, exit_code, exit_sig, coredump, 0);
+ c->file->update_status = 1;
+ if (exit_sig != 0)
+ delete_child_targets (c);
+ }
+ else
+ {
+ if (child_failed)
+ {
+ /* The commands failed, but we don't care. */
+ child_error (c->file->name,
+ exit_code, exit_sig, coredump, 1);
+ child_failed = 0;
+ }
+
+ /* If there are more commands to run, try to start them. */
+ start_job (c);
+
+ switch (c->file->command_state)
+ {
+ case cs_running:
+ /* Successfully started. Loop to reap more children. */
+ continue;
+
+ case cs_finished:
+ if (c->file->update_status != 0)
+ {
+ /* We failed to start the commands. */
+ delete_child_targets (c);
+ }
+ break;
+
+ default:
+ error ("internal error: `%s' command_state \
+%d in child_handler", c->file->name);
+ abort ();
+ break;
+ }
+ }
+
+ /* Set the state flag to say the commands have finished. */
+ notice_finished_file (c->file);
+
+ /* Remove the child from the chain and free it. */
+ if (lastc == 0)
+ children = c->next;
+ else
+ lastc->next = c->next;
+ free_child (c);
+
+ /* There is now another slot open. */
+ --job_slots_used;
+
+ /* If the job failed, and the -k flag was not given, die. */
+ if (child_failed && !keep_going_flag)
+ die (1);
+
+ /* See if we have reached our quota for blocking. */
+ ++dead_children;
+ if (sig < 0 && dead_children == -sig)
+ break;
+#if defined(USG) && !defined(HAVE_SYS_WAIT)
+ else if (sig > 0)
+ break;
+#endif
+ }
+ }
+
+#ifdef USG
+ if (sig > 0)
+ (void) SIGNAL (sig, child_handler);
+#endif
+
+ if (sig > 0)
+ unblock_signals ();
+
+ return 0;
+}
+
+
+/* Wait for N children, blocking if necessary.
+ If N is zero, wait until we run out of children.
+ If ERR is nonzero and we have any children to wait for,
+ print a message on stderr. */
+
+void
+wait_for_children (n, err)
+ unsigned int n;
+ int err;
+{
+ push_signals_blocked_p (1);
+
+ if (err && (children != 0 || shell_function_pid != 0))
+ {
+ fflush (stdout);
+ error ("*** Waiting for unfinished jobs....");
+ }
+
+ /* Call child_handler to do the work. */
+ (void) child_handler (- (int) n);
+
+ pop_signals_blocked_p ();
+}
+
+/* Free the storage allocated for CHILD. */
+
+static void
+free_child (child)
+ register struct child *child;
+{
+ if (child->command_lines != 0)
+ {
+ register unsigned int i;
+ for (i = 0; i < child->file->cmds->ncommand_lines; ++i)
+ free (child->command_lines[i]);
+ free ((char *) child->command_lines);
+ }
+
+ if (child->environment != 0)
+ {
+ register char **ep = child->environment;
+ while (*ep != 0)
+ free (*ep++);
+ free ((char *) child->environment);
+ }
+
+ free ((char *) child);
+}
+
+/* Start a job to run the commands specified in CHILD.
+ CHILD is updated to reflect the commands and ID of the child process. */
+
+static void
+start_job (child)
+ register struct child *child;
+{
+ static int bad_stdin = -1;
+ register char *p;
+ char noprint = 0, recursive;
+ char **argv;
+
+ if (child->command_ptr == 0 || *child->command_ptr == '\0')
+ {
+ /* There are no more lines in the expansion of this line. */
+ if (child->command_line == child->file->cmds->ncommand_lines)
+ {
+ /* There are no more lines to be expanded. */
+ child->command_ptr = 0;
+ child->file->command_state = cs_finished;
+ child->file->update_status = 0;
+ return;
+ }
+ else
+ {
+ /* Get the next line to run, and set RECURSIVE
+ if the unexpanded line contains $(MAKE). */
+ child->command_ptr = child->command_lines[child->command_line];
+ recursive = child->file->cmds->lines_recurse[child->command_line];
+ ++child->command_line;
+ }
+ }
+ else
+ /* Still executing the last line we started. */
+ recursive = child->file->cmds->lines_recurse[child->command_line - 1];
+
+ p = child->command_ptr;
+ child->noerror = 0;
+ while (*p != '\0')
+ {
+ if (*p == '@')
+ noprint = 1;
+ else if (*p == '-')
+ child->noerror = 1;
+ else if (*p == '+')
+ recursive = 1;
+ else if (!isblank (*p))
+ break;
+ ++p;
+ }
+
+ /* If -q was given, just say that updating `failed'. */
+ if (question_flag && !recursive)
+ goto error;
+
+ /* There may be some preceding whitespace left if there
+ was nothing but a backslash on the first line. */
+ p = next_token (p);
+
+ /* Figure out an argument list from this command line. */
+
+ {
+ char *end;
+ argv = construct_command_argv (p, &end, child->file);
+ if (end == NULL)
+ child->command_ptr = NULL;
+ else
+ {
+ *end++ = '\0';
+ child->command_ptr = end;
+ }
+ }
+
+ if (argv == 0)
+ {
+ /* This line has no commands. Go to the next. */
+ start_job (child);
+ return;
+ }
+
+ /* Print out the command. */
+
+ if (just_print_flag || (!noprint && !silent_flag))
+ puts (p);
+
+ /* If -n was given, recurse to get the next line in the sequence. */
+
+ if (just_print_flag && !recursive)
+ {
+ free (argv[0]);
+ free ((char *) argv);
+ start_job (child);
+ return;
+ }
+
+ /* Flush the output streams so they won't have things written twice. */
+
+ fflush (stdout);
+ fflush (stderr);
+
+ /* Set up a bad standard input that reads from a broken pipe. */
+
+ if (bad_stdin == -1)
+ {
+ /* Make a file descriptor that is the read end of a broken pipe.
+ This will be used for some children's standard inputs. */
+ int pd[2];
+ if (pipe (pd) == 0)
+ {
+ /* Close the write side. */
+ (void) close (pd[1]);
+ /* Save the read side. */
+ bad_stdin = pd[0];
+ }
+ }
+
+ /* Decide whether to give this child the `good' standard input
+ (one that points to the terminal or whatever), or the `bad' one
+ that points to the read side of a broken pipe. */
+
+ child->good_stdin = !good_stdin_used;
+ if (child->good_stdin)
+ good_stdin_used = 1;
+
+ child->deleted = 0;
+
+ /* Set up the environment for the child. */
+ if (child->environment == 0)
+ child->environment = target_environment (child->file);
+
+ if (start_remote_job_p ())
+ {
+ int is_remote, id, used_stdin;
+ if (start_remote_job (argv, child->good_stdin ? 0 : bad_stdin,
+ &is_remote, &id, &used_stdin))
+ goto error;
+ else
+ {
+ if (child->good_stdin && !used_stdin)
+ {
+ child->good_stdin = 0;
+ good_stdin_used = 0;
+ }
+ child->remote = is_remote;
+ child->pid = id;
+ }
+ }
+ else
+ {
+ if (child->command_line - 1 == 0)
+ {
+ /* Wait for the load to be low enough if this
+ is the first command in the sequence. */
+ make_access ();
+ wait_to_start_job ();
+ user_access ();
+ }
+
+ /* Fork the child process. */
+
+ child->remote = 0;
+ child->pid = vfork ();
+ if (child->pid == 0)
+ /* We are the child side. */
+ child_execute_job (child->good_stdin ? 0 : bad_stdin, 1,
+ argv, child->environment);
+ else if (child->pid < 0)
+ {
+ /* Fork failed! */
+ perror_with_name (VFORK_NAME, "");
+ goto error;
+ }
+ }
+
+ /* We are the parent side. Set the state to
+ say the commands are running and return. */
+
+ child->file->command_state = cs_running;
+
+ /* Free the storage used by the child's argument list. */
+
+ free (argv[0]);
+ free ((char *) argv);
+
+ return;
+
+ error:;
+ child->file->update_status = 1;
+ child->file->command_state = cs_finished;
+}
+
+
+/* Create a `struct child' for FILE and start its commands running. */
+
+void
+new_job (file)
+ register struct file *file;
+{
+ register struct commands *cmds = file->cmds;
+ register struct child *c;
+ char **lines;
+ register unsigned int i;
+
+ /* Chop the commands up into lines if they aren't already. */
+ chop_commands (cmds);
+
+ if (job_slots != 0)
+ /* Wait for a job slot to be freed up. */
+ while (job_slots_used == job_slots)
+ wait_for_children (1, 0);
+
+ /* Expand the command lines and store the results in LINES. */
+ lines = (char **) xmalloc (cmds->ncommand_lines * sizeof (char *));
+ for (i = 0; i < cmds->ncommand_lines; ++i)
+ lines[i] = allocated_variable_expand_for_file (cmds->command_lines[i],
+ file);
+
+ /* Start the command sequence, record it in a new
+ `struct child', and add that to the chain. */
+
+ push_signals_blocked_p (1);
+
+ c = (struct child *) xmalloc (sizeof (struct child));
+ c->file = file;
+ c->command_lines = lines;
+ c->command_line = 0;
+ c->command_ptr = 0;
+ c->environment = 0;
+ start_job (c);
+ switch (file->command_state)
+ {
+ case cs_running:
+ c->next = children;
+ children = c;
+ /* One more job slot is in use. */
+ ++job_slots_used;
+ break;
+
+ case cs_finished:
+ free_child (c);
+ notice_finished_file (file);
+ break;
+
+ default:
+ error ("internal error: `%s' command_state == %d in new_job",
+ file->name, (int) file->command_state);
+ abort ();
+ break;
+ }
+
+ pop_signals_blocked_p ();
+
+ if (job_slots == 1 && file->command_state == cs_running)
+ {
+ /* Since there is only one job slot, make things run linearly.
+ Wait for the child to finish, setting the state to `cs_finished'. */
+ while (file->command_state != cs_finished)
+ wait_for_children (1, 0);
+ }
+}
+
+/* Replace the current process with one executing the command in ARGV.
+ STDIN_FD and STDOUT_FD are used as the process's stdin and stdout; ENVP is
+ the environment of the new program. This function does not return. */
+
+void
+child_execute_job (stdin_fd, stdout_fd, argv, envp)
+ int stdin_fd, stdout_fd;
+ char **argv, **envp;
+{
+ if (stdin_fd != 0)
+ (void) dup2 (stdin_fd, 0);
+ if (stdout_fd != 1)
+ (void) dup2 (stdout_fd, 1);
+
+ /* Free up file descriptors. */
+ {
+ register int d;
+ int max = getdtablesize ();
+ for (d = 3; d < max; ++d)
+ (void) close (d);
+ }
+
+ /* Don't block signals for the new process. */
+ unblock_signals ();
+
+ /* Run the command. */
+ exec_command (argv, envp);
+}
+
+/* Search PATH for FILE.
+ If successful, store the full pathname in PROGRAM and return 1.
+ If not sucessful, return zero. */
+
+static int
+search_path (file, path, program)
+ char *file, *path, *program;
+{
+ if (path == 0 || path[0] == '\0')
+ path = default_path;
+
+ if (index (file, '/') != 0)
+ {
+ strcpy (program, file);
+ return 1;
+ }
+ else
+ {
+ unsigned int len;
+
+#if !defined (USG) || defined (POSIX)
+#ifndef POSIX
+ extern int getgroups ();
+#endif
+ static int ngroups = -1;
+#ifdef NGROUPS_MAX
+ static GID_T groups[NGROUPS_MAX];
+#define ngroups_max NGROUPS_MAX
+#else
+ static GID_T *groups = 0;
+ static int ngroups_max;
+ if (groups == 0)
+ {
+ ngroups_max = GET_NGROUPS_MAX;
+ groups = (GID_T *) malloc (ngroups_max * sizeof (GID_T));
+ }
+#endif
+ if (groups != 0 && ngroups == -1)
+ ngroups = getgroups (ngroups_max, groups);
+#endif /* POSIX or not USG. */
+
+ len = strlen (file) + 1;
+ do
+ {
+ struct stat st;
+ int perm;
+ char *p;
+
+ p = index (path, ':');
+ if (p == 0)
+ p = path + strlen (path);
+
+ if (p == path)
+ bcopy (file, program, len);
+ else
+ {
+ bcopy (path, program, p - path);
+ program[p - path] = '/';
+ bcopy (file, program + (p - path) + 1, len);
+ }
+
+ if (stat (program, &st) == 0
+ && S_ISREG (st.st_mode))
+ {
+ if (st.st_uid == geteuid ())
+ perm = (st.st_mode & 0100);
+ else if (st.st_gid == getegid ())
+ perm = (st.st_mode & 0010);
+ else
+ {
+#ifndef USG
+ register int i;
+ for (i = 0; i < ngroups; ++i)
+ if (groups[i] == st.st_gid)
+ break;
+ if (i < ngroups)
+ perm = (st.st_mode & 0010);
+ else
+#endif /* Not USG. */
+ perm = (st.st_mode & 0001);
+ }
+
+ if (perm != 0)
+ return 1;
+ }
+
+ path = p + 1;
+ } while (*path != '\0');
+ }
+
+ return 0;
+}
+
+/* Replace the current process with one running the command in ARGV,
+ with environment ENVP. This function does not return. */
+
+void
+exec_command (argv, envp)
+ char **argv, **envp;
+{
+ char *shell, *path;
+ PATH_VAR (program);
+ register char **ep;
+
+ shell = path = 0;
+ for (ep = envp; *ep != 0; ++ep)
+ {
+ if (shell == 0 && !strncmp(*ep, "SHELL=", 6))
+ shell = &(*ep)[6];
+ else if (path == 0 && !strncmp(*ep, "PATH=", 5))
+ path = &(*ep)[5];
+ else if (path != 0 && shell != 0)
+ break;
+ }
+
+ /* Be the user, permanently. */
+ child_access ();
+
+ if (!search_path (argv[0], path, program))
+ error ("%s: Command not found", argv[0]);
+ else
+ {
+ /* Run the program. */
+ execve (program, argv, envp);
+
+ if (errno == ENOEXEC)
+ {
+ PATH_VAR (shell_program);
+ char *shell_path;
+ if (shell == 0)
+ shell_path = default_shell;
+ else
+ {
+ if (search_path (shell, path, shell_program))
+ shell_path = shell_program;
+ else
+ {
+ shell_path = 0;
+ error ("%s: Shell program not found", shell);
+ }
+ }
+
+ if (shell_path != 0)
+ {
+ char **new_argv;
+ int argc;
+
+ argc = 1;
+ while (argv[argc] != 0)
+ ++argc;
+
+ new_argv = (char **) alloca ((1 + argc + 1) * sizeof (char *));
+ new_argv[0] = shell_path;
+ new_argv[1] = program;
+ while (argc > 0)
+ {
+ new_argv[1 + argc] = argv[argc];
+ --argc;
+ }
+
+ execve (shell_path, new_argv, envp);
+ perror_with_name ("execve: ", shell_path);
+ }
+ }
+ else
+ perror_with_name ("execve: ", program);
+ }
+
+ _exit (127);
+}
+
+/* Figure out the argument list necessary to run LINE as a command.
+ Try to avoid using a shell. This routine handles only ' quoting.
+ Starting quotes may be escaped with a backslash. If any of the
+ characters in sh_chars[] is seen, or any of the builtin commands
+ listed in sh_cmds[] is the first word of a line, the shell is used.
+
+ If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
+ If *RESTP is NULL, newlines will be ignored.
+
+ SHELL is the shell to use, or nil to use the default shell.
+ IFS is the value of $IFS, or nil (meaning the default). */
+
+static char **
+construct_command_argv_internal (line, restp, shell, ifs)
+ char *line, **restp;
+ char *shell, *ifs;
+{
+ static char sh_chars[] = "#;\"*?[]&|<>(){}=$`";
+ static char *sh_cmds[] = { "cd", "eval", "exec", "exit", "login",
+ "logout", "set", "umask", "wait", "while", "for",
+ "case", "if", ":", ".", "break", "continue",
+ "export", "read", "readonly", "shift", "times",
+ "trap", "switch", 0 };
+ register int i;
+ register char *p;
+ register char *ap;
+ char *end;
+ int instring;
+ char **new_argv = 0;
+
+ if (restp != NULL)
+ *restp = NULL;
+
+ /* Make sure not to bother processing an empty line. */
+ while (isblank (*line))
+ ++line;
+ if (*line == '\0')
+ return 0;
+
+ /* See if it is safe to parse commands internally. */
+ if (shell == 0)
+ shell = default_shell;
+ else if (strcmp (shell, default_shell))
+ goto slow;
+
+ if (ifs != 0)
+ for (ap = ifs; *ap != '\0'; ++ap)
+ if (*ap != ' ' && *ap != '\t' && *ap != '\n')
+ goto slow;
+
+ i = strlen (line) + 1;
+
+ /* More than 1 arg per character is impossible. */
+ new_argv = (char **) xmalloc (i * sizeof (char *));
+
+ /* All the args can fit in a buffer as big as LINE is. */
+ ap = new_argv[0] = (char *) xmalloc (i);
+ end = ap + i;
+
+ /* I is how many complete arguments have been found. */
+ i = 0;
+ instring = 0;
+ for (p = line; *p != '\0'; ++p)
+ {
+ if (ap > end)
+ abort ();
+
+ if (instring)
+ {
+ /* Inside a string, just copy any char except a closing quote. */
+ if (*p == '\'')
+ instring = 0;
+ else
+ *ap++ = *p;
+ }
+ else if (index (sh_chars, *p) != 0)
+ /* Not inside a string, but it's a special char. */
+ goto slow;
+ else
+ /* Not a special char. */
+ switch (*p)
+ {
+ case '\\':
+ /* Backslash-newline combinations are eaten. */
+ if (p[1] == '\n')
+ {
+ /* Eat the backslash, the newline, and following whitespace,
+ replacing it all with a single space. */
+ p += 2;
+
+ /* If there is a tab after a backslash-newline,
+ remove it from the source line which will be echoed,
+ since it was most likely used to line
+ up the continued line with the previous one. */
+ if (*p == '\t')
+ strcpy (p, p + 1);
+
+ if (ap != new_argv[i])
+ /* Treat this as a space, ending the arg.
+ But if it's at the beginning of the arg, it should
+ just get eaten, rather than becoming an empty arg. */
+ goto end_of_arg;
+ else
+ --p;
+ }
+ else if (p[1] != '\0')
+ /* Copy and skip the following char. */
+ *ap++ = *++p;
+ break;
+
+ case '\'':
+ instring = 1;
+ break;
+
+ case '\n':
+ if (restp != NULL)
+ {
+ /* End of the command line. */
+ *restp = p;
+ goto end_of_line;
+ }
+ else
+ /* Newlines are not special. */
+ *ap++ = '\n';
+ break;
+
+ case ' ':
+ case '\t':
+ end_of_arg:
+ /* We have the end of an argument.
+ Terminate the text of the argument. */
+ *ap++ = '\0';
+ new_argv[++i] = ap;
+ /* If this argument is the command name,
+ see if it is a built-in shell command.
+ If so, have the shell handle it. */
+ if (i == 1)
+ {
+ register int j;
+ for (j = 0; sh_cmds[j] != 0; ++j)
+ if (streq (sh_cmds[j], new_argv[0]))
+ goto slow;
+ }
+
+ /* Ignore multiple whitespace chars. */
+ p = next_token (p);
+ /* Next iteration should examine the first nonwhite char. */
+ --p;
+ break;
+
+ default:
+ *ap++ = *p;
+ break;
+ }
+ }
+ end_of_line:
+
+ if (instring)
+ /* Let the shell deal with an unterminated quote. */
+ goto slow;
+
+ /* Terminate the last argument and the argument list. */
+
+ *ap = '\0';
+ if (new_argv[i][0] != '\0')
+ ++i;
+ new_argv[i] = 0;
+
+ if (new_argv[0] == 0)
+ /* Line was empty. */
+ return 0;
+ else
+ return new_argv;
+
+ slow:;
+ /* We must use the shell. */
+
+ if (new_argv != 0)
+ {
+ /* Free the old argument list we were working on. */
+ free (new_argv[0]);
+ free (new_argv);
+ }
+
+ {
+ /* SHELL may be a multi-word command. Construct a command line
+ "SHELL -c LINE", with all special chars in LINE escaped.
+ Then recurse, expanding this command line to get the final
+ argument list. */
+
+ unsigned int shell_len = strlen (shell);
+ static char minus_c[] = " -c ";
+ unsigned int line_len = strlen (line);
+
+ char *new_line = (char *) alloca (shell_len + (sizeof (minus_c) - 1)
+ + (line_len * 2) + 1);
+
+ ap = new_line;
+ bcopy (shell, ap, shell_len);
+ ap += shell_len;
+ bcopy (minus_c, ap, sizeof (minus_c) - 1);
+ ap += sizeof (minus_c) - 1;
+ for (p = line; *p != '\0'; ++p)
+ {
+ if (restp != NULL && *p == '\n')
+ {
+ *restp = p;
+ break;
+ }
+ else if (*p == '\\' && p[1] == '\n')
+ {
+ /* Eat the backslash, the newline, and following whitespace,
+ replacing it all with a single space (which is escaped
+ from the shell). */
+ p += 2;
+
+ /* If there is a tab after a backslash-newline,
+ remove it from the source line which will be echoed,
+ since it was most likely used to line
+ up the continued line with the previous one. */
+ if (*p == '\t')
+ strcpy (p, p + 1);
+
+ p = next_token (p);
+ --p;
+ *ap++ = '\\';
+ *ap++ = ' ';
+ continue;
+ }
+
+ if (*p == '\\' || *p == '\''
+ || isspace (*p)
+ || index (sh_chars, *p) != 0)
+ *ap++ = '\\';
+ *ap++ = *p;
+ }
+ *ap = '\0';
+
+ new_argv = construct_command_argv_internal (new_line, (char **) NULL,
+ (char *) 0, (char *) 0);
+ }
+
+ return new_argv;
+}
+
+/* Figure out the argument list necessary to run LINE as a command.
+ Try to avoid using a shell. This routine handles only ' quoting.
+ Starting quotes may be escaped with a backslash. If any of the
+ characters in sh_chars[] is seen, or any of the builtin commands
+ listed in sh_cmds[] is the first word of a line, the shell is used.
+
+ If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
+ If *RESTP is NULL, newlines will be ignored.
+
+ FILE is the target whose commands these are. It is used for
+ variable expansion for $(SHELL) and $(IFS). */
+
+char **
+construct_command_argv (line, restp, file)
+ char *line, **restp;
+ struct file *file;
+{
+ char *shell = allocated_variable_expand_for_file ("$(SHELL)", file);
+ char *ifs = allocated_variable_expand_for_file ("$(IFS)", file);
+ char **argv;
+
+ argv = construct_command_argv_internal (line, restp, shell, ifs);
+
+ free (shell);
+ free (ifs);
+
+ return argv;
+}
+
+#if (defined(USG) && !defined(HAVE_SIGLIST)) || defined(DGUX)
+/* Initialize sys_siglist. */
+
+void
+init_siglist ()
+{
+ char buf[100];
+ register unsigned int i;
+
+ for (i = 0; i < NSIG; ++i)
+ switch (i)
+ {
+ default:
+ sprintf (buf, "Signal %u", i);
+ sys_siglist[i] = savestring (buf, strlen (buf));
+ break;
+ case SIGHUP:
+ sys_siglist[i] = "Hangup";
+ break;
+ case SIGINT:
+ sys_siglist[i] = "Interrupt";
+ break;
+ case SIGQUIT:
+ sys_siglist[i] = "Quit";
+ break;
+ case SIGILL:
+ sys_siglist[i] = "Illegal Instruction";
+ break;
+ case SIGTRAP:
+ sys_siglist[i] = "Trace Trap";
+ break;
+ case SIGIOT:
+ sys_siglist[i] = "IOT Trap";
+ break;
+#ifdef SIGEMT
+ case SIGEMT:
+ sys_siglist[i] = "EMT Trap";
+ break;
+#endif
+#ifdef SIGDANGER
+ case SIGDANGER:
+ sys_siglist[i] = "Danger signal";
+ break;
+#endif
+ case SIGFPE:
+ sys_siglist[i] = "Floating Point Exception";
+ break;
+ case SIGKILL:
+ sys_siglist[i] = "Killed";
+ break;
+ case SIGBUS:
+ sys_siglist[i] = "Bus Error";
+ break;
+ case SIGSEGV:
+ sys_siglist[i] = "Segmentation fault";
+ break;
+ case SIGSYS:
+ sys_siglist[i] = "Bad Argument to System Call";
+ break;
+ case SIGPIPE:
+ sys_siglist[i] = "Broken Pipe";
+ break;
+ case SIGALRM:
+ sys_siglist[i] = "Alarm Clock";
+ break;
+ case SIGTERM:
+ sys_siglist[i] = "Terminated";
+ break;
+#if !defined (SIGIO) || SIGUSR1 != SIGIO
+ case SIGUSR1:
+ sys_siglist[i] = "User-defined signal 1";
+ break;
+#endif
+#if !defined (SIGURG) || SIGUSR2 != SIGURG
+ case SIGUSR2:
+ sys_siglist[i] = "User-defined signal 2";
+ break;
+#endif
+#ifdef SIGCLD
+ case SIGCLD:
+#endif
+#if defined(SIGCHLD) && !defined(SIGCLD)
+ case SIGCHLD:
+#endif
+ sys_siglist[i] = "Child Process Exited";
+ break;
+#ifdef SIGPWR
+ case SIGPWR:
+ sys_siglist[i] = "Power Failure";
+ break;
+#endif
+#ifdef SIGVTALRM
+ case SIGVTALRM:
+ sys_siglist[i] = "Virtual Timer Alarm";
+ break;
+#endif
+#ifdef SIGPROF
+ case SIGPROF:
+ sys_siglist[i] = "Profiling Alarm Clock";
+ break;
+#endif
+#ifdef SIGIO
+ case SIGIO:
+ sys_siglist[i] = "I/O Possible";
+ break;
+#endif
+#ifdef SIGWINDOW
+ case SIGWINDOW:
+ sys_siglist[i] = "Window System Signal";
+ break;
+#endif
+#ifdef SIGSTOP
+ case SIGSTOP:
+ sys_siglist[i] = "Stopped (signal)";
+ break;
+#endif
+#ifdef SIGTSTP
+ case SIGTSTP:
+ sys_siglist[i] = "Stopped";
+ break;
+#endif
+#ifdef SIGCONT
+ case SIGCONT:
+ sys_siglist[i] = "Continued";
+ break;
+#endif
+#ifdef SIGTTIN
+ case SIGTTIN:
+ sys_siglist[i] = "Stopped (tty input)";
+ break;
+#endif
+#ifdef SIGTTOU
+ case SIGTTOU:
+ sys_siglist[i] = "Stopped (tty output)";
+ break;
+#endif
+#ifdef SIGURG
+ case SIGURG:
+ sys_siglist[i] = "Urgent Condition on Socket";
+ break;
+#endif
+#ifdef SIGXCPU
+ case SIGXCPU:
+ sys_siglist[i] = "CPU Limit Exceeded";
+ break;
+#endif
+#ifdef SIGXFSZ
+ case SIGXFSZ:
+ sys_siglist[i] = "File Size Limit Exceeded";
+ break;
+#endif
+ }
+}
+#endif /* USG and not HAVE_SIGLIST. */
+
+#if defined(USG) && !defined(USGr3) && !defined(HAVE_DUP2)
+int
+dup2 (old, new)
+ int old, new;
+{
+ int fd;
+
+ (void) close (new);
+ fd = dup (old);
+ if (fd != new)
+ {
+ (void) close (fd);
+ errno = EMFILE;
+ return -1;
+ }
+
+ return fd;
+}
+#endif /* USG and not USGr3 and not HAVE_DUP2. */