libiberty/pex-common.c

   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->count = 0;
  66   obj->children = NULL;
  67   obj->status = NULL;
  68   obj->time = NULL;
  69   obj->number_waited = 0;
  70   obj->input_file = NULL;
  71   obj->read_output = NULL;
  72   obj->remove_count = 0;
  73   obj->remove = NULL;
  74   obj->funcs = funcs;
  75   obj->sysdep = NULL;
  76   return obj;
  77 }
  78
  79 /* Add a file to be removed when we are done.  */
  80
  81 static void
  82 pex_add_remove (struct pex_obj *obj, const char *name, int allocated)
  83 {
  84   char *add;
  85
  86   ++obj->remove_count;
  87   obj->remove = XRESIZEVEC (char *, obj->remove, obj->remove_count);
  88   if (allocated)
  89     add = (char *) name;
  90   else
  91     add = xstrdup (name);
  92   obj->remove[obj->remove_count - 1] = add;
  93 }
  94
  95 /* Generate a temporary file name based on OBJ, FLAGS, and NAME.
  96    Return NULL if we were unable to reserve a temporary filename.
  97
  98    If non-NULL, the result is either allocated with malloc, or the
  99    same pointer as NAME.  */
 100 static char *
 101 temp_file (struct pex_obj *obj, int flags, char *name)
 102 {
 103   if (name == NULL)
 104     {
 105       if (obj->tempbase == NULL)
 106         {
 107           name = make_temp_file (NULL);
 108         }
 109       else
 110         {
 111           int len = strlen (obj->tempbase);
 112           int out;
 113
 114           if (len >= 6
 115               && strcmp (obj->tempbase + len - 6, "XXXXXX") == 0)
 116             name = xstrdup (obj->tempbase);
 117           else
 118             name = concat (obj->tempbase, "XXXXXX", NULL);
 119
 120           out = mkstemps (name, 0);
 121           if (out < 0)
 122             {
 123               free (name);
 124               return NULL;
 125             }
 126
 127           /* This isn't obj->funcs->close because we got the
 128              descriptor from mkstemps, not from a function in
 129              obj->funcs.  Calling close here is just like what
 130              make_temp_file does.  */
 131           close (out);
 132         }
 133     }
 134   else if ((flags & PEX_SUFFIX) != 0)
 135     {
 136       if (obj->tempbase == NULL)
 137         name = make_temp_file (name);
 138       else
 139         name = concat (obj->tempbase, name, NULL);
 140     }
 141
 142   return name;
 143 }
 144
 145
 146 /* As for pex_run (), but permits the environment for the child process
 147    to be specified. */
 148
 149 const char *
 150 pex_run_in_environment (struct pex_obj *obj, int flags, const char *executable,
 151                         char * const * argv, char * const * env,
 152                         const char *orig_outname, const char *errname,
 153                         int *err)
 154 {
 155   const char *errmsg;
 156   int in, out, errdes;
 157   char *outname;
 158   int outname_allocated;
 159   int p[2];
 160   long pid;
 161
 162   in = -1;
 163   out = -1;
 164   errdes = -1;
 165   p[READ_PORT] = -1;
 166   p[WRITE_PORT] = -1;
 167   outname = (char *) orig_outname;
 168   outname_allocated = 0;
 169
 170   /* If the user called pex_input_file, close the file now.  */
 171   if (obj->input_file)
 172     {
 173       if (fclose (obj->input_file) == EOF)
 174         {
 175           errmsg = "closing pipeline input file";
 176           goto error_exit;
 177         }
 178       obj->input_file = NULL;
 179     }
 180
 181   /* Set IN.  */
 182
 183   if (obj->next_input_name != NULL)
 184     {
 185       /* We have to make sure that the previous process has completed
 186          before we try to read the file.  */
 187       if (!pex_get_status_and_time (obj, 0, &errmsg, err))
 188         goto error_exit;
 189
 190       in = obj->funcs->open_read (obj, obj->next_input_name,
 191                                   (flags & PEX_BINARY_INPUT) != 0);
 192       if (in < 0)
 193         {
 194           *err = errno;
 195           errmsg = "open temporary file";
 196           goto error_exit;
 197         }
 198       if (obj->next_input_name_allocated)
 199         {
 200           free (obj->next_input_name);
 201           obj->next_input_name_allocated = 0;
 202         }
 203       obj->next_input_name = NULL;
 204     }
 205   else
 206     {
 207       in = obj->next_input;
 208       if (in < 0)
 209         {
 210           *err = 0;
 211           errmsg = "pipeline already complete";
 212           goto error_exit;
 213         }
 214     }
 215
 216   /* Set OUT and OBJ->NEXT_INPUT/OBJ->NEXT_INPUT_NAME.  */
 217
 218   if ((flags & PEX_LAST) != 0)
 219     {
 220       if (outname == NULL)
 221         out = STDOUT_FILE_NO;
 222       else if ((flags & PEX_SUFFIX) != 0)
 223         {
 224           outname = concat (obj->tempbase, outname, NULL);
 225           outname_allocated = 1;
 226         }
 227       obj->next_input = -1;
 228     }
 229   else if ((obj->flags & PEX_USE_PIPES) == 0)
 230     {
 231       outname = temp_file (obj, flags, outname);
 232       if (! outname)
 233         {
 234           *err = 0;
 235           errmsg = "could not create temporary file";
 236           goto error_exit;
 237         }
 238
 239       if (outname != orig_outname)
 240         outname_allocated = 1;
 241
 242       if ((obj->flags & PEX_SAVE_TEMPS) == 0)
 243         {
 244           pex_add_remove (obj, outname, outname_allocated);
 245           outname_allocated = 0;
 246         }
 247
 248       /* Hand off ownership of outname to the next stage.  */
 249       obj->next_input_name = outname;
 250       obj->next_input_name_allocated = outname_allocated;
 251       outname_allocated = 0;
 252     }
 253   else
 254     {
 255       if (obj->funcs->pipe (obj, p, (flags & PEX_BINARY_OUTPUT) != 0) < 0)
 256         {
 257           *err = errno;
 258           errmsg = "pipe";
 259           goto error_exit;
 260         }
 261
 262       out = p[WRITE_PORT];
 263       obj->next_input = p[READ_PORT];
 264     }
 265
 266   if (out < 0)
 267     {
 268       out = obj->funcs->open_write (obj, outname,
 269                                     (flags & PEX_BINARY_OUTPUT) != 0);
 270       if (out < 0)
 271         {
 272           *err = errno;
 273           errmsg = "open temporary output file";
 274           goto error_exit;
 275         }
 276     }
 277
 278   if (outname_allocated)
 279     {
 280       free (outname);
 281       outname_allocated = 0;
 282     }
 283
 284   /* Set ERRDES.  */
 285
 286   if (errname == NULL)
 287     errdes = STDERR_FILE_NO;
 288   else
 289     {
 290       /* We assume that stderr is in text mode--it certainly shouldn't
 291          be controlled by PEX_BINARY_OUTPUT.  If necessary, we can add
 292          a PEX_BINARY_STDERR flag.  */
 293       errdes = obj->funcs->open_write (obj, errname, 0);
 294       if (errdes < 0)
 295         {
 296           *err = errno;
 297           errmsg = "open error file";
 298           goto error_exit;
 299         }
 300     }
 301
 302   /* Run the program.  */
 303
 304   pid = obj->funcs->exec_child (obj, flags, executable, argv, env,
 305                                 in, out, errdes, &errmsg, err);
 306   if (p[WRITE_PORT] != -1)
 307     obj->funcs->close (obj, p[WRITE_PORT]);
 308   if (pid < 0)
 309     goto error_exit;
 310
 311   ++obj->count;
 312   obj->children = XRESIZEVEC (long, obj->children, obj->count);
 313   obj->children[obj->count - 1] = pid;
 314
 315   return NULL;
 316
 317  error_exit:
 318   if (in >= 0 && in != STDIN_FILE_NO)
 319     obj->funcs->close (obj, in);
 320   if (out >= 0 && out != STDOUT_FILE_NO)
 321     obj->funcs->close (obj, out);
 322   if (errdes >= 0 && errdes != STDERR_FILE_NO)
 323     obj->funcs->close (obj, errdes);
 324   if (outname_allocated)
 325     free (outname);
 326   return errmsg;
 327 }
 328
 329 /* Return a FILE pointer for the input of the first program
 330    executed.  */
 331
 332 FILE *
 333 pex_write_input (struct pex_obj *obj, int binary)
 334 {
 335   int p[2];
 336   FILE *write_input;
 337
 338   /* You must call pex_write_input before the first pex_run or pex_one.  */
 339   if (obj->count > 0)
 340     goto usage_error;
 341
 342   /* You must be using pipes.  Implementations that don't support
 343      pipes clear this flag before calling pex_init_common.  */
 344   if (! (obj->flags & PEX_USE_PIPES))
 345     goto usage_error;
 346
 347   /* If we have somehow already selected other input, that's a
 348      mistake.  */
 349   if ((obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO)
 350       || obj->next_input_name)
 351     goto usage_error;
 352
 353   if (obj->funcs->pipe (obj, p, binary != 0) < 0)
 354     return NULL;
 355
 356   write_input = obj->funcs->fdopenw (obj, p[WRITE_PORT], binary != 0);
 357   if (! write_input)
 358     {
 359       int saved_errno = errno;
 360       obj->funcs->close (obj, p[READ_PORT]);
 361       obj->funcs->close (obj, p[WRITE_PORT]);
 362       errno = saved_errno;
 363       return NULL;
 364     }
 365
 366   obj->next_input = p[READ_PORT];
 367
 368   return write_input;
 369
 370  usage_error:
 371   errno = EINVAL;
 372   return NULL;
 373 }
 374
 375 /* Run a program.  */
 376
 377 const char *
 378 pex_run (struct pex_obj *obj, int flags, const char *executable,
 379          char * const * argv, const char *orig_outname, const char *errname,
 380          int *err)
 381 {
 382   return pex_run_in_environment (obj, flags, executable, argv, NULL,
 383                                  orig_outname, errname, err);
 384 }
 385
 386 /* Return a FILE pointer for a temporary file to fill with input for
 387    the pipeline.  */
 388 FILE *
 389 pex_input_file (struct pex_obj *obj, int flags, const char *in_name)
 390 {
 391   char *name = (char *) in_name;
 392   FILE *f;
 393
 394   /* This must be called before the first pipeline stage is run, and
 395      there must not have been any other input selected.  */
 396   if (obj->count != 0
 397       || (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO)
 398       || obj->next_input_name)
 399     {
 400       errno = EINVAL;
 401       return NULL;
 402     }
 403
 404   name = temp_file (obj, flags, name);
 405   if (! name)
 406     return NULL;
 407
 408   f = fopen (name, (flags & PEX_BINARY_OUTPUT) ? "wb" : "w");
 409   if (! f)
 410     {
 411       free (name);
 412       return NULL;
 413     }
 414
 415   obj->input_file = f;
 416   obj->next_input_name = name;
 417   obj->next_input_name_allocated = (name != in_name);
 418
 419   return f;
 420 }
 421
 422 /* Return a stream for a pipe connected to the standard input of the
 423    first stage of the pipeline.  */
 424 FILE *
 425 pex_input_pipe (struct pex_obj *obj, int binary)
 426 {
 427   int p[2];
 428   FILE *f;
 429
 430   /* You must call pex_input_pipe before the first pex_run or pex_one.  */
 431   if (obj->count > 0)
 432     goto usage_error;
 433
 434   /* You must be using pipes.  Implementations that don't support
 435      pipes clear this flag before calling pex_init_common.  */
 436   if (! (obj->flags & PEX_USE_PIPES))
 437     goto usage_error;
 438
 439   /* If we have somehow already selected other input, that's a
 440      mistake.  */
 441   if ((obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO)
 442       || obj->next_input_name)
 443     goto usage_error;
 444
 445   if (obj->funcs->pipe (obj, p, binary != 0) < 0)
 446     return NULL;
 447
 448   f = obj->funcs->fdopenw (obj, p[WRITE_PORT], binary != 0);
 449   if (! f)
 450     {
 451       int saved_errno = errno;
 452       obj->funcs->close (obj, p[READ_PORT]);
 453       obj->funcs->close (obj, p[WRITE_PORT]);
 454       errno = saved_errno;
 455       return NULL;
 456     }
 457
 458   obj->next_input = p[READ_PORT];
 459
 460   return f;
 461
 462  usage_error:
 463   errno = EINVAL;
 464   return NULL;
 465 }
 466
 467 /* Return a FILE pointer for the output of the last program
 468    executed.  */
 469
 470 FILE *
 471 pex_read_output (struct pex_obj *obj, int binary)
 472 {
 473   if (obj->next_input_name != NULL)
 474     {
 475       const char *errmsg;
 476       int err;
 477
 478       /* We have to make sure that the process has completed before we
 479          try to read the file.  */
 480       if (!pex_get_status_and_time (obj, 0, &errmsg, &err))
 481         {
 482           errno = err;
 483           return NULL;
 484         }
 485
 486       obj->read_output = fopen (obj->next_input_name, binary ? "rb" : "r");
 487
 488       if (obj->next_input_name_allocated)
 489         {
 490           free (obj->next_input_name);
 491           obj->next_input_name_allocated = 0;
 492         }
 493       obj->next_input_name = NULL;
 494     }
 495   else
 496     {
 497       int o;
 498
 499       o = obj->next_input;
 500       if (o < 0 || o == STDIN_FILE_NO)
 501         return NULL;
 502       obj->read_output = obj->funcs->fdopenr (obj, o, binary);
 503       obj->next_input = -1;
 504     }
 505
 506   return obj->read_output;
 507 }
 508
 509 /* Get the exit status and, if requested, the resource time for all
 510    the child processes.  Return 0 on failure, 1 on success.  */
 511
 512 static int
 513 pex_get_status_and_time (struct pex_obj *obj, int done, const char **errmsg,
 514                          int *err)
 515 {
 516   int ret;
 517   int i;
 518
 519   if (obj->number_waited == obj->count)
 520     return 1;
 521
 522   obj->status = XRESIZEVEC (int, obj->status, obj->count);
 523   if ((obj->flags & PEX_RECORD_TIMES) != 0)
 524     obj->time = XRESIZEVEC (struct pex_time, obj->time, obj->count);
 525
 526   ret = 1;
 527   for (i = obj->number_waited; i < obj->count; ++i)
 528     {
 529       if (obj->funcs->wait (obj, obj->children[i], &obj->status[i],
 530                             obj->time == NULL ? NULL : &obj->time[i],
 531                             done, errmsg, err) < 0)
 532         ret = 0;
 533     }
 534   obj->number_waited = i;
 535
 536   return ret;
 537 }
 538
 539 /* Get exit status of executed programs.  */
 540
 541 int
 542 pex_get_status (struct pex_obj *obj, int count, int *vector)
 543 {
 544   if (obj->status == NULL)
 545     {
 546       const char *errmsg;
 547       int err;
 548
 549       if (!pex_get_status_and_time (obj, 0, &errmsg, &err))
 550         return 0;
 551     }
 552
 553   if (count > obj->count)
 554     {
 555       memset (vector + obj->count, 0, (count - obj->count) * sizeof (int));
 556       count = obj->count;
 557     }
 558
 559   memcpy (vector, obj->status, count * sizeof (int));
 560
 561   return 1;
 562 }
 563
 564 /* Get process times of executed programs.  */
 565
 566 int
 567 pex_get_times (struct pex_obj *obj, int count, struct pex_time *vector)
 568 {
 569   if (obj->status == NULL)
 570     {
 571       const char *errmsg;
 572       int err;
 573
 574       if (!pex_get_status_and_time (obj, 0, &errmsg, &err))
 575         return 0;
 576     }
 577
 578   if (obj->time == NULL)
 579     return 0;
 580
 581   if (count > obj->count)
 582     {
 583       memset (vector + obj->count, 0,
 584               (count - obj->count) * sizeof (struct pex_time));
 585       count = obj->count;
 586     }
 587
 588   memcpy (vector, obj->time, count * sizeof (struct pex_time));
 589
 590   return 1;
 591 }
 592
 593 /* Free a pex_obj structure.  */
 594
 595 void
 596 pex_free (struct pex_obj *obj)
 597 {
 598   if (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO)
 599     obj->funcs->close (obj, obj->next_input);
 600
 601   /* If the caller forgot to wait for the children, we do it here, to
 602      avoid zombies.  */
 603   if (obj->status == NULL)
 604     {
 605       const char *errmsg;
 606       int err;
 607
 608       obj->flags &= ~ PEX_RECORD_TIMES;
 609       pex_get_status_and_time (obj, 1, &errmsg, &err);
 610     }
 611
 612   if (obj->next_input_name_allocated)
 613     free (obj->next_input_name);
 614   if (obj->children != NULL)
 615     free (obj->children);
 616   if (obj->status != NULL)
 617     free (obj->status);
 618   if (obj->time != NULL)
 619     free (obj->time);
 620   if (obj->read_output != NULL)
 621     fclose (obj->read_output);
 622
 623   if (obj->remove_count > 0)
 624     {
 625       int i;
 626
 627       for (i = 0; i < obj->remove_count; ++i)
 628         {
 629           remove (obj->remove[i]);
 630           free (obj->remove[i]);
 631         }
 632       free (obj->remove);
 633     }
 634
 635   if (obj->funcs->cleanup != NULL)
 636     obj->funcs->cleanup (obj);
 637
 638   free (obj);
 639 }