gnulib/import/open.c

   1 /* Open a descriptor to a file.
   2    Copyright (C) 2007-2019 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2007.  */
  18
  19 /* If the user's config.h happens to include <fcntl.h>, let it include only
  20    the system's <fcntl.h> here, so that orig_open doesn't recurse to
  21    rpl_open.  */
  22 #define __need_system_fcntl_h
  23 #include <config.h>
  24
  25 /* Get the original definition of open.  It might be defined as a macro.  */
  26 #include <fcntl.h>
  27 #include <sys/types.h>
  28 #undef __need_system_fcntl_h
  29
  30 static int
  31 orig_open (const char *filename, int flags, mode_t mode)
  32 {
  33   return open (filename, flags, mode);
  34 }
  35
  36 /* Specification.  */
  37 /* Write "fcntl.h" here, not <fcntl.h>, otherwise OSF/1 5.1 DTK cc eliminates
  38    this include because of the preliminary #include <fcntl.h> above.  */
  39 #include "fcntl.h"
  40
  41 #include "cloexec.h"
  42
  43 #include <errno.h>
  44 #include <stdarg.h>
  45 #include <string.h>
  46 #include <sys/types.h>
  47 #include <sys/stat.h>
  48 #include <unistd.h>
  49
  50 #ifndef REPLACE_OPEN_DIRECTORY
  51 # define REPLACE_OPEN_DIRECTORY 0
  52 #endif
  53
  54 int
  55 open (const char *filename, int flags, ...)
  56 {
  57   /* 0 = unknown, 1 = yes, -1 = no.  */
  58 #if GNULIB_defined_O_CLOEXEC
  59   int have_cloexec = -1;
  60 #else
  61   static int have_cloexec;
  62 #endif
  63
  64   mode_t mode;
  65   int fd;
  66
  67   mode = 0;
  68   if (flags & O_CREAT)
  69     {
  70       va_list arg;
  71       va_start (arg, flags);
  72
  73       /* We have to use PROMOTED_MODE_T instead of mode_t, otherwise GCC 4
  74          creates crashing code when 'mode_t' is smaller than 'int'.  */
  75       mode = va_arg (arg, PROMOTED_MODE_T);
  76
  77       va_end (arg);
  78     }
  79
  80 #if GNULIB_defined_O_NONBLOCK
  81   /* The only known platform that lacks O_NONBLOCK is mingw, but it
  82      also lacks named pipes and Unix sockets, which are the only two
  83      file types that require non-blocking handling in open().
  84      Therefore, it is safe to ignore O_NONBLOCK here.  It is handy
  85      that mingw also lacks openat(), so that is also covered here.  */
  86   flags &= ~O_NONBLOCK;
  87 #endif
  88
  89 #if defined _WIN32 && ! defined __CYGWIN__
  90   if (strcmp (filename, "/dev/null") == 0)
  91     filename = "NUL";
  92 #endif
  93
  94 #if OPEN_TRAILING_SLASH_BUG
  95   /* Fail if one of O_CREAT, O_WRONLY, O_RDWR is specified and the filename
  96      ends in a slash, as POSIX says such a filename must name a directory
  97      <https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_13>:
  98        "A pathname that contains at least one non-<slash> character and that
  99         ends with one or more trailing <slash> characters shall not be resolved
 100         successfully unless the last pathname component before the trailing
 101         <slash> characters names an existing directory"
 102      If the named file already exists as a directory, then
 103        - if O_CREAT is specified, open() must fail because of the semantics
 104          of O_CREAT,
 105        - if O_WRONLY or O_RDWR is specified, open() must fail because POSIX
 106          <https://pubs.opengroup.org/onlinepubs/9699919799/functions/open.html>
 107          says that it fails with errno = EISDIR in this case.
 108      If the named file does not exist or does not name a directory, then
 109        - if O_CREAT is specified, open() must fail since open() cannot create
 110          directories,
 111        - if O_WRONLY or O_RDWR is specified, open() must fail because the
 112          file does not contain a '.' directory.  */
 113   if (flags & (O_CREAT | O_WRONLY | O_RDWR))
 114     {
 115       size_t len = strlen (filename);
 116       if (len > 0 && filename[len - 1] == '/')
 117         {
 118           errno = EISDIR;
 119           return -1;
 120         }
 121     }
 122 #endif
 123
 124   fd = orig_open (filename,
 125                   flags & ~(have_cloexec <= 0 ? O_CLOEXEC : 0), mode);
 126
 127   if (flags & O_CLOEXEC)
 128     {
 129       if (! have_cloexec)
 130         {
 131           if (0 <= fd)
 132             have_cloexec = 1;
 133           else if (errno == EINVAL)
 134             {
 135               fd = orig_open (filename, flags & ~O_CLOEXEC, mode);
 136               have_cloexec = -1;
 137             }
 138         }
 139       if (have_cloexec < 0 && 0 <= fd)
 140         set_cloexec_flag (fd, true);
 141     }
 142
 143
 144 #if REPLACE_FCHDIR
 145   /* Implementing fchdir and fdopendir requires the ability to open a
 146      directory file descriptor.  If open doesn't support that (as on
 147      mingw), we use a dummy file that behaves the same as directories
 148      on Linux (ie. always reports EOF on attempts to read()), and
 149      override fstat() in fchdir.c to hide the fact that we have a
 150      dummy.  */
 151   if (REPLACE_OPEN_DIRECTORY && fd < 0 && errno == EACCES
 152       && ((flags & O_ACCMODE) == O_RDONLY
 153           || (O_SEARCH != O_RDONLY && (flags & O_ACCMODE) == O_SEARCH)))
 154     {
 155       struct stat statbuf;
 156       if (stat (filename, &statbuf) == 0 && S_ISDIR (statbuf.st_mode))
 157         {
 158           /* Maximum recursion depth of 1.  */
 159           fd = open ("/dev/null", flags, mode);
 160           if (0 <= fd)
 161             fd = _gl_register_fd (fd, filename);
 162         }
 163       else
 164         errno = EACCES;
 165     }
 166 #endif
 167
 168 #if OPEN_TRAILING_SLASH_BUG
 169   /* If the filename ends in a slash and fd does not refer to a directory,
 170      then fail.
 171      Rationale: POSIX says such a filename must name a directory
 172      <https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_13>:
 173        "A pathname that contains at least one non-<slash> character and that
 174         ends with one or more trailing <slash> characters shall not be resolved
 175         successfully unless the last pathname component before the trailing
 176         <slash> characters names an existing directory"
 177      If the named file without the slash is not a directory, open() must fail
 178      with ENOTDIR.  */
 179   if (fd >= 0)
 180     {
 181       /* We know len is positive, since open did not fail with ENOENT.  */
 182       size_t len = strlen (filename);
 183       if (filename[len - 1] == '/')
 184         {
 185           struct stat statbuf;
 186
 187           if (fstat (fd, &statbuf) >= 0 && !S_ISDIR (statbuf.st_mode))
 188             {
 189               close (fd);
 190               errno = ENOTDIR;
 191               return -1;
 192             }
 193         }
 194     }
 195 #endif
 196
 197 #if REPLACE_FCHDIR
 198   if (!REPLACE_OPEN_DIRECTORY && 0 <= fd)
 199     fd = _gl_register_fd (fd, filename);
 200 #endif
 201
 202   return fd;
 203 }