1 /* Copyright (C) 1991-1999, 2004-2013 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 or if we're using the
31 gnulib replacement function with a native fdopendir, then enable
32 code below to make getcwd more efficient and robust. */
33 #if defined HAVE_OPENAT || (defined GNULIB_OPENAT && defined HAVE_FDOPENDIR)
34 # define HAVE_OPENAT_SUPPORT 1
36 # define HAVE_OPENAT_SUPPORT 0
40 # define __set_errno(val) (errno = (val))
44 #ifndef _D_EXACT_NAMLEN
45 # define _D_EXACT_NAMLEN(d) strlen ((d)->d_name)
47 #ifndef _D_ALLOC_NAMLEN
48 # define _D_ALLOC_NAMLEN(d) (_D_EXACT_NAMLEN (d) + 1)
57 # define mempcpy __mempcpy
62 # define MAX(a, b) ((a) < (b) ? (b) : (a))
65 # define MIN(a, b) ((a) < (b) ? (a) : (b))
70 /* In this file, PATH_MAX only serves as a threshold for choosing among two
73 # define PATH_MAX 8192
77 # define MATCHING_INO(dp, ino) ((dp)->d_ino == (ino))
79 # define MATCHING_INO(dp, ino) true
83 # define __getcwd rpl_getcwd
84 # define __lstat lstat
85 # define __closedir closedir
86 # define __opendir opendir
87 # define __readdir readdir
90 /* The results of opendir() in this file are not used with dirfd and fchdir,
91 and we do not leak fds to any single-threaded code that could use stdio,
92 therefore save some unnecessary recursion in fchdir.c.
93 FIXME - if the kernel ever adds support for multi-thread safety for
94 avoiding standard fds, then we should use opendir_safer and
99 /* Get the name of the current working directory, and put it in SIZE
100 bytes of BUF. Returns NULL if the directory couldn't be determined or
101 SIZE was too small. If successful, returns BUF. In GNU, if BUF is
102 NULL, an array is allocated with 'malloc'; the array is SIZE bytes long,
103 unless SIZE == 0, in which case it is as big as necessary. */
106 __getcwd (char *buf, size_t size)
108 /* Lengths of big file name components and entire file names, and a
109 deep level of file name nesting. These numbers are not upper
110 bounds; they are merely large values suitable for initial
111 allocations, designed to be large enough for most real-world
115 BIG_FILE_NAME_COMPONENT_LENGTH = 255,
116 BIG_FILE_NAME_LENGTH = MIN (4095, PATH_MAX - 1),
120 #if HAVE_OPENAT_SUPPORT
122 bool fd_needs_closing = false;
124 char dots[DEEP_NESTING * sizeof ".." + BIG_FILE_NAME_COMPONENT_LENGTH + 1];
125 char *dotlist = dots;
126 size_t dotsize = sizeof dots;
129 DIR *dirstream = NULL;
130 dev_t rootdev, thisdev;
131 ino_t rootino, thisino;
135 size_t allocated = size;
138 #if HAVE_MINIMALLY_WORKING_GETCWD
139 /* If AT_FDCWD is not defined, the algorithm below is O(N**2) and
140 this is much slower than the system getcwd (at least on
141 GNU/Linux). So trust the system getcwd's results unless they
144 Use the system getcwd even if we have openat support, since the
145 system getcwd works even when a parent is unreadable, while the
146 openat-based approach does not.
148 But on AIX 5.1..7.1, the system getcwd is not even minimally
149 working: If the current directory name is slightly longer than
150 PATH_MAX, it omits the first directory component and returns
151 this wrong result with errno = 0. */
154 dir = getcwd (buf, size);
155 if (dir || (size && errno == ERANGE))
158 /* Solaris getcwd (NULL, 0) fails with errno == EINVAL, but it has
159 internal magic that lets it work even if an ancestor directory is
160 inaccessible, which is better in many cases. So in this case try
161 again with a buffer that's almost always big enough. */
162 if (errno == EINVAL && buf == NULL && size == 0)
164 char big_buffer[BIG_FILE_NAME_LENGTH + 1];
165 dir = getcwd (big_buffer, sizeof big_buffer);
170 # if HAVE_PARTLY_WORKING_GETCWD
171 /* The system getcwd works, except it sometimes fails when it
172 shouldn't, setting errno to ERANGE, ENAMETOOLONG, or ENOENT. */
173 if (errno != ERANGE && errno != ENAMETOOLONG && errno != ENOENT)
182 __set_errno (EINVAL);
186 allocated = BIG_FILE_NAME_LENGTH + 1;
191 dir = malloc (allocated);
198 dirp = dir + allocated;
201 if (__lstat (".", &st) < 0)
206 if (__lstat ("/", &st) < 0)
211 while (!(thisdev == rootdev && thisino == rootino))
220 bool use_d_ino = true;
222 /* Look at the parent directory. */
223 #if HAVE_OPENAT_SUPPORT
224 fd = openat (fd, "..", O_RDONLY);
227 fd_needs_closing = true;
228 parent_status = fstat (fd, &st);
230 dotlist[dotlen++] = '.';
231 dotlist[dotlen++] = '.';
232 dotlist[dotlen] = '\0';
233 parent_status = __lstat (dotlist, &st);
235 if (parent_status != 0)
238 if (dirstream && __closedir (dirstream) != 0)
244 /* Figure out if this directory is a mount point. */
247 mount_point = dotdev != thisdev;
249 /* Search for the last directory. */
250 #if HAVE_OPENAT_SUPPORT
251 dirstream = fdopendir (fd);
252 if (dirstream == NULL)
254 fd_needs_closing = false;
256 dirstream = __opendir (dotlist);
257 if (dirstream == NULL)
259 dotlist[dotlen++] = '/';
263 /* Clear errno to distinguish EOF from error if readdir returns
266 d = __readdir (dirstream);
268 /* When we've iterated through all directory entries without finding
269 one with a matching d_ino, rewind the stream and consider each
270 name again, but this time, using lstat. This is necessary in a
271 chroot on at least one system (glibc-2.3.6 + linux 2.6.12), where
272 .., ../.., ../../.., etc. all had the same device number, yet the
273 d_ino values for entries in / did not match those obtained
275 if (d == NULL && errno == 0 && use_d_ino)
278 rewinddir (dirstream);
279 d = __readdir (dirstream);
285 /* EOF on dirstream, which can mean e.g., that the current
286 directory has been removed. */
287 __set_errno (ENOENT);
290 if (d->d_name[0] == '.' &&
291 (d->d_name[1] == '\0' ||
292 (d->d_name[1] == '.' && d->d_name[2] == '\0')))
297 bool match = (MATCHING_INO (d, thisino) || mount_point);
304 #if HAVE_OPENAT_SUPPORT
305 entry_status = fstatat (fd, d->d_name, &st, AT_SYMLINK_NOFOLLOW);
307 /* Compute size needed for this file name, or for the file
308 name ".." in the same directory, whichever is larger.
309 Room for ".." might be needed the next time through
311 size_t name_alloc = _D_ALLOC_NAMLEN (d);
312 size_t filesize = dotlen + MAX (sizeof "..", name_alloc);
314 if (filesize < dotlen)
315 goto memory_exhausted;
317 if (dotsize < filesize)
319 /* My, what a deep directory tree you have, Grandma. */
320 size_t newsize = MAX (filesize, dotsize * 2);
322 if (newsize < dotsize)
323 goto memory_exhausted;
326 dotlist = malloc (newsize);
341 memcpy (dotlist + dotlen, d->d_name, _D_ALLOC_NAMLEN (d));
342 entry_status = __lstat (dotlist, &st);
344 /* We don't fail here if we cannot stat() a directory entry.
345 This can happen when (network) file systems fail. If this
346 entry is in fact the one we are looking for we will find
347 out soon as we reach the end of the directory without
348 having found anything. */
349 if (entry_status == 0 && S_ISDIR (st.st_mode)
350 && st.st_dev == thisdev && st.st_ino == thisino)
355 dirroom = dirp - dir;
356 namlen = _D_EXACT_NAMLEN (d);
358 if (dirroom <= namlen)
362 __set_errno (ERANGE);
368 size_t oldsize = allocated;
370 allocated += MAX (allocated, namlen);
371 if (allocated < oldsize
372 || ! (tmp = realloc (dir, allocated)))
373 goto memory_exhausted;
375 /* Move current contents up to the end of the buffer.
376 This is guaranteed to be non-overlapping. */
377 dirp = memcpy (tmp + allocated - (oldsize - dirroom),
384 memcpy (dirp, d->d_name, namlen);
391 if (dirstream && __closedir (dirstream) != 0)
397 if (dirp == &dir[allocated - 1])
400 #if ! HAVE_OPENAT_SUPPORT
405 used = dir + allocated - dirp;
406 memmove (dir, dirp, used);
409 /* Ensure that the buffer is only as large as necessary. */
410 buf = realloc (dir, used);
413 /* Either buf was NULL all along, or 'realloc' failed but
414 we still have the original string. */
420 __set_errno (ENOMEM);
425 __closedir (dirstream);
426 #if HAVE_OPENAT_SUPPORT
427 if (fd_needs_closing)
441 weak_alias (__getcwd, getcwd)