/* Common code for executing a program in a sub-process.
  Copyright (C) 2005-2024 Free Software Foundation, Inc.
  Written by Ian Lance Taylor <[email protected]>.

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);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.