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