/buildworker/marxinbox-gcc-clang-static-analyzer/build/libiberty/pex-unix.c

Bug Summary

File:	build/libiberty/pex-unix.c
Warning:	line 643, column 12 This assignment is prohibited after a successful vfork

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name pex-unix.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 1 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/libiberty -resource-dir /usr/lib64/clang/15.0.7 -D HAVE_CONFIG_H -I . -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/libiberty/../include -D _GNU_SOURCE -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wwrite-strings -fconst-strings -fdebug-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/libiberty -ferror-limit 19 -fcf-protection=full -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-6YIw1P.plist -x c /buildworker/marxinbox-gcc-clang-static-analyzer/build/libiberty/pex-unix.c

1/* Utilities to execute a program in a subprocess (possibly linked by pipes
 with other subprocesses), and wait for it.  Generic Unix version
 (also used for UWIN and VMS).
 Copyright (C) 1996-2023 Free Software Foundation, Inc.

6This file is part of the libiberty library.
7Libiberty is free software; you can redistribute it and/or
8modify it under the terms of the GNU Library General Public
9License as published by the Free Software Foundation; either
10version 2 of the License, or (at your option) any later version.

12Libiberty is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15Library General Public License for more details.

17You should have received a copy of the GNU Library General Public
18License along with libiberty; see the file COPYING.LIB.  If not,
19write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
20Boston, MA 02110-1301, USA.  */

22#include "config.h"
23#include "libiberty.h"
24#include "pex-common.h"
25#include "environ.h"

27#include <stdio.h>
28#include <signal.h>
29#include <errno(*__errno_location ()).h>
30#ifdef NEED_DECLARATION_ERRNO
31extern int errno(*__errno_location ());
32#endif
33#ifdef HAVE_STDLIB_H1
34#include <stdlib.h>
35#endif
36#ifdef HAVE_STRING_H1
37#include <string.h>
38#endif
39#ifdef HAVE_UNISTD_H1
40#include <unistd.h>
41#endif

43#include <sys/types.h>

45#ifdef HAVE_FCNTL_H1
46#include <fcntl.h>
47#endif
48#ifdef HAVE_SYS_WAIT_H1
49#include <sys/wait.h>
50#endif
51#ifdef HAVE_GETRUSAGE1
52#include <sys/time.h>
53#include <sys/resource.h>
54#endif
55#ifdef HAVE_SYS_STAT_H1
56#include <sys/stat.h>
57#endif
58#ifdef HAVE_PROCESS_H
59#include <process.h>
60#endif

62#ifdef vfork /* Autoconf may define this to fork for us. */
63# define VFORK_STRING"vfork" "fork"
64#else
65# define VFORK_STRING"vfork" "vfork"
66#endif
67#ifdef HAVE_VFORK_H
68#include <vfork.h>
69#endif
70#if defined(VMS) && defined (__LONG_POINTERS)
71#ifndef __CHAR_PTR32
72typedef char * __char_ptr32
73__attribute__ ((mode (SI)));
74#endif

76typedef __char_ptr32 *__char_ptr_char_ptr32
77__attribute__ ((mode (SI)));

79/* Return a 32 bit pointer to an array of 32 bit pointers 
 given a 64 bit pointer to an array of 64 bit pointers.  */

82static __char_ptr_char_ptr32
83to_ptr32 (char **ptr64)char **ptr64
84{
int argc;
__char_ptr_char_ptr32 short_argv;

/* Count number of arguments.  */
for (argc = 0; ptr64[argc] != NULL((void*)0); argc++)
  ;

/* Reallocate argv with 32 bit pointers.  */
short_argv = (__char_ptr_char_ptr32) decc$malloc
  (sizeof (__char_ptr32) * (argc + 1));

for (argc = 0; ptr64[argc] != NULL((void*)0); argc++)
  short_argv[argc] = (__char_ptr32) decc$strdup (ptr64[argc]);

short_argv[argc] = (__char_ptr32) 0;
return short_argv;

102}
103#else
104#define to_ptr32(argv)argv argv
105#endif

107/* File mode to use for private and world-readable files.  */

109#if defined (S_IRUSR0400) && defined (S_IWUSR0200) && defined (S_IRGRP(0400 >> 3)) && defined (S_IWGRP(0200 >> 3)) && defined (S_IROTH((0400 >> 3) >> 3)) && defined (S_IWOTH((0200 >> 3) >> 3))
110#define PUBLIC_MODE(0400 | 0200 | (0400 >> 3) | (0200 >> 3) | ((0400
 >> 3) >> 3) | ((0200 >> 3) >> 3))  \
  (S_IRUSR0400 | S_IWUSR0200 | S_IRGRP(0400 >> 3) | S_IWGRP(0200 >> 3) | S_IROTH((0400 >> 3) >> 3) | S_IWOTH((0200 >> 3) >> 3))
112#else
113#define PUBLIC_MODE(0400 | 0200 | (0400 >> 3) | (0200 >> 3) | ((0400
 >> 3) >> 3) | ((0200 >> 3) >> 3)) 0666
114#endif

116/* Get the exit status of a particular process, and optionally get the
 time that it took.  This is simple if we have wait4, slightly
 harder if we have waitpid, and is a pain if we only have wait.  */

120static pid_t pex_wait (struct pex_obj *, pid_t, int *, struct pex_time *);

122#ifdef HAVE_WAIT41

124static pid_t
125pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED__attribute__ ((__unused__)), pid_t pid, int *status,
 struct pex_time *time)
127{
pid_t ret;
struct rusage r;

131#ifdef HAVE_WAITPID1
if (time == NULL((void*)0))
  return waitpid (pid, status, 0);
134#endif

ret = wait4 (pid, status, 0, &r);

if (time != NULL((void*)0))
  {
    time->user_seconds = r.ru_utime.tv_sec;
    time->user_microseconds= r.ru_utime.tv_usec;
    time->system_seconds = r.ru_stime.tv_sec;
    time->system_microseconds= r.ru_stime.tv_usec;
  }

return ret;
147}

149#else /* ! defined (HAVE_WAIT4) */

151#ifdef HAVE_WAITPID1

153#ifndef HAVE_GETRUSAGE1

155static pid_t
156pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED__attribute__ ((__unused__)), pid_t pid, int *status,
 struct pex_time *time)
158{
if (time != NULL((void*)0))
  memset (time, 0, sizeof (struct pex_time));
return waitpid (pid, status, 0);
162}

164#else /* defined (HAVE_GETRUSAGE) */

166static pid_t
167pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED__attribute__ ((__unused__)), pid_t pid, int *status,
 struct pex_time *time)
169{
struct rusage r1, r2;
pid_t ret;

if (time == NULL((void*)0))
  return waitpid (pid, status, 0);

getrusage (RUSAGE_CHILDRENRUSAGE_CHILDREN, &r1);

ret = waitpid (pid, status, 0);
if (ret < 0)
  return ret;

getrusage (RUSAGE_CHILDRENRUSAGE_CHILDREN, &r2);

time->user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
time->user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
if (r2.ru_utime.tv_usec < r1.ru_utime.tv_usec)
  {
    --time->user_seconds;
    time->user_microseconds += 1000000;
  }

time->system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
time->system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
if (r2.ru_stime.tv_usec < r1.ru_stime.tv_usec)
  {
    --time->system_seconds;
    time->system_microseconds += 1000000;
  }

return ret;
201}

203#endif /* defined (HAVE_GETRUSAGE) */

205#else /* ! defined (HAVE_WAITPID) */

207struct status_list
208{
struct status_list *next;
pid_t pid;
int status;
struct pex_time time;
213};

215static pid_t
216pex_wait (struct pex_obj *obj, pid_t pid, int *status, struct pex_time *time)
217{
struct status_list **pp;

for (pp = (struct status_list **) &obj->sysdep;
     *pp != NULL((void*)0);
     pp = &(*pp)->next)
  {
    if ((*pp)->pid == pid)
{
 struct status_list *p;

 p = *pp;
 *status = p->status;
 if (time != NULL((void*)0))
   *time = p->time;
 *pp = p->next;
 free (p);
 return pid;
}
  }

while (1)
  {
    pid_t cpid;
    struct status_list *psl;
    struct pex_time pt;
243#ifdef HAVE_GETRUSAGE1
    struct rusage r1, r2;
245#endif

    if (time != NULL((void*)0))
{
249#ifdef HAVE_GETRUSAGE1
 getrusage (RUSAGE_CHILDRENRUSAGE_CHILDREN, &r1);
251#else
 memset (&pt, 0, sizeof (struct pex_time));
253#endif
}

    cpid = wait (status);

258#ifdef HAVE_GETRUSAGE1
    if (time != NULL((void*)0) && cpid >= 0)
{
 getrusage (RUSAGE_CHILDRENRUSAGE_CHILDREN, &r2);

 pt.user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
 pt.user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
 if (pt.user_microseconds < 0)
   {
     --pt.user_seconds;
     pt.user_microseconds += 1000000;
   }

 pt.system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
 pt.system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
 if (pt.system_microseconds < 0)
   {
     --pt.system_seconds;
     pt.system_microseconds += 1000000;
   }
}
279#endif

    if (cpid < 0 || cpid == pid)
{
 if (time != NULL((void*)0))
   *time = pt;
 return cpid;
}

    psl = XNEW (struct status_list)((struct status_list *) xmalloc (sizeof (struct status_list))
);
    psl->pid = cpid;
    psl->status = *status;
    if (time != NULL((void*)0))
psl->time = pt;
    psl->next = (struct status_list *) obj->sysdep;
    obj->sysdep = (void *) psl;
  }
296}

298#endif /* ! defined (HAVE_WAITPID) */
299#endif /* ! defined (HAVE_WAIT4) */

301static int pex_unix_open_read (struct pex_obj *, const char *, int);
302static int pex_unix_open_write (struct pex_obj *, const char *, int, int);
303static pid_t pex_unix_exec_child (struct pex_obj *, int, const char *,
		 char * const *, char * const *,
		 int, int, int, int,
		 const char **, int *);
307static int pex_unix_close (struct pex_obj *, int);
308static int pex_unix_wait (struct pex_obj *, pid_t, int *, struct pex_time *,
	  int, const char **, int *);
310static int pex_unix_pipe (struct pex_obj *, int *, int);
311static FILE *pex_unix_fdopenr (struct pex_obj *, int, int);
312static FILE *pex_unix_fdopenw (struct pex_obj *, int, int);
313static void pex_unix_cleanup (struct pex_obj *);

315/* The list of functions we pass to the common routines.  */

317const struct pex_funcs funcs =
318{
pex_unix_open_read,
pex_unix_open_write,
pex_unix_exec_child,
pex_unix_close,
pex_unix_wait,
pex_unix_pipe,
pex_unix_fdopenr,
pex_unix_fdopenw,
pex_unix_cleanup
328};

330/* Return a newly initialized pex_obj structure.  */

332struct pex_obj *
333pex_init (int flags, const char *pname, const char *tempbase)
334{
return pex_init_common (flags, pname, tempbase, &funcs);
336}

338/* Open a file for reading.  */

340static int
341pex_unix_open_read (struct pex_obj *obj ATTRIBUTE_UNUSED__attribute__ ((__unused__)), const char *name,
    int binary ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
343{
return open (name, O_RDONLY00);
345}

347/* Open a file for writing.  */

349static int
350pex_unix_open_write (struct pex_obj *obj ATTRIBUTE_UNUSED__attribute__ ((__unused__)), const char *name,
     int binary ATTRIBUTE_UNUSED__attribute__ ((__unused__)), int append)
352{
/* Note that we can't use O_EXCL here because gcc may have already
   created the temporary file via make_temp_file.  */
return open (name, O_WRONLY01 | O_CREAT0100
     | (append ? O_APPEND02000 : O_TRUNC01000), PUBLIC_MODE(0400 | 0200 | (0400 >> 3) | (0200 >> 3) | ((0400
 >> 3) >> 3) | ((0200 >> 3) >> 3)));
357}

359/* Close a file.  */

361static int
362pex_unix_close (struct pex_obj *obj ATTRIBUTE_UNUSED__attribute__ ((__unused__)), int fd)
363{
return close (fd);
365}

367/* Execute a child.  */

369#if defined(HAVE_SPAWNVE) && defined(HAVE_SPAWNVPE)
370/* Implementation of pex->exec_child using the Cygwin spawn operation.  */

372/* Subroutine of pex_unix_exec_child.  Move OLD_FD to a new file descriptor
 to be stored in *PNEW_FD, save the flags in *PFLAGS, and arrange for the
 saved copy to be close-on-exec.  Move CHILD_FD into OLD_FD.  If CHILD_FD
 is -1, OLD_FD is to be closed.  Return -1 on error.  */

377static int
378save_and_install_fd(int *pnew_fd, int *pflags, int old_fd, int child_fd)
379{
int new_fd, flags;

flags = fcntl (old_fd, F_GETFD1);

/* If we could not retrieve the flags, then OLD_FD was not open.  */
if (flags < 0)
  {
    new_fd = -1, flags = 0;
    if (child_fd >= 0 && dup2 (child_fd, old_fd) < 0)
return -1;
  }
/* If we wish to close OLD_FD, just mark it CLOEXEC.  */
else if (child_fd == -1)
  {
    new_fd = old_fd;
    if ((flags & FD_CLOEXEC1) == 0 && fcntl (old_fd, F_SETFD2, FD_CLOEXEC1) < 0)
return -1;
  }
/* Otherwise we need to save a copy of OLD_FD before installing CHILD_FD.  */
else
  {
401#ifdef F_DUPFD_CLOEXEC1030
    new_fd = fcntl (old_fd, F_DUPFD_CLOEXEC1030, 3);
    if (new_fd < 0)
return -1;
405#else
    /* Prefer F_DUPFD over dup in order to avoid getting a new fd
in the range 0-2, right where a new stderr fd might get put.  */
    new_fd = fcntl (old_fd, F_DUPFD0, 3);
    if (new_fd < 0)
return -1;
    if (fcntl (new_fd, F_SETFD2, FD_CLOEXEC1) < 0)
return -1;
413#endif
    if (dup2 (child_fd, old_fd) < 0)
return -1;
  }

*pflags = flags;
if (pnew_fd)
  *pnew_fd = new_fd;
else if (new_fd != old_fd)
  abort ();

return 0;
425}

427/* Subroutine of pex_unix_exec_child.  Move SAVE_FD back to OLD_FD
 restoring FLAGS.  If SAVE_FD < 0, OLD_FD is to be closed.  */

430static int
431restore_fd(int old_fd, int save_fd, int flags)
432{
/* For SAVE_FD < 0, all we have to do is restore the
   "closed-ness" of the original.  */
if (save_fd < 0)
  return close (old_fd);

/* For SAVE_FD == OLD_FD, all we have to do is restore the
   original setting of the CLOEXEC flag.  */
if (save_fd == old_fd)
  {
    if (flags & FD_CLOEXEC1)
return 0;
    return fcntl (old_fd, F_SETFD2, flags);
  }

/* Otherwise we have to move the descriptor back, restore the flags,
   and close the saved copy.  */
449#ifdef HAVE_DUP31
if (flags == FD_CLOEXEC1)
  {
    if (dup3 (save_fd, old_fd, O_CLOEXEC02000000) < 0)
return -1;
  }
else
456#endif
  {
    if (dup2 (save_fd, old_fd) < 0)
return -1;
    if (flags != 0 && fcntl (old_fd, F_SETFD2, flags) < 0)
return -1;
  }
return close (save_fd);
464}

466static pid_t
467pex_unix_exec_child (struct pex_obj *obj ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
     int flags, const char *executable,
     char * const * argv, char * const * env,
                   int in, int out, int errdes, int toclose,
     const char **errmsg, int *err)
472{
int fl_in = 0, fl_out = 0, fl_err = 0, fl_tc = 0;
int save_in = -1, save_out = -1, save_err = -1;
int max, retries;
pid_t pid;

if (flags & PEX_STDERR_TO_STDOUT0x8)
  errdes = out;

/* We need the three standard file descriptors to be set up as for
   the child before we perform the spawn.  The file descriptors for
   the parent need to be moved and marked for close-on-exec.  */
if (in != STDIN_FILE_NO0
    && save_and_install_fd (&save_in, &fl_in, STDIN_FILE_NO0, in) < 0)
  goto error_dup2;
if (out != STDOUT_FILE_NO1
    && save_and_install_fd (&save_out, &fl_out, STDOUT_FILE_NO1, out) < 0)
  goto error_dup2;
if (errdes != STDERR_FILE_NO2
    && save_and_install_fd (&save_err, &fl_err, STDERR_FILE_NO2, errdes) < 0)
  goto error_dup2;
if (toclose >= 0
    && save_and_install_fd (NULL((void*)0), &fl_tc, toclose, -1) < 0)
  goto error_dup2;

/* Now that we've moved the file descriptors for the child into place,
   close the originals.  Be careful not to close any of the standard
   file descriptors that we just set up.  */
max = -1;
if (errdes >= 0)
  max = STDERR_FILE_NO2;
else if (out >= 0)
  max = STDOUT_FILE_NO1;
else if (in >= 0)
  max = STDIN_FILE_NO0;
if (in > max)
  close (in);
if (out > max)
  close (out);
if (errdes > max && errdes != out)
  close (errdes);

/* If we were not given an environment, use the global environment.  */
if (env == NULL((void*)0))
  env = environ;

/* Launch the program.  If we get EAGAIN (normally out of pid's), try
   again a few times with increasing backoff times.  */
retries = 0;
while (1)
  {
    typedef const char * const *cc_cp;

    if (flags & PEX_SEARCH0x2)
pid = spawnvpe (_P_NOWAITO, executable, (cc_cp)argv, (cc_cp)env);
    else
pid = spawnve (_P_NOWAITO, executable, (cc_cp)argv, (cc_cp)env);

    if (pid > 0)
break;

    *err = errno(*__errno_location ());
    *errmsg = "spawn";
    if (errno(*__errno_location ()) != EAGAIN11 || ++retries == 4)
return (pid_t) -1;
    sleep (1 << retries);
  }

/* Success.  Restore the parent's file descriptors that we saved above.  */
if (toclose >= 0
    && restore_fd (toclose, toclose, fl_tc) < 0)
  goto error_dup2;
if (in != STDIN_FILE_NO0
    && restore_fd (STDIN_FILE_NO0, save_in, fl_in) < 0)
  goto error_dup2;
if (out != STDOUT_FILE_NO1
    && restore_fd (STDOUT_FILE_NO1, save_out, fl_out) < 0)
  goto error_dup2;
if (errdes != STDERR_FILE_NO2
    && restore_fd (STDERR_FILE_NO2, save_err, fl_err) < 0)
  goto error_dup2;

return pid;

error_dup2:
*err = errno(*__errno_location ());
*errmsg = "dup2";
return (pid_t) -1;
560}

562#else
563/* Implementation of pex->exec_child using standard vfork + exec.  */

565static pid_t
566pex_unix_exec_child (struct pex_obj *obj, int flags, const char *executable,
     char * const * argv, char * const * env,
                   int in, int out, int errdes,
     int toclose, const char **errmsg, int *err)
570{
pid_t pid = -1;
/* Tuple to communicate error from child to parent.  We can safely
   transfer string literal pointers as both run with identical
   address mappings.  */
struct fn_err 
{
  const char *fn;
  int err;
};
volatile int do_pipe = 0;
volatile int pipes[2]; /* [0]:reader,[1]:writer.  */
582#ifdef O_CLOEXEC02000000
do_pipe = 1;
584#endif
if (do_pipe0.1
'do_pipe' is 1
)
1
Taking true branch→
  {
587#ifdef HAVE_PIPE21
    if (pipe2 ((int *)pipes, O_CLOEXEC02000000))
2
←
Assuming the condition is false→
3
←
Taking false branch→
do_pipe = 0;
590#else
    if (pipe ((int *)pipes))
do_pipe = 0;
    else
{
 if (fcntl (pipes[1], F_SETFD2, FD_CLOEXEC1) == -1)
   {
     close (pipes[0]);
     close (pipes[1]);
     do_pipe = 0;
   }
}
602#endif
  }

/* We declare these to be volatile to avoid warnings from gcc about
   them being clobbered by vfork.  */
volatile int sleep_interval = 1;
volatile int retries;

/* We vfork and then set environ in the child before calling execvp.
   This clobbers the parent's environ so we need to restore it.
   It would be nice to use one of the exec* functions that takes an
   environment as a parameter, but that may have portability
   issues.  It is marked volatile so the child doesn't consider it a
   dead variable and therefore clobber where ever it is stored.  */
char **volatile save_environ = environ;

for (retries = 0; retries < 4; ++retries)
4
←
Loop condition is true.  Entering loop body→
  {
    pid = vfork ();
    if (pid4.1
'pid' is >= 0
 >= 0)
5
←
Taking true branch→
break;
6
←
 Execution continues on line 627→
    sleep (sleep_interval);
    sleep_interval *= 2;
  }

switch (pid)
7
←
Control jumps to 'case 0:'  at line 639→
  {
  case -1:
    if (do_pipe)
{
 close (pipes[0]);
 close (pipes[1]);
}
    *err = errno(*__errno_location ());
    *errmsg = VFORK_STRING"vfork";
    return (pid_t) -1;

  case 0:
    /* Child process.  */
    {
struct fn_err failed;
failed.fn = NULL((void*)0);
8
←
This assignment is prohibited after a successful vfork

if (do_pipe)
 close (pipes[0]);
if (!failed.fn && in != STDIN_FILE_NO0)
 {
   if (dup2 (in, STDIN_FILE_NO0) < 0)
     failed.fn = "dup2", failed.err = errno(*__errno_location ());
   else if (close (in) < 0)
     failed.fn = "close", failed.err = errno(*__errno_location ());
 }
if (!failed.fn && out != STDOUT_FILE_NO1)
 {
   if (dup2 (out, STDOUT_FILE_NO1) < 0)
     failed.fn = "dup2", failed.err = errno(*__errno_location ());
   else if (close (out) < 0)
     failed.fn = "close", failed.err = errno(*__errno_location ());
 }
if (!failed.fn && errdes != STDERR_FILE_NO2)
 {
   if (dup2 (errdes, STDERR_FILE_NO2) < 0)
     failed.fn = "dup2", failed.err = errno(*__errno_location ());
   else if (close (errdes) < 0)
     failed.fn = "close", failed.err = errno(*__errno_location ());
 }
if (!failed.fn && toclose >= 0)
 {
   if (close (toclose) < 0)
     failed.fn = "close", failed.err = errno(*__errno_location ());
 }
if (!failed.fn && (flags & PEX_STDERR_TO_STDOUT0x8) != 0)
 {
   if (dup2 (STDOUT_FILE_NO1, STDERR_FILE_NO2) < 0)
     failed.fn = "dup2", failed.err = errno(*__errno_location ());
 }
if (!failed.fn)
 {
   if (env)
     /* NOTE: In a standard vfork implementation this clobbers
 the parent's copy of environ "too" (in reality there's
 only one copy).  This is ok as we restore it below.  */
     environ = (char**) env;
   if ((flags & PEX_SEARCH0x2) != 0)
     {
execvp (executable, to_ptr32 (argv)argv);
failed.fn = "execvp", failed.err = errno(*__errno_location ());
     }
   else
     {
execv (executable, to_ptr32 (argv)argv);
failed.fn = "execv", failed.err = errno(*__errno_location ());
     }
 }

/* Something failed, report an error.  We don't use stdio
  routines, because we might be here due to a vfork call.  */
ssize_t retval = 0;

if (!do_pipe
   || write (pipes[1], &failed, sizeof (failed)) != sizeof (failed))
 {
   /* The parent will not see our scream above, so write to
      stdout.  */
706#define writeerr(s) (retval |= write (STDERR_FILE_NO2, s, strlen (s)))
   writeerr (obj->pname);
   writeerr (": error trying to exec '");
   writeerr (executable);
   writeerr ("': ");
   writeerr (failed.fn);
   writeerr (": ");
   writeerr (xstrerror (failed.err));
   writeerr ("\n");
715#undef writeerr
 }

/* Exit with -2 if the error output failed, too.  */
_exit (retval < 0 ? -2 : -1);
    }
    /* NOTREACHED */
    return (pid_t) -1;

  default:
    /* Parent process.  */
    {
/* Restore environ.  Note that the parent either doesn't run
  until the child execs/exits (standard vfork behaviour), or
  if it does run then vfork is behaving more like fork.  In
  either case we needn't worry about clobbering the child's
  copy of environ.  */
environ = save_environ;

struct fn_err failed;
failed.fn = NULL((void*)0);
if (do_pipe)
 {
   close (pipes[1]);
   ssize_t len = read (pipes[0], &failed, sizeof (failed));
   if (len < 0)
     failed.fn = NULL((void*)0);
   close (pipes[0]);
 }

if (!failed.fn && in != STDIN_FILE_NO0)
 if (close (in) < 0)
   failed.fn = "close", failed.err = errno(*__errno_location ());
if (!failed.fn && out != STDOUT_FILE_NO1)
 if (close (out) < 0)
   failed.fn = "close", failed.err = errno(*__errno_location ());
if (!failed.fn && errdes != STDERR_FILE_NO2)
 if (close (errdes) < 0)
   failed.fn = "close", failed.err = errno(*__errno_location ());

if (failed.fn)
 {
   *err = failed.err;
   *errmsg = failed.fn;
   return (pid_t) -1;
 }
    }
    return pid;
  }
764}
765#endif /* SPAWN */

767/* Wait for a child process to complete.  */

769static int
770pex_unix_wait (struct pex_obj *obj, pid_t pid, int *status,
      struct pex_time *time, int done, const char **errmsg,
      int *err)
773{
/* If we are cleaning up when the caller didn't retrieve process
   status for some reason, encourage the process to go away.  */
if (done)
  kill (pid, SIGTERM15);

if (pex_wait (obj, pid, status, time) < 0)
  {
    *err = errno(*__errno_location ());
    *errmsg = "wait";
    return -1;
  }

return 0;
787}

789/* Create a pipe.  */

791static int
792pex_unix_pipe (struct pex_obj *obj ATTRIBUTE_UNUSED__attribute__ ((__unused__)), int *p,
      int binary ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
794{
return pipe (p);
796}

798/* Get a FILE pointer to read from a file descriptor.  */

800static FILE *
801pex_unix_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED__attribute__ ((__unused__)), int fd,
  int binary ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
803{
return fdopen (fd, "r");
805}

807static FILE *
808pex_unix_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED__attribute__ ((__unused__)), int fd,
  int binary ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
810{
if (fcntl (fd, F_SETFD2, FD_CLOEXEC1) < 0)
  return NULL((void*)0);
return fdopen (fd, "w");
814}

816static void
817pex_unix_cleanup (struct pex_obj *obj ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
818{
819#if !defined (HAVE_WAIT41) && !defined (HAVE_WAITPID1)
while (obj->sysdep != NULL((void*)0))
  {
    struct status_list *this;
    struct status_list *next;

    this = (struct status_list *) obj->sysdep;
    next = this->next;
    free (this);
    obj->sysdep = (void *) next;
  }
830#endif
831}