1 /* Copyright (C) 1991-1999, 2004-2011 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
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.
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.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include <sys/types.h>
28 #include <fcntl.h> /* For AT_FDCWD on Solaris 9. */
30 /* If this host provides the openat function, then enable
31 code below to make getcwd more efficient and robust. */
33 # define HAVE_OPENAT_SUPPORT 1
35 # define HAVE_OPENAT_SUPPORT 0
39 # define __set_errno(val) (errno = (val))
43 #ifndef _D_EXACT_NAMLEN
44 # define _D_EXACT_NAMLEN(d) strlen ((d)->d_name)
46 #ifndef _D_ALLOC_NAMLEN
47 # define _D_ALLOC_NAMLEN(d) (_D_EXACT_NAMLEN (d) + 1)
56 # define mempcpy __mempcpy
61 # define MAX(a, b) ((a) < (b) ? (b) : (a))
64 # define MIN(a, b) ((a) < (b) ? (a) : (b))
69 /* In this file, PATH_MAX only serves as a threshold for choosing among two
72 # define PATH_MAX 8192
76 # define MATCHING_INO(dp, ino) ((dp)->d_ino == (ino))
78 # define MATCHING_INO(dp, ino) true
82 # define __getcwd rpl_getcwd
83 # define __lstat lstat
84 # define __closedir closedir
85 # define __opendir opendir
86 # define __readdir readdir
89 /* The results of opendir() in this file are not used with dirfd and fchdir,
90 and we do not leak fds to any single-threaded code that could use stdio,
91 therefore save some unnecessary recursion in fchdir.c.
92 FIXME - if the kernel ever adds support for multi-thread safety for
93 avoiding standard fds, then we should use opendir_safer and
98 /* Get the name of the current working directory, and put it in SIZE
99 bytes of BUF. Returns NULL if the directory couldn't be determined or
100 SIZE was too small. If successful, returns BUF. In GNU, if BUF is
101 NULL, an array is allocated with `malloc'; the array is SIZE bytes long,
102 unless SIZE == 0, in which case it is as big as necessary. */
105 __getcwd (char *buf, size_t size)
107 /* Lengths of big file name components and entire file names, and a
108 deep level of file name nesting. These numbers are not upper
109 bounds; they are merely large values suitable for initial
110 allocations, designed to be large enough for most real-world
114 BIG_FILE_NAME_COMPONENT_LENGTH = 255,
115 BIG_FILE_NAME_LENGTH = MIN (4095, PATH_MAX - 1),
119 #if HAVE_OPENAT_SUPPORT
121 bool fd_needs_closing = false;
123 char dots[DEEP_NESTING * sizeof ".." + BIG_FILE_NAME_COMPONENT_LENGTH + 1];
124 char *dotlist = dots;
125 size_t dotsize = sizeof dots;
128 DIR *dirstream = NULL;
129 dev_t rootdev, thisdev;
130 ino_t rootino, thisino;
134 size_t allocated = size;
137 #if HAVE_RAW_DECL_GETCWD
138 /* If AT_FDCWD is not defined, the algorithm below is O(N**2) and
139 this is much slower than the system getcwd (at least on
140 GNU/Linux). So trust the system getcwd's results unless they
143 Use the system getcwd even if we have openat support, since the
144 system getcwd works even when a parent is unreadable, while the
145 openat-based approach does not. */
148 dir = getcwd (buf, size);
149 if (dir || (size && errno == ERANGE))
152 /* Solaris getcwd (NULL, 0) fails with errno == EINVAL, but it has
153 internal magic that lets it work even if an ancestor directory is
154 inaccessible, which is better in many cases. So in this case try
155 again with a buffer that's almost always big enough. */
156 if (errno == EINVAL && buf == NULL && size == 0)
158 char big_buffer[BIG_FILE_NAME_LENGTH + 1];
159 dir = getcwd (big_buffer, sizeof big_buffer);
164 # if HAVE_PARTLY_WORKING_GETCWD
165 /* The system getcwd works, except it sometimes fails when it
166 shouldn't, setting errno to ERANGE, ENAMETOOLONG, or ENOENT. */
167 if (errno != ERANGE && errno != ENAMETOOLONG && errno != ENOENT)
176 __set_errno (EINVAL);
180 allocated = BIG_FILE_NAME_LENGTH + 1;
185 dir = malloc (allocated);
192 dirp = dir + allocated;
195 if (__lstat (".", &st) < 0)
200 if (__lstat ("/", &st) < 0)
205 while (!(thisdev == rootdev && thisino == rootino))
214 bool use_d_ino = true;
216 /* Look at the parent directory. */
217 #if HAVE_OPENAT_SUPPORT
218 fd = openat (fd, "..", O_RDONLY);
221 fd_needs_closing = true;
222 parent_status = fstat (fd, &st);
224 dotlist[dotlen++] = '.';
225 dotlist[dotlen++] = '.';
226 dotlist[dotlen] = '\0';
227 parent_status = __lstat (dotlist, &st);
229 if (parent_status != 0)
232 if (dirstream && __closedir (dirstream) != 0)
238 /* Figure out if this directory is a mount point. */
241 mount_point = dotdev != thisdev;
243 /* Search for the last directory. */
244 #if HAVE_OPENAT_SUPPORT
245 dirstream = fdopendir (fd);
246 if (dirstream == NULL)
248 fd_needs_closing = false;
250 dirstream = __opendir (dotlist);
251 if (dirstream == NULL)
253 dotlist[dotlen++] = '/';
257 /* Clear errno to distinguish EOF from error if readdir returns
260 d = __readdir (dirstream);
262 /* When we've iterated through all directory entries without finding
263 one with a matching d_ino, rewind the stream and consider each
264 name again, but this time, using lstat. This is necessary in a
265 chroot on at least one system (glibc-2.3.6 + linux 2.6.12), where
266 .., ../.., ../../.., etc. all had the same device number, yet the
267 d_ino values for entries in / did not match those obtained
269 if (d == NULL && errno == 0 && use_d_ino)
272 rewinddir (dirstream);
273 d = __readdir (dirstream);
279 /* EOF on dirstream, which can mean e.g., that the current
280 directory has been removed. */
281 __set_errno (ENOENT);
284 if (d->d_name[0] == '.' &&
285 (d->d_name[1] == '\0' ||
286 (d->d_name[1] == '.' && d->d_name[2] == '\0')))
291 bool match = (MATCHING_INO (d, thisino) || mount_point);
298 #if HAVE_OPENAT_SUPPORT
299 entry_status = fstatat (fd, d->d_name, &st, AT_SYMLINK_NOFOLLOW);
301 /* Compute size needed for this file name, or for the file
302 name ".." in the same directory, whichever is larger.
303 Room for ".." might be needed the next time through
305 size_t name_alloc = _D_ALLOC_NAMLEN (d);
306 size_t filesize = dotlen + MAX (sizeof "..", name_alloc);
308 if (filesize < dotlen)
309 goto memory_exhausted;
311 if (dotsize < filesize)
313 /* My, what a deep directory tree you have, Grandma. */
314 size_t newsize = MAX (filesize, dotsize * 2);
316 if (newsize < dotsize)
317 goto memory_exhausted;
320 dotlist = malloc (newsize);
335 memcpy (dotlist + dotlen, d->d_name, _D_ALLOC_NAMLEN (d));
336 entry_status = __lstat (dotlist, &st);
338 /* We don't fail here if we cannot stat() a directory entry.
339 This can happen when (network) file systems fail. If this
340 entry is in fact the one we are looking for we will find
341 out soon as we reach the end of the directory without
342 having found anything. */
343 if (entry_status == 0 && S_ISDIR (st.st_mode)
344 && st.st_dev == thisdev && st.st_ino == thisino)
349 dirroom = dirp - dir;
350 namlen = _D_EXACT_NAMLEN (d);
352 if (dirroom <= namlen)
356 __set_errno (ERANGE);
362 size_t oldsize = allocated;
364 allocated += MAX (allocated, namlen);
365 if (allocated < oldsize
366 || ! (tmp = realloc (dir, allocated)))
367 goto memory_exhausted;
369 /* Move current contents up to the end of the buffer.
370 This is guaranteed to be non-overlapping. */
371 dirp = memcpy (tmp + allocated - (oldsize - dirroom),
378 memcpy (dirp, d->d_name, namlen);
385 if (dirstream && __closedir (dirstream) != 0)
391 if (dirp == &dir[allocated - 1])
394 #if ! HAVE_OPENAT_SUPPORT
399 used = dir + allocated - dirp;
400 memmove (dir, dirp, used);
403 /* Ensure that the buffer is only as large as necessary. */
404 buf = realloc (dir, used);
407 /* Either buf was NULL all along, or `realloc' failed but
408 we still have the original string. */
414 __set_errno (ENOMEM);
419 __closedir (dirstream);
420 #if HAVE_OPENAT_SUPPORT
421 if (fd_needs_closing)
435 weak_alias (__getcwd, getcwd)