lib/fcntl.c

   1 /* Provide file descriptor control.
   2
   3    Copyright (C) 2009-2014 Free Software Foundation, Inc.
   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
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  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
  35 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
  36 /* Get declarations of the native Windows API functions.  */
  37 # define WIN32_LEAN_AND_MEAN
  38 # include <windows.h>
  39
  40 /* Get _get_osfhandle.  */
  41 # include "msvc-nothrow.h"
  42
  43 /* Upper bound on getdtablesize().  See lib/getdtablesize.c.  */
  44 # define OPEN_MAX_MAX 0x10000
  45
  46 /* Duplicate OLDFD into the first available slot of at least NEWFD,
  47    which must be positive, with FLAGS determining whether the duplicate
  48    will be inheritable.  */
  49 static int
  50 dupfd (int oldfd, int newfd, int flags)
  51 {
  52   /* Mingw has no way to create an arbitrary fd.  Iterate until all
  53      file descriptors less than newfd are filled up.  */
  54   HANDLE curr_process = GetCurrentProcess ();
  55   HANDLE old_handle = (HANDLE) _get_osfhandle (oldfd);
  56   unsigned char fds_to_close[OPEN_MAX_MAX / CHAR_BIT];
  57   unsigned int fds_to_close_bound = 0;
  58   int result;
  59   BOOL inherit = flags & O_CLOEXEC ? FALSE : TRUE;
  60   int mode;
  61
  62   if (newfd < 0 || getdtablesize () <= newfd)
  63     {
  64       errno = EINVAL;
  65       return -1;
  66     }
  67   if (old_handle == INVALID_HANDLE_VALUE
  68       || (mode = setmode (oldfd, O_BINARY)) == -1)
  69     {
  70       /* oldfd is not open, or is an unassigned standard file
  71          descriptor.  */
  72       errno = EBADF;
  73       return -1;
  74     }
  75   setmode (oldfd, mode);
  76   flags |= mode;
  77
  78   for (;;)
  79     {
  80       HANDLE new_handle;
  81       int duplicated_fd;
  82       unsigned int index;
  83
  84       if (!DuplicateHandle (curr_process,           /* SourceProcessHandle */
  85                             old_handle,             /* SourceHandle */
  86                             curr_process,           /* TargetProcessHandle */
  87                             (PHANDLE) &new_handle,  /* TargetHandle */
  88                             (DWORD) 0,              /* DesiredAccess */
  89                             inherit,                /* InheritHandle */
  90                             DUPLICATE_SAME_ACCESS)) /* Options */
  91         {
  92           switch (GetLastError ())
  93             {
  94               case ERROR_TOO_MANY_OPEN_FILES:
  95                 errno = EMFILE;
  96                 break;
  97               case ERROR_INVALID_HANDLE:
  98               case ERROR_INVALID_TARGET_HANDLE:
  99               case ERROR_DIRECT_ACCESS_HANDLE:
 100                 errno = EBADF;
 101                 break;
 102               case ERROR_INVALID_PARAMETER:
 103               case ERROR_INVALID_FUNCTION:
 104               case ERROR_INVALID_ACCESS:
 105                 errno = EINVAL;
 106                 break;
 107               default:
 108                 errno = EACCES;
 109                 break;
 110             }
 111           result = -1;
 112           break;
 113         }
 114       duplicated_fd = _open_osfhandle ((intptr_t) new_handle, flags);
 115       if (duplicated_fd < 0)
 116         {
 117           CloseHandle (new_handle);
 118           result = -1;
 119           break;
 120         }
 121       if (newfd <= duplicated_fd)
 122         {
 123           result = duplicated_fd;
 124           break;
 125         }
 126
 127       /* Set the bit duplicated_fd in fds_to_close[].  */
 128       index = (unsigned int) duplicated_fd / CHAR_BIT;
 129       if (fds_to_close_bound <= index)
 130         {
 131           if (sizeof fds_to_close <= index)
 132             /* Need to increase OPEN_MAX_MAX.  */
 133             abort ();
 134           memset (fds_to_close + fds_to_close_bound, '\0',
 135                   index + 1 - fds_to_close_bound);
 136           fds_to_close_bound = index + 1;
 137         }
 138       fds_to_close[index] |= 1 << ((unsigned int) duplicated_fd % CHAR_BIT);
 139     }
 140
 141   /* Close the previous fds that turned out to be too small.  */
 142   {
 143     int saved_errno = errno;
 144     unsigned int duplicated_fd;
 145
 146     for (duplicated_fd = 0;
 147          duplicated_fd < fds_to_close_bound * CHAR_BIT;
 148          duplicated_fd++)
 149       if ((fds_to_close[duplicated_fd / CHAR_BIT]
 150            >> (duplicated_fd % CHAR_BIT))
 151           & 1)
 152         close (duplicated_fd);
 153
 154     errno = saved_errno;
 155   }
 156
 157 # if REPLACE_FCHDIR
 158   if (0 <= result)
 159     result = _gl_register_dup (oldfd, result);
 160 # endif
 161   return result;
 162 }
 163 #endif /* W32 */
 164
 165 /* Perform the specified ACTION on the file descriptor FD, possibly
 166    using the argument ARG further described below.  This replacement
 167    handles the following actions, and forwards all others on to the
 168    native fcntl.  An unrecognized ACTION returns -1 with errno set to
 169    EINVAL.
 170
 171    F_DUPFD - duplicate FD, with int ARG being the minimum target fd.
 172    If successful, return the duplicate, which will be inheritable;
 173    otherwise return -1 and set errno.
 174
 175    F_DUPFD_CLOEXEC - duplicate FD, with int ARG being the minimum
 176    target fd.  If successful, return the duplicate, which will not be
 177    inheritable; otherwise return -1 and set errno.
 178
 179    F_GETFD - ARG need not be present.  If successful, return a
 180    non-negative value containing the descriptor flags of FD (only
 181    FD_CLOEXEC is portable, but other flags may be present); otherwise
 182    return -1 and set errno.  */
 183
 184 int
 185 rpl_fcntl (int fd, int action, /* arg */...)
 186 {
 187   va_list arg;
 188   int result = -1;
 189   va_start (arg, action);
 190   switch (action)
 191     {
 192
 193 #if !HAVE_FCNTL
 194     case F_DUPFD:
 195       {
 196         int target = va_arg (arg, int);
 197         result = dupfd (fd, target, 0);
 198         break;
 199       }
 200 #elif FCNTL_DUPFD_BUGGY || REPLACE_FCHDIR
 201     case F_DUPFD:
 202       {
 203         int target = va_arg (arg, int);
 204         /* Detect invalid target; needed for cygwin 1.5.x.  */
 205         if (target < 0 || getdtablesize () <= target)
 206           errno = EINVAL;
 207         else
 208           {
 209             /* Haiku alpha 2 loses fd flags on original.  */
 210             int flags = fcntl (fd, F_GETFD);
 211             if (flags < 0)
 212               {
 213                 result = -1;
 214                 break;
 215               }
 216             result = fcntl (fd, action, target);
 217             if (0 <= result && fcntl (fd, F_SETFD, flags) == -1)
 218               {
 219                 int saved_errno = errno;
 220                 close (result);
 221                 result = -1;
 222                 errno = saved_errno;
 223               }
 224 # if REPLACE_FCHDIR
 225             if (0 <= result)
 226               result = _gl_register_dup (fd, result);
 227 # endif
 228           }
 229         break;
 230       } /* F_DUPFD */
 231 #endif /* FCNTL_DUPFD_BUGGY || REPLACE_FCHDIR */
 232
 233     case F_DUPFD_CLOEXEC:
 234       {
 235         int target = va_arg (arg, int);
 236
 237 #if !HAVE_FCNTL
 238         result = dupfd (fd, target, O_CLOEXEC);
 239         break;
 240 #else /* HAVE_FCNTL */
 241         /* Try the system call first, if the headers claim it exists
 242            (that is, if GNULIB_defined_F_DUPFD_CLOEXEC is 0), since we
 243            may be running with a glibc that has the macro but with an
 244            older kernel that does not support it.  Cache the
 245            information on whether the system call really works, but
 246            avoid caching failure if the corresponding F_DUPFD fails
 247            for any reason.  0 = unknown, 1 = yes, -1 = no.  */
 248         static int have_dupfd_cloexec = GNULIB_defined_F_DUPFD_CLOEXEC ? -1 : 0;
 249         if (0 <= have_dupfd_cloexec)
 250           {
 251             result = fcntl (fd, action, target);
 252             if (0 <= result || errno != EINVAL)
 253               {
 254                 have_dupfd_cloexec = 1;
 255 # if REPLACE_FCHDIR
 256                 if (0 <= result)
 257                   result = _gl_register_dup (fd, result);
 258 # endif
 259               }
 260             else
 261               {
 262                 result = rpl_fcntl (fd, F_DUPFD, target);
 263                 if (result < 0)
 264                   break;
 265                 have_dupfd_cloexec = -1;
 266               }
 267           }
 268         else
 269           result = rpl_fcntl (fd, F_DUPFD, target);
 270         if (0 <= result && have_dupfd_cloexec == -1)
 271           {
 272             int flags = fcntl (result, F_GETFD);
 273             if (flags < 0 || fcntl (result, F_SETFD, flags | FD_CLOEXEC) == -1)
 274               {
 275                 int saved_errno = errno;
 276                 close (result);
 277                 errno = saved_errno;
 278                 result = -1;
 279               }
 280           }
 281         break;
 282 #endif /* HAVE_FCNTL */
 283       } /* F_DUPFD_CLOEXEC */
 284
 285 #if !HAVE_FCNTL
 286     case F_GETFD:
 287       {
 288 # if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
 289         HANDLE handle = (HANDLE) _get_osfhandle (fd);
 290         DWORD flags;
 291         if (handle == INVALID_HANDLE_VALUE
 292             || GetHandleInformation (handle, &flags) == 0)
 293           errno = EBADF;
 294         else
 295           result = (flags & HANDLE_FLAG_INHERIT) ? 0 : FD_CLOEXEC;
 296 # else /* !W32 */
 297         /* Use dup2 to reject invalid file descriptors.  No way to
 298            access this information, so punt.  */
 299         if (0 <= dup2 (fd, fd))
 300           result = 0;
 301 # endif /* !W32 */
 302         break;
 303       } /* F_GETFD */
 304 #endif /* !HAVE_FCNTL */
 305
 306       /* Implementing F_SETFD on mingw is not trivial - there is no
 307          API for changing the O_NOINHERIT bit on an fd, and merely
 308          changing the HANDLE_FLAG_INHERIT bit on the underlying handle
 309          can lead to odd state.  It may be possible by duplicating the
 310          handle, using _open_osfhandle with the right flags, then
 311          using dup2 to move the duplicate onto the original, but that
 312          is not supported for now.  */
 313
 314     default:
 315       {
 316 #if HAVE_FCNTL
 317         void *p = va_arg (arg, void *);
 318         result = fcntl (fd, action, p);
 319 #else
 320         errno = EINVAL;
 321 #endif
 322         break;
 323       }
 324     }
 325   va_end (arg);
 326   return result;
 327 }