[deliverable/binutils-gdb.git] / gdb / gnulib / import / fcntl.c

/* Provide file descriptor control.

   Copyright (C) 2009-2018 Free Software Foundation, Inc.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program 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 General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */

/* Written by Eric Blake <ebb9@byu.net>.  */

#include <config.h>

/* Specification.  */
#include <fcntl.h>

#include <errno.h>
#include <limits.h>
#include <stdarg.h>
#include <unistd.h>

#if !HAVE_FCNTL
# define rpl_fcntl fcntl
#endif
#undef fcntl

#if defined _WIN32 && ! defined __CYGWIN__
/* Get declarations of the native Windows API functions.  */
# define WIN32_LEAN_AND_MEAN
# include <windows.h>

/* Get _get_osfhandle.  */
# if GNULIB_MSVC_NOTHROW
#  include "msvc-nothrow.h"
# else
#  include <io.h>
# endif

/* Upper bound on getdtablesize().  See lib/getdtablesize.c.  */
# define OPEN_MAX_MAX 0x10000

/* Duplicate OLDFD into the first available slot of at least NEWFD,
   which must be positive, with FLAGS determining whether the duplicate
   will be inheritable.  */
static int
dupfd (int oldfd, int newfd, int flags)
{
  /* Mingw has no way to create an arbitrary fd.  Iterate until all
     file descriptors less than newfd are filled up.  */
  HANDLE curr_process = GetCurrentProcess ();
  HANDLE old_handle = (HANDLE) _get_osfhandle (oldfd);
  unsigned char fds_to_close[OPEN_MAX_MAX / CHAR_BIT];
  unsigned int fds_to_close_bound = 0;
  int result;
  BOOL inherit = flags & O_CLOEXEC ? FALSE : TRUE;
  int mode;

  if (newfd < 0 || getdtablesize () <= newfd)
    {
      errno = EINVAL;
      return -1;
    }
  if (old_handle == INVALID_HANDLE_VALUE
      || (mode = setmode (oldfd, O_BINARY)) == -1)
    {
      /* oldfd is not open, or is an unassigned standard file
         descriptor.  */
      errno = EBADF;
      return -1;
    }
  setmode (oldfd, mode);
  flags |= mode;

  for (;;)
    {
      HANDLE new_handle;
      int duplicated_fd;
      unsigned int index;

      if (!DuplicateHandle (curr_process,           /* SourceProcessHandle */
                            old_handle,             /* SourceHandle */
                            curr_process,           /* TargetProcessHandle */
                            (PHANDLE) &new_handle,  /* TargetHandle */
                            (DWORD) 0,              /* DesiredAccess */
                            inherit,                /* InheritHandle */
                            DUPLICATE_SAME_ACCESS)) /* Options */
        {
          switch (GetLastError ())
            {
              case ERROR_TOO_MANY_OPEN_FILES:
                errno = EMFILE;
                break;
              case ERROR_INVALID_HANDLE:
              case ERROR_INVALID_TARGET_HANDLE:
              case ERROR_DIRECT_ACCESS_HANDLE:
                errno = EBADF;
                break;
              case ERROR_INVALID_PARAMETER:
              case ERROR_INVALID_FUNCTION:
              case ERROR_INVALID_ACCESS:
                errno = EINVAL;
                break;
              default:
                errno = EACCES;
                break;
            }
          result = -1;
          break;
        }
      duplicated_fd = _open_osfhandle ((intptr_t) new_handle, flags);
      if (duplicated_fd < 0)
        {
          CloseHandle (new_handle);
          result = -1;
          break;
        }
      if (newfd <= duplicated_fd)
        {
          result = duplicated_fd;
          break;
        }

      /* Set the bit duplicated_fd in fds_to_close[].  */
      index = (unsigned int) duplicated_fd / CHAR_BIT;
      if (fds_to_close_bound <= index)
        {
          if (sizeof fds_to_close <= index)
            /* Need to increase OPEN_MAX_MAX.  */
            abort ();
          memset (fds_to_close + fds_to_close_bound, '\0',
                  index + 1 - fds_to_close_bound);
          fds_to_close_bound = index + 1;
        }
      fds_to_close[index] |= 1 << ((unsigned int) duplicated_fd % CHAR_BIT);
    }

  /* Close the previous fds that turned out to be too small.  */
  {
    int saved_errno = errno;
    unsigned int duplicated_fd;

    for (duplicated_fd = 0;
         duplicated_fd < fds_to_close_bound * CHAR_BIT;
         duplicated_fd++)
      if ((fds_to_close[duplicated_fd / CHAR_BIT]
           >> (duplicated_fd % CHAR_BIT))
          & 1)
        close (duplicated_fd);

    errno = saved_errno;
  }

# if REPLACE_FCHDIR
  if (0 <= result)
    result = _gl_register_dup (oldfd, result);
# endif
  return result;
}
#endif /* W32 */

#ifdef __KLIBC__

# define INCL_DOS
# include <os2.h>

static int
klibc_fcntl (int fd, int action, /* arg */...)
{
  va_list arg_ptr;
  int arg;
  struct stat sbuf;
  int result = -1;

  va_start (arg_ptr, action);
  arg = va_arg (arg_ptr, int);
  result = fcntl (fd, action, arg);
  /* EPERM for F_DUPFD, ENOTSUP for others */
  if (result == -1 && (errno == EPERM || errno == ENOTSUP)
      && !fstat (fd, &sbuf) && S_ISDIR (sbuf.st_mode))
  {
    ULONG ulMode;

    switch (action)
      {
      case F_DUPFD:
        /* Find available fd */
        while (fcntl (arg, F_GETFL) != -1 || errno != EBADF)
          arg++;

        result = dup2 (fd, arg);
        break;

      /* Using underlying APIs is right ? */
      case F_GETFD:
        if (DosQueryFHState (fd, &ulMode))
          break;

        result = (ulMode & OPEN_FLAGS_NOINHERIT) ? FD_CLOEXEC : 0;
        break;

      case F_SETFD:
        if (arg & ~FD_CLOEXEC)
          break;

        if (DosQueryFHState (fd, &ulMode))
          break;

        if (arg & FD_CLOEXEC)
          ulMode |= OPEN_FLAGS_NOINHERIT;
        else
          ulMode &= ~OPEN_FLAGS_NOINHERIT;

        /* Filter supported flags.  */
        ulMode &= (OPEN_FLAGS_WRITE_THROUGH | OPEN_FLAGS_FAIL_ON_ERROR
                   | OPEN_FLAGS_NO_CACHE | OPEN_FLAGS_NOINHERIT);

        if (DosSetFHState (fd, ulMode))
          break;

        result = 0;
        break;

      case F_GETFL:
        result = 0;
        break;

      case F_SETFL:
        if (arg != 0)
          break;

        result = 0;
        break;

      default :
        errno = EINVAL;
        break;
      }
  }

  va_end (arg_ptr);

  return result;
}

# define fcntl klibc_fcntl
#endif

/* Perform the specified ACTION on the file descriptor FD, possibly
   using the argument ARG further described below.  This replacement
   handles the following actions, and forwards all others on to the
   native fcntl.  An unrecognized ACTION returns -1 with errno set to
   EINVAL.

   F_DUPFD - duplicate FD, with int ARG being the minimum target fd.
   If successful, return the duplicate, which will be inheritable;
   otherwise return -1 and set errno.

   F_DUPFD_CLOEXEC - duplicate FD, with int ARG being the minimum
   target fd.  If successful, return the duplicate, which will not be
   inheritable; otherwise return -1 and set errno.

   F_GETFD - ARG need not be present.  If successful, return a
   non-negative value containing the descriptor flags of FD (only
   FD_CLOEXEC is portable, but other flags may be present); otherwise
   return -1 and set errno.  */

int
rpl_fcntl (int fd, int action, /* arg */...)
{
  va_list arg;
  int result = -1;
  va_start (arg, action);
  switch (action)
    {

#if !HAVE_FCNTL
    case F_DUPFD:
      {
        int target = va_arg (arg, int);
        result = dupfd (fd, target, 0);
        break;
      }
#elif FCNTL_DUPFD_BUGGY || REPLACE_FCHDIR
    case F_DUPFD:
      {
        int target = va_arg (arg, int);
        /* Detect invalid target; needed for cygwin 1.5.x.  */
        if (target < 0 || getdtablesize () <= target)
          errno = EINVAL;
        else
          {
            /* Haiku alpha 2 loses fd flags on original.  */
            int flags = fcntl (fd, F_GETFD);
            if (flags < 0)
              {
                result = -1;
                break;
              }
            result = fcntl (fd, action, target);
            if (0 <= result && fcntl (fd, F_SETFD, flags) == -1)
              {
                int saved_errno = errno;
                close (result);
                result = -1;
                errno = saved_errno;
              }
# if REPLACE_FCHDIR
            if (0 <= result)
              result = _gl_register_dup (fd, result);
# endif
          }
        break;
      } /* F_DUPFD */
#endif /* FCNTL_DUPFD_BUGGY || REPLACE_FCHDIR */

    case F_DUPFD_CLOEXEC:
      {
        int target = va_arg (arg, int);

#if !HAVE_FCNTL
        result = dupfd (fd, target, O_CLOEXEC);
        break;
#else /* HAVE_FCNTL */
        /* Try the system call first, if the headers claim it exists
           (that is, if GNULIB_defined_F_DUPFD_CLOEXEC is 0), since we
           may be running with a glibc that has the macro but with an
           older kernel that does not support it.  Cache the
           information on whether the system call really works, but
           avoid caching failure if the corresponding F_DUPFD fails
           for any reason.  0 = unknown, 1 = yes, -1 = no.  */
        static int have_dupfd_cloexec = GNULIB_defined_F_DUPFD_CLOEXEC ? -1 : 0;
        if (0 <= have_dupfd_cloexec)
          {
            result = fcntl (fd, action, target);
            if (0 <= result || errno != EINVAL)
              {
                have_dupfd_cloexec = 1;
# if REPLACE_FCHDIR
                if (0 <= result)
                  result = _gl_register_dup (fd, result);
# endif
              }
            else
              {
                result = rpl_fcntl (fd, F_DUPFD, target);
                if (result < 0)
                  break;
                have_dupfd_cloexec = -1;
              }
          }
        else
          result = rpl_fcntl (fd, F_DUPFD, target);
        if (0 <= result && have_dupfd_cloexec == -1)
          {
            int flags = fcntl (result, F_GETFD);
            if (flags < 0 || fcntl (result, F_SETFD, flags | FD_CLOEXEC) == -1)
              {
                int saved_errno = errno;
                close (result);
                errno = saved_errno;
                result = -1;
              }
          }
        break;
#endif /* HAVE_FCNTL */
      } /* F_DUPFD_CLOEXEC */

#if !HAVE_FCNTL
    case F_GETFD:
      {
# if defined _WIN32 && ! defined __CYGWIN__
        HANDLE handle = (HANDLE) _get_osfhandle (fd);
        DWORD flags;
        if (handle == INVALID_HANDLE_VALUE
            || GetHandleInformation (handle, &flags) == 0)
          errno = EBADF;
        else
          result = (flags & HANDLE_FLAG_INHERIT) ? 0 : FD_CLOEXEC;
# else /* !W32 */
        /* Use dup2 to reject invalid file descriptors.  No way to
           access this information, so punt.  */
        if (0 <= dup2 (fd, fd))
          result = 0;
# endif /* !W32 */
        break;
      } /* F_GETFD */
#endif /* !HAVE_FCNTL */

      /* Implementing F_SETFD on mingw is not trivial - there is no
         API for changing the O_NOINHERIT bit on an fd, and merely
         changing the HANDLE_FLAG_INHERIT bit on the underlying handle
         can lead to odd state.  It may be possible by duplicating the
         handle, using _open_osfhandle with the right flags, then
         using dup2 to move the duplicate onto the original, but that
         is not supported for now.  */

    default:
      {
#if HAVE_FCNTL
        void *p = va_arg (arg, void *);
        result = fcntl (fd, action, p);
#else
        errno = EINVAL;
#endif
        break;
      }
    }
  va_end (arg);
  return result;
}
Commit	Line	Data
6ec2e0f5 SDJ	1	/* Provide file descriptor control.
6ec2e0f5 SDJ	2
7a6dbc2f	3	Copyright (C) 2009-2018 Free Software Foundation, Inc.
6ec2e0f5 SDJ	4
	5	This program is free software: you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 3 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
7a6dbc2f	16	along with this program. If not, see <https://www.gnu.org/licenses/>. */
6ec2e0f5 SDJ	17
	18	/* Written by Eric Blake <ebb9@byu.net>. */
	19
	20	#include <config.h>
	21
	22	/* Specification. */
	23	#include <fcntl.h>
	24
	25	#include <errno.h>
	26	#include <limits.h>
	27	#include <stdarg.h>
	28	#include <unistd.h>
	29
	30	#if !HAVE_FCNTL
	31	# define rpl_fcntl fcntl
	32	#endif
	33	#undef fcntl
	34
7a6dbc2f	35	#if defined _WIN32 && ! defined __CYGWIN__
6ec2e0f5 SDJ	36	/* Get declarations of the native Windows API functions. */
	37	# define WIN32_LEAN_AND_MEAN
	38	# include <windows.h>
	39
	40	/* Get _get_osfhandle. */
7a6dbc2f SDJ	41	# if GNULIB_MSVC_NOTHROW
	42	# include "msvc-nothrow.h"
	43	# else
	44	# include <io.h>
	45	# endif
6ec2e0f5 SDJ	46
	47	/* Upper bound on getdtablesize(). See lib/getdtablesize.c. */
	48	# define OPEN_MAX_MAX 0x10000
	49
	50	/* Duplicate OLDFD into the first available slot of at least NEWFD,
	51	which must be positive, with FLAGS determining whether the duplicate
	52	will be inheritable. */
	53	static int
	54	dupfd (int oldfd, int newfd, int flags)
	55	{
	56	/* Mingw has no way to create an arbitrary fd. Iterate until all
	57	file descriptors less than newfd are filled up. */
	58	HANDLE curr_process = GetCurrentProcess ();
	59	HANDLE old_handle = (HANDLE) _get_osfhandle (oldfd);
	60	unsigned char fds_to_close[OPEN_MAX_MAX / CHAR_BIT];
	61	unsigned int fds_to_close_bound = 0;
	62	int result;
	63	BOOL inherit = flags & O_CLOEXEC ? FALSE : TRUE;
	64	int mode;
	65
	66	if (newfd < 0 \|\| getdtablesize () <= newfd)
	67	{
	68	errno = EINVAL;
	69	return -1;
	70	}
	71	if (old_handle == INVALID_HANDLE_VALUE
	72	\|\| (mode = setmode (oldfd, O_BINARY)) == -1)
	73	{
	74	/* oldfd is not open, or is an unassigned standard file
	75	descriptor. */
	76	errno = EBADF;
	77	return -1;
	78	}
	79	setmode (oldfd, mode);
	80	flags \|= mode;
	81
	82	for (;;)
	83	{
	84	HANDLE new_handle;
	85	int duplicated_fd;
	86	unsigned int index;
	87
	88	if (!DuplicateHandle (curr_process, /* SourceProcessHandle */
	89	old_handle, /* SourceHandle */
	90	curr_process, /* TargetProcessHandle */
	91	(PHANDLE) &new_handle, /* TargetHandle */
	92	(DWORD) 0, /* DesiredAccess */
	93	inherit, /* InheritHandle */
	94	DUPLICATE_SAME_ACCESS)) /* Options */
	95	{
	96	switch (GetLastError ())
	97	{
	98	case ERROR_TOO_MANY_OPEN_FILES:
	99	errno = EMFILE;
	100	break;
	101	case ERROR_INVALID_HANDLE:
	102	case ERROR_INVALID_TARGET_HANDLE:
	103	case ERROR_DIRECT_ACCESS_HANDLE:
	104	errno = EBADF;
	105	break;
	106	case ERROR_INVALID_PARAMETER:
	107	case ERROR_INVALID_FUNCTION:
	108	case ERROR_INVALID_ACCESS:
	109	errno = EINVAL;
110	break;
111	default:
112	errno = EACCES;
113	break;
114	}
115	result = -1;
116	break;
117	}
118	duplicated_fd = _open_osfhandle ((intptr_t) new_handle, flags);
119	if (duplicated_fd < 0)
120	{
121	CloseHandle (new_handle);
122	result = -1;
123	break;
124	}
125	if (newfd <= duplicated_fd)
126	{
127	result = duplicated_fd;
128	break;
129	}
130
131	/* Set the bit duplicated_fd in fds_to_close[]. */
132	index = (unsigned int) duplicated_fd / CHAR_BIT;
133	if (fds_to_close_bound <= index)
134	{
135	if (sizeof fds_to_close <= index)
136	/* Need to increase OPEN_MAX_MAX. */
137	abort ();
138	memset (fds_to_close + fds_to_close_bound, '\0',
139	index + 1 - fds_to_close_bound);
140	fds_to_close_bound = index + 1;
141	}
142	fds_to_close[index] \|= 1 << ((unsigned int) duplicated_fd % CHAR_BIT);
143	}
144
145	/* Close the previous fds that turned out to be too small. */
146	{
147	int saved_errno = errno;
148	unsigned int duplicated_fd;
149
150	for (duplicated_fd = 0;
151	duplicated_fd < fds_to_close_bound * CHAR_BIT;
152	duplicated_fd++)
153	if ((fds_to_close[duplicated_fd / CHAR_BIT]
154	>> (duplicated_fd % CHAR_BIT))
155	& 1)
156	close (duplicated_fd);
157
158	errno = saved_errno;
159	}
160
161	# if REPLACE_FCHDIR
162	if (0 <= result)
163	result = _gl_register_dup (oldfd, result);
164	# endif
165	return result;
166	}
167	#endif /* W32 */
168
169	#ifdef __KLIBC__
170
171	# define INCL_DOS
172	# include <os2.h>
173
174	static int
175	klibc_fcntl (int fd, int action, /* arg */...)
176	{
177	va_list arg_ptr;
178	int arg;
179	struct stat sbuf;
180	int result = -1;
181
182	va_start (arg_ptr, action);
183	arg = va_arg (arg_ptr, int);
184	result = fcntl (fd, action, arg);
185	/* EPERM for F_DUPFD, ENOTSUP for others */
186	if (result == -1 && (errno == EPERM \|\| errno == ENOTSUP)
187	&& !fstat (fd, &sbuf) && S_ISDIR (sbuf.st_mode))
188	{
189	ULONG ulMode;
190
191	switch (action)
192	{
193	case F_DUPFD:
194	/* Find available fd */
195	while (fcntl (arg, F_GETFL) != -1 \|\| errno != EBADF)
196	arg++;
197
198	result = dup2 (fd, arg);
199	break;
200
201	/* Using underlying APIs is right ? */
202	case F_GETFD:
203	if (DosQueryFHState (fd, &ulMode))
204	break;
205
206	result = (ulMode & OPEN_FLAGS_NOINHERIT) ? FD_CLOEXEC : 0;
207	break;
208
209	case F_SETFD:
210	if (arg & ~FD_CLOEXEC)
211	break;
212
213	if (DosQueryFHState (fd, &ulMode))
214	break;
215
216	if (arg & FD_CLOEXEC)
217	ulMode \|= OPEN_FLAGS_NOINHERIT;
218	else
219	ulMode &= ~OPEN_FLAGS_NOINHERIT;
220
221	/* Filter supported flags. */
222	ulMode &= (OPEN_FLAGS_WRITE_THROUGH \| OPEN_FLAGS_FAIL_ON_ERROR
223	\| OPEN_FLAGS_NO_CACHE \| OPEN_FLAGS_NOINHERIT);
224
225	if (DosSetFHState (fd, ulMode))
226	break;
227
228	result = 0;
229	break;
230
231	case F_GETFL:
232	result = 0;
233	break;
234
235	case F_SETFL:
236	if (arg != 0)
237	break;
238
239	result = 0;
240	break;
241
242	default :
243	errno = EINVAL;
244	break;
245	}
246	}
247
248	va_end (arg_ptr);
249
250	return result;
251	}
252
253	# define fcntl klibc_fcntl
254	#endif
255
256	/* Perform the specified ACTION on the file descriptor FD, possibly
257	using the argument ARG further described below. This replacement
258	handles the following actions, and forwards all others on to the
259	native fcntl. An unrecognized ACTION returns -1 with errno set to
260	EINVAL.
261
262	F_DUPFD - duplicate FD, with int ARG being the minimum target fd.
263	If successful, return the duplicate, which will be inheritable;
264	otherwise return -1 and set errno.
265
266	F_DUPFD_CLOEXEC - duplicate FD, with int ARG being the minimum
267	target fd. If successful, return the duplicate, which will not be
268	inheritable; otherwise return -1 and set errno.
269
270	F_GETFD - ARG need not be present. If successful, return a
271	non-negative value containing the descriptor flags of FD (only
272	FD_CLOEXEC is portable, but other flags may be present); otherwise
273	return -1 and set errno. */
274
275	int
276	rpl_fcntl (int fd, int action, /* arg */...)
277	{
278	va_list arg;
279	int result = -1;
280	va_start (arg, action);
281	switch (action)
282	{
283
284	#if !HAVE_FCNTL
285	case F_DUPFD:
286	{
287	int target = va_arg (arg, int);
288	result = dupfd (fd, target, 0);
289	break;
290	}
291	#elif FCNTL_DUPFD_BUGGY \|\| REPLACE_FCHDIR
292	case F_DUPFD:
293	{
294	int target = va_arg (arg, int);
295	/* Detect invalid target; needed for cygwin 1.5.x. */
296	if (target < 0 \|\| getdtablesize () <= target)
297	errno = EINVAL;
298	else
299	{
300	/* Haiku alpha 2 loses fd flags on original. */
301	int flags = fcntl (fd, F_GETFD);
302	if (flags < 0)
303	{
304	result = -1;
305	break;
306	}
307	result = fcntl (fd, action, target);
308	if (0 <= result && fcntl (fd, F_SETFD, flags) == -1)
309	{
310	int saved_errno = errno;
311	close (result);
312	result = -1;
313	errno = saved_errno;
314	}
315	# if REPLACE_FCHDIR
316	if (0 <= result)
317	result = _gl_register_dup (fd, result);
318	# endif
319	}
320	break;
321	} /* F_DUPFD */
322	#endif /* FCNTL_DUPFD_BUGGY \|\| REPLACE_FCHDIR */
323
324	case F_DUPFD_CLOEXEC:
325	{
326	int target = va_arg (arg, int);
327
328	#if !HAVE_FCNTL
329	result = dupfd (fd, target, O_CLOEXEC);
330	break;
331	#else /* HAVE_FCNTL */
332	/* Try the system call first, if the headers claim it exists
333	(that is, if GNULIB_defined_F_DUPFD_CLOEXEC is 0), since we
334	may be running with a glibc that has the macro but with an
335	older kernel that does not support it. Cache the
336	information on whether the system call really works, but
337	avoid caching failure if the corresponding F_DUPFD fails
338	for any reason. 0 = unknown, 1 = yes, -1 = no. */
339	static int have_dupfd_cloexec = GNULIB_defined_F_DUPFD_CLOEXEC ? -1 : 0;
340	if (0 <= have_dupfd_cloexec)
341	{
342	result = fcntl (fd, action, target);
343	if (0 <= result \|\| errno != EINVAL)
344	{
345	have_dupfd_cloexec = 1;
346	# if REPLACE_FCHDIR
347	if (0 <= result)
348	result = _gl_register_dup (fd, result);
349	# endif
350	}
351	else
352	{
353	result = rpl_fcntl (fd, F_DUPFD, target);
354	if (result < 0)
355	break;
356	have_dupfd_cloexec = -1;
357	}
358	}
359	else
360	result = rpl_fcntl (fd, F_DUPFD, target);
361	if (0 <= result && have_dupfd_cloexec == -1)
362	{
363	int flags = fcntl (result, F_GETFD);
364	if (flags < 0 \|\| fcntl (result, F_SETFD, flags \| FD_CLOEXEC) == -1)
365	{
366	int saved_errno = errno;
367	close (result);
368	errno = saved_errno;
369	result = -1;
370	}
371	}
372	break;
373	#endif /* HAVE_FCNTL */
374	} /* F_DUPFD_CLOEXEC */
375
376	#if !HAVE_FCNTL
377	case F_GETFD:
378	{
7a6dbc2f	379	# if defined _WIN32 && ! defined __CYGWIN__
6ec2e0f5 SDJ	380	HANDLE handle = (HANDLE) _get_osfhandle (fd);
	381	DWORD flags;
	382	if (handle == INVALID_HANDLE_VALUE
	383	\|\| GetHandleInformation (handle, &flags) == 0)
	384	errno = EBADF;
	385	else
	386	result = (flags & HANDLE_FLAG_INHERIT) ? 0 : FD_CLOEXEC;
	387	# else /* !W32 */
	388	/* Use dup2 to reject invalid file descriptors. No way to
	389	access this information, so punt. */
	390	if (0 <= dup2 (fd, fd))
	391	result = 0;
	392	# endif /* !W32 */
	393	break;
	394	} /* F_GETFD */
	395	#endif /* !HAVE_FCNTL */
	396
	397	/* Implementing F_SETFD on mingw is not trivial - there is no
	398	API for changing the O_NOINHERIT bit on an fd, and merely
	399	changing the HANDLE_FLAG_INHERIT bit on the underlying handle
	400	can lead to odd state. It may be possible by duplicating the
	401	handle, using _open_osfhandle with the right flags, then
	402	using dup2 to move the duplicate onto the original, but that
	403	is not supported for now. */
	404
	405	default:
	406	{
	407	#if HAVE_FCNTL
	408	void p = va_arg (arg, void );
	409	result = fcntl (fd, action, p);
	410	#else
	411	errno = EINVAL;
	412	#endif
	413	break;
	414	}
	415	}
	416	va_end (arg);
	417	return result;
	418	}