1 /* Copyright (C) 1991,92,93,94,95,96,97,98,99,2004,2005 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 2, or (at your option)
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 along
16 with this program; if not, write to the Free Software Foundation,
17 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
28 #include <sys/types.h>
33 #include <fcntl.h> /* For AT_FDCWD on Solaris 9. */
36 # define __set_errno(val) (errno = (val))
39 #if HAVE_DIRENT_H || _LIBC
41 # ifndef _D_EXACT_NAMLEN
42 # define _D_EXACT_NAMLEN(d) strlen ((d)->d_name)
45 # define dirent direct
47 # include <sys/ndir.h>
56 #ifndef _D_EXACT_NAMLEN
57 # define _D_EXACT_NAMLEN(d) ((d)->d_namlen)
59 #ifndef _D_ALLOC_NAMLEN
60 # define _D_ALLOC_NAMLEN(d) (_D_EXACT_NAMLEN (d) + 1)
63 #if HAVE_UNISTD_H || _LIBC
72 # define mempcpy __mempcpy
81 # define is_ENAMETOOLONG(x) ((x) == ENAMETOOLONG)
83 # define is_ENAMETOOLONG(x) 0
87 # define MAX(a, b) ((a) < (b) ? (b) : (a))
90 # define MIN(a, b) ((a) < (b) ? (a) : (b))
95 # define PATH_MAX MAXPATHLEN
97 # define PATH_MAX 1024
102 # define MATCHING_INO(dp, ino) ((dp)->d_ino == (ino))
104 # define MATCHING_INO(dp, ino) true
108 # define __getcwd getcwd
109 # define __lstat lstat
110 # define __closedir closedir
111 # define __opendir opendir
112 # define __readdir readdir
115 /* Get the name of the current working directory, and put it in SIZE
116 bytes of BUF. Returns NULL if the directory couldn't be determined or
117 SIZE was too small. If successful, returns BUF. In GNU, if BUF is
118 NULL, an array is allocated with `malloc'; the array is SIZE bytes long,
119 unless SIZE == 0, in which case it is as big as necessary. */
122 __getcwd (char *buf, size_t size)
124 /* Lengths of big file name components and entire file names, and a
125 deep level of file name nesting. These numbers are not upper
126 bounds; they are merely large values suitable for initial
127 allocations, designed to be large enough for most real-world
131 BIG_FILE_NAME_COMPONENT_LENGTH = 255,
132 BIG_FILE_NAME_LENGTH = MIN (4095, PATH_MAX - 1),
138 bool fd_needs_closing = false;
140 char dots[DEEP_NESTING * sizeof ".." + BIG_FILE_NAME_COMPONENT_LENGTH + 1];
141 char *dotlist = dots;
142 size_t dotsize = sizeof dots;
145 DIR *dirstream = NULL;
146 dev_t rootdev, thisdev;
147 ino_t rootino, thisino;
151 size_t allocated = size;
154 #if HAVE_PARTLY_WORKING_GETCWD
155 /* The system getcwd works, except it sometimes fails when it
156 shouldn't, setting errno to ERANGE, ENAMETOOLONG, or ENOENT. If
157 AT_FDCWD is not defined, the algorithm below is O(N**2) and this
158 is much slower than the system getcwd (at least on GNU/Linux).
159 So trust the system getcwd's results unless they look
162 dir = getcwd (buf, size);
163 if (dir || (errno != ERANGE && !is_ENAMETOOLONG (errno) && errno != ENOENT))
171 __set_errno (EINVAL);
175 allocated = BIG_FILE_NAME_LENGTH + 1;
180 dir = malloc (allocated);
187 dirp = dir + allocated;
190 if (__lstat (".", &st) < 0)
195 if (__lstat ("/", &st) < 0)
200 while (!(thisdev == rootdev && thisino == rootino))
209 bool use_d_ino = true;
211 /* Look at the parent directory. */
213 fd = openat (fd, "..", O_RDONLY);
216 fd_needs_closing = true;
217 parent_status = fstat (fd, &st);
219 dotlist[dotlen++] = '.';
220 dotlist[dotlen++] = '.';
221 dotlist[dotlen] = '\0';
222 parent_status = __lstat (dotlist, &st);
224 if (parent_status != 0)
227 if (dirstream && __closedir (dirstream) != 0)
233 /* Figure out if this directory is a mount point. */
236 mount_point = dotdev != thisdev;
238 /* Search for the last directory. */
240 dirstream = fdopendir (fd);
241 if (dirstream == NULL)
243 fd_needs_closing = false;
245 dirstream = __opendir (dotlist);
246 if (dirstream == NULL)
248 dotlist[dotlen++] = '/';
252 /* Clear errno to distinguish EOF from error if readdir returns
255 d = __readdir (dirstream);
257 /* When we've iterated through all directory entries without finding
258 one with a matching d_ino, rewind the stream and consider each
259 name again, but this time, using lstat. This is necessary in a
260 chroot on at least one system (glibc-2.3.6 + linux 2.6.12), where
261 .., ../.., ../../.., etc. all had the same device number, yet the
262 d_ino values for entries in / did not match those obtained
264 if (d == NULL && errno == 0 && use_d_ino)
267 rewinddir (dirstream);
268 d = __readdir (dirstream);
274 /* EOF on dirstream, which can mean e.g., that the current
275 directory has been removed. */
276 __set_errno (ENOENT);
279 if (d->d_name[0] == '.' &&
280 (d->d_name[1] == '\0' ||
281 (d->d_name[1] == '.' && d->d_name[2] == '\0')))
286 bool match = (MATCHING_INO (d, thisino) || mount_point);
294 entry_status = fstatat (fd, d->d_name, &st, AT_SYMLINK_NOFOLLOW);
296 /* Compute size needed for this file name, or for the file
297 name ".." in the same directory, whichever is larger.
298 Room for ".." might be needed the next time through
300 size_t name_alloc = _D_ALLOC_NAMLEN (d);
301 size_t filesize = dotlen + MAX (sizeof "..", name_alloc);
303 if (filesize < dotlen)
304 goto memory_exhausted;
306 if (dotsize < filesize)
308 /* My, what a deep directory tree you have, Grandma. */
309 size_t newsize = MAX (filesize, dotsize * 2);
311 if (newsize < dotsize)
312 goto memory_exhausted;
315 dotlist = malloc (newsize);
330 memcpy (dotlist + dotlen, d->d_name, _D_ALLOC_NAMLEN (d));
331 entry_status = __lstat (dotlist, &st);
333 /* We don't fail here if we cannot stat() a directory entry.
334 This can happen when (network) file systems fail. If this
335 entry is in fact the one we are looking for we will find
336 out soon as we reach the end of the directory without
337 having found anything. */
338 if (entry_status == 0 && S_ISDIR (st.st_mode)
339 && st.st_dev == thisdev && st.st_ino == thisino)
344 dirroom = dirp - dir;
345 namlen = _D_EXACT_NAMLEN (d);
347 if (dirroom <= namlen)
351 __set_errno (ERANGE);
357 size_t oldsize = allocated;
359 allocated += MAX (allocated, namlen);
360 if (allocated < oldsize
361 || ! (tmp = realloc (dir, allocated)))
362 goto memory_exhausted;
364 /* Move current contents up to the end of the buffer.
365 This is guaranteed to be non-overlapping. */
366 dirp = memcpy (tmp + allocated - (oldsize - dirroom),
373 memcpy (dirp, d->d_name, namlen);
380 if (dirstream && __closedir (dirstream) != 0)
386 if (dirp == &dir[allocated - 1])
394 used = dir + allocated - dirp;
395 memmove (dir, dirp, used);
397 if (buf == NULL && size == 0)
398 /* Ensure that the buffer is only as large as necessary. */
399 buf = realloc (dir, used);
402 /* Either buf was NULL all along, or `realloc' failed but
403 we still have the original string. */
409 __set_errno (ENOMEM);
414 __closedir (dirstream);
416 if (fd_needs_closing)
430 weak_alias (__getcwd, getcwd)