Mercurial > hg > CbC > CbC_gcc

comparison libiberty/pex-common.c @ 0:a06113de4d67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first commit
author kent <kent@cr.ie.u-ryukyu.ac.jp>
date Fri, 17 Jul 2009 14:47:48 +0900
parents
children 77e2b8dfacca
comparison
equal deleted inserted replaced
-1:000000000000 0:a06113de4d67
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 long 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 (long, 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 return obj->read_err;
509 }
510
511 /* Get the exit status and, if requested, the resource time for all
512 the child processes. Return 0 on failure, 1 on success. */
513
514 static int
515 pex_get_status_and_time (struct pex_obj *obj, int done, const char **errmsg,
516 int *err)
517 {
518 int ret;
519 int i;
520
521 if (obj->number_waited == obj->count)
522 return 1;
523
524 obj->status = XRESIZEVEC (int, obj->status, obj->count);
525 if ((obj->flags & PEX_RECORD_TIMES) != 0)
526 obj->time = XRESIZEVEC (struct pex_time, obj->time, obj->count);
527
528 ret = 1;
529 for (i = obj->number_waited; i < obj->count; ++i)
530 {
531 if (obj->funcs->wait (obj, obj->children[i], &obj->status[i],
532 obj->time == NULL ? NULL : &obj->time[i],
533 done, errmsg, err) < 0)
534 ret = 0;
535 }
536 obj->number_waited = i;
537
538 return ret;
539 }
540
541 /* Get exit status of executed programs. */
542
543 int
544 pex_get_status (struct pex_obj *obj, int count, int *vector)
545 {
546 if (obj->status == NULL)
547 {
548 const char *errmsg;
549 int err;
550
551 if (!pex_get_status_and_time (obj, 0, &errmsg, &err))
552 return 0;
553 }
554
555 if (count > obj->count)
556 {
557 memset (vector + obj->count, 0, (count - obj->count) * sizeof (int));
558 count = obj->count;
559 }
560
561 memcpy (vector, obj->status, count * sizeof (int));
562
563 return 1;
564 }
565
566 /* Get process times of executed programs. */
567
568 int
569 pex_get_times (struct pex_obj *obj, int count, struct pex_time *vector)
570 {
571 if (obj->status == NULL)
572 {
573 const char *errmsg;
574 int err;
575
576 if (!pex_get_status_and_time (obj, 0, &errmsg, &err))
577 return 0;
578 }
579
580 if (obj->time == NULL)
581 return 0;
582
583 if (count > obj->count)
584 {
585 memset (vector + obj->count, 0,
586 (count - obj->count) * sizeof (struct pex_time));
587 count = obj->count;
588 }
589
590 memcpy (vector, obj->time, count * sizeof (struct pex_time));
591
592 return 1;
593 }
594
595 /* Free a pex_obj structure. */
596
597 void
598 pex_free (struct pex_obj *obj)
599 {
600 if (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO)
601 obj->funcs->close (obj, obj->next_input);
602
603 /* If the caller forgot to wait for the children, we do it here, to
604 avoid zombies. */
605 if (obj->status == NULL)
606 {
607 const char *errmsg;
608 int err;
609
610 obj->flags &= ~ PEX_RECORD_TIMES;
611 pex_get_status_and_time (obj, 1, &errmsg, &err);
612 }
613
614 if (obj->next_input_name_allocated)
615 free (obj->next_input_name);
616 if (obj->children != NULL)
617 free (obj->children);
618 if (obj->status != NULL)
619 free (obj->status);
620 if (obj->time != NULL)
621 free (obj->time);
622 if (obj->read_output != NULL)
623 fclose (obj->read_output);
624 if (obj->read_err != NULL)
625 fclose (obj->read_err);
626
627 if (obj->remove_count > 0)
628 {
629 int i;
630
631 for (i = 0; i < obj->remove_count; ++i)
632 {
633 remove (obj->remove[i]);
634 free (obj->remove[i]);
635 }
636 free (obj->remove);
637 }
638
639 if (obj->funcs->cleanup != NULL)
640 obj->funcs->cleanup (obj);
641
642 free (obj);
643 }