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
    5:    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: 
   59: 
   60: #ifdef vfork /* Autoconf may define this to fork for us. */
   61: # define VFORK_STRING "fork"
   62: #else
   63: # define VFORK_STRING "vfork"
   64: #endif
   65: #ifdef HAVE_VFORK_H
   66: #include <vfork.h>
   67: #endif
   68: #ifdef VMS
   69: #define vfork() (decc$$alloc_vfork_blocks() >= 0 ? \
   70:                lib$get_current_invo_context(decc$$get_vfork_jmpbuf()) : -1)
   71: #endif /* VMS */
   72: 
   73: 
   74: /* File mode to use for private and world-readable files.  */
   75: 
   76: #if defined (S_IRUSR) && defined (S_IWUSR) && defined (S_IRGRP) && defined (S_IWGRP) && defined (S_IROTH) && defined (S_IWOTH)
   77: #define PUBLIC_MODE  \
   78:     (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
   79: #else
   80: #define PUBLIC_MODE 0666
   81: #endif
   82: 
   83: /* Get the exit status of a particular process, and optionally get the
   84:    time that it took.  This is simple if we have wait4, slightly
   85:    harder if we have waitpid, and is a pain if we only have wait.  */
   86: 
   87: static pid_t pex_wait (struct pex_obj *, pid_t, int *, struct pex_time *);
   88: 
   89: #ifdef HAVE_WAIT4
   90: 
   91: static pid_t
   92: pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
   93:           struct pex_time *time)
   94: {
   95:   pid_t ret;
   96:   struct rusage r;
   97: 
   98: #ifdef HAVE_WAITPID
   99:   if (time == NULL)
  100:     return waitpid (pid, status, 0);
  101: #endif
  102: 
  103:   ret = wait4 (pid, status, 0, &r);
  104: 
  105:   if (time != NULL)
  106:     {
  107:       time->user_seconds = r.ru_utime.tv_sec;
  108:       time->user_microseconds= r.ru_utime.tv_usec;
  109:       time->system_seconds = r.ru_stime.tv_sec;
  110:       time->system_microseconds= r.ru_stime.tv_usec;
  111:     }
  112: 
  113:   return ret;
  114: }
  115: 
  116: #else /* ! defined (HAVE_WAIT4) */
  117: 
  118: #ifdef HAVE_WAITPID
  119: 
  120: #ifndef HAVE_GETRUSAGE
  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:   if (time != NULL)
  127:     memset (time, 0, sizeof (struct pex_time));
  128:   return waitpid (pid, status, 0);
  129: }
  130: 
  131: #else /* defined (HAVE_GETRUSAGE) */
  132: 
  133: static pid_t
  134: pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
  135:           struct pex_time *time)
  136: {
  137:   struct rusage r1, r2;
  138:   pid_t ret;
  139: 
  140:   if (time == NULL)
  141:     return waitpid (pid, status, 0);
  142: 
  143:   getrusage (RUSAGE_CHILDREN, &r1);
  144: 
  145:   ret = waitpid (pid, status, 0);
  146:   if (ret < 0)
  147:     return ret;
  148: 
  149:   getrusage (RUSAGE_CHILDREN, &r2);
  150: 
  151:   time->user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
  152:   time->user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
  153:   if (r2.ru_utime.tv_usec < r1.ru_utime.tv_usec)
  154:     {
  155:       --time->user_seconds;
  156:       time->user_microseconds += 1000000;
  157:     }
  158: 
  159:   time->system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
  160:   time->system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
  161:   if (r2.ru_stime.tv_usec < r1.ru_stime.tv_usec)
  162:     {
  163:       --time->system_seconds;
  164:       time->system_microseconds += 1000000;
  165:     }
  166: 
  167:   return ret;
  168: }
  169: 
  170: #endif /* defined (HAVE_GETRUSAGE) */
  171: 
  172: #else /* ! defined (HAVE_WAITPID) */
  173: 
  174: struct status_list
  175: {
  176:   struct status_list *next;
  177:   pid_t pid;
  178:   int status;
  179:   struct pex_time time;
  180: };
  181: 
  182: static pid_t
  183: pex_wait (struct pex_obj *obj, pid_t pid, int *status, struct pex_time *time)
  184: {
  185:   struct status_list **pp;
  186: 
  187:   for (pp = (struct status_list **) &obj->sysdep;
  188:        *pp != NULL;
  189:        pp = &(*pp)->next)
  190:     {
  191:       if ((*pp)->pid == pid)
  192:         {
  193:           struct status_list *p;
  194: 
  195:           p = *pp;
  196:           *status = p->status;
  197:           if (time != NULL)
  198:             *time = p->time;
  199:           *pp = p->next;
  200:           free (p);
  201:           return pid;
  202:         }
  203:     }
  204: 
  205:   while (1)
  206:     {
  207:       pid_t cpid;
  208:       struct status_list *psl;
  209:       struct pex_time pt;
  210: #ifdef HAVE_GETRUSAGE
  211:       struct rusage r1, r2;
  212: #endif
  213: 
  214:       if (time != NULL)
  215:         {
  216: #ifdef HAVE_GETRUSAGE
  217:           getrusage (RUSAGE_CHILDREN, &r1);
  218: #else
  219:           memset (&pt, 0, sizeof (struct pex_time));
  220: #endif
  221:         }
  222: 
  223:       cpid = wait (status);
  224: 
  225: #ifdef HAVE_GETRUSAGE
  226:       if (time != NULL && cpid >= 0)
  227:         {
  228:           getrusage (RUSAGE_CHILDREN, &r2);
  229: 
  230:           pt.user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
  231:           pt.user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
  232:           if (pt.user_microseconds < 0)
  233:             {
  234:               --pt.user_seconds;
  235:               pt.user_microseconds += 1000000;
  236:             }
  237: 
  238:           pt.system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
  239:           pt.system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
  240:           if (pt.system_microseconds < 0)
  241:             {
  242:               --pt.system_seconds;
  243:               pt.system_microseconds += 1000000;
  244:             }
  245:         }
  246: #endif
  247: 
  248:       if (cpid < 0 || cpid == pid)
  249:         {
  250:           if (time != NULL)
  251:             *time = pt;
  252:           return cpid;
  253:         }
  254: 
  255:       psl = XNEW (struct status_list);
  256:       psl->pid = cpid;
  257:       psl->status = *status;
  258:       if (time != NULL)
  259:         psl->time = pt;
  260:       psl->next = (struct status_list *) obj->sysdep;
  261:       obj->sysdep = (void *) psl;
  262:     }
  263: }
  264: 
  265: #endif /* ! defined (HAVE_WAITPID) */
  266: #endif /* ! defined (HAVE_WAIT4) */
  267: 
  268: static void pex_child_error (struct pex_obj *, const char *, const char *, int)
  269:      ATTRIBUTE_NORETURN;
  270: static int pex_unix_open_read (struct pex_obj *, const char *, int);
  271: static int pex_unix_open_write (struct pex_obj *, const char *, int);
  272: static long pex_unix_exec_child (struct pex_obj *, int, const char *,
  273:                                  char * const *, char * const *,
  274:                                  int, int, int, int,
  275:                                  const char **, int *);
  276: static int pex_unix_close (struct pex_obj *, int);
  277: static int pex_unix_wait (struct pex_obj *, long, int *, struct pex_time *,
  278:                           int, const char **, int *);
  279: static int pex_unix_pipe (struct pex_obj *, int *, int);
  280: static FILE *pex_unix_fdopenr (struct pex_obj *, int, int);
  281: static FILE *pex_unix_fdopenw (struct pex_obj *, int, int);
  282: static void pex_unix_cleanup (struct pex_obj *);
  283: 
  284: /* The list of functions we pass to the common routines.  */
  285: 
  286: const struct pex_funcs funcs =
  287: {
  288:   pex_unix_open_read,
  289:   pex_unix_open_write,
  290:   pex_unix_exec_child,
  291:   pex_unix_close,
  292:   pex_unix_wait,
  293:   pex_unix_pipe,
  294:   pex_unix_fdopenr,
  295:   pex_unix_fdopenw,
  296:   pex_unix_cleanup
  297: };
  298: 
  299: /* Return a newly initialized pex_obj structure.  */
  300: 
  301: struct pex_obj *
  302: pex_init (int flags, const char *pname, const char *tempbase)
  303: {
  304:   return pex_init_common (flags, pname, tempbase, &funcs);
  305: }
  306: 
  307: /* Open a file for reading.  */
  308: 
  309: static int
  310: pex_unix_open_read (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
  311:                     int binary ATTRIBUTE_UNUSED)
  312: {
  313:   return open (name, O_RDONLY);
  314: }
  315: 
  316: /* Open a file for writing.  */
  317: 
  318: static int
  319: pex_unix_open_write (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
  320:                      int binary ATTRIBUTE_UNUSED)
  321: {
  322:   /* Note that we can't use O_EXCL here because gcc may have already
  323:      created the temporary file via make_temp_file.  */
  324:   return open (name, O_WRONLY | O_CREAT | O_TRUNC, PUBLIC_MODE);
  325: }
  326: 
  327: /* Close a file.  */
  328: 
  329: static int
  330: pex_unix_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
  331: {
  332:   return close (fd);
  333: }
  334: 
  335: /* Report an error from a child process.  We don't use stdio routines,
  336:    because we might be here due to a vfork call.  */
  337: 
  338: static void
  339: pex_child_error (struct pex_obj *obj, const char *executable,
  340:                  const char *errmsg, int err)
  341: {
  342: #define writeerr(s) (void) write (STDERR_FILE_NO, s, strlen (s))
  343:   writeerr (obj->pname);
  344:   writeerr (": error trying to exec '");
  345:   writeerr (executable);
  346:   writeerr ("': ");
  347:   writeerr (errmsg);
  348:   writeerr (": ");
  349:   writeerr (xstrerror (err));
  350:   writeerr ("\n");
  351:   _exit (-1);
  352: }
  353: 
  354: /* Execute a child.  */
  355: 
  356: extern char **environ;
  357: 
  358: static long
  359: pex_unix_exec_child (struct pex_obj *obj, int flags, const char *executable,
  360:                      char * const * argv, char * const * env,
  361:                      int in, int out, int errdes,
  362:                      int toclose, const char **errmsg, int *err)
  363: {
  364:   pid_t pid;
  365: 
  366:   /* We declare these to be volatile to avoid warnings from gcc about
  367:      them being clobbered by vfork.  */
  368:   volatile int sleep_interval;
  369:   volatile int retries;
  370: 
  371:   sleep_interval = 1;
  372:   pid = -1;
  373:   for (retries = 0; retries < 4; ++retries)
  374:     {
  375:       pid = vfork ();
  376:       if (pid >= 0)
  377:         break;
  378:       sleep (sleep_interval);
  379:       sleep_interval *= 2;
  380:     }
  381: 
  382:   switch (pid)
  383:     {
  384:     case -1:
  385:       *err = errno;
  386:       *errmsg = VFORK_STRING;
  387:       return -1;
  388: 
  389:     case 0:
  390:       /* Child process.  */
  391:       if (in != STDIN_FILE_NO)
  392:         {
  393:           if (dup2 (in, STDIN_FILE_NO) < 0)
  394:             pex_child_error (obj, executable, "dup2", errno);
  395:           if (close (in) < 0)
  396:             pex_child_error (obj, executable, "close", errno);
  397:         }
  398:       if (out != STDOUT_FILE_NO)
  399:         {
  400:           if (dup2 (out, STDOUT_FILE_NO) < 0)
  401:             pex_child_error (obj, executable, "dup2", errno);
  402:           if (close (out) < 0)
  403:             pex_child_error (obj, executable, "close", errno);
  404:         }
  405:       if (errdes != STDERR_FILE_NO)
  406:         {
  407:           if (dup2 (errdes, STDERR_FILE_NO) < 0)
  408:             pex_child_error (obj, executable, "dup2", errno);
  409:           if (close (errdes) < 0)
  410:             pex_child_error (obj, executable, "close", errno);
  411:         }
  412:       if (toclose >= 0)
  413:         {
  414:           if (close (toclose) < 0)
  415:             pex_child_error (obj, executable, "close", errno);
  416:         }
  417:       if ((flags & PEX_STDERR_TO_STDOUT) != 0)
  418:         {
  419:           if (dup2 (STDOUT_FILE_NO, STDERR_FILE_NO) < 0)
  420:             pex_child_error (obj, executable, "dup2", errno);
  421:         }
  422: 
  423:       if (env)
  424:         environ = (char**) env;
  425: 
  426:       if ((flags & PEX_SEARCH) != 0)
  427:         {
  428:           execvp (executable, argv);
  429:           pex_child_error (obj, executable, "execvp", errno);
  430:         }
  431:       else
  432:         {
  433:           execv (executable, argv);
  434:           pex_child_error (obj, executable, "execv", errno);
  435:         }
  436: 
  437:       /* NOTREACHED */
  438:       return -1;
  439: 
  440:     default:
  441:       /* Parent process.  */
  442:       if (in != STDIN_FILE_NO)
  443:         {
  444:           if (close (in) < 0)
  445:             {
  446:               *err = errno;
  447:               *errmsg = "close";
  448:               return -1;
  449:             }
  450:         }
  451:       if (out != STDOUT_FILE_NO)
  452:         {
  453:           if (close (out) < 0)
  454:             {
  455:               *err = errno;
  456:               *errmsg = "close";
  457:               return -1;
  458:             }
  459:         }
  460:       if (errdes != STDERR_FILE_NO)
  461:         {
  462:           if (close (errdes) < 0)
  463:             {
  464:               *err = errno;
  465:               *errmsg = "close";
  466:               return -1;
  467:             }
  468:         }
  469: 
  470:       return (long) pid;
  471:     }
  472: }
  473: 
  474: /* Wait for a child process to complete.  */
  475: 
  476: static int
  477: pex_unix_wait (struct pex_obj *obj, long pid, int *status,
  478:                struct pex_time *time, int done, const char **errmsg,
  479:                int *err)
  480: {
  481:   /* If we are cleaning up when the caller didn't retrieve process
  482:      status for some reason, encourage the process to go away.  */
  483:   if (done)
  484:     kill (pid, SIGTERM);
  485: 
  486:   if (pex_wait (obj, pid, status, time) < 0)
  487:     {
  488:       *err = errno;
  489:       *errmsg = "wait";
  490:       return -1;
  491:     }
  492: 
  493:   return 0;
  494: }
  495: 
  496: /* Create a pipe.  */
  497: 
  498: static int
  499: pex_unix_pipe (struct pex_obj *obj ATTRIBUTE_UNUSED, int *p,
  500:                int binary ATTRIBUTE_UNUSED)
  501: {
  502:   return pipe (p);
  503: }
  504: 
  505: /* Get a FILE pointer to read from a file descriptor.  */
  506: 
  507: static FILE *
  508: pex_unix_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
  509:                   int binary ATTRIBUTE_UNUSED)
  510: {
  511:   return fdopen (fd, "r");
  512: }
  513: 
  514: static FILE *
  515: pex_unix_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
  516:                   int binary ATTRIBUTE_UNUSED)
  517: {
  518:   if (fcntl (fd, F_SETFD, FD_CLOEXEC) < 0)
  519:     return NULL;
  520:   return fdopen (fd, "w");
  521: }
  522: 
  523: static void
  524: pex_unix_cleanup (struct pex_obj *obj ATTRIBUTE_UNUSED)
  525: {
  526: #if !defined (HAVE_WAIT4) && !defined (HAVE_WAITPID)
  527:   while (obj->sysdep != NULL)
  528:     {
  529:       struct status_list *this;
  530:       struct status_list *next;
  531: 
  532:       this = (struct status_list *) obj->sysdep;
  533:       next = this->next;
  534:       free (this);
  535:       obj->sysdep = (void *) next;
  536:     }
  537: #endif
  538: }