[binutils.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., 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
#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 = 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 long 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 *, 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 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 long
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 -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, 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 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).
1e45deed	4	Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005
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
	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
5a17353c	73
b109e79a ILT	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	}
12a7367e	166
b109e79a ILT	167	return ret;
b109e79a ILT	168	}
5a17353c	169
b109e79a	170	#endif /* defined (HAVE_GETRUSAGE) */
5a17353c	171
b109e79a ILT	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)
5a17353c	190	{
b109e79a	191	if ((*pp)->pid == pid)
5a17353c	192	{
b109e79a ILT	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;
5a17353c	202	}
5a17353c	203	}
b109e79a ILT	204
b109e79a ILT	205	while (1)
5a17353c	206	{
b109e79a ILT	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
abf6a75b	255	psl = XNEW (struct status_list);
b109e79a ILT	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;
5a17353c	262	}
b109e79a ILT	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 ,
014a8caf	273	char * const , char const *,
cb6c09ac DD	274	int, int, int, int,
cb6c09ac DD	275	const char *, int );
b109e79a ILT	276	static int pex_unix_close (struct pex_obj *, int);
	277	static int pex_unix_wait (struct pex_obj , long, int , struct pex_time *,
	278	int, const char *, int );
	279	static int pex_unix_pipe (struct pex_obj , int , int);
	280	static FILE pex_unix_fdopenr (struct pex_obj , int, int);
3db2e6dd	281	static FILE pex_unix_fdopenw (struct pex_obj , int, int);
b109e79a ILT	282	static void pex_unix_cleanup (struct pex_obj *);
	283
	284	/* The list of functions we pass to the common routines. */
	285
	286	const struct pex_funcs funcs =
	287	{
	288	pex_unix_open_read,
	289	pex_unix_open_write,
	290	pex_unix_exec_child,
	291	pex_unix_close,
	292	pex_unix_wait,
	293	pex_unix_pipe,
	294	pex_unix_fdopenr,
3db2e6dd	295	pex_unix_fdopenw,
b109e79a ILT	296	pex_unix_cleanup
	297	};
	298
	299	/* Return a newly initialized pex_obj structure. */
	300
	301	struct pex_obj *
	302	pex_init (int flags, const char pname, const char tempbase)
	303	{
	304	return pex_init_common (flags, pname, tempbase, &funcs);
	305	}
	306
	307	/* Open a file for reading. */
	308
	309	static int
	310	pex_unix_open_read (struct pex_obj obj ATTRIBUTE_UNUSED, const char name,
	311	int binary ATTRIBUTE_UNUSED)
	312	{
	313	return open (name, O_RDONLY);
	314	}
	315
	316	/* Open a file for writing. */
	317
	318	static int
	319	pex_unix_open_write (struct pex_obj obj ATTRIBUTE_UNUSED, const char name,
	320	int binary ATTRIBUTE_UNUSED)
	321	{
	322	/* Note that we can't use O_EXCL here because gcc may have already
	323	created the temporary file via make_temp_file. */
	324	return open (name, O_WRONLY \| O_CREAT \| O_TRUNC, PUBLIC_MODE);
	325	}
5a17353c	326
b109e79a ILT	327	/* Close a file. */
	328
	329	static int
	330	pex_unix_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
	331	{
	332	return close (fd);
	333	}
	334
	335	/* Report an error from a child process. We don't use stdio routines,
	336	because we might be here due to a vfork call. */
	337
	338	static void
	339	pex_child_error (struct pex_obj obj, const char executable,
	340	const char *errmsg, int err)
	341	{
0bbe7a79	342	#define writeerr(s) (void) write (STDERR_FILE_NO, s, strlen (s))
b109e79a ILT	343	writeerr (obj->pname);
	344	writeerr (": error trying to exec '");
	345	writeerr (executable);
	346	writeerr ("': ");
	347	writeerr (errmsg);
	348	writeerr (": ");
	349	writeerr (xstrerror (err));
	350	writeerr ("\n");
	351	_exit (-1);
	352	}
	353
	354	/* Execute a child. */
	355
014a8caf DD	356	extern char **environ;
014a8caf DD	357
b109e79a ILT	358	static long
b109e79a ILT	359	pex_unix_exec_child (struct pex_obj obj, int flags, const char executable,
014a8caf DD	360	char * const * argv, char * const * env,
014a8caf DD	361	int in, int out, int errdes,
cb6c09ac	362	int toclose, const char *errmsg, int err)
b109e79a ILT	363	{
b109e79a ILT	364	pid_t pid;
014a8caf	365
b109e79a ILT	366	/* We declare these to be volatile to avoid warnings from gcc about
	367	them being clobbered by vfork. */
	368	volatile int sleep_interval;
	369	volatile int retries;
12a7367e	370
5a17353c DD	371	sleep_interval = 1;
5a17353c DD	372	pid = -1;
b109e79a	373	for (retries = 0; retries < 4; ++retries)
5a17353c	374	{
12a7367e	375	pid = vfork ();
5a17353c DD	376	if (pid >= 0)
	377	break;
	378	sleep (sleep_interval);
	379	sleep_interval *= 2;
	380	}
	381
	382	switch (pid)
	383	{
	384	case -1:
b109e79a ILT	385	*err = errno;
b109e79a ILT	386	*errmsg = VFORK_STRING;
5a17353c DD	387	return -1;
5a17353c DD	388
b109e79a ILT	389	case 0:
	390	/* Child process. */
	391	if (in != STDIN_FILE_NO)
5a17353c	392	{
b109e79a ILT	393	if (dup2 (in, STDIN_FILE_NO) < 0)
	394	pex_child_error (obj, executable, "dup2", errno);
	395	if (close (in) < 0)
	396	pex_child_error (obj, executable, "close", errno);
5a17353c	397	}
b109e79a	398	if (out != STDOUT_FILE_NO)
5a17353c	399	{
b109e79a ILT	400	if (dup2 (out, STDOUT_FILE_NO) < 0)
	401	pex_child_error (obj, executable, "dup2", errno);
	402	if (close (out) < 0)
	403	pex_child_error (obj, executable, "close", errno);
	404	}
	405	if (errdes != STDERR_FILE_NO)
	406	{
	407	if (dup2 (errdes, STDERR_FILE_NO) < 0)
	408	pex_child_error (obj, executable, "dup2", errno);
	409	if (close (errdes) < 0)
	410	pex_child_error (obj, executable, "close", errno);
	411	}
cb6c09ac DD	412	if (toclose >= 0)
	413	{
	414	if (close (toclose) < 0)
	415	pex_child_error (obj, executable, "close", errno);
	416	}
b109e79a ILT	417	if ((flags & PEX_STDERR_TO_STDOUT) != 0)
	418	{
	419	if (dup2 (STDOUT_FILE_NO, STDERR_FILE_NO) < 0)
	420	pex_child_error (obj, executable, "dup2", errno);
	421	}
014a8caf DD	422
014a8caf DD	423	if (env)
7741be99	424	environ = (char**) env;
014a8caf	425
b109e79a ILT	426	if ((flags & PEX_SEARCH) != 0)
	427	{
	428	execvp (executable, argv);
	429	pex_child_error (obj, executable, "execvp", errno);
5a17353c	430	}
12a7367e	431	else
b109e79a ILT	432	{
	433	execv (executable, argv);
	434	pex_child_error (obj, executable, "execv", errno);
	435	}
12a7367e	436
5a17353c	437	/* NOTREACHED */
b109e79a	438	return -1;
5a17353c DD	439
5a17353c DD	440	default:
b109e79a ILT	441	/* Parent process. */
	442	if (in != STDIN_FILE_NO)
	443	{
	444	if (close (in) < 0)
	445	{
	446	*err = errno;
	447	*errmsg = "close";
	448	return -1;
	449	}
	450	}
	451	if (out != STDOUT_FILE_NO)
	452	{
	453	if (close (out) < 0)
	454	{
	455	*err = errno;
	456	*errmsg = "close";
	457	return -1;
	458	}
	459	}
	460	if (errdes != STDERR_FILE_NO)
	461	{
	462	if (close (errdes) < 0)
	463	{
	464	*err = errno;
	465	*errmsg = "close";
	466	return -1;
	467	}
	468	}
	469
	470	return (long) pid;
5a17353c DD	471	}
	472	}
	473
b109e79a ILT	474	/* Wait for a child process to complete. */
	475
	476	static int
	477	pex_unix_wait (struct pex_obj obj, long pid, int status,
	478	struct pex_time time, int done, const char *errmsg,
	479	int *err)
5a17353c	480	{
b109e79a ILT	481	/* If we are cleaning up when the caller didn't retrieve process
	482	status for some reason, encourage the process to go away. */
	483	if (done)
	484	kill (pid, SIGTERM);
	485
	486	if (pex_wait (obj, pid, status, time) < 0)
	487	{
	488	*err = errno;
	489	*errmsg = "wait";
	490	return -1;
	491	}
	492
	493	return 0;
	494	}
	495
	496	/* Create a pipe. */
	497
	498	static int
	499	pex_unix_pipe (struct pex_obj obj ATTRIBUTE_UNUSED, int p,
	500	int binary ATTRIBUTE_UNUSED)
	501	{
	502	return pipe (p);
	503	}
	504
	505	/* Get a FILE pointer to read from a file descriptor. */
	506
	507	static FILE *
	508	pex_unix_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
	509	int binary ATTRIBUTE_UNUSED)
	510	{
	511	return fdopen (fd, "r");
	512	}
	513
3db2e6dd DD	514	static FILE *
	515	pex_unix_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
	516	int binary ATTRIBUTE_UNUSED)
	517	{
	518	if (fcntl (fd, F_SETFD, FD_CLOEXEC) < 0)
	519	return NULL;
	520	return fdopen (fd, "w");
	521	}
	522
b109e79a ILT	523	static void
	524	pex_unix_cleanup (struct pex_obj *obj ATTRIBUTE_UNUSED)
	525	{
	526	#if !defined (HAVE_WAIT4) && !defined (HAVE_WAITPID)
	527	while (obj->sysdep != NULL)
	528	{
	529	struct status_list *this;
	530	struct status_list *next;
	531
	532	this = (struct status_list *) obj->sysdep;
	533	next = this->next;
	534	free (this);
	535	obj->sysdep = (void *) next;
	536	}
	537	#endif
5a17353c	538	}