[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
   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., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, 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
#ifdef VMS
#define vfork() (decc$$alloc_vfork_blocks() >= 0 ? \
               lib$get_current_invo_context(decc$$get_vfork_jmpbuf()) : -1)
#endif /* VMS */


/* 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 = xmalloc (sizeof (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 long pex_unix_exec_child (struct pex_obj *, int, const char *,
				 char * const *, int, int, int,
				 const char **, int *);
static int pex_unix_close (struct pex_obj *, int);
static int pex_unix_wait (struct pex_obj *, long, 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 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_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) 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.  */

static long
pex_unix_exec_child (struct pex_obj *obj, int flags, const char *executable,
		     char * const * argv, int in, int out, int errdes,
		     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 -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 ((flags & PEX_STDERR_TO_STDOUT) != 0)
	{
	  if (dup2 (STDOUT_FILE_NO, STDERR_FILE_NO) < 0)
	    pex_child_error (obj, executable, "dup2", errno);
	}
      if ((flags & PEX_SEARCH) != 0)
	{
	  execvp (executable, argv);
	  pex_child_error (obj, executable, "execvp", errno);
	}
      else
	{
	  execv (executable, argv);
	  pex_child_error (obj, executable, "execv", errno);
	}

      /* NOTREACHED */
      return -1;

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

      return (long) pid;
    }
}

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

static int
pex_unix_wait (struct pex_obj *obj, long 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 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
8cb0536d	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).
f8d9d6a0	4	Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005
8cb0536d	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,
	20	write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	21	Boston, MA 02111-1307, USA. */
	22
22683dca	23	#include "config.h"
22683dca	24	#include "libiberty.h"
8cb0536d	25	#include "pex-common.h"
	26
	27	#include <stdio.h>
22683dca	28	#include <signal.h>
8cb0536d	29	#include <errno.h>
	30	#ifdef NEED_DECLARATION_ERRNO
	31	extern int errno;
	32	#endif
22683dca	33	#ifdef HAVE_STDLIB_H
	34	#include <stdlib.h>
	35	#endif
8cb0536d	36	#ifdef HAVE_STRING_H
	37	#include <string.h>
	38	#endif
	39	#ifdef HAVE_UNISTD_H
	40	#include <unistd.h>
	41	#endif
22683dca	42
	43	#include <sys/types.h>
	44
	45	#ifdef HAVE_FCNTL_H
	46	#include <fcntl.h>
8cb0536d	47	#endif
	48	#ifdef HAVE_SYS_WAIT_H
	49	#include <sys/wait.h>
	50	#endif
22683dca	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>
8cb0536d	57	#endif
8cb0536d	58
22683dca	59
e1e51a4a	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
	68	#ifdef VMS
	69	#define vfork() (decc$$alloc_vfork_blocks() >= 0 ? \
	70	lib$get_current_invo_context(decc$$get_vfork_jmpbuf()) : -1)
	71	#endif /* VMS */
	72
8cb0536d	73
22683dca	74	/* File mode to use for private and world-readable files. */
	75
	76	#if defined (S_IRUSR) && defined (S_IWUSR) && defined (S_IRGRP) && defined (S_IWGRP) && defined (S_IROTH) && defined (S_IWOTH)
	77	#define PUBLIC_MODE \
	78	(S_IRUSR \| S_IWUSR \| S_IRGRP \| S_IWGRP \| S_IROTH \| S_IWOTH)
	79	#else
	80	#define PUBLIC_MODE 0666
	81	#endif
	82
	83	/* Get the exit status of a particular process, and optionally get the
	84	time that it took. This is simple if we have wait4, slightly
	85	harder if we have waitpid, and is a pain if we only have wait. */
	86
	87	static pid_t pex_wait (struct pex_obj , pid_t, int , struct pex_time *);
	88
	89	#ifdef HAVE_WAIT4
	90
	91	static pid_t
	92	pex_wait (struct pex_obj obj ATTRIBUTE_UNUSED, pid_t pid, int status,
	93	struct pex_time *time)
	94	{
	95	pid_t ret;
	96	struct rusage r;
	97
	98	#ifdef HAVE_WAITPID
	99	if (time == NULL)
	100	return waitpid (pid, status, 0);
	101	#endif
	102
	103	ret = wait4 (pid, status, 0, &r);
	104
	105	if (time != NULL)
	106	{
	107	time->user_seconds = r.ru_utime.tv_sec;
	108	time->user_microseconds= r.ru_utime.tv_usec;
	109	time->system_seconds = r.ru_stime.tv_sec;
	110	time->system_microseconds= r.ru_stime.tv_usec;
	111	}
	112
	113	return ret;
	114	}
	115
	116	#else /* ! defined (HAVE_WAIT4) */
	117
	118	#ifdef HAVE_WAITPID
	119
	120	#ifndef HAVE_GETRUSAGE
	121
	122	static pid_t
	123	pex_wait (struct pex_obj obj ATTRIBUTE_UNUSED, pid_t pid, int status,
	124	struct pex_time *time)
	125	{
	126	if (time != NULL)
	127	memset (time, 0, sizeof (struct pex_time));
	128	return waitpid (pid, status, 0);
	129	}
	130
	131	#else /* defined (HAVE_GETRUSAGE) */
	132
	133	static pid_t
	134	pex_wait (struct pex_obj obj ATTRIBUTE_UNUSED, pid_t pid, int status,
	135	struct pex_time *time)
	136	{
	137	struct rusage r1, r2;
138	pid_t ret;
139
140	if (time == NULL)
141	return waitpid (pid, status, 0);
142
143	getrusage (RUSAGE_CHILDREN, &r1);
144
145	ret = waitpid (pid, status, 0);
146	if (ret < 0)
147	return ret;
148
149	getrusage (RUSAGE_CHILDREN, &r2);
150
151	time->user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
152	time->user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
153	if (r2.ru_utime.tv_usec < r1.ru_utime.tv_usec)
154	{
155	--time->user_seconds;
156	time->user_microseconds += 1000000;
157	}
158
159	time->system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
160	time->system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
161	if (r2.ru_stime.tv_usec < r1.ru_stime.tv_usec)
162	{
163	--time->system_seconds;
164	time->system_microseconds += 1000000;
165	}
e1e51a4a	166
22683dca	167	return ret;
22683dca	168	}
8cb0536d	169
22683dca	170	#endif /* defined (HAVE_GETRUSAGE) */
8cb0536d	171
22683dca	172	#else /* ! defined (HAVE_WAITPID) */
	173
	174	struct status_list
	175	{
	176	struct status_list *next;
	177	pid_t pid;
	178	int status;
	179	struct pex_time time;
	180	};
	181
	182	static pid_t
	183	pex_wait (struct pex_obj obj, pid_t pid, int status, struct pex_time *time)
	184	{
	185	struct status_list **pp;
	186
	187	for (pp = (struct status_list **) &obj->sysdep;
	188	*pp != NULL;
	189	pp = &(*pp)->next)
8cb0536d	190	{
22683dca	191	if ((*pp)->pid == pid)
8cb0536d	192	{
22683dca	193	struct status_list *p;
	194
	195	p = *pp;
	196	*status = p->status;
	197	if (time != NULL)
	198	*time = p->time;
	199	*pp = p->next;
	200	free (p);
	201	return pid;
8cb0536d	202	}
8cb0536d	203	}
22683dca	204
22683dca	205	while (1)
8cb0536d	206	{
22683dca	207	pid_t cpid;
	208	struct status_list *psl;
	209	struct pex_time pt;
	210	#ifdef HAVE_GETRUSAGE
	211	struct rusage r1, r2;
	212	#endif
	213
	214	if (time != NULL)
	215	{
	216	#ifdef HAVE_GETRUSAGE
	217	getrusage (RUSAGE_CHILDREN, &r1);
	218	#else
	219	memset (&pt, 0, sizeof (struct pex_time));
	220	#endif
	221	}
	222
	223	cpid = wait (status);
	224
	225	#ifdef HAVE_GETRUSAGE
	226	if (time != NULL && cpid >= 0)
	227	{
	228	getrusage (RUSAGE_CHILDREN, &r2);
	229
	230	pt.user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
	231	pt.user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
	232	if (pt.user_microseconds < 0)
	233	{
	234	--pt.user_seconds;
	235	pt.user_microseconds += 1000000;
	236	}
	237
	238	pt.system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
	239	pt.system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
	240	if (pt.system_microseconds < 0)
	241	{
	242	--pt.system_seconds;
	243	pt.system_microseconds += 1000000;
	244	}
	245	}
	246	#endif
	247
	248	if (cpid < 0 \|\| cpid == pid)
	249	{
	250	if (time != NULL)
	251	*time = pt;
	252	return cpid;
	253	}
	254
	255	psl = xmalloc (sizeof (struct status_list));
	256	psl->pid = cpid;
	257	psl->status = *status;
	258	if (time != NULL)
	259	psl->time = pt;
	260	psl->next = (struct status_list *) obj->sysdep;
	261	obj->sysdep = (void *) psl;
8cb0536d	262	}
22683dca	263	}
	264
	265	#endif /* ! defined (HAVE_WAITPID) */
	266	#endif /* ! defined (HAVE_WAIT4) */
	267
	268	static void pex_child_error (struct pex_obj , const char , const char *, int)
	269	ATTRIBUTE_NORETURN;
	270	static int pex_unix_open_read (struct pex_obj , const char , int);
	271	static int pex_unix_open_write (struct pex_obj , const char , int);
	272	static long pex_unix_exec_child (struct pex_obj , int, const char ,
	273	char * const *, int, int, int,
	274	const char *, int );
	275	static int pex_unix_close (struct pex_obj *, int);
	276	static int pex_unix_wait (struct pex_obj , long, int , struct pex_time *,
	277	int, const char *, int );
	278	static int pex_unix_pipe (struct pex_obj , int , int);
	279	static FILE pex_unix_fdopenr (struct pex_obj , int, int);
	280	static void pex_unix_cleanup (struct pex_obj *);
	281
	282	/* The list of functions we pass to the common routines. */
	283
	284	const struct pex_funcs funcs =
	285	{
	286	pex_unix_open_read,
	287	pex_unix_open_write,
	288	pex_unix_exec_child,
	289	pex_unix_close,
	290	pex_unix_wait,
	291	pex_unix_pipe,
	292	pex_unix_fdopenr,
	293	pex_unix_cleanup
	294	};
	295
	296	/* Return a newly initialized pex_obj structure. */
	297
	298	struct pex_obj *
	299	pex_init (int flags, const char pname, const char tempbase)
	300	{
	301	return pex_init_common (flags, pname, tempbase, &funcs);
	302	}
	303
	304	/* Open a file for reading. */
	305
	306	static int
	307	pex_unix_open_read (struct pex_obj obj ATTRIBUTE_UNUSED, const char name,
	308	int binary ATTRIBUTE_UNUSED)
	309	{
	310	return open (name, O_RDONLY);
	311	}
	312
	313	/* Open a file for writing. */
	314
	315	static int
	316	pex_unix_open_write (struct pex_obj obj ATTRIBUTE_UNUSED, const char name,
	317	int binary ATTRIBUTE_UNUSED)
	318	{
	319	/* Note that we can't use O_EXCL here because gcc may have already
	320	created the temporary file via make_temp_file. */
	321	return open (name, O_WRONLY \| O_CREAT \| O_TRUNC, PUBLIC_MODE);
	322	}
8cb0536d	323
22683dca	324	/* Close a file. */
	325
	326	static int
	327	pex_unix_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
	328	{
	329	return close (fd);
	330	}
	331
	332	/* Report an error from a child process. We don't use stdio routines,
	333	because we might be here due to a vfork call. */
	334
	335	static void
	336	pex_child_error (struct pex_obj obj, const char executable,
	337	const char *errmsg, int err)
	338	{
	339	#define writeerr(s) write (STDERR_FILE_NO, s, strlen (s))
	340	writeerr (obj->pname);
	341	writeerr (": error trying to exec '");
	342	writeerr (executable);
	343	writeerr ("': ");
	344	writeerr (errmsg);
	345	writeerr (": ");
	346	writeerr (xstrerror (err));
	347	writeerr ("\n");
	348	_exit (-1);
	349	}
	350
	351	/* Execute a child. */
	352
	353	static long
	354	pex_unix_exec_child (struct pex_obj obj, int flags, const char executable,
	355	char * const * argv, int in, int out, int errdes,
	356	const char *errmsg, int err)
	357	{
	358	pid_t pid;
	359	/* We declare these to be volatile to avoid warnings from gcc about
	360	them being clobbered by vfork. */
	361	volatile int sleep_interval;
	362	volatile int retries;
e1e51a4a	363
8cb0536d	364	sleep_interval = 1;
8cb0536d	365	pid = -1;
22683dca	366	for (retries = 0; retries < 4; ++retries)
8cb0536d	367	{
e1e51a4a	368	pid = vfork ();
8cb0536d	369	if (pid >= 0)
	370	break;
	371	sleep (sleep_interval);
	372	sleep_interval *= 2;
	373	}
	374
	375	switch (pid)
	376	{
	377	case -1:
22683dca	378	*err = errno;
22683dca	379	*errmsg = VFORK_STRING;
8cb0536d	380	return -1;
8cb0536d	381
22683dca	382	case 0:
	383	/* Child process. */
	384	if (in != STDIN_FILE_NO)
8cb0536d	385	{
22683dca	386	if (dup2 (in, STDIN_FILE_NO) < 0)
	387	pex_child_error (obj, executable, "dup2", errno);
	388	if (close (in) < 0)
	389	pex_child_error (obj, executable, "close", errno);
8cb0536d	390	}
22683dca	391	if (out != STDOUT_FILE_NO)
8cb0536d	392	{
22683dca	393	if (dup2 (out, STDOUT_FILE_NO) < 0)
	394	pex_child_error (obj, executable, "dup2", errno);
	395	if (close (out) < 0)
	396	pex_child_error (obj, executable, "close", errno);
	397	}
	398	if (errdes != STDERR_FILE_NO)
	399	{
	400	if (dup2 (errdes, STDERR_FILE_NO) < 0)
	401	pex_child_error (obj, executable, "dup2", errno);
	402	if (close (errdes) < 0)
	403	pex_child_error (obj, executable, "close", errno);
	404	}
	405	if ((flags & PEX_STDERR_TO_STDOUT) != 0)
	406	{
	407	if (dup2 (STDOUT_FILE_NO, STDERR_FILE_NO) < 0)
	408	pex_child_error (obj, executable, "dup2", errno);
	409	}
	410	if ((flags & PEX_SEARCH) != 0)
	411	{
	412	execvp (executable, argv);
	413	pex_child_error (obj, executable, "execvp", errno);
8cb0536d	414	}
e1e51a4a	415	else
22683dca	416	{
	417	execv (executable, argv);
	418	pex_child_error (obj, executable, "execv", errno);
	419	}
e1e51a4a	420
8cb0536d	421	/* NOTREACHED */
22683dca	422	return -1;
8cb0536d	423
8cb0536d	424	default:
22683dca	425	/* Parent process. */
	426	if (in != STDIN_FILE_NO)
	427	{
	428	if (close (in) < 0)
	429	{
	430	*err = errno;
	431	*errmsg = "close";
	432	return -1;
	433	}
	434	}
	435	if (out != STDOUT_FILE_NO)
	436	{
	437	if (close (out) < 0)
	438	{
	439	*err = errno;
	440	*errmsg = "close";
	441	return -1;
	442	}
	443	}
	444	if (errdes != STDERR_FILE_NO)
	445	{
	446	if (close (errdes) < 0)
	447	{
	448	*err = errno;
	449	*errmsg = "close";
	450	return -1;
	451	}
	452	}
	453
	454	return (long) pid;
8cb0536d	455	}
	456	}
	457
22683dca	458	/* Wait for a child process to complete. */
	459
	460	static int
	461	pex_unix_wait (struct pex_obj obj, long pid, int status,
	462	struct pex_time time, int done, const char *errmsg,
	463	int *err)
8cb0536d	464	{
22683dca	465	/* If we are cleaning up when the caller didn't retrieve process
	466	status for some reason, encourage the process to go away. */
	467	if (done)
	468	kill (pid, SIGTERM);
	469
	470	if (pex_wait (obj, pid, status, time) < 0)
	471	{
	472	*err = errno;
	473	*errmsg = "wait";
	474	return -1;
	475	}
	476
	477	return 0;
	478	}
	479
	480	/* Create a pipe. */
	481
	482	static int
	483	pex_unix_pipe (struct pex_obj obj ATTRIBUTE_UNUSED, int p,
	484	int binary ATTRIBUTE_UNUSED)
	485	{
	486	return pipe (p);
	487	}
	488
	489	/* Get a FILE pointer to read from a file descriptor. */
	490
	491	static FILE *
	492	pex_unix_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
	493	int binary ATTRIBUTE_UNUSED)
	494	{
	495	return fdopen (fd, "r");
	496	}
	497
	498	static void
	499	pex_unix_cleanup (struct pex_obj *obj ATTRIBUTE_UNUSED)
	500	{
	501	#if !defined (HAVE_WAIT4) && !defined (HAVE_WAITPID)
	502	while (obj->sysdep != NULL)
	503	{
	504	struct status_list *this;
	505	struct status_list *next;
	506
	507	this = (struct status_list *) obj->sysdep;
	508	next = this->next;
	509	free (this);
	510	obj->sysdep = (void *) next;
	511	}
	512	#endif
8cb0536d	513	}