]>
Commit | Line | Data |
---|---|---|
6ec2e0f5 SDJ |
1 | /* Provide file descriptor control. |
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 | } |