[deliverable/binutils-gdb.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)
{
#define writeerr(s) (void) write (STDERR_FILE_NO, s, strlen (s))
  writeerr (obj->pname);
  writeerr (": error trying to exec '");
  writeerr (executable);
  writeerr ("': ");
  writeerr (errmsg);
  writeerr (": ");
  writeerr (xstrerror (err));
  writeerr ("\n");
  _exit (-1);
}

/* 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
5a17353c DD	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).
9fef968a	4	Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2009
5a17353c DD	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,
979c05d3 NC	20	write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
979c05d3 NC	21	Boston, MA 02110-1301, USA. */
5a17353c	22
b109e79a ILT	23	#include "config.h"
b109e79a ILT	24	#include "libiberty.h"
5a17353c DD	25	#include "pex-common.h"
	26
	27	#include <stdio.h>
b109e79a	28	#include <signal.h>
5a17353c DD	29	#include <errno.h>
	30	#ifdef NEED_DECLARATION_ERRNO
	31	extern int errno;
	32	#endif
b109e79a ILT	33	#ifdef HAVE_STDLIB_H
	34	#include <stdlib.h>
	35	#endif
5a17353c DD	36	#ifdef HAVE_STRING_H
	37	#include <string.h>
	38	#endif
	39	#ifdef HAVE_UNISTD_H
	40	#include <unistd.h>
	41	#endif
b109e79a ILT	42
	43	#include <sys/types.h>
	44
	45	#ifdef HAVE_FCNTL_H
	46	#include <fcntl.h>
5a17353c DD	47	#endif
	48	#ifdef HAVE_SYS_WAIT_H
	49	#include <sys/wait.h>
	50	#endif
b109e79a 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>
5a17353c DD	57	#endif
5a17353c DD	58
b109e79a	59
12a7367e DD	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
9fef968a DD	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++);
12a7367e	87
9fef968a DD	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
5a17353c	102
b109e79a 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	}
12a7367e	195
b109e79a ILT	196	return ret;
b109e79a ILT	197	}
5a17353c	198
b109e79a	199	#endif /* defined (HAVE_GETRUSAGE) */
5a17353c	200
b109e79a 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)
5a17353c	219	{
b109e79a	220	if ((*pp)->pid == pid)
5a17353c	221	{
b109e79a 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;
5a17353c	231	}
5a17353c	232	}
b109e79a ILT	233
b109e79a ILT	234	while (1)
5a17353c	235	{
b109e79a 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
abf6a75b	284	psl = XNEW (struct status_list);
b109e79a 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;
5a17353c	291	}
b109e79a 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);
29d89e07	301	static pid_t pex_unix_exec_child (struct pex_obj , int, const char ,
014a8caf	302	char * const , char const *,
cb6c09ac DD	303	int, int, int, int,
cb6c09ac DD	304	const char *, int );
b109e79a	305	static int pex_unix_close (struct pex_obj *, int);
29d89e07	306	static int pex_unix_wait (struct pex_obj , pid_t, int , struct pex_time *,
b109e79a 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);
3db2e6dd	310	static FILE pex_unix_fdopenw (struct pex_obj , int, int);
b109e79a 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,
3db2e6dd	324	pex_unix_fdopenw,
b109e79a 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	}
5a17353c	355
b109e79a 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	{
0bbe7a79	371	#define writeerr(s) (void) write (STDERR_FILE_NO, s, strlen (s))
b109e79a ILT	372	writeerr (obj->pname);
	373	writeerr (": error trying to exec '");
	374	writeerr (executable);
	375	writeerr ("': ");
	376	writeerr (errmsg);
	377	writeerr (": ");
	378	writeerr (xstrerror (err));
	379	writeerr ("\n");
	380	_exit (-1);
	381	}
	382
	383	/* Execute a child. */
	384
014a8caf DD	385	extern char **environ;
014a8caf DD	386
29d89e07	387	static pid_t
b109e79a	388	pex_unix_exec_child (struct pex_obj obj, int flags, const char executable,
014a8caf DD	389	char * const * argv, char * const * env,
014a8caf DD	390	int in, int out, int errdes,
cb6c09ac	391	int toclose, const char *errmsg, int err)
b109e79a ILT	392	{
b109e79a ILT	393	pid_t pid;
014a8caf	394
b109e79a ILT	395	/* We declare these to be volatile to avoid warnings from gcc about
	396	them being clobbered by vfork. */
	397	volatile int sleep_interval;
	398	volatile int retries;
12a7367e	399
5a17353c DD	400	sleep_interval = 1;
5a17353c DD	401	pid = -1;
b109e79a	402	for (retries = 0; retries < 4; ++retries)
5a17353c	403	{
12a7367e	404	pid = vfork ();
5a17353c DD	405	if (pid >= 0)
	406	break;
	407	sleep (sleep_interval);
	408	sleep_interval *= 2;
	409	}
	410
	411	switch (pid)
	412	{
	413	case -1:
b109e79a ILT	414	*err = errno;
b109e79a ILT	415	*errmsg = VFORK_STRING;
29d89e07	416	return (pid_t) -1;
5a17353c	417
b109e79a ILT	418	case 0:
	419	/* Child process. */
	420	if (in != STDIN_FILE_NO)
5a17353c	421	{
b109e79a ILT	422	if (dup2 (in, STDIN_FILE_NO) < 0)
	423	pex_child_error (obj, executable, "dup2", errno);
	424	if (close (in) < 0)
	425	pex_child_error (obj, executable, "close", errno);
5a17353c	426	}
b109e79a	427	if (out != STDOUT_FILE_NO)
5a17353c	428	{
b109e79a ILT	429	if (dup2 (out, STDOUT_FILE_NO) < 0)
	430	pex_child_error (obj, executable, "dup2", errno);
	431	if (close (out) < 0)
	432	pex_child_error (obj, executable, "close", errno);
	433	}
	434	if (errdes != STDERR_FILE_NO)
	435	{
	436	if (dup2 (errdes, STDERR_FILE_NO) < 0)
	437	pex_child_error (obj, executable, "dup2", errno);
	438	if (close (errdes) < 0)
	439	pex_child_error (obj, executable, "close", errno);
	440	}
cb6c09ac DD	441	if (toclose >= 0)
	442	{
	443	if (close (toclose) < 0)
	444	pex_child_error (obj, executable, "close", errno);
	445	}
b109e79a ILT	446	if ((flags & PEX_STDERR_TO_STDOUT) != 0)
	447	{
	448	if (dup2 (STDOUT_FILE_NO, STDERR_FILE_NO) < 0)
	449	pex_child_error (obj, executable, "dup2", errno);
	450	}
014a8caf DD	451
014a8caf DD	452	if (env)
7741be99	453	environ = (char**) env;
014a8caf	454
b109e79a ILT	455	if ((flags & PEX_SEARCH) != 0)
b109e79a ILT	456	{
9fef968a	457	execvp (executable, to_ptr32 (argv));
b109e79a	458	pex_child_error (obj, executable, "execvp", errno);
5a17353c	459	}
12a7367e	460	else
b109e79a	461	{
9fef968a	462	execv (executable, to_ptr32 (argv));
b109e79a ILT	463	pex_child_error (obj, executable, "execv", errno);
b109e79a ILT	464	}
12a7367e	465
5a17353c	466	/* NOTREACHED */
29d89e07	467	return (pid_t) -1;
5a17353c DD	468
5a17353c DD	469	default:
b109e79a ILT	470	/* Parent process. */
	471	if (in != STDIN_FILE_NO)
	472	{
	473	if (close (in) < 0)
	474	{
	475	*err = errno;
	476	*errmsg = "close";
29d89e07	477	return (pid_t) -1;
b109e79a ILT	478	}
	479	}
	480	if (out != STDOUT_FILE_NO)
	481	{
	482	if (close (out) < 0)
	483	{
	484	*err = errno;
	485	*errmsg = "close";
29d89e07	486	return (pid_t) -1;
b109e79a ILT	487	}
	488	}
	489	if (errdes != STDERR_FILE_NO)
	490	{
	491	if (close (errdes) < 0)
	492	{
	493	*err = errno;
	494	*errmsg = "close";
29d89e07	495	return (pid_t) -1;
b109e79a ILT	496	}
	497	}
	498
29d89e07	499	return pid;
5a17353c DD	500	}
	501	}
	502
b109e79a ILT	503	/* Wait for a child process to complete. */
	504
	505	static int
29d89e07	506	pex_unix_wait (struct pex_obj obj, pid_t pid, int status,
b109e79a ILT	507	struct pex_time time, int done, const char *errmsg,
b109e79a ILT	508	int *err)
5a17353c	509	{
b109e79a ILT	510	/* If we are cleaning up when the caller didn't retrieve process
	511	status for some reason, encourage the process to go away. */
	512	if (done)
	513	kill (pid, SIGTERM);
	514
	515	if (pex_wait (obj, pid, status, time) < 0)
	516	{
	517	*err = errno;
	518	*errmsg = "wait";
	519	return -1;
	520	}
	521
	522	return 0;
	523	}
	524
	525	/* Create a pipe. */
	526
	527	static int
	528	pex_unix_pipe (struct pex_obj obj ATTRIBUTE_UNUSED, int p,
	529	int binary ATTRIBUTE_UNUSED)
	530	{
	531	return pipe (p);
	532	}
	533
	534	/* Get a FILE pointer to read from a file descriptor. */
	535
	536	static FILE *
	537	pex_unix_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
	538	int binary ATTRIBUTE_UNUSED)
	539	{
	540	return fdopen (fd, "r");
	541	}
	542
3db2e6dd DD	543	static FILE *
	544	pex_unix_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
	545	int binary ATTRIBUTE_UNUSED)
	546	{
	547	if (fcntl (fd, F_SETFD, FD_CLOEXEC) < 0)
	548	return NULL;
	549	return fdopen (fd, "w");
	550	}
	551
b109e79a ILT	552	static void
	553	pex_unix_cleanup (struct pex_obj *obj ATTRIBUTE_UNUSED)
	554	{
	555	#if !defined (HAVE_WAIT4) && !defined (HAVE_WAITPID)
	556	while (obj->sysdep != NULL)
	557	{
	558	struct status_list *this;
	559	struct status_list *next;
	560
	561	this = (struct status_list *) obj->sysdep;
	562	next = this->next;
	563	free (this);
	564	obj->sysdep = (void *) next;
	565	}
	566	#endif
5a17353c	567	}