lib/fcntl.c

   1 /* Provide file descriptor control.
   2
   3    Copyright (C) 2009-2019 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 <https://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 #ifdef __KLIBC__
  31 # define INCL_DOS
  32 # include <os2.h>
  33 #endif
  34
  35 #if 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 # if GNULIB_MSVC_NOTHROW
  42 #  include "msvc-nothrow.h"
  43 # else
  44 #  include <io.h>
  45 # endif
  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 /* Forward declarations, because we '#undef fcntl' in the middle of this
 170    compilation unit.  */
 171 /* Our implementation of fcntl (fd, F_DUPFD, target).  */
 172 static int rpl_fcntl_DUPFD (int fd, int target);
 173 /* Our implementation of fcntl (fd, F_DUPFD_CLOEXEC, target).  */
 174 static int rpl_fcntl_DUPFD_CLOEXEC (int fd, int target);
 175 #ifdef __KLIBC__
 176 /* Adds support for fcntl on directories.  */
 177 static int klibc_fcntl (int fd, int action, /* arg */...);
 178 #endif
 179
 180
 181 /* Perform the specified ACTION on the file descriptor FD, possibly
 182    using the argument ARG further described below.  This replacement
 183    handles the following actions, and forwards all others on to the
 184    native fcntl.  An unrecognized ACTION returns -1 with errno set to
 185    EINVAL.
 186
 187    F_DUPFD - duplicate FD, with int ARG being the minimum target fd.
 188    If successful, return the duplicate, which will be inheritable;
 189    otherwise return -1 and set errno.
 190
 191    F_DUPFD_CLOEXEC - duplicate FD, with int ARG being the minimum
 192    target fd.  If successful, return the duplicate, which will not be
 193    inheritable; otherwise return -1 and set errno.
 194
 195    F_GETFD - ARG need not be present.  If successful, return a
 196    non-negative value containing the descriptor flags of FD (only
 197    FD_CLOEXEC is portable, but other flags may be present); otherwise
 198    return -1 and set errno.  */
 199
 200 int
 201 fcntl (int fd, int action, /* arg */...)
 202 #undef fcntl
 203 #ifdef __KLIBC__
 204 # define fcntl klibc_fcntl
 205 #endif
 206 {
 207   va_list arg;
 208   int result = -1;
 209   va_start (arg, action);
 210   switch (action)
 211     {
 212     case F_DUPFD:
 213       {
 214         int target = va_arg (arg, int);
 215         result = rpl_fcntl_DUPFD (fd, target);
 216         break;
 217       }
 218
 219     case F_DUPFD_CLOEXEC:
 220       {
 221         int target = va_arg (arg, int);
 222         result = rpl_fcntl_DUPFD_CLOEXEC (fd, target);
 223         break;
 224       }
 225
 226 #if !HAVE_FCNTL
 227     case F_GETFD:
 228       {
 229 # if defined _WIN32 && ! defined __CYGWIN__
 230         HANDLE handle = (HANDLE) _get_osfhandle (fd);
 231         DWORD flags;
 232         if (handle == INVALID_HANDLE_VALUE
 233             || GetHandleInformation (handle, &flags) == 0)
 234           errno = EBADF;
 235         else
 236           result = (flags & HANDLE_FLAG_INHERIT) ? 0 : FD_CLOEXEC;
 237 # else /* !W32 */
 238         /* Use dup2 to reject invalid file descriptors.  No way to
 239            access this information, so punt.  */
 240         if (0 <= dup2 (fd, fd))
 241           result = 0;
 242 # endif /* !W32 */
 243         break;
 244       } /* F_GETFD */
 245 #endif /* !HAVE_FCNTL */
 246
 247       /* Implementing F_SETFD on mingw is not trivial - there is no
 248          API for changing the O_NOINHERIT bit on an fd, and merely
 249          changing the HANDLE_FLAG_INHERIT bit on the underlying handle
 250          can lead to odd state.  It may be possible by duplicating the
 251          handle, using _open_osfhandle with the right flags, then
 252          using dup2 to move the duplicate onto the original, but that
 253          is not supported for now.  */
 254
 255     default:
 256       {
 257 #if HAVE_FCNTL
 258         switch (action)
 259           {
 260           #ifdef F_BARRIERFSYNC                  /* macOS */
 261           case F_BARRIERFSYNC:
 262           #endif
 263           #ifdef F_CHKCLEAN                      /* macOS */
 264           case F_CHKCLEAN:
 265           #endif
 266           #ifdef F_CLOSEM                        /* NetBSD, HP-UX */
 267           case F_CLOSEM:
 268           #endif
 269           #ifdef F_FLUSH_DATA                    /* macOS */
 270           case F_FLUSH_DATA:
 271           #endif
 272           #ifdef F_FREEZE_FS                     /* macOS */
 273           case F_FREEZE_FS:
 274           #endif
 275           #ifdef F_FULLFSYNC                     /* macOS */
 276           case F_FULLFSYNC:
 277           #endif
 278           #ifdef F_GETCONFINED                   /* macOS */
 279           case F_GETCONFINED:
 280           #endif
 281           #ifdef F_GETDEFAULTPROTLEVEL           /* macOS */
 282           case F_GETDEFAULTPROTLEVEL:
 283           #endif
 284           #ifdef F_GETFD                         /* POSIX */
 285           case F_GETFD:
 286           #endif
 287           #ifdef F_GETFL                         /* POSIX */
 288           case F_GETFL:
 289           #endif
 290           #ifdef F_GETLEASE                      /* Linux */
 291           case F_GETLEASE:
 292           #endif
 293           #ifdef F_GETNOSIGPIPE                  /* macOS */
 294           case F_GETNOSIGPIPE:
 295           #endif
 296           #ifdef F_GETOWN                        /* POSIX */
 297           case F_GETOWN:
 298           #endif
 299           #ifdef F_GETPIPE_SZ                    /* Linux */
 300           case F_GETPIPE_SZ:
 301           #endif
 302           #ifdef F_GETPROTECTIONCLASS            /* macOS */
 303           case F_GETPROTECTIONCLASS:
 304           #endif
 305           #ifdef F_GETPROTECTIONLEVEL            /* macOS */
 306           case F_GETPROTECTIONLEVEL:
 307           #endif
 308           #ifdef F_GET_SEALS                     /* Linux */
 309           case F_GET_SEALS:
 310           #endif
 311           #ifdef F_GETSIG                        /* Linux */
 312           case F_GETSIG:
 313           #endif
 314           #ifdef F_MAXFD                         /* NetBSD */
 315           case F_MAXFD:
 316           #endif
 317           #ifdef F_RECYCLE                       /* macOS */
 318           case F_RECYCLE:
 319           #endif
 320           #ifdef F_SETFIFOENH                    /* HP-UX */
 321           case F_SETFIFOENH:
 322           #endif
 323           #ifdef F_THAW_FS                       /* macOS */
 324           case F_THAW_FS:
 325           #endif
 326             /* These actions take no argument.  */
 327             result = fcntl (fd, action);
 328             break;
 329
 330           #ifdef F_ADD_SEALS                     /* Linux */
 331           case F_ADD_SEALS:
 332           #endif
 333           #ifdef F_BADFD                         /* Solaris */
 334           case F_BADFD:
 335           #endif
 336           #ifdef F_CHECK_OPENEVT                 /* macOS */
 337           case F_CHECK_OPENEVT:
 338           #endif
 339           #ifdef F_DUP2FD                        /* FreeBSD, AIX, Solaris */
 340           case F_DUP2FD:
 341           #endif
 342           #ifdef F_DUP2FD_CLOEXEC                /* FreeBSD, Solaris */
 343           case F_DUP2FD_CLOEXEC:
 344           #endif
 345           #ifdef F_DUP2FD_CLOFORK                /* Solaris */
 346           case F_DUP2FD_CLOFORK:
 347           #endif
 348           #ifdef F_DUPFD                         /* POSIX */
 349           case F_DUPFD:
 350           #endif
 351           #ifdef F_DUPFD_CLOEXEC                 /* POSIX */
 352           case F_DUPFD_CLOEXEC:
 353           #endif
 354           #ifdef F_DUPFD_CLOFORK                 /* Solaris */
 355           case F_DUPFD_CLOFORK:
 356           #endif
 357           #ifdef F_GETXFL                        /* Solaris */
 358           case F_GETXFL:
 359           #endif
 360           #ifdef F_GLOBAL_NOCACHE                /* macOS */
 361           case F_GLOBAL_NOCACHE:
 362           #endif
 363           #ifdef F_MAKECOMPRESSED                /* macOS */
 364           case F_MAKECOMPRESSED:
 365           #endif
 366           #ifdef F_MOVEDATAEXTENTS               /* macOS */
 367           case F_MOVEDATAEXTENTS:
 368           #endif
 369           #ifdef F_NOCACHE                       /* macOS */
 370           case F_NOCACHE:
 371           #endif
 372           #ifdef F_NODIRECT                      /* macOS */
 373           case F_NODIRECT:
 374           #endif
 375           #ifdef F_NOTIFY                        /* Linux */
 376           case F_NOTIFY:
 377           #endif
 378           #ifdef F_OPLKACK                       /* IRIX */
 379           case F_OPLKACK:
 380           #endif
 381           #ifdef F_OPLKREG                       /* IRIX */
 382           case F_OPLKREG:
 383           #endif
 384           #ifdef F_RDAHEAD                       /* macOS */
 385           case F_RDAHEAD:
 386           #endif
 387           #ifdef F_SETBACKINGSTORE               /* macOS */
 388           case F_SETBACKINGSTORE:
 389           #endif
 390           #ifdef F_SETCONFINED                   /* macOS */
 391           case F_SETCONFINED:
 392           #endif
 393           #ifdef F_SETFD                         /* POSIX */
 394           case F_SETFD:
 395           #endif
 396           #ifdef F_SETFL                         /* POSIX */
 397           case F_SETFL:
 398           #endif
 399           #ifdef F_SETLEASE                      /* Linux */
 400           case F_SETLEASE:
 401           #endif
 402           #ifdef F_SETNOSIGPIPE                  /* macOS */
 403           case F_SETNOSIGPIPE:
 404           #endif
 405           #ifdef F_SETOWN                        /* POSIX */
 406           case F_SETOWN:
 407           #endif
 408           #ifdef F_SETPIPE_SZ                    /* Linux */
 409           case F_SETPIPE_SZ:
 410           #endif
 411           #ifdef F_SETPROTECTIONCLASS            /* macOS */
 412           case F_SETPROTECTIONCLASS:
 413           #endif
 414           #ifdef F_SETSIG                        /* Linux */
 415           case F_SETSIG:
 416           #endif
 417           #ifdef F_SINGLE_WRITER                 /* macOS */
 418           case F_SINGLE_WRITER:
 419           #endif
 420             /* These actions take an 'int' argument.  */
 421             {
 422               int x = va_arg (arg, int);
 423               result = fcntl (fd, action, x);
 424             }
 425             break;
 426
 427           default:
 428             /* Other actions take a pointer argument.  */
 429             {
 430               void *p = va_arg (arg, void *);
 431               result = fcntl (fd, action, p);
 432             }
 433             break;
 434           }
 435 #else
 436         errno = EINVAL;
 437 #endif
 438         break;
 439       }
 440     }
 441   va_end (arg);
 442   return result;
 443 }
 444
 445 static int
 446 rpl_fcntl_DUPFD (int fd, int target)
 447 {
 448   int result;
 449 #if !HAVE_FCNTL
 450   result = dupfd (fd, target, 0);
 451 #elif FCNTL_DUPFD_BUGGY || REPLACE_FCHDIR
 452   /* Detect invalid target; needed for cygwin 1.5.x.  */
 453   if (target < 0 || getdtablesize () <= target)
 454     {
 455       result = -1;
 456       errno = EINVAL;
 457     }
 458   else
 459     {
 460       /* Haiku alpha 2 loses fd flags on original.  */
 461       int flags = fcntl (fd, F_GETFD);
 462       if (flags < 0)
 463         result = -1;
 464       else
 465         {
 466           result = fcntl (fd, F_DUPFD, target);
 467           if (0 <= result && fcntl (fd, F_SETFD, flags) == -1)
 468             {
 469               int saved_errno = errno;
 470               close (result);
 471               result = -1;
 472               errno = saved_errno;
 473             }
 474 # if REPLACE_FCHDIR
 475           if (0 <= result)
 476             result = _gl_register_dup (fd, result);
 477 # endif
 478         }
 479     }
 480 #else
 481   result = fcntl (fd, F_DUPFD, target);
 482 #endif
 483   return result;
 484 }
 485
 486 static int
 487 rpl_fcntl_DUPFD_CLOEXEC (int fd, int target)
 488 {
 489   int result;
 490 #if !HAVE_FCNTL
 491   result = dupfd (fd, target, O_CLOEXEC);
 492 #else /* HAVE_FCNTL */
 493 # if defined __HAIKU__
 494   /* On Haiku, the system fcntl (fd, F_DUPFD_CLOEXEC, target) sets
 495      the FD_CLOEXEC flag on fd, not on target.  Therefore avoid the
 496      system fcntl in this case.  */
 497 #  define have_dupfd_cloexec -1
 498 # else
 499   /* Try the system call first, if the headers claim it exists
 500      (that is, if GNULIB_defined_F_DUPFD_CLOEXEC is 0), since we
 501      may be running with a glibc that has the macro but with an
 502      older kernel that does not support it.  Cache the
 503      information on whether the system call really works, but
 504      avoid caching failure if the corresponding F_DUPFD fails
 505      for any reason.  0 = unknown, 1 = yes, -1 = no.  */
 506   static int have_dupfd_cloexec = GNULIB_defined_F_DUPFD_CLOEXEC ? -1 : 0;
 507   if (0 <= have_dupfd_cloexec)
 508     {
 509       result = fcntl (fd, F_DUPFD_CLOEXEC, target);
 510       if (0 <= result || errno != EINVAL)
 511         {
 512           have_dupfd_cloexec = 1;
 513 #  if REPLACE_FCHDIR
 514           if (0 <= result)
 515             result = _gl_register_dup (fd, result);
 516 #  endif
 517         }
 518       else
 519         {
 520           result = rpl_fcntl_DUPFD (fd, target);
 521           if (result >= 0)
 522             have_dupfd_cloexec = -1;
 523         }
 524     }
 525   else
 526 # endif
 527     result = rpl_fcntl_DUPFD (fd, target);
 528   if (0 <= result && have_dupfd_cloexec == -1)
 529     {
 530       int flags = fcntl (result, F_GETFD);
 531       if (flags < 0 || fcntl (result, F_SETFD, flags | FD_CLOEXEC) == -1)
 532         {
 533           int saved_errno = errno;
 534           close (result);
 535           errno = saved_errno;
 536           result = -1;
 537         }
 538     }
 539 #endif /* HAVE_FCNTL */
 540   return result;
 541 }
 542
 543 #undef fcntl
 544
 545 #ifdef __KLIBC__
 546
 547 static int
 548 klibc_fcntl (int fd, int action, /* arg */...)
 549 {
 550   va_list arg_ptr;
 551   int arg;
 552   struct stat sbuf;
 553   int result;
 554
 555   va_start (arg_ptr, action);
 556   arg = va_arg (arg_ptr, int);
 557   result = fcntl (fd, action, arg);
 558   /* EPERM for F_DUPFD, ENOTSUP for others */
 559   if (result == -1 && (errno == EPERM || errno == ENOTSUP)
 560       && !fstat (fd, &sbuf) && S_ISDIR (sbuf.st_mode))
 561     {
 562       ULONG ulMode;
 563
 564       switch (action)
 565         {
 566         case F_DUPFD:
 567           /* Find available fd */
 568           while (fcntl (arg, F_GETFL) != -1 || errno != EBADF)
 569             arg++;
 570
 571           result = dup2 (fd, arg);
 572           break;
 573
 574         /* Using underlying APIs is right ? */
 575         case F_GETFD:
 576           if (DosQueryFHState (fd, &ulMode))
 577             break;
 578
 579           result = (ulMode & OPEN_FLAGS_NOINHERIT) ? FD_CLOEXEC : 0;
 580           break;
 581
 582         case F_SETFD:
 583           if (arg & ~FD_CLOEXEC)
 584             break;
 585
 586           if (DosQueryFHState (fd, &ulMode))
 587             break;
 588
 589           if (arg & FD_CLOEXEC)
 590             ulMode |= OPEN_FLAGS_NOINHERIT;
 591           else
 592             ulMode &= ~OPEN_FLAGS_NOINHERIT;
 593
 594           /* Filter supported flags.  */
 595           ulMode &= (OPEN_FLAGS_WRITE_THROUGH | OPEN_FLAGS_FAIL_ON_ERROR
 596                      | OPEN_FLAGS_NO_CACHE | OPEN_FLAGS_NOINHERIT);
 597
 598           if (DosSetFHState (fd, ulMode))
 599             break;
 600
 601           result = 0;
 602           break;
 603
 604         case F_GETFL:
 605           result = 0;
 606           break;
 607
 608         case F_SETFL:
 609           if (arg != 0)
 610             break;
 611
 612           result = 0;
 613           break;
 614
 615         default:
 616           errno = EINVAL;
 617           break;
 618         }
 619     }
 620
 621   va_end (arg_ptr);
 622
 623   return result;
 624 }
 625
 626 #endif