X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;f=lib%2Fcanonicalize.c;h=18acd061324992ed50f109d4f82f01ba748ec56b;hb=710aad94fa0056e27daee30d23130fd9c9339b71;hp=523e08204cf0320695b6740e34b95551262163ce;hpb=9de26050ef8a950fd62ebadeeab2eb7505631028;p=gnulib.git diff --git a/lib/canonicalize.c b/lib/canonicalize.c index 523e08204..18acd0613 100644 --- a/lib/canonicalize.c +++ b/lib/canonicalize.c @@ -1,5 +1,5 @@ /* Return the canonical absolute name of a given file. - Copyright (C) 1996-2009 Free Software Foundation, Inc. + Copyright (C) 1996-2010 Free Software Foundation, Inc. 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 @@ -18,34 +18,25 @@ #include "canonicalize.h" +#include #include #include - -#if HAVE_SYS_PARAM_H -# include -#endif - #include - #include -#include -#include - +#include "areadlink.h" #include "file-set.h" -#include "filenamecat.h" #include "hash-triple.h" +#include "pathmax.h" #include "xalloc.h" #include "xgetcwd.h" -#ifndef __set_errno -# define __set_errno(Val) errno = (Val) +#ifndef DOUBLE_SLASH_IS_DISTINCT_ROOT +# define DOUBLE_SLASH_IS_DISTINCT_ROOT 0 #endif -#include "pathmax.h" -#include "areadlink.h" - -#if !(HAVE_CANONICALIZE_FILE_NAME || GNULIB_CANONICALIZE_LGPL) +#if !((HAVE_CANONICALIZE_FILE_NAME && FUNC_REALPATH_WORKS) \ + || GNULIB_CANONICALIZE_LGPL) /* Return the canonical absolute name of file NAME. A canonical name does not contain any `.', `..' components nor any repeated file name separators ('/') or symlinks. All components must exist. @@ -54,68 +45,7 @@ char * canonicalize_file_name (const char *name) { -# if HAVE_RESOLVEPATH - - char *resolved, *extra_buf = NULL; - size_t resolved_size; - ssize_t resolved_len; - - if (name == NULL) - { - __set_errno (EINVAL); - return NULL; - } - - if (name[0] == '\0') - { - __set_errno (ENOENT); - return NULL; - } - - /* All known hosts with resolvepath (e.g. Solaris 7) don't turn - relative names into absolute ones, so prepend the working - directory if the file name is not absolute. */ - if (name[0] != '/') - { - char *wd; - - if (!(wd = xgetcwd ())) - return NULL; - - extra_buf = file_name_concat (wd, name, NULL); - name = extra_buf; - free (wd); - } - - resolved_size = strlen (name); - while (1) - { - resolved_size = 2 * resolved_size + 1; - resolved = xmalloc (resolved_size); - resolved_len = resolvepath (name, resolved, resolved_size); - if (resolved_len < 0) - { - free (resolved); - free (extra_buf); - return NULL; - } - if (resolved_len < resolved_size) - break; - free (resolved); - } - - free (extra_buf); - - /* NUL-terminate the resulting name. */ - resolved[resolved_len] = '\0'; - - return resolved; - -# else - return canonicalize_filename_mode (name, CAN_EXISTING); - -# endif /* !HAVE_RESOLVEPATH */ } #endif /* !HAVE_CANONICALIZE_FILE_NAME */ @@ -128,12 +58,12 @@ seen_triple (Hash_table **ht, char const *filename, struct stat const *st) { size_t initial_capacity = 7; *ht = hash_initialize (initial_capacity, - NULL, - triple_hash, - triple_compare_ino_str, - triple_free); + NULL, + triple_hash, + triple_compare_ino_str, + triple_free); if (*ht == NULL) - xalloc_die (); + xalloc_die (); } if (seen_file (*ht, filename, st)) @@ -143,7 +73,8 @@ seen_triple (Hash_table **ht, char const *filename, struct stat const *st) return false; } -/* Return the canonical absolute name of file NAME. A canonical name +/* Return the canonical absolute name of file NAME, while treating + missing elements according to CAN_MODE. A canonical name does not contain any `.', `..' components nor any repeated file name separators ('/') or symlinks. Whether components must exist or not depends on canonicalize mode. The result is malloc'd. */ @@ -157,16 +88,17 @@ canonicalize_filename_mode (const char *name, canonicalize_mode_t can_mode) char const *rname_limit; size_t extra_len = 0; Hash_table *ht = NULL; + int saved_errno; if (name == NULL) { - __set_errno (EINVAL); + errno = EINVAL; return NULL; } if (name[0] == '\0') { - __set_errno (ENOENT); + errno = ENOENT; return NULL; } @@ -174,19 +106,19 @@ canonicalize_filename_mode (const char *name, canonicalize_mode_t can_mode) { rname = xgetcwd (); if (!rname) - return NULL; + return NULL; dest = strchr (rname, '\0'); if (dest - rname < PATH_MAX) - { - char *p = xrealloc (rname, PATH_MAX); - dest = p + (dest - rname); - rname = p; - rname_limit = rname + PATH_MAX; - } + { + char *p = xrealloc (rname, PATH_MAX); + dest = p + (dest - rname); + rname = p; + rname_limit = rname + PATH_MAX; + } else - { - rname_limit = dest; - } + { + rname_limit = dest; + } } else { @@ -194,131 +126,154 @@ canonicalize_filename_mode (const char *name, canonicalize_mode_t can_mode) rname_limit = rname + PATH_MAX; rname[0] = '/'; dest = rname + 1; + if (DOUBLE_SLASH_IS_DISTINCT_ROOT && name[1] == '/') + *dest++ = '/'; } for (start = name; *start; start = end) { /* Skip sequence of multiple file name separators. */ while (*start == '/') - ++start; + ++start; /* Find end of component. */ for (end = start; *end && *end != '/'; ++end) - /* Nothing. */; + /* Nothing. */; if (end - start == 0) - break; + break; else if (end - start == 1 && start[0] == '.') - /* nothing */; + /* nothing */; else if (end - start == 2 && start[0] == '.' && start[1] == '.') - { - /* Back up to previous component, ignore if at root already. */ - if (dest > rname + 1) - while ((--dest)[-1] != '/'); - } + { + /* Back up to previous component, ignore if at root already. */ + if (dest > rname + 1) + while ((--dest)[-1] != '/'); + if (DOUBLE_SLASH_IS_DISTINCT_ROOT && dest == rname + 1 + && *dest == '/') + dest++; + } else - { - struct stat st; - - if (dest[-1] != '/') - *dest++ = '/'; - - if (dest + (end - start) >= rname_limit) - { - ptrdiff_t dest_offset = dest - rname; - size_t new_size = rname_limit - rname; - - if (end - start + 1 > PATH_MAX) - new_size += end - start + 1; - else - new_size += PATH_MAX; - rname = xrealloc (rname, new_size); - rname_limit = rname + new_size; - - dest = rname + dest_offset; - } - - dest = memcpy (dest, start, end - start); - dest += end - start; - *dest = '\0'; - - if (lstat (rname, &st) != 0) - { - if (can_mode == CAN_EXISTING) - goto error; - if (can_mode == CAN_ALL_BUT_LAST && *end) - goto error; - st.st_mode = 0; - } - - if (S_ISLNK (st.st_mode)) - { - char *buf; - size_t n, len; - - /* Detect loops. We cannot use the cycle-check module here, - since it's actually possible to encounter the same symlink - more than once in a given traversal. However, encountering - the same symlink,NAME pair twice does indicate a loop. */ - if (seen_triple (&ht, name, &st)) - { - __set_errno (ELOOP); - if (can_mode == CAN_MISSING) - continue; - else - goto error; - } - - buf = areadlink_with_size (rname, st.st_size); - if (!buf) - { - if (can_mode == CAN_MISSING && errno != ENOMEM) - continue; - else - goto error; - } - - n = strlen (buf); - len = strlen (end); - - if (!extra_len) - { - extra_len = - ((n + len + 1) > PATH_MAX) ? (n + len + 1) : PATH_MAX; - extra_buf = xmalloc (extra_len); - } - else if ((n + len + 1) > extra_len) - { - extra_len = n + len + 1; - extra_buf = xrealloc (extra_buf, extra_len); - } - - /* Careful here, end may be a pointer into extra_buf... */ - memmove (&extra_buf[n], end, len + 1); - name = end = memcpy (extra_buf, buf, n); - - if (buf[0] == '/') - dest = rname + 1; /* It's an absolute symlink */ - else - /* Back up to previous component, ignore if at root already: */ - if (dest > rname + 1) - while ((--dest)[-1] != '/'); - - free (buf); - } - else - { - if (!S_ISDIR (st.st_mode) && *end && (can_mode != CAN_MISSING)) - { - errno = ENOTDIR; - goto error; - } - } - } + { + struct stat st; + + if (dest[-1] != '/') + *dest++ = '/'; + + if (dest + (end - start) >= rname_limit) + { + ptrdiff_t dest_offset = dest - rname; + size_t new_size = rname_limit - rname; + + if (end - start + 1 > PATH_MAX) + new_size += end - start + 1; + else + new_size += PATH_MAX; + rname = xrealloc (rname, new_size); + rname_limit = rname + new_size; + + dest = rname + dest_offset; + } + + dest = memcpy (dest, start, end - start); + dest += end - start; + *dest = '\0'; + + if (lstat (rname, &st) != 0) + { + saved_errno = errno; + if (can_mode == CAN_EXISTING) + goto error; + if (can_mode == CAN_ALL_BUT_LAST) + { + if (end[strspn (end, "/")] || saved_errno != ENOENT) + goto error; + continue; + } + st.st_mode = 0; + } + + if (S_ISLNK (st.st_mode)) + { + char *buf; + size_t n, len; + + /* Detect loops. We cannot use the cycle-check module here, + since it's actually possible to encounter the same symlink + more than once in a given traversal. However, encountering + the same symlink,NAME pair twice does indicate a loop. */ + if (seen_triple (&ht, name, &st)) + { + if (can_mode == CAN_MISSING) + continue; + saved_errno = ELOOP; + goto error; + } + + buf = areadlink_with_size (rname, st.st_size); + if (!buf) + { + if (can_mode == CAN_MISSING && errno != ENOMEM) + continue; + saved_errno = errno; + goto error; + } + + n = strlen (buf); + len = strlen (end); + + if (!extra_len) + { + extra_len = + ((n + len + 1) > PATH_MAX) ? (n + len + 1) : PATH_MAX; + extra_buf = xmalloc (extra_len); + } + else if ((n + len + 1) > extra_len) + { + extra_len = n + len + 1; + extra_buf = xrealloc (extra_buf, extra_len); + } + + /* Careful here, end may be a pointer into extra_buf... */ + memmove (&extra_buf[n], end, len + 1); + name = end = memcpy (extra_buf, buf, n); + + if (buf[0] == '/') + { + dest = rname + 1; /* It's an absolute symlink */ + if (DOUBLE_SLASH_IS_DISTINCT_ROOT && buf[1] == '/') + *dest++ = '/'; + } + else + { + /* Back up to previous component, ignore if at root + already: */ + if (dest > rname + 1) + while ((--dest)[-1] != '/'); + if (DOUBLE_SLASH_IS_DISTINCT_ROOT && dest == rname + 1 + && *dest == '/') + dest++; + } + + free (buf); + } + else + { + if (!S_ISDIR (st.st_mode) && *end && (can_mode != CAN_MISSING)) + { + saved_errno = ENOTDIR; + goto error; + } + } + } } if (dest > rname + 1 && dest[-1] == '/') --dest; + if (DOUBLE_SLASH_IS_DISTINCT_ROOT && dest == rname + 1 && *dest == '/') + dest++; *dest = '\0'; + if (rname_limit != dest + 1) + rname = xrealloc (rname, dest - rname + 1); free (extra_buf); if (ht) @@ -330,5 +285,6 @@ error: free (rname); if (ht) hash_free (ht); + errno = saved_errno; return NULL; }