gcc/pexecute.c

   1 /* Utilities to execute a program in a subprocess (possibly linked by pipes
   2    with other subprocesses), and wait for it.
   3    Copyright (C) 1996, 1997 Free Software Foundation, Inc.
   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., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 /* This file exports two functions: pexecute and pwait.  */
  22
  23 /* This file lives in at least two places: libiberty and gcc.
  24    Don't change one without the other.  */
  25
  26 #ifdef IN_GCC
  27 #include "config.h"
  28 #endif
  29
  30 #include <stdio.h>
  31 #include <errno.h>
  32
  33 #ifdef IN_GCC
  34 #include "gansidecl.h"
  35 /* ??? Need to find a suitable header file.  */
  36 #define PEXECUTE_FIRST   1
  37 #define PEXECUTE_LAST    2
  38 #define PEXECUTE_ONE     (PEXECUTE_FIRST + PEXECUTE_LAST)
  39 #define PEXECUTE_SEARCH  4
  40 #define PEXECUTE_VERBOSE 8
  41 #else
  42 #include "libiberty.h"
  43 #endif
  44
  45 /* stdin file number.  */
  46 #define STDIN_FILE_NO 0
  47
  48 /* stdout file number.  */
  49 #define STDOUT_FILE_NO 1
  50
  51 /* value of `pipe': port index for reading.  */
  52 #define READ_PORT 0
  53
  54 /* value of `pipe': port index for writing.  */
  55 #define WRITE_PORT 1
  56
  57 static char *install_error_msg = "installation problem, cannot exec `%s'";
  58
  59 /* pexecute: execute a program.
  60
  61    PROGRAM and ARGV are the arguments to execv/execvp.
  62
  63    THIS_PNAME is name of the calling program (i.e. argv[0]).
  64
  65    TEMP_BASE is the path name, sans suffix, of a temporary file to use
  66    if needed.  This is currently only needed for MSDOS ports that don't use
  67    GO32 (do any still exist?).  Ports that don't need it can pass NULL.
  68
  69    (FLAGS & PEXECUTE_SEARCH) is non-zero if $PATH should be searched
  70    (??? It's not clear that GCC passes this flag correctly).
  71    (FLAGS & PEXECUTE_FIRST) is nonzero for the first process in chain.
  72    (FLAGS & PEXECUTE_FIRST) is nonzero for the last process in chain.
  73    FIRST_LAST could be simplified to only mark the last of a chain of processes
  74    but that requires the caller to always mark the last one (and not give up
  75    early if some error occurs).  It's more robust to require the caller to
  76    mark both ends of the chain.
  77
  78    The result is the pid on systems like Unix where we fork/exec and on systems
  79    like WIN32 and OS2 where we use spawn.  It is up to the caller to wait for
  80    the child.
  81
  82    The result is the WEXITSTATUS on systems like MSDOS where we spawn and wait
  83    for the child here.
  84
  85    Upon failure, ERRMSG_FMT and ERRMSG_ARG are set to the text of the error
  86    message with an optional argument (if not needed, ERRMSG_ARG is set to
  87    NULL), and -1 is returned.  `errno' is available to the caller to use.
  88
  89    pwait: cover function for wait.
  90
  91    PID is the process id of the task to wait for.
  92    STATUS is the `status' argument to wait.
  93    FLAGS is currently unused (allows future enhancement without breaking
  94    upward compatibility).  Pass 0 for now.
  95
  96    The result is the pid of the child reaped,
  97    or -1 for failure (errno says why).
  98
  99    On systems that don't support waiting for a particular child, PID is
 100    ignored.  On systems like MSDOS that don't really multitask pwait
 101    is just a mechanism to provide a consistent interface for the caller.
 102
 103    pfinish: finish generation of script
 104
 105    pfinish is necessary for systems like MPW where a script is generated that
 106    runs the requested programs.
 107 */
 108
 109 #ifdef __MSDOS__
 110
 111 /* MSDOS doesn't multitask, but for the sake of a consistent interface
 112    the code behaves like it does.  pexecute runs the program, tucks the
 113    exit code away, and returns a "pid".  pwait must be called to fetch the
 114    exit code.  */
 115
 116 #include <process.h>
 117
 118 /* For communicating information from pexecute to pwait.  */
 119 static int last_pid = 0;
 120 static int last_status = 0;
 121 static int last_reaped = 0;
 122
 123 int
 124 pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
 125      const char *program;
 126      char * const *argv;
 127      const char *this_pname;
 128      const char *temp_base;
 129      char **errmsg_fmt, **errmsg_arg;
 130      int flags;
 131 {
 132   int rc;
 133
 134   last_pid++;
 135   if (last_pid < 0)
 136     last_pid = 1;
 137
 138   if ((flags & PEXECUTE_ONE) != PEXECUTE_ONE)
 139     abort ();
 140
 141 #ifdef __GO32__
 142   /* ??? What are the possible return values from spawnv?  */
 143   rc = (flags & PEXECUTE_SEARCH ? spawnvp : spawnv) (1, program, argv);
 144 #else
 145   char *scmd, *rf;
 146   FILE *argfile;
 147   int i, el = flags & PEXECUTE_SEARCH ? 4 : 0;
 148
 149   scmd = (char *) xmalloc (strlen (program) + strlen (temp_base) + 6 + el);
 150   rf = scmd + strlen(program) + 2 + el;
 151   sprintf (scmd, "%s%s @%s.gp", program,
 152            (flags & PEXECUTE_SEARCH ? ".exe" : ""), temp_base);
 153   argfile = fopen (rf, "w");
 154   if (argfile == 0)
 155     {
 156       int errno_save = errno;
 157       free (scmd);
 158       errno = errno_save;
 159       *errmsg_fmt = "cannot open `%s.gp'";
 160       *errmsg_arg = temp_base;
 161       return -1;
 162     }
 163
 164   for (i=1; argv[i]; i++)
 165     {
 166       char *cp;
 167       for (cp = argv[i]; *cp; cp++)
 168         {
 169           if (*cp == '"' || *cp == '\'' || *cp == '\\' || isspace (*cp))
 170             fputc ('\\', argfile);
 171           fputc (*cp, argfile);
 172         }
 173       fputc ('\n', argfile);
 174     }
 175   fclose (argfile);
 176
 177   rc = system (scmd);
 178
 179   {
 180     int errno_save = errno;
 181     remove (rf);
 182     free (scmd);
 183     errno = errno_save;
 184   }
 185 #endif
 186
 187   if (rc == -1)
 188     {
 189       *errmsg_fmt = install_error_msg;
 190       *errmsg_arg = program;
 191       return -1;
 192     }
 193
 194   /* Tuck the status away for pwait, and return a "pid".  */
 195   last_status = rc << 8;
 196   return last_pid;
 197 }
 198
 199 int
 200 pwait (pid, status, flags)
 201      int pid;
 202      int *status;
 203      int flags;
 204 {
 205   /* On MSDOS each pexecute must be followed by it's associated pwait.  */
 206   if (pid != last_pid
 207       /* Called twice for the same child?  */
 208       || pid == last_reaped)
 209     {
 210       /* ??? ECHILD would be a better choice.  Can we use it here?  */
 211       errno = EINVAL;
 212       return -1;
 213     }
 214   /* ??? Here's an opportunity to canonicalize the values in STATUS.
 215      Needed?  */
 216   *status = last_status;
 217   last_reaped = last_pid;
 218   return last_pid;
 219 }
 220
 221 #endif /* MSDOS */
 222
 223 #if defined (_WIN32)
 224
 225 #include <process.h>
 226 extern int _spawnv ();
 227 extern int _spawnvp ();
 228
 229 #ifdef __CYGWIN32__
 230
 231 #define fix_argv(argvec) (argvec)
 232
 233 #else
 234
 235 /* This is a kludge to get around the Microsoft C spawn functions' propensity
 236    to remove the outermost set of double quotes from all arguments.  */
 237
 238 const char * const *
 239 fix_argv (argvec)
 240      char **argvec;
 241 {
 242   int i;
 243
 244   for (i = 1; argvec[i] != 0; i++)
 245     {
 246       int len, j;
 247       char *temp, *newtemp;
 248
 249       temp = argvec[i];
 250       len = strlen (temp);
 251       for (j = 0; j < len; j++)
 252         {
 253           if (temp[j] == '"')
 254             {
 255               newtemp = (char *) xmalloc (len + 2);
 256               strncpy (newtemp, temp, j);
 257               newtemp [j] = '\\';
 258               strncpy (&newtemp [j+1], &temp [j], len-j);
 259               newtemp [len+1] = 0;
 260               temp = newtemp;
 261               len++;
 262               j++;
 263             }
 264         }
 265
 266         argvec[i] = temp;
 267       }
 268
 269   return (const char * const *) argvec;
 270 }
 271
 272 #endif /* ! defined (__CYGWIN32__) */
 273
 274 int
 275 pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
 276      const char *program;
 277      char * const *argv;
 278      const char *this_pname;
 279      const char *temp_base;
 280      char **errmsg_fmt, **errmsg_arg;
 281      int flags;
 282 {
 283   int pid;
 284
 285   if ((flags & PEXECUTE_ONE) != PEXECUTE_ONE)
 286     abort ();
 287   pid = (flags & PEXECUTE_SEARCH ? _spawnvp : _spawnv)
 288     (_P_NOWAIT, program, fix_argv(argv));
 289   if (pid == -1)
 290     {
 291       *errmsg_fmt = install_error_msg;
 292       *errmsg_arg = program;
 293       return -1;
 294     }
 295   return pid;
 296 }
 297
 298 int
 299 pwait (pid, status, flags)
 300      int pid;
 301      int *status;
 302      int flags;
 303 {
 304   /* ??? Here's an opportunity to canonicalize the values in STATUS.
 305      Needed?  */
 306   return _cwait (status, pid, WAIT_CHILD);
 307 }
 308
 309 #endif /* _WIN32 */
 310
 311 #ifdef OS2
 312
 313 /* ??? Does OS2 have process.h?  */
 314 extern int spawnv ();
 315 extern int spawnvp ();
 316
 317 int
 318 pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
 319      const char *program;
 320      char * const *argv;
 321      const char *this_pname;
 322      const char *temp_base;
 323      char **errmsg_fmt, **errmsg_arg;
 324      int flags;
 325 {
 326   int pid;
 327
 328   if ((flags & PEXECUTE_ONE) != PEXECUTE_ONE)
 329     abort ();
 330   /* ??? Presumably 1 == _P_NOWAIT.  */
 331   pid = (flags & PEXECUTE_SEARCH ? spawnvp : spawnv) (1, program, argv);
 332   if (pid == -1)
 333     {
 334       *errmsg_fmt = install_error_msg;
 335       *errmsg_arg = program;
 336       return -1;
 337     }
 338   return pid;
 339 }
 340
 341 int
 342 pwait (pid, status, flags)
 343      int pid;
 344      int *status;
 345      int flags;
 346 {
 347   /* ??? Here's an opportunity to canonicalize the values in STATUS.
 348      Needed?  */
 349   int pid = wait (status);
 350   return pid;
 351 }
 352
 353 #endif /* OS2 */
 354
 355 #ifdef MPW
 356
 357 /* MPW pexecute doesn't actually run anything; instead, it writes out
 358    script commands that, when run, will do the actual executing.
 359
 360    For example, in GCC's case, GCC will write out several script commands:
 361
 362    cpp ...
 363    cc1 ...
 364    as ...
 365    ld ...
 366
 367    and then exit.  None of the above programs will have run yet.  The task
 368    that called GCC will then execute the script and cause cpp,etc. to run.
 369    The caller must invoke pfinish before calling exit.  This adds
 370    the finishing touches to the generated script.  */
 371
 372 static int first_time = 1;
 373
 374 int
 375 pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
 376      const char *program;
 377      char * const *argv;
 378      const char *this_pname;
 379      const char *temp_base;
 380      char **errmsg_fmt, **errmsg_arg;
 381      int flags;
 382 {
 383   char tmpprogram[255];
 384   char *cp, *tmpname;
 385   int i;
 386
 387   mpwify_filename (program, tmpprogram);
 388   if (first_time)
 389     {
 390       printf ("Set Failed 0\n");
 391       first_time = 0;
 392     }
 393
 394   fputs ("If {Failed} == 0\n", stdout);
 395   /* If being verbose, output a copy of the command.  It should be
 396      accurate enough and escaped enough to be "clickable".  */
 397   if (flags & PEXECUTE_VERBOSE)
 398     {
 399       fputs ("\tEcho ", stdout);
 400       fputc ('\'', stdout);
 401       fputs (tmpprogram, stdout);
 402       fputc ('\'', stdout);
 403       fputc (' ', stdout);
 404       for (i=1; argv[i]; i++)
 405         {
 406           fputc ('\'', stdout);
 407           /* See if we have an argument that needs fixing.  */
 408           if (strchr(argv[i], '/'))
 409             {
 410               tmpname = (char *) xmalloc (256);
 411               mpwify_filename (argv[i], tmpname);
 412               argv[i] = tmpname;
 413             }
 414           for (cp = argv[i]; *cp; cp++)
 415             {
 416               /* Write an Option-d escape char in front of special chars.  */
 417               if (strchr("'+", *cp))
 418                 fputc ('\266', stdout);
 419               fputc (*cp, stdout);
 420             }
 421           fputc ('\'', stdout);
 422           fputc (' ', stdout);
 423         }
 424       fputs ("\n", stdout);
 425     }
 426   fputs ("\t", stdout);
 427   fputs (tmpprogram, stdout);
 428   fputc (' ', stdout);
 429
 430   for (i=1; argv[i]; i++)
 431     {
 432       /* See if we have an argument that needs fixing.  */
 433       if (strchr(argv[i], '/'))
 434         {
 435           tmpname = (char *) xmalloc (256);
 436           mpwify_filename (argv[i], tmpname);
 437           argv[i] = tmpname;
 438         }
 439       if (strchr (argv[i], ' '))
 440         fputc ('\'', stdout);
 441       for (cp = argv[i]; *cp; cp++)
 442         {
 443           /* Write an Option-d escape char in front of special chars.  */
 444           if (strchr("'+", *cp))
 445             fputc ('\266', stdout);
 446           fputc (*cp, stdout);
 447         }
 448       if (strchr (argv[i], ' '))
 449         fputc ('\'', stdout);
 450       fputc (' ', stdout);
 451     }
 452
 453   fputs ("\n", stdout);
 454
 455   /* Output commands that arrange to clean up and exit if a failure occurs.
 456      We have to be careful to collect the status from the program that was
 457      run, rather than some other script command.  Also, we don't exit
 458      immediately, since necessary cleanups are at the end of the script.  */
 459   fputs ("\tSet TmpStatus {Status}\n", stdout);
 460   fputs ("\tIf {TmpStatus} != 0\n", stdout);
 461   fputs ("\t\tSet Failed {TmpStatus}\n", stdout);
 462   fputs ("\tEnd\n", stdout);
 463   fputs ("End\n", stdout);
 464
 465   /* We're just composing a script, can't fail here.  */
 466   return 0;
 467 }
 468
 469 int
 470 pwait (pid, status, flags)
 471      int pid;
 472      int *status;
 473      int flags;
 474 {
 475   *status = 0;
 476   return 0;
 477 }
 478
 479 /* Write out commands that will exit with the correct error code
 480    if something in the script failed.  */
 481
 482 void
 483 pfinish ()
 484 {
 485   printf ("\tExit \"{Failed}\"\n");
 486 }
 487
 488 #endif /* MPW */
 489
 490 /* include for Unix-like environments but not for Dos-like environments */
 491 #if ! defined (__MSDOS__) && ! defined (OS2) && ! defined (MPW) \
 492     && ! defined (_WIN32)
 493
 494 #ifdef VMS
 495 #define vfork() (decc$$alloc_vfork_blocks() >= 0 ? \
 496                lib$get_current_invo_context(decc$$get_vfork_jmpbuf()) : -1)
 497 #else
 498 #ifdef USG
 499 #define vfork fork
 500 #endif
 501 #endif
 502
 503 extern int execv ();
 504 extern int execvp ();
 505
 506 int
 507 pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
 508      const char *program;
 509      char * const *argv;
 510      const char *this_pname;
 511      const char *temp_base;
 512      char **errmsg_fmt, **errmsg_arg;
 513      int flags;
 514 {
 515   int (*func)() = (flags & PEXECUTE_SEARCH ? execvp : execv);
 516   int pid;
 517   int pdes[2];
 518   int input_desc, output_desc;
 519   int retries, sleep_interval;
 520   /* Pipe waiting from last process, to be used as input for the next one.
 521      Value is STDIN_FILE_NO if no pipe is waiting
 522      (i.e. the next command is the first of a group).  */
 523   static int last_pipe_input;
 524
 525   /* If this is the first process, initialize.  */
 526   if (flags & PEXECUTE_FIRST)
 527     last_pipe_input = STDIN_FILE_NO;
 528
 529   input_desc = last_pipe_input;
 530
 531   /* If this isn't the last process, make a pipe for its output,
 532      and record it as waiting to be the input to the next process.  */
 533   if (! (flags & PEXECUTE_LAST))
 534     {
 535       if (pipe (pdes) < 0)
 536         {
 537           *errmsg_fmt = "pipe";
 538           *errmsg_arg = NULL;
 539           return -1;
 540         }
 541       output_desc = pdes[WRITE_PORT];
 542       last_pipe_input = pdes[READ_PORT];
 543     }
 544   else
 545     {
 546       /* Last process.  */
 547       output_desc = STDOUT_FILE_NO;
 548       last_pipe_input = STDIN_FILE_NO;
 549     }
 550
 551   /* Fork a subprocess; wait and retry if it fails.  */
 552   sleep_interval = 1;
 553   for (retries = 0; retries < 4; retries++)
 554     {
 555       pid = vfork ();
 556       if (pid >= 0)
 557         break;
 558       sleep (sleep_interval);
 559       sleep_interval *= 2;
 560     }
 561
 562   switch (pid)
 563     {
 564     case -1:
 565       {
 566 #ifdef vfork
 567         *errmsg_fmt = "fork";
 568 #else
 569         *errmsg_fmt = "vfork";
 570 #endif
 571         *errmsg_arg = NULL;
 572         return -1;
 573       }
 574
 575     case 0: /* child */
 576       /* Move the input and output pipes into place, if necessary.  */
 577       if (input_desc != STDIN_FILE_NO)
 578         {
 579           close (STDIN_FILE_NO);
 580           dup (input_desc);
 581           close (input_desc);
 582         }
 583       if (output_desc != STDOUT_FILE_NO)
 584         {
 585           close (STDOUT_FILE_NO);
 586           dup (output_desc);
 587           close (output_desc);
 588         }
 589
 590       /* Close the parent's descs that aren't wanted here.  */
 591       if (last_pipe_input != STDIN_FILE_NO)
 592         close (last_pipe_input);
 593
 594       /* Exec the program.  */
 595       (*func) (program, argv);
 596
 597       /* Note: Calling fprintf and exit here doesn't seem right for vfork.  */
 598       fprintf (stderr, "%s: ", this_pname);
 599       fprintf (stderr, install_error_msg, program);
 600 #ifdef IN_GCC
 601       fprintf (stderr, ": %s\n", my_strerror (errno));
 602 #else
 603       fprintf (stderr, ": %s\n", xstrerror (errno));
 604 #endif
 605       exit (-1);
 606       /* NOTREACHED */
 607       return 0;
 608
 609     default:
 610       /* In the parent, after forking.
 611          Close the descriptors that we made for this child.  */
 612       if (input_desc != STDIN_FILE_NO)
 613         close (input_desc);
 614       if (output_desc != STDOUT_FILE_NO)
 615         close (output_desc);
 616
 617       /* Return child's process number.  */
 618       return pid;
 619     }
 620 }
 621
 622 int
 623 pwait (pid, status, flags)
 624      int pid;
 625      int *status;
 626      int flags;
 627 {
 628   /* ??? Here's an opportunity to canonicalize the values in STATUS.
 629      Needed?  */
 630 #ifdef VMS
 631   pid = waitpid (-1, status, 0);
 632 #else
 633   pid = wait (status);
 634 #endif
 635   return pid;
 636 }
 637
 638 #endif /* ! __MSDOS__ && ! OS2 && ! MPW && ! _WIN32 */