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-2024 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 #ifdef HAVE_SPAWN_H
  62 #include <spawn.h>
  63 #endif
  64
  65 #ifdef vfork /* Autoconf may define this to fork for us. */
  66 # define VFORK_STRING "fork"
  67 #else
  68 # define VFORK_STRING "vfork"
  69 #endif
  70 #ifdef HAVE_VFORK_H
  71 #include <vfork.h>
  72 #endif
  73 #if defined(VMS) && defined (__LONG_POINTERS)
  74 #ifndef __CHAR_PTR32
  75 typedef char * __char_ptr32
  76 __attribute__ ((mode (SI)));
  77 #endif
  78
  79 typedef __char_ptr32 *__char_ptr_char_ptr32
  80 __attribute__ ((mode (SI)));
  81
  82 /* Return a 32 bit pointer to an array of 32 bit pointers
  83    given a 64 bit pointer to an array of 64 bit pointers.  */
  84
  85 static __char_ptr_char_ptr32
  86 to_ptr32 (char **ptr64)
  87 {
  88   int argc;
  89   __char_ptr_char_ptr32 short_argv;
  90
  91   /* Count number of arguments.  */
  92   for (argc = 0; ptr64[argc] != NULL; argc++)
  93     ;
  94
  95   /* Reallocate argv with 32 bit pointers.  */
  96   short_argv = (__char_ptr_char_ptr32) decc$malloc
  97     (sizeof (__char_ptr32) * (argc + 1));
  98
  99   for (argc = 0; ptr64[argc] != NULL; argc++)
 100     short_argv[argc] = (__char_ptr32) decc$strdup (ptr64[argc]);
 101
 102   short_argv[argc] = (__char_ptr32) 0;
 103   return short_argv;
 104
 105 }
 106 #else
 107 #define to_ptr32(argv) argv
 108 #endif
 109
 110 /* File mode to use for private and world-readable files.  */
 111
 112 #if defined (S_IRUSR) && defined (S_IWUSR) && defined (S_IRGRP) && defined (S_IWGRP) && defined (S_IROTH) && defined (S_IWOTH)
 113 #define PUBLIC_MODE  \
 114     (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
 115 #else
 116 #define PUBLIC_MODE 0666
 117 #endif
 118
 119 /* Get the exit status of a particular process, and optionally get the
 120    time that it took.  This is simple if we have wait4, slightly
 121    harder if we have waitpid, and is a pain if we only have wait.  */
 122
 123 static pid_t pex_wait (struct pex_obj *, pid_t, int *, struct pex_time *);
 124
 125 #ifdef HAVE_WAIT4
 126
 127 static pid_t
 128 pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
 129           struct pex_time *time)
 130 {
 131   pid_t ret;
 132   struct rusage r;
 133
 134 #ifdef HAVE_WAITPID
 135   if (time == NULL)
 136     return waitpid (pid, status, 0);
 137 #endif
 138
 139   ret = wait4 (pid, status, 0, &r);
 140
 141   if (time != NULL)
 142     {
 143       time->user_seconds = r.ru_utime.tv_sec;
 144       time->user_microseconds= r.ru_utime.tv_usec;
 145       time->system_seconds = r.ru_stime.tv_sec;
 146       time->system_microseconds= r.ru_stime.tv_usec;
 147     }
 148
 149   return ret;
 150 }
 151
 152 #else /* ! defined (HAVE_WAIT4) */
 153
 154 #ifdef HAVE_WAITPID
 155
 156 #ifndef HAVE_GETRUSAGE
 157
 158 static pid_t
 159 pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
 160           struct pex_time *time)
 161 {
 162   if (time != NULL)
 163     memset (time, 0, sizeof (struct pex_time));
 164   return waitpid (pid, status, 0);
 165 }
 166
 167 #else /* defined (HAVE_GETRUSAGE) */
 168
 169 static pid_t
 170 pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
 171           struct pex_time *time)
 172 {
 173   struct rusage r1, r2;
 174   pid_t ret;
 175
 176   if (time == NULL)
 177     return waitpid (pid, status, 0);
 178
 179   getrusage (RUSAGE_CHILDREN, &r1);
 180
 181   ret = waitpid (pid, status, 0);
 182   if (ret < 0)
 183     return ret;
 184
 185   getrusage (RUSAGE_CHILDREN, &r2);
 186
 187   time->user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
 188   time->user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
 189   if (r2.ru_utime.tv_usec < r1.ru_utime.tv_usec)
 190     {
 191       --time->user_seconds;
 192       time->user_microseconds += 1000000;
 193     }
 194
 195   time->system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
 196   time->system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
 197   if (r2.ru_stime.tv_usec < r1.ru_stime.tv_usec)
 198     {
 199       --time->system_seconds;
 200       time->system_microseconds += 1000000;
 201     }
 202
 203   return ret;
 204 }
 205
 206 #endif /* defined (HAVE_GETRUSAGE) */
 207
 208 #else /* ! defined (HAVE_WAITPID) */
 209
 210 struct status_list
 211 {
 212   struct status_list *next;
 213   pid_t pid;
 214   int status;
 215   struct pex_time time;
 216 };
 217
 218 static pid_t
 219 pex_wait (struct pex_obj *obj, pid_t pid, int *status, struct pex_time *time)
 220 {
 221   struct status_list **pp;
 222
 223   for (pp = (struct status_list **) &obj->sysdep;
 224        *pp != NULL;
 225        pp = &(*pp)->next)
 226     {
 227       if ((*pp)->pid == pid)
 228         {
 229           struct status_list *p;
 230
 231           p = *pp;
 232           *status = p->status;
 233           if (time != NULL)
 234             *time = p->time;
 235           *pp = p->next;
 236           free (p);
 237           return pid;
 238         }
 239     }
 240
 241   while (1)
 242     {
 243       pid_t cpid;
 244       struct status_list *psl;
 245       struct pex_time pt;
 246 #ifdef HAVE_GETRUSAGE
 247       struct rusage r1, r2;
 248 #endif
 249
 250       if (time != NULL)
 251         {
 252 #ifdef HAVE_GETRUSAGE
 253           getrusage (RUSAGE_CHILDREN, &r1);
 254 #else
 255           memset (&pt, 0, sizeof (struct pex_time));
 256 #endif
 257         }
 258
 259       cpid = wait (status);
 260
 261 #ifdef HAVE_GETRUSAGE
 262       if (time != NULL && cpid >= 0)
 263         {
 264           getrusage (RUSAGE_CHILDREN, &r2);
 265
 266           pt.user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
 267           pt.user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
 268           if (pt.user_microseconds < 0)
 269             {
 270               --pt.user_seconds;
 271               pt.user_microseconds += 1000000;
 272             }
 273
 274           pt.system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
 275           pt.system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
 276           if (pt.system_microseconds < 0)
 277             {
 278               --pt.system_seconds;
 279               pt.system_microseconds += 1000000;
 280             }
 281         }
 282 #endif
 283
 284       if (cpid < 0 || cpid == pid)
 285         {
 286           if (time != NULL)
 287             *time = pt;
 288           return cpid;
 289         }
 290
 291       psl = XNEW (struct status_list);
 292       psl->pid = cpid;
 293       psl->status = *status;
 294       if (time != NULL)
 295         psl->time = pt;
 296       psl->next = (struct status_list *) obj->sysdep;
 297       obj->sysdep = (void *) psl;
 298     }
 299 }
 300
 301 #endif /* ! defined (HAVE_WAITPID) */
 302 #endif /* ! defined (HAVE_WAIT4) */
 303
 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 pid_t 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 *
 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
 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
 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
 365 pex_unix_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
 366 {
 367   return close (fd);
 368 }
 369
 370 /* Execute a child.  */
 371
 372 #if defined(HAVE_SPAWNVE) && defined(HAVE_SPAWNVPE)
 373 /* Implementation of pex->exec_child using the Cygwin spawn operation.  */
 374
 375 /* Subroutine of pex_unix_exec_child.  Move OLD_FD to a new file descriptor
 376    to be stored in *PNEW_FD, save the flags in *PFLAGS, and arrange for the
 377    saved copy to be close-on-exec.  Move CHILD_FD into OLD_FD.  If CHILD_FD
 378    is -1, OLD_FD is to be closed.  Return -1 on error.  */
 379
 380 static int
 381 save_and_install_fd(int *pnew_fd, int *pflags, int old_fd, int child_fd)
 382 {
 383   int new_fd, flags;
 384
 385   flags = fcntl (old_fd, F_GETFD);
 386
 387   /* If we could not retrieve the flags, then OLD_FD was not open.  */
 388   if (flags < 0)
 389     {
 390       new_fd = -1, flags = 0;
 391       if (child_fd >= 0 && dup2 (child_fd, old_fd) < 0)
 392         return -1;
 393     }
 394   /* If we wish to close OLD_FD, just mark it CLOEXEC.  */
 395   else if (child_fd == -1)
 396     {
 397       new_fd = old_fd;
 398       if ((flags & FD_CLOEXEC) == 0 && fcntl (old_fd, F_SETFD, FD_CLOEXEC) < 0)
 399         return -1;
 400     }
 401   /* Otherwise we need to save a copy of OLD_FD before installing CHILD_FD.  */
 402   else
 403     {
 404 #ifdef F_DUPFD_CLOEXEC
 405       new_fd = fcntl (old_fd, F_DUPFD_CLOEXEC, 3);
 406       if (new_fd < 0)
 407         return -1;
 408 #else
 409       /* Prefer F_DUPFD over dup in order to avoid getting a new fd
 410          in the range 0-2, right where a new stderr fd might get put.  */
 411       new_fd = fcntl (old_fd, F_DUPFD, 3);
 412       if (new_fd < 0)
 413         return -1;
 414       if (fcntl (new_fd, F_SETFD, FD_CLOEXEC) < 0)
 415         return -1;
 416 #endif
 417       if (dup2 (child_fd, old_fd) < 0)
 418         return -1;
 419     }
 420
 421   *pflags = flags;
 422   if (pnew_fd)
 423     *pnew_fd = new_fd;
 424   else if (new_fd != old_fd)
 425     abort ();
 426
 427   return 0;
 428 }
 429
 430 /* Subroutine of pex_unix_exec_child.  Move SAVE_FD back to OLD_FD
 431    restoring FLAGS.  If SAVE_FD < 0, OLD_FD is to be closed.  */
 432
 433 static int
 434 restore_fd(int old_fd, int save_fd, int flags)
 435 {
 436   /* For SAVE_FD < 0, all we have to do is restore the
 437      "closed-ness" of the original.  */
 438   if (save_fd < 0)
 439     return close (old_fd);
 440
 441   /* For SAVE_FD == OLD_FD, all we have to do is restore the
 442      original setting of the CLOEXEC flag.  */
 443   if (save_fd == old_fd)
 444     {
 445       if (flags & FD_CLOEXEC)
 446         return 0;
 447       return fcntl (old_fd, F_SETFD, flags);
 448     }
 449
 450   /* Otherwise we have to move the descriptor back, restore the flags,
 451      and close the saved copy.  */
 452 #ifdef HAVE_DUP3
 453   if (flags == FD_CLOEXEC)
 454     {
 455       if (dup3 (save_fd, old_fd, O_CLOEXEC) < 0)
 456         return -1;
 457     }
 458   else
 459 #endif
 460     {
 461       if (dup2 (save_fd, old_fd) < 0)
 462         return -1;
 463       if (flags != 0 && fcntl (old_fd, F_SETFD, flags) < 0)
 464         return -1;
 465     }
 466   return close (save_fd);
 467 }
 468
 469 static pid_t
 470 pex_unix_exec_child (struct pex_obj *obj ATTRIBUTE_UNUSED,
 471                      int flags, const char *executable,
 472                      char * const * argv, char * const * env,
 473                      int in, int out, int errdes, int toclose,
 474                      const char **errmsg, int *err)
 475 {
 476   int fl_in = 0, fl_out = 0, fl_err = 0, fl_tc = 0;
 477   int save_in = -1, save_out = -1, save_err = -1;
 478   int max, retries;
 479   pid_t pid;
 480
 481   if (flags & PEX_STDERR_TO_STDOUT)
 482     errdes = out;
 483
 484   /* We need the three standard file descriptors to be set up as for
 485      the child before we perform the spawn.  The file descriptors for
 486      the parent need to be moved and marked for close-on-exec.  */
 487   if (in != STDIN_FILE_NO
 488       && save_and_install_fd (&save_in, &fl_in, STDIN_FILE_NO, in) < 0)
 489     goto error_dup2;
 490   if (out != STDOUT_FILE_NO
 491       && save_and_install_fd (&save_out, &fl_out, STDOUT_FILE_NO, out) < 0)
 492     goto error_dup2;
 493   if (errdes != STDERR_FILE_NO
 494       && save_and_install_fd (&save_err, &fl_err, STDERR_FILE_NO, errdes) < 0)
 495     goto error_dup2;
 496   if (toclose >= 0
 497       && save_and_install_fd (NULL, &fl_tc, toclose, -1) < 0)
 498     goto error_dup2;
 499
 500   /* Now that we've moved the file descriptors for the child into place,
 501      close the originals.  Be careful not to close any of the standard
 502      file descriptors that we just set up.  */
 503   max = -1;
 504   if (errdes >= 0)
 505     max = STDERR_FILE_NO;
 506   else if (out >= 0)
 507     max = STDOUT_FILE_NO;
 508   else if (in >= 0)
 509     max = STDIN_FILE_NO;
 510   if (in > max)
 511     close (in);
 512   if (out > max)
 513     close (out);
 514   if (errdes > max && errdes != out)
 515     close (errdes);
 516
 517   /* If we were not given an environment, use the global environment.  */
 518   if (env == NULL)
 519     env = environ;
 520
 521   /* Launch the program.  If we get EAGAIN (normally out of pid's), try
 522      again a few times with increasing backoff times.  */
 523   retries = 0;
 524   while (1)
 525     {
 526       typedef const char * const *cc_cp;
 527
 528       if (flags & PEX_SEARCH)
 529         pid = spawnvpe (_P_NOWAITO, executable, (cc_cp)argv, (cc_cp)env);
 530       else
 531         pid = spawnve (_P_NOWAITO, executable, (cc_cp)argv, (cc_cp)env);
 532
 533       if (pid > 0)
 534         break;
 535
 536       *err = errno;
 537       *errmsg = "spawn";
 538       if (errno != EAGAIN || ++retries == 4)
 539         return (pid_t) -1;
 540       sleep (1 << retries);
 541     }
 542
 543   /* Success.  Restore the parent's file descriptors that we saved above.  */
 544   if (toclose >= 0
 545       && restore_fd (toclose, toclose, fl_tc) < 0)
 546     goto error_dup2;
 547   if (in != STDIN_FILE_NO
 548       && restore_fd (STDIN_FILE_NO, save_in, fl_in) < 0)
 549     goto error_dup2;
 550   if (out != STDOUT_FILE_NO
 551       && restore_fd (STDOUT_FILE_NO, save_out, fl_out) < 0)
 552     goto error_dup2;
 553   if (errdes != STDERR_FILE_NO
 554       && restore_fd (STDERR_FILE_NO, save_err, fl_err) < 0)
 555     goto error_dup2;
 556
 557   return pid;
 558
 559  error_dup2:
 560   *err = errno;
 561   *errmsg = "dup2";
 562   return (pid_t) -1;
 563 }
 564
 565 #elif defined(HAVE_POSIX_SPAWN) && defined(HAVE_POSIX_SPAWNP)
 566 /* Implementation of pex->exec_child using posix_spawn.            */
 567
 568 static pid_t
 569 pex_unix_exec_child (struct pex_obj *obj ATTRIBUTE_UNUSED,
 570                      int flags, const char *executable,
 571                      char * const * argv, char * const * env,
 572                      int in, int out, int errdes,
 573                      int toclose, const char **errmsg, int *err)
 574 {
 575   int ret;
 576   pid_t pid = -1;
 577   posix_spawnattr_t attr;
 578   posix_spawn_file_actions_t actions;
 579   int attr_initialized = 0, actions_initialized = 0;
 580
 581   *err = 0;
 582
 583   ret = posix_spawnattr_init (&attr);
 584   if (ret)
 585     {
 586       *err = ret;
 587       *errmsg = "posix_spawnattr_init";
 588       goto exit;
 589     }
 590   attr_initialized = 1;
 591
 592   /* Use vfork() on glibc <=2.24. */
 593 #ifdef POSIX_SPAWN_USEVFORK
 594   ret = posix_spawnattr_setflags (&attr, POSIX_SPAWN_USEVFORK);
 595   if (ret)
 596     {
 597       *err = ret;
 598       *errmsg = "posix_spawnattr_setflags";
 599       goto exit;
 600     }
 601 #endif
 602
 603   ret = posix_spawn_file_actions_init (&actions);
 604   if (ret)
 605     {
 606       *err = ret;
 607       *errmsg = "posix_spawn_file_actions_init";
 608       goto exit;
 609     }
 610   actions_initialized = 1;
 611
 612   if (in != STDIN_FILE_NO)
 613     {
 614       ret = posix_spawn_file_actions_adddup2 (&actions, in, STDIN_FILE_NO);
 615       if (ret)
 616         {
 617           *err = ret;
 618           *errmsg = "posix_spawn_file_actions_adddup2";
 619           goto exit;
 620         }
 621
 622       ret = posix_spawn_file_actions_addclose (&actions, in);
 623       if (ret)
 624         {
 625           *err = ret;
 626           *errmsg = "posix_spawn_file_actions_addclose";
 627           goto exit;
 628         }
 629     }
 630
 631   if (out != STDOUT_FILE_NO)
 632     {
 633       ret = posix_spawn_file_actions_adddup2 (&actions, out, STDOUT_FILE_NO);
 634       if (ret)
 635         {
 636           *err = ret;
 637           *errmsg = "posix_spawn_file_actions_adddup2";
 638           goto exit;
 639         }
 640
 641       ret = posix_spawn_file_actions_addclose (&actions, out);
 642       if (ret)
 643         {
 644           *err = ret;
 645           *errmsg = "posix_spawn_file_actions_addclose";
 646           goto exit;
 647         }
 648     }
 649
 650   if (errdes != STDERR_FILE_NO)
 651     {
 652       ret = posix_spawn_file_actions_adddup2 (&actions, errdes, STDERR_FILE_NO);
 653       if (ret)
 654         {
 655           *err = ret;
 656           *errmsg = "posix_spawn_file_actions_adddup2";
 657           goto exit;
 658         }
 659
 660       ret = posix_spawn_file_actions_addclose (&actions, errdes);
 661       if (ret)
 662         {
 663           *err = ret;
 664           *errmsg = "posix_spawn_file_actions_addclose";
 665           goto exit;
 666         }
 667     }
 668
 669   if (toclose >= 0)
 670     {
 671       ret = posix_spawn_file_actions_addclose (&actions, toclose);
 672       if (ret)
 673         {
 674           *err = ret;
 675           *errmsg = "posix_spawn_file_actions_addclose";
 676           goto exit;
 677         }
 678     }
 679
 680   if ((flags & PEX_STDERR_TO_STDOUT) != 0)
 681     {
 682       ret = posix_spawn_file_actions_adddup2 (&actions, STDOUT_FILE_NO, STDERR_FILE_NO);
 683       if (ret)
 684         {
 685           *err = ret;
 686           *errmsg = "posix_spawn_file_actions_adddup2";
 687           goto exit;
 688         }
 689     }
 690
 691   if ((flags & PEX_SEARCH) != 0)
 692     {
 693       ret = posix_spawnp (&pid, executable, &actions, &attr, argv, env ? env : environ);
 694       if (ret)
 695         {
 696           *err = ret;
 697           *errmsg = "posix_spawnp";
 698           goto exit;
 699         }
 700     }
 701   else
 702     {
 703       ret = posix_spawn (&pid, executable, &actions, &attr, argv, env ? env : environ);
 704       if (ret)
 705         {
 706           *err = ret;
 707           *errmsg = "posix_spawn";
 708           goto exit;
 709         }
 710     }
 711
 712 exit:
 713   if (actions_initialized)
 714     posix_spawn_file_actions_destroy (&actions);
 715   if (attr_initialized)
 716     posix_spawnattr_destroy (&attr);
 717
 718   if (!*err && in != STDIN_FILE_NO)
 719     if (close (in))
 720       *errmsg = "close", *err = errno, pid = -1;
 721   if (!*err && out != STDOUT_FILE_NO)
 722     if (close (out))
 723       *errmsg = "close", *err = errno, pid = -1;
 724   if (!*err && errdes != STDERR_FILE_NO)
 725     if (close (errdes))
 726       *errmsg = "close", *err = errno, pid = -1;
 727
 728   return pid;
 729 }
 730 #else
 731 /* Implementation of pex->exec_child using standard vfork + exec.  */
 732
 733 static pid_t
 734 pex_unix_exec_child (struct pex_obj *obj, int flags, const char *executable,
 735                      char * const * argv, char * const * env,
 736                      int in, int out, int errdes,
 737                      int toclose, const char **errmsg, int *err)
 738 {
 739   pid_t pid = -1;
 740   /* Tuple to communicate error from child to parent.  We can safely
 741      transfer string literal pointers as both run with identical
 742      address mappings.  */
 743   struct fn_err
 744   {
 745     const char *fn;
 746     int err;
 747   };
 748   volatile int do_pipe = 0;
 749   volatile int pipes[2]; /* [0]:reader,[1]:writer.  */
 750 #ifdef O_CLOEXEC
 751   do_pipe = 1;
 752 #endif
 753   if (do_pipe)
 754     {
 755 #ifdef HAVE_PIPE2
 756       if (pipe2 ((int *)pipes, O_CLOEXEC))
 757         do_pipe = 0;
 758 #else
 759       if (pipe ((int *)pipes))
 760         do_pipe = 0;
 761       else
 762         {
 763           if (fcntl (pipes[1], F_SETFD, FD_CLOEXEC) == -1)
 764             {
 765               close (pipes[0]);
 766               close (pipes[1]);
 767               do_pipe = 0;
 768             }
 769         }
 770 #endif
 771     }
 772
 773   /* We declare these to be volatile to avoid warnings from gcc about
 774      them being clobbered by vfork.  */
 775   volatile int sleep_interval = 1;
 776   volatile int retries;
 777
 778   /* We vfork and then set environ in the child before calling execvp.
 779      This clobbers the parent's environ so we need to restore it.
 780      It would be nice to use one of the exec* functions that takes an
 781      environment as a parameter, but that may have portability
 782      issues.  It is marked volatile so the child doesn't consider it a
 783      dead variable and therefore clobber where ever it is stored.  */
 784   char **volatile save_environ = environ;
 785
 786   for (retries = 0; retries < 4; ++retries)
 787     {
 788       pid = vfork ();
 789       if (pid >= 0)
 790         break;
 791       sleep (sleep_interval);
 792       sleep_interval *= 2;
 793     }
 794
 795   switch (pid)
 796     {
 797     case -1:
 798       if (do_pipe)
 799         {
 800           close (pipes[0]);
 801           close (pipes[1]);
 802         }
 803       *err = errno;
 804       *errmsg = VFORK_STRING;
 805       return (pid_t) -1;
 806
 807     case 0:
 808       /* Child process.  */
 809       {
 810         struct fn_err failed;
 811         failed.fn = NULL;
 812
 813         if (do_pipe)
 814           close (pipes[0]);
 815         if (!failed.fn && in != STDIN_FILE_NO)
 816           {
 817             if (dup2 (in, STDIN_FILE_NO) < 0)
 818               failed.fn = "dup2", failed.err = errno;
 819             else if (close (in) < 0)
 820               failed.fn = "close", failed.err = errno;
 821           }
 822         if (!failed.fn && out != STDOUT_FILE_NO)
 823           {
 824             if (dup2 (out, STDOUT_FILE_NO) < 0)
 825               failed.fn = "dup2", failed.err = errno;
 826             else if (close (out) < 0)
 827               failed.fn = "close", failed.err = errno;
 828           }
 829         if (!failed.fn && errdes != STDERR_FILE_NO)
 830           {
 831             if (dup2 (errdes, STDERR_FILE_NO) < 0)
 832               failed.fn = "dup2", failed.err = errno;
 833             else if (close (errdes) < 0)
 834               failed.fn = "close", failed.err = errno;
 835           }
 836         if (!failed.fn && toclose >= 0)
 837           {
 838             if (close (toclose) < 0)
 839               failed.fn = "close", failed.err = errno;
 840           }
 841         if (!failed.fn && (flags & PEX_STDERR_TO_STDOUT) != 0)
 842           {
 843             if (dup2 (STDOUT_FILE_NO, STDERR_FILE_NO) < 0)
 844               failed.fn = "dup2", failed.err = errno;
 845           }
 846         if (!failed.fn)
 847           {
 848             if (env)
 849               /* NOTE: In a standard vfork implementation this clobbers
 850                  the parent's copy of environ "too" (in reality there's
 851                  only one copy).  This is ok as we restore it below.  */
 852               environ = (char**) env;
 853             if ((flags & PEX_SEARCH) != 0)
 854               {
 855                 execvp (executable, to_ptr32 (argv));
 856                 failed.fn = "execvp", failed.err = errno;
 857               }
 858             else
 859               {
 860                 execv (executable, to_ptr32 (argv));
 861                 failed.fn = "execv", failed.err = errno;
 862               }
 863           }
 864
 865         /* Something failed, report an error.  We don't use stdio
 866            routines, because we might be here due to a vfork call.  */
 867         ssize_t retval = 0;
 868
 869         if (!do_pipe
 870             || write (pipes[1], &failed, sizeof (failed)) != sizeof (failed))
 871           {
 872             /* The parent will not see our scream above, so write to
 873                stdout.  */
 874 #define writeerr(s) (retval |= write (STDERR_FILE_NO, s, strlen (s)))
 875             writeerr (obj->pname);
 876             writeerr (": error trying to exec '");
 877             writeerr (executable);
 878             writeerr ("': ");
 879             writeerr (failed.fn);
 880             writeerr (": ");
 881             writeerr (xstrerror (failed.err));
 882             writeerr ("\n");
 883 #undef writeerr
 884           }
 885
 886         /* Exit with -2 if the error output failed, too.  */
 887         _exit (retval < 0 ? -2 : -1);
 888       }
 889       /* NOTREACHED */
 890       return (pid_t) -1;
 891
 892     default:
 893       /* Parent process.  */
 894       {
 895         /* Restore environ.  Note that the parent either doesn't run
 896            until the child execs/exits (standard vfork behaviour), or
 897            if it does run then vfork is behaving more like fork.  In
 898            either case we needn't worry about clobbering the child's
 899            copy of environ.  */
 900         environ = save_environ;
 901
 902         struct fn_err failed;
 903         failed.fn = NULL;
 904         if (do_pipe)
 905           {
 906             close (pipes[1]);
 907             ssize_t len = read (pipes[0], &failed, sizeof (failed));
 908             if (len < 0)
 909               failed.fn = NULL;
 910             close (pipes[0]);
 911           }
 912
 913         if (!failed.fn && in != STDIN_FILE_NO)
 914           if (close (in) < 0)
 915             failed.fn = "close", failed.err = errno;
 916         if (!failed.fn && out != STDOUT_FILE_NO)
 917           if (close (out) < 0)
 918             failed.fn = "close", failed.err = errno;
 919         if (!failed.fn && errdes != STDERR_FILE_NO)
 920           if (close (errdes) < 0)
 921             failed.fn = "close", failed.err = errno;
 922
 923         if (failed.fn)
 924           {
 925             *err = failed.err;
 926             *errmsg = failed.fn;
 927             return (pid_t) -1;
 928           }
 929       }
 930       return pid;
 931     }
 932 }
 933 #endif /* SPAWN */
 934
 935 /* Wait for a child process to complete.  */
 936
 937 static pid_t
 938 pex_unix_wait (struct pex_obj *obj, pid_t pid, int *status,
 939                struct pex_time *time, int done, const char **errmsg,
 940                int *err)
 941 {
 942   /* If we are cleaning up when the caller didn't retrieve process
 943      status for some reason, encourage the process to go away.  */
 944   if (done)
 945     kill (pid, SIGTERM);
 946
 947   if (pex_wait (obj, pid, status, time) < 0)
 948     {
 949       *err = errno;
 950       *errmsg = "wait";
 951       return -1;
 952     }
 953
 954   return 0;
 955 }
 956
 957 /* Create a pipe.  */
 958
 959 static int
 960 pex_unix_pipe (struct pex_obj *obj ATTRIBUTE_UNUSED, int *p,
 961                int binary ATTRIBUTE_UNUSED)
 962 {
 963   return pipe (p);
 964 }
 965
 966 /* Get a FILE pointer to read from a file descriptor.  */
 967
 968 static FILE *
 969 pex_unix_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
 970                   int binary ATTRIBUTE_UNUSED)
 971 {
 972   return fdopen (fd, "r");
 973 }
 974
 975 static FILE *
 976 pex_unix_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
 977                   int binary ATTRIBUTE_UNUSED)
 978 {
 979   if (fcntl (fd, F_SETFD, FD_CLOEXEC) < 0)
 980     return NULL;
 981   return fdopen (fd, "w");
 982 }
 983
 984 static void
 985 pex_unix_cleanup (struct pex_obj *obj ATTRIBUTE_UNUSED)
 986 {
 987 #if !defined (HAVE_WAIT4) && !defined (HAVE_WAITPID)
 988   while (obj->sysdep != NULL)
 989     {
 990       struct status_list *this;
 991       struct status_list *next;
 992
 993       this = (struct status_list *) obj->sysdep;
 994       next = this->next;
 995       free (this);
 996       obj->sysdep = (void *) next;
 997     }
 998 #endif
 999 }