1 /* Copyright (C) 1991-2021 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public
6 License as published by the Free Software Foundation; either
7 version 3 of the License, or (at your option) any later version.
8
9 The GNU C Library 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 GNU
12 General Public License for more details.
13
14 You should have received a copy of the GNU General Public
15 License along with the GNU C Library; if not, see
16 <https://www.gnu.org/licenses/>. */
17
18 #if !_LIBC
19 # include <config.h>
20 # include <unistd.h>
21 # include "pathmax.h"
22 #else
23 # define HAVE_OPENAT 1
24 # define D_INO_IN_DIRENT 1
25 # define HAVE_MSVC_INVALID_PARAMETER_HANDLER 0
26 # define HAVE_MINIMALLY_WORKING_GETCWD 0
27 #endif
28
29 #include <errno.h>
30 #include <sys/types.h>
31 #include <sys/stat.h>
32 #include <stdbool.h>
33 #include <stddef.h>
34
35 #include <fcntl.h> /* For AT_FDCWD on Solaris 9. */
36
37 /* If this host provides the openat function or if we're using the
38 gnulib replacement function with a native fdopendir, then enable
39 code below to make getcwd more efficient and robust. */
40 #if defined HAVE_OPENAT || (defined GNULIB_OPENAT && defined HAVE_FDOPENDIR)
41 # define HAVE_OPENAT_SUPPORT 1
42 #else
43 # define HAVE_OPENAT_SUPPORT 0
44 #endif
45
46 #ifndef __set_errno
47 # define __set_errno(val) (errno = (val))
48 #endif
49
50 #include <dirent.h>
51 #ifndef _D_EXACT_NAMLEN
52 # define _D_EXACT_NAMLEN(d) strlen ((d)->d_name)
53 #endif
54 #ifndef _D_ALLOC_NAMLEN
55 # define _D_ALLOC_NAMLEN(d) (_D_EXACT_NAMLEN (d) + 1)
56 #endif
57
58 #include <unistd.h>
59 #include <stdlib.h>
60 #include <string.h>
61
62 #if _LIBC
63 # ifndef mempcpy
64 # define mempcpy __mempcpy
65 # endif
66 #endif
67
68 #ifndef MAX
69 # define MAX(a, b) ((a) < (b) ? (b) : (a))
70 #endif
71 #ifndef MIN
72 # define MIN(a, b) ((a) < (b) ? (a) : (b))
73 #endif
74
75 /* In this file, PATH_MAX only serves as a threshold for choosing among two
76 algorithms. */
77 #ifndef PATH_MAX
78 # define PATH_MAX 8192
79 #endif
80
81 #if D_INO_IN_DIRENT
82 # define MATCHING_INO(dp, ino) ((dp)->d_ino == (ino))
83 #else
84 # define MATCHING_INO(dp, ino) true
85 #endif
86
87 #if HAVE_MSVC_INVALID_PARAMETER_HANDLER
88 # include "msvc-inval.h"
89 #endif
90
91 #if !_LIBC
92 # define GETCWD_RETURN_TYPE char *
93 # define __close_nocancel_nostatus close
94 # define __getcwd_generic rpl_getcwd
95 # undef stat64
96 # define stat64 stat
97 # define __fstat64 fstat
98 # define __fstatat64 fstatat
99 # define __lstat64 lstat
100 # define __closedir closedir
101 # define __opendir opendir
102 # define __readdir64 readdir
103 # define __fdopendir fdopendir
104 # define __openat openat
105 # define __rewinddir rewinddir
106 # define __openat64 openat
107 # define dirent64 dirent
108 #else
109 # include <not-cancel.h>
110 #endif
111
112 /* The results of opendir() in this file are not used with dirfd and fchdir,
113 and we do not leak fds to any single-threaded code that could use stdio,
114 therefore save some unnecessary recursion in fchdir.c.
115 FIXME - if the kernel ever adds support for multi-thread safety for
116 avoiding standard fds, then we should use opendir_safer and
117 openat_safer. */
118 #ifdef GNULIB_defined_opendir
119 # undef opendir
120 #endif
121 #ifdef GNULIB_defined_closedir
122 # undef closedir
123 #endif
124
125 #if defined _WIN32 && !defined __CYGWIN__
126 # if HAVE_MSVC_INVALID_PARAMETER_HANDLER
127 static char *
128 getcwd_nothrow (char *buf, size_t size)
129 {
130 char *result;
131
132 TRY_MSVC_INVAL
133 {
134 result = _getcwd (buf, size);
135 }
136 CATCH_MSVC_INVAL
137 {
138 result = NULL;
139 errno = ERANGE;
140 }
141 DONE_MSVC_INVAL;
142
143 return result;
144 }
145 # else
146 # define getcwd_nothrow _getcwd
147 # endif
148 # define getcwd_system getcwd_nothrow
149 #else
150 # define getcwd_system getcwd
151 #endif
152
153 /* Get the name of the current working directory, and put it in SIZE
154 bytes of BUF. Returns NULL with errno set if the directory couldn't be
155 determined or SIZE was too small. If successful, returns BUF. In GNU,
156 if BUF is NULL, an array is allocated with 'malloc'; the array is SIZE
157 bytes long, unless SIZE == 0, in which case it is as big as necessary. */
158
159 GETCWD_RETURN_TYPE
160 __getcwd_generic (char *buf, size_t size)
161 {
162 /* Lengths of big file name components and entire file names, and a
163 deep level of file name nesting. These numbers are not upper
164 bounds; they are merely large values suitable for initial
165 allocations, designed to be large enough for most real-world
166 uses. */
167 enum
168 {
169 BIG_FILE_NAME_COMPONENT_LENGTH = 255,
170 BIG_FILE_NAME_LENGTH = MIN (4095, PATH_MAX - 1),
171 DEEP_NESTING = 100
172 };
173
174 #if HAVE_OPENAT_SUPPORT
175 int fd = AT_FDCWD;
176 bool fd_needs_closing = false;
177 #else
178 char dots[DEEP_NESTING * sizeof ".." + BIG_FILE_NAME_COMPONENT_LENGTH + 1];
179 char *dotlist = dots;
180 size_t dotsize = sizeof dots;
181 size_t dotlen = 0;
182 #endif
183 DIR *dirstream = NULL;
184 dev_t rootdev, thisdev;
185 ino_t rootino, thisino;
186 char *dir;
187 register char *dirp;
188 struct stat64 st;
189 size_t allocated = size;
190 size_t used;
191
192 #if HAVE_MINIMALLY_WORKING_GETCWD
193 /* If AT_FDCWD is not defined, the algorithm below is O(N**2) and
194 this is much slower than the system getcwd (at least on
195 GNU/Linux). So trust the system getcwd's results unless they
196 look suspicious.
197
198 Use the system getcwd even if we have openat support, since the
199 system getcwd works even when a parent is unreadable, while the
200 openat-based approach does not.
201
202 But on AIX 5.1..7.1, the system getcwd is not even minimally
203 working: If the current directory name is slightly longer than
204 PATH_MAX, it omits the first directory component and returns
205 this wrong result with errno = 0. */
206
207 # undef getcwd
208 dir = getcwd_system (buf, size);
209 if (dir || (size && errno == ERANGE))
210 return dir;
211
212 /* Solaris getcwd (NULL, 0) fails with errno == EINVAL, but it has
213 internal magic that lets it work even if an ancestor directory is
214 inaccessible, which is better in many cases. So in this case try
215 again with a buffer that's almost always big enough. */
216 if (errno == EINVAL && buf == NULL && size == 0)
217 {
218 char big_buffer[BIG_FILE_NAME_LENGTH + 1];
219 dir = getcwd_system (big_buffer, sizeof big_buffer);
220 if (dir)
221 return strdup (dir);
222 }
223
224 # if HAVE_PARTLY_WORKING_GETCWD
225 /* The system getcwd works, except it sometimes fails when it
226 shouldn't, setting errno to ERANGE, ENAMETOOLONG, or ENOENT. */
227 if (errno != ERANGE && errno != ENAMETOOLONG && errno != ENOENT)
228 return NULL;
229 # endif
230 #endif
231 if (size == 0)
232 {
233 if (buf != NULL)
234 {
235 __set_errno (EINVAL);
236 return NULL;
237 }
238
239 allocated = BIG_FILE_NAME_LENGTH + 1;
240 }
241
242 if (buf == NULL)
243 {
244 dir = malloc (allocated);
245 if (dir == NULL)
246 return NULL;
247 }
248 else
249 dir = buf;
250
251 dirp = dir + allocated;
252 *--dirp = '\0';
253
254 if (__lstat64 (".", &st) < 0)
255 goto lose;
256 thisdev = st.st_dev;
257 thisino = st.st_ino;
258
259 if (__lstat64 ("/", &st) < 0)
260 goto lose;
261 rootdev = st.st_dev;
262 rootino = st.st_ino;
263
264 while (!(thisdev == rootdev && thisino == rootino))
265 {
266 struct dirent64 *d;
267 dev_t dotdev;
268 ino_t dotino;
269 bool mount_point;
270 int parent_status;
271 size_t dirroom;
272 size_t namlen;
273 bool use_d_ino = true;
274
275 /* Look at the parent directory. */
276 #if HAVE_OPENAT_SUPPORT
277 fd = __openat64 (fd, "..", O_RDONLY);
278 if (fd < 0)
279 goto lose;
280 fd_needs_closing = true;
281 parent_status = __fstat64 (fd, &st);
282 #else
283 dotlist[dotlen++] = '.';
284 dotlist[dotlen++] = '.';
285 dotlist[dotlen] = '\0';
286 parent_status = __lstat64 (dotlist, &st);
287 #endif
288 if (parent_status != 0)
289 goto lose;
290
291 if (dirstream && __closedir (dirstream) != 0)
292 {
293 dirstream = NULL;
294 goto lose;
295 }
296
297 /* Figure out if this directory is a mount point. */
298 dotdev = st.st_dev;
299 dotino = st.st_ino;
300 mount_point = dotdev != thisdev;
301
302 /* Search for the last directory. */
303 #if HAVE_OPENAT_SUPPORT
304 dirstream = __fdopendir (fd);
305 if (dirstream == NULL)
306 goto lose;
307 fd_needs_closing = false;
308 #else
309 dirstream = __opendir (dotlist);
310 if (dirstream == NULL)
311 goto lose;
312 dotlist[dotlen++] = '/';
313 #endif
314 for (;;)
315 {
316 /* Clear errno to distinguish EOF from error if readdir returns
317 NULL. */
318 __set_errno (0);
319 d = __readdir64 (dirstream);
320
321 /* When we've iterated through all directory entries without finding
322 one with a matching d_ino, rewind the stream and consider each
323 name again, but this time, using lstat. This is necessary in a
324 chroot on at least one system (glibc-2.3.6 + linux 2.6.12), where
325 .., ../.., ../../.., etc. all had the same device number, yet the
326 d_ino values for entries in / did not match those obtained
327 via lstat. */
328 if (d == NULL && errno == 0 && use_d_ino)
329 {
330 use_d_ino = false;
331 __rewinddir (dirstream);
332 d = __readdir64 (dirstream);
333 }
334
335 if (d == NULL)
336 {
337 if (errno == 0)
338 /* EOF on dirstream, which can mean e.g., that the current
339 directory has been removed. */
340 __set_errno (ENOENT);
341 goto lose;
342 }
343 if (d->d_name[0] == '.' &&
344 (d->d_name[1] == '\0' ||
345 (d->d_name[1] == '.' && d->d_name[2] == '\0')))
346 continue;
347
348 if (use_d_ino)
349 {
350 bool match = (MATCHING_INO (d, thisino) || mount_point);
351 if (! match)
352 continue;
353 }
354
355 {
356 int entry_status;
357 #if HAVE_OPENAT_SUPPORT
358 entry_status = __fstatat64 (fd, d->d_name, &st, AT_SYMLINK_NOFOLLOW);
359 #else
360 /* Compute size needed for this file name, or for the file
361 name ".." in the same directory, whichever is larger.
362 Room for ".." might be needed the next time through
363 the outer loop. */
364 size_t name_alloc = _D_ALLOC_NAMLEN (d);
365 size_t filesize = dotlen + MAX (sizeof "..", name_alloc);
366
367 if (filesize < dotlen)
368 goto memory_exhausted;
369
370 if (dotsize < filesize)
371 {
372 /* My, what a deep directory tree you have, Grandma. */
373 size_t newsize = MAX (filesize, dotsize * 2);
374 size_t i;
375 if (newsize < dotsize)
376 goto memory_exhausted;
377 if (dotlist != dots)
378 free (dotlist);
379 dotlist = malloc (newsize);
380 if (dotlist == NULL)
381 goto lose;
382 dotsize = newsize;
383
384 i = 0;
385 do
386 {
387 dotlist[i++] = '.';
388 dotlist[i++] = '.';
389 dotlist[i++] = '/';
390 }
391 while (i < dotlen);
392 }
393
394 memcpy (dotlist + dotlen, d->d_name, _D_ALLOC_NAMLEN (d));
395 entry_status = __lstat64 (dotlist, &st);
396 #endif
397 /* We don't fail here if we cannot stat() a directory entry.
398 This can happen when (network) file systems fail. If this
399 entry is in fact the one we are looking for we will find
400 out soon as we reach the end of the directory without
401 having found anything. */
402 if (entry_status == 0 && S_ISDIR (st.st_mode)
403 && st.st_dev == thisdev && st.st_ino == thisino)
404 break;
405 }
406 }
407
408 dirroom = dirp - dir;
409 namlen = _D_EXACT_NAMLEN (d);
410
411 if (dirroom <= namlen)
412 {
413 if (size != 0)
414 {
415 __set_errno (ERANGE);
416 goto lose;
417 }
418 else
419 {
420 char *tmp;
421 size_t oldsize = allocated;
422
423 allocated += MAX (allocated, namlen);
424 if (allocated < oldsize
425 || ! (tmp = realloc (dir, allocated)))
426 goto memory_exhausted;
427
428 /* Move current contents up to the end of the buffer.
429 This is guaranteed to be non-overlapping. */
430 dirp = memcpy (tmp + allocated - (oldsize - dirroom),
431 tmp + dirroom,
432 oldsize - dirroom);
433 dir = tmp;
434 }
435 }
436 dirp -= namlen;
437 memcpy (dirp, d->d_name, namlen);
438 *--dirp = '/';
439
440 thisdev = dotdev;
441 thisino = dotino;
442 }
443
444 if (dirstream && __closedir (dirstream) != 0)
445 {
446 dirstream = NULL;
447 goto lose;
448 }
449
450 if (dirp == &dir[allocated - 1])
451 *--dirp = '/';
452
453 #if ! HAVE_OPENAT_SUPPORT
454 if (dotlist != dots)
455 free (dotlist);
456 #endif
457
458 used = dir + allocated - dirp;
459 memmove (dir, dirp, used);
460
461 if (size == 0)
462 /* Ensure that the buffer is only as large as necessary. */
463 buf = (used < allocated ? realloc (dir, used) : dir);
464
465 if (buf == NULL)
466 /* Either buf was NULL all along, or 'realloc' failed but
467 we still have the original string. */
468 buf = dir;
469
470 return buf;
471
472 memory_exhausted:
473 __set_errno (ENOMEM);
474 lose:
475 {
476 int save = errno;
477 if (dirstream)
478 __closedir (dirstream);
479 #if HAVE_OPENAT_SUPPORT
480 if (fd_needs_closing)
481 __close_nocancel_nostatus (fd);
482 #else
483 if (dotlist != dots)
484 free (dotlist);
485 #endif
486 if (buf == NULL)
487 free (dir);
488 __set_errno (save);
489 }
490 return NULL;
491 }
492
493 #if defined _LIBC && !defined GETCWD_RETURN_TYPE
494 libc_hidden_def (__getcwd)
495 weak_alias (__getcwd, getcwd)
496 #endif