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 } 789