1 /* Copyright (C) 1991,92,93,94,95,96,97,98,99,2004,2005,2006,2007 Free Software
3 This file is part of the GNU C Library.
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program 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
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include <sys/types.h>
30 #include <fcntl.h> /* For AT_FDCWD on Solaris 9. */
32 /* If this host provides the openat function, then enable
33 code below to make getcwd more efficient and robust. */
35 # define HAVE_OPENAT_SUPPORT 1
37 # define HAVE_OPENAT_SUPPORT 0
41 # define __set_errno(val) (errno = (val))
45 #ifndef _D_EXACT_NAMLEN
46 # define _D_EXACT_NAMLEN(d) strlen ((d)->d_name)
48 #ifndef _D_ALLOC_NAMLEN
49 # define _D_ALLOC_NAMLEN(d) (_D_EXACT_NAMLEN (d) + 1)
58 # define mempcpy __mempcpy
64 /* Work around a bug in Solaris 9 and 10: AT_FDCWD is positive. Its
65 value exceeds INT_MAX, so its use as an int doesn't conform to the
66 C standard, and GCC and Sun C complain in some cases. */
67 #if 0 < AT_FDCWD && AT_FDCWD == 0xffd19553
69 # define AT_FDCWD (-3041965)
73 # define is_ENAMETOOLONG(x) ((x) == ENAMETOOLONG)
75 # define is_ENAMETOOLONG(x) 0
79 # define MAX(a, b) ((a) < (b) ? (b) : (a))
82 # define MIN(a, b) ((a) < (b) ? (a) : (b))
87 # define PATH_MAX MAXPATHLEN
89 # define PATH_MAX 1024
94 # define MATCHING_INO(dp, ino) ((dp)->d_ino == (ino))
96 # define MATCHING_INO(dp, ino) true
100 # define __getcwd rpl_getcwd
101 # define __lstat lstat
102 # define __closedir closedir
103 # define __opendir opendir
104 # define __readdir readdir
107 /* The results of opendir() in this file are not used with dirfd and fchdir,
108 therefore save some unnecessary recursion in fchdir.c. */
112 /* Get the name of the current working directory, and put it in SIZE
113 bytes of BUF. Returns NULL if the directory couldn't be determined or
114 SIZE was too small. If successful, returns BUF. In GNU, if BUF is
115 NULL, an array is allocated with `malloc'; the array is SIZE bytes long,
116 unless SIZE == 0, in which case it is as big as necessary. */
119 __getcwd (char *buf, size_t size)
121 /* Lengths of big file name components and entire file names, and a
122 deep level of file name nesting. These numbers are not upper
123 bounds; they are merely large values suitable for initial
124 allocations, designed to be large enough for most real-world
128 BIG_FILE_NAME_COMPONENT_LENGTH = 255,
129 BIG_FILE_NAME_LENGTH = MIN (4095, PATH_MAX - 1),
133 #if HAVE_OPENAT_SUPPORT
135 bool fd_needs_closing = false;
137 char dots[DEEP_NESTING * sizeof ".." + BIG_FILE_NAME_COMPONENT_LENGTH + 1];
138 char *dotlist = dots;
139 size_t dotsize = sizeof dots;
142 DIR *dirstream = NULL;
143 dev_t rootdev, thisdev;
144 ino_t rootino, thisino;
148 size_t allocated = size;
151 #if HAVE_PARTLY_WORKING_GETCWD
152 /* The system getcwd works, except it sometimes fails when it
153 shouldn't, setting errno to ERANGE, ENAMETOOLONG, or ENOENT. If
154 AT_FDCWD is not defined, the algorithm below is O(N**2) and this
155 is much slower than the system getcwd (at least on GNU/Linux).
156 So trust the system getcwd's results unless they look
159 Use the system getcwd even if we have openat support, since the
160 system getcwd works even when a parent is unreadable, while the
161 openat-based approach does not. */
164 dir = getcwd (buf, size);
165 if (dir || (errno != ERANGE && !is_ENAMETOOLONG (errno) && errno != ENOENT))
173 __set_errno (EINVAL);
177 allocated = BIG_FILE_NAME_LENGTH + 1;
182 dir = malloc (allocated);
189 dirp = dir + allocated;
192 if (__lstat (".", &st) < 0)
197 if (__lstat ("/", &st) < 0)
202 while (!(thisdev == rootdev && thisino == rootino))
211 bool use_d_ino = true;
213 /* Look at the parent directory. */
214 #if HAVE_OPENAT_SUPPORT
215 fd = openat (fd, "..", O_RDONLY);
218 fd_needs_closing = true;
219 parent_status = fstat (fd, &st);
221 dotlist[dotlen++] = '.';
222 dotlist[dotlen++] = '.';
223 dotlist[dotlen] = '\0';
224 parent_status = __lstat (dotlist, &st);
226 if (parent_status != 0)
229 if (dirstream && __closedir (dirstream) != 0)
235 /* Figure out if this directory is a mount point. */
238 mount_point = dotdev != thisdev;
240 /* Search for the last directory. */
241 #if HAVE_OPENAT_SUPPORT
242 dirstream = fdopendir (fd);
243 if (dirstream == NULL)
245 /* Reset fd. It may have been closed by fdopendir. */
246 fd = dirfd (dirstream);
247 fd_needs_closing = false;
249 dirstream = __opendir (dotlist);
250 if (dirstream == NULL)
252 dotlist[dotlen++] = '/';
256 /* Clear errno to distinguish EOF from error if readdir returns
259 d = __readdir (dirstream);
261 /* When we've iterated through all directory entries without finding
262 one with a matching d_ino, rewind the stream and consider each
263 name again, but this time, using lstat. This is necessary in a
264 chroot on at least one system (glibc-2.3.6 + linux 2.6.12), where
265 .., ../.., ../../.., etc. all had the same device number, yet the
266 d_ino values for entries in / did not match those obtained
268 if (d == NULL && errno == 0 && use_d_ino)
271 rewinddir (dirstream);
272 d = __readdir (dirstream);
278 /* EOF on dirstream, which can mean e.g., that the current
279 directory has been removed. */
280 __set_errno (ENOENT);
283 if (d->d_name[0] == '.' &&
284 (d->d_name[1] == '\0' ||
285 (d->d_name[1] == '.' && d->d_name[2] == '\0')))
290 bool match = (MATCHING_INO (d, thisino) || mount_point);
297 #if HAVE_OPENAT_SUPPORT
298 entry_status = fstatat (fd, d->d_name, &st, AT_SYMLINK_NOFOLLOW);
300 /* Compute size needed for this file name, or for the file
301 name ".." in the same directory, whichever is larger.
302 Room for ".." might be needed the next time through
304 size_t name_alloc = _D_ALLOC_NAMLEN (d);
305 size_t filesize = dotlen + MAX (sizeof "..", name_alloc);
307 if (filesize < dotlen)
308 goto memory_exhausted;
310 if (dotsize < filesize)
312 /* My, what a deep directory tree you have, Grandma. */
313 size_t newsize = MAX (filesize, dotsize * 2);
315 if (newsize < dotsize)
316 goto memory_exhausted;
319 dotlist = malloc (newsize);
334 memcpy (dotlist + dotlen, d->d_name, _D_ALLOC_NAMLEN (d));
335 entry_status = __lstat (dotlist, &st);
337 /* We don't fail here if we cannot stat() a directory entry.
338 This can happen when (network) file systems fail. If this
339 entry is in fact the one we are looking for we will find
340 out soon as we reach the end of the directory without
341 having found anything. */
342 if (entry_status == 0 && S_ISDIR (st.st_mode)
343 && st.st_dev == thisdev && st.st_ino == thisino)
348 dirroom = dirp - dir;
349 namlen = _D_EXACT_NAMLEN (d);
351 if (dirroom <= namlen)
355 __set_errno (ERANGE);
361 size_t oldsize = allocated;
363 allocated += MAX (allocated, namlen);
364 if (allocated < oldsize
365 || ! (tmp = realloc (dir, allocated)))
366 goto memory_exhausted;
368 /* Move current contents up to the end of the buffer.
369 This is guaranteed to be non-overlapping. */
370 dirp = memcpy (tmp + allocated - (oldsize - dirroom),
377 memcpy (dirp, d->d_name, namlen);
384 if (dirstream && __closedir (dirstream) != 0)
390 if (dirp == &dir[allocated - 1])
393 #if ! HAVE_OPENAT_SUPPORT
398 used = dir + allocated - dirp;
399 memmove (dir, dirp, used);
402 /* Ensure that the buffer is only as large as necessary. */
403 buf = realloc (dir, used);
406 /* Either buf was NULL all along, or `realloc' failed but
407 we still have the original string. */
413 __set_errno (ENOMEM);
418 __closedir (dirstream);
419 #if HAVE_OPENAT_SUPPORT
420 if (fd_needs_closing)
434 weak_alias (__getcwd, getcwd)