aboutsummaryrefslogtreecommitdiff
path: root/libiberty/lrealpath.c
blob: 2578288e8acef49d0f4ac624fdc81dfbff7befce (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
/* Libiberty realpath.  Like realpath, but more consistent behavior.
   Based on gdb_realpath from GDB.

   Copyright (C) 2003-2023 Free Software Foundation, Inc.

   This file is part of the libiberty library.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor,
   Boston, MA 02110-1301, USA.  */

/*

@deftypefn Replacement {const char*} lrealpath (const char *@var{name})

Given a pointer to a string containing a pathname, returns a canonical
version of the filename.  Symlinks will be resolved, and ``.'' and ``..''
components will be simplified.  The returned value will be allocated using
@code{malloc}, or @code{NULL} will be returned on a memory allocation error.

@end deftypefn

*/

#include "config.h"
#include "ansidecl.h"
#include "libiberty.h"

#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif

/* On GNU libc systems the declaration is only visible with _GNU_SOURCE.  */
#if defined(HAVE_CANONICALIZE_FILE_NAME) \
    && defined(NEED_DECLARATION_CANONICALIZE_FILE_NAME)
extern char *canonicalize_file_name (const char *);
#endif

#if defined(HAVE_REALPATH)
# if defined (PATH_MAX)
#  define REALPATH_LIMIT PATH_MAX
# else
#  if defined (MAXPATHLEN)
#   define REALPATH_LIMIT MAXPATHLEN
#  endif
# endif
#else
  /* cygwin has realpath, so it won't get here.  */ 
# if defined (_WIN32)
#  define WIN32_LEAN_AND_MEAN
#  include <windows.h> /* for GetFullPathName/GetFinalPathNameByHandle/
                          CreateFile/CloseHandle */
#  define WIN32_REPLACE_SLASHES(_ptr, _len) \
     for (unsigned i = 0; i != (_len); ++i) \
       if ((_ptr)[i] == '\\') (_ptr)[i] = '/';

#  define WIN32_UNC_PREFIX "//?/UNC/"
#  define WIN32_UNC_PREFIX_LEN (sizeof(WIN32_UNC_PREFIX)-1)
#  define WIN32_IS_UNC_PREFIX(ptr) \
  (0 == memcmp(ptr, WIN32_UNC_PREFIX, WIN32_UNC_PREFIX_LEN))

#  define WIN32_NON_UNC_PREFIX "//?/"
#  define WIN32_NON_UNC_PREFIX_LEN (sizeof(WIN32_NON_UNC_PREFIX)-1)
#  define WIN32_IS_NON_UNC_PREFIX(ptr) \
  (0 == memcmp(ptr, WIN32_NON_UNC_PREFIX, WIN32_NON_UNC_PREFIX_LEN))

/* Get full path name without symlinks resolution.
   It also converts all forward slashes to back slashes.
*/
char* get_full_path_name(const char *filename) {
  DWORD len;
  char *buf, *ptr, *res;

  /* determining the required buffer size.
     from the man: `If the lpBuffer buffer is too small to contain
     the path, the return value is the size, in TCHARs, of the buffer
     that is required to hold the path _and_the_terminating_null_character_`
  */
  len = GetFullPathName(filename, 0, NULL, NULL);

  if ( len == 0 )
    return strdup(filename);

  buf = (char *)malloc(len);

  /* no point to check the result again */
  len = GetFullPathName(filename, len, buf, NULL);
  buf[len] = 0;

  /* replace slashes */
  WIN32_REPLACE_SLASHES(buf, len);

  /* calculate offset based on prefix type */
  len = WIN32_IS_UNC_PREFIX(buf)
    ? (WIN32_UNC_PREFIX_LEN - 2)
    : WIN32_IS_NON_UNC_PREFIX(buf)
      ? WIN32_NON_UNC_PREFIX_LEN
      : 0
  ;

  ptr = buf + len;
  if ( WIN32_IS_UNC_PREFIX(buf) ) {
    ptr[0] = '/';
    ptr[1] = '/';
  }

  res = strdup(ptr);

  free(buf);

  return res;
}

# if _WIN32_WINNT >= 0x0600

/* Get full path name WITH symlinks resolution.
   It also converts all forward slashes to back slashes.
*/
char* get_final_path_name(HANDLE fh) {
  DWORD len;
  char *buf, *ptr, *res;

  /* determining the required buffer size.
     from the  man: `If the function fails because lpszFilePath is too
     small to hold the string plus the terminating null character,
     the return value is the required buffer size, in TCHARs. This
     value _includes_the_size_of_the_terminating_null_character_`.
     but in my testcase I have path with 26 chars, the function
     returns 26 also, ie without the trailing zero-char...
  */
  len = GetFinalPathNameByHandle(
     fh
    ,NULL
    ,0
    ,FILE_NAME_NORMALIZED | VOLUME_NAME_DOS
  );

  if ( len == 0 )
    return NULL;

  len += 1; /* for zero-char */
  buf = (char *)malloc(len);

  /* no point to check the result again */
  len = GetFinalPathNameByHandle(
     fh
    ,buf
    ,len
    ,FILE_NAME_NORMALIZED | VOLUME_NAME_DOS
  );
  buf[len] = 0;

  /* replace slashes */
  WIN32_REPLACE_SLASHES(buf, len);

  /* calculate offset based on prefix type */
  len = WIN32_IS_UNC_PREFIX(buf)
    ? (WIN32_UNC_PREFIX_LEN - 2)
    : WIN32_IS_NON_UNC_PREFIX(buf)
      ? WIN32_NON_UNC_PREFIX_LEN
      : 0
  ;

  ptr = buf + len;
  if ( WIN32_IS_UNC_PREFIX(buf) ) {
    ptr[0] = '/';
    ptr[1] = '/';
  }

  res = strdup(ptr);

  free(buf);

  return res;
}

# endif // _WIN32_WINNT >= 0x0600

# endif // _WIN32
#endif

char *
lrealpath (const char *filename)
{
  /* Method 1: The system has a compile time upper bound on a filename
     path.  Use that and realpath() to canonicalize the name.  This is
     the most common case.  Note that, if there isn't a compile time
     upper bound, you want to avoid realpath() at all costs.  */
#if defined(REALPATH_LIMIT)
  {
    char buf[REALPATH_LIMIT];
    const char *rp = realpath (filename, buf);
    if (rp == NULL)
      rp = filename;
    return strdup (rp);
  }
#endif /* REALPATH_LIMIT */

  /* Method 2: The host system (i.e., GNU) has the function
     canonicalize_file_name() which malloc's a chunk of memory and
     returns that, use that.  */
#if defined(HAVE_CANONICALIZE_FILE_NAME)
  {
    char *rp = canonicalize_file_name (filename);
    if (rp == NULL)
      return strdup (filename);
    else
      return rp;
  }
#endif

  /* Method 3: Now we're getting desperate!  The system doesn't have a
     compile time buffer size and no alternative function.  Query the
     OS, using pathconf(), for the buffer limit.  Care is needed
     though, some systems do not limit PATH_MAX (return -1 for
     pathconf()) making it impossible to pass a correctly sized buffer
     to realpath() (it could always overflow).  On those systems, we
     skip this.  */
#if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H)
  {
    /* Find out the max path size.  */
    long path_max = pathconf ("/", _PC_PATH_MAX);
    if (path_max > 0)
      {
	/* PATH_MAX is bounded.  */
	char *buf, *rp, *ret;
	buf = (char *) malloc (path_max);
	if (buf == NULL)
	  return NULL;
	rp = realpath (filename, buf);
	ret = strdup (rp ? rp : filename);
	free (buf);
	return ret;
      }
  }
#endif

  /* The MS Windows method */
#if defined (_WIN32)
  {
    char *res;

    /* For Windows Vista and greater */
#if _WIN32_WINNT >= 0x0600

    /* For some reason the function receives just empty `filename`, but not NULL.
       What should we do in that case?
       According to `strdup()` implementation
         (https://elixir.bootlin.com/glibc/latest/source/string/strdup.c)
       it will alloc 1 byte even for empty but non NULL string.
       OK, will use `strdup()` for that case.
    */
    if ( 0 == strlen(filename) )
      return strdup(filename);

    HANDLE fh = CreateFile(
       filename
      ,FILE_READ_ATTRIBUTES
      ,FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE
      ,NULL
      ,OPEN_EXISTING
      ,FILE_FLAG_BACKUP_SEMANTICS
      ,NULL
    );

    if ( fh == INVALID_HANDLE_VALUE ) {
      res = get_full_path_name(filename);
    } else {
      res = get_final_path_name(fh);
      CloseHandle(fh);

      if ( !res )
        res = get_full_path_name(filename);
    }

#else

    /* For Windows XP */
    res = get_full_path_name(filename);

#endif // _WIN32_WINNT >= 0x0600

    return res;
  }
#endif // _WIN32
}