gnulib/import/open.c

   1 /* Open a descriptor to a file.
   2    Copyright (C) 2007-2020 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)
 114       || (flags & O_ACCMODE) == O_RDWR
 115       || (flags & O_ACCMODE) == O_WRONLY)
 116     {
 117       size_t len = strlen (filename);
 118       if (len > 0 && filename[len - 1] == '/')
 119         {
 120           errno = EISDIR;
 121           return -1;
 122         }
 123     }
 124 #endif
 125
 126   fd = orig_open (filename,
 127                   flags & ~(have_cloexec < 0 ? O_CLOEXEC : 0), mode);
 128
 129   if (flags & O_CLOEXEC)
 130     {
 131       if (! have_cloexec)
 132         {
 133           if (0 <= fd)
 134             have_cloexec = 1;
 135           else if (errno == EINVAL)
 136             {
 137               fd = orig_open (filename, flags & ~O_CLOEXEC, mode);
 138               have_cloexec = -1;
 139             }
 140         }
 141       if (have_cloexec < 0 && 0 <= fd)
 142         set_cloexec_flag (fd, true);
 143     }
 144
 145
 146 #if REPLACE_FCHDIR
 147   /* Implementing fchdir and fdopendir requires the ability to open a
 148      directory file descriptor.  If open doesn't support that (as on
 149      mingw), we use a dummy file that behaves the same as directories
 150      on Linux (ie. always reports EOF on attempts to read()), and
 151      override fstat() in fchdir.c to hide the fact that we have a
 152      dummy.  */
 153   if (REPLACE_OPEN_DIRECTORY && fd < 0 && errno == EACCES
 154       && ((flags & O_ACCMODE) == O_RDONLY
 155           || (O_SEARCH != O_RDONLY && (flags & O_ACCMODE) == O_SEARCH)))
 156     {
 157       struct stat statbuf;
 158       if (stat (filename, &statbuf) == 0 && S_ISDIR (statbuf.st_mode))
 159         {
 160           /* Maximum recursion depth of 1.  */
 161           fd = open ("/dev/null", flags, mode);
 162           if (0 <= fd)
 163             fd = _gl_register_fd (fd, filename);
 164         }
 165       else
 166         errno = EACCES;
 167     }
 168 #endif
 169
 170 #if OPEN_TRAILING_SLASH_BUG
 171   /* If the filename ends in a slash and fd does not refer to a directory,
 172      then fail.
 173      Rationale: POSIX says such a filename must name a directory
 174      <https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_13>:
 175        "A pathname that contains at least one non-<slash> character and that
 176         ends with one or more trailing <slash> characters shall not be resolved
 177         successfully unless the last pathname component before the trailing
 178         <slash> characters names an existing directory"
 179      If the named file without the slash is not a directory, open() must fail
 180      with ENOTDIR.  */
 181   if (fd >= 0)
 182     {
 183       /* We know len is positive, since open did not fail with ENOENT.  */
 184       size_t len = strlen (filename);
 185       if (filename[len - 1] == '/')
 186         {
 187           struct stat statbuf;
 188
 189           if (fstat (fd, &statbuf) >= 0 && !S_ISDIR (statbuf.st_mode))
 190             {
 191               close (fd);
 192               errno = ENOTDIR;
 193               return -1;
 194             }
 195         }
 196     }
 197 #endif
 198
 199 #if REPLACE_FCHDIR
 200   if (!REPLACE_OPEN_DIRECTORY && 0 <= fd)
 201     fd = _gl_register_fd (fd, filename);
 202 #endif
 203
 204   return fd;
 205 }