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-2023 Free Software Foundation, Inc.
5
6 This file is part of the libiberty library.
7 Libiberty is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Library General Public
9 License as published by the Free Software Foundation; either
10 version 2 of the License, or (at your option) any later version.
11
12 Libiberty is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Library General Public License for more details.
16
17 You should have received a copy of the GNU Library General Public
18 License along with libiberty; see the file COPYING.LIB. If not,
19 write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
20 Boston, MA 02110-1301, USA. */
21
22 #include "config.h"
23 #include "libiberty.h"
24 #include "pex-common.h"
25 #include "environ.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 /* Count number of arguments. */
89 for (argc = 0; ptr64[argc] != NULL; argc++)
90 ;
91
92 /* Reallocate argv with 32 bit pointers. */
93 short_argv = (__char_ptr_char_ptr32) decc$malloc
94 (sizeof (__char_ptr32) * (argc + 1));
95
96 for (argc = 0; ptr64[argc] != NULL; argc++)
97 short_argv[argc] = (__char_ptr32) decc$strdup (ptr64[argc]);
98
99 short_argv[argc] = (__char_ptr32) 0;
100 return short_argv;
101
102 }
103 #else
104 #define to_ptr32(argv) argv
105 #endif
106
107 /* File mode to use for private and world-readable files. */
108
109 #if defined (S_IRUSR) && defined (S_IWUSR) && defined (S_IRGRP) && defined (S_IWGRP) && defined (S_IROTH) && defined (S_IWOTH)
110 #define PUBLIC_MODE \
111 (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
112 #else
113 #define PUBLIC_MODE 0666
114 #endif
115
116 /* Get the exit status of a particular process, and optionally get the
117 time that it took. This is simple if we have wait4, slightly
118 harder if we have waitpid, and is a pain if we only have wait. */
119
120 static pid_t pex_wait (struct pex_obj *, pid_t, int *, struct pex_time *);
121
122 #ifdef HAVE_WAIT4
123
124 static pid_t
125 pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
126 struct pex_time *time)
127 {
128 pid_t ret;
129 struct rusage r;
130
131 #ifdef HAVE_WAITPID
132 if (time == NULL)
133 return waitpid (pid, status, 0);
134 #endif
135
136 ret = wait4 (pid, status, 0, &r);
137
138 if (time != NULL)
139 {
140 time->user_seconds = r.ru_utime.tv_sec;
141 time->user_microseconds= r.ru_utime.tv_usec;
142 time->system_seconds = r.ru_stime.tv_sec;
143 time->system_microseconds= r.ru_stime.tv_usec;
144 }
145
146 return ret;
147 }
148
149 #else /* ! defined (HAVE_WAIT4) */
150
151 #ifdef HAVE_WAITPID
152
153 #ifndef HAVE_GETRUSAGE
154
155 static pid_t
156 pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
157 struct pex_time *time)
158 {
159 if (time != NULL)
160 memset (time, 0, sizeof (struct pex_time));
161 return waitpid (pid, status, 0);
162 }
163
164 #else /* defined (HAVE_GETRUSAGE) */
165
166 static pid_t
167 pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
168 struct pex_time *time)
169 {
170 struct rusage r1, r2;
171 pid_t ret;
172
173 if (time == NULL)
174 return waitpid (pid, status, 0);
175
176 getrusage (RUSAGE_CHILDREN, &r1);
177
178 ret = waitpid (pid, status, 0);
179 if (ret < 0)
180 return ret;
181
182 getrusage (RUSAGE_CHILDREN, &r2);
183
184 time->user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
185 time->user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
186 if (r2.ru_utime.tv_usec < r1.ru_utime.tv_usec)
187 {
188 --time->user_seconds;
189 time->user_microseconds += 1000000;
190 }
191
192 time->system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
193 time->system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
194 if (r2.ru_stime.tv_usec < r1.ru_stime.tv_usec)
195 {
196 --time->system_seconds;
197 time->system_microseconds += 1000000;
198 }
199
200 return ret;
201 }
202
203 #endif /* defined (HAVE_GETRUSAGE) */
204
205 #else /* ! defined (HAVE_WAITPID) */
206
207 struct status_list
208 {
209 struct status_list *next;
210 pid_t pid;
211 int status;
212 struct pex_time time;
213 };
214
215 static pid_t
216 pex_wait (struct pex_obj *obj, pid_t pid, int *status, struct pex_time *time)
217 {
218 struct status_list **pp;
219
220 for (pp = (struct status_list **) &obj->sysdep;
221 *pp != NULL;
222 pp = &(*pp)->next)
223 {
224 if ((*pp)->pid == pid)
225 {
226 struct status_list *p;
227
228 p = *pp;
229 *status = p->status;
230 if (time != NULL)
231 *time = p->time;
232 *pp = p->next;
233 free (p);
234 return pid;
235 }
236 }
237
238 while (1)
239 {
240 pid_t cpid;
241 struct status_list *psl;
242 struct pex_time pt;
243 #ifdef HAVE_GETRUSAGE
244 struct rusage r1, r2;
245 #endif
246
247 if (time != NULL)
248 {
249 #ifdef HAVE_GETRUSAGE
250 getrusage (RUSAGE_CHILDREN, &r1);
251 #else
252 memset (&pt, 0, sizeof (struct pex_time));
253 #endif
254 }
255
256 cpid = wait (status);
257
258 #ifdef HAVE_GETRUSAGE
259 if (time != NULL && cpid >= 0)
260 {
261 getrusage (RUSAGE_CHILDREN, &r2);
262
263 pt.user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
264 pt.user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
265 if (pt.user_microseconds < 0)
266 {
267 --pt.user_seconds;
268 pt.user_microseconds += 1000000;
269 }
270
271 pt.system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
272 pt.system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
273 if (pt.system_microseconds < 0)
274 {
275 --pt.system_seconds;
276 pt.system_microseconds += 1000000;
277 }
278 }
279 #endif
280
281 if (cpid < 0 || cpid == pid)
282 {
283 if (time != NULL)
284 *time = pt;
285 return cpid;
286 }
287
288 psl = XNEW (struct status_list);
289 psl->pid = cpid;
290 psl->status = *status;
291 if (time != NULL)
292 psl->time = pt;
293 psl->next = (struct status_list *) obj->sysdep;
294 obj->sysdep = (void *) psl;
295 }
296 }
297
298 #endif /* ! defined (HAVE_WAITPID) */
299 #endif /* ! defined (HAVE_WAIT4) */
300
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, 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, int append)
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
356 | (append ? O_APPEND : O_TRUNC), PUBLIC_MODE);
357 }
358
359 /* Close a file. */
360
361 static int
362 pex_unix_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
363 {
364 return close (fd);
365 }
366
367 /* Execute a child. */
368
369 #if defined(HAVE_SPAWNVE) && defined(HAVE_SPAWNVPE)
370 /* Implementation of pex->exec_child using the Cygwin spawn operation. */
371
372 /* Subroutine of pex_unix_exec_child. Move OLD_FD to a new file descriptor
373 to be stored in *PNEW_FD, save the flags in *PFLAGS, and arrange for the
374 saved copy to be close-on-exec. Move CHILD_FD into OLD_FD. If CHILD_FD
375 is -1, OLD_FD is to be closed. Return -1 on error. */
376
377 static int
378 save_and_install_fd(int *pnew_fd, int *pflags, int old_fd, int child_fd)
379 {
380 int new_fd, flags;
381
382 flags = fcntl (old_fd, F_GETFD);
383
384 /* If we could not retrieve the flags, then OLD_FD was not open. */
385 if (flags < 0)
386 {
387 new_fd = -1, flags = 0;
388 if (child_fd >= 0 && dup2 (child_fd, old_fd) < 0)
389 return -1;
390 }
391 /* If we wish to close OLD_FD, just mark it CLOEXEC. */
392 else if (child_fd == -1)
393 {
394 new_fd = old_fd;
395 if ((flags & FD_CLOEXEC) == 0 && fcntl (old_fd, F_SETFD, FD_CLOEXEC) < 0)
396 return -1;
397 }
398 /* Otherwise we need to save a copy of OLD_FD before installing CHILD_FD. */
399 else
400 {
401 #ifdef F_DUPFD_CLOEXEC
402 new_fd = fcntl (old_fd, F_DUPFD_CLOEXEC, 3);
403 if (new_fd < 0)
404 return -1;
405 #else
406 /* Prefer F_DUPFD over dup in order to avoid getting a new fd
407 in the range 0-2, right where a new stderr fd might get put. */
408 new_fd = fcntl (old_fd, F_DUPFD, 3);
409 if (new_fd < 0)
410 return -1;
411 if (fcntl (new_fd, F_SETFD, FD_CLOEXEC) < 0)
412 return -1;
413 #endif
414 if (dup2 (child_fd, old_fd) < 0)
415 return -1;
416 }
417
418 *pflags = flags;
419 if (pnew_fd)
420 *pnew_fd = new_fd;
421 else if (new_fd != old_fd)
422 abort ();
423
424 return 0;
425 }
426
427 /* Subroutine of pex_unix_exec_child. Move SAVE_FD back to OLD_FD
428 restoring FLAGS. If SAVE_FD < 0, OLD_FD is to be closed. */
429
430 static int
431 restore_fd(int old_fd, int save_fd, int flags)
432 {
433 /* For SAVE_FD < 0, all we have to do is restore the
434 "closed-ness" of the original. */
435 if (save_fd < 0)
436 return close (old_fd);
437
438 /* For SAVE_FD == OLD_FD, all we have to do is restore the
439 original setting of the CLOEXEC flag. */
440 if (save_fd == old_fd)
441 {
442 if (flags & FD_CLOEXEC)
443 return 0;
444 return fcntl (old_fd, F_SETFD, flags);
445 }
446
447 /* Otherwise we have to move the descriptor back, restore the flags,
448 and close the saved copy. */
449 #ifdef HAVE_DUP3
450 if (flags == FD_CLOEXEC)
451 {
452 if (dup3 (save_fd, old_fd, O_CLOEXEC) < 0)
453 return -1;
454 }
455 else
456 #endif
457 {
458 if (dup2 (save_fd, old_fd) < 0)
459 return -1;
460 if (flags != 0 && fcntl (old_fd, F_SETFD, flags) < 0)
461 return -1;
462 }
463 return close (save_fd);
464 }
465
466 static pid_t
467 pex_unix_exec_child (struct pex_obj *obj ATTRIBUTE_UNUSED,
468 int flags, const char *executable,
469 char * const * argv, char * const * env,
470 int in, int out, int errdes, int toclose,
471 const char **errmsg, int *err)
472 {
473 int fl_in = 0, fl_out = 0, fl_err = 0, fl_tc = 0;
474 int save_in = -1, save_out = -1, save_err = -1;
475 int max, retries;
476 pid_t pid;
477
478 if (flags & PEX_STDERR_TO_STDOUT)
479 errdes = out;
480
481 /* We need the three standard file descriptors to be set up as for
482 the child before we perform the spawn. The file descriptors for
483 the parent need to be moved and marked for close-on-exec. */
484 if (in != STDIN_FILE_NO
485 && save_and_install_fd (&save_in, &fl_in, STDIN_FILE_NO, in) < 0)
486 goto error_dup2;
487 if (out != STDOUT_FILE_NO
488 && save_and_install_fd (&save_out, &fl_out, STDOUT_FILE_NO, out) < 0)
489 goto error_dup2;
490 if (errdes != STDERR_FILE_NO
491 && save_and_install_fd (&save_err, &fl_err, STDERR_FILE_NO, errdes) < 0)
492 goto error_dup2;
493 if (toclose >= 0
494 && save_and_install_fd (NULL, &fl_tc, toclose, -1) < 0)
495 goto error_dup2;
496
497 /* Now that we've moved the file descriptors for the child into place,
498 close the originals. Be careful not to close any of the standard
499 file descriptors that we just set up. */
500 max = -1;
501 if (errdes >= 0)
502 max = STDERR_FILE_NO;
503 else if (out >= 0)
504 max = STDOUT_FILE_NO;
505 else if (in >= 0)
506 max = STDIN_FILE_NO;
507 if (in > max)
508 close (in);
509 if (out > max)
510 close (out);
511 if (errdes > max && errdes != out)
512 close (errdes);
513
514 /* If we were not given an environment, use the global environment. */
515 if (env == NULL)
516 env = environ;
517
518 /* Launch the program. If we get EAGAIN (normally out of pid's), try
519 again a few times with increasing backoff times. */
520 retries = 0;
521 while (1)
522 {
523 typedef const char * const *cc_cp;
524
525 if (flags & PEX_SEARCH)
526 pid = spawnvpe (_P_NOWAITO, executable, (cc_cp)argv, (cc_cp)env);
527 else
528 pid = spawnve (_P_NOWAITO, executable, (cc_cp)argv, (cc_cp)env);
529
530 if (pid > 0)
531 break;
532
533 *err = errno;
534 *errmsg = "spawn";
535 if (errno != EAGAIN || ++retries == 4)
536 return (pid_t) -1;
537 sleep (1 << retries);
538 }
539
540 /* Success. Restore the parent's file descriptors that we saved above. */
541 if (toclose >= 0
542 && restore_fd (toclose, toclose, fl_tc) < 0)
543 goto error_dup2;
544 if (in != STDIN_FILE_NO
545 && restore_fd (STDIN_FILE_NO, save_in, fl_in) < 0)
546 goto error_dup2;
547 if (out != STDOUT_FILE_NO
548 && restore_fd (STDOUT_FILE_NO, save_out, fl_out) < 0)
549 goto error_dup2;
550 if (errdes != STDERR_FILE_NO
551 && restore_fd (STDERR_FILE_NO, save_err, fl_err) < 0)
552 goto error_dup2;
553
554 return pid;
555
556 error_dup2:
557 *err = errno;
558 *errmsg = "dup2";
559 return (pid_t) -1;
560 }
561
562 #else
563 /* Implementation of pex->exec_child using standard vfork + exec. */
564
565 static pid_t
566 pex_unix_exec_child (struct pex_obj *obj, int flags, const char *executable,
567 char * const * argv, char * const * env,
568 int in, int out, int errdes,
569 int toclose, const char **errmsg, int *err)
570 {
571 pid_t pid = -1;
572 /* Tuple to communicate error from child to parent. We can safely
573 transfer string literal pointers as both run with identical
574 address mappings. */
575 struct fn_err
576 {
577 const char *fn;
578 int err;
579 };
580 volatile int do_pipe = 0;
581 volatile int pipes[2]; /* [0]:reader,[1]:writer. */
582 #ifdef O_CLOEXEC
583 do_pipe = 1;
584 #endif
585 if (do_pipe)
586 {
587 #ifdef HAVE_PIPE2
588 if (pipe2 ((int *)pipes, O_CLOEXEC))
589 do_pipe = 0;
590 #else
591 if (pipe ((int *)pipes))
592 do_pipe = 0;
593 else
594 {
595 if (fcntl (pipes[1], F_SETFD, FD_CLOEXEC) == -1)
596 {
597 close (pipes[0]);
598 close (pipes[1]);
599 do_pipe = 0;
600 }
601 }
602 #endif
603 }
604
605 /* We declare these to be volatile to avoid warnings from gcc about
606 them being clobbered by vfork. */
607 volatile int sleep_interval = 1;
608 volatile int retries;
609
610 /* We vfork and then set environ in the child before calling execvp.
611 This clobbers the parent's environ so we need to restore it.
612 It would be nice to use one of the exec* functions that takes an
613 environment as a parameter, but that may have portability
614 issues. It is marked volatile so the child doesn't consider it a
615 dead variable and therefore clobber where ever it is stored. */
616 char **volatile save_environ = environ;
617
618 for (retries = 0; retries < 4; ++retries)
619 {
620 pid = vfork ();
621 if (pid >= 0)
622 break;
623 sleep (sleep_interval);
624 sleep_interval *= 2;
625 }
626
627 switch (pid)
628 {
629 case -1:
630 if (do_pipe)
631 {
632 close (pipes[0]);
633 close (pipes[1]);
634 }
635 *err = errno;
636 *errmsg = VFORK_STRING;
637 return (pid_t) -1;
638
639 case 0:
640 /* Child process. */
641 {
642 struct fn_err failed;
643 failed.fn = NULL;
644
645 if (do_pipe)
646 close (pipes[0]);
647 if (!failed.fn && in != STDIN_FILE_NO)
648 {
649 if (dup2 (in, STDIN_FILE_NO) < 0)
650 failed.fn = "dup2", failed.err = errno;
651 else if (close (in) < 0)
652 failed.fn = "close", failed.err = errno;
653 }
654 if (!failed.fn && out != STDOUT_FILE_NO)
655 {
656 if (dup2 (out, STDOUT_FILE_NO) < 0)
657 failed.fn = "dup2", failed.err = errno;
658 else if (close (out) < 0)
659 failed.fn = "close", failed.err = errno;
660 }
661 if (!failed.fn && errdes != STDERR_FILE_NO)
662 {
663 if (dup2 (errdes, STDERR_FILE_NO) < 0)
664 failed.fn = "dup2", failed.err = errno;
665 else if (close (errdes) < 0)
666 failed.fn = "close", failed.err = errno;
667 }
668 if (!failed.fn && toclose >= 0)
669 {
670 if (close (toclose) < 0)
671 failed.fn = "close", failed.err = errno;
672 }
673 if (!failed.fn && (flags & PEX_STDERR_TO_STDOUT) != 0)
674 {
675 if (dup2 (STDOUT_FILE_NO, STDERR_FILE_NO) < 0)
676 failed.fn = "dup2", failed.err = errno;
677 }
678 if (!failed.fn)
679 {
680 if (env)
681 /* NOTE: In a standard vfork implementation this clobbers
682 the parent's copy of environ "too" (in reality there's
683 only one copy). This is ok as we restore it below. */
684 environ = (char**) env;
685 if ((flags & PEX_SEARCH) != 0)
686 {
687 execvp (executable, to_ptr32 (argv));
688 failed.fn = "execvp", failed.err = errno;
689 }
690 else
691 {
692 execv (executable, to_ptr32 (argv));
693 failed.fn = "execv", failed.err = errno;
694 }
695 }
696
697 /* Something failed, report an error. We don't use stdio
698 routines, because we might be here due to a vfork call. */
699 ssize_t retval = 0;
700
701 if (!do_pipe
702 || write (pipes[1], &failed, sizeof (failed)) != sizeof (failed))
703 {
704 /* The parent will not see our scream above, so write to
705 stdout. */
706 #define writeerr(s) (retval |= write (STDERR_FILE_NO, s, strlen (s)))
707 writeerr (obj->pname);
708 writeerr (": error trying to exec '");
709 writeerr (executable);
710 writeerr ("': ");
711 writeerr (failed.fn);
712 writeerr (": ");
713 writeerr (xstrerror (failed.err));
714 writeerr ("\n");
715 #undef writeerr
716 }
717
718 /* Exit with -2 if the error output failed, too. */
719 _exit (retval < 0 ? -2 : -1);
720 }
721 /* NOTREACHED */
722 return (pid_t) -1;
723
724 default:
725 /* Parent process. */
726 {
727 /* Restore environ. Note that the parent either doesn't run
728 until the child execs/exits (standard vfork behaviour), or
729 if it does run then vfork is behaving more like fork. In
730 either case we needn't worry about clobbering the child's
731 copy of environ. */
732 environ = save_environ;
733
734 struct fn_err failed;
735 failed.fn = NULL;
736 if (do_pipe)
737 {
738 close (pipes[1]);
739 ssize_t len = read (pipes[0], &failed, sizeof (failed));
740 if (len < 0)
741 failed.fn = NULL;
742 close (pipes[0]);
743 }
744
745 if (!failed.fn && in != STDIN_FILE_NO)
746 if (close (in) < 0)
747 failed.fn = "close", failed.err = errno;
748 if (!failed.fn && out != STDOUT_FILE_NO)
749 if (close (out) < 0)
750 failed.fn = "close", failed.err = errno;
751 if (!failed.fn && errdes != STDERR_FILE_NO)
752 if (close (errdes) < 0)
753 failed.fn = "close", failed.err = errno;
754
755 if (failed.fn)
756 {
757 *err = failed.err;
758 *errmsg = failed.fn;
759 return (pid_t) -1;
760 }
761 }
762 return pid;
763 }
764 }
765 #endif /* SPAWN */
766
767 /* Wait for a child process to complete. */
768
769 static int
770 pex_unix_wait (struct pex_obj *obj, pid_t pid, int *status,
771 struct pex_time *time, int done, const char **errmsg,
772 int *err)
773 {
774 /* If we are cleaning up when the caller didn't retrieve process
775 status for some reason, encourage the process to go away. */
776 if (done)
777 kill (pid, SIGTERM);
778
779 if (pex_wait (obj, pid, status, time) < 0)
780 {
781 *err = errno;
782 *errmsg = "wait";
783 return -1;
784 }
785
786 return 0;
787 }
788
789 /* Create a pipe. */
790
791 static int
792 pex_unix_pipe (struct pex_obj *obj ATTRIBUTE_UNUSED, int *p,
793 int binary ATTRIBUTE_UNUSED)
794 {
795 return pipe (p);
796 }
797
798 /* Get a FILE pointer to read from a file descriptor. */
799
800 static FILE *
801 pex_unix_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
802 int binary ATTRIBUTE_UNUSED)
803 {
804 return fdopen (fd, "r");
805 }
806
807 static FILE *
808 pex_unix_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
809 int binary ATTRIBUTE_UNUSED)
810 {
811 if (fcntl (fd, F_SETFD, FD_CLOEXEC) < 0)
812 return NULL;
813 return fdopen (fd, "w");
814 }
815
816 static void
817 pex_unix_cleanup (struct pex_obj *obj ATTRIBUTE_UNUSED)
818 {
819 #if !defined (HAVE_WAIT4) && !defined (HAVE_WAITPID)
820 while (obj->sysdep != NULL)
821 {
822 struct status_list *this;
823 struct status_list *next;
824
825 this = (struct status_list *) obj->sysdep;
826 next = this->next;
827 free (this);
828 obj->sysdep = (void *) next;
829 }
830 #endif
831 }