diff options
Diffstat (limited to 'job.c')
| -rw-r--r-- | job.c | 1461 |
1 files changed, 1461 insertions, 0 deletions
@@ -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. */ |