libiberty/pex-common.c

   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@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       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 (pid_t, 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   obj->stderr_pipe = -1;
 509   return obj->read_err;
 510 }
 511
 512 /* Get the exit status and, if requested, the resource time for all
 513    the child processes.  Return 0 on failure, 1 on success.  */
 514
 515 static int
 516 pex_get_status_and_time (struct pex_obj *obj, int done, const char **errmsg,
 517                          int *err)
 518 {
 519   int ret;
 520   int i;
 521
 522   if (obj->number_waited == obj->count)
 523     return 1;
 524
 525   obj->status = XRESIZEVEC (int, obj->status, obj->count);
 526   if ((obj->flags & PEX_RECORD_TIMES) != 0)
 527     obj->time = XRESIZEVEC (struct pex_time, obj->time, obj->count);
 528
 529   ret = 1;
 530   for (i = obj->number_waited; i < obj->count; ++i)
 531     {
 532       if (obj->funcs->wait (obj, obj->children[i], &obj->status[i],
 533                             obj->time == NULL ? NULL : &obj->time[i],
 534                             done, errmsg, err) < 0)
 535         ret = 0;
 536     }
 537   obj->number_waited = i;
 538
 539   return ret;
 540 }
 541
 542 /* Get exit status of executed programs.  */
 543
 544 int
 545 pex_get_status (struct pex_obj *obj, int count, int *vector)
 546 {
 547   if (obj->status == NULL)
 548     {
 549       const char *errmsg;
 550       int err;
 551
 552       if (!pex_get_status_and_time (obj, 0, &errmsg, &err))
 553         return 0;
 554     }
 555
 556   if (count > obj->count)
 557     {
 558       memset (vector + obj->count, 0, (count - obj->count) * sizeof (int));
 559       count = obj->count;
 560     }
 561
 562   memcpy (vector, obj->status, count * sizeof (int));
 563
 564   return 1;
 565 }
 566
 567 /* Get process times of executed programs.  */
 568
 569 int
 570 pex_get_times (struct pex_obj *obj, int count, struct pex_time *vector)
 571 {
 572   if (obj->status == NULL)
 573     {
 574       const char *errmsg;
 575       int err;
 576
 577       if (!pex_get_status_and_time (obj, 0, &errmsg, &err))
 578         return 0;
 579     }
 580
 581   if (obj->time == NULL)
 582     return 0;
 583
 584   if (count > obj->count)
 585     {
 586       memset (vector + obj->count, 0,
 587               (count - obj->count) * sizeof (struct pex_time));
 588       count = obj->count;
 589     }
 590
 591   memcpy (vector, obj->time, count * sizeof (struct pex_time));
 592
 593   return 1;
 594 }
 595
 596 /* Free a pex_obj structure.  */
 597
 598 void
 599 pex_free (struct pex_obj *obj)
 600 {
 601   /* Close pipe file descriptors corresponding to child's stdout and
 602      stderr so that the child does not hang trying to output something
 603      while we're waiting for it.  */
 604   if (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO)
 605     obj->funcs->close (obj, obj->next_input);
 606   if (obj->stderr_pipe >= 0 && obj->stderr_pipe != STDIN_FILE_NO)
 607     obj->funcs->close (obj, obj->stderr_pipe);
 608   if (obj->read_output != NULL)
 609     fclose (obj->read_output);
 610   if (obj->read_err != NULL)
 611     fclose (obj->read_err);
 612
 613   /* If the caller forgot to wait for the children, we do it here, to
 614      avoid zombies.  */
 615   if (obj->status == NULL)
 616     {
 617       const char *errmsg;
 618       int err;
 619
 620       obj->flags &= ~ PEX_RECORD_TIMES;
 621       pex_get_status_and_time (obj, 1, &errmsg, &err);
 622     }
 623
 624   if (obj->next_input_name_allocated)
 625     free (obj->next_input_name);
 626   free (obj->children);
 627   free (obj->status);
 628   free (obj->time);
 629
 630   if (obj->remove_count > 0)
 631     {
 632       int i;
 633
 634       for (i = 0; i < obj->remove_count; ++i)
 635         {
 636           remove (obj->remove[i]);
 637           free (obj->remove[i]);
 638         }
 639       free (obj->remove);
 640     }
 641
 642   if (obj->funcs->cleanup != NULL)
 643     obj->funcs->cleanup (obj);
 644
 645   free (obj);
 646 }