sysdeps/posix/opendir.c

   1 /* Copyright (C) 1991-2014 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library 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 GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <http://www.gnu.org/licenses/>.  */
  17
  18 #include <assert.h>
  19 #include <errno.h>
  20 #include <limits.h>
  21 #include <stddef.h>
  22 #include <stdlib.h>
  23 #include <dirent.h>
  24 #include <fcntl.h>
  25 #include <sys/param.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <unistd.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31
  32 #include <dirstream.h>
  33 #include <not-cancel.h>
  34 #include <kernel-features.h>
  35
  36 /* The st_blksize value of the directory is used as a hint for the
  37    size of the buffer which receives struct dirent values from the
  38    kernel.  st_blksize is limited to MAX_DIR_BUFFER_SIZE, in case the
  39    file system provides a bogus value.  */
  40 #define MAX_DIR_BUFFER_SIZE 1048576U
  41
  42 /* opendir() must not accidentally open something other than a directory.
  43    Some OS's have kernel support for that, some don't.  In the worst
  44    case we have to stat() before the open() AND fstat() after.
  45
  46    We have to test at runtime for kernel support since libc may have
  47    been compiled with different headers to the kernel it's running on.
  48    This test can't be done reliably in the general case.  We'll use
  49    /dev/null, which if it's not a device lots of stuff will break, as
  50    a guinea pig.  It may be missing in chroot environments, so we
  51    make sure to fail safe. */
  52 #ifdef O_DIRECTORY
  53 # ifdef O_DIRECTORY_WORKS
  54 #  define o_directory_works 1
  55 #  define tryopen_o_directory() while (1) /* This must not be called.  */
  56 # else
  57 static int o_directory_works;
  58
  59 static void
  60 tryopen_o_directory (void)
  61 {
  62   int serrno = errno;
  63   int x = open_not_cancel_2 ("/dev/null", O_RDONLY|O_NDELAY|O_DIRECTORY);
  64
  65   if (x >= 0)
  66     {
  67       close_not_cancel_no_status (x);
  68       o_directory_works = -1;
  69     }
  70   else if (errno != ENOTDIR)
  71     o_directory_works = -1;
  72   else
  73     o_directory_works = 1;
  74
  75   __set_errno (serrno);
  76 }
  77 # endif
  78 # define EXTRA_FLAGS O_DIRECTORY
  79 #else
  80 # define EXTRA_FLAGS 0
  81 #endif
  82
  83
  84 DIR *
  85 internal_function
  86 __opendirat (int dfd, const char *name)
  87 {
  88   struct stat64 statbuf;
  89   struct stat64 *statp = NULL;
  90
  91   if (__builtin_expect (name[0], '\1') == '\0')
  92     {
  93       /* POSIX.1-1990 says an empty name gets ENOENT;
  94          but `open' might like it fine.  */
  95       __set_errno (ENOENT);
  96       return NULL;
  97     }
  98
  99 #ifdef O_DIRECTORY
 100   /* Test whether O_DIRECTORY works.  */
 101   if (o_directory_works == 0)
 102     tryopen_o_directory ();
 103
 104   /* We can skip the expensive `stat' call if O_DIRECTORY works.  */
 105   if (o_directory_works < 0)
 106 #endif
 107     {
 108       /* We first have to check whether the name is for a directory.  We
 109          cannot do this after the open() call since the open/close operation
 110          performed on, say, a tape device might have undesirable effects.  */
 111       if (__builtin_expect (__xstat64 (_STAT_VER, name, &statbuf), 0) < 0)
 112         return NULL;
 113       if (__glibc_unlikely (! S_ISDIR (statbuf.st_mode)))
 114         {
 115           __set_errno (ENOTDIR);
 116           return NULL;
 117          }
 118     }
 119
 120   int flags = O_RDONLY|O_NDELAY|EXTRA_FLAGS|O_LARGEFILE;
 121 #ifdef O_CLOEXEC
 122   flags |= O_CLOEXEC;
 123 #endif
 124   int fd;
 125 #if IS_IN (rtld)
 126   assert (dfd == AT_FDCWD);
 127   fd = open_not_cancel_2 (name, flags);
 128 #else
 129   fd = openat_not_cancel_3 (dfd, name, flags);
 130 #endif
 131   if (__builtin_expect (fd, 0) < 0)
 132     return NULL;
 133
 134 #ifdef O_DIRECTORY
 135   if (o_directory_works <= 0)
 136 #endif
 137     {
 138       /* Now make sure this really is a directory and nothing changed since
 139          the `stat' call.  */
 140       if (__builtin_expect (__fxstat64 (_STAT_VER, fd, &statbuf), 0) < 0)
 141         goto lose;
 142       if (__glibc_unlikely (! S_ISDIR (statbuf.st_mode)))
 143         {
 144           __set_errno (ENOTDIR);
 145         lose:
 146           close_not_cancel_no_status (fd);
 147           return NULL;
 148         }
 149       statp = &statbuf;
 150     }
 151
 152   return __alloc_dir (fd, true, 0, statp);
 153 }
 154
 155
 156 /* Open a directory stream on NAME.  */
 157 DIR *
 158 __opendir (const char *name)
 159 {
 160   return __opendirat (AT_FDCWD, name);
 161 }
 162 weak_alias (__opendir, opendir)
 163
 164
 165 #ifdef __ASSUME_O_CLOEXEC
 166 # define check_have_o_cloexec(fd) 1
 167 #else
 168 static int
 169 check_have_o_cloexec (int fd)
 170 {
 171   if (__have_o_cloexec == 0)
 172     __have_o_cloexec = (__fcntl (fd, F_GETFD, 0) & FD_CLOEXEC) == 0 ? -1 : 1;
 173   return __have_o_cloexec > 0;
 174 }
 175 #endif
 176
 177
 178 DIR *
 179 internal_function
 180 __alloc_dir (int fd, bool close_fd, int flags, const struct stat64 *statp)
 181 {
 182   /* We always have to set the close-on-exit flag if the user provided
 183      the file descriptor.  Otherwise only if we have no working
 184      O_CLOEXEC support.  */
 185 #ifdef O_CLOEXEC
 186   if ((! close_fd && (flags & O_CLOEXEC) == 0)
 187       || ! check_have_o_cloexec (fd))
 188 #endif
 189     {
 190       if (__builtin_expect (__fcntl (fd, F_SETFD, FD_CLOEXEC), 0) < 0)
 191         goto lose;
 192     }
 193
 194   const size_t default_allocation = (4 * BUFSIZ < sizeof (struct dirent64)
 195                                      ? sizeof (struct dirent64) : 4 * BUFSIZ);
 196   const size_t small_allocation = (BUFSIZ < sizeof (struct dirent64)
 197                                    ? sizeof (struct dirent64) : BUFSIZ);
 198   size_t allocation = default_allocation;
 199 #ifdef _STATBUF_ST_BLKSIZE
 200   /* Increase allocation if requested, but not if the value appears to
 201      be bogus.  */
 202   if (statp != NULL)
 203     allocation = MIN (MAX ((size_t) statp->st_blksize, default_allocation),
 204                       MAX_DIR_BUFFER_SIZE);
 205 #endif
 206
 207   DIR *dirp = (DIR *) malloc (sizeof (DIR) + allocation);
 208   if (dirp == NULL)
 209     {
 210       allocation = small_allocation;
 211       dirp = (DIR *) malloc (sizeof (DIR) + allocation);
 212
 213       if (dirp == NULL)
 214       lose:
 215         {
 216           if (close_fd)
 217             {
 218               int save_errno = errno;
 219               close_not_cancel_no_status (fd);
 220               __set_errno (save_errno);
 221             }
 222           return NULL;
 223         }
 224     }
 225
 226   dirp->fd = fd;
 227 #if IS_IN (libc)
 228   __libc_lock_init (dirp->lock);
 229 #endif
 230   dirp->allocation = allocation;
 231   dirp->size = 0;
 232   dirp->offset = 0;
 233   dirp->filepos = 0;
 234   dirp->errcode = 0;
 235
 236   return dirp;
 237 }