[thirdparty/gcc.git] / libiberty / pex-unix.c

/* Utilities to execute a program in a subprocess (possibly linked by pipes
   with other subprocesses), and wait for it.  Generic Unix version
   (also used for UWIN and VMS).
   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2009
   Free Software Foundation, Inc.

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 <signal.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

#include <sys/types.h>

#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#ifdef HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
#ifdef HAVE_GETRUSAGE
#include <sys/time.h>
#include <sys/resource.h>
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif


#ifdef vfork /* Autoconf may define this to fork for us. */
# define VFORK_STRING "fork"
#else
# define VFORK_STRING "vfork"
#endif
#ifdef HAVE_VFORK_H
#include <vfork.h>
#endif
#if defined(VMS) && defined (__LONG_POINTERS)
#ifndef __CHAR_PTR32
typedef char * __char_ptr32
__attribute__ ((mode (SI)));
#endif

typedef __char_ptr32 *__char_ptr_char_ptr32
__attribute__ ((mode (SI)));

/* Return a 32 bit pointer to an array of 32 bit pointers 
   given a 64 bit pointer to an array of 64 bit pointers.  */

static __char_ptr_char_ptr32
to_ptr32 (char **ptr64)
{
  int argc;
  __char_ptr_char_ptr32 short_argv;

  for (argc=0; ptr64[argc]; argc++);

  /* Reallocate argv with 32 bit pointers.  */
  short_argv = (__char_ptr_char_ptr32) decc$malloc
    (sizeof (__char_ptr32) * (argc + 1));

  for (argc=0; ptr64[argc]; argc++)
    short_argv[argc] = (__char_ptr32) decc$strdup (ptr64[argc]);

  short_argv[argc] = (__char_ptr32) 0;
  return short_argv;

}
#else
#define to_ptr32(argv) argv
#endif

/* File mode to use for private and world-readable files.  */

#if defined (S_IRUSR) && defined (S_IWUSR) && defined (S_IRGRP) && defined (S_IWGRP) && defined (S_IROTH) && defined (S_IWOTH)
#define PUBLIC_MODE  \
    (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
#else
#define PUBLIC_MODE 0666
#endif

/* Get the exit status of a particular process, and optionally get the
   time that it took.  This is simple if we have wait4, slightly
   harder if we have waitpid, and is a pain if we only have wait.  */

static pid_t pex_wait (struct pex_obj *, pid_t, int *, struct pex_time *);

#ifdef HAVE_WAIT4

static pid_t
pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
	  struct pex_time *time)
{
  pid_t ret;
  struct rusage r;

#ifdef HAVE_WAITPID
  if (time == NULL)
    return waitpid (pid, status, 0);
#endif

  ret = wait4 (pid, status, 0, &r);

  if (time != NULL)
    {
      time->user_seconds = r.ru_utime.tv_sec;
      time->user_microseconds= r.ru_utime.tv_usec;
      time->system_seconds = r.ru_stime.tv_sec;
      time->system_microseconds= r.ru_stime.tv_usec;
    }

  return ret;
}

#else /* ! defined (HAVE_WAIT4) */

#ifdef HAVE_WAITPID

#ifndef HAVE_GETRUSAGE

static pid_t
pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
	  struct pex_time *time)
{
  if (time != NULL)
    memset (time, 0, sizeof (struct pex_time));
  return waitpid (pid, status, 0);
}

#else /* defined (HAVE_GETRUSAGE) */

static pid_t
pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
	  struct pex_time *time)
{
  struct rusage r1, r2;
  pid_t ret;

  if (time == NULL)
    return waitpid (pid, status, 0);

  getrusage (RUSAGE_CHILDREN, &r1);

  ret = waitpid (pid, status, 0);
  if (ret < 0)
    return ret;

  getrusage (RUSAGE_CHILDREN, &r2);

  time->user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
  time->user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
  if (r2.ru_utime.tv_usec < r1.ru_utime.tv_usec)
    {
      --time->user_seconds;
      time->user_microseconds += 1000000;
    }

  time->system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
  time->system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
  if (r2.ru_stime.tv_usec < r1.ru_stime.tv_usec)
    {
      --time->system_seconds;
      time->system_microseconds += 1000000;
    }

  return ret;
}

#endif /* defined (HAVE_GETRUSAGE) */

#else /* ! defined (HAVE_WAITPID) */

struct status_list
{
  struct status_list *next;
  pid_t pid;
  int status;
  struct pex_time time;
};

static pid_t
pex_wait (struct pex_obj *obj, pid_t pid, int *status, struct pex_time *time)
{
  struct status_list **pp;

  for (pp = (struct status_list **) &obj->sysdep;
       *pp != NULL;
       pp = &(*pp)->next)
    {
      if ((*pp)->pid == pid)
	{
	  struct status_list *p;

	  p = *pp;
	  *status = p->status;
	  if (time != NULL)
	    *time = p->time;
	  *pp = p->next;
	  free (p);
	  return pid;
	}
    }

  while (1)
    {
      pid_t cpid;
      struct status_list *psl;
      struct pex_time pt;
#ifdef HAVE_GETRUSAGE
      struct rusage r1, r2;
#endif

      if (time != NULL)
	{
#ifdef HAVE_GETRUSAGE
	  getrusage (RUSAGE_CHILDREN, &r1);
#else
	  memset (&pt, 0, sizeof (struct pex_time));
#endif
	}

      cpid = wait (status);

#ifdef HAVE_GETRUSAGE
      if (time != NULL && cpid >= 0)
	{
	  getrusage (RUSAGE_CHILDREN, &r2);

	  pt.user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
	  pt.user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
	  if (pt.user_microseconds < 0)
	    {
	      --pt.user_seconds;
	      pt.user_microseconds += 1000000;
	    }

	  pt.system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
	  pt.system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
	  if (pt.system_microseconds < 0)
	    {
	      --pt.system_seconds;
	      pt.system_microseconds += 1000000;
	    }
	}
#endif

      if (cpid < 0 || cpid == pid)
	{
	  if (time != NULL)
	    *time = pt;
	  return cpid;
	}

      psl = XNEW (struct status_list);
      psl->pid = cpid;
      psl->status = *status;
      if (time != NULL)
	psl->time = pt;
      psl->next = (struct status_list *) obj->sysdep;
      obj->sysdep = (void *) psl;
    }
}

#endif /* ! defined (HAVE_WAITPID) */
#endif /* ! defined (HAVE_WAIT4) */

static void pex_child_error (struct pex_obj *, const char *, const char *, int)
     ATTRIBUTE_NORETURN;
static int pex_unix_open_read (struct pex_obj *, const char *, int);
static int pex_unix_open_write (struct pex_obj *, const char *, int);
static pid_t pex_unix_exec_child (struct pex_obj *, int, const char *,
				 char * const *, char * const *,
				 int, int, int, int,
				 const char **, int *);
static int pex_unix_close (struct pex_obj *, int);
static int pex_unix_wait (struct pex_obj *, pid_t, int *, struct pex_time *,
			  int, const char **, int *);
static int pex_unix_pipe (struct pex_obj *, int *, int);
static FILE *pex_unix_fdopenr (struct pex_obj *, int, int);
static FILE *pex_unix_fdopenw (struct pex_obj *, int, int);
static void pex_unix_cleanup (struct pex_obj *);

/* The list of functions we pass to the common routines.  */

const struct pex_funcs funcs =
{
  pex_unix_open_read,
  pex_unix_open_write,
  pex_unix_exec_child,
  pex_unix_close,
  pex_unix_wait,
  pex_unix_pipe,
  pex_unix_fdopenr,
  pex_unix_fdopenw,
  pex_unix_cleanup
};

/* Return a newly initialized pex_obj structure.  */

struct pex_obj *
pex_init (int flags, const char *pname, const char *tempbase)
{
  return pex_init_common (flags, pname, tempbase, &funcs);
}

/* Open a file for reading.  */

static int
pex_unix_open_read (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
		    int binary ATTRIBUTE_UNUSED)
{
  return open (name, O_RDONLY);
}

/* Open a file for writing.  */

static int
pex_unix_open_write (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
		     int binary ATTRIBUTE_UNUSED)
{
  /* Note that we can't use O_EXCL here because gcc may have already
     created the temporary file via make_temp_file.  */
  return open (name, O_WRONLY | O_CREAT | O_TRUNC, PUBLIC_MODE);
}

/* Close a file.  */

static int
pex_unix_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
{
  return close (fd);
}

/* Report an error from a child process.  We don't use stdio routines,
   because we might be here due to a vfork call.  */

static void
pex_child_error (struct pex_obj *obj, const char *executable,
		 const char *errmsg, int err)
{
  int retval = 0;
#define writeerr(s) retval |= (write (STDERR_FILE_NO, s, strlen (s)) < 0)
  writeerr (obj->pname);
  writeerr (": error trying to exec '");
  writeerr (executable);
  writeerr ("': ");
  writeerr (errmsg);
  writeerr (": ");
  writeerr (xstrerror (err));
  writeerr ("\n");
#undef writeerr
  /* Exit with -2 if the error output failed, too.  */
  _exit (retval == 0 ? -1 : -2);
}

/* Execute a child.  */

extern char **environ;

static pid_t
pex_unix_exec_child (struct pex_obj *obj, int flags, const char *executable,
		     char * const * argv, char * const * env,
                     int in, int out, int errdes,
		     int toclose, const char **errmsg, int *err)
{
  pid_t pid;

  /* We declare these to be volatile to avoid warnings from gcc about
     them being clobbered by vfork.  */
  volatile int sleep_interval;
  volatile int retries;

  sleep_interval = 1;
  pid = -1;
  for (retries = 0; retries < 4; ++retries)
    {
      pid = vfork ();
      if (pid >= 0)
	break;
      sleep (sleep_interval);
      sleep_interval *= 2;
    }

  switch (pid)
    {
    case -1:
      *err = errno;
      *errmsg = VFORK_STRING;
      return (pid_t) -1;

    case 0:
      /* Child process.  */
      if (in != STDIN_FILE_NO)
	{
	  if (dup2 (in, STDIN_FILE_NO) < 0)
	    pex_child_error (obj, executable, "dup2", errno);
	  if (close (in) < 0)
	    pex_child_error (obj, executable, "close", errno);
	}
      if (out != STDOUT_FILE_NO)
	{
	  if (dup2 (out, STDOUT_FILE_NO) < 0)
	    pex_child_error (obj, executable, "dup2", errno);
	  if (close (out) < 0)
	    pex_child_error (obj, executable, "close", errno);
	}
      if (errdes != STDERR_FILE_NO)
	{
	  if (dup2 (errdes, STDERR_FILE_NO) < 0)
	    pex_child_error (obj, executable, "dup2", errno);
	  if (close (errdes) < 0)
	    pex_child_error (obj, executable, "close", errno);
	}
      if (toclose >= 0)
	{
	  if (close (toclose) < 0)
	    pex_child_error (obj, executable, "close", errno);
	}
      if ((flags & PEX_STDERR_TO_STDOUT) != 0)
	{
	  if (dup2 (STDOUT_FILE_NO, STDERR_FILE_NO) < 0)
	    pex_child_error (obj, executable, "dup2", errno);
	}

      if (env)
        environ = (char**) env;

      if ((flags & PEX_SEARCH) != 0)
	{
	  execvp (executable, to_ptr32 (argv));
	  pex_child_error (obj, executable, "execvp", errno);
	}
      else
	{
	  execv (executable, to_ptr32 (argv));
	  pex_child_error (obj, executable, "execv", errno);
	}

      /* NOTREACHED */
      return (pid_t) -1;

    default:
      /* Parent process.  */
      if (in != STDIN_FILE_NO)
	{
	  if (close (in) < 0)
	    {
	      *err = errno;
	      *errmsg = "close";
	      return (pid_t) -1;
	    }
	}
      if (out != STDOUT_FILE_NO)
	{
	  if (close (out) < 0)
	    {
	      *err = errno;
	      *errmsg = "close";
	      return (pid_t) -1;
	    }
	}
      if (errdes != STDERR_FILE_NO)
	{
	  if (close (errdes) < 0)
	    {
	      *err = errno;
	      *errmsg = "close";
	      return (pid_t) -1;
	    }
	}

      return pid;
    }
}

/* Wait for a child process to complete.  */

static int
pex_unix_wait (struct pex_obj *obj, pid_t pid, int *status,
	       struct pex_time *time, int done, const char **errmsg,
	       int *err)
{
  /* If we are cleaning up when the caller didn't retrieve process
     status for some reason, encourage the process to go away.  */
  if (done)
    kill (pid, SIGTERM);

  if (pex_wait (obj, pid, status, time) < 0)
    {
      *err = errno;
      *errmsg = "wait";
      return -1;
    }

  return 0;
}

/* Create a pipe.  */

static int
pex_unix_pipe (struct pex_obj *obj ATTRIBUTE_UNUSED, int *p,
	       int binary ATTRIBUTE_UNUSED)
{
  return pipe (p);
}

/* Get a FILE pointer to read from a file descriptor.  */

static FILE *
pex_unix_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
		  int binary ATTRIBUTE_UNUSED)
{
  return fdopen (fd, "r");
}

static FILE *
pex_unix_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
		  int binary ATTRIBUTE_UNUSED)
{
  if (fcntl (fd, F_SETFD, FD_CLOEXEC) < 0)
    return NULL;
  return fdopen (fd, "w");
}

static void
pex_unix_cleanup (struct pex_obj *obj ATTRIBUTE_UNUSED)
{
#if !defined (HAVE_WAIT4) && !defined (HAVE_WAITPID)
  while (obj->sysdep != NULL)
    {
      struct status_list *this;
      struct status_list *next;

      this = (struct status_list *) obj->sysdep;
      next = this->next;
      free (this);
      obj->sysdep = (void *) next;
    }
#endif
}
Commit	Line	Data
55d0e5e0 ZW	1	/* Utilities to execute a program in a subprocess (possibly linked by pipes
	2	with other subprocesses), and wait for it. Generic Unix version
	3	(also used for UWIN and VMS).
b303ef51	4	Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2009
55d0e5e0 ZW	5	Free Software Foundation, Inc.
	6
	7	This file is part of the libiberty library.
	8	Libiberty is free software; you can redistribute it and/or
	9	modify it under the terms of the GNU Library General Public
	10	License as published by the Free Software Foundation; either
	11	version 2 of the License, or (at your option) any later version.
	12
	13	Libiberty is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Library General Public License for more details.
	17
	18	You should have received a copy of the GNU Library General Public
	19	License along with libiberty; see the file COPYING.LIB. If not,
ee58dffd NC	20	write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
ee58dffd NC	21	Boston, MA 02110-1301, USA. */
55d0e5e0	22
a584cf65 ILT	23	#include "config.h"
a584cf65 ILT	24	#include "libiberty.h"
55d0e5e0 ZW	25	#include "pex-common.h"
	26
	27	#include <stdio.h>
a584cf65	28	#include <signal.h>
55d0e5e0 ZW	29	#include <errno.h>
	30	#ifdef NEED_DECLARATION_ERRNO
	31	extern int errno;
	32	#endif
a584cf65 ILT	33	#ifdef HAVE_STDLIB_H
	34	#include <stdlib.h>
	35	#endif
55d0e5e0 ZW	36	#ifdef HAVE_STRING_H
	37	#include <string.h>
	38	#endif
	39	#ifdef HAVE_UNISTD_H
	40	#include <unistd.h>
	41	#endif
a584cf65 ILT	42
	43	#include <sys/types.h>
	44
	45	#ifdef HAVE_FCNTL_H
	46	#include <fcntl.h>
55d0e5e0 ZW	47	#endif
	48	#ifdef HAVE_SYS_WAIT_H
	49	#include <sys/wait.h>
	50	#endif
a584cf65 ILT	51	#ifdef HAVE_GETRUSAGE
	52	#include <sys/time.h>
	53	#include <sys/resource.h>
	54	#endif
	55	#ifdef HAVE_SYS_STAT_H
	56	#include <sys/stat.h>
55d0e5e0 ZW	57	#endif
55d0e5e0 ZW	58
a584cf65	59
fed8129b ILT	60	#ifdef vfork /* Autoconf may define this to fork for us. */
	61	# define VFORK_STRING "fork"
	62	#else
	63	# define VFORK_STRING "vfork"
	64	#endif
	65	#ifdef HAVE_VFORK_H
	66	#include <vfork.h>
	67	#endif
b303ef51 DR	68	#if defined(VMS) && defined (__LONG_POINTERS)
	69	#ifndef __CHAR_PTR32
	70	typedef char * __char_ptr32
	71	__attribute__ ((mode (SI)));
	72	#endif
	73
	74	typedef __char_ptr32 *__char_ptr_char_ptr32
	75	__attribute__ ((mode (SI)));
	76
	77	/* Return a 32 bit pointer to an array of 32 bit pointers
	78	given a 64 bit pointer to an array of 64 bit pointers. */
	79
	80	static __char_ptr_char_ptr32
	81	to_ptr32 (char **ptr64)
	82	{
	83	int argc;
	84	__char_ptr_char_ptr32 short_argv;
	85
	86	for (argc=0; ptr64[argc]; argc++);
fed8129b	87
b303ef51 DR	88	/* Reallocate argv with 32 bit pointers. */
	89	short_argv = (__char_ptr_char_ptr32) decc$malloc
	90	(sizeof (__char_ptr32) * (argc + 1));
	91
	92	for (argc=0; ptr64[argc]; argc++)
	93	short_argv[argc] = (__char_ptr32) decc$strdup (ptr64[argc]);
	94
	95	short_argv[argc] = (__char_ptr32) 0;
	96	return short_argv;
	97
	98	}
	99	#else
	100	#define to_ptr32(argv) argv
	101	#endif
55d0e5e0	102
a584cf65 ILT	103	/* File mode to use for private and world-readable files. */
	104
	105	#if defined (S_IRUSR) && defined (S_IWUSR) && defined (S_IRGRP) && defined (S_IWGRP) && defined (S_IROTH) && defined (S_IWOTH)
	106	#define PUBLIC_MODE \
	107	(S_IRUSR \| S_IWUSR \| S_IRGRP \| S_IWGRP \| S_IROTH \| S_IWOTH)
	108	#else
	109	#define PUBLIC_MODE 0666
	110	#endif
	111
	112	/* Get the exit status of a particular process, and optionally get the
	113	time that it took. This is simple if we have wait4, slightly
	114	harder if we have waitpid, and is a pain if we only have wait. */
	115
	116	static pid_t pex_wait (struct pex_obj , pid_t, int , struct pex_time *);
	117
	118	#ifdef HAVE_WAIT4
	119
	120	static pid_t
	121	pex_wait (struct pex_obj obj ATTRIBUTE_UNUSED, pid_t pid, int status,
	122	struct pex_time *time)
	123	{
	124	pid_t ret;
	125	struct rusage r;
	126
	127	#ifdef HAVE_WAITPID
	128	if (time == NULL)
	129	return waitpid (pid, status, 0);
	130	#endif
	131
	132	ret = wait4 (pid, status, 0, &r);
	133
	134	if (time != NULL)
	135	{
	136	time->user_seconds = r.ru_utime.tv_sec;
	137	time->user_microseconds= r.ru_utime.tv_usec;
	138	time->system_seconds = r.ru_stime.tv_sec;
	139	time->system_microseconds= r.ru_stime.tv_usec;
	140	}
	141
	142	return ret;
	143	}
	144
	145	#else /* ! defined (HAVE_WAIT4) */
	146
	147	#ifdef HAVE_WAITPID
	148
	149	#ifndef HAVE_GETRUSAGE
	150
	151	static pid_t
	152	pex_wait (struct pex_obj obj ATTRIBUTE_UNUSED, pid_t pid, int status,
	153	struct pex_time *time)
	154	{
	155	if (time != NULL)
	156	memset (time, 0, sizeof (struct pex_time));
	157	return waitpid (pid, status, 0);
	158	}
	159
	160	#else /* defined (HAVE_GETRUSAGE) */
	161
	162	static pid_t
	163	pex_wait (struct pex_obj obj ATTRIBUTE_UNUSED, pid_t pid, int status,
	164	struct pex_time *time)
	165	{
	166	struct rusage r1, r2;
167	pid_t ret;
168
169	if (time == NULL)
170	return waitpid (pid, status, 0);
171
172	getrusage (RUSAGE_CHILDREN, &r1);
173
174	ret = waitpid (pid, status, 0);
175	if (ret < 0)
176	return ret;
177
178	getrusage (RUSAGE_CHILDREN, &r2);
179
180	time->user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
181	time->user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
182	if (r2.ru_utime.tv_usec < r1.ru_utime.tv_usec)
183	{
184	--time->user_seconds;
185	time->user_microseconds += 1000000;
186	}
187
188	time->system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
189	time->system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
190	if (r2.ru_stime.tv_usec < r1.ru_stime.tv_usec)
191	{
192	--time->system_seconds;
193	time->system_microseconds += 1000000;
194	}
fed8129b	195
a584cf65 ILT	196	return ret;
a584cf65 ILT	197	}
55d0e5e0	198
a584cf65	199	#endif /* defined (HAVE_GETRUSAGE) */
55d0e5e0	200
a584cf65 ILT	201	#else /* ! defined (HAVE_WAITPID) */
	202
	203	struct status_list
	204	{
	205	struct status_list *next;
	206	pid_t pid;
	207	int status;
	208	struct pex_time time;
	209	};
	210
	211	static pid_t
	212	pex_wait (struct pex_obj obj, pid_t pid, int status, struct pex_time *time)
	213	{
	214	struct status_list **pp;
	215
	216	for (pp = (struct status_list **) &obj->sysdep;
	217	*pp != NULL;
	218	pp = &(*pp)->next)
55d0e5e0	219	{
a584cf65	220	if ((*pp)->pid == pid)
55d0e5e0	221	{
a584cf65 ILT	222	struct status_list *p;
	223
	224	p = *pp;
	225	*status = p->status;
	226	if (time != NULL)
	227	*time = p->time;
	228	*pp = p->next;
	229	free (p);
	230	return pid;
55d0e5e0	231	}
55d0e5e0	232	}
a584cf65 ILT	233
a584cf65 ILT	234	while (1)
55d0e5e0	235	{
a584cf65 ILT	236	pid_t cpid;
	237	struct status_list *psl;
	238	struct pex_time pt;
	239	#ifdef HAVE_GETRUSAGE
	240	struct rusage r1, r2;
	241	#endif
	242
	243	if (time != NULL)
	244	{
	245	#ifdef HAVE_GETRUSAGE
	246	getrusage (RUSAGE_CHILDREN, &r1);
	247	#else
	248	memset (&pt, 0, sizeof (struct pex_time));
	249	#endif
	250	}
	251
	252	cpid = wait (status);
	253
	254	#ifdef HAVE_GETRUSAGE
	255	if (time != NULL && cpid >= 0)
	256	{
	257	getrusage (RUSAGE_CHILDREN, &r2);
	258
	259	pt.user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
	260	pt.user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
	261	if (pt.user_microseconds < 0)
	262	{
	263	--pt.user_seconds;
	264	pt.user_microseconds += 1000000;
	265	}
	266
	267	pt.system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
	268	pt.system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
	269	if (pt.system_microseconds < 0)
	270	{
	271	--pt.system_seconds;
	272	pt.system_microseconds += 1000000;
	273	}
	274	}
	275	#endif
	276
	277	if (cpid < 0 \|\| cpid == pid)
	278	{
	279	if (time != NULL)
	280	*time = pt;
	281	return cpid;
	282	}
	283
d7cf8390	284	psl = XNEW (struct status_list);
a584cf65 ILT	285	psl->pid = cpid;
	286	psl->status = *status;
	287	if (time != NULL)
	288	psl->time = pt;
	289	psl->next = (struct status_list *) obj->sysdep;
	290	obj->sysdep = (void *) psl;
55d0e5e0	291	}
a584cf65 ILT	292	}
	293
	294	#endif /* ! defined (HAVE_WAITPID) */
	295	#endif /* ! defined (HAVE_WAIT4) */
	296
	297	static void pex_child_error (struct pex_obj , const char , const char *, int)
	298	ATTRIBUTE_NORETURN;
	299	static int pex_unix_open_read (struct pex_obj , const char , int);
	300	static int pex_unix_open_write (struct pex_obj , const char , int);
1651030c	301	static pid_t pex_unix_exec_child (struct pex_obj , int, const char ,
ea60341e	302	char * const , char const *,
5317e1c7 ILT	303	int, int, int, int,
5317e1c7 ILT	304	const char *, int );
a584cf65	305	static int pex_unix_close (struct pex_obj *, int);
1651030c	306	static int pex_unix_wait (struct pex_obj , pid_t, int , struct pex_time *,
a584cf65 ILT	307	int, const char *, int );
	308	static int pex_unix_pipe (struct pex_obj , int , int);
	309	static FILE pex_unix_fdopenr (struct pex_obj , int, int);
8eff378c	310	static FILE pex_unix_fdopenw (struct pex_obj , int, int);
a584cf65 ILT	311	static void pex_unix_cleanup (struct pex_obj *);
	312
	313	/* The list of functions we pass to the common routines. */
	314
	315	const struct pex_funcs funcs =
	316	{
	317	pex_unix_open_read,
	318	pex_unix_open_write,
	319	pex_unix_exec_child,
	320	pex_unix_close,
	321	pex_unix_wait,
	322	pex_unix_pipe,
	323	pex_unix_fdopenr,
8eff378c	324	pex_unix_fdopenw,
a584cf65 ILT	325	pex_unix_cleanup
	326	};
	327
	328	/* Return a newly initialized pex_obj structure. */
	329
	330	struct pex_obj *
	331	pex_init (int flags, const char pname, const char tempbase)
	332	{
	333	return pex_init_common (flags, pname, tempbase, &funcs);
	334	}
	335
	336	/* Open a file for reading. */
	337
	338	static int
	339	pex_unix_open_read (struct pex_obj obj ATTRIBUTE_UNUSED, const char name,
	340	int binary ATTRIBUTE_UNUSED)
	341	{
	342	return open (name, O_RDONLY);
	343	}
	344
	345	/* Open a file for writing. */
	346
	347	static int
	348	pex_unix_open_write (struct pex_obj obj ATTRIBUTE_UNUSED, const char name,
	349	int binary ATTRIBUTE_UNUSED)
	350	{
	351	/* Note that we can't use O_EXCL here because gcc may have already
	352	created the temporary file via make_temp_file. */
	353	return open (name, O_WRONLY \| O_CREAT \| O_TRUNC, PUBLIC_MODE);
	354	}
55d0e5e0	355
a584cf65 ILT	356	/* Close a file. */
	357
	358	static int
	359	pex_unix_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
	360	{
	361	return close (fd);
	362	}
	363
	364	/* Report an error from a child process. We don't use stdio routines,
	365	because we might be here due to a vfork call. */
	366
	367	static void
	368	pex_child_error (struct pex_obj obj, const char executable,
	369	const char *errmsg, int err)
	370	{
5120dc38 BE	371	int retval = 0;
5120dc38 BE	372	#define writeerr(s) retval \|= (write (STDERR_FILE_NO, s, strlen (s)) < 0)
a584cf65 ILT	373	writeerr (obj->pname);
	374	writeerr (": error trying to exec '");
	375	writeerr (executable);
	376	writeerr ("': ");
	377	writeerr (errmsg);
	378	writeerr (": ");
	379	writeerr (xstrerror (err));
	380	writeerr ("\n");
c22c44ba	381	#undef writeerr
5120dc38 BE	382	/* Exit with -2 if the error output failed, too. */
5120dc38 BE	383	_exit (retval == 0 ? -1 : -2);
a584cf65 ILT	384	}
	385
	386	/* Execute a child. */
	387
ea60341e MS	388	extern char **environ;
ea60341e MS	389
1651030c	390	static pid_t
a584cf65	391	pex_unix_exec_child (struct pex_obj obj, int flags, const char executable,
ea60341e MS	392	char * const * argv, char * const * env,
ea60341e MS	393	int in, int out, int errdes,
5317e1c7	394	int toclose, const char *errmsg, int err)
a584cf65 ILT	395	{
a584cf65 ILT	396	pid_t pid;
ea60341e	397
a584cf65 ILT	398	/* We declare these to be volatile to avoid warnings from gcc about
	399	them being clobbered by vfork. */
	400	volatile int sleep_interval;
	401	volatile int retries;
fed8129b	402
55d0e5e0 ZW	403	sleep_interval = 1;
55d0e5e0 ZW	404	pid = -1;
a584cf65	405	for (retries = 0; retries < 4; ++retries)
55d0e5e0	406	{
fed8129b	407	pid = vfork ();
55d0e5e0 ZW	408	if (pid >= 0)
	409	break;
	410	sleep (sleep_interval);
	411	sleep_interval *= 2;
	412	}
	413
	414	switch (pid)
	415	{
	416	case -1:
a584cf65 ILT	417	*err = errno;
a584cf65 ILT	418	*errmsg = VFORK_STRING;
1651030c	419	return (pid_t) -1;
55d0e5e0	420
a584cf65 ILT	421	case 0:
	422	/* Child process. */
	423	if (in != STDIN_FILE_NO)
55d0e5e0	424	{
a584cf65 ILT	425	if (dup2 (in, STDIN_FILE_NO) < 0)
	426	pex_child_error (obj, executable, "dup2", errno);
	427	if (close (in) < 0)
	428	pex_child_error (obj, executable, "close", errno);
55d0e5e0	429	}
a584cf65	430	if (out != STDOUT_FILE_NO)
55d0e5e0	431	{
a584cf65 ILT	432	if (dup2 (out, STDOUT_FILE_NO) < 0)
	433	pex_child_error (obj, executable, "dup2", errno);
	434	if (close (out) < 0)
	435	pex_child_error (obj, executable, "close", errno);
	436	}
	437	if (errdes != STDERR_FILE_NO)
	438	{
	439	if (dup2 (errdes, STDERR_FILE_NO) < 0)
	440	pex_child_error (obj, executable, "dup2", errno);
	441	if (close (errdes) < 0)
	442	pex_child_error (obj, executable, "close", errno);
	443	}
5317e1c7 ILT	444	if (toclose >= 0)
	445	{
	446	if (close (toclose) < 0)
	447	pex_child_error (obj, executable, "close", errno);
	448	}
a584cf65 ILT	449	if ((flags & PEX_STDERR_TO_STDOUT) != 0)
	450	{
	451	if (dup2 (STDOUT_FILE_NO, STDERR_FILE_NO) < 0)
	452	pex_child_error (obj, executable, "dup2", errno);
	453	}
ea60341e MS	454
ea60341e MS	455	if (env)
239559e7	456	environ = (char**) env;
ea60341e	457
a584cf65 ILT	458	if ((flags & PEX_SEARCH) != 0)
a584cf65 ILT	459	{
b303ef51	460	execvp (executable, to_ptr32 (argv));
a584cf65	461	pex_child_error (obj, executable, "execvp", errno);
55d0e5e0	462	}
fed8129b	463	else
a584cf65	464	{
b303ef51	465	execv (executable, to_ptr32 (argv));
a584cf65 ILT	466	pex_child_error (obj, executable, "execv", errno);
a584cf65 ILT	467	}
fed8129b	468
55d0e5e0	469	/* NOTREACHED */
1651030c	470	return (pid_t) -1;
55d0e5e0 ZW	471
55d0e5e0 ZW	472	default:
a584cf65 ILT	473	/* Parent process. */
	474	if (in != STDIN_FILE_NO)
	475	{
	476	if (close (in) < 0)
	477	{
	478	*err = errno;
	479	*errmsg = "close";
1651030c	480	return (pid_t) -1;
a584cf65 ILT	481	}
	482	}
	483	if (out != STDOUT_FILE_NO)
	484	{
	485	if (close (out) < 0)
	486	{
	487	*err = errno;
	488	*errmsg = "close";
1651030c	489	return (pid_t) -1;
a584cf65 ILT	490	}
	491	}
	492	if (errdes != STDERR_FILE_NO)
	493	{
	494	if (close (errdes) < 0)
	495	{
	496	*err = errno;
	497	*errmsg = "close";
1651030c	498	return (pid_t) -1;
a584cf65 ILT	499	}
	500	}
	501
1651030c	502	return pid;
55d0e5e0 ZW	503	}
	504	}
	505
a584cf65 ILT	506	/* Wait for a child process to complete. */
	507
	508	static int
1651030c	509	pex_unix_wait (struct pex_obj obj, pid_t pid, int status,
a584cf65 ILT	510	struct pex_time time, int done, const char *errmsg,
a584cf65 ILT	511	int *err)
55d0e5e0	512	{
a584cf65 ILT	513	/* If we are cleaning up when the caller didn't retrieve process
	514	status for some reason, encourage the process to go away. */
	515	if (done)
	516	kill (pid, SIGTERM);
	517
	518	if (pex_wait (obj, pid, status, time) < 0)
	519	{
	520	*err = errno;
	521	*errmsg = "wait";
	522	return -1;
	523	}
	524
	525	return 0;
	526	}
	527
	528	/* Create a pipe. */
	529
	530	static int
	531	pex_unix_pipe (struct pex_obj obj ATTRIBUTE_UNUSED, int p,
	532	int binary ATTRIBUTE_UNUSED)
	533	{
	534	return pipe (p);
	535	}
	536
	537	/* Get a FILE pointer to read from a file descriptor. */
	538
	539	static FILE *
	540	pex_unix_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
	541	int binary ATTRIBUTE_UNUSED)
	542	{
	543	return fdopen (fd, "r");
	544	}
	545
8eff378c JB	546	static FILE *
	547	pex_unix_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
	548	int binary ATTRIBUTE_UNUSED)
	549	{
	550	if (fcntl (fd, F_SETFD, FD_CLOEXEC) < 0)
	551	return NULL;
	552	return fdopen (fd, "w");
	553	}
	554
a584cf65 ILT	555	static void
	556	pex_unix_cleanup (struct pex_obj *obj ATTRIBUTE_UNUSED)
	557	{
	558	#if !defined (HAVE_WAIT4) && !defined (HAVE_WAITPID)
	559	while (obj->sysdep != NULL)
	560	{
	561	struct status_list *this;
	562	struct status_list *next;
	563
	564	this = (struct status_list *) obj->sysdep;
	565	next = this->next;
	566	free (this);
	567	obj->sysdep = (void *) next;
	568	}
	569	#endif
55d0e5e0	570	}