fcntl.c revision 1.1.1.2
1 /* Provide file descriptor control. 2 3 Copyright (C) 2009-2022 Free Software Foundation, Inc. 4 5 This file is free software: you can redistribute it and/or modify 6 it under the terms of the GNU Lesser General Public License as 7 published by the Free Software Foundation; either version 2.1 of the 8 License, or (at your option) any later version. 9 10 This file 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 Lesser General Public License for more details. 14 15 You should have received a copy of the GNU Lesser General Public License 16 along with this program. If not, see <https://www.gnu.org/licenses/>. */ 17 18 /* Written by Eric Blake <ebb9 (at) 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 <stdlib.h> 29 #include <unistd.h> 30 31 #ifdef __KLIBC__ 32 # define INCL_DOS 33 # include <os2.h> 34 #endif 35 36 #if defined _WIN32 && ! defined __CYGWIN__ 37 /* Get declarations of the native Windows API functions. */ 38 # define WIN32_LEAN_AND_MEAN 39 # include <windows.h> 40 41 /* Get _get_osfhandle. */ 42 # if GNULIB_MSVC_NOTHROW 43 # include "msvc-nothrow.h" 44 # else 45 # include <io.h> 46 # endif 47 48 /* Upper bound on getdtablesize(). See lib/getdtablesize.c. */ 49 # define OPEN_MAX_MAX 0x10000 50 51 /* Duplicate OLDFD into the first available slot of at least NEWFD, 52 which must be positive, with FLAGS determining whether the duplicate 53 will be inheritable. */ 54 static int 55 dupfd (int oldfd, int newfd, int flags) 56 { 57 /* Mingw has no way to create an arbitrary fd. Iterate until all 58 file descriptors less than newfd are filled up. */ 59 HANDLE curr_process = GetCurrentProcess (); 60 HANDLE old_handle = (HANDLE) _get_osfhandle (oldfd); 61 unsigned char fds_to_close[OPEN_MAX_MAX / CHAR_BIT]; 62 unsigned int fds_to_close_bound = 0; 63 int result; 64 BOOL inherit = flags & O_CLOEXEC ? FALSE : TRUE; 65 int mode; 66 67 if (newfd < 0 || getdtablesize () <= newfd) 68 { 69 errno = EINVAL; 70 return -1; 71 } 72 if (old_handle == INVALID_HANDLE_VALUE 73 || (mode = _setmode (oldfd, O_BINARY)) == -1) 74 { 75 /* oldfd is not open, or is an unassigned standard file 76 descriptor. */ 77 errno = EBADF; 78 return -1; 79 } 80 _setmode (oldfd, mode); 81 flags |= mode; 82 83 for (;;) 84 { 85 HANDLE new_handle; 86 int duplicated_fd; 87 unsigned int index; 88 89 if (!DuplicateHandle (curr_process, /* SourceProcessHandle */ 90 old_handle, /* SourceHandle */ 91 curr_process, /* TargetProcessHandle */ 92 (PHANDLE) &new_handle, /* TargetHandle */ 93 (DWORD) 0, /* DesiredAccess */ 94 inherit, /* InheritHandle */ 95 DUPLICATE_SAME_ACCESS)) /* Options */ 96 { 97 switch (GetLastError ()) 98 { 99 case ERROR_TOO_MANY_OPEN_FILES: 100 errno = EMFILE; 101 break; 102 case ERROR_INVALID_HANDLE: 103 case ERROR_INVALID_TARGET_HANDLE: 104 case ERROR_DIRECT_ACCESS_HANDLE: 105 errno = EBADF; 106 break; 107 case ERROR_INVALID_PARAMETER: 108 case ERROR_INVALID_FUNCTION: 109 case ERROR_INVALID_ACCESS: 110 errno = EINVAL; 111 break; 112 default: 113 errno = EACCES; 114 break; 115 } 116 result = -1; 117 break; 118 } 119 duplicated_fd = _open_osfhandle ((intptr_t) new_handle, flags); 120 if (duplicated_fd < 0) 121 { 122 CloseHandle (new_handle); 123 result = -1; 124 break; 125 } 126 if (newfd <= duplicated_fd) 127 { 128 result = duplicated_fd; 129 break; 130 } 131 132 /* Set the bit duplicated_fd in fds_to_close[]. */ 133 index = (unsigned int) duplicated_fd / CHAR_BIT; 134 if (fds_to_close_bound <= index) 135 { 136 if (sizeof fds_to_close <= index) 137 /* Need to increase OPEN_MAX_MAX. */ 138 abort (); 139 memset (fds_to_close + fds_to_close_bound, '\0', 140 index + 1 - fds_to_close_bound); 141 fds_to_close_bound = index + 1; 142 } 143 fds_to_close[index] |= 1 << ((unsigned int) duplicated_fd % CHAR_BIT); 144 } 145 146 /* Close the previous fds that turned out to be too small. */ 147 { 148 int saved_errno = errno; 149 unsigned int duplicated_fd; 150 151 for (duplicated_fd = 0; 152 duplicated_fd < fds_to_close_bound * CHAR_BIT; 153 duplicated_fd++) 154 if ((fds_to_close[duplicated_fd / CHAR_BIT] 155 >> (duplicated_fd % CHAR_BIT)) 156 & 1) 157 close (duplicated_fd); 158 159 errno = saved_errno; 160 } 161 162 # if REPLACE_FCHDIR 163 if (0 <= result) 164 result = _gl_register_dup (oldfd, result); 165 # endif 166 return result; 167 } 168 #endif /* W32 */ 169 170 /* Forward declarations, because we '#undef fcntl' in the middle of this 171 compilation unit. */ 172 /* Our implementation of fcntl (fd, F_DUPFD, target). */ 173 static int rpl_fcntl_DUPFD (int fd, int target); 174 /* Our implementation of fcntl (fd, F_DUPFD_CLOEXEC, target). */ 175 static int rpl_fcntl_DUPFD_CLOEXEC (int fd, int target); 176 #ifdef __KLIBC__ 177 /* Adds support for fcntl on directories. */ 178 static int klibc_fcntl (int fd, int action, /* arg */...); 179 #endif 180 181 182 /* Perform the specified ACTION on the file descriptor FD, possibly 183 using the argument ARG further described below. This replacement 184 handles the following actions, and forwards all others on to the 185 native fcntl. An unrecognized ACTION returns -1 with errno set to 186 EINVAL. 187 188 F_DUPFD - duplicate FD, with int ARG being the minimum target fd. 189 If successful, return the duplicate, which will be inheritable; 190 otherwise return -1 and set errno. 191 192 F_DUPFD_CLOEXEC - duplicate FD, with int ARG being the minimum 193 target fd. If successful, return the duplicate, which will not be 194 inheritable; otherwise return -1 and set errno. 195 196 F_GETFD - ARG need not be present. If successful, return a 197 non-negative value containing the descriptor flags of FD (only 198 FD_CLOEXEC is portable, but other flags may be present); otherwise 199 return -1 and set errno. */ 200 201 int 202 fcntl (int fd, int action, /* arg */...) 203 #undef fcntl 204 #ifdef __KLIBC__ 205 # define fcntl klibc_fcntl 206 #endif 207 { 208 va_list arg; 209 int result = -1; 210 va_start (arg, action); 211 switch (action) 212 { 213 case F_DUPFD: 214 { 215 int target = va_arg (arg, int); 216 result = rpl_fcntl_DUPFD (fd, target); 217 break; 218 } 219 220 case F_DUPFD_CLOEXEC: 221 { 222 int target = va_arg (arg, int); 223 result = rpl_fcntl_DUPFD_CLOEXEC (fd, target); 224 break; 225 } 226 227 #if !HAVE_FCNTL 228 case F_GETFD: 229 { 230 # if defined _WIN32 && ! defined __CYGWIN__ 231 HANDLE handle = (HANDLE) _get_osfhandle (fd); 232 DWORD flags; 233 if (handle == INVALID_HANDLE_VALUE 234 || GetHandleInformation (handle, &flags) == 0) 235 errno = EBADF; 236 else 237 result = (flags & HANDLE_FLAG_INHERIT) ? 0 : FD_CLOEXEC; 238 # else /* !W32 */ 239 /* Use dup2 to reject invalid file descriptors. No way to 240 access this information, so punt. */ 241 if (0 <= dup2 (fd, fd)) 242 result = 0; 243 # endif /* !W32 */ 244 break; 245 } /* F_GETFD */ 246 #endif /* !HAVE_FCNTL */ 247 248 /* Implementing F_SETFD on mingw is not trivial - there is no 249 API for changing the O_NOINHERIT bit on an fd, and merely 250 changing the HANDLE_FLAG_INHERIT bit on the underlying handle 251 can lead to odd state. It may be possible by duplicating the 252 handle, using _open_osfhandle with the right flags, then 253 using dup2 to move the duplicate onto the original, but that 254 is not supported for now. */ 255 256 default: 257 { 258 #if HAVE_FCNTL 259 switch (action) 260 { 261 #ifdef F_BARRIERFSYNC /* macOS */ 262 case F_BARRIERFSYNC: 263 #endif 264 #ifdef F_CHKCLEAN /* macOS */ 265 case F_CHKCLEAN: 266 #endif 267 #ifdef F_CLOSEM /* NetBSD, HP-UX */ 268 case F_CLOSEM: 269 #endif 270 #ifdef F_FLUSH_DATA /* macOS */ 271 case F_FLUSH_DATA: 272 #endif 273 #ifdef F_FREEZE_FS /* macOS */ 274 case F_FREEZE_FS: 275 #endif 276 #ifdef F_FULLFSYNC /* macOS */ 277 case F_FULLFSYNC: 278 #endif 279 #ifdef F_GETCONFINED /* macOS */ 280 case F_GETCONFINED: 281 #endif 282 #ifdef F_GETDEFAULTPROTLEVEL /* macOS */ 283 case F_GETDEFAULTPROTLEVEL: 284 #endif 285 #ifdef F_GETFD /* POSIX */ 286 case F_GETFD: 287 #endif 288 #ifdef F_GETFL /* POSIX */ 289 case F_GETFL: 290 #endif 291 #ifdef F_GETLEASE /* Linux */ 292 case F_GETLEASE: 293 #endif 294 #ifdef F_GETNOSIGPIPE /* macOS */ 295 case F_GETNOSIGPIPE: 296 #endif 297 #ifdef F_GETOWN /* POSIX */ 298 case F_GETOWN: 299 #endif 300 #ifdef F_GETPIPE_SZ /* Linux */ 301 case F_GETPIPE_SZ: 302 #endif 303 #ifdef F_GETPROTECTIONCLASS /* macOS */ 304 case F_GETPROTECTIONCLASS: 305 #endif 306 #ifdef F_GETPROTECTIONLEVEL /* macOS */ 307 case F_GETPROTECTIONLEVEL: 308 #endif 309 #ifdef F_GET_SEALS /* Linux */ 310 case F_GET_SEALS: 311 #endif 312 #ifdef F_GETSIG /* Linux */ 313 case F_GETSIG: 314 #endif 315 #ifdef F_MAXFD /* NetBSD */ 316 case F_MAXFD: 317 #endif 318 #ifdef F_RECYCLE /* macOS */ 319 case F_RECYCLE: 320 #endif 321 #ifdef F_SETFIFOENH /* HP-UX */ 322 case F_SETFIFOENH: 323 #endif 324 #ifdef F_THAW_FS /* macOS */ 325 case F_THAW_FS: 326 #endif 327 /* These actions take no argument. */ 328 result = fcntl (fd, action); 329 break; 330 331 #ifdef F_ADD_SEALS /* Linux */ 332 case F_ADD_SEALS: 333 #endif 334 #ifdef F_BADFD /* Solaris */ 335 case F_BADFD: 336 #endif 337 #ifdef F_CHECK_OPENEVT /* macOS */ 338 case F_CHECK_OPENEVT: 339 #endif 340 #ifdef F_DUP2FD /* FreeBSD, AIX, Solaris */ 341 case F_DUP2FD: 342 #endif 343 #ifdef F_DUP2FD_CLOEXEC /* FreeBSD, Solaris */ 344 case F_DUP2FD_CLOEXEC: 345 #endif 346 #ifdef F_DUP2FD_CLOFORK /* Solaris */ 347 case F_DUP2FD_CLOFORK: 348 #endif 349 #ifdef F_DUPFD /* POSIX */ 350 case F_DUPFD: 351 #endif 352 #ifdef F_DUPFD_CLOEXEC /* POSIX */ 353 case F_DUPFD_CLOEXEC: 354 #endif 355 #ifdef F_DUPFD_CLOFORK /* Solaris */ 356 case F_DUPFD_CLOFORK: 357 #endif 358 #ifdef F_GETXFL /* Solaris */ 359 case F_GETXFL: 360 #endif 361 #ifdef F_GLOBAL_NOCACHE /* macOS */ 362 case F_GLOBAL_NOCACHE: 363 #endif 364 #ifdef F_MAKECOMPRESSED /* macOS */ 365 case F_MAKECOMPRESSED: 366 #endif 367 #ifdef F_MOVEDATAEXTENTS /* macOS */ 368 case F_MOVEDATAEXTENTS: 369 #endif 370 #ifdef F_NOCACHE /* macOS */ 371 case F_NOCACHE: 372 #endif 373 #ifdef F_NODIRECT /* macOS */ 374 case F_NODIRECT: 375 #endif 376 #ifdef F_NOTIFY /* Linux */ 377 case F_NOTIFY: 378 #endif 379 #ifdef F_OPLKACK /* IRIX */ 380 case F_OPLKACK: 381 #endif 382 #ifdef F_OPLKREG /* IRIX */ 383 case F_OPLKREG: 384 #endif 385 #ifdef F_RDAHEAD /* macOS */ 386 case F_RDAHEAD: 387 #endif 388 #ifdef F_SETBACKINGSTORE /* macOS */ 389 case F_SETBACKINGSTORE: 390 #endif 391 #ifdef F_SETCONFINED /* macOS */ 392 case F_SETCONFINED: 393 #endif 394 #ifdef F_SETFD /* POSIX */ 395 case F_SETFD: 396 #endif 397 #ifdef F_SETFL /* POSIX */ 398 case F_SETFL: 399 #endif 400 #ifdef F_SETLEASE /* Linux */ 401 case F_SETLEASE: 402 #endif 403 #ifdef F_SETNOSIGPIPE /* macOS */ 404 case F_SETNOSIGPIPE: 405 #endif 406 #ifdef F_SETOWN /* POSIX */ 407 case F_SETOWN: 408 #endif 409 #ifdef F_SETPIPE_SZ /* Linux */ 410 case F_SETPIPE_SZ: 411 #endif 412 #ifdef F_SETPROTECTIONCLASS /* macOS */ 413 case F_SETPROTECTIONCLASS: 414 #endif 415 #ifdef F_SETSIG /* Linux */ 416 case F_SETSIG: 417 #endif 418 #ifdef F_SINGLE_WRITER /* macOS */ 419 case F_SINGLE_WRITER: 420 #endif 421 /* These actions take an 'int' argument. */ 422 { 423 int x = va_arg (arg, int); 424 result = fcntl (fd, action, x); 425 } 426 break; 427 428 default: 429 /* Other actions take a pointer argument. */ 430 { 431 void *p = va_arg (arg, void *); 432 result = fcntl (fd, action, p); 433 } 434 break; 435 } 436 #else 437 errno = EINVAL; 438 #endif 439 break; 440 } 441 } 442 va_end (arg); 443 return result; 444 } 445 446 static int 447 rpl_fcntl_DUPFD (int fd, int target) 448 { 449 int result; 450 #if !HAVE_FCNTL 451 result = dupfd (fd, target, 0); 452 #elif FCNTL_DUPFD_BUGGY || REPLACE_FCHDIR 453 /* Detect invalid target; needed for cygwin 1.5.x. */ 454 if (target < 0 || getdtablesize () <= target) 455 { 456 result = -1; 457 errno = EINVAL; 458 } 459 else 460 { 461 /* Haiku alpha 2 loses fd flags on original. */ 462 int flags = fcntl (fd, F_GETFD); 463 if (flags < 0) 464 result = -1; 465 else 466 { 467 result = fcntl (fd, F_DUPFD, target); 468 if (0 <= result && fcntl (fd, F_SETFD, flags) == -1) 469 { 470 int saved_errno = errno; 471 close (result); 472 result = -1; 473 errno = saved_errno; 474 } 475 # if REPLACE_FCHDIR 476 if (0 <= result) 477 result = _gl_register_dup (fd, result); 478 # endif 479 } 480 } 481 #else 482 result = fcntl (fd, F_DUPFD, target); 483 #endif 484 return result; 485 } 486 487 static int 488 rpl_fcntl_DUPFD_CLOEXEC (int fd, int target) 489 { 490 int result; 491 #if !HAVE_FCNTL 492 result = dupfd (fd, target, O_CLOEXEC); 493 #else /* HAVE_FCNTL */ 494 # if defined __NetBSD__ || defined __HAIKU__ 495 /* On NetBSD 9.0, the system fcntl (fd, F_DUPFD_CLOEXEC, target) 496 has only the same effect as fcntl (fd, F_DUPFD, target). */ 497 /* On Haiku, the system fcntl (fd, F_DUPFD_CLOEXEC, target) sets 498 the FD_CLOEXEC flag on fd, not on target. Therefore avoid the 499 system fcntl in this case. */ 500 # define have_dupfd_cloexec -1 501 # else 502 /* Try the system call first, if the headers claim it exists 503 (that is, if GNULIB_defined_F_DUPFD_CLOEXEC is 0), since we 504 may be running with a glibc that has the macro but with an 505 older kernel that does not support it. Cache the 506 information on whether the system call really works, but 507 avoid caching failure if the corresponding F_DUPFD fails 508 for any reason. 0 = unknown, 1 = yes, -1 = no. */ 509 static int have_dupfd_cloexec = GNULIB_defined_F_DUPFD_CLOEXEC ? -1 : 0; 510 if (0 <= have_dupfd_cloexec) 511 { 512 result = fcntl (fd, F_DUPFD_CLOEXEC, target); 513 if (0 <= result || errno != EINVAL) 514 { 515 have_dupfd_cloexec = 1; 516 # if REPLACE_FCHDIR 517 if (0 <= result) 518 result = _gl_register_dup (fd, result); 519 # endif 520 } 521 else 522 { 523 result = rpl_fcntl_DUPFD (fd, target); 524 if (result >= 0) 525 have_dupfd_cloexec = -1; 526 } 527 } 528 else 529 # endif 530 result = rpl_fcntl_DUPFD (fd, target); 531 if (0 <= result && have_dupfd_cloexec == -1) 532 { 533 int flags = fcntl (result, F_GETFD); 534 if (flags < 0 || fcntl (result, F_SETFD, flags | FD_CLOEXEC) == -1) 535 { 536 int saved_errno = errno; 537 close (result); 538 errno = saved_errno; 539 result = -1; 540 } 541 } 542 #endif /* HAVE_FCNTL */ 543 return result; 544 } 545 546 #undef fcntl 547 548 #ifdef __KLIBC__ 549 550 static int 551 klibc_fcntl (int fd, int action, /* arg */...) 552 { 553 va_list arg_ptr; 554 int arg; 555 struct stat sbuf; 556 int result; 557 558 va_start (arg_ptr, action); 559 arg = va_arg (arg_ptr, int); 560 result = fcntl (fd, action, arg); 561 /* EPERM for F_DUPFD, ENOTSUP for others */ 562 if (result == -1 && (errno == EPERM || errno == ENOTSUP) 563 && !fstat (fd, &sbuf) && S_ISDIR (sbuf.st_mode)) 564 { 565 ULONG ulMode; 566 567 switch (action) 568 { 569 case F_DUPFD: 570 /* Find available fd */ 571 while (fcntl (arg, F_GETFL) != -1 || errno != EBADF) 572 arg++; 573 574 result = dup2 (fd, arg); 575 break; 576 577 /* Using underlying APIs is right ? */ 578 case F_GETFD: 579 if (DosQueryFHState (fd, &ulMode)) 580 break; 581 582 result = (ulMode & OPEN_FLAGS_NOINHERIT) ? FD_CLOEXEC : 0; 583 break; 584 585 case F_SETFD: 586 if (arg & ~FD_CLOEXEC) 587 break; 588 589 if (DosQueryFHState (fd, &ulMode)) 590 break; 591 592 if (arg & FD_CLOEXEC) 593 ulMode |= OPEN_FLAGS_NOINHERIT; 594 else 595 ulMode &= ~OPEN_FLAGS_NOINHERIT; 596 597 /* Filter supported flags. */ 598 ulMode &= (OPEN_FLAGS_WRITE_THROUGH | OPEN_FLAGS_FAIL_ON_ERROR 599 | OPEN_FLAGS_NO_CACHE | OPEN_FLAGS_NOINHERIT); 600 601 if (DosSetFHState (fd, ulMode)) 602 break; 603 604 result = 0; 605 break; 606 607 case F_GETFL: 608 result = 0; 609 break; 610 611 case F_SETFL: 612 if (arg != 0) 613 break; 614 615 result = 0; 616 break; 617 618 default: 619 errno = EINVAL; 620 break; 621 } 622 } 623 624 va_end (arg_ptr); 625 626 return result; 627 } 628 629 #endif 630
Indexes created Sun Apr 19 00:22:55 UTC 2026