1: /* Common code for executing a program in a sub-process.
    2:    Copyright (C) 2005 Free Software Foundation, Inc.
    3:    Written by Ian Lance Taylor <ian@airs.com>.
    4: 
    5: This file is part of the libiberty library.
    6: Libiberty is free software; you can redistribute it and/or
    7: modify it under the terms of the GNU Library General Public
    8: License as published by the Free Software Foundation; either
    9: version 2 of the License, or (at your option) any later version.
   10: 
   11: Libiberty is distributed in the hope that it will be useful,
   12: but WITHOUT ANY WARRANTY; without even the implied warranty of
   13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   14: Library General Public License for more details.
   15: 
   16: You should have received a copy of the GNU Library General Public
   17: License along with libiberty; see the file COPYING.LIB.  If not,
   18: write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
   19: Boston, MA 02110-1301, USA.  */
   20: 
   21: #include "config.h"
   22: #include "libiberty.h"
   23: #include "pex-common.h"
   24: 
   25: #include <stdio.h>
   26: #include <errno.h>
   27: #ifdef NEED_DECLARATION_ERRNO
   28: extern int errno;
   29: #endif
   30: #ifdef HAVE_STDLIB_H
   31: #include <stdlib.h>
   32: #endif
   33: #ifdef HAVE_STRING_H
   34: #include <string.h>
   35: #endif
   36: #ifdef HAVE_UNISTD_H
   37: #include <unistd.h>
   38: #endif
   39: 
   40: extern int mkstemps (char *, int);
   41: 
   42: /* This file contains subroutines for the program execution routines
   43:    (pex_init, pex_run, etc.).  This file is compiled on all
   44:    systems.  */
   45: 
   46: static void pex_add_remove (struct pex_obj *, const char *, int);
   47: static int pex_get_status_and_time (struct pex_obj *, int, const char **,
   48:                                     int *);
   49: 
   50: /* Initialize a pex_obj structure.  */
   51: 
   52: struct pex_obj *
   53: pex_init_common (int flags, const char *pname, const char *tempbase,
   54:                  const struct pex_funcs *funcs)
   55: {
   56:   struct pex_obj *obj;
   57: 
   58:   obj = XNEW (struct pex_obj);
   59:   obj->flags = flags;
   60:   obj->pname = pname;
   61:   obj->tempbase = tempbase;
   62:   obj->next_input = STDIN_FILE_NO;
   63:   obj->next_input_name = NULL;
   64:   obj->next_input_name_allocated = 0;
   65:   obj->stderr_pipe = -1;
   66:   obj->count = 0;
   67:   obj->children = NULL;
   68:   obj->status = NULL;
   69:   obj->time = NULL;
   70:   obj->number_waited = 0;
   71:   obj->input_file = NULL;
   72:   obj->read_output = NULL;
   73:   obj->read_err = NULL;
   74:   obj->remove_count = 0;
   75:   obj->remove = NULL;
   76:   obj->funcs = funcs;
   77:   obj->sysdep = NULL;
   78:   return obj;
   79: }
   80: 
   81: /* Add a file to be removed when we are done.  */
   82: 
   83: static void
   84: pex_add_remove (struct pex_obj *obj, const char *name, int allocated)
   85: {
   86:   char *add;
   87: 
   88:   ++obj->remove_count;
   89:   obj->remove = XRESIZEVEC (char *, obj->remove, obj->remove_count);
   90:   if (allocated)
   91:     add = (char *) name;
   92:   else
   93:     add = xstrdup (name);
   94:   obj->remove[obj->remove_count - 1] = add;
   95: }
   96: 
   97: /* Generate a temporary file name based on OBJ, FLAGS, and NAME.
   98:    Return NULL if we were unable to reserve a temporary filename.
   99: 
  100:    If non-NULL, the result is either allocated with malloc, or the
  101:    same pointer as NAME.  */
  102: static char *
  103: temp_file (struct pex_obj *obj, int flags, char *name)
  104: {
  105:   if (name == NULL)
  106:     {
  107:       if (obj->tempbase == NULL)
  108:         {
  109:           name = make_temp_file (NULL);
  110:         }
  111:       else
  112:         {
  113:           int len = strlen (obj->tempbase);
  114:           int out;
  115: 
  116:           if (len >= 6
  117:               && strcmp (obj->tempbase + len - 6, "XXXXXX") == 0)
  118:             name = xstrdup (obj->tempbase);
  119:           else
  120:             name = concat (obj->tempbase, "XXXXXX", NULL);
  121: 
  122:           out = mkstemps (name, 0);
  123:           if (out < 0)
  124:             {
  125:               free (name);
  126:               return NULL;
  127:             }
  128: 
  129:           /* This isn't obj->funcs->close because we got the
  130:              descriptor from mkstemps, not from a function in
  131:              obj->funcs.  Calling close here is just like what
  132:              make_temp_file does.  */
  133:           close (out);
  134:         }
  135:     }
  136:   else if ((flags & PEX_SUFFIX) != 0)
  137:     {
  138:       if (obj->tempbase == NULL)
  139:         name = make_temp_file (name);
  140:       else
  141:         name = concat (obj->tempbase, name, NULL);
  142:     }
  143: 
  144:   return name;
  145: }
  146: 
  147: 
  148: /* As for pex_run (), but permits the environment for the child process
  149:    to be specified. */
  150: 
  151: const char *
  152: pex_run_in_environment (struct pex_obj *obj, int flags, const char *executable,
  153:                         char * const * argv, char * const * env,
  154:                         const char *orig_outname, const char *errname,
  155:                         int *err)
  156: {
  157:   const char *errmsg;
  158:   int in, out, errdes;
  159:   char *outname;
  160:   int outname_allocated;
  161:   int p[2];
  162:   int toclose;
  163:   long pid;
  164: 
  165:   in = -1;
  166:   out = -1;
  167:   errdes = -1;
  168:   outname = (char *) orig_outname;
  169:   outname_allocated = 0;
  170: 
  171:   /* If the user called pex_input_file, close the file now.  */
  172:   if (obj->input_file)
  173:     {
  174:       if (fclose (obj->input_file) == EOF)
  175:         {
  176:           errmsg = "closing pipeline input file";
  177:           goto error_exit;
  178:         }
  179:       obj->input_file = NULL;
  180:     }
  181: 
  182:   /* Set IN.  */
  183: 
  184:   if (obj->next_input_name != NULL)
  185:     {
  186:       /* We have to make sure that the previous process has completed
  187:          before we try to read the file.  */
  188:       if (!pex_get_status_and_time (obj, 0, &errmsg, err))
  189:         goto error_exit;
  190: 
  191:       in = obj->funcs->open_read (obj, obj->next_input_name,
  192:                                   (flags & PEX_BINARY_INPUT) != 0);
  193:       if (in < 0)
  194:         {
  195:           *err = errno;
  196:           errmsg = "open temporary file";
  197:           goto error_exit;
  198:         }
  199:       if (obj->next_input_name_allocated)
  200:         {
  201:           free (obj->next_input_name);
  202:           obj->next_input_name_allocated = 0;
  203:         }
  204:       obj->next_input_name = NULL;
  205:     }
  206:   else
  207:     {
  208:       in = obj->next_input;
  209:       if (in < 0)
  210:         {
  211:           *err = 0;
  212:           errmsg = "pipeline already complete";
  213:           goto error_exit;
  214:         }
  215:     }
  216: 
  217:   /* Set OUT and OBJ->NEXT_INPUT/OBJ->NEXT_INPUT_NAME.  */
  218: 
  219:   if ((flags & PEX_LAST) != 0)
  220:     {
  221:       if (outname == NULL)
  222:         out = STDOUT_FILE_NO;
  223:       else if ((flags & PEX_SUFFIX) != 0)
  224:         {
  225:           outname = concat (obj->tempbase, outname, NULL);
  226:           outname_allocated = 1;
  227:         }
  228:       obj->next_input = -1;
  229:     }
  230:   else if ((obj->flags & PEX_USE_PIPES) == 0)
  231:     {
  232:       outname = temp_file (obj, flags, outname);
  233:       if (! outname)
  234:         {
  235:           *err = 0;
  236:           errmsg = "could not create temporary file";
  237:           goto error_exit;
  238:         }
  239: 
  240:       if (outname != orig_outname)
  241:         outname_allocated = 1;
  242: 
  243:       if ((obj->flags & PEX_SAVE_TEMPS) == 0)
  244:         {
  245:           pex_add_remove (obj, outname, outname_allocated);
  246:           outname_allocated = 0;
  247:         }
  248: 
  249:       /* Hand off ownership of outname to the next stage.  */
  250:       obj->next_input_name = outname;
  251:       obj->next_input_name_allocated = outname_allocated;
  252:       outname_allocated = 0;
  253:     }
  254:   else
  255:     {
  256:       if (obj->funcs->pipe (obj, p, (flags & PEX_BINARY_OUTPUT) != 0) < 0)
  257:         {
  258:           *err = errno;
  259:           errmsg = "pipe";
  260:           goto error_exit;
  261:         }
  262: 
  263:       out = p[WRITE_PORT];
  264:       obj->next_input = p[READ_PORT];
  265:     }
  266: 
  267:   if (out < 0)
  268:     {
  269:       out = obj->funcs->open_write (obj, outname,
  270:                                     (flags & PEX_BINARY_OUTPUT) != 0);
  271:       if (out < 0)
  272:         {
  273:           *err = errno;
  274:           errmsg = "open temporary output file";
  275:           goto error_exit;
  276:         }
  277:     }
  278: 
  279:   if (outname_allocated)
  280:     {
  281:       free (outname);
  282:       outname_allocated = 0;
  283:     }
  284: 
  285:   /* Set ERRDES.  */
  286: 
  287:   if (errname != NULL && (flags & PEX_STDERR_TO_PIPE) != 0)
  288:     {
  289:       *err = 0;
  290:       errmsg = "both ERRNAME and PEX_STDERR_TO_PIPE specified.";
  291:       goto error_exit;
  292:     }
  293: 
  294:   if (obj->stderr_pipe != -1)
  295:     {
  296:       *err = 0;
  297:       errmsg = "PEX_STDERR_TO_PIPE used in the middle of pipeline";
  298:       goto error_exit;
  299:     }
  300: 
  301:   if (errname == NULL)
  302:     {
  303:       if (flags & PEX_STDERR_TO_PIPE)
  304:         {
  305:           if (obj->funcs->pipe (obj, p, (flags & PEX_BINARY_ERROR) != 0) < 0)
  306:             {
  307:               *err = errno;
  308:               errmsg = "pipe";
  309:               goto error_exit;
  310:             }
  311:           
  312:           errdes = p[WRITE_PORT];
  313:           obj->stderr_pipe = p[READ_PORT];       
  314:         }
  315:       else
  316:         {
  317:           errdes = STDERR_FILE_NO;
  318:         }
  319:     }
  320:   else
  321:     {
  322:       errdes = obj->funcs->open_write (obj, errname, 
  323:                                        (flags & PEX_BINARY_ERROR) != 0);
  324:       if (errdes < 0)
  325:         {
  326:           *err = errno;
  327:           errmsg = "open error file";
  328:           goto error_exit;
  329:         }
  330:     }
  331: 
  332:   /* If we are using pipes, the child process has to close the next
  333:      input pipe.  */
  334: 
  335:   if ((obj->flags & PEX_USE_PIPES) == 0)
  336:     toclose = -1;
  337:   else
  338:     toclose = obj->next_input;
  339: 
  340:   /* Run the program.  */
  341: 
  342:   pid = obj->funcs->exec_child (obj, flags, executable, argv, env,
  343:                                 in, out, errdes, toclose, &errmsg, err);
  344:   if (pid < 0)
  345:     goto error_exit;
  346: 
  347:   ++obj->count;
  348:   obj->children = XRESIZEVEC (long, obj->children, obj->count);
  349:   obj->children[obj->count - 1] = pid;
  350: 
  351:   return NULL;
  352: 
  353:  error_exit:
  354:   if (in >= 0 && in != STDIN_FILE_NO)
  355:     obj->funcs->close (obj, in);
  356:   if (out >= 0 && out != STDOUT_FILE_NO)
  357:     obj->funcs->close (obj, out);
  358:   if (errdes >= 0 && errdes != STDERR_FILE_NO)
  359:     obj->funcs->close (obj, errdes);
  360:   if (outname_allocated)
  361:     free (outname);
  362:   return errmsg;
  363: }
  364: 
  365: /* Run a program.  */
  366: 
  367: const char *
  368: pex_run (struct pex_obj *obj, int flags, const char *executable,
  369:          char * const * argv, const char *orig_outname, const char *errname,
  370:          int *err)
  371: {
  372:   return pex_run_in_environment (obj, flags, executable, argv, NULL,
  373:                                  orig_outname, errname, err);
  374: }
  375: 
  376: /* Return a FILE pointer for a temporary file to fill with input for
  377:    the pipeline.  */
  378: FILE *
  379: pex_input_file (struct pex_obj *obj, int flags, const char *in_name)
  380: {
  381:   char *name = (char *) in_name;
  382:   FILE *f;
  383: 
  384:   /* This must be called before the first pipeline stage is run, and
  385:      there must not have been any other input selected.  */
  386:   if (obj->count != 0
  387:       || (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO)
  388:       || obj->next_input_name)
  389:     {
  390:       errno = EINVAL;
  391:       return NULL;
  392:     }
  393: 
  394:   name = temp_file (obj, flags, name);
  395:   if (! name)
  396:     return NULL;
  397: 
  398:   f = fopen (name, (flags & PEX_BINARY_OUTPUT) ? "wb" : "w");
  399:   if (! f)
  400:     {
  401:       free (name);
  402:       return NULL;
  403:     }
  404: 
  405:   obj->input_file = f;
  406:   obj->next_input_name = name;
  407:   obj->next_input_name_allocated = (name != in_name);
  408: 
  409:   return f;
  410: }
  411: 
  412: /* Return a stream for a pipe connected to the standard input of the
  413:    first stage of the pipeline.  */
  414: FILE *
  415: pex_input_pipe (struct pex_obj *obj, int binary)
  416: {
  417:   int p[2];
  418:   FILE *f;
  419: 
  420:   /* You must call pex_input_pipe before the first pex_run or pex_one.  */
  421:   if (obj->count > 0)
  422:     goto usage_error;
  423: 
  424:   /* You must be using pipes.  Implementations that don't support
  425:      pipes clear this flag before calling pex_init_common.  */
  426:   if (! (obj->flags & PEX_USE_PIPES))
  427:     goto usage_error;
  428: 
  429:   /* If we have somehow already selected other input, that's a
  430:      mistake.  */
  431:   if ((obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO)
  432:       || obj->next_input_name)
  433:     goto usage_error;
  434: 
  435:   if (obj->funcs->pipe (obj, p, binary != 0) < 0)
  436:     return NULL;
  437: 
  438:   f = obj->funcs->fdopenw (obj, p[WRITE_PORT], binary != 0);
  439:   if (! f)
  440:     {
  441:       int saved_errno = errno;
  442:       obj->funcs->close (obj, p[READ_PORT]);
  443:       obj->funcs->close (obj, p[WRITE_PORT]);
  444:       errno = saved_errno;
  445:       return NULL;
  446:     }
  447: 
  448:   obj->next_input = p[READ_PORT];
  449: 
  450:   return f;
  451: 
  452:  usage_error:
  453:   errno = EINVAL;
  454:   return NULL;
  455: }
  456: 
  457: /* Return a FILE pointer for the output of the last program
  458:    executed.  */
  459: 
  460: FILE *
  461: pex_read_output (struct pex_obj *obj, int binary)
  462: {
  463:   if (obj->next_input_name != NULL)
  464:     {
  465:       const char *errmsg;
  466:       int err;
  467: 
  468:       /* We have to make sure that the process has completed before we
  469:          try to read the file.  */
  470:       if (!pex_get_status_and_time (obj, 0, &errmsg, &err))
  471:         {
  472:           errno = err;
  473:           return NULL;
  474:         }
  475: 
  476:       obj->read_output = fopen (obj->next_input_name, binary ? "rb" : "r");
  477: 
  478:       if (obj->next_input_name_allocated)
  479:         {
  480:           free (obj->next_input_name);
  481:           obj->next_input_name_allocated = 0;
  482:         }
  483:       obj->next_input_name = NULL;
  484:     }
  485:   else
  486:     {
  487:       int o;
  488: 
  489:       o = obj->next_input;
  490:       if (o < 0 || o == STDIN_FILE_NO)
  491:         return NULL;
  492:       obj->read_output = obj->funcs->fdopenr (obj, o, binary);
  493:       obj->next_input = -1;
  494:     }
  495: 
  496:   return obj->read_output;
  497: }
  498: 
  499: FILE *
  500: pex_read_err (struct pex_obj *obj, int binary)
  501: {
  502:   int o;
  503:   
  504:   o = obj->stderr_pipe;
  505:   if (o < 0 || o == STDIN_FILE_NO)
  506:     return NULL;
  507:   obj->read_err = obj->funcs->fdopenr (obj, o, binary);
  508:   return obj->read_err;    
  509: }
  510: 
  511: /* Get the exit status and, if requested, the resource time for all
  512:    the child processes.  Return 0 on failure, 1 on success.  */
  513: 
  514: static int
  515: pex_get_status_and_time (struct pex_obj *obj, int done, const char **errmsg,
  516:                          int *err)
  517: {
  518:   int ret;
  519:   int i;
  520: 
  521:   if (obj->number_waited == obj->count)
  522:     return 1;
  523: 
  524:   obj->status = XRESIZEVEC (int, obj->status, obj->count);
  525:   if ((obj->flags & PEX_RECORD_TIMES) != 0)
  526:     obj->time = XRESIZEVEC (struct pex_time, obj->time, obj->count);
  527: 
  528:   ret = 1;
  529:   for (i = obj->number_waited; i < obj->count; ++i)
  530:     {
  531:       if (obj->funcs->wait (obj, obj->children[i], &obj->status[i],
  532:                             obj->time == NULL ? NULL : &obj->time[i],
  533:                             done, errmsg, err) < 0)
  534:         ret = 0;
  535:     }
  536:   obj->number_waited = i;
  537: 
  538:   return ret;
  539: }
  540: 
  541: /* Get exit status of executed programs.  */
  542: 
  543: int
  544: pex_get_status (struct pex_obj *obj, int count, int *vector)
  545: {
  546:   if (obj->status == NULL)
  547:     {
  548:       const char *errmsg;
  549:       int err;
  550: 
  551:       if (!pex_get_status_and_time (obj, 0, &errmsg, &err))
  552:         return 0;
  553:     }
  554: 
  555:   if (count > obj->count)
  556:     {
  557:       memset (vector + obj->count, 0, (count - obj->count) * sizeof (int));
  558:       count = obj->count;
  559:     }
  560: 
  561:   memcpy (vector, obj->status, count * sizeof (int));
  562: 
  563:   return 1;
  564: }
  565: 
  566: /* Get process times of executed programs.  */
  567: 
  568: int
  569: pex_get_times (struct pex_obj *obj, int count, struct pex_time *vector)
  570: {
  571:   if (obj->status == NULL)
  572:     {