|
0
|
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 }
|
