merge from gcc
[external/binutils.git] / 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->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   if (obj->children != NULL)
627     free (obj->children);
628   if (obj->status != NULL)
629     free (obj->status);
630   if (obj->time != NULL)
631     free (obj->time);
632
633   if (obj->remove_count > 0)
634     {
635       int i;
636
637       for (i = 0; i < obj->remove_count; ++i)
638         {
639           remove (obj->remove[i]);
640           free (obj->remove[i]);
641         }
642       free (obj->remove);
643     }
644
645   if (obj->funcs->cleanup != NULL)
646     obj->funcs->cleanup (obj);
647
648   free (obj);
649 }