libiberty/pex-unix.c

   1 /* Utilities to execute a program in a subprocess (possibly linked by pipes
   2    with other subprocesses), and wait for it.  Generic Unix version
   3    (also used for UWIN and VMS).
   4    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004
   5    Free Software Foundation, Inc.
   6
   7 This file is part of the libiberty library.
   8 Libiberty is free software; you can redistribute it and/or
   9 modify it under the terms of the GNU Library General Public
  10 License as published by the Free Software Foundation; either
  11 version 2 of the License, or (at your option) any later version.
  12
  13 Libiberty is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 Library General Public License for more details.
  17
  18 You should have received a copy of the GNU Library General Public
  19 License along with libiberty; see the file COPYING.LIB.  If not,
  20 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23 #include "pex-common.h"
  24
  25 #include <stdio.h>
  26 #include <errno.h>
  27 #ifdef NEED_DECLARATION_ERRNO
  28 extern int errno;
  29 #endif
  30 #ifdef HAVE_STRING_H
  31 #include <string.h>
  32 #endif
  33 #ifdef HAVE_UNISTD_H
  34 #include <unistd.h>
  35 #endif
  36 #ifdef HAVE_STDLIB_H
  37 #include <stdlib.h>
  38 #endif
  39 #ifdef HAVE_SYS_WAIT_H
  40 #include <sys/wait.h>
  41 #endif
  42
  43 #ifndef HAVE_WAITPID
  44 #define waitpid(pid, status, flags) wait(status)
  45 #endif
  46
  47 #ifdef vfork /* Autoconf may define this to fork for us. */
  48 # define VFORK_STRING "fork"
  49 #else
  50 # define VFORK_STRING "vfork"
  51 #endif
  52 #ifdef HAVE_VFORK_H
  53 #include <vfork.h>
  54 #endif
  55 #ifdef VMS
  56 #define vfork() (decc$$alloc_vfork_blocks() >= 0 ? \
  57                lib$get_current_invo_context(decc$$get_vfork_jmpbuf()) : -1)
  58 #endif /* VMS */
  59
  60 /* Execute a program, possibly setting up pipes to programs executed
  61    via other calls to this function.
  62
  63    This version of the function uses vfork.  In general vfork is
  64    similar to setjmp/longjmp, in that any variable which is modified by
  65    the child process has an indeterminate value in the parent process.
  66    We follow a safe approach here by not modifying any variables at
  67    all in the child process (with the possible exception of variables
  68    modified by xstrerror if exec fails, but this is unlikely to be
  69    detectable).
  70
  71    We work a little bit harder to avoid gcc warnings.  gcc will warn
  72    about any automatic variable which is live at the time of the
  73    vfork, which is non-volatile, and which is either set more than
  74    once or is an argument to the function.  This warning isn't quite
  75    right, since what we really care about is whether the variable is
  76    live at the time of the vfork and set afterward by the child
  77    process, but gcc only checks whether the variable is set more than
  78    once.  To avoid this warning, we ensure that any variable which is
  79    live at the time of the vfork (i.e., used after the vfork) is set
  80    exactly once and is not an argument, or is marked volatile.  */
  81
  82 int
  83 pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg,
  84           flagsarg)
  85      const char *program;
  86      char * const *argv;
  87      const char *this_pname;
  88      const char *temp_base ATTRIBUTE_UNUSED;
  89      char **errmsg_fmt, **errmsg_arg;
  90      int flagsarg;
  91 {
  92   int pid;
  93   int pdes[2];
  94   int out;
  95   int input_desc, output_desc;
  96   int flags;
  97   /* We declare these to be volatile to avoid warnings from gcc about
  98      them being clobbered by vfork.  */
  99   volatile int retries, sleep_interval;
 100   /* Pipe waiting from last process, to be used as input for the next one.
 101      Value is STDIN_FILE_NO if no pipe is waiting
 102      (i.e. the next command is the first of a group).  */
 103   static int last_pipe_input;
 104
 105   flags = flagsarg;
 106
 107   /* If this is the first process, initialize.  */
 108   if (flags & PEXECUTE_FIRST)
 109     last_pipe_input = STDIN_FILE_NO;
 110
 111   input_desc = last_pipe_input;
 112
 113   /* If this isn't the last process, make a pipe for its output,
 114      and record it as waiting to be the input to the next process.  */
 115   if (! (flags & PEXECUTE_LAST))
 116     {
 117       if (pipe (pdes) < 0)
 118         {
 119           *errmsg_fmt = "pipe";
 120           *errmsg_arg = NULL;
 121           return -1;
 122         }
 123       out = pdes[WRITE_PORT];
 124       last_pipe_input = pdes[READ_PORT];
 125     }
 126   else
 127     {
 128       /* Last process.  */
 129       out = STDOUT_FILE_NO;
 130       last_pipe_input = STDIN_FILE_NO;
 131     }
 132
 133   output_desc = out;
 134
 135   /* Fork a subprocess; wait and retry if it fails.  */
 136   sleep_interval = 1;
 137   pid = -1;
 138   for (retries = 0; retries < 4; retries++)
 139     {
 140       pid = vfork ();
 141       if (pid >= 0)
 142         break;
 143       sleep (sleep_interval);
 144       sleep_interval *= 2;
 145     }
 146
 147   switch (pid)
 148     {
 149     case -1:
 150       *errmsg_fmt = "fork";
 151       *errmsg_arg = NULL;
 152       return -1;
 153
 154     case 0: /* child */
 155       /* Move the input and output pipes into place, if necessary.  */
 156       if (input_desc != STDIN_FILE_NO)
 157         {
 158           close (STDIN_FILE_NO);
 159           dup (input_desc);
 160           close (input_desc);
 161         }
 162       if (output_desc != STDOUT_FILE_NO)
 163         {
 164           close (STDOUT_FILE_NO);
 165           dup (output_desc);
 166           close (output_desc);
 167         }
 168
 169       /* Close the parent's descs that aren't wanted here.  */
 170       if (last_pipe_input != STDIN_FILE_NO)
 171         close (last_pipe_input);
 172
 173       /* Exec the program.  */
 174       if (flags & PEXECUTE_SEARCH)
 175         execvp (program, argv);
 176       else
 177         execv (program, argv);
 178
 179       /* We don't want to call fprintf after vfork.  */
 180 #define writeerr(s) write (STDERR_FILE_NO, s, strlen (s))
 181       writeerr (this_pname);
 182       writeerr (": ");
 183       writeerr ("installation problem, cannot exec '");
 184       writeerr (program);
 185       writeerr ("': ");
 186       writeerr (xstrerror (errno));
 187       writeerr ("\n");
 188       _exit (-1);
 189       /* NOTREACHED */
 190       return 0;
 191
 192     default:
 193       /* In the parent, after forking.
 194          Close the descriptors that we made for this child.  */
 195       if (input_desc != STDIN_FILE_NO)
 196         close (input_desc);
 197       if (output_desc != STDOUT_FILE_NO)
 198         close (output_desc);
 199
 200       /* Return child's process number.  */
 201       return pid;
 202     }
 203 }
 204
 205 int
 206 pwait (pid, status, flags)
 207      int pid;
 208      int *status;
 209      int flags ATTRIBUTE_UNUSED;
 210 {
 211   /* ??? Here's an opportunity to canonicalize the values in STATUS.
 212      Needed?  */
 213   pid = waitpid (pid, status, 0);
 214   return pid;
 215 }