Home | History | Annotate | Download | only in libiberty
      1 /* Common code for executing a program in a sub-process.
      2    Copyright (C) 2005, 2010 Free Software Foundation, Inc.
      3    Written by Ian Lance Taylor <ian (at) 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   pid_t 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 				    (flags & PEX_STDOUT_APPEND) != 0);
    272       if (out < 0)
    273 	{
    274 	  *err = errno;
    275 	  errmsg = "open temporary output file";
    276 	  goto error_exit;
    277 	}
    278     }
    279 
    280   if (outname_allocated)
    281     {
    282       free (outname);
    283       outname_allocated = 0;
    284     }
    285 
    286   /* Set ERRDES.  */
    287 
    288   if (errname != NULL && (flags & PEX_STDERR_TO_PIPE) != 0)
    289     {
    290       *err = 0;
    291       errmsg = "both ERRNAME and PEX_STDERR_TO_PIPE specified.";
    292       goto error_exit;
    293     }
    294 
    295   if (obj->stderr_pipe != -1)
    296     {
    297       *err = 0;
    298       errmsg = "PEX_STDERR_TO_PIPE used in the middle of pipeline";
    299       goto error_exit;
    300     }
    301 
    302   if (errname == NULL)
    303     {
    304       if (flags & PEX_STDERR_TO_PIPE)
    305 	{
    306 	  if (obj->funcs->pipe (obj, p, (flags & PEX_BINARY_ERROR) != 0) < 0)
    307 	    {
    308 	      *err = errno;
    309 	      errmsg = "pipe";
    310 	      goto error_exit;
    311 	    }
    312 
    313 	  errdes = p[WRITE_PORT];
    314 	  obj->stderr_pipe = p[READ_PORT];
    315 	}
    316       else
    317 	{
    318 	  errdes = STDERR_FILE_NO;
    319 	}
    320     }
    321   else
    322     {
    323       errdes = obj->funcs->open_write (obj, errname,
    324 				       (flags & PEX_BINARY_ERROR) != 0,
    325 				       (flags & PEX_STDERR_APPEND) != 0);
    326       if (errdes < 0)
    327 	{
    328 	  *err = errno;
    329 	  errmsg = "open error file";
    330 	  goto error_exit;
    331 	}
    332     }
    333 
    334   /* If we are using pipes, the child process has to close the next
    335      input pipe.  */
    336 
    337   if ((obj->flags & PEX_USE_PIPES) == 0)
    338     toclose = -1;
    339   else
    340     toclose = obj->next_input;
    341 
    342   /* Run the program.  */
    343 
    344   pid = obj->funcs->exec_child (obj, flags, executable, argv, env,
    345 				in, out, errdes, toclose, &errmsg, err);
    346   if (pid < 0)
    347     goto error_exit;
    348 
    349   ++obj->count;
    350   obj->children = XRESIZEVEC (pid_t, obj->children, obj->count);
    351   obj->children[obj->count - 1] = pid;
    352 
    353   return NULL;
    354 
    355  error_exit:
    356   if (in >= 0 && in != STDIN_FILE_NO)
    357     obj->funcs->close (obj, in);
    358   if (out >= 0 && out != STDOUT_FILE_NO)
    359     obj->funcs->close (obj, out);
    360   if (errdes >= 0 && errdes != STDERR_FILE_NO)
    361     obj->funcs->close (obj, errdes);
    362   if (outname_allocated)
    363     free (outname);
    364   return errmsg;
    365 }
    366 
    367 /* Run a program.  */
    368 
    369 const char *
    370 pex_run (struct pex_obj *obj, int flags, const char *executable,
    371        	 char * const * argv, const char *orig_outname, const char *errname,
    372          int *err)
    373 {
    374   return pex_run_in_environment (obj, flags, executable, argv, NULL,
    375 				 orig_outname, errname, err);
    376 }
    377 
    378 /* Return a FILE pointer for a temporary file to fill with input for
    379    the pipeline.  */
    380 FILE *
    381 pex_input_file (struct pex_obj *obj, int flags, const char *in_name)
    382 {
    383   char *name = (char *) in_name;
    384   FILE *f;
    385 
    386   /* This must be called before the first pipeline stage is run, and
    387      there must not have been any other input selected.  */
    388   if (obj->count != 0
    389       || (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO)
    390       || obj->next_input_name)
    391     {
    392       errno = EINVAL;
    393       return NULL;
    394     }
    395 
    396   name = temp_file (obj, flags, name);
    397   if (! name)
    398     return NULL;
    399 
    400   f = fopen (name, (flags & PEX_BINARY_OUTPUT) ? "wb" : "w");
    401   if (! f)
    402     {
    403       free (name);
    404       return NULL;
    405     }
    406 
    407   obj->input_file = f;
    408   obj->next_input_name = name;
    409   obj->next_input_name_allocated = (name != in_name);
    410 
    411   return f;
    412 }
    413 
    414 /* Return a stream for a pipe connected to the standard input of the
    415    first stage of the pipeline.  */
    416 FILE *
    417 pex_input_pipe (struct pex_obj *obj, int binary)
    418 {
    419   int p[2];
    420   FILE *f;
    421 
    422   /* You must call pex_input_pipe before the first pex_run or pex_one.  */
    423   if (obj->count > 0)
    424     goto usage_error;
    425 
    426   /* You must be using pipes.  Implementations that don't support
    427      pipes clear this flag before calling pex_init_common.  */
    428   if (! (obj->flags & PEX_USE_PIPES))
    429     goto usage_error;
    430 
    431   /* If we have somehow already selected other input, that's a
    432      mistake.  */
    433   if ((obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO)
    434       || obj->next_input_name)
    435     goto usage_error;
    436 
    437   if (obj->funcs->pipe (obj, p, binary != 0) < 0)
    438     return NULL;
    439 
    440   f = obj->funcs->fdopenw (obj, p[WRITE_PORT], binary != 0);
    441   if (! f)
    442     {
    443       int saved_errno = errno;
    444       obj->funcs->close (obj, p[READ_PORT]);
    445       obj->funcs->close (obj, p[WRITE_PORT]);
    446       errno = saved_errno;
    447       return NULL;
    448     }
    449 
    450   obj->next_input = p[READ_PORT];
    451 
    452   return f;
    453 
    454  usage_error:
    455   errno = EINVAL;
    456   return NULL;
    457 }
    458 
    459 /* Return a FILE pointer for the output of the last program
    460    executed.  */
    461 
    462 FILE *
    463 pex_read_output (struct pex_obj *obj, int binary)
    464 {
    465   if (obj->next_input_name != NULL)
    466     {
    467       const char *errmsg;
    468       int err;
    469 
    470       /* We have to make sure that the process has completed before we
    471 	 try to read the file.  */
    472       if (!pex_get_status_and_time (obj, 0, &errmsg, &err))
    473 	{
    474 	  errno = err;
    475 	  return NULL;
    476 	}
    477 
    478       obj->read_output = fopen (obj->next_input_name, binary ? "rb" : "r");
    479 
    480       if (obj->next_input_name_allocated)
    481 	{
    482 	  free (obj->next_input_name);
    483 	  obj->next_input_name_allocated = 0;
    484 	}
    485       obj->next_input_name = NULL;
    486     }
    487   else
    488     {
    489       int o;
    490 
    491       o = obj->next_input;
    492       if (o < 0 || o == STDIN_FILE_NO)
    493 	return NULL;
    494       obj->read_output = obj->funcs->fdopenr (obj, o, binary);
    495       obj->next_input = -1;
    496     }
    497 
    498   return obj->read_output;
    499 }
    500 
    501 FILE *
    502 pex_read_err (struct pex_obj *obj, int binary)
    503 {
    504   int o;
    505 
    506   o = obj->stderr_pipe;
    507   if (o < 0 || o == STDIN_FILE_NO)
    508     return NULL;
    509   obj->read_err = obj->funcs->fdopenr (obj, o, binary);
    510   obj->stderr_pipe = -1;
    511   return obj->read_err;
    512 }
    513 
    514 /* Get the exit status and, if requested, the resource time for all
    515    the child processes.  Return 0 on failure, 1 on success.  */
    516 
    517 static int
    518 pex_get_status_and_time (struct pex_obj *obj, int done, const char **errmsg,
    519 			 int *err)
    520 {
    521   int ret;
    522   int i;
    523 
    524   if (obj->number_waited == obj->count)
    525     return 1;
    526 
    527   obj->status = XRESIZEVEC (int, obj->status, obj->count);
    528   if ((obj->flags & PEX_RECORD_TIMES) != 0)
    529     obj->time = XRESIZEVEC (struct pex_time, obj->time, obj->count);
    530 
    531   ret = 1;
    532   for (i = obj->number_waited; i < obj->count; ++i)
    533     {
    534       if (obj->funcs->wait (obj, obj->children[i], &obj->status[i],
    535 			    obj->time == NULL ? NULL : &obj->time[i],
    536 			    done, errmsg, err) < 0)
    537 	ret = 0;
    538     }
    539   obj->number_waited = i;
    540 
    541   return ret;
    542 }
    543 
    544 /* Get exit status of executed programs.  */
    545 
    546 int
    547 pex_get_status (struct pex_obj *obj, int count, int *vector)
    548 {
    549   if (obj->status == NULL)
    550     {
    551       const char *errmsg;
    552       int err;
    553 
    554       if (!pex_get_status_and_time (obj, 0, &errmsg, &err))
    555 	return 0;
    556     }
    557 
    558   if (count > obj->count)
    559     {
    560       memset (vector + obj->count, 0, (count - obj->count) * sizeof (int));
    561       count = obj->count;
    562     }
    563 
    564   memcpy (vector, obj->status, count * sizeof (int));
    565 
    566   return 1;
    567 }
    568 
    569 /* Get process times of executed programs.  */
    570 
    571 int
    572 pex_get_times (struct pex_obj *obj, int count, struct pex_time *vector)
    573 {
    574   if (obj->status == NULL)
    575     {
    576       const char *errmsg;
    577       int err;
    578 
    579       if (!pex_get_status_and_time (obj, 0, &errmsg, &err))
    580 	return 0;
    581     }
    582 
    583   if (obj->time == NULL)
    584     return 0;
    585 
    586   if (count > obj->count)
    587     {
    588       memset (vector + obj->count, 0,
    589 	      (count - obj->count) * sizeof (struct pex_time));
    590       count = obj->count;
    591     }
    592 
    593   memcpy (vector, obj->time, count * sizeof (struct pex_time));
    594 
    595   return 1;
    596 }
    597 
    598 /* Free a pex_obj structure.  */
    599 
    600 void
    601 pex_free (struct pex_obj *obj)
    602 {
    603   /* Close pipe file descriptors corresponding to child's stdout and
    604      stderr so that the child does not hang trying to output something
    605      while we're waiting for it.  */
    606   if (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO)
    607     obj->funcs->close (obj, obj->next_input);
    608   if (obj->stderr_pipe >= 0 && obj->stderr_pipe != STDIN_FILE_NO)
    609     obj->funcs->close (obj, obj->stderr_pipe);
    610   if (obj->read_output != NULL)
    611     fclose (obj->read_output);
    612   if (obj->read_err != NULL)
    613     fclose (obj->read_err);
    614 
    615   /* If the caller forgot to wait for the children, we do it here, to
    616      avoid zombies.  */
    617   if (obj->status == NULL)
    618     {
    619       const char *errmsg;
    620       int err;
    621 
    622       obj->flags &= ~ PEX_RECORD_TIMES;
    623       pex_get_status_and_time (obj, 1, &errmsg, &err);
    624     }
    625 
    626   if (obj->next_input_name_allocated)
    627     free (obj->next_input_name);
    628   free (obj->children);
    629   free (obj->status);
    630   free (obj->time);
    631 
    632   if (obj->remove_count > 0)
    633     {
    634       int i;
    635 
    636       for (i = 0; i < obj->remove_count; ++i)
    637 	{
    638 	  remove (obj->remove[i]);
    639 	  free (obj->remove[i]);
    640 	}
    641       free (obj->remove);
    642     }
    643 
    644   if (obj->funcs->cleanup != NULL)
    645     obj->funcs->cleanup (obj);
    646 
    647   free (obj);
    648 }
    649