1 /* Libiberty realpath. Like realpath, but more consistent behavior.
2 Based on gdb_realpath from GDB.
3
4 Copyright (C) 2003-2023 Free Software Foundation, Inc.
5
6 This file is part of the libiberty library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor,
21 Boston, MA 02110-1301, USA. */
22
23 /*
24
25 @deftypefn Replacement {const char*} lrealpath (const char *@var{name})
26
27 Given a pointer to a string containing a pathname, returns a canonical
28 version of the filename. Symlinks will be resolved, and ``.'' and ``..''
29 components will be simplified. The returned value will be allocated using
30 @code{malloc}, or @code{NULL} will be returned on a memory allocation error.
31
32 @end deftypefn
33
34 */
35
36 #include "config.h"
37 #include "ansidecl.h"
38 #include "libiberty.h"
39
40 #ifdef HAVE_LIMITS_H
41 #include <limits.h>
42 #endif
43 #ifdef HAVE_STDLIB_H
44 #include <stdlib.h>
45 #endif
46 #ifdef HAVE_UNISTD_H
47 #include <unistd.h>
48 #endif
49 #ifdef HAVE_STRING_H
50 #include <string.h>
51 #endif
52
53 /* On GNU libc systems the declaration is only visible with _GNU_SOURCE. */
54 #if defined(HAVE_CANONICALIZE_FILE_NAME) \
55 && defined(NEED_DECLARATION_CANONICALIZE_FILE_NAME)
56 extern char *canonicalize_file_name (const char *);
57 #endif
58
59 #if defined(HAVE_REALPATH)
60 # if defined (PATH_MAX)
61 # define REALPATH_LIMIT PATH_MAX
62 # else
63 # if defined (MAXPATHLEN)
64 # define REALPATH_LIMIT MAXPATHLEN
65 # endif
66 # endif
67 #else
68 /* cygwin has realpath, so it won't get here. */
69 # if defined (_WIN32)
70 # define WIN32_LEAN_AND_MEAN
71 # include <windows.h> /* for GetFullPathName/GetFinalPathNameByHandle/
72 CreateFile/CloseHandle */
73 # define WIN32_REPLACE_SLASHES(_ptr, _len) \
74 for (unsigned i = 0; i != (_len); ++i) \
75 if ((_ptr)[i] == '\\') (_ptr)[i] = '/';
76
77 # define WIN32_UNC_PREFIX "//?/UNC/"
78 # define WIN32_UNC_PREFIX_LEN (sizeof(WIN32_UNC_PREFIX)-1)
79 # define WIN32_IS_UNC_PREFIX(ptr) \
80 (0 == memcmp(ptr, WIN32_UNC_PREFIX, WIN32_UNC_PREFIX_LEN))
81
82 # define WIN32_NON_UNC_PREFIX "//?/"
83 # define WIN32_NON_UNC_PREFIX_LEN (sizeof(WIN32_NON_UNC_PREFIX)-1)
84 # define WIN32_IS_NON_UNC_PREFIX(ptr) \
85 (0 == memcmp(ptr, WIN32_NON_UNC_PREFIX, WIN32_NON_UNC_PREFIX_LEN))
86
87 /* Get full path name without symlinks resolution.
88 It also converts all forward slashes to back slashes.
89 */
90 char* get_full_path_name(const char *filename) {
91 DWORD len;
92 char *buf, *ptr, *res;
93
94 /* determining the required buffer size.
95 from the man: `If the lpBuffer buffer is too small to contain
96 the path, the return value is the size, in TCHARs, of the buffer
97 that is required to hold the path _and_the_terminating_null_character_`
98 */
99 len = GetFullPathName(filename, 0, NULL, NULL);
100
101 if ( len == 0 )
102 return strdup(filename);
103
104 buf = (char *)malloc(len);
105
106 /* no point to check the result again */
107 len = GetFullPathName(filename, len, buf, NULL);
108 buf[len] = 0;
109
110 /* replace slashes */
111 WIN32_REPLACE_SLASHES(buf, len);
112
113 /* calculate offset based on prefix type */
114 len = WIN32_IS_UNC_PREFIX(buf)
115 ? (WIN32_UNC_PREFIX_LEN - 2)
116 : WIN32_IS_NON_UNC_PREFIX(buf)
117 ? WIN32_NON_UNC_PREFIX_LEN
118 : 0
119 ;
120
121 ptr = buf + len;
122 if ( WIN32_IS_UNC_PREFIX(buf) ) {
123 ptr[0] = '/';
124 ptr[1] = '/';
125 }
126
127 res = strdup(ptr);
128
129 free(buf);
130
131 return res;
132 }
133
134 # if _WIN32_WINNT >= 0x0600
135
136 /* Get full path name WITH symlinks resolution.
137 It also converts all forward slashes to back slashes.
138 */
139 char* get_final_path_name(HANDLE fh) {
140 DWORD len;
141 char *buf, *ptr, *res;
142
143 /* determining the required buffer size.
144 from the man: `If the function fails because lpszFilePath is too
145 small to hold the string plus the terminating null character,
146 the return value is the required buffer size, in TCHARs. This
147 value _includes_the_size_of_the_terminating_null_character_`.
148 but in my testcase I have path with 26 chars, the function
149 returns 26 also, ie without the trailing zero-char...
150 */
151 len = GetFinalPathNameByHandle(
152 fh
153 ,NULL
154 ,0
155 ,FILE_NAME_NORMALIZED | VOLUME_NAME_DOS
156 );
157
158 if ( len == 0 )
159 return NULL;
160
161 len += 1; /* for zero-char */
162 buf = (char *)malloc(len);
163
164 /* no point to check the result again */
165 len = GetFinalPathNameByHandle(
166 fh
167 ,buf
168 ,len
169 ,FILE_NAME_NORMALIZED | VOLUME_NAME_DOS
170 );
171 buf[len] = 0;
172
173 /* replace slashes */
174 WIN32_REPLACE_SLASHES(buf, len);
175
176 /* calculate offset based on prefix type */
177 len = WIN32_IS_UNC_PREFIX(buf)
178 ? (WIN32_UNC_PREFIX_LEN - 2)
179 : WIN32_IS_NON_UNC_PREFIX(buf)
180 ? WIN32_NON_UNC_PREFIX_LEN
181 : 0
182 ;
183
184 ptr = buf + len;
185 if ( WIN32_IS_UNC_PREFIX(buf) ) {
186 ptr[0] = '/';
187 ptr[1] = '/';
188 }
189
190 res = strdup(ptr);
191
192 free(buf);
193
194 return res;
195 }
196
197 # endif // _WIN32_WINNT >= 0x0600
198
199 # endif // _WIN32
200 #endif
201
202 char *
203 lrealpath (const char *filename)
204 {
205 /* Method 1: The system has a compile time upper bound on a filename
206 path. Use that and realpath() to canonicalize the name. This is
207 the most common case. Note that, if there isn't a compile time
208 upper bound, you want to avoid realpath() at all costs. */
209 #if defined(REALPATH_LIMIT)
210 {
211 char buf[REALPATH_LIMIT];
212 const char *rp = realpath (filename, buf);
213 if (rp == NULL)
214 rp = filename;
215 return strdup (rp);
216 }
217 #endif /* REALPATH_LIMIT */
218
219 /* Method 2: The host system (i.e., GNU) has the function
220 canonicalize_file_name() which malloc's a chunk of memory and
221 returns that, use that. */
222 #if defined(HAVE_CANONICALIZE_FILE_NAME)
223 {
224 char *rp = canonicalize_file_name (filename);
225 if (rp == NULL)
226 return strdup (filename);
227 else
228 return rp;
229 }
230 #endif
231
232 /* Method 3: Now we're getting desperate! The system doesn't have a
233 compile time buffer size and no alternative function. Query the
234 OS, using pathconf(), for the buffer limit. Care is needed
235 though, some systems do not limit PATH_MAX (return -1 for
236 pathconf()) making it impossible to pass a correctly sized buffer
237 to realpath() (it could always overflow). On those systems, we
238 skip this. */
239 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H)
240 {
241 /* Find out the max path size. */
242 long path_max = pathconf ("/", _PC_PATH_MAX);
243 if (path_max > 0)
244 {
245 /* PATH_MAX is bounded. */
246 char *buf, *rp, *ret;
247 buf = (char *) malloc (path_max);
248 if (buf == NULL)
249 return NULL;
250 rp = realpath (filename, buf);
251 ret = strdup (rp ? rp : filename);
252 free (buf);
253 return ret;
254 }
255 }
256 #endif
257
258 /* The MS Windows method */
259 #if defined (_WIN32)
260 {
261 char *res;
262
263 /* For Windows Vista and greater */
264 #if _WIN32_WINNT >= 0x0600
265
266 /* For some reason the function receives just empty `filename`, but not NULL.
267 What should we do in that case?
268 According to `strdup()` implementation
269 (https://elixir.bootlin.com/glibc/latest/source/string/strdup.c)
270 it will alloc 1 byte even for empty but non NULL string.
271 OK, will use `strdup()` for that case.
272 */
273 if ( 0 == strlen(filename) )
274 return strdup(filename);
275
276 HANDLE fh = CreateFile(
277 filename
278 ,FILE_READ_ATTRIBUTES
279 ,FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE
280 ,NULL
281 ,OPEN_EXISTING
282 ,FILE_FLAG_BACKUP_SEMANTICS
283 ,NULL
284 );
285
286 if ( fh == INVALID_HANDLE_VALUE ) {
287 res = get_full_path_name(filename);
288 } else {
289 res = get_final_path_name(fh);
290 CloseHandle(fh);
291
292 if ( !res )
293 res = get_full_path_name(filename);
294 }
295
296 #else
297
298 /* For Windows XP */
299 res = get_full_path_name(filename);
300
301 #endif // _WIN32_WINNT >= 0x0600
302
303 return res;
304 }
305 #endif // _WIN32
306 }