780 lines
19 KiB
C
780 lines
19 KiB
C
/* Utilities to execute a program in a subprocess (possibly linked by pipes
|
|
with other subprocesses), and wait for it.
|
|
Copyright (C) 1996-2000 Free Software Foundation, Inc.
|
|
|
|
This file is part of the libiberty library.
|
|
Libiberty is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 of the License, or (at your option) any later version.
|
|
|
|
Libiberty 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
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public
|
|
License along with libiberty; see the file COPYING.LIB. If not,
|
|
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
Boston, MA 02111-1307, USA. */
|
|
|
|
/* This file exports two functions: pexecute and pwait. */
|
|
|
|
/* This file lives in at least two places: libiberty and gcc.
|
|
Don't change one without the other. */
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#ifdef NEED_DECLARATION_ERRNO
|
|
extern int errno;
|
|
#endif
|
|
#ifdef HAVE_STRING_H
|
|
#include <string.h>
|
|
#endif
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#ifdef HAVE_STDLIB_H
|
|
#include <stdlib.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_WAIT_H
|
|
#include <sys/wait.h>
|
|
#endif
|
|
|
|
#include "libiberty.h"
|
|
#include "safe-ctype.h"
|
|
|
|
/* stdin file number. */
|
|
#define STDIN_FILE_NO 0
|
|
|
|
/* stdout file number. */
|
|
#define STDOUT_FILE_NO 1
|
|
|
|
/* value of `pipe': port index for reading. */
|
|
#define READ_PORT 0
|
|
|
|
/* value of `pipe': port index for writing. */
|
|
#define WRITE_PORT 1
|
|
|
|
static char *install_error_msg = "installation problem, cannot exec `%s'";
|
|
|
|
/* pexecute: execute a program.
|
|
|
|
PROGRAM and ARGV are the arguments to execv/execvp.
|
|
|
|
THIS_PNAME is name of the calling program (i.e. argv[0]).
|
|
|
|
TEMP_BASE is the path name, sans suffix, of a temporary file to use
|
|
if needed. This is currently only needed for MSDOS ports that don't use
|
|
GO32 (do any still exist?). Ports that don't need it can pass NULL.
|
|
|
|
(FLAGS & PEXECUTE_SEARCH) is non-zero if $PATH should be searched
|
|
(??? It's not clear that GCC passes this flag correctly).
|
|
(FLAGS & PEXECUTE_FIRST) is nonzero for the first process in chain.
|
|
(FLAGS & PEXECUTE_FIRST) is nonzero for the last process in chain.
|
|
FIRST_LAST could be simplified to only mark the last of a chain of processes
|
|
but that requires the caller to always mark the last one (and not give up
|
|
early if some error occurs). It's more robust to require the caller to
|
|
mark both ends of the chain.
|
|
|
|
The result is the pid on systems like Unix where we fork/exec and on systems
|
|
like WIN32 and OS2 where we use spawn. It is up to the caller to wait for
|
|
the child.
|
|
|
|
The result is the WEXITSTATUS on systems like MSDOS where we spawn and wait
|
|
for the child here.
|
|
|
|
Upon failure, ERRMSG_FMT and ERRMSG_ARG are set to the text of the error
|
|
message with an optional argument (if not needed, ERRMSG_ARG is set to
|
|
NULL), and -1 is returned. `errno' is available to the caller to use.
|
|
|
|
pwait: cover function for wait.
|
|
|
|
PID is the process id of the task to wait for.
|
|
STATUS is the `status' argument to wait.
|
|
FLAGS is currently unused (allows future enhancement without breaking
|
|
upward compatibility). Pass 0 for now.
|
|
|
|
The result is the pid of the child reaped,
|
|
or -1 for failure (errno says why).
|
|
|
|
On systems that don't support waiting for a particular child, PID is
|
|
ignored. On systems like MSDOS that don't really multitask pwait
|
|
is just a mechanism to provide a consistent interface for the caller.
|
|
|
|
pfinish: finish generation of script
|
|
|
|
pfinish is necessary for systems like MPW where a script is generated that
|
|
runs the requested programs.
|
|
*/
|
|
|
|
#ifdef __MSDOS__
|
|
|
|
/* MSDOS doesn't multitask, but for the sake of a consistent interface
|
|
the code behaves like it does. pexecute runs the program, tucks the
|
|
exit code away, and returns a "pid". pwait must be called to fetch the
|
|
exit code. */
|
|
|
|
#include <process.h>
|
|
|
|
/* For communicating information from pexecute to pwait. */
|
|
static int last_pid = 0;
|
|
static int last_status = 0;
|
|
static int last_reaped = 0;
|
|
|
|
int
|
|
pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
|
|
const char *program;
|
|
char * const *argv;
|
|
const char *this_pname;
|
|
const char *temp_base;
|
|
char **errmsg_fmt, **errmsg_arg;
|
|
int flags;
|
|
{
|
|
int rc;
|
|
|
|
last_pid++;
|
|
if (last_pid < 0)
|
|
last_pid = 1;
|
|
|
|
if ((flags & PEXECUTE_ONE) != PEXECUTE_ONE)
|
|
abort ();
|
|
|
|
#ifdef __DJGPP__
|
|
/* ??? What are the possible return values from spawnv? */
|
|
rc = (flags & PEXECUTE_SEARCH ? spawnvp : spawnv) (P_WAIT, program, argv);
|
|
#else
|
|
char *scmd, *rf;
|
|
FILE *argfile;
|
|
int i, el = flags & PEXECUTE_SEARCH ? 4 : 0;
|
|
|
|
if (temp_base == 0)
|
|
temp_base = choose_temp_base ();
|
|
scmd = (char *) xmalloc (strlen (program) + strlen (temp_base) + 6 + el);
|
|
rf = scmd + strlen(program) + 2 + el;
|
|
sprintf (scmd, "%s%s @%s.gp", program,
|
|
(flags & PEXECUTE_SEARCH ? ".exe" : ""), temp_base);
|
|
argfile = fopen (rf, "w");
|
|
if (argfile == 0)
|
|
{
|
|
int errno_save = errno;
|
|
free (scmd);
|
|
errno = errno_save;
|
|
*errmsg_fmt = "cannot open `%s.gp'";
|
|
*errmsg_arg = temp_base;
|
|
return -1;
|
|
}
|
|
|
|
for (i=1; argv[i]; i++)
|
|
{
|
|
char *cp;
|
|
for (cp = argv[i]; *cp; cp++)
|
|
{
|
|
if (*cp == '"' || *cp == '\'' || *cp == '\\' || ISSPACE (*cp))
|
|
fputc ('\\', argfile);
|
|
fputc (*cp, argfile);
|
|
}
|
|
fputc ('\n', argfile);
|
|
}
|
|
fclose (argfile);
|
|
|
|
rc = system (scmd);
|
|
|
|
{
|
|
int errno_save = errno;
|
|
remove (rf);
|
|
free (scmd);
|
|
errno = errno_save;
|
|
}
|
|
#endif
|
|
|
|
if (rc == -1)
|
|
{
|
|
*errmsg_fmt = install_error_msg;
|
|
*errmsg_arg = (char *)program;
|
|
return -1;
|
|
}
|
|
|
|
/* Tuck the status away for pwait, and return a "pid". */
|
|
last_status = rc << 8;
|
|
return last_pid;
|
|
}
|
|
|
|
/* Use ECHILD if available, otherwise use EINVAL. */
|
|
#ifdef ECHILD
|
|
#define PWAIT_ERROR ECHILD
|
|
#else
|
|
#define PWAIT_ERROR EINVAL
|
|
#endif
|
|
|
|
int
|
|
pwait (pid, status, flags)
|
|
int pid;
|
|
int *status;
|
|
int flags;
|
|
{
|
|
/* On MSDOS each pexecute must be followed by it's associated pwait. */
|
|
if (pid != last_pid
|
|
/* Called twice for the same child? */
|
|
|| pid == last_reaped)
|
|
{
|
|
errno = PWAIT_ERROR;
|
|
return -1;
|
|
}
|
|
/* ??? Here's an opportunity to canonicalize the values in STATUS.
|
|
Needed? */
|
|
#ifdef __DJGPP__
|
|
*status = (last_status >> 8);
|
|
#else
|
|
*status = last_status;
|
|
#endif
|
|
last_reaped = last_pid;
|
|
return last_pid;
|
|
}
|
|
|
|
#endif /* MSDOS */
|
|
|
|
#if defined (_WIN32) && ! defined (_UWIN)
|
|
|
|
#include <process.h>
|
|
|
|
#ifdef __CYGWIN__
|
|
|
|
#define fix_argv(argvec) (argvec)
|
|
|
|
extern int _spawnv ();
|
|
extern int _spawnvp ();
|
|
|
|
#else /* ! __CYGWIN__ */
|
|
|
|
/* This is a kludge to get around the Microsoft C spawn functions' propensity
|
|
to remove the outermost set of double quotes from all arguments. */
|
|
|
|
const char * const *
|
|
fix_argv (argvec)
|
|
char **argvec;
|
|
{
|
|
int i;
|
|
|
|
for (i = 1; argvec[i] != 0; i++)
|
|
{
|
|
int len, j;
|
|
char *temp, *newtemp;
|
|
|
|
temp = argvec[i];
|
|
len = strlen (temp);
|
|
for (j = 0; j < len; j++)
|
|
{
|
|
if (temp[j] == '"')
|
|
{
|
|
newtemp = xmalloc (len + 2);
|
|
strncpy (newtemp, temp, j);
|
|
newtemp [j] = '\\';
|
|
strncpy (&newtemp [j+1], &temp [j], len-j);
|
|
newtemp [len+1] = 0;
|
|
temp = newtemp;
|
|
len++;
|
|
j++;
|
|
}
|
|
}
|
|
|
|
argvec[i] = temp;
|
|
}
|
|
|
|
for (i = 0; argvec[i] != 0; i++)
|
|
{
|
|
if (strpbrk (argvec[i], " \t"))
|
|
{
|
|
int len, trailing_backslash;
|
|
char *temp;
|
|
|
|
len = strlen (argvec[i]);
|
|
trailing_backslash = 0;
|
|
|
|
/* There is an added complication when an arg with embedded white
|
|
space ends in a backslash (such as in the case of -iprefix arg
|
|
passed to cpp). The resulting quoted strings gets misinterpreted
|
|
by the command interpreter -- it thinks that the ending quote
|
|
is escaped by the trailing backslash and things get confused.
|
|
We handle this case by escaping the trailing backslash, provided
|
|
it was not escaped in the first place. */
|
|
if (len > 1
|
|
&& argvec[i][len-1] == '\\'
|
|
&& argvec[i][len-2] != '\\')
|
|
{
|
|
trailing_backslash = 1;
|
|
++len; /* to escape the final backslash. */
|
|
}
|
|
|
|
len += 2; /* and for the enclosing quotes. */
|
|
|
|
temp = xmalloc (len + 1);
|
|
temp[0] = '"';
|
|
strcpy (temp + 1, argvec[i]);
|
|
if (trailing_backslash)
|
|
temp[len-2] = '\\';
|
|
temp[len-1] = '"';
|
|
temp[len] = '\0';
|
|
|
|
argvec[i] = temp;
|
|
}
|
|
}
|
|
|
|
return (const char * const *) argvec;
|
|
}
|
|
#endif /* __CYGWIN__ */
|
|
|
|
#include <io.h>
|
|
#include <fcntl.h>
|
|
#include <signal.h>
|
|
|
|
/* mingw32 headers may not define the following. */
|
|
|
|
#ifndef _P_WAIT
|
|
# define _P_WAIT 0
|
|
# define _P_NOWAIT 1
|
|
# define _P_OVERLAY 2
|
|
# define _P_NOWAITO 3
|
|
# define _P_DETACH 4
|
|
|
|
# define WAIT_CHILD 0
|
|
# define WAIT_GRANDCHILD 1
|
|
#endif
|
|
|
|
/* Win32 supports pipes */
|
|
int
|
|
pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
|
|
const char *program;
|
|
char * const *argv;
|
|
const char *this_pname;
|
|
const char *temp_base;
|
|
char **errmsg_fmt, **errmsg_arg;
|
|
int flags;
|
|
{
|
|
int pid;
|
|
int pdes[2], org_stdin, org_stdout;
|
|
int input_desc, output_desc;
|
|
int retries, sleep_interval;
|
|
|
|
/* Pipe waiting from last process, to be used as input for the next one.
|
|
Value is STDIN_FILE_NO if no pipe is waiting
|
|
(i.e. the next command is the first of a group). */
|
|
static int last_pipe_input;
|
|
|
|
/* If this is the first process, initialize. */
|
|
if (flags & PEXECUTE_FIRST)
|
|
last_pipe_input = STDIN_FILE_NO;
|
|
|
|
input_desc = last_pipe_input;
|
|
|
|
/* If this isn't the last process, make a pipe for its output,
|
|
and record it as waiting to be the input to the next process. */
|
|
if (! (flags & PEXECUTE_LAST))
|
|
{
|
|
if (_pipe (pdes, 256, O_BINARY) < 0)
|
|
{
|
|
*errmsg_fmt = "pipe";
|
|
*errmsg_arg = NULL;
|
|
return -1;
|
|
}
|
|
output_desc = pdes[WRITE_PORT];
|
|
last_pipe_input = pdes[READ_PORT];
|
|
}
|
|
else
|
|
{
|
|
/* Last process. */
|
|
output_desc = STDOUT_FILE_NO;
|
|
last_pipe_input = STDIN_FILE_NO;
|
|
}
|
|
|
|
if (input_desc != STDIN_FILE_NO)
|
|
{
|
|
org_stdin = dup (STDIN_FILE_NO);
|
|
dup2 (input_desc, STDIN_FILE_NO);
|
|
close (input_desc);
|
|
}
|
|
|
|
if (output_desc != STDOUT_FILE_NO)
|
|
{
|
|
org_stdout = dup (STDOUT_FILE_NO);
|
|
dup2 (output_desc, STDOUT_FILE_NO);
|
|
close (output_desc);
|
|
}
|
|
|
|
pid = (flags & PEXECUTE_SEARCH ? _spawnvp : _spawnv)
|
|
(_P_NOWAIT, program, fix_argv(argv));
|
|
|
|
if (input_desc != STDIN_FILE_NO)
|
|
{
|
|
dup2 (org_stdin, STDIN_FILE_NO);
|
|
close (org_stdin);
|
|
}
|
|
|
|
if (output_desc != STDOUT_FILE_NO)
|
|
{
|
|
dup2 (org_stdout, STDOUT_FILE_NO);
|
|
close (org_stdout);
|
|
}
|
|
|
|
if (pid == -1)
|
|
{
|
|
*errmsg_fmt = install_error_msg;
|
|
*errmsg_arg = program;
|
|
return -1;
|
|
}
|
|
|
|
return pid;
|
|
}
|
|
|
|
/* MS CRTDLL doesn't return enough information in status to decide if the
|
|
child exited due to a signal or not, rather it simply returns an
|
|
integer with the exit code of the child; eg., if the child exited with
|
|
an abort() call and didn't have a handler for SIGABRT, it simply returns
|
|
with status = 3. We fix the status code to conform to the usual WIF*
|
|
macros. Note that WIFSIGNALED will never be true under CRTDLL. */
|
|
|
|
int
|
|
pwait (pid, status, flags)
|
|
int pid;
|
|
int *status;
|
|
int flags;
|
|
{
|
|
#ifdef __CYGWIN__
|
|
return wait (status);
|
|
#else
|
|
int termstat;
|
|
|
|
pid = _cwait (&termstat, pid, WAIT_CHILD);
|
|
|
|
/* ??? Here's an opportunity to canonicalize the values in STATUS.
|
|
Needed? */
|
|
|
|
/* cwait returns the child process exit code in termstat.
|
|
A value of 3 indicates that the child caught a signal, but not
|
|
which one. Since only SIGABRT, SIGFPE and SIGINT do anything, we
|
|
report SIGABRT. */
|
|
if (termstat == 3)
|
|
*status = SIGABRT;
|
|
else
|
|
*status = (((termstat) & 0xff) << 8);
|
|
|
|
return pid;
|
|
#endif /* __CYGWIN__ */
|
|
}
|
|
|
|
#endif /* _WIN32 && ! _UWIN */
|
|
|
|
#ifdef OS2
|
|
|
|
/* ??? Does OS2 have process.h? */
|
|
extern int spawnv ();
|
|
extern int spawnvp ();
|
|
|
|
int
|
|
pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
|
|
const char *program;
|
|
char * const *argv;
|
|
const char *this_pname;
|
|
const char *temp_base;
|
|
char **errmsg_fmt, **errmsg_arg;
|
|
int flags;
|
|
{
|
|
int pid;
|
|
|
|
if ((flags & PEXECUTE_ONE) != PEXECUTE_ONE)
|
|
abort ();
|
|
/* ??? Presumably 1 == _P_NOWAIT. */
|
|
pid = (flags & PEXECUTE_SEARCH ? spawnvp : spawnv) (1, program, argv);
|
|
if (pid == -1)
|
|
{
|
|
*errmsg_fmt = install_error_msg;
|
|
*errmsg_arg = program;
|
|
return -1;
|
|
}
|
|
return pid;
|
|
}
|
|
|
|
int
|
|
pwait (pid, status, flags)
|
|
int pid;
|
|
int *status;
|
|
int flags;
|
|
{
|
|
/* ??? Here's an opportunity to canonicalize the values in STATUS.
|
|
Needed? */
|
|
int pid = wait (status);
|
|
return pid;
|
|
}
|
|
|
|
#endif /* OS2 */
|
|
|
|
#ifdef MPW
|
|
|
|
/* MPW pexecute doesn't actually run anything; instead, it writes out
|
|
script commands that, when run, will do the actual executing.
|
|
|
|
For example, in GCC's case, GCC will write out several script commands:
|
|
|
|
cpp ...
|
|
cc1 ...
|
|
as ...
|
|
ld ...
|
|
|
|
and then exit. None of the above programs will have run yet. The task
|
|
that called GCC will then execute the script and cause cpp,etc. to run.
|
|
The caller must invoke pfinish before calling exit. This adds
|
|
the finishing touches to the generated script. */
|
|
|
|
static int first_time = 1;
|
|
|
|
int
|
|
pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
|
|
const char *program;
|
|
char * const *argv;
|
|
const char *this_pname;
|
|
const char *temp_base;
|
|
char **errmsg_fmt, **errmsg_arg;
|
|
int flags;
|
|
{
|
|
char tmpprogram[255];
|
|
char *cp, *tmpname;
|
|
int i;
|
|
|
|
mpwify_filename (program, tmpprogram);
|
|
if (first_time)
|
|
{
|
|
printf ("Set Failed 0\n");
|
|
first_time = 0;
|
|
}
|
|
|
|
fputs ("If {Failed} == 0\n", stdout);
|
|
/* If being verbose, output a copy of the command. It should be
|
|
accurate enough and escaped enough to be "clickable". */
|
|
if (flags & PEXECUTE_VERBOSE)
|
|
{
|
|
fputs ("\tEcho ", stdout);
|
|
fputc ('\'', stdout);
|
|
fputs (tmpprogram, stdout);
|
|
fputc ('\'', stdout);
|
|
fputc (' ', stdout);
|
|
for (i=1; argv[i]; i++)
|
|
{
|
|
fputc ('\'', stdout);
|
|
/* See if we have an argument that needs fixing. */
|
|
if (strchr(argv[i], '/'))
|
|
{
|
|
tmpname = (char *) xmalloc (256);
|
|
mpwify_filename (argv[i], tmpname);
|
|
argv[i] = tmpname;
|
|
}
|
|
for (cp = argv[i]; *cp; cp++)
|
|
{
|
|
/* Write an Option-d escape char in front of special chars. */
|
|
if (strchr("'+", *cp))
|
|
fputc ('\266', stdout);
|
|
fputc (*cp, stdout);
|
|
}
|
|
fputc ('\'', stdout);
|
|
fputc (' ', stdout);
|
|
}
|
|
fputs ("\n", stdout);
|
|
}
|
|
fputs ("\t", stdout);
|
|
fputs (tmpprogram, stdout);
|
|
fputc (' ', stdout);
|
|
|
|
for (i=1; argv[i]; i++)
|
|
{
|
|
/* See if we have an argument that needs fixing. */
|
|
if (strchr(argv[i], '/'))
|
|
{
|
|
tmpname = (char *) xmalloc (256);
|
|
mpwify_filename (argv[i], tmpname);
|
|
argv[i] = tmpname;
|
|
}
|
|
if (strchr (argv[i], ' '))
|
|
fputc ('\'', stdout);
|
|
for (cp = argv[i]; *cp; cp++)
|
|
{
|
|
/* Write an Option-d escape char in front of special chars. */
|
|
if (strchr("'+", *cp))
|
|
fputc ('\266', stdout);
|
|
fputc (*cp, stdout);
|
|
}
|
|
if (strchr (argv[i], ' '))
|
|
fputc ('\'', stdout);
|
|
fputc (' ', stdout);
|
|
}
|
|
|
|
fputs ("\n", stdout);
|
|
|
|
/* Output commands that arrange to clean up and exit if a failure occurs.
|
|
We have to be careful to collect the status from the program that was
|
|
run, rather than some other script command. Also, we don't exit
|
|
immediately, since necessary cleanups are at the end of the script. */
|
|
fputs ("\tSet TmpStatus {Status}\n", stdout);
|
|
fputs ("\tIf {TmpStatus} != 0\n", stdout);
|
|
fputs ("\t\tSet Failed {TmpStatus}\n", stdout);
|
|
fputs ("\tEnd\n", stdout);
|
|
fputs ("End\n", stdout);
|
|
|
|
/* We're just composing a script, can't fail here. */
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
pwait (pid, status, flags)
|
|
int pid;
|
|
int *status;
|
|
int flags;
|
|
{
|
|
*status = 0;
|
|
return 0;
|
|
}
|
|
|
|
/* Write out commands that will exit with the correct error code
|
|
if something in the script failed. */
|
|
|
|
void
|
|
pfinish ()
|
|
{
|
|
printf ("\tExit \"{Failed}\"\n");
|
|
}
|
|
|
|
#endif /* MPW */
|
|
|
|
/* include for Unix-like environments but not for Dos-like environments */
|
|
#if ! defined (__MSDOS__) && ! defined (OS2) && ! defined (MPW) \
|
|
&& ! (defined (_WIN32) && ! defined (_UWIN))
|
|
|
|
extern int execv ();
|
|
extern int execvp ();
|
|
|
|
int
|
|
pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
|
|
const char *program;
|
|
char * const *argv;
|
|
const char *this_pname;
|
|
const char *temp_base ATTRIBUTE_UNUSED;
|
|
char **errmsg_fmt, **errmsg_arg;
|
|
int flags;
|
|
{
|
|
int (*func)() = (flags & PEXECUTE_SEARCH ? execvp : execv);
|
|
int pid;
|
|
int pdes[2];
|
|
int input_desc, output_desc;
|
|
int retries, sleep_interval;
|
|
/* Pipe waiting from last process, to be used as input for the next one.
|
|
Value is STDIN_FILE_NO if no pipe is waiting
|
|
(i.e. the next command is the first of a group). */
|
|
static int last_pipe_input;
|
|
|
|
/* If this is the first process, initialize. */
|
|
if (flags & PEXECUTE_FIRST)
|
|
last_pipe_input = STDIN_FILE_NO;
|
|
|
|
input_desc = last_pipe_input;
|
|
|
|
/* If this isn't the last process, make a pipe for its output,
|
|
and record it as waiting to be the input to the next process. */
|
|
if (! (flags & PEXECUTE_LAST))
|
|
{
|
|
if (pipe (pdes) < 0)
|
|
{
|
|
*errmsg_fmt = "pipe";
|
|
*errmsg_arg = NULL;
|
|
return -1;
|
|
}
|
|
output_desc = pdes[WRITE_PORT];
|
|
last_pipe_input = pdes[READ_PORT];
|
|
}
|
|
else
|
|
{
|
|
/* Last process. */
|
|
output_desc = STDOUT_FILE_NO;
|
|
last_pipe_input = STDIN_FILE_NO;
|
|
}
|
|
|
|
/* Fork a subprocess; wait and retry if it fails. */
|
|
sleep_interval = 1;
|
|
pid = -1;
|
|
for (retries = 0; retries < 4; retries++)
|
|
{
|
|
pid = fork ();
|
|
if (pid >= 0)
|
|
break;
|
|
sleep (sleep_interval);
|
|
sleep_interval *= 2;
|
|
}
|
|
|
|
switch (pid)
|
|
{
|
|
case -1:
|
|
*errmsg_fmt = "fork";
|
|
*errmsg_arg = NULL;
|
|
return -1;
|
|
|
|
case 0: /* child */
|
|
/* Move the input and output pipes into place, if necessary. */
|
|
if (input_desc != STDIN_FILE_NO)
|
|
{
|
|
close (STDIN_FILE_NO);
|
|
dup (input_desc);
|
|
close (input_desc);
|
|
}
|
|
if (output_desc != STDOUT_FILE_NO)
|
|
{
|
|
close (STDOUT_FILE_NO);
|
|
dup (output_desc);
|
|
close (output_desc);
|
|
}
|
|
|
|
/* Close the parent's descs that aren't wanted here. */
|
|
if (last_pipe_input != STDIN_FILE_NO)
|
|
close (last_pipe_input);
|
|
|
|
/* Exec the program. */
|
|
(*func) (program, argv);
|
|
|
|
fprintf (stderr, "%s: ", this_pname);
|
|
fprintf (stderr, install_error_msg, program);
|
|
fprintf (stderr, ": %s\n", xstrerror (errno));
|
|
exit (-1);
|
|
/* NOTREACHED */
|
|
return 0;
|
|
|
|
default:
|
|
/* In the parent, after forking.
|
|
Close the descriptors that we made for this child. */
|
|
if (input_desc != STDIN_FILE_NO)
|
|
close (input_desc);
|
|
if (output_desc != STDOUT_FILE_NO)
|
|
close (output_desc);
|
|
|
|
/* Return child's process number. */
|
|
return pid;
|
|
}
|
|
}
|
|
|
|
int
|
|
pwait (pid, status, flags)
|
|
int pid;
|
|
int *status;
|
|
int flags ATTRIBUTE_UNUSED;
|
|
{
|
|
/* ??? Here's an opportunity to canonicalize the values in STATUS.
|
|
Needed? */
|
|
#ifdef VMS
|
|
pid = waitpid (-1, status, 0);
|
|
#else
|
|
pid = wait (status);
|
|
#endif
|
|
return pid;
|
|
}
|
|
|
|
#endif /* ! __MSDOS__ && ! OS2 && ! MPW && ! (_WIN32 && ! _UWIN) */
|