1 /* Return the canonical absolute name of a given file.
2    Copyright (C) 1996-2011 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4 
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.
9 
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.
14 
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/>.  */
17 
18 #ifndef _LIBC
19 # define _GL_USE_STDLIB_ALLOC 1
20 # include <ac_config.h>
21 #endif
22 
23 #if !HAVE_CANONICALIZE_FILE_NAME || !FUNC_REALPATH_WORKS || defined _LIBC
24 
25 /* Don't use __attribute__ __nonnull__ in this compilation unit.  Otherwise gcc
26    optimizes away the name == NULL test below.  */
27 #define _GL_ARG_NONNULL(params)
28 
29 /* Specification.  */
30 #include <stdlib.h>
31 
32 #include <alloca.h>
33 #include <string.h>
34 #include <unistd.h>
35 #include <limits.h>
36 #if HAVE_SYS_PARAM_H || defined _LIBC
37 # include <sys/param.h>
38 #endif
39 #include <sys/stat.h>
40 #include <errno.h>
41 #include <stddef.h>
42 
43 #ifdef _LIBC
44 # include <shlib-compat.h>
45 #else
46 # define SHLIB_COMPAT(lib, introduced, obsoleted) 0
47 # define versioned_symbol(lib, local, symbol, version) extern int dummy
48 # define compat_symbol(lib, local, symbol, version)
49 # define weak_alias(local, symbol)
50 # define __canonicalize_file_name canonicalize_file_name
51 # define __realpath realpath
52 # include "pathmax.h"
53 # include "malloca.h"
54 # if HAVE_GETCWD
55 #  if IN_RELOCWRAPPER
56     /* When building the relocatable program wrapper, use the system's getcwd
57        function, not the gnulib override, otherwise we would get a link error.
58      */
59 #   undef getcwd
60 #  endif
61 #  ifdef VMS
62     /* We want the directory in Unix syntax, not in VMS syntax.  */
63 #   define __getcwd(buf, max) getcwd (buf, max, 0)
64 #  else
65 #   define __getcwd getcwd
66 #  endif
67 # else
68 #  define __getcwd(buf, max) getwd (buf)
69 # endif
70 # define __readlink readlink
71 # define __set_errno(e) errno = (e)
72 # ifndef MAXSYMLINKS
73 #  ifdef SYMLOOP_MAX
74 #   define MAXSYMLINKS SYMLOOP_MAX
75 #  else
76 #   define MAXSYMLINKS 20
77 #  endif
78 # endif
79 #endif
80 
81 #ifndef DOUBLE_SLASH_IS_DISTINCT_ROOT
82 # define DOUBLE_SLASH_IS_DISTINCT_ROOT 0
83 #endif
84 
85 #if !FUNC_REALPATH_WORKS || defined _LIBC
86 /* Return the canonical absolute name of file NAME.  A canonical name
87    does not contain any `.', `..' components nor any repeated path
88    separators ('/') or symlinks.  All path components must exist.  If
89    RESOLVED is null, the result is malloc'd; otherwise, if the
90    canonical name is PATH_MAX chars or more, returns null with `errno'
91    set to ENAMETOOLONG; if the name fits in fewer than PATH_MAX chars,
92    returns the name in RESOLVED.  If the name cannot be resolved and
93    RESOLVED is non-NULL, it contains the path of the first component
94    that cannot be resolved.  If the path can be resolved, RESOLVED
95    holds the same value as the value returned.  */
96 
97 char *
__realpath(const char * name,char * resolved)98 __realpath (const char *name, char *resolved)
99 {
100   char *rpath, *dest, *extra_buf = NULL;
101   const char *start, *end, *rpath_limit;
102   long int path_max;
103   int num_links = 0;
104 
105   if (name == NULL)
106     {
107       /* As per Single Unix Specification V2 we must return an error if
108          either parameter is a null pointer.  We extend this to allow
109          the RESOLVED parameter to be NULL in case the we are expected to
110          allocate the room for the return value.  */
111       __set_errno (EINVAL);
112       return NULL;
113     }
114 
115   if (name[0] == '\0')
116     {
117       /* As per Single Unix Specification V2 we must return an error if
118          the name argument points to an empty string.  */
119       __set_errno (ENOENT);
120       return NULL;
121     }
122 
123 #ifdef PATH_MAX
124   path_max = PATH_MAX;
125 #else
126   path_max = pathconf (name, _PC_PATH_MAX);
127   if (path_max <= 0)
128     path_max = 1024;
129 #endif
130 
131   if (resolved == NULL)
132     {
133       rpath = malloc (path_max);
134       if (rpath == NULL)
135         {
136           /* It's easier to set errno to ENOMEM than to rely on the
137              'malloc-posix' gnulib module.  */
138           errno = ENOMEM;
139           return NULL;
140         }
141     }
142   else
143     rpath = resolved;
144   rpath_limit = rpath + path_max;
145 
146   if (name[0] != '/')
147     {
148       if (!__getcwd (rpath, path_max))
149         {
150           rpath[0] = '\0';
151           goto error;
152         }
153       dest = strchr (rpath, '\0');
154     }
155   else
156     {
157       rpath[0] = '/';
158       dest = rpath + 1;
159       if (DOUBLE_SLASH_IS_DISTINCT_ROOT && name[1] == '/')
160         *dest++ = '/';
161     }
162 
163   for (start = end = name; *start; start = end)
164     {
165 #ifdef _LIBC
166       struct stat64 st;
167 #else
168       struct stat st;
169 #endif
170       int n;
171 
172       /* Skip sequence of multiple path-separators.  */
173       while (*start == '/')
174         ++start;
175 
176       /* Find end of path component.  */
177       for (end = start; *end && *end != '/'; ++end)
178         /* Nothing.  */;
179 
180       if (end - start == 0)
181         break;
182       else if (end - start == 1 && start[0] == '.')
183         /* nothing */;
184       else if (end - start == 2 && start[0] == '.' && start[1] == '.')
185         {
186           /* Back up to previous component, ignore if at root already.  */
187           if (dest > rpath + 1)
188             while ((--dest)[-1] != '/');
189           if (DOUBLE_SLASH_IS_DISTINCT_ROOT && dest == rpath + 1
190               && *dest == '/')
191             dest++;
192         }
193       else
194         {
195           size_t new_size;
196 
197           if (dest[-1] != '/')
198             *dest++ = '/';
199 
200           if (dest + (end - start) >= rpath_limit)
201             {
202               ptrdiff_t dest_offset = dest - rpath;
203               char *new_rpath;
204 
205               if (resolved)
206                 {
207                   __set_errno (ENAMETOOLONG);
208                   if (dest > rpath + 1)
209                     dest--;
210                   *dest = '\0';
211                   goto error;
212                 }
213               new_size = rpath_limit - rpath;
214               if (end - start + 1 > path_max)
215                 new_size += end - start + 1;
216               else
217                 new_size += path_max;
218               new_rpath = (char *) realloc (rpath, new_size);
219               if (new_rpath == NULL)
220                 {
221                   /* It's easier to set errno to ENOMEM than to rely on the
222                      'realloc-posix' gnulib module.  */
223                   errno = ENOMEM;
224                   goto error;
225                 }
226               rpath = new_rpath;
227               rpath_limit = rpath + new_size;
228 
229               dest = rpath + dest_offset;
230             }
231 
232 #ifdef _LIBC
233           dest = __mempcpy (dest, start, end - start);
234 #else
235           memcpy (dest, start, end - start);
236           dest += end - start;
237 #endif
238           *dest = '\0';
239 
240 #ifdef _LIBC
241           if (__lxstat64 (_STAT_VER, rpath, &st) < 0)
242 #else
243           if (lstat (rpath, &st) < 0)
244 #endif
245             goto error;
246 
247           if (S_ISLNK (st.st_mode))
248             {
249               char *buf;
250               size_t len;
251 
252               if (++num_links > MAXSYMLINKS)
253                 {
254                   __set_errno (ELOOP);
255                   goto error;
256                 }
257 
258               buf = malloca (path_max);
259               if (!buf)
260                 {
261                   errno = ENOMEM;
262                   goto error;
263                 }
264 
265               n = __readlink (rpath, buf, path_max - 1);
266               if (n < 0)
267                 {
268                   int saved_errno = errno;
269                   freea (buf);
270                   errno = saved_errno;
271                   goto error;
272                 }
273               buf[n] = '\0';
274 
275               if (!extra_buf)
276                 {
277                   extra_buf = malloca (path_max);
278                   if (!extra_buf)
279                     {
280                       freea (buf);
281                       errno = ENOMEM;
282                       goto error;
283                     }
284                 }
285 
286               len = strlen (end);
287               if ((long int) (n + len) >= path_max)
288                 {
289                   freea (buf);
290                   __set_errno (ENAMETOOLONG);
291                   goto error;
292                 }
293 
294               /* Careful here, end may be a pointer into extra_buf... */
295               memmove (&extra_buf[n], end, len + 1);
296               name = end = memcpy (extra_buf, buf, n);
297 
298               if (buf[0] == '/')
299                 {
300                   dest = rpath + 1;     /* It's an absolute symlink */
301                   if (DOUBLE_SLASH_IS_DISTINCT_ROOT && buf[1] == '/')
302                     *dest++ = '/';
303                 }
304               else
305                 {
306                   /* Back up to previous component, ignore if at root
307                      already: */
308                   if (dest > rpath + 1)
309                     while ((--dest)[-1] != '/');
310                   if (DOUBLE_SLASH_IS_DISTINCT_ROOT && dest == rpath + 1
311                       && *dest == '/')
312                     dest++;
313                 }
314             }
315           else if (!S_ISDIR (st.st_mode) && *end != '\0')
316             {
317               __set_errno (ENOTDIR);
318               goto error;
319             }
320         }
321     }
322   if (dest > rpath + 1 && dest[-1] == '/')
323     --dest;
324   if (DOUBLE_SLASH_IS_DISTINCT_ROOT && dest == rpath + 1 && *dest == '/')
325     dest++;
326   *dest = '\0';
327 
328   if (extra_buf)
329     freea (extra_buf);
330 
331   return rpath;
332 
333 error:
334   {
335     int saved_errno = errno;
336     if (extra_buf)
337       freea (extra_buf);
338     if (resolved == NULL)
339       free (rpath);
340     errno = saved_errno;
341   }
342   return NULL;
343 }
344 versioned_symbol (libc, __realpath, realpath, GLIBC_2_3);
345 #endif /* !FUNC_REALPATH_WORKS || defined _LIBC */
346 
347 
348 #if SHLIB_COMPAT(libc, GLIBC_2_0, GLIBC_2_3)
349 char *
350 attribute_compat_text_section
__old_realpath(const char * name,char * resolved)351 __old_realpath (const char *name, char *resolved)
352 {
353   if (resolved == NULL)
354     {
355       __set_errno (EINVAL);
356       return NULL;
357     }
358 
359   return __realpath (name, resolved);
360 }
361 compat_symbol (libc, __old_realpath, realpath, GLIBC_2_0);
362 #endif
363 
364 
365 char *
__canonicalize_file_name(const char * name)366 __canonicalize_file_name (const char *name)
367 {
368   return __realpath (name, NULL);
369 }
370 weak_alias (__canonicalize_file_name, canonicalize_file_name)
371 
372 #else
373 
374 /* This declaration is solely to ensure that after preprocessing
375    this file is never empty.  */
376 typedef int dummy;
377 
378 #endif
379