1 /* Provide file descriptor control. 2 3 Copyright (C) 2009-2015 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 } 328