merge from gcc
[external/binutils.git] / libiberty / 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-2000 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 HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29
30 #include <stdio.h>
31 #include <errno.h>
32 #ifdef NEED_DECLARATION_ERRNO
33 extern int errno;
34 #endif
35 #ifdef HAVE_STRING_H
36 #include <string.h>
37 #endif
38 #ifdef HAVE_UNISTD_H
39 #include <unistd.h>
40 #endif
41 #ifdef HAVE_STDLIB_H
42 #include <stdlib.h>
43 #endif
44 #ifdef HAVE_SYS_WAIT_H
45 #include <sys/wait.h>
46 #endif
47
48 #include "libiberty.h"
49 #include "safe-ctype.h"
50
51 /* stdin file number.  */
52 #define STDIN_FILE_NO 0
53
54 /* stdout file number.  */
55 #define STDOUT_FILE_NO 1
56
57 /* value of `pipe': port index for reading.  */
58 #define READ_PORT 0
59
60 /* value of `pipe': port index for writing.  */
61 #define WRITE_PORT 1
62
63 static char *install_error_msg = "installation problem, cannot exec `%s'";
64
65 /* pexecute: execute a program.
66
67    PROGRAM and ARGV are the arguments to execv/execvp.
68
69    THIS_PNAME is name of the calling program (i.e. argv[0]).
70
71    TEMP_BASE is the path name, sans suffix, of a temporary file to use
72    if needed.  This is currently only needed for MSDOS ports that don't use
73    GO32 (do any still exist?).  Ports that don't need it can pass NULL.
74
75    (FLAGS & PEXECUTE_SEARCH) is non-zero if $PATH should be searched
76    (??? It's not clear that GCC passes this flag correctly).
77    (FLAGS & PEXECUTE_FIRST) is nonzero for the first process in chain.
78    (FLAGS & PEXECUTE_FIRST) is nonzero for the last process in chain.
79    FIRST_LAST could be simplified to only mark the last of a chain of processes
80    but that requires the caller to always mark the last one (and not give up
81    early if some error occurs).  It's more robust to require the caller to
82    mark both ends of the chain.
83
84    The result is the pid on systems like Unix where we fork/exec and on systems
85    like WIN32 and OS2 where we use spawn.  It is up to the caller to wait for
86    the child.
87
88    The result is the WEXITSTATUS on systems like MSDOS where we spawn and wait
89    for the child here.
90
91    Upon failure, ERRMSG_FMT and ERRMSG_ARG are set to the text of the error
92    message with an optional argument (if not needed, ERRMSG_ARG is set to
93    NULL), and -1 is returned.  `errno' is available to the caller to use.
94
95    pwait: cover function for wait.
96
97    PID is the process id of the task to wait for.
98    STATUS is the `status' argument to wait.
99    FLAGS is currently unused (allows future enhancement without breaking
100    upward compatibility).  Pass 0 for now.
101
102    The result is the pid of the child reaped,
103    or -1 for failure (errno says why).
104
105    On systems that don't support waiting for a particular child, PID is
106    ignored.  On systems like MSDOS that don't really multitask pwait
107    is just a mechanism to provide a consistent interface for the caller.
108
109    pfinish: finish generation of script
110
111    pfinish is necessary for systems like MPW where a script is generated that
112    runs the requested programs.
113 */
114
115 #ifdef __MSDOS__
116
117 /* MSDOS doesn't multitask, but for the sake of a consistent interface
118    the code behaves like it does.  pexecute runs the program, tucks the
119    exit code away, and returns a "pid".  pwait must be called to fetch the
120    exit code.  */
121
122 #include <process.h>
123
124 /* For communicating information from pexecute to pwait.  */
125 static int last_pid = 0;
126 static int last_status = 0;
127 static int last_reaped = 0;
128
129 int
130 pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
131      const char *program;
132      char * const *argv;
133      const char *this_pname;
134      const char *temp_base;
135      char **errmsg_fmt, **errmsg_arg;
136      int flags;
137 {
138   int rc;
139
140   last_pid++;
141   if (last_pid < 0)
142     last_pid = 1;
143
144   if ((flags & PEXECUTE_ONE) != PEXECUTE_ONE)
145     abort ();
146
147 #ifdef __DJGPP__
148   /* ??? What are the possible return values from spawnv?  */
149   rc = (flags & PEXECUTE_SEARCH ? spawnvp : spawnv) (P_WAIT, program, argv);
150 #else
151   char *scmd, *rf;
152   FILE *argfile;
153   int i, el = flags & PEXECUTE_SEARCH ? 4 : 0;
154
155   if (temp_base == 0)
156     temp_base = choose_temp_base ();
157   scmd = (char *) xmalloc (strlen (program) + strlen (temp_base) + 6 + el);
158   rf = scmd + strlen(program) + 2 + el;
159   sprintf (scmd, "%s%s @%s.gp", program,
160            (flags & PEXECUTE_SEARCH ? ".exe" : ""), temp_base);
161   argfile = fopen (rf, "w");
162   if (argfile == 0)
163     {
164       int errno_save = errno;
165       free (scmd);
166       errno = errno_save;
167       *errmsg_fmt = "cannot open `%s.gp'";
168       *errmsg_arg = temp_base;
169       return -1;
170     }
171
172   for (i=1; argv[i]; i++)
173     {
174       char *cp;
175       for (cp = argv[i]; *cp; cp++)
176         {
177           if (*cp == '"' || *cp == '\'' || *cp == '\\' || ISSPACE (*cp))
178             fputc ('\\', argfile);
179           fputc (*cp, argfile);
180         }
181       fputc ('\n', argfile);
182     }
183   fclose (argfile);
184
185   rc = system (scmd);
186
187   {
188     int errno_save = errno;
189     remove (rf);
190     free (scmd);
191     errno = errno_save;
192   }
193 #endif
194
195   if (rc == -1)
196     {
197       *errmsg_fmt = install_error_msg;
198       *errmsg_arg = (char *)program;
199       return -1;
200     }
201
202   /* Tuck the status away for pwait, and return a "pid".  */
203   last_status = rc << 8;
204   return last_pid;
205 }
206
207 /* Use ECHILD if available, otherwise use EINVAL.  */
208 #ifdef ECHILD
209 #define PWAIT_ERROR ECHILD
210 #else
211 #define PWAIT_ERROR EINVAL
212 #endif
213
214 int
215 pwait (pid, status, flags)
216      int pid;
217      int *status;
218      int flags;
219 {
220   /* On MSDOS each pexecute must be followed by it's associated pwait.  */
221   if (pid != last_pid
222       /* Called twice for the same child?  */
223       || pid == last_reaped)
224     {
225       errno = PWAIT_ERROR;
226       return -1;
227     }
228   /* ??? Here's an opportunity to canonicalize the values in STATUS.
229      Needed?  */
230 #ifdef __DJGPP__
231   *status = (last_status >> 8);
232 #else
233   *status = last_status;
234 #endif
235   last_reaped = last_pid;
236   return last_pid;
237 }
238
239 #endif /* MSDOS */
240
241 #if defined (_WIN32) && ! defined (_UWIN)
242
243 #include <process.h>
244
245 #ifdef __CYGWIN__
246
247 #define fix_argv(argvec) (argvec)
248
249 extern int _spawnv ();
250 extern int _spawnvp ();
251
252 #else /* ! __CYGWIN__ */
253
254 /* This is a kludge to get around the Microsoft C spawn functions' propensity
255    to remove the outermost set of double quotes from all arguments.  */
256
257 const char * const *
258 fix_argv (argvec)
259      char **argvec;
260 {
261   int i;
262
263   for (i = 1; argvec[i] != 0; i++)
264     {
265       int len, j;
266       char *temp, *newtemp;
267
268       temp = argvec[i];
269       len = strlen (temp);
270       for (j = 0; j < len; j++)
271         {
272           if (temp[j] == '"')
273             {
274               newtemp = xmalloc (len + 2);
275               strncpy (newtemp, temp, j);
276               newtemp [j] = '\\';
277               strncpy (&newtemp [j+1], &temp [j], len-j);
278               newtemp [len+1] = 0;
279               temp = newtemp;
280               len++;
281               j++;
282             }
283         }
284
285         argvec[i] = temp;
286       }
287
288   for (i = 0; argvec[i] != 0; i++)
289     {
290       if (strpbrk (argvec[i], " \t"))
291         {
292           int len, trailing_backslash;
293           char *temp;
294
295           len = strlen (argvec[i]);
296           trailing_backslash = 0;
297
298           /* There is an added complication when an arg with embedded white
299              space ends in a backslash (such as in the case of -iprefix arg
300              passed to cpp). The resulting quoted strings gets misinterpreted
301              by the command interpreter -- it thinks that the ending quote
302              is escaped by the trailing backslash and things get confused. 
303              We handle this case by escaping the trailing backslash, provided
304              it was not escaped in the first place.  */
305           if (len > 1 
306               && argvec[i][len-1] == '\\' 
307               && argvec[i][len-2] != '\\')
308             {
309               trailing_backslash = 1;
310               ++len;                    /* to escape the final backslash. */
311             }
312
313           len += 2;                     /* and for the enclosing quotes. */
314
315           temp = xmalloc (len + 1);
316           temp[0] = '"';
317           strcpy (temp + 1, argvec[i]);
318           if (trailing_backslash)
319             temp[len-2] = '\\';
320           temp[len-1] = '"';
321           temp[len] = '\0';
322
323           argvec[i] = temp;
324         }
325     }
326
327   return (const char * const *) argvec;
328 }
329 #endif /* __CYGWIN__ */
330
331 #include <io.h>
332 #include <fcntl.h>
333 #include <signal.h>
334
335 /* mingw32 headers may not define the following.  */
336
337 #ifndef _P_WAIT
338 #  define _P_WAIT       0
339 #  define _P_NOWAIT     1
340 #  define _P_OVERLAY    2
341 #  define _P_NOWAITO    3
342 #  define _P_DETACH     4
343
344 #  define WAIT_CHILD    0
345 #  define WAIT_GRANDCHILD       1
346 #endif
347
348 /* Win32 supports pipes */
349 int
350 pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
351      const char *program;
352      char * const *argv;
353      const char *this_pname;
354      const char *temp_base;
355      char **errmsg_fmt, **errmsg_arg;
356      int flags;
357 {
358   int pid;
359   int pdes[2], org_stdin, org_stdout;
360   int input_desc, output_desc;
361   int retries, sleep_interval;
362
363   /* Pipe waiting from last process, to be used as input for the next one.
364      Value is STDIN_FILE_NO if no pipe is waiting
365      (i.e. the next command is the first of a group).  */
366   static int last_pipe_input;
367
368   /* If this is the first process, initialize.  */
369   if (flags & PEXECUTE_FIRST)
370     last_pipe_input = STDIN_FILE_NO;
371
372   input_desc = last_pipe_input;
373
374   /* If this isn't the last process, make a pipe for its output,
375      and record it as waiting to be the input to the next process.  */
376   if (! (flags & PEXECUTE_LAST))
377     {
378       if (_pipe (pdes, 256, O_BINARY) < 0)
379         {
380           *errmsg_fmt = "pipe";
381           *errmsg_arg = NULL;
382           return -1;
383         }
384       output_desc = pdes[WRITE_PORT];
385       last_pipe_input = pdes[READ_PORT];
386     }
387   else
388     {
389       /* Last process.  */
390       output_desc = STDOUT_FILE_NO;
391       last_pipe_input = STDIN_FILE_NO;
392     }
393
394   if (input_desc != STDIN_FILE_NO)
395     {
396       org_stdin = dup (STDIN_FILE_NO);
397       dup2 (input_desc, STDIN_FILE_NO);
398       close (input_desc); 
399     }
400
401   if (output_desc != STDOUT_FILE_NO)
402     {
403       org_stdout = dup (STDOUT_FILE_NO);
404       dup2 (output_desc, STDOUT_FILE_NO);
405       close (output_desc);
406     }
407
408   pid = (flags & PEXECUTE_SEARCH ? _spawnvp : _spawnv)
409     (_P_NOWAIT, program, fix_argv(argv));
410
411   if (input_desc != STDIN_FILE_NO)
412     {
413       dup2 (org_stdin, STDIN_FILE_NO);
414       close (org_stdin);
415     }
416
417   if (output_desc != STDOUT_FILE_NO)
418     {
419       dup2 (org_stdout, STDOUT_FILE_NO);
420       close (org_stdout);
421     }
422
423   if (pid == -1)
424     {
425       *errmsg_fmt = install_error_msg;
426       *errmsg_arg = program;
427       return -1;
428     }
429
430   return pid;
431 }
432
433 /* MS CRTDLL doesn't return enough information in status to decide if the
434    child exited due to a signal or not, rather it simply returns an
435    integer with the exit code of the child; eg., if the child exited with 
436    an abort() call and didn't have a handler for SIGABRT, it simply returns
437    with status = 3. We fix the status code to conform to the usual WIF*
438    macros. Note that WIFSIGNALED will never be true under CRTDLL. */
439
440 int
441 pwait (pid, status, flags)
442      int pid;
443      int *status;
444      int flags;
445 {
446 #ifdef __CYGWIN__
447   return wait (status);
448 #else
449   int termstat;
450
451   pid = _cwait (&termstat, pid, WAIT_CHILD);
452
453   /* ??? Here's an opportunity to canonicalize the values in STATUS.
454      Needed?  */
455
456   /* cwait returns the child process exit code in termstat.
457      A value of 3 indicates that the child caught a signal, but not
458      which one.  Since only SIGABRT, SIGFPE and SIGINT do anything, we
459      report SIGABRT.  */
460   if (termstat == 3)
461     *status = SIGABRT;
462   else
463     *status = (((termstat) & 0xff) << 8);
464
465   return pid;
466 #endif /* __CYGWIN__ */
467 }
468
469 #endif /* _WIN32 && ! _UWIN */
470
471 #ifdef OS2
472
473 /* ??? Does OS2 have process.h?  */
474 extern int spawnv ();
475 extern int spawnvp ();
476
477 int
478 pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
479      const char *program;
480      char * const *argv;
481      const char *this_pname;
482      const char *temp_base;
483      char **errmsg_fmt, **errmsg_arg;
484      int flags;
485 {
486   int pid;
487
488   if ((flags & PEXECUTE_ONE) != PEXECUTE_ONE)
489     abort ();
490   /* ??? Presumably 1 == _P_NOWAIT.  */
491   pid = (flags & PEXECUTE_SEARCH ? spawnvp : spawnv) (1, program, argv);
492   if (pid == -1)
493     {
494       *errmsg_fmt = install_error_msg;
495       *errmsg_arg = program;
496       return -1;
497     }
498   return pid;
499 }
500
501 int
502 pwait (pid, status, flags)
503      int pid;
504      int *status;
505      int flags;
506 {
507   /* ??? Here's an opportunity to canonicalize the values in STATUS.
508      Needed?  */
509   int pid = wait (status);
510   return pid;
511 }
512
513 #endif /* OS2 */
514
515 #ifdef MPW
516
517 /* MPW pexecute doesn't actually run anything; instead, it writes out
518    script commands that, when run, will do the actual executing.
519
520    For example, in GCC's case, GCC will write out several script commands:
521
522    cpp ...
523    cc1 ...
524    as ...
525    ld ...
526
527    and then exit.  None of the above programs will have run yet.  The task
528    that called GCC will then execute the script and cause cpp,etc. to run.
529    The caller must invoke pfinish before calling exit.  This adds
530    the finishing touches to the generated script.  */
531
532 static int first_time = 1;
533
534 int
535 pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
536      const char *program;
537      char * const *argv;
538      const char *this_pname;
539      const char *temp_base;
540      char **errmsg_fmt, **errmsg_arg;
541      int flags;
542 {
543   char tmpprogram[255];
544   char *cp, *tmpname;
545   int i;
546
547   mpwify_filename (program, tmpprogram);
548   if (first_time)
549     {
550       printf ("Set Failed 0\n");
551       first_time = 0;
552     }
553
554   fputs ("If {Failed} == 0\n", stdout);
555   /* If being verbose, output a copy of the command.  It should be
556      accurate enough and escaped enough to be "clickable".  */
557   if (flags & PEXECUTE_VERBOSE)
558     {
559       fputs ("\tEcho ", stdout);
560       fputc ('\'', stdout);
561       fputs (tmpprogram, stdout);
562       fputc ('\'', stdout);
563       fputc (' ', stdout);
564       for (i=1; argv[i]; i++)
565         {
566           fputc ('\'', stdout);
567           /* See if we have an argument that needs fixing.  */
568           if (strchr(argv[i], '/'))
569             {
570               tmpname = (char *) xmalloc (256);
571               mpwify_filename (argv[i], tmpname);
572               argv[i] = tmpname;
573             }
574           for (cp = argv[i]; *cp; cp++)
575             {
576               /* Write an Option-d escape char in front of special chars.  */
577               if (strchr("'+", *cp))
578                 fputc ('\266', stdout);
579               fputc (*cp, stdout);
580             }
581           fputc ('\'', stdout);
582           fputc (' ', stdout);
583         }
584       fputs ("\n", stdout);
585     }
586   fputs ("\t", stdout);
587   fputs (tmpprogram, stdout);
588   fputc (' ', stdout);
589
590   for (i=1; argv[i]; i++)
591     {
592       /* See if we have an argument that needs fixing.  */
593       if (strchr(argv[i], '/'))
594         {
595           tmpname = (char *) xmalloc (256);
596           mpwify_filename (argv[i], tmpname);
597           argv[i] = tmpname;
598         }
599       if (strchr (argv[i], ' '))
600         fputc ('\'', stdout);
601       for (cp = argv[i]; *cp; cp++)
602         {
603           /* Write an Option-d escape char in front of special chars.  */
604           if (strchr("'+", *cp))
605             fputc ('\266', stdout);
606           fputc (*cp, stdout);
607         }
608       if (strchr (argv[i], ' '))
609         fputc ('\'', stdout);
610       fputc (' ', stdout);
611     }
612
613   fputs ("\n", stdout);
614
615   /* Output commands that arrange to clean up and exit if a failure occurs.
616      We have to be careful to collect the status from the program that was
617      run, rather than some other script command.  Also, we don't exit
618      immediately, since necessary cleanups are at the end of the script.  */
619   fputs ("\tSet TmpStatus {Status}\n", stdout);
620   fputs ("\tIf {TmpStatus} != 0\n", stdout);
621   fputs ("\t\tSet Failed {TmpStatus}\n", stdout);
622   fputs ("\tEnd\n", stdout);
623   fputs ("End\n", stdout);
624
625   /* We're just composing a script, can't fail here.  */
626   return 0;
627 }
628
629 int
630 pwait (pid, status, flags)
631      int pid;
632      int *status;
633      int flags;
634 {
635   *status = 0;
636   return 0;
637 }
638
639 /* Write out commands that will exit with the correct error code
640    if something in the script failed.  */
641
642 void
643 pfinish ()
644 {
645   printf ("\tExit \"{Failed}\"\n");
646 }
647
648 #endif /* MPW */
649
650 /* include for Unix-like environments but not for Dos-like environments */
651 #if ! defined (__MSDOS__) && ! defined (OS2) && ! defined (MPW) \
652     && ! (defined (_WIN32) && ! defined (_UWIN))
653
654 extern int execv ();
655 extern int execvp ();
656
657 int
658 pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
659      const char *program;
660      char * const *argv;
661      const char *this_pname;
662      const char *temp_base ATTRIBUTE_UNUSED;
663      char **errmsg_fmt, **errmsg_arg;
664      int flags;
665 {
666   int (*func)() = (flags & PEXECUTE_SEARCH ? execvp : execv);
667   int pid;
668   int pdes[2];
669   int input_desc, output_desc;
670   int retries, sleep_interval;
671   /* Pipe waiting from last process, to be used as input for the next one.
672      Value is STDIN_FILE_NO if no pipe is waiting
673      (i.e. the next command is the first of a group).  */
674   static int last_pipe_input;
675
676   /* If this is the first process, initialize.  */
677   if (flags & PEXECUTE_FIRST)
678     last_pipe_input = STDIN_FILE_NO;
679
680   input_desc = last_pipe_input;
681
682   /* If this isn't the last process, make a pipe for its output,
683      and record it as waiting to be the input to the next process.  */
684   if (! (flags & PEXECUTE_LAST))
685     {
686       if (pipe (pdes) < 0)
687         {
688           *errmsg_fmt = "pipe";
689           *errmsg_arg = NULL;
690           return -1;
691         }
692       output_desc = pdes[WRITE_PORT];
693       last_pipe_input = pdes[READ_PORT];
694     }
695   else
696     {
697       /* Last process.  */
698       output_desc = STDOUT_FILE_NO;
699       last_pipe_input = STDIN_FILE_NO;
700     }
701
702   /* Fork a subprocess; wait and retry if it fails.  */
703   sleep_interval = 1;
704   pid = -1;
705   for (retries = 0; retries < 4; retries++)
706     {
707       pid = fork ();
708       if (pid >= 0)
709         break;
710       sleep (sleep_interval);
711       sleep_interval *= 2;
712     }
713
714   switch (pid)
715     {
716     case -1:
717       *errmsg_fmt = "fork";
718       *errmsg_arg = NULL;
719       return -1;
720
721     case 0: /* child */
722       /* Move the input and output pipes into place, if necessary.  */
723       if (input_desc != STDIN_FILE_NO)
724         {
725           close (STDIN_FILE_NO);
726           dup (input_desc);
727           close (input_desc);
728         }
729       if (output_desc != STDOUT_FILE_NO)
730         {
731           close (STDOUT_FILE_NO);
732           dup (output_desc);
733           close (output_desc);
734         }
735
736       /* Close the parent's descs that aren't wanted here.  */
737       if (last_pipe_input != STDIN_FILE_NO)
738         close (last_pipe_input);
739
740       /* Exec the program.  */
741       (*func) (program, argv);
742
743       fprintf (stderr, "%s: ", this_pname);
744       fprintf (stderr, install_error_msg, program);
745       fprintf (stderr, ": %s\n", xstrerror (errno));
746       exit (-1);
747       /* NOTREACHED */
748       return 0;
749
750     default:
751       /* In the parent, after forking.
752          Close the descriptors that we made for this child.  */
753       if (input_desc != STDIN_FILE_NO)
754         close (input_desc);
755       if (output_desc != STDOUT_FILE_NO)
756         close (output_desc);
757
758       /* Return child's process number.  */
759       return pid;
760     }
761 }
762
763 int
764 pwait (pid, status, flags)
765      int pid;
766      int *status;
767      int flags ATTRIBUTE_UNUSED;
768 {
769   /* ??? Here's an opportunity to canonicalize the values in STATUS.
770      Needed?  */
771 #ifdef VMS
772   pid = waitpid (-1, status, 0);
773 #else
774   pid = wait (status);
775 #endif
776   return pid;
777 }
778
779 #endif /* ! __MSDOS__ && ! OS2 && ! MPW && ! (_WIN32 && ! _UWIN) */