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, 2005, 2009,
5    2010, 2015 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., 51 Franklin Street - Fifth Floor,
21 Boston, MA 02110-1301, USA.  */
22 
23 #include "config.h"
24 #include "libiberty.h"
25 #include "pex-common.h"
26 #include "environ.h"
27 
28 #include <stdio.h>
29 #include <signal.h>
30 #include <errno.h>
31 #ifdef NEED_DECLARATION_ERRNO
32 extern int errno;
33 #endif
34 #ifdef HAVE_STDLIB_H
35 #include <stdlib.h>
36 #endif
37 #ifdef HAVE_STRING_H
38 #include <string.h>
39 #endif
40 #ifdef HAVE_UNISTD_H
41 #include <unistd.h>
42 #endif
43 
44 #include <sys/types.h>
45 
46 #ifdef HAVE_FCNTL_H
47 #include <fcntl.h>
48 #endif
49 #ifdef HAVE_SYS_WAIT_H
50 #include <sys/wait.h>
51 #endif
52 #ifdef HAVE_GETRUSAGE
53 #include <sys/time.h>
54 #include <sys/resource.h>
55 #endif
56 #ifdef HAVE_SYS_STAT_H
57 #include <sys/stat.h>
58 #endif
59 #ifdef HAVE_PROCESS_H
60 #include <process.h>
61 #endif
62 
63 #ifdef vfork /* Autoconf may define this to fork for us. */
64 # define VFORK_STRING "fork"
65 #else
66 # define VFORK_STRING "vfork"
67 #endif
68 #ifdef HAVE_VFORK_H
69 #include <vfork.h>
70 #endif
71 #if defined(VMS) && defined (__LONG_POINTERS)
72 #ifndef __CHAR_PTR32
73 typedef char * __char_ptr32
74 __attribute__ ((mode (SI)));
75 #endif
76 
77 typedef __char_ptr32 *__char_ptr_char_ptr32
78 __attribute__ ((mode (SI)));
79 
80 /* Return a 32 bit pointer to an array of 32 bit pointers
81    given a 64 bit pointer to an array of 64 bit pointers.  */
82 
83 static __char_ptr_char_ptr32
to_ptr32(char ** ptr64)84 to_ptr32 (char **ptr64)
85 {
86   int argc;
87   __char_ptr_char_ptr32 short_argv;
88 
89   /* Count number of arguments.  */
90   for (argc = 0; ptr64[argc] != NULL; argc++)
91     ;
92 
93   /* Reallocate argv with 32 bit pointers.  */
94   short_argv = (__char_ptr_char_ptr32) decc$malloc
95     (sizeof (__char_ptr32) * (argc + 1));
96 
97   for (argc = 0; ptr64[argc] != NULL; argc++)
98     short_argv[argc] = (__char_ptr32) decc$strdup (ptr64[argc]);
99 
100   short_argv[argc] = (__char_ptr32) 0;
101   return short_argv;
102 
103 }
104 #else
105 #define to_ptr32(argv) argv
106 #endif
107 
108 /* File mode to use for private and world-readable files.  */
109 
110 #if defined (S_IRUSR) && defined (S_IWUSR) && defined (S_IRGRP) && defined (S_IWGRP) && defined (S_IROTH) && defined (S_IWOTH)
111 #define PUBLIC_MODE  \
112     (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
113 #else
114 #define PUBLIC_MODE 0666
115 #endif
116 
117 /* Get the exit status of a particular process, and optionally get the
118    time that it took.  This is simple if we have wait4, slightly
119    harder if we have waitpid, and is a pain if we only have wait.  */
120 
121 static pid_t pex_wait (struct pex_obj *, pid_t, int *, struct pex_time *);
122 
123 #ifdef HAVE_WAIT4
124 
125 static pid_t
pex_wait(struct pex_obj * obj ATTRIBUTE_UNUSED,pid_t pid,int * status,struct pex_time * time)126 pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
127 	  struct pex_time *time)
128 {
129   pid_t ret;
130   struct rusage r;
131 
132 #ifdef HAVE_WAITPID
133   if (time == NULL)
134     return waitpid (pid, status, 0);
135 #endif
136 
137   ret = wait4 (pid, status, 0, &r);
138 
139   if (time != NULL)
140     {
141       time->user_seconds = r.ru_utime.tv_sec;
142       time->user_microseconds= r.ru_utime.tv_usec;
143       time->system_seconds = r.ru_stime.tv_sec;
144       time->system_microseconds= r.ru_stime.tv_usec;
145     }
146 
147   return ret;
148 }
149 
150 #else /* ! defined (HAVE_WAIT4) */
151 
152 #ifdef HAVE_WAITPID
153 
154 #ifndef HAVE_GETRUSAGE
155 
156 static pid_t
pex_wait(struct pex_obj * obj ATTRIBUTE_UNUSED,pid_t pid,int * status,struct pex_time * time)157 pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
158 	  struct pex_time *time)
159 {
160   if (time != NULL)
161     memset (time, 0, sizeof (struct pex_time));
162   return waitpid (pid, status, 0);
163 }
164 
165 #else /* defined (HAVE_GETRUSAGE) */
166 
167 static pid_t
pex_wait(struct pex_obj * obj ATTRIBUTE_UNUSED,pid_t pid,int * status,struct pex_time * time)168 pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
169 	  struct pex_time *time)
170 {
171   struct rusage r1, r2;
172   pid_t ret;
173 
174   if (time == NULL)
175     return waitpid (pid, status, 0);
176 
177   getrusage (RUSAGE_CHILDREN, &r1);
178 
179   ret = waitpid (pid, status, 0);
180   if (ret < 0)
181     return ret;
182 
183   getrusage (RUSAGE_CHILDREN, &r2);
184 
185   time->user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
186   time->user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
187   if (r2.ru_utime.tv_usec < r1.ru_utime.tv_usec)
188     {
189       --time->user_seconds;
190       time->user_microseconds += 1000000;
191     }
192 
193   time->system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
194   time->system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
195   if (r2.ru_stime.tv_usec < r1.ru_stime.tv_usec)
196     {
197       --time->system_seconds;
198       time->system_microseconds += 1000000;
199     }
200 
201   return ret;
202 }
203 
204 #endif /* defined (HAVE_GETRUSAGE) */
205 
206 #else /* ! defined (HAVE_WAITPID) */
207 
208 struct status_list
209 {
210   struct status_list *next;
211   pid_t pid;
212   int status;
213   struct pex_time time;
214 };
215 
216 static pid_t
pex_wait(struct pex_obj * obj,pid_t pid,int * status,struct pex_time * time)217 pex_wait (struct pex_obj *obj, pid_t pid, int *status, struct pex_time *time)
218 {
219   struct status_list **pp;
220 
221   for (pp = (struct status_list **) &obj->sysdep;
222        *pp != NULL;
223        pp = &(*pp)->next)
224     {
225       if ((*pp)->pid == pid)
226 	{
227 	  struct status_list *p;
228 
229 	  p = *pp;
230 	  *status = p->status;
231 	  if (time != NULL)
232 	    *time = p->time;
233 	  *pp = p->next;
234 	  free (p);
235 	  return pid;
236 	}
237     }
238 
239   while (1)
240     {
241       pid_t cpid;
242       struct status_list *psl;
243       struct pex_time pt;
244 #ifdef HAVE_GETRUSAGE
245       struct rusage r1, r2;
246 #endif
247 
248       if (time != NULL)
249 	{
250 #ifdef HAVE_GETRUSAGE
251 	  getrusage (RUSAGE_CHILDREN, &r1);
252 #else
253 	  memset (&pt, 0, sizeof (struct pex_time));
254 #endif
255 	}
256 
257       cpid = wait (status);
258 
259 #ifdef HAVE_GETRUSAGE
260       if (time != NULL && cpid >= 0)
261 	{
262 	  getrusage (RUSAGE_CHILDREN, &r2);
263 
264 	  pt.user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
265 	  pt.user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
266 	  if (pt.user_microseconds < 0)
267 	    {
268 	      --pt.user_seconds;
269 	      pt.user_microseconds += 1000000;
270 	    }
271 
272 	  pt.system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
273 	  pt.system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
274 	  if (pt.system_microseconds < 0)
275 	    {
276 	      --pt.system_seconds;
277 	      pt.system_microseconds += 1000000;
278 	    }
279 	}
280 #endif
281 
282       if (cpid < 0 || cpid == pid)
283 	{
284 	  if (time != NULL)
285 	    *time = pt;
286 	  return cpid;
287 	}
288 
289       psl = XNEW (struct status_list);
290       psl->pid = cpid;
291       psl->status = *status;
292       if (time != NULL)
293 	psl->time = pt;
294       psl->next = (struct status_list *) obj->sysdep;
295       obj->sysdep = (void *) psl;
296     }
297 }
298 
299 #endif /* ! defined (HAVE_WAITPID) */
300 #endif /* ! defined (HAVE_WAIT4) */
301 
302 static void pex_child_error (struct pex_obj *, const char *, const char *, int)
303      ATTRIBUTE_NORETURN;
304 static int pex_unix_open_read (struct pex_obj *, const char *, int);
305 static int pex_unix_open_write (struct pex_obj *, const char *, int, int);
306 static pid_t pex_unix_exec_child (struct pex_obj *, int, const char *,
307 				 char * const *, char * const *,
308 				 int, int, int, int,
309 				 const char **, int *);
310 static int pex_unix_close (struct pex_obj *, int);
311 static int pex_unix_wait (struct pex_obj *, pid_t, int *, struct pex_time *,
312 			  int, const char **, int *);
313 static int pex_unix_pipe (struct pex_obj *, int *, int);
314 static FILE *pex_unix_fdopenr (struct pex_obj *, int, int);
315 static FILE *pex_unix_fdopenw (struct pex_obj *, int, int);
316 static void pex_unix_cleanup (struct pex_obj *);
317 
318 /* The list of functions we pass to the common routines.  */
319 
320 const struct pex_funcs funcs =
321 {
322   pex_unix_open_read,
323   pex_unix_open_write,
324   pex_unix_exec_child,
325   pex_unix_close,
326   pex_unix_wait,
327   pex_unix_pipe,
328   pex_unix_fdopenr,
329   pex_unix_fdopenw,
330   pex_unix_cleanup
331 };
332 
333 /* Return a newly initialized pex_obj structure.  */
334 
335 struct pex_obj *
pex_init(int flags,const char * pname,const char * tempbase)336 pex_init (int flags, const char *pname, const char *tempbase)
337 {
338   return pex_init_common (flags, pname, tempbase, &funcs);
339 }
340 
341 /* Open a file for reading.  */
342 
343 static int
pex_unix_open_read(struct pex_obj * obj ATTRIBUTE_UNUSED,const char * name,int binary ATTRIBUTE_UNUSED)344 pex_unix_open_read (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
345 		    int binary ATTRIBUTE_UNUSED)
346 {
347   return open (name, O_RDONLY);
348 }
349 
350 /* Open a file for writing.  */
351 
352 static int
pex_unix_open_write(struct pex_obj * obj ATTRIBUTE_UNUSED,const char * name,int binary ATTRIBUTE_UNUSED,int append)353 pex_unix_open_write (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
354 		     int binary ATTRIBUTE_UNUSED, int append)
355 {
356   /* Note that we can't use O_EXCL here because gcc may have already
357      created the temporary file via make_temp_file.  */
358   return open (name, O_WRONLY | O_CREAT
359 		     | (append ? O_APPEND : O_TRUNC), PUBLIC_MODE);
360 }
361 
362 /* Close a file.  */
363 
364 static int
pex_unix_close(struct pex_obj * obj ATTRIBUTE_UNUSED,int fd)365 pex_unix_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
366 {
367   return close (fd);
368 }
369 
370 /* Report an error from a child process.  We don't use stdio routines,
371    because we might be here due to a vfork call.  */
372 
373 static void
pex_child_error(struct pex_obj * obj,const char * executable,const char * errmsg,int err)374 pex_child_error (struct pex_obj *obj, const char *executable,
375 		 const char *errmsg, int err)
376 {
377   int retval = 0;
378 #define writeerr(s) retval |= (write (STDERR_FILE_NO, s, strlen (s)) < 0)
379   writeerr (obj->pname);
380   writeerr (": error trying to exec '");
381   writeerr (executable);
382   writeerr ("': ");
383   writeerr (errmsg);
384   writeerr (": ");
385   writeerr (xstrerror (err));
386   writeerr ("\n");
387 #undef writeerr
388   /* Exit with -2 if the error output failed, too.  */
389   _exit (retval == 0 ? -1 : -2);
390 }
391 
392 /* Execute a child.  */
393 
394 #if defined(HAVE_SPAWNVE) && defined(HAVE_SPAWNVPE)
395 /* Implementation of pex->exec_child using the Cygwin spawn operation.  */
396 
397 /* Subroutine of pex_unix_exec_child.  Move OLD_FD to a new file descriptor
398    to be stored in *PNEW_FD, save the flags in *PFLAGS, and arrange for the
399    saved copy to be close-on-exec.  Move CHILD_FD into OLD_FD.  If CHILD_FD
400    is -1, OLD_FD is to be closed.  Return -1 on error.  */
401 
402 static int
save_and_install_fd(int * pnew_fd,int * pflags,int old_fd,int child_fd)403 save_and_install_fd(int *pnew_fd, int *pflags, int old_fd, int child_fd)
404 {
405   int new_fd, flags;
406 
407   flags = fcntl (old_fd, F_GETFD);
408 
409   /* If we could not retrieve the flags, then OLD_FD was not open.  */
410   if (flags < 0)
411     {
412       new_fd = -1, flags = 0;
413       if (child_fd >= 0 && dup2 (child_fd, old_fd) < 0)
414 	return -1;
415     }
416   /* If we wish to close OLD_FD, just mark it CLOEXEC.  */
417   else if (child_fd == -1)
418     {
419       new_fd = old_fd;
420       if ((flags & FD_CLOEXEC) == 0 && fcntl (old_fd, F_SETFD, FD_CLOEXEC) < 0)
421 	return -1;
422     }
423   /* Otherwise we need to save a copy of OLD_FD before installing CHILD_FD.  */
424   else
425     {
426 #ifdef F_DUPFD_CLOEXEC
427       new_fd = fcntl (old_fd, F_DUPFD_CLOEXEC, 3);
428       if (new_fd < 0)
429 	return -1;
430 #else
431       /* Prefer F_DUPFD over dup in order to avoid getting a new fd
432 	 in the range 0-2, right where a new stderr fd might get put.  */
433       new_fd = fcntl (old_fd, F_DUPFD, 3);
434       if (new_fd < 0)
435 	return -1;
436       if (fcntl (new_fd, F_SETFD, FD_CLOEXEC) < 0)
437 	return -1;
438 #endif
439       if (dup2 (child_fd, old_fd) < 0)
440 	return -1;
441     }
442 
443   *pflags = flags;
444   if (pnew_fd)
445     *pnew_fd = new_fd;
446   else if (new_fd != old_fd)
447     abort ();
448 
449   return 0;
450 }
451 
452 /* Subroutine of pex_unix_exec_child.  Move SAVE_FD back to OLD_FD
453    restoring FLAGS.  If SAVE_FD < 0, OLD_FD is to be closed.  */
454 
455 static int
restore_fd(int old_fd,int save_fd,int flags)456 restore_fd(int old_fd, int save_fd, int flags)
457 {
458   /* For SAVE_FD < 0, all we have to do is restore the
459      "closed-ness" of the original.  */
460   if (save_fd < 0)
461     return close (old_fd);
462 
463   /* For SAVE_FD == OLD_FD, all we have to do is restore the
464      original setting of the CLOEXEC flag.  */
465   if (save_fd == old_fd)
466     {
467       if (flags & FD_CLOEXEC)
468 	return 0;
469       return fcntl (old_fd, F_SETFD, flags);
470     }
471 
472   /* Otherwise we have to move the descriptor back, restore the flags,
473      and close the saved copy.  */
474 #ifdef HAVE_DUP3
475   if (flags == FD_CLOEXEC)
476     {
477       if (dup3 (save_fd, old_fd, O_CLOEXEC) < 0)
478 	return -1;
479     }
480   else
481 #endif
482     {
483       if (dup2 (save_fd, old_fd) < 0)
484 	return -1;
485       if (flags != 0 && fcntl (old_fd, F_SETFD, flags) < 0)
486 	return -1;
487     }
488   return close (save_fd);
489 }
490 
491 static pid_t
pex_unix_exec_child(struct pex_obj * obj 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)492 pex_unix_exec_child (struct pex_obj *obj ATTRIBUTE_UNUSED,
493 		     int flags, const char *executable,
494 		     char * const * argv, char * const * env,
495                      int in, int out, int errdes, int toclose,
496 		     const char **errmsg, int *err)
497 {
498   int fl_in = 0, fl_out = 0, fl_err = 0, fl_tc = 0;
499   int save_in = -1, save_out = -1, save_err = -1;
500   int max, retries;
501   pid_t pid;
502 
503   if (flags & PEX_STDERR_TO_STDOUT)
504     errdes = out;
505 
506   /* We need the three standard file descriptors to be set up as for
507      the child before we perform the spawn.  The file descriptors for
508      the parent need to be moved and marked for close-on-exec.  */
509   if (in != STDIN_FILE_NO
510       && save_and_install_fd (&save_in, &fl_in, STDIN_FILE_NO, in) < 0)
511     goto error_dup2;
512   if (out != STDOUT_FILE_NO
513       && save_and_install_fd (&save_out, &fl_out, STDOUT_FILE_NO, out) < 0)
514     goto error_dup2;
515   if (errdes != STDERR_FILE_NO
516       && save_and_install_fd (&save_err, &fl_err, STDERR_FILE_NO, errdes) < 0)
517     goto error_dup2;
518   if (toclose >= 0
519       && save_and_install_fd (NULL, &fl_tc, toclose, -1) < 0)
520     goto error_dup2;
521 
522   /* Now that we've moved the file descriptors for the child into place,
523      close the originals.  Be careful not to close any of the standard
524      file descriptors that we just set up.  */
525   max = -1;
526   if (errdes >= 0)
527     max = STDERR_FILE_NO;
528   else if (out >= 0)
529     max = STDOUT_FILE_NO;
530   else if (in >= 0)
531     max = STDIN_FILE_NO;
532   if (in > max)
533     close (in);
534   if (out > max)
535     close (out);
536   if (errdes > max && errdes != out)
537     close (errdes);
538 
539   /* If we were not given an environment, use the global environment.  */
540   if (env == NULL)
541     env = environ;
542 
543   /* Launch the program.  If we get EAGAIN (normally out of pid's), try
544      again a few times with increasing backoff times.  */
545   retries = 0;
546   while (1)
547     {
548       typedef const char * const *cc_cp;
549 
550       if (flags & PEX_SEARCH)
551 	pid = spawnvpe (_P_NOWAITO, executable, (cc_cp)argv, (cc_cp)env);
552       else
553 	pid = spawnve (_P_NOWAITO, executable, (cc_cp)argv, (cc_cp)env);
554 
555       if (pid > 0)
556 	break;
557 
558       *err = errno;
559       *errmsg = "spawn";
560       if (errno != EAGAIN || ++retries == 4)
561 	return (pid_t) -1;
562       sleep (1 << retries);
563     }
564 
565   /* Success.  Restore the parent's file descriptors that we saved above.  */
566   if (toclose >= 0
567       && restore_fd (toclose, toclose, fl_tc) < 0)
568     goto error_dup2;
569   if (in != STDIN_FILE_NO
570       && restore_fd (STDIN_FILE_NO, save_in, fl_in) < 0)
571     goto error_dup2;
572   if (out != STDOUT_FILE_NO
573       && restore_fd (STDOUT_FILE_NO, save_out, fl_out) < 0)
574     goto error_dup2;
575   if (errdes != STDERR_FILE_NO
576       && restore_fd (STDERR_FILE_NO, save_err, fl_err) < 0)
577     goto error_dup2;
578 
579   return pid;
580 
581  error_dup2:
582   *err = errno;
583   *errmsg = "dup2";
584   return (pid_t) -1;
585 }
586 
587 #else
588 /* Implementation of pex->exec_child using standard vfork + exec.  */
589 
590 static pid_t
pex_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)591 pex_unix_exec_child (struct pex_obj *obj, int flags, const char *executable,
592 		     char * const * argv, char * const * env,
593                      int in, int out, int errdes,
594 		     int toclose, const char **errmsg, int *err)
595 {
596   pid_t pid;
597 
598   /* We declare these to be volatile to avoid warnings from gcc about
599      them being clobbered by vfork.  */
600   volatile int sleep_interval;
601   volatile int retries;
602 
603   /* We vfork and then set environ in the child before calling execvp.
604      This clobbers the parent's environ so we need to restore it.
605      It would be nice to use one of the exec* functions that takes an
606      environment as a parameter, but that may have portability issues.  */
607   char **save_environ = environ;
608 
609   sleep_interval = 1;
610   pid = -1;
611   for (retries = 0; retries < 4; ++retries)
612     {
613       pid = vfork ();
614       if (pid >= 0)
615 	break;
616       sleep (sleep_interval);
617       sleep_interval *= 2;
618     }
619 
620   switch (pid)
621     {
622     case -1:
623       *err = errno;
624       *errmsg = VFORK_STRING;
625       return (pid_t) -1;
626 
627     case 0:
628       /* Child process.  */
629       if (in != STDIN_FILE_NO)
630 	{
631 	  if (dup2 (in, STDIN_FILE_NO) < 0)
632 	    pex_child_error (obj, executable, "dup2", errno);
633 	  if (close (in) < 0)
634 	    pex_child_error (obj, executable, "close", errno);
635 	}
636       if (out != STDOUT_FILE_NO)
637 	{
638 	  if (dup2 (out, STDOUT_FILE_NO) < 0)
639 	    pex_child_error (obj, executable, "dup2", errno);
640 	  if (close (out) < 0)
641 	    pex_child_error (obj, executable, "close", errno);
642 	}
643       if (errdes != STDERR_FILE_NO)
644 	{
645 	  if (dup2 (errdes, STDERR_FILE_NO) < 0)
646 	    pex_child_error (obj, executable, "dup2", errno);
647 	  if (close (errdes) < 0)
648 	    pex_child_error (obj, executable, "close", errno);
649 	}
650       if (toclose >= 0)
651 	{
652 	  if (close (toclose) < 0)
653 	    pex_child_error (obj, executable, "close", errno);
654 	}
655       if ((flags & PEX_STDERR_TO_STDOUT) != 0)
656 	{
657 	  if (dup2 (STDOUT_FILE_NO, STDERR_FILE_NO) < 0)
658 	    pex_child_error (obj, executable, "dup2", errno);
659 	}
660 
661       if (env)
662 	{
663 	  /* NOTE: In a standard vfork implementation this clobbers the
664 	     parent's copy of environ "too" (in reality there's only one copy).
665 	     This is ok as we restore it below.  */
666 	  environ = (char**) env;
667 	}
668 
669       if ((flags & PEX_SEARCH) != 0)
670 	{
671 	  execvp (executable, to_ptr32 (argv));
672 	  pex_child_error (obj, executable, "execvp", errno);
673 	}
674       else
675 	{
676 	  execv (executable, to_ptr32 (argv));
677 	  pex_child_error (obj, executable, "execv", errno);
678 	}
679 
680       /* NOTREACHED */
681       return (pid_t) -1;
682 
683     default:
684       /* Parent process.  */
685 
686       /* Restore environ.
687 	 Note that the parent either doesn't run until the child execs/exits
688 	 (standard vfork behaviour), or if it does run then vfork is behaving
689 	 more like fork.  In either case we needn't worry about clobbering
690 	 the child's copy of environ.  */
691       environ = save_environ;
692 
693       if (in != STDIN_FILE_NO)
694 	{
695 	  if (close (in) < 0)
696 	    {
697 	      *err = errno;
698 	      *errmsg = "close";
699 	      return (pid_t) -1;
700 	    }
701 	}
702       if (out != STDOUT_FILE_NO)
703 	{
704 	  if (close (out) < 0)
705 	    {
706 	      *err = errno;
707 	      *errmsg = "close";
708 	      return (pid_t) -1;
709 	    }
710 	}
711       if (errdes != STDERR_FILE_NO)
712 	{
713 	  if (close (errdes) < 0)
714 	    {
715 	      *err = errno;
716 	      *errmsg = "close";
717 	      return (pid_t) -1;
718 	    }
719 	}
720 
721       return pid;
722     }
723 }
724 #endif /* SPAWN */
725 
726 /* Wait for a child process to complete.  */
727 
728 static int
pex_unix_wait(struct pex_obj * obj,pid_t pid,int * status,struct pex_time * time,int done,const char ** errmsg,int * err)729 pex_unix_wait (struct pex_obj *obj, pid_t pid, int *status,
730 	       struct pex_time *time, int done, const char **errmsg,
731 	       int *err)
732 {
733   /* If we are cleaning up when the caller didn't retrieve process
734      status for some reason, encourage the process to go away.  */
735   if (done)
736     kill (pid, SIGTERM);
737 
738   if (pex_wait (obj, pid, status, time) < 0)
739     {
740       *err = errno;
741       *errmsg = "wait";
742       return -1;
743     }
744 
745   return 0;
746 }
747 
748 /* Create a pipe.  */
749 
750 static int
pex_unix_pipe(struct pex_obj * obj ATTRIBUTE_UNUSED,int * p,int binary ATTRIBUTE_UNUSED)751 pex_unix_pipe (struct pex_obj *obj ATTRIBUTE_UNUSED, int *p,
752 	       int binary ATTRIBUTE_UNUSED)
753 {
754   return pipe (p);
755 }
756 
757 /* Get a FILE pointer to read from a file descriptor.  */
758 
759 static FILE *
pex_unix_fdopenr(struct pex_obj * obj ATTRIBUTE_UNUSED,int fd,int binary ATTRIBUTE_UNUSED)760 pex_unix_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
761 		  int binary ATTRIBUTE_UNUSED)
762 {
763   return fdopen (fd, "r");
764 }
765 
766 static FILE *
pex_unix_fdopenw(struct pex_obj * obj ATTRIBUTE_UNUSED,int fd,int binary ATTRIBUTE_UNUSED)767 pex_unix_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
768 		  int binary ATTRIBUTE_UNUSED)
769 {
770   if (fcntl (fd, F_SETFD, FD_CLOEXEC) < 0)
771     return NULL;
772   return fdopen (fd, "w");
773 }
774 
775 static void
pex_unix_cleanup(struct pex_obj * obj ATTRIBUTE_UNUSED)776 pex_unix_cleanup (struct pex_obj *obj ATTRIBUTE_UNUSED)
777 {
778 #if !defined (HAVE_WAIT4) && !defined (HAVE_WAITPID)
779   while (obj->sysdep != NULL)
780     {
781       struct status_list *this;
782       struct status_list *next;
783 
784       this = (struct status_list *) obj->sysdep;
785       next = this->next;
786       free (this);
787       obj->sysdep = (void *) next;
788     }
789 #endif
790 }
791