canonicalize.c

/* canonicalize.c: Return the canonical absolute name of a given file.
 * Copyright (C) 1996-2012 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
 * the Free Software Foundation; either version 3 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, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>

#include "canonicalize.h"

#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

#include "areadlink.h"
#include "file-set.h"
#include "hash-triple.h"
#include "pathmax.h"
#include "xalloc.h"
#include "xgetcwd.h"

#define MULTIPLE_BITS_SET(i) (((i) & ((i) - 1)) != 0)

/* In this file, we cannot handle file names longer than PATH_MAX.
 * On systems with no file name length limit, use a fallback.  */
#ifndef PATH_MAX
# define PATH_MAX 8192
#endif /* !PATH_MAX */

#ifndef DOUBLE_SLASH_IS_DISTINCT_ROOT
# define DOUBLE_SLASH_IS_DISTINCT_ROOT 0
#endif /* !DOUBLE_SLASH_IS_DISTINCT_ROOT */

#if !(((defined(HAVE_CANONICALIZE_FILE_NAME) && 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.
 * The result is malloc'd.
 */
char *
canonicalize_file_name(const char *name)
{
  return canonicalize_filename_mode(name, CAN_EXISTING);
}
#endif /* !HAVE_CANONICALIZE_FILE_NAME */

/* Return true if we have already seen the triple, <FILENAME, dev, ino>.
 * If *HT is not initialized, initialize it.  */
static bool
seen_triple(Hash_table **ht, char const *filename, struct stat const *st)
{
  if (*ht == NULL) {
      size_t initial_capacity = 7;
      *ht = hash_initialize(initial_capacity, NULL, triple_hash,
                            triple_compare_ino_str, triple_free);
      if (*ht == NULL) {
		  xalloc_die();
	  }
  }

  if (seen_file(*ht, filename, st)) {
	  return true;
  }

  record_file(*ht, filename, st);
  return false;
}

/* 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, depending on other CAN_MODE flags, symlinks.
 * Whether components must exist or not depends on canonicalize mode.
 * The result is malloc'd.
 */
char *canonicalize_filename_mode(const char *name, canonicalize_mode_t can_mode)
{
  char *rname, *dest, *extra_buf = NULL;
  char const *start;
  char const *end;
  char const *rname_limit;
  size_t extra_len = 0;
  Hash_table *ht = NULL;
  int saved_errno;
  bool logical;
  int can_flags = (int)(can_mode & (canonicalize_mode_t)~CAN_MODE_MASK);
  can_mode &= (canonicalize_mode_t)CAN_MODE_MASK;
  logical = (can_flags & CAN_NOLINKS);
  /* Perhaps in future we might support CAN_NOALLOC with CAN_NOLINKS.  */

  if (MULTIPLE_BITS_SET(can_mode)) {
      errno = EINVAL;
      return NULL;
  }

  if (name == NULL) {
      errno = EINVAL;
      return NULL;
  }

  if (name[0] == '\0') {
      errno = ENOENT;
      return NULL;
  }

  if (name[0] != '/') {
      rname = xgetcwd();
      if (!rname) {
		  return NULL;
	  }
      dest = strchr(rname, '\0');
      if ((dest - rname) < PATH_MAX) {
          char *p;
		  p = (char *)xrealloc(rname, (size_t)PATH_MAX);
          dest = (p + (dest - rname));
          rname = p;
          rname_limit = (rname + PATH_MAX);
	  } else {
          rname_limit = dest;
	  }
  } else {
      rname = (char *)xmalloc((size_t)PATH_MAX);
      rname_limit = (rname + PATH_MAX);
      rname[0] = '/';
      dest = (rname + 1);
      if (DOUBLE_SLASH_IS_DISTINCT_ROOT) {
          if ((name[1] == '/') && (name[2] != '/')) {
			  *dest++ = '/';
		  }
          *dest = '\0';
	  }
  }

  for ((start = name); *start; (start = end)) {
      /* Skip sequence of multiple file name separators.  */
      while (*start == '/') {
		  ++start;
	  }

      /* Find end of 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 > (rname + 1)) {
			  while ((--dest)[-1] != '/') {
				  /* nothing (?) */;
			  }
		  }
          if (DOUBLE_SLASH_IS_DISTINCT_ROOT && (dest == (rname + 1))
              && (*dest == '/') && (dest[1] != '/')) {
			  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;
			  new_size = (size_t)(rname_limit - rname);

              if ((end - start + 1) > PATH_MAX) {
				  new_size += (size_t)(end - start + 1);
              } else {
				  new_size += PATH_MAX;
			  }
              rname = (char *)xrealloc(rname, new_size);
              rname_limit = (rname + new_size);

              dest = (rname + dest_offset);
		  }

          dest = (char *)memcpy(dest, start, (size_t)(end - start));
          dest += (end - start);
          *dest = '\0';

          if (logical && (can_mode == CAN_MISSING)) {
              /* Avoid the stat in this case as it is inconsequential.
               * i.e. we are neither resolving symlinks or testing
               * component existence.  */
              st.st_mode = 0;
		  } else if ((logical ? stat(rname, &st) : 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 is 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, (size_t)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 = (char *)xmalloc(extra_len);
			  } else if ((n + len + 1) > extra_len) {
                  extra_len = (n + len + 1);
                  extra_buf = (char *)xrealloc(extra_buf, extra_len);
			  }

              /* Careful here, end may be a pointer into extra_buf... */
              memmove(&extra_buf[n], end, (len + 1));
              name = end = (const char *)memcpy(extra_buf, buf, n);

              if (buf[0] == '/') {
                  dest = (rname + 1);     /* It is an absolute symlink */
                  if (DOUBLE_SLASH_IS_DISTINCT_ROOT) {
                      if ((buf[1] == '/') && (buf[2] != '/')) {
						  *dest++ = '/';
					  }
                      *dest = '\0';
				  }
			  } else {
                  /* Back up to previous component, ignore if at root
                   * already: */
                  if (dest > (rname + 1)) {
					  while ((--dest)[-1] != '/') {
						  /* nothing (?) */;
					  }
				  }
                  if (DOUBLE_SLASH_IS_DISTINCT_ROOT && (dest == (rname + 1))
                      && (*dest == '/') && (dest[1] != '/')) {
					  dest++;
				  }
			  }

              free(buf);
		  } else {
              if (!S_ISDIR(st.st_mode) && *end && (can_mode != CAN_MISSING)) {
                  saved_errno = ENOTDIR;
                  goto error;
			  }
		  } /* end conditional on symlinks */
	  } /* end use of "if... else..." to compare 'start' and 'end' */
  } /* end for-loop */
  if ((dest > (rname + 1)) && (dest[-1] == '/')) {
	  --dest;
  }
  if (DOUBLE_SLASH_IS_DISTINCT_ROOT && (dest == (rname + 1))
      && (*dest == '/') && (dest[1] != '/')) {
	  dest++;
  }
  *dest = '\0';
  if (rname_limit != (dest + 1)) {
	  rname = (char *)xrealloc(rname, (size_t)(dest - rname + 1));
  }

  free(extra_buf);
  if (ht) {
	  hash_free(ht);
  }
  return rname;

error:
  free(extra_buf);
  free(rname);
  if (ht) {
	  hash_free(ht);
  }
  errno = saved_errno;
  return NULL;
}

/* EOF */