/* Libiberty realpath.  Like realpath, but more consistent behavior.
  Based on gdb_realpath from GDB.

  Copyright (C) 2003-2024 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
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.