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