[deliverable/binutils-gdb.git] / libiberty / pex-djgpp.c

/* Utilities to execute a program in a subprocess (possibly linked by pipes
   with other subprocesses), and wait for it.  DJGPP specialization.
   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 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 "pex-common.h"

#include <stdio.h>
#include <errno.h>
#ifdef NEED_DECLARATION_ERRNO
extern int errno;
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <process.h>

/* Use ECHILD if available, otherwise use EINVAL.  */
#ifdef ECHILD
#define PWAIT_ERROR ECHILD
#else
#define PWAIT_ERROR EINVAL
#endif

static int pex_djgpp_open_read (struct pex_obj *, const char *, int);
static int pex_djgpp_open_write (struct pex_obj *, const char *, int, int);
static pid_t pex_djgpp_exec_child (struct pex_obj *, int, const char *,
				  char * const *, char * const *,
				  int, int, int, int,
				  const char **, int *);
static int pex_djgpp_close (struct pex_obj *, int);
static pid_t pex_djgpp_wait (struct pex_obj *, pid_t, int *, struct pex_time *,
			   int, const char **, int *);

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

const struct pex_funcs funcs =
{
  pex_djgpp_open_read,
  pex_djgpp_open_write,
  pex_djgpp_exec_child,
  pex_djgpp_close,
  pex_djgpp_wait,
  NULL, /* pipe */
  NULL, /* fdopenr */
  NULL, /* fdopenw */
  NULL  /* cleanup */
};

/* Return a newly initialized pex_obj structure.  */

struct pex_obj *
pex_init (int flags, const char *pname, const char *tempbase)
{
  /* DJGPP does not support pipes.  */
  flags &= ~ PEX_USE_PIPES;
  return pex_init_common (flags, pname, tempbase, &funcs);
}

/* Open a file for reading.  */

static int
pex_djgpp_open_read (struct pex_obj *obj ATTRIBUTE_UNUSED,
		     const char *name, int binary)
{
  return open (name, O_RDONLY | (binary ? O_BINARY : O_TEXT));
}

/* Open a file for writing.  */

static int
pex_djgpp_open_write (struct pex_obj *obj ATTRIBUTE_UNUSED,
		      const char *name, int binary, int append)
{
  /* Note that we can't use O_EXCL here because gcc may have already
     created the temporary file via make_temp_file.  */
  if (append)
    return -1;
  return open (name,
	       (O_WRONLY | O_CREAT | O_TRUNC
		| (binary ? O_BINARY : O_TEXT)),
	       S_IRUSR | S_IWUSR);
}

/* Close a file.  */

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

/* Execute a child.  */

static pid_t
pex_djgpp_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 ATTRIBUTE_UNUSED, const char **errmsg,
		      int *err)
{
  int org_in, org_out, org_errdes;
  int status;
  int *statuses;

  org_in = -1;
  org_out = -1;
  org_errdes = -1;

  if (in != STDIN_FILE_NO)
    {
      org_in = dup (STDIN_FILE_NO);
      if (org_in < 0)
	{
	  *err = errno;
	  *errmsg = "dup";
	  return (pid_t) -1;
	}
      if (dup2 (in, STDIN_FILE_NO) < 0)
	{
	  *err = errno;
	  *errmsg = "dup2";
	  return (pid_t) -1;
	}
      if (close (in) < 0)
	{
	  *err = errno;
	  *errmsg = "close";
	  return (pid_t) -1;
	}
    }

  if (out != STDOUT_FILE_NO)
    {
      org_out = dup (STDOUT_FILE_NO);
      if (org_out < 0)
	{
	  *err = errno;
	  *errmsg = "dup";
	  return (pid_t) -1;
	}
      if (dup2 (out, STDOUT_FILE_NO) < 0)
	{
	  *err = errno;
	  *errmsg = "dup2";
	  return (pid_t) -1;
	}
      if (close (out) < 0)
	{
	  *err = errno;
	  *errmsg = "close";
	  return (pid_t) -1;
	}
    }

  if (errdes != STDERR_FILE_NO
      || (flags & PEX_STDERR_TO_STDOUT) != 0)
    {
      org_errdes = dup (STDERR_FILE_NO);
      if (org_errdes < 0)
	{
	  *err = errno;
	  *errmsg = "dup";
	  return (pid_t) -1;
	}
      if (dup2 ((flags & PEX_STDERR_TO_STDOUT) != 0 ? STDOUT_FILE_NO : errdes,
		 STDERR_FILE_NO) < 0)
	{
	  *err = errno;
	  *errmsg = "dup2";
	  return (pid_t) -1;
	}
      if (errdes != STDERR_FILE_NO)
	{
	  if (close (errdes) < 0)
	    {
	      *err = errno;
	      *errmsg = "close";
	      return (pid_t) -1;
	    }
	}
    }

  if (env)
    status = (((flags & PEX_SEARCH) != 0 ? spawnvpe : spawnve)
	      (P_WAIT, executable, argv, env));
  else
    status = (((flags & PEX_SEARCH) != 0 ? spawnvp : spawnv)
  	      (P_WAIT, executable, argv));

  if (status == -1)
    {
      *err = errno;
      *errmsg = ((flags & PEX_SEARCH) != 0) ? "spawnvp" : "spawnv";
    }

  if (in != STDIN_FILE_NO)
    {
      if (dup2 (org_in, STDIN_FILE_NO) < 0)
	{
	  *err = errno;
	  *errmsg = "dup2";
	  return (pid_t) -1;
	}
      if (close (org_in) < 0)
	{
	  *err = errno;
	  *errmsg = "close";
	  return (pid_t) -1;
	}
    }

  if (out != STDOUT_FILE_NO)
    {
      if (dup2 (org_out, STDOUT_FILE_NO) < 0)
	{
	  *err = errno;
	  *errmsg = "dup2";
	  return (pid_t) -1;
	}
      if (close (org_out) < 0)
	{
	  *err = errno;
	  *errmsg = "close";
	  return (pid_t) -1;
	}
    }

  if (errdes != STDERR_FILE_NO
      || (flags & PEX_STDERR_TO_STDOUT) != 0)
    {
      if (dup2 (org_errdes, STDERR_FILE_NO) < 0)
	{
	  *err = errno;
	  *errmsg = "dup2";
	  return (pid_t) -1;
	}
      if (close (org_errdes) < 0)
	{
	  *err = errno;
	  *errmsg = "close";
	  return (pid_t) -1;
	}
    }

  /* Save the exit status for later.  When we are called, obj->count
     is the number of children which have executed before this
     one.  */
  statuses = (int *) obj->sysdep;
  statuses = XRESIZEVEC (int, statuses, obj->count + 1);
  statuses[obj->count] = status;
  obj->sysdep = (void *) statuses;

  return (pid_t) obj->count;
}

/* Wait for a child process to complete.  Actually the child process
   has already completed, and we just need to return the exit
   status.  */

static pid_t
pex_djgpp_wait (struct pex_obj *obj, pid_t pid, int *status,
		struct pex_time *time, int done ATTRIBUTE_UNUSED,
		const char **errmsg ATTRIBUTE_UNUSED,
		int *err ATTRIBUTE_UNUSED)
{
  int *statuses;

  if (time != NULL)
    memset (time, 0, sizeof *time);

  statuses = (int *) obj->sysdep;
  *status = statuses[pid];

  return 0;
}
Commit	Line	Data
	1	/* Utilities to execute a program in a subprocess (possibly linked by pipes
	2	with other subprocesses), and wait for it. DJGPP specialization.
	3	Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2005
	4	Free Software Foundation, Inc.
	5
	6	This file is part of the libiberty library.
	7	Libiberty is free software; you can redistribute it and/or
	8	modify it under the terms of the GNU Library General Public
	9	License as published by the Free Software Foundation; either
	10	version 2 of the License, or (at your option) any later version.
	11
	12	Libiberty is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	Library General Public License for more details.
	16
	17	You should have received a copy of the GNU Library General Public
	18	License along with libiberty; see the file COPYING.LIB. If not,
	19	write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
	20	Boston, MA 02110-1301, USA. */
	21
	22	#include "pex-common.h"
	23
	24	#include <stdio.h>
	25	#include <errno.h>
	26	#ifdef NEED_DECLARATION_ERRNO
	27	extern int errno;
	28	#endif
	29	#ifdef HAVE_STDLIB_H
	30	#include <stdlib.h>
	31	#endif
	32	#include <string.h>
	33	#include <fcntl.h>
	34	#include <unistd.h>
	35	#include <sys/stat.h>
	36	#include <process.h>
	37
	38	/* Use ECHILD if available, otherwise use EINVAL. */
	39	#ifdef ECHILD
	40	#define PWAIT_ERROR ECHILD
	41	#else
	42	#define PWAIT_ERROR EINVAL
	43	#endif
	44
	45	static int pex_djgpp_open_read (struct pex_obj , const char , int);
	46	static int pex_djgpp_open_write (struct pex_obj , const char , int, int);
	47	static pid_t pex_djgpp_exec_child (struct pex_obj , int, const char ,
	48	char * const , char const *,
	49	int, int, int, int,
	50	const char *, int );
	51	static int pex_djgpp_close (struct pex_obj *, int);
	52	static pid_t pex_djgpp_wait (struct pex_obj , pid_t, int , struct pex_time *,
	53	int, const char *, int );
	54
	55	/* The list of functions we pass to the common routines. */
	56
	57	const struct pex_funcs funcs =
	58	{
	59	pex_djgpp_open_read,
	60	pex_djgpp_open_write,
	61	pex_djgpp_exec_child,
	62	pex_djgpp_close,
	63	pex_djgpp_wait,
	64	NULL, /* pipe */
	65	NULL, /* fdopenr */
	66	NULL, /* fdopenw */
	67	NULL /* cleanup */
	68	};
	69
	70	/* Return a newly initialized pex_obj structure. */
	71
	72	struct pex_obj *
	73	pex_init (int flags, const char pname, const char tempbase)
	74	{
	75	/* DJGPP does not support pipes. */
	76	flags &= ~ PEX_USE_PIPES;
	77	return pex_init_common (flags, pname, tempbase, &funcs);
	78	}
	79
	80	/* Open a file for reading. */
	81
	82	static int
	83	pex_djgpp_open_read (struct pex_obj *obj ATTRIBUTE_UNUSED,
	84	const char *name, int binary)
	85	{
	86	return open (name, O_RDONLY \| (binary ? O_BINARY : O_TEXT));
	87	}
	88
	89	/* Open a file for writing. */
	90
	91	static int
	92	pex_djgpp_open_write (struct pex_obj *obj ATTRIBUTE_UNUSED,
	93	const char *name, int binary, int append)
	94	{
	95	/* Note that we can't use O_EXCL here because gcc may have already
	96	created the temporary file via make_temp_file. */
	97	if (append)
	98	return -1;
	99	return open (name,
	100	(O_WRONLY \| O_CREAT \| O_TRUNC
	101	\| (binary ? O_BINARY : O_TEXT)),
	102	S_IRUSR \| S_IWUSR);
	103	}
	104
	105	/* Close a file. */
	106
	107	static int
	108	pex_djgpp_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
	109	{
	110	return close (fd);
	111	}
	112
	113	/* Execute a child. */
	114
	115	static pid_t
	116	pex_djgpp_exec_child (struct pex_obj obj, int flags, const char executable,
	117	char * const * argv, char * const * env,
	118	int in, int out, int errdes,
	119	int toclose ATTRIBUTE_UNUSED, const char **errmsg,
	120	int *err)
	121	{
	122	int org_in, org_out, org_errdes;
	123	int status;
	124	int *statuses;
	125
	126	org_in = -1;
	127	org_out = -1;
	128	org_errdes = -1;
	129
	130	if (in != STDIN_FILE_NO)
	131	{
	132	org_in = dup (STDIN_FILE_NO);
	133	if (org_in < 0)
	134	{
	135	*err = errno;
	136	*errmsg = "dup";
	137	return (pid_t) -1;
	138	}
	139	if (dup2 (in, STDIN_FILE_NO) < 0)
	140	{
	141	*err = errno;
	142	*errmsg = "dup2";
	143	return (pid_t) -1;
	144	}
	145	if (close (in) < 0)
	146	{
	147	*err = errno;
	148	*errmsg = "close";
	149	return (pid_t) -1;
	150	}
	151	}
	152
	153	if (out != STDOUT_FILE_NO)
	154	{
	155	org_out = dup (STDOUT_FILE_NO);
	156	if (org_out < 0)
	157	{
	158	*err = errno;
	159	*errmsg = "dup";
	160	return (pid_t) -1;
	161	}
	162	if (dup2 (out, STDOUT_FILE_NO) < 0)
	163	{
	164	*err = errno;
	165	*errmsg = "dup2";
	166	return (pid_t) -1;
	167	}
	168	if (close (out) < 0)
	169	{
	170	*err = errno;
	171	*errmsg = "close";
	172	return (pid_t) -1;
	173	}
	174	}
	175
	176	if (errdes != STDERR_FILE_NO
	177	\|\| (flags & PEX_STDERR_TO_STDOUT) != 0)
	178	{
	179	org_errdes = dup (STDERR_FILE_NO);
	180	if (org_errdes < 0)
	181	{
	182	*err = errno;
	183	*errmsg = "dup";
	184	return (pid_t) -1;
	185	}
	186	if (dup2 ((flags & PEX_STDERR_TO_STDOUT) != 0 ? STDOUT_FILE_NO : errdes,
	187	STDERR_FILE_NO) < 0)
	188	{
	189	*err = errno;
	190	*errmsg = "dup2";
	191	return (pid_t) -1;
	192	}
	193	if (errdes != STDERR_FILE_NO)
	194	{
	195	if (close (errdes) < 0)
	196	{
	197	*err = errno;
	198	*errmsg = "close";
	199	return (pid_t) -1;
	200	}
	201	}
	202	}
	203
	204	if (env)
	205	status = (((flags & PEX_SEARCH) != 0 ? spawnvpe : spawnve)
	206	(P_WAIT, executable, argv, env));
	207	else
	208	status = (((flags & PEX_SEARCH) != 0 ? spawnvp : spawnv)
	209	(P_WAIT, executable, argv));
	210
	211	if (status == -1)
	212	{
	213	*err = errno;
	214	*errmsg = ((flags & PEX_SEARCH) != 0) ? "spawnvp" : "spawnv";
	215	}
	216
	217	if (in != STDIN_FILE_NO)
	218	{
	219	if (dup2 (org_in, STDIN_FILE_NO) < 0)
	220	{
	221	*err = errno;
	222	*errmsg = "dup2";
	223	return (pid_t) -1;
	224	}
	225	if (close (org_in) < 0)
	226	{
	227	*err = errno;
	228	*errmsg = "close";
	229	return (pid_t) -1;
	230	}
	231	}
	232
	233	if (out != STDOUT_FILE_NO)
	234	{
	235	if (dup2 (org_out, STDOUT_FILE_NO) < 0)
	236	{
	237	*err = errno;
	238	*errmsg = "dup2";
	239	return (pid_t) -1;
	240	}
	241	if (close (org_out) < 0)
	242	{
	243	*err = errno;
	244	*errmsg = "close";
	245	return (pid_t) -1;
	246	}
	247	}
	248
	249	if (errdes != STDERR_FILE_NO
	250	\|\| (flags & PEX_STDERR_TO_STDOUT) != 0)
	251	{
	252	if (dup2 (org_errdes, STDERR_FILE_NO) < 0)
	253	{
	254	*err = errno;
	255	*errmsg = "dup2";
	256	return (pid_t) -1;
	257	}
	258	if (close (org_errdes) < 0)
	259	{
	260	*err = errno;
	261	*errmsg = "close";
	262	return (pid_t) -1;
	263	}
	264	}
	265
	266	/* Save the exit status for later. When we are called, obj->count
	267	is the number of children which have executed before this
	268	one. */
	269	statuses = (int *) obj->sysdep;
	270	statuses = XRESIZEVEC (int, statuses, obj->count + 1);
	271	statuses[obj->count] = status;
	272	obj->sysdep = (void *) statuses;
	273
	274	return (pid_t) obj->count;
	275	}
	276
	277	/* Wait for a child process to complete. Actually the child process
	278	has already completed, and we just need to return the exit
	279	status. */
	280
	281	static pid_t
	282	pex_djgpp_wait (struct pex_obj obj, pid_t pid, int status,
	283	struct pex_time *time, int done ATTRIBUTE_UNUSED,
	284	const char **errmsg ATTRIBUTE_UNUSED,
	285	int *err ATTRIBUTE_UNUSED)
	286	{
	287	int *statuses;
	288
	289	if (time != NULL)
	290	memset (time, 0, sizeof *time);
	291
	292	statuses = (int *) obj->sysdep;
	293	*status = statuses[pid];
	294
	295	return 0;
	296	}