stdlib/canonicalize.c

   1 /* Return the canonical absolute name of a given file.
   2 Copyright (C) 1996 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 Library General Public License as
   7 published by the Free Software Foundation; either version 2 of the
   8 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 Library General Public License for more details.
  14
  15 You should have received a copy of the GNU Library General Public
  16 License along with the GNU C Library; see the file COPYING.LIB.  If
  17 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  18 Cambridge, MA 02139, USA.  */
  19
  20 #include <assert.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24 #include <limits.h>
  25 #include <sys/param.h>
  26 #include <sys/stat.h>
  27 #include <errno.h>
  28
  29 /* Return the canonical absolute name of file NAME.  A canonical name
  30    does not contain any `.', `..' components nor any repeated path
  31    separators ('/') or symlinks.  All path components must exist.  If
  32    RESOLVED is null, the result is malloc'd; otherwise, if the
  33    canonical name is PATH_MAX chars or more, returns null with `errno'
  34    set to ENAMETOOLONG; if the name fits in fewer than PATH_MAX chars,
  35    returns the name in RESOLVED.  If the name cannot be resolved and
  36    RESOLVED is non-NULL, it contains the path of the first component
  37    that cannot be resolved.  If the path can be resolved, RESOLVED
  38    holds the same value as the value returned.  */
  39
  40 static char *
  41 canonicalize (const char *name, char *resolved)
  42 {
  43   char *rpath, *dest, *extra_buf = NULL;
  44   const char *start, *end, *rpath_limit;
  45   long int path_max;
  46   int num_links = 0;
  47
  48 #ifdef PATH_MAX
  49   path_max = PATH_MAX;
  50 #else
  51   path_max = pathconf (name, _PC_PATH_MAX);
  52   if (path_max <= 0)
  53     path_max = 1024;
  54 #endif
  55
  56   rpath = resolved;
  57   rpath_limit = rpath + path_max;
  58   if (!resolved)
  59     rpath = malloc (path_max);
  60
  61   strcpy (rpath, "/");
  62   if (name[0] != '/' && !getcwd (rpath, path_max))
  63     goto error;
  64   dest = rpath + strlen (rpath);
  65
  66   for (start = end = name; *start; start = end)
  67     {
  68       struct stat st;
  69       int n;
  70
  71       /* skip sequence of multiple path-separators: */
  72       while (*start == '/') ++start;
  73
  74       /* find end of path component: */
  75       for (end = start; *end && *end != '/'; ++end);
  76
  77       if (end - start == 0)
  78         break;
  79       else if (strncmp (start, ".", end - start) == 0)
  80         /* nothing */;
  81       else if (strncmp (start, "..", end - start) == 0) {
  82         /* back up to previous component, ignore if at root already: */
  83         if (dest > rpath + 1)
  84           while ((--dest)[-1] != '/');
  85       } else
  86         {
  87           size_t new_size;
  88
  89           if (dest[-1] != '/')
  90             *dest++ = '/';
  91
  92           if (dest + (end - start) >= rpath_limit)
  93             {
  94               if (resolved)
  95                 {
  96                   errno = ENAMETOOLONG;
  97                   goto error;
  98                 }
  99               new_size = rpath_limit - rpath;
 100               if (end - start + 1 > path_max)
 101                 new_size += end - start + 1;
 102               else
 103                 new_size += path_max;
 104               rpath = realloc (rpath, new_size);
 105               rpath_limit = rpath + new_size;
 106               if (!rpath)
 107                 return NULL;
 108             }
 109
 110           memcpy (dest, start, end - start);
 111           dest += end - start;
 112           *dest = '\0';
 113
 114           if (__lstat (rpath, &st) < 0)
 115             goto error;
 116
 117           if (S_ISLNK (st.st_mode))
 118             {
 119               char * buf = __alloca(path_max);
 120
 121               if (++num_links > MAXSYMLINKS)
 122                 {
 123                   errno = ELOOP;
 124                   goto error;
 125                 }
 126
 127               n = readlink (rpath, buf, path_max);
 128               if (n < 0)
 129                 goto error;
 130               buf[n] = '\0';
 131
 132               if (!extra_buf)
 133                 extra_buf = __alloca (path_max);
 134
 135               if (n + strlen (end) >= path_max)
 136                 {
 137                   errno = ENAMETOOLONG;
 138                   goto error;
 139                 }
 140
 141               /* careful here, end may be a pointer into extra_buf... */
 142               strcat (buf, end);
 143               strcpy (extra_buf, buf);
 144               name = end = extra_buf;
 145
 146               if (buf[0] == '/')
 147                 dest = rpath + 1;       /* it's an absolute symlink */
 148               else
 149                 /* back up to previous component, ignore if at root already: */
 150                 if (dest > rpath + 1)
 151                   while ((--dest)[-1] != '/');
 152             }
 153           else
 154             num_links = 0;
 155         }
 156     }
 157   if (dest > rpath + 1 && dest[-1] == '/')
 158     --dest;
 159   *dest = '\0';
 160   return rpath;
 161
 162 error:
 163   if (!resolved)
 164     free (rpath);
 165   return NULL;
 166 }
 167
 168 weak_alias (canonicalize, realpath)
 169
 170 char *
 171 canonicalize_file_name (const char *name)
 172 {
 173   return canonicalize (name, NULL);
 174 }