1 /* Return the canonical absolute name of a given file.
2 Copyright (C) 1996-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library 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 GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 #ifndef _LIBC
20 /* Don't use __attribute__ __nonnull__ in this compilation unit. Otherwise gcc
21 optimizes away the name == NULL test below. */
22 # define _GL_ARG_NONNULL(params)
23
24 # define _GL_USE_STDLIB_ALLOC 1
25 # include <libc-config.h>
26 #endif
27
28 /* Specification. */
29 #include <stdlib.h>
30
31 #include <errno.h>
32 #include <fcntl.h>
33 #include <limits.h>
34 #include <stdbool.h>
35 #include <string.h>
36 #include <sys/stat.h>
37 #include <unistd.h>
38
39 #include <eloop-threshold.h>
40 #include <filename.h>
41 #include <idx.h>
42 #include <intprops.h>
43 #include <scratch_buffer.h>
44
45 #ifdef _LIBC
46 # include <shlib-compat.h>
47 # define GCC_LINT 1
48 # define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__))
49 #else
50 # define __canonicalize_file_name canonicalize_file_name
51 # define __realpath realpath
52 # define __strdup strdup
53 # include "pathmax.h"
54 # define __faccessat faccessat
55 # if defined _WIN32 && !defined __CYGWIN__
56 # define __getcwd _getcwd
57 # elif HAVE_GETCWD
58 # if IN_RELOCWRAPPER
59 /* When building the relocatable program wrapper, use the system's getcwd
60 function, not the gnulib override, otherwise we would get a link error.
61 */
62 # undef getcwd
63 # endif
64 # if defined VMS && !defined getcwd
65 /* We want the directory in Unix syntax, not in VMS syntax.
66 The gnulib override of 'getcwd' takes 2 arguments; the original VMS
67 'getcwd' takes 3 arguments. */
68 # define __getcwd(buf, max) getcwd (buf, max, 0)
69 # else
70 # define __getcwd getcwd
71 # endif
72 # else
73 # define __getcwd(buf, max) getwd (buf)
74 # endif
75 # define __mempcpy mempcpy
76 # define __pathconf pathconf
77 # define __readlink readlink
78 # define __stat stat
79 #endif
80
81 /* Suppress bogus GCC -Wmaybe-uninitialized warnings. */
82 #if defined GCC_LINT || defined lint
83 # define IF_LINT(Code) Code
84 #else
85 # define IF_LINT(Code) /* empty */
86 #endif
87
88 #ifndef DOUBLE_SLASH_IS_DISTINCT_ROOT
89 # define DOUBLE_SLASH_IS_DISTINCT_ROOT false
90 #endif
91
92 #if defined _LIBC || !FUNC_REALPATH_WORKS
93
94 /* Return true if FILE's existence can be shown, false (setting errno)
95 otherwise. Follow symbolic links. */
96 static bool
97 file_accessible (char const *file)
98 {
99 # if defined _LIBC || HAVE_FACCESSAT
100 return __faccessat (AT_FDCWD, file, F_OK, AT_EACCESS) == 0;
101 # else
102 struct stat st;
103 return __stat (file, &st) == 0 || errno == EOVERFLOW;
104 # endif
105 }
106
107 /* True if concatenating END as a suffix to a file name means that the
108 code needs to check that the file name is that of a searchable
109 directory, since the canonicalize_filename_mode_stk code won't
110 check this later anyway when it checks an ordinary file name
111 component within END. END must either be empty, or start with a
112 slash. */
113
114 static bool _GL_ATTRIBUTE_PURE
115 suffix_requires_dir_check (char const *end)
116 {
117 /* If END does not start with a slash, the suffix is OK. */
118 while (ISSLASH (*end))
119 {
120 /* Two or more slashes act like a single slash. */
121 do
122 end++;
123 while (ISSLASH (*end));
124
125 switch (*end++)
126 {
127 default: return false; /* An ordinary file name component is OK. */
128 case '\0': return true; /* Trailing "/" is trouble. */
129 case '.': break; /* Possibly "." or "..". */
130 }
131 /* Trailing "/.", or "/.." even if not trailing, is trouble. */
132 if (!*end || (*end == '.' && (!end[1] || ISSLASH (end[1]))))
133 return true;
134 }
135
136 return false;
137 }
138
139 /* Append this to a file name to test whether it is a searchable directory.
140 On POSIX platforms "/" suffices, but "/./" is sometimes needed on
141 macOS 10.13 <https://bugs.gnu.org/30350>, and should also work on
142 platforms like AIX 7.2 that need at least "/.". */
143
144 #if defined _LIBC || defined LSTAT_FOLLOWS_SLASHED_SYMLINK
145 static char const dir_suffix[] = "/";
146 #else
147 static char const dir_suffix[] = "/./";
148 #endif
149
150 /* Return true if DIR is a searchable dir, false (setting errno) otherwise.
151 DIREND points to the NUL byte at the end of the DIR string.
152 Store garbage into DIREND[0 .. strlen (dir_suffix)]. */
153
154 static bool
155 dir_check (char *dir, char *dirend)
156 {
157 strcpy (dirend, dir_suffix);
158 return file_accessible (dir);
159 }
160
161 static idx_t
162 get_path_max (void)
163 {
164 # ifdef PATH_MAX
165 long int path_max = PATH_MAX;
166 # else
167 /* The caller invoked realpath with a null RESOLVED, even though
168 PATH_MAX is not defined as a constant. The glibc manual says
169 programs should not do this, and POSIX says the behavior is undefined.
170 Historically, glibc here used the result of pathconf, or 1024 if that
171 failed; stay consistent with this (dubious) historical practice. */
172 int err = errno;
173 long int path_max = __pathconf ("/", _PC_PATH_MAX);
174 __set_errno (err);
175 # endif
176 return path_max < 0 ? 1024 : path_max <= IDX_MAX ? path_max : IDX_MAX;
177 }
178
179 /* Scratch buffers used by realpath_stk and managed by __realpath. */
180 struct realpath_bufs
181 {
182 struct scratch_buffer rname;
183 struct scratch_buffer extra;
184 struct scratch_buffer link;
185 };
186
187 static char *
188 realpath_stk (const char *name, char *resolved, struct realpath_bufs *bufs)
189 {
190 char *dest;
191 char const *start;
192 char const *end;
193 int num_links = 0;
194
195 if (name == NULL)
196 {
197 /* As per Single Unix Specification V2 we must return an error if
198 either parameter is a null pointer. We extend this to allow
199 the RESOLVED parameter to be NULL in case the we are expected to
200 allocate the room for the return value. */
201 __set_errno (EINVAL);
202 return NULL;
203 }
204
205 if (name[0] == '\0')
206 {
207 /* As per Single Unix Specification V2 we must return an error if
208 the name argument points to an empty string. */
209 __set_errno (ENOENT);
210 return NULL;
211 }
212
213 char *rname = bufs->rname.data;
214 bool end_in_extra_buffer = false;
215 bool failed = true;
216
217 /* This is always zero for Posix hosts, but can be 2 for MS-Windows
218 and MS-DOS X:/foo/bar file names. */
219 idx_t prefix_len = FILE_SYSTEM_PREFIX_LEN (name);
220
221 if (!IS_ABSOLUTE_FILE_NAME (name))
222 {
223 while (!__getcwd (bufs->rname.data, bufs->rname.length))
224 {
225 if (errno != ERANGE)
226 {
227 dest = rname;
228 goto error;
229 }
230 if (!scratch_buffer_grow (&bufs->rname))
231 return NULL;
232 rname = bufs->rname.data;
233 }
234 dest = strchr (rname, '\0');
235 start = name;
236 prefix_len = FILE_SYSTEM_PREFIX_LEN (rname);
237 }
238 else
239 {
240 dest = __mempcpy (rname, name, prefix_len);
241 *dest++ = '/';
242 if (DOUBLE_SLASH_IS_DISTINCT_ROOT)
243 {
244 if (prefix_len == 0 /* implies ISSLASH (name[0]) */
245 && ISSLASH (name[1]) && !ISSLASH (name[2]))
246 *dest++ = '/';
247 *dest = '\0';
248 }
249 start = name + prefix_len;
250 }
251
252 for ( ; *start; start = end)
253 {
254 /* Skip sequence of multiple file name separators. */
255 while (ISSLASH (*start))
256 ++start;
257
258 /* Find end of component. */
259 for (end = start; *end && !ISSLASH (*end); ++end)
260 /* Nothing. */;
261
262 /* Length of this file name component; it can be zero if a file
263 name ends in '/'. */
264 idx_t startlen = end - start;
265
266 if (startlen == 0)
267 break;
268 else if (startlen == 1 && start[0] == '.')
269 /* nothing */;
270 else if (startlen == 2 && start[0] == '.' && start[1] == '.')
271 {
272 /* Back up to previous component, ignore if at root already. */
273 if (dest > rname + prefix_len + 1)
274 for (--dest; dest > rname && !ISSLASH (dest[-1]); --dest)
275 continue;
276 if (DOUBLE_SLASH_IS_DISTINCT_ROOT
277 && dest == rname + 1 && !prefix_len
278 && ISSLASH (*dest) && !ISSLASH (dest[1]))
279 dest++;
280 }
281 else
282 {
283 if (!ISSLASH (dest[-1]))
284 *dest++ = '/';
285
286 while (rname + bufs->rname.length - dest
287 < startlen + sizeof dir_suffix)
288 {
289 idx_t dest_offset = dest - rname;
290 if (!scratch_buffer_grow_preserve (&bufs->rname))
291 return NULL;
292 rname = bufs->rname.data;
293 dest = rname + dest_offset;
294 }
295
296 dest = __mempcpy (dest, start, startlen);
297 *dest = '\0';
298
299 char *buf;
300 ssize_t n;
301 while (true)
302 {
303 buf = bufs->link.data;
304 idx_t bufsize = bufs->link.length;
305 n = __readlink (rname, buf, bufsize - 1);
306 if (n < bufsize - 1)
307 break;
308 if (!scratch_buffer_grow (&bufs->link))
309 return NULL;
310 }
311 if (0 <= n)
312 {
313 if (++num_links > __eloop_threshold ())
314 {
315 __set_errno (ELOOP);
316 goto error;
317 }
318
319 buf[n] = '\0';
320
321 char *extra_buf = bufs->extra.data;
322 idx_t end_idx IF_LINT (= 0);
323 if (end_in_extra_buffer)
324 end_idx = end - extra_buf;
325 size_t len = strlen (end);
326 if (INT_ADD_OVERFLOW (len, n))
327 {
328 __set_errno (ENOMEM);
329 return NULL;
330 }
331 while (bufs->extra.length <= len + n)
332 {
333 if (!scratch_buffer_grow_preserve (&bufs->extra))
334 return NULL;
335 extra_buf = bufs->extra.data;
336 }
337 if (end_in_extra_buffer)
338 end = extra_buf + end_idx;
339
340 /* Careful here, end may be a pointer into extra_buf... */
341 memmove (&extra_buf[n], end, len + 1);
342 name = end = memcpy (extra_buf, buf, n);
343 end_in_extra_buffer = true;
344
345 if (IS_ABSOLUTE_FILE_NAME (buf))
346 {
347 idx_t pfxlen = FILE_SYSTEM_PREFIX_LEN (buf);
348
349 dest = __mempcpy (rname, buf, pfxlen);
350 *dest++ = '/'; /* It's an absolute symlink */
351 if (DOUBLE_SLASH_IS_DISTINCT_ROOT)
352 {
353 if (ISSLASH (buf[1]) && !ISSLASH (buf[2]) && !pfxlen)
354 *dest++ = '/';
355 *dest = '\0';
356 }
357 /* Install the new prefix to be in effect hereafter. */
358 prefix_len = pfxlen;
359 }
360 else
361 {
362 /* Back up to previous component, ignore if at root
363 already: */
364 if (dest > rname + prefix_len + 1)
365 for (--dest; dest > rname && !ISSLASH (dest[-1]); --dest)
366 continue;
367 if (DOUBLE_SLASH_IS_DISTINCT_ROOT && dest == rname + 1
368 && ISSLASH (*dest) && !ISSLASH (dest[1]) && !prefix_len)
369 dest++;
370 }
371 }
372 else if (! (suffix_requires_dir_check (end)
373 ? dir_check (rname, dest)
374 : errno == EINVAL))
375 goto error;
376 }
377 }
378 if (dest > rname + prefix_len + 1 && ISSLASH (dest[-1]))
379 --dest;
380 if (DOUBLE_SLASH_IS_DISTINCT_ROOT && dest == rname + 1 && !prefix_len
381 && ISSLASH (*dest) && !ISSLASH (dest[1]))
382 dest++;
383 failed = false;
384
385 error:
386 *dest++ = '\0';
387 if (resolved != NULL)
388 {
389 /* Copy the full result on success or partial result if failure was due
390 to the path not existing or not being accessible. */
391 if ((!failed || errno == ENOENT || errno == EACCES)
392 && dest - rname <= get_path_max ())
393 {
394 strcpy (resolved, rname);
395 if (failed)
396 return NULL;
397 else
398 return resolved;
399 }
400 if (!failed)
401 __set_errno (ENAMETOOLONG);
402 return NULL;
403 }
404 else
405 {
406 if (failed)
407 return NULL;
408 else
409 return __strdup (bufs->rname.data);
410 }
411 }
412
413 /* Return the canonical absolute name of file NAME. A canonical name
414 does not contain any ".", ".." components nor any repeated file name
415 separators ('/') or symlinks. All file name components must exist. If
416 RESOLVED is null, the result is malloc'd; otherwise, if the
417 canonical name is PATH_MAX chars or more, returns null with 'errno'
418 set to ENAMETOOLONG; if the name fits in fewer than PATH_MAX chars,
419 returns the name in RESOLVED. If the name cannot be resolved and
420 RESOLVED is non-NULL, it contains the name of the first component
421 that cannot be resolved. If the name can be resolved, RESOLVED
422 holds the same value as the value returned. */
423
424 char *
425 __realpath (const char *name, char *resolved)
426 {
427 struct realpath_bufs bufs;
428 scratch_buffer_init (&bufs.rname);
429 scratch_buffer_init (&bufs.extra);
430 scratch_buffer_init (&bufs.link);
431 char *result = realpath_stk (name, resolved, &bufs);
432 scratch_buffer_free (&bufs.link);
433 scratch_buffer_free (&bufs.extra);
434 scratch_buffer_free (&bufs.rname);
435 return result;
436 }
437 libc_hidden_def (__realpath)
438 versioned_symbol (libc, __realpath, realpath, GLIBC_2_3);
439 #endif /* !FUNC_REALPATH_WORKS || defined _LIBC */
440
441
442 #if SHLIB_COMPAT(libc, GLIBC_2_0, GLIBC_2_3)
443 char *
444 attribute_compat_text_section
445 __old_realpath (const char *name, char *resolved)
446 {
447 if (resolved == NULL)
448 {
449 __set_errno (EINVAL);
450 return NULL;
451 }
452
453 return __realpath (name, resolved);
454 }
455 compat_symbol (libc, __old_realpath, realpath, GLIBC_2_0);
456 #endif
457
458
459 char *
460 __canonicalize_file_name (const char *name)
461 {
462 return __realpath (name, NULL);
463 }
464 weak_alias (__canonicalize_file_name, canonicalize_file_name)