| /* Common code for executing a program in a sub-process. |
| Copyright (C) 2005-2021 Free Software Foundation, Inc. |
| Written by Ian Lance Taylor <ian@airs.com>. |
| |
| This file is part of the libiberty library. |
| Libiberty is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Library General Public |
| License as published by the Free Software Foundation; either |
| version 2 of the License, or (at your option) any later version. |
| |
| Libiberty is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Library General Public License for more details. |
| |
| You should have received a copy of the GNU Library General Public |
| License along with libiberty; see the file COPYING.LIB. If not, |
| write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor, |
| Boston, MA 02110-1301, USA. */ |
| |
| #include "config.h" |
| #include "libiberty.h" |
| #include "pex-common.h" |
| |
| #include <stdio.h> |
| #include <errno.h> |
| #ifdef NEED_DECLARATION_ERRNO |
| extern int errno; |
| #endif |
| #ifdef HAVE_STDLIB_H |
| #include <stdlib.h> |
| #endif |
| #ifdef HAVE_STRING_H |
| #include <string.h> |
| #endif |
| #ifdef HAVE_UNISTD_H |
| #include <unistd.h> |
| #endif |
| |
| extern int mkstemps (char *, int); |
| |
| /* This file contains subroutines for the program execution routines |
| (pex_init, pex_run, etc.). This file is compiled on all |
| systems. */ |
| |
| static void pex_add_remove (struct pex_obj *, const char *, int); |
| static int pex_get_status_and_time (struct pex_obj *, int, const char **, |
| int *); |
| |
| /* Initialize a pex_obj structure. */ |
| |
| struct pex_obj * |
| pex_init_common (int flags, const char *pname, const char *tempbase, |
| const struct pex_funcs *funcs) |
| { |
| struct pex_obj *obj; |
| |
| obj = XNEW (struct pex_obj); |
| obj->flags = flags; |
| obj->pname = pname; |
| obj->tempbase = tempbase; |
| obj->next_input = STDIN_FILE_NO; |
| obj->next_input_name = NULL; |
| obj->next_input_name_allocated = 0; |
| obj->stderr_pipe = -1; |
| obj->count = 0; |
| obj->children = NULL; |
| obj->status = NULL; |
| obj->time = NULL; |
| obj->number_waited = 0; |
| obj->input_file = NULL; |
| obj->read_output = NULL; |
| obj->read_err = NULL; |
| obj->remove_count = 0; |
| obj->remove = NULL; |
| obj->funcs = funcs; |
| obj->sysdep = NULL; |
| return obj; |
| } |
| |
| /* Add a file to be removed when we are done. */ |
| |
| static void |
| pex_add_remove (struct pex_obj *obj, const char *name, int allocated) |
| { |
| char *add; |
| |
| ++obj->remove_count; |
| obj->remove = XRESIZEVEC (char *, obj->remove, obj->remove_count); |
| if (allocated) |
| add = (char *) name; |
| else |
| add = xstrdup (name); |
| obj->remove[obj->remove_count - 1] = add; |
| } |
| |
| /* Generate a temporary file name based on OBJ, FLAGS, and NAME. |
| Return NULL if we were unable to reserve a temporary filename. |
| |
| If non-NULL, the result is either allocated with malloc, or the |
| same pointer as NAME. */ |
| static char * |
| temp_file (struct pex_obj *obj, int flags, char *name) |
| { |
| if (name == NULL) |
| { |
| if (obj->tempbase == NULL) |
| { |
| name = make_temp_file (NULL); |
| } |
| else |
| { |
| int len = strlen (obj->tempbase); |
| int out; |
| |
| if (len >= 6 |
| && strcmp (obj->tempbase + len - 6, "XXXXXX") == 0) |
| name = xstrdup (obj->tempbase); |
| else |
| name = concat (obj->tempbase, "XXXXXX", NULL); |
| |
| out = mkstemps (name, 0); |
| if (out < 0) |
| { |
| free (name); |
| return NULL; |
| } |
| |
| /* This isn't obj->funcs->close because we got the |
| descriptor from mkstemps, not from a function in |
| obj->funcs. Calling close here is just like what |
| make_temp_file does. */ |
| close (out); |
| } |
| } |
| else if ((flags & PEX_SUFFIX) != 0) |
| { |
| if (obj->tempbase == NULL) |
| name = make_temp_file (name); |
| else |
| name = concat (obj->tempbase, name, NULL); |
| } |
| |
| return name; |
| } |
| |
| |
| /* As for pex_run (), but permits the environment for the child process |
| to be specified. */ |
| |
| const char * |
| pex_run_in_environment (struct pex_obj *obj, int flags, const char *executable, |
| char * const * argv, char * const * env, |
| const char *orig_outname, const char *errname, |
| int *err) |
| { |
| const char *errmsg; |
| int in, out, errdes; |
| char *outname; |
| int outname_allocated; |
| int p[2]; |
| int toclose; |
| pid_t pid; |
| |
| in = -1; |
| out = -1; |
| errdes = -1; |
| outname = (char *) orig_outname; |
| outname_allocated = 0; |
| |
| /* If the user called pex_input_file, close the file now. */ |
| if (obj->input_file) |
| { |
| if (fclose (obj->input_file) == EOF) |
| { |
| errmsg = "closing pipeline input file"; |
| goto error_exit; |
| } |
| obj->input_file = NULL; |
| } |
| |
| /* Set IN. */ |
| |
| if (obj->next_input_name != NULL) |
| { |
| /* We have to make sure that the previous process has completed |
| before we try to read the file. */ |
| if (!pex_get_status_and_time (obj, 0, &errmsg, err)) |
| goto error_exit; |
| |
| in = obj->funcs->open_read (obj, obj->next_input_name, |
| (flags & PEX_BINARY_INPUT) != 0); |
| if (in < 0) |
| { |
| *err = errno; |
| errmsg = "open temporary file"; |
| goto error_exit; |
| } |
| if (obj->next_input_name_allocated) |
| { |
| free (obj->next_input_name); |
| obj->next_input_name_allocated = 0; |
| } |
| obj->next_input_name = NULL; |
| } |
| else |
| { |
| in = obj->next_input; |
| if (in < 0) |
| { |
| *err = 0; |
| errmsg = "pipeline already complete"; |
| goto error_exit; |
| } |
| } |
| |
| /* Set OUT and OBJ->NEXT_INPUT/OBJ->NEXT_INPUT_NAME. */ |
| |
| if ((flags & PEX_LAST) != 0) |
| { |
| if (outname == NULL) |
| out = STDOUT_FILE_NO; |
| else if ((flags & PEX_SUFFIX) != 0) |
| { |
| outname = concat (obj->tempbase, outname, NULL); |
| outname_allocated = 1; |
| } |
| obj->next_input = -1; |
| } |
| else if ((obj->flags & PEX_USE_PIPES) == 0) |
| { |
| outname = temp_file (obj, flags, outname); |
| if (! outname) |
| { |
| *err = 0; |
| errmsg = "could not create temporary file"; |
| goto error_exit; |
| } |
| |
| if (outname != orig_outname) |
| outname_allocated = 1; |
| |
| if ((obj->flags & PEX_SAVE_TEMPS) == 0) |
| { |
| pex_add_remove (obj, outname, outname_allocated); |
| outname_allocated = 0; |
| } |
| |
| /* Hand off ownership of outname to the next stage. */ |
| obj->next_input_name = outname; |
| obj->next_input_name_allocated = outname_allocated; |
| outname_allocated = 0; |
| } |
| else |
| { |
| if (obj->funcs->pipe (obj, p, (flags & PEX_BINARY_OUTPUT) != 0) < 0) |
| { |
| *err = errno; |
| errmsg = "pipe"; |
| goto error_exit; |
| } |
| |
| out = p[WRITE_PORT]; |
| obj->next_input = p[READ_PORT]; |
| } |
| |
| if (out < 0) |
| { |
| out = obj->funcs->open_write (obj, outname, |
| (flags & PEX_BINARY_OUTPUT) != 0, |
| (flags & PEX_STDOUT_APPEND) != 0); |
| if (out < 0) |
| { |
| *err = errno; |
| errmsg = "open temporary output file"; |
| goto error_exit; |
| } |
| } |
| |
| if (outname_allocated) |
| { |
| free (outname); |
| outname_allocated = 0; |
| } |
| |
| /* Set ERRDES. */ |
| |
| if (errname != NULL && (flags & PEX_STDERR_TO_PIPE) != 0) |
| { |
| *err = 0; |
| errmsg = "both ERRNAME and PEX_STDERR_TO_PIPE specified."; |
| goto error_exit; |
| } |
| |
| if (obj->stderr_pipe != -1) |
| { |
| *err = 0; |
| errmsg = "PEX_STDERR_TO_PIPE used in the middle of pipeline"; |
| goto error_exit; |
| } |
| |
| if (errname == NULL) |
| { |
| if (flags & PEX_STDERR_TO_PIPE) |
| { |
| if (obj->funcs->pipe (obj, p, (flags & PEX_BINARY_ERROR) != 0) < 0) |
| { |
| *err = errno; |
| errmsg = "pipe"; |
| goto error_exit; |
| } |
| |
| errdes = p[WRITE_PORT]; |
| obj->stderr_pipe = p[READ_PORT]; |
| } |
| else |
| { |
| errdes = STDERR_FILE_NO; |
| } |
| } |
| else |
| { |
| errdes = obj->funcs->open_write (obj, errname, |
| (flags & PEX_BINARY_ERROR) != 0, |
| (flags & PEX_STDERR_APPEND) != 0); |
| if (errdes < 0) |
| { |
| *err = errno; |
| errmsg = "open error file"; |
| goto error_exit; |
| } |
| } |
| |
| /* If we are using pipes, the child process has to close the next |
| input pipe. */ |
| |
| if ((obj->flags & PEX_USE_PIPES) == 0) |
| toclose = -1; |
| else |
| toclose = obj->next_input; |
| |
| /* Run the program. */ |
| |
| pid = obj->funcs->exec_child (obj, flags, executable, argv, env, |
| in, out, errdes, toclose, &errmsg, err); |
| if (pid < 0) |
| goto error_exit; |
| |
| ++obj->count; |
| obj->children = XRESIZEVEC (pid_t, obj->children, obj->count); |
| obj->children[obj->count - 1] = pid; |
| |
| return NULL; |
| |
| error_exit: |
| if (in >= 0 && in != STDIN_FILE_NO) |
| obj->funcs->close (obj, in); |
| if (out >= 0 && out != STDOUT_FILE_NO) |
| obj->funcs->close (obj, out); |
| if (errdes >= 0 && errdes != STDERR_FILE_NO) |
| obj->funcs->close (obj, errdes); |
| if (outname_allocated) |
| free (outname); |
| return errmsg; |
| } |
| |
| /* Run a program. */ |
| |
| const char * |
| pex_run (struct pex_obj *obj, int flags, const char *executable, |
| char * const * argv, const char *orig_outname, const char *errname, |
| int *err) |
| { |
| return pex_run_in_environment (obj, flags, executable, argv, NULL, |
| orig_outname, errname, err); |
| } |
| |
| /* Return a FILE pointer for a temporary file to fill with input for |
| the pipeline. */ |
| FILE * |
| pex_input_file (struct pex_obj *obj, int flags, const char *in_name) |
| { |
| char *name = (char *) in_name; |
| FILE *f; |
| |
| /* This must be called before the first pipeline stage is run, and |
| there must not have been any other input selected. */ |
| if (obj->count != 0 |
| || (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO) |
| || obj->next_input_name) |
| { |
| errno = EINVAL; |
| return NULL; |
| } |
| |
| name = temp_file (obj, flags, name); |
| if (! name) |
| return NULL; |
| |
| f = fopen (name, (flags & PEX_BINARY_OUTPUT) ? "wb" : "w"); |
| if (! f) |
| { |
| free (name); |
| return NULL; |
| } |
| |
| obj->input_file = f; |
| obj->next_input_name = name; |
| obj->next_input_name_allocated = (name != in_name); |
| |
| return f; |
| } |
| |
| /* Return a stream for a pipe connected to the standard input of the |
| first stage of the pipeline. */ |
| FILE * |
| pex_input_pipe (struct pex_obj *obj, int binary) |
| { |
| int p[2]; |
| FILE *f; |
| |
| /* You must call pex_input_pipe before the first pex_run or pex_one. */ |
| if (obj->count > 0) |
| goto usage_error; |
| |
| /* You must be using pipes. Implementations that don't support |
| pipes clear this flag before calling pex_init_common. */ |
| if (! (obj->flags & PEX_USE_PIPES)) |
| goto usage_error; |
| |
| /* If we have somehow already selected other input, that's a |
| mistake. */ |
| if ((obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO) |
| || obj->next_input_name) |
| goto usage_error; |
| |
| if (obj->funcs->pipe (obj, p, binary != 0) < 0) |
| return NULL; |
| |
| f = obj->funcs->fdopenw (obj, p[WRITE_PORT], binary != 0); |
| if (! f) |
| { |
| int saved_errno = errno; |
| obj->funcs->close (obj, p[READ_PORT]); |
| obj->funcs->close (obj, p[WRITE_PORT]); |
| errno = saved_errno; |
| return NULL; |
| } |
| |
| obj->next_input = p[READ_PORT]; |
| |
| return f; |
| |
| usage_error: |
| errno = EINVAL; |
| return NULL; |
| } |
| |
| /* Return a FILE pointer for the output of the last program |
| executed. */ |
| |
| FILE * |
| pex_read_output (struct pex_obj *obj, int binary) |
| { |
| if (obj->next_input_name != NULL) |
| { |
| const char *errmsg; |
| int err; |
| |
| /* We have to make sure that the process has completed before we |
| try to read the file. */ |
| if (!pex_get_status_and_time (obj, 0, &errmsg, &err)) |
| { |
| errno = err; |
| return NULL; |
| } |
| |
| obj->read_output = fopen (obj->next_input_name, binary ? "rb" : "r"); |
| |
| if (obj->next_input_name_allocated) |
| { |
| free (obj->next_input_name); |
| obj->next_input_name_allocated = 0; |
| } |
| obj->next_input_name = NULL; |
| } |
| else |
| { |
| int o; |
| |
| o = obj->next_input; |
| if (o < 0 || o == STDIN_FILE_NO) |
| return NULL; |
| obj->read_output = obj->funcs->fdopenr (obj, o, binary); |
| obj->next_input = -1; |
| } |
| |
| return obj->read_output; |
| } |
| |
| FILE * |
| pex_read_err (struct pex_obj *obj, int binary) |
| { |
| int o; |
| |
| o = obj->stderr_pipe; |
| if (o < 0 || o == STDIN_FILE_NO) |
| return NULL; |
| obj->read_err = obj->funcs->fdopenr (obj, o, binary); |
| obj->stderr_pipe = -1; |
| return obj->read_err; |
| } |
| |
| /* Get the exit status and, if requested, the resource time for all |
| the child processes. Return 0 on failure, 1 on success. */ |
| |
| static int |
| pex_get_status_and_time (struct pex_obj *obj, int done, const char **errmsg, |
| int *err) |
| { |
| int ret; |
| int i; |
| |
| if (obj->number_waited == obj->count) |
| return 1; |
| |
| obj->status = XRESIZEVEC (int, obj->status, obj->count); |
| if ((obj->flags & PEX_RECORD_TIMES) != 0) |
| obj->time = XRESIZEVEC (struct pex_time, obj->time, obj->count); |
| |
| ret = 1; |
| for (i = obj->number_waited; i < obj->count; ++i) |
| { |
| if (obj->funcs->wait (obj, obj->children[i], &obj->status[i], |
| obj->time == NULL ? NULL : &obj->time[i], |
| done, errmsg, err) < 0) |
| ret = 0; |
| } |
| obj->number_waited = i; |
| |
| return ret; |
| } |
| |
| /* Get exit status of executed programs. */ |
| |
| int |
| pex_get_status (struct pex_obj *obj, int count, int *vector) |
| { |
| if (obj->status == NULL) |
| { |
| const char *errmsg; |
| int err; |
| |
| if (!pex_get_status_and_time (obj, 0, &errmsg, &err)) |
| return 0; |
| } |
| |
| if (count > obj->count) |
| { |
| memset (vector + obj->count, 0, (count - obj->count) * sizeof (int)); |
| count = obj->count; |
| } |
| |
| memcpy (vector, obj->status, count * sizeof (int)); |
| |
| return 1; |
| } |
| |
| /* Get process times of executed programs. */ |
| |
| int |
| pex_get_times (struct pex_obj *obj, int count, struct pex_time *vector) |
| { |
| if (obj->status == NULL) |
| { |
| const char *errmsg; |
| int err; |
| |
| if (!pex_get_status_and_time (obj, 0, &errmsg, &err)) |
| return 0; |
| } |
| |
| if (obj->time == NULL) |
| return 0; |
| |
| if (count > obj->count) |
| { |
| memset (vector + obj->count, 0, |
| (count - obj->count) * sizeof (struct pex_time)); |
| count = obj->count; |
| } |
| |
| memcpy (vector, obj->time, count * sizeof (struct pex_time)); |
| |
| return 1; |
| } |
| |
| /* Free a pex_obj structure. */ |
| |
| void |
| pex_free (struct pex_obj *obj) |
| { |
| /* Close pipe file descriptors corresponding to child's stdout and |
| stderr so that the child does not hang trying to output something |
| while we're waiting for it. */ |
| if (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO) |
| obj->funcs->close (obj, obj->next_input); |
| if (obj->stderr_pipe >= 0 && obj->stderr_pipe != STDIN_FILE_NO) |
| obj->funcs->close (obj, obj->stderr_pipe); |
| if (obj->read_output != NULL) |
| fclose (obj->read_output); |
| if (obj->read_err != NULL) |
| fclose (obj->read_err); |
| |
| /* If the caller forgot to wait for the children, we do it here, to |
| avoid zombies. */ |
| if (obj->status == NULL) |
| { |
| const char *errmsg; |
| int err; |
| |
| obj->flags &= ~ PEX_RECORD_TIMES; |
| pex_get_status_and_time (obj, 1, &errmsg, &err); |
| } |
| |
| if (obj->next_input_name_allocated) |
| free (obj->next_input_name); |
| free (obj->children); |
| free (obj->status); |
| free (obj->time); |
| |
| if (obj->remove_count > 0) |
| { |
| int i; |
| |
| for (i = 0; i < obj->remove_count; ++i) |
| { |
| remove (obj->remove[i]); |
| free (obj->remove[i]); |
| } |
| free (obj->remove); |
| } |
| |
| if (obj->funcs->cleanup != NULL) |
| obj->funcs->cleanup (obj); |
| |
| free (obj); |
| } |