1 /* Common code for executing a program in a sub-process. 2 Copyright (C) 2005, 2010 Free Software Foundation, Inc. 3 Written by Ian Lance Taylor <ian (at) 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 (flags & PEX_STDOUT_APPEND) != 0); 272 if (out < 0) 273 { 274 *err = errno; 275 errmsg = "open temporary output file"; 276 goto error_exit; 277 } 278 } 279 280 if (outname_allocated) 281 { 282 free (outname); 283 outname_allocated = 0; 284 } 285 286 /* Set ERRDES. */ 287 288 if (errname != NULL && (flags & PEX_STDERR_TO_PIPE) != 0) 289 { 290 *err = 0; 291 errmsg = "both ERRNAME and PEX_STDERR_TO_PIPE specified."; 292 goto error_exit; 293 } 294 295 if (obj->stderr_pipe != -1) 296 { 297 *err = 0; 298 errmsg = "PEX_STDERR_TO_PIPE used in the middle of pipeline"; 299 goto error_exit; 300 } 301 302 if (errname == NULL) 303 { 304 if (flags & PEX_STDERR_TO_PIPE) 305 { 306 if (obj->funcs->pipe (obj, p, (flags & PEX_BINARY_ERROR) != 0) < 0) 307 { 308 *err = errno; 309 errmsg = "pipe"; 310 goto error_exit; 311 } 312 313 errdes = p[WRITE_PORT]; 314 obj->stderr_pipe = p[READ_PORT]; 315 } 316 else 317 { 318 errdes = STDERR_FILE_NO; 319 } 320 } 321 else 322 { 323 errdes = obj->funcs->open_write (obj, errname, 324 (flags & PEX_BINARY_ERROR) != 0, 325 (flags & PEX_STDERR_APPEND) != 0); 326 if (errdes < 0) 327 { 328 *err = errno; 329 errmsg = "open error file"; 330 goto error_exit; 331 } 332 } 333 334 /* If we are using pipes, the child process has to close the next 335 input pipe. */ 336 337 if ((obj->flags & PEX_USE_PIPES) == 0) 338 toclose = -1; 339 else 340 toclose = obj->next_input; 341 342 /* Run the program. */ 343 344 pid = obj->funcs->exec_child (obj, flags, executable, argv, env, 345 in, out, errdes, toclose, &errmsg, err); 346 if (pid < 0) 347 goto error_exit; 348 349 ++obj->count; 350 obj->children = XRESIZEVEC (pid_t, obj->children, obj->count); 351 obj->children[obj->count - 1] = pid; 352 353 return NULL; 354 355 error_exit: 356 if (in >= 0 && in != STDIN_FILE_NO) 357 obj->funcs->close (obj, in); 358 if (out >= 0 && out != STDOUT_FILE_NO) 359 obj->funcs->close (obj, out); 360 if (errdes >= 0 && errdes != STDERR_FILE_NO) 361 obj->funcs->close (obj, errdes); 362 if (outname_allocated) 363 free (outname); 364 return errmsg; 365 } 366 367 /* Run a program. */ 368 369 const char * 370 pex_run (struct pex_obj *obj, int flags, const char *executable, 371 char * const * argv, const char *orig_outname, const char *errname, 372 int *err) 373 { 374 return pex_run_in_environment (obj, flags, executable, argv, NULL, 375 orig_outname, errname, err); 376 } 377 378 /* Return a FILE pointer for a temporary file to fill with input for 379 the pipeline. */ 380 FILE * 381 pex_input_file (struct pex_obj *obj, int flags, const char *in_name) 382 { 383 char *name = (char *) in_name; 384 FILE *f; 385 386 /* This must be called before the first pipeline stage is run, and 387 there must not have been any other input selected. */ 388 if (obj->count != 0 389 || (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO) 390 || obj->next_input_name) 391 { 392 errno = EINVAL; 393 return NULL; 394 } 395 396 name = temp_file (obj, flags, name); 397 if (! name) 398 return NULL; 399 400 f = fopen (name, (flags & PEX_BINARY_OUTPUT) ? "wb" : "w"); 401 if (! f) 402 { 403 free (name); 404 return NULL; 405 } 406 407 obj->input_file = f; 408 obj->next_input_name = name; 409 obj->next_input_name_allocated = (name != in_name); 410 411 return f; 412 } 413 414 /* Return a stream for a pipe connected to the standard input of the 415 first stage of the pipeline. */ 416 FILE * 417 pex_input_pipe (struct pex_obj *obj, int binary) 418 { 419 int p[2]; 420 FILE *f; 421 422 /* You must call pex_input_pipe before the first pex_run or pex_one. */ 423 if (obj->count > 0) 424 goto usage_error; 425 426 /* You must be using pipes. Implementations that don't support 427 pipes clear this flag before calling pex_init_common. */ 428 if (! (obj->flags & PEX_USE_PIPES)) 429 goto usage_error; 430 431 /* If we have somehow already selected other input, that's a 432 mistake. */ 433 if ((obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO) 434 || obj->next_input_name) 435 goto usage_error; 436 437 if (obj->funcs->pipe (obj, p, binary != 0) < 0) 438 return NULL; 439 440 f = obj->funcs->fdopenw (obj, p[WRITE_PORT], binary != 0); 441 if (! f) 442 { 443 int saved_errno = errno; 444 obj->funcs->close (obj, p[READ_PORT]); 445 obj->funcs->close (obj, p[WRITE_PORT]); 446 errno = saved_errno; 447 return NULL; 448 } 449 450 obj->next_input = p[READ_PORT]; 451 452 return f; 453 454 usage_error: 455 errno = EINVAL; 456 return NULL; 457 } 458 459 /* Return a FILE pointer for the output of the last program 460 executed. */ 461 462 FILE * 463 pex_read_output (struct pex_obj *obj, int binary) 464 { 465 if (obj->next_input_name != NULL) 466 { 467 const char *errmsg; 468 int err; 469 470 /* We have to make sure that the process has completed before we 471 try to read the file. */ 472 if (!pex_get_status_and_time (obj, 0, &errmsg, &err)) 473 { 474 errno = err; 475 return NULL; 476 } 477 478 obj->read_output = fopen (obj->next_input_name, binary ? "rb" : "r"); 479 480 if (obj->next_input_name_allocated) 481 { 482 free (obj->next_input_name); 483 obj->next_input_name_allocated = 0; 484 } 485 obj->next_input_name = NULL; 486 } 487 else 488 { 489 int o; 490 491 o = obj->next_input; 492 if (o < 0 || o == STDIN_FILE_NO) 493 return NULL; 494 obj->read_output = obj->funcs->fdopenr (obj, o, binary); 495 obj->next_input = -1; 496 } 497 498 return obj->read_output; 499 } 500 501 FILE * 502 pex_read_err (struct pex_obj *obj, int binary) 503 { 504 int o; 505 506 o = obj->stderr_pipe; 507 if (o < 0 || o == STDIN_FILE_NO) 508 return NULL; 509 obj->read_err = obj->funcs->fdopenr (obj, o, binary); 510 obj->stderr_pipe = -1; 511 return obj->read_err; 512 } 513 514 /* Get the exit status and, if requested, the resource time for all 515 the child processes. Return 0 on failure, 1 on success. */ 516 517 static int 518 pex_get_status_and_time (struct pex_obj *obj, int done, const char **errmsg, 519 int *err) 520 { 521 int ret; 522 int i; 523 524 if (obj->number_waited == obj->count) 525 return 1; 526 527 obj->status = XRESIZEVEC (int, obj->status, obj->count); 528 if ((obj->flags & PEX_RECORD_TIMES) != 0) 529 obj->time = XRESIZEVEC (struct pex_time, obj->time, obj->count); 530 531 ret = 1; 532 for (i = obj->number_waited; i < obj->count; ++i) 533 { 534 if (obj->funcs->wait (obj, obj->children[i], &obj->status[i], 535 obj->time == NULL ? NULL : &obj->time[i], 536 done, errmsg, err) < 0) 537 ret = 0; 538 } 539 obj->number_waited = i; 540 541 return ret; 542 } 543 544 /* Get exit status of executed programs. */ 545 546 int 547 pex_get_status (struct pex_obj *obj, int count, int *vector) 548 { 549 if (obj->status == NULL) 550 { 551 const char *errmsg; 552 int err; 553 554 if (!pex_get_status_and_time (obj, 0, &errmsg, &err)) 555 return 0; 556 } 557 558 if (count > obj->count) 559 { 560 memset (vector + obj->count, 0, (count - obj->count) * sizeof (int)); 561 count = obj->count; 562 } 563 564 memcpy (vector, obj->status, count * sizeof (int)); 565 566 return 1; 567 } 568 569 /* Get process times of executed programs. */ 570 571 int 572 pex_get_times (struct pex_obj *obj, int count, struct pex_time *vector) 573 { 574 if (obj->status == NULL) 575 { 576 const char *errmsg; 577 int err; 578 579 if (!pex_get_status_and_time (obj, 0, &errmsg, &err)) 580 return 0; 581 } 582 583 if (obj->time == NULL) 584 return 0; 585 586 if (count > obj->count) 587 { 588 memset (vector + obj->count, 0, 589 (count - obj->count) * sizeof (struct pex_time)); 590 count = obj->count; 591 } 592 593 memcpy (vector, obj->time, count * sizeof (struct pex_time)); 594 595 return 1; 596 } 597 598 /* Free a pex_obj structure. */ 599 600 void 601 pex_free (struct pex_obj *obj) 602 { 603 /* Close pipe file descriptors corresponding to child's stdout and 604 stderr so that the child does not hang trying to output something 605 while we're waiting for it. */ 606 if (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO) 607 obj->funcs->close (obj, obj->next_input); 608 if (obj->stderr_pipe >= 0 && obj->stderr_pipe != STDIN_FILE_NO) 609 obj->funcs->close (obj, obj->stderr_pipe); 610 if (obj->read_output != NULL) 611 fclose (obj->read_output); 612 if (obj->read_err != NULL) 613 fclose (obj->read_err); 614 615 /* If the caller forgot to wait for the children, we do it here, to 616 avoid zombies. */ 617 if (obj->status == NULL) 618 { 619 const char *errmsg; 620 int err; 621 622 obj->flags &= ~ PEX_RECORD_TIMES; 623 pex_get_status_and_time (obj, 1, &errmsg, &err); 624 } 625 626 if (obj->next_input_name_allocated) 627 free (obj->next_input_name); 628 free (obj->children); 629 free (obj->status); 630 free (obj->time); 631 632 if (obj->remove_count > 0) 633 { 634 int i; 635 636 for (i = 0; i < obj->remove_count; ++i) 637 { 638 remove (obj->remove[i]); 639 free (obj->remove[i]); 640 } 641 free (obj->remove); 642 } 643 644 if (obj->funcs->cleanup != NULL) 645 obj->funcs->cleanup (obj); 646 647 free (obj); 648 } 649
