Bump to 1.14.1
[platform/upstream/augeas.git] / lib / fcntl.c
1 /* Provide file descriptor control.
2
3    Copyright (C) 2009-2016 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 #ifdef __KLIBC__
166
167 # define INCL_DOS
168 # include <os2.h>
169
170 static int
171 klibc_fcntl (int fd, int action, /* arg */...)
172 {
173   va_list arg_ptr;
174   int arg;
175   struct stat sbuf;
176   int result = -1;
177
178   va_start (arg_ptr, action);
179   arg = va_arg (arg_ptr, int);
180   result = fcntl (fd, action, arg);
181   /* EPERM for F_DUPFD, ENOTSUP for others */
182   if (result == -1 && (errno == EPERM || errno == ENOTSUP)
183       && !fstat (fd, &sbuf) && S_ISDIR (sbuf.st_mode))
184   {
185     ULONG ulMode;
186
187     switch (action)
188       {
189       case F_DUPFD:
190         /* Find available fd */
191         while (fcntl (arg, F_GETFL) != -1 || errno != EBADF)
192           arg++;
193
194         result = dup2 (fd, arg);
195         break;
196
197       /* Using underlying APIs is right ? */
198       case F_GETFD:
199         if (DosQueryFHState (fd, &ulMode))
200           break;
201
202         result = (ulMode & OPEN_FLAGS_NOINHERIT) ? FD_CLOEXEC : 0;
203         break;
204
205       case F_SETFD:
206         if (arg & ~FD_CLOEXEC)
207           break;
208
209         if (DosQueryFHState (fd, &ulMode))
210           break;
211
212         if (arg & FD_CLOEXEC)
213           ulMode |= OPEN_FLAGS_NOINHERIT;
214         else
215           ulMode &= ~OPEN_FLAGS_NOINHERIT;
216
217         /* Filter supported flags.  */
218         ulMode &= (OPEN_FLAGS_WRITE_THROUGH | OPEN_FLAGS_FAIL_ON_ERROR
219                    | OPEN_FLAGS_NO_CACHE | OPEN_FLAGS_NOINHERIT);
220
221         if (DosSetFHState (fd, ulMode))
222           break;
223
224         result = 0;
225         break;
226
227       case F_GETFL:
228         result = 0;
229         break;
230
231       case F_SETFL:
232         if (arg != 0)
233           break;
234
235         result = 0;
236         break;
237
238       default :
239         errno = EINVAL;
240         break;
241       }
242   }
243
244   va_end (arg_ptr);
245
246   return result;
247 }
248
249 # define fcntl klibc_fcntl
250 #endif
251
252 /* Perform the specified ACTION on the file descriptor FD, possibly
253    using the argument ARG further described below.  This replacement
254    handles the following actions, and forwards all others on to the
255    native fcntl.  An unrecognized ACTION returns -1 with errno set to
256    EINVAL.
257
258    F_DUPFD - duplicate FD, with int ARG being the minimum target fd.
259    If successful, return the duplicate, which will be inheritable;
260    otherwise return -1 and set errno.
261
262    F_DUPFD_CLOEXEC - duplicate FD, with int ARG being the minimum
263    target fd.  If successful, return the duplicate, which will not be
264    inheritable; otherwise return -1 and set errno.
265
266    F_GETFD - ARG need not be present.  If successful, return a
267    non-negative value containing the descriptor flags of FD (only
268    FD_CLOEXEC is portable, but other flags may be present); otherwise
269    return -1 and set errno.  */
270
271 int
272 rpl_fcntl (int fd, int action, /* arg */...)
273 {
274   va_list arg;
275   int result = -1;
276   va_start (arg, action);
277   switch (action)
278     {
279
280 #if !HAVE_FCNTL
281     case F_DUPFD:
282       {
283         int target = va_arg (arg, int);
284         result = dupfd (fd, target, 0);
285         break;
286       }
287 #elif FCNTL_DUPFD_BUGGY || REPLACE_FCHDIR
288     case F_DUPFD:
289       {
290         int target = va_arg (arg, int);
291         /* Detect invalid target; needed for cygwin 1.5.x.  */
292         if (target < 0 || getdtablesize () <= target)
293           errno = EINVAL;
294         else
295           {
296             /* Haiku alpha 2 loses fd flags on original.  */
297             int flags = fcntl (fd, F_GETFD);
298             if (flags < 0)
299               {
300                 result = -1;
301                 break;
302               }
303             result = fcntl (fd, action, target);
304             if (0 <= result && fcntl (fd, F_SETFD, flags) == -1)
305               {
306                 int saved_errno = errno;
307                 close (result);
308                 result = -1;
309                 errno = saved_errno;
310               }
311 # if REPLACE_FCHDIR
312             if (0 <= result)
313               result = _gl_register_dup (fd, result);
314 # endif
315           }
316         break;
317       } /* F_DUPFD */
318 #endif /* FCNTL_DUPFD_BUGGY || REPLACE_FCHDIR */
319
320     case F_DUPFD_CLOEXEC:
321       {
322         int target = va_arg (arg, int);
323
324 #if !HAVE_FCNTL
325         result = dupfd (fd, target, O_CLOEXEC);
326         break;
327 #else /* HAVE_FCNTL */
328         /* Try the system call first, if the headers claim it exists
329            (that is, if GNULIB_defined_F_DUPFD_CLOEXEC is 0), since we
330            may be running with a glibc that has the macro but with an
331            older kernel that does not support it.  Cache the
332            information on whether the system call really works, but
333            avoid caching failure if the corresponding F_DUPFD fails
334            for any reason.  0 = unknown, 1 = yes, -1 = no.  */
335         static int have_dupfd_cloexec = GNULIB_defined_F_DUPFD_CLOEXEC ? -1 : 0;
336         if (0 <= have_dupfd_cloexec)
337           {
338             result = fcntl (fd, action, target);
339             if (0 <= result || errno != EINVAL)
340               {
341                 have_dupfd_cloexec = 1;
342 # if REPLACE_FCHDIR
343                 if (0 <= result)
344                   result = _gl_register_dup (fd, result);
345 # endif
346               }
347             else
348               {
349                 result = rpl_fcntl (fd, F_DUPFD, target);
350                 if (result < 0)
351                   break;
352                 have_dupfd_cloexec = -1;
353               }
354           }
355         else
356           result = rpl_fcntl (fd, F_DUPFD, target);
357         if (0 <= result && have_dupfd_cloexec == -1)
358           {
359             int flags = fcntl (result, F_GETFD);
360             if (flags < 0 || fcntl (result, F_SETFD, flags | FD_CLOEXEC) == -1)
361               {
362                 int saved_errno = errno;
363                 close (result);
364                 errno = saved_errno;
365                 result = -1;
366               }
367           }
368         break;
369 #endif /* HAVE_FCNTL */
370       } /* F_DUPFD_CLOEXEC */
371
372 #if !HAVE_FCNTL
373     case F_GETFD:
374       {
375 # if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
376         HANDLE handle = (HANDLE) _get_osfhandle (fd);
377         DWORD flags;
378         if (handle == INVALID_HANDLE_VALUE
379             || GetHandleInformation (handle, &flags) == 0)
380           errno = EBADF;
381         else
382           result = (flags & HANDLE_FLAG_INHERIT) ? 0 : FD_CLOEXEC;
383 # else /* !W32 */
384         /* Use dup2 to reject invalid file descriptors.  No way to
385            access this information, so punt.  */
386         if (0 <= dup2 (fd, fd))
387           result = 0;
388 # endif /* !W32 */
389         break;
390       } /* F_GETFD */
391 #endif /* !HAVE_FCNTL */
392
393       /* Implementing F_SETFD on mingw is not trivial - there is no
394          API for changing the O_NOINHERIT bit on an fd, and merely
395          changing the HANDLE_FLAG_INHERIT bit on the underlying handle
396          can lead to odd state.  It may be possible by duplicating the
397          handle, using _open_osfhandle with the right flags, then
398          using dup2 to move the duplicate onto the original, but that
399          is not supported for now.  */
400
401     default:
402       {
403 #if HAVE_FCNTL
404         void *p = va_arg (arg, void *);
405         result = fcntl (fd, action, p);
406 #else
407         errno = EINVAL;
408 #endif
409         break;
410       }
411     }
412   va_end (arg);
413   return result;
414 }