/* libfakechroot -- fake chroot environment Copyright (c) 2010, 2013 Piotr Roszatycki This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #ifdef HAVE___LXSTAT64 # define _LARGEFILE64_SOURCE #endif #include #include #ifdef HAVE_ALLOCA_H # include #endif #include #include #include #include "libfakechroot.h" #include "readlink.h" #ifdef HAVE___LXSTAT64 # define _LARGEFILE64_SOURCE # include "__lxstat64.h" # define STAT_T stat64 # define LSTAT_REL(rpath, st) __lxstat64_rel(_STAT_VER, rpath, st) #else # include "lstat.h" # define STAT_T stat # define LSTAT_REL(rpath, st) lstat_rel(rpath, st) #endif /* realpath function taken from Gnulib. Copyright (C) 1996-2010 Free Software Foundation, Inc. */ #ifndef MAXSYMLINKS # ifdef SYMLOOP_MAX # define MAXSYMLINKS SYMLOOP_MAX # else # define MAXSYMLINKS 20 # endif #endif #ifndef DOUBLE_SLASH_IS_DISTINCT_ROOT # define DOUBLE_SLASH_IS_DISTINCT_ROOT 0 #endif wrapper(realpath, char *, (const char * name, char * resolved)) { char *rpath, *dest, *extra_buf = NULL; const char *start, *end, *rpath_limit; long int path_max; int num_links = 0; debug("realpath(\"%s\", &resolved)", name); if (name == NULL) { /* As per Single Unix Specification V2 we must return an error if either parameter is a null pointer. We extend this to allow the RESOLVED parameter to be NULL in case the we are expected to allocate the room for the return value. */ __set_errno(EINVAL); return NULL; } if (name[0] == '\0') { /* As per Single Unix Specification V2 we must return an error if the name argument points to an empty string. */ __set_errno(ENOENT); return NULL; } path_max = FAKECHROOT_PATH_MAX; if (resolved == NULL) { rpath = malloc(path_max); if (rpath == NULL) { /* It's easier to set errno to ENOMEM than to rely on the 'malloc-posix' gnulib module. */ __set_errno(ENOMEM); return NULL; } } else rpath = resolved; rpath_limit = rpath + path_max; if (name[0] != '/') { if (!getcwd(rpath, path_max)) { rpath[0] = '\0'; goto error; } dest = strchr(rpath, '\0'); } else { rpath[0] = '/'; dest = rpath + 1; if (DOUBLE_SLASH_IS_DISTINCT_ROOT && name[1] == '/') *dest++ = '/'; } for (start = end = name; *start; start = end) { struct STAT_T st; int n; /* Skip sequence of multiple path-separators. */ while (*start == '/') ++start; /* Find end of path component. */ for (end = start; *end && *end != '/'; ++end) /* Nothing. */; if (end - start == 0) break; else if (end - start == 1 && start[0] == '.') { /* nothing */ } else if (end - start == 2 && start[0] == '.' && start[1] == '.') { /* Back up to previous component, ignore if at root already. */ if (dest > rpath + 1) while ((--dest)[-1] != '/'); if (DOUBLE_SLASH_IS_DISTINCT_ROOT && dest == rpath + 1 && *dest == '/') dest++; } else { size_t new_size; if (dest[-1] != '/') *dest++ = '/'; if (dest + (end - start) >= rpath_limit) { ptrdiff_t dest_offset = dest - rpath; char *new_rpath; if (resolved) { __set_errno(ENAMETOOLONG); if (dest > rpath + 1) dest--; *dest = '\0'; goto error; } new_size = rpath_limit - rpath; if (end - start + 1 > path_max) new_size += end - start + 1; else new_size += path_max; new_rpath = (char *) realloc(rpath, new_size); if (new_rpath == NULL) { /* It's easier to set errno to ENOMEM than to rely on the 'realloc-posix' gnulib module. */ __set_errno(ENOMEM); goto error; } rpath = new_rpath; rpath_limit = rpath + new_size; dest = rpath + dest_offset; } memcpy(dest, start, end - start); dest += end - start; *dest = '\0'; if (LSTAT_REL (rpath, &st) < 0) goto error; if (S_ISLNK (st.st_mode)) { char *buf; size_t len; if (++num_links > MAXSYMLINKS) { __set_errno(ELOOP); goto error; } buf = alloca(path_max); if (!buf) { __set_errno(ENOMEM); goto error; } n = readlink(rpath, buf, path_max - 1); if (n < 0) { int saved_errno = errno; __set_errno(saved_errno); goto error; } buf[n] = '\0'; if (!extra_buf) { extra_buf = alloca(path_max); if (!extra_buf) { __set_errno(ENOMEM); goto error; } } len = strlen(end); if ((long int) (n + len) >= path_max) { __set_errno(ENAMETOOLONG); goto error; } /* 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 = rpath + 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 > rpath + 1) while ((--dest)[-1] != '/'); if (DOUBLE_SLASH_IS_DISTINCT_ROOT && dest == rpath + 1 && *dest == '/') dest++; } } else if (!S_ISDIR (st.st_mode) && *end != '\0') { __set_errno(ENOTDIR); goto error; } } } if (dest > rpath + 1 && dest[-1] == '/') --dest; if (DOUBLE_SLASH_IS_DISTINCT_ROOT && dest == rpath + 1 && *dest == '/') dest++; *dest = '\0'; return rpath; error: { int saved_errno = errno; if (resolved == NULL) free(rpath); __set_errno(saved_errno); } return NULL; }