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