[Bug-gnulib] new module "canonicalize" from coreutils

[Paul Eggert]

I installed this:

2004-08-05  Paul Eggert  <address@hidden>

        * lib/canonicalize.h, lib/canonicalize.c, m4/canonicalize.m4,
        modules/canonicalize: New files.

--- /dev/null   2003-03-18 13:55:57 -0800
+++ lib/canonicalize.h  2004-08-05 16:41:30 -0700
@@ -0,0 +1,41 @@
+/* Return the canonical absolute name of a given file.
+   Copyright (C) 1996-2004 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 2, 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; see the file COPYING.
+   If not, write to the Free Software Foundation,
+   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ifndef CANONICALIZE_H_
+# define CANONICALIZE_H_
+
+enum canonicalize_mode_t
+  {
+    /* All path components must exist.  */
+    CAN_EXISTING = 0,
+
+    /* All path components excluding last one must exist.  */
+    CAN_ALL_BUT_LAST = 1,
+
+    /* No requirements on components existence.  */
+    CAN_MISSING = 2
+  };
+typedef enum canonicalize_mode_t canonicalize_mode_t;
+
+char *canonicalize_filename_mode (const char *, canonicalize_mode_t);
+
+# if !HAVE_CANONICALIZE_FILE_NAME
+char *canonicalize_file_name (const char *);
+# endif
+
+#endif /* !CANONICALIZE_H_ */
--- /dev/null   2003-03-18 13:55:57 -0800
+++ lib/canonicalize.c  2004-08-04 23:12:03 -0700
@@ -0,0 +1,332 @@
+/* Return the canonical absolute name of a given file.
+   Copyright (C) 1996-2004 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 2, 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; see the file COPYING.
+   If not, write to the Free Software Foundation,
+   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+#else
+void free ();
+#endif
+
+#if defined STDC_HEADERS || defined HAVE_STRING_H
+# include <string.h>
+#else
+# include <strings.h>
+#endif
+
+#if HAVE_SYS_PARAM_H
+# include <sys/param.h>
+#endif
+
+#include <sys/stat.h>
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#include <errno.h>
+
+#include "cycle-check.h"
+#include "path-concat.h"
+#include "stat-macros.h"
+#include "xalloc.h"
+#include "xgetcwd.h"
+
+#ifndef __set_errno
+# define __set_errno(Val) errno = (Val)
+#endif
+
+/* If __PTRDIFF_TYPE__ is
+   defined, as with GNU C, use that; that way we don't pollute the
+   namespace with <stddef.h>'s symbols.  Otherwise, if <stddef.h> is
+   available, include it and use ptrdiff_t.  In traditional C, long is
+   the best that we can do.  */
+
+#ifdef __PTRDIFF_TYPE__
+# define PTR_INT_TYPE __PTRDIFF_TYPE__
+#else
+# ifdef HAVE_STDDEF_H
+#  include <stddef.h>
+#  define PTR_INT_TYPE ptrdiff_t
+# else
+#  define PTR_INT_TYPE long
+# endif
+#endif
+
+#include "canonicalize.h"
+#include "pathmax.h"
+#include "stat-macros.h"
+#include "xreadlink.h"
+
+#if !HAVE_CANONICALIZE_FILE_NAME
+/* Return the canonical absolute name of file NAME.  A canonical name
+   does not contain any `.', `..' components nor any repeated path
+   separators ('/') or symlinks.  All path components must exist.
+   The result is malloc'd.  */
+
+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 path is not absolute.  */
+  if (name[0] != '/')
+    {
+      char *wd;
+
+      if (!(wd = xgetcwd ()))
+       return NULL;
+
+      extra_buf = path_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 */
+
+/* Return the canonical absolute name of file NAME.  A canonical name
+   does not contain any `.', `..' components nor any repeated path
+   separators ('/') or symlinks.  Whether path 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 *rpath, *dest, *extra_buf = NULL;
+  const char *start, *end, *rpath_limit;
+  size_t extra_len = 0;
+  struct cycle_check_state cycle_state;
+
+  if (name == NULL)
+    {
+      __set_errno (EINVAL);
+      return NULL;
+    }
+
+  if (name[0] == '\0')
+    {
+      __set_errno (ENOENT);
+      return NULL;
+    }
+
+  if (name[0] != '/')
+    {
+      rpath = xgetcwd ();
+      if (!rpath)
+       return NULL;
+      dest = strchr (rpath, '\0');
+      if (dest - rpath < PATH_MAX)
+       {
+         char *p = xrealloc (rpath, PATH_MAX);
+         dest = p + (dest - rpath);
+         rpath = p;
+         rpath_limit = rpath + PATH_MAX;
+       }
+      else
+       {
+         rpath_limit = dest;
+       }
+    }
+  else
+    {
+      rpath = xmalloc (PATH_MAX);
+      rpath_limit = rpath + PATH_MAX;
+      rpath[0] = '/';
+      dest = rpath + 1;
+    }
+
+  cycle_check_init (&cycle_state);
+  for (start = end = name; *start; start = end)
+    {
+      /* 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] != '/');
+       }
+      else
+       {
+         struct stat st;
+
+         if (dest[-1] != '/')
+           *dest++ = '/';
+
+         if (dest + (end - start) >= rpath_limit)
+           {
+             PTR_INT_TYPE dest_offset = dest - rpath;
+             size_t new_size = rpath_limit - rpath;
+
+             if (end - start + 1 > PATH_MAX)
+               new_size += end - start + 1;
+             else
+               new_size += PATH_MAX;
+             rpath = xrealloc (rpath, new_size);
+             rpath_limit = rpath + new_size;
+
+             dest = rpath + dest_offset;
+           }
+
+         dest = memcpy (dest, start, end - start);
+         dest += end - start;
+         *dest = '\0';
+
+         if (lstat (rpath, &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;
+
+             if (cycle_check (&cycle_state, &st))
+               {
+                 __set_errno (ELOOP);
+                 if (can_mode == CAN_MISSING)
+                   continue;
+                 else
+                   goto error;
+               }
+
+             buf = xreadlink (rpath, st.st_size);
+             if (!buf)
+               {
+                 if (can_mode == CAN_MISSING)
+                   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 = rpath + 1;       /* It's an absolute symlink */
+             else
+               /* Back up to previous component, ignore if at root already: */
+               if (dest > rpath + 1)
+                 while ((--dest)[-1] != '/');
+
+             free (buf);
+           }
+         else
+           {
+             if (!S_ISDIR (st.st_mode) && *end && (can_mode != CAN_MISSING))
+               {
+                 errno = ENOTDIR;
+                 goto error;
+               }
+           }
+       }
+    }
+  if (dest > rpath + 1 && dest[-1] == '/')
+    --dest;
+  *dest = '\0';
+
+  free (extra_buf);
+  return rpath;
+
+error:
+  free (extra_buf);
+  free (rpath);
+  return NULL;
+}
--- /dev/null   2003-03-18 13:55:57 -0800
+++ m4/canonicalize.m4  2004-08-05 22:04:36 -0700
@@ -0,0 +1,27 @@
+#serial 3
+
+# Copyright (C) 2003, 2004 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 2, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+# Written by Jim Meyering.
+
+AC_DEFUN([AC_FUNC_CANONICALIZE_FILE_NAME],
+  [
+    AC_REQUIRE([AC_HEADER_STDC])
+    AC_CHECK_HEADERS(string.h sys/param.h stddef.h)
+    AC_CHECK_FUNCS(resolvepath canonicalize_file_name)
+    AC_REQUIRE([AC_HEADER_STAT])
+  ])
--- /dev/null   2003-03-18 13:55:57 -0800
+++ modules/canonicalize        2004-08-05 22:06:17 -0700
@@ -0,0 +1,27 @@
+Description:
+Return the canonical absolute name of a given file.
+
+Files:
+lib/canonicalize.h
+lib/canonicalize.c
+lib/stat-macros.h
+m4/canonicalize.m4
+
+Depends-on:
+cycle-check
+path-concat
+xalloc
+xgetcwd
+
+configure.ac:
+AC_FUNC_CANONICALIZE_FILE_NAME
+
+Makefile.am:
+lib_SOURCES += canonicalize.h canonicalize.c
+
+Include:
+"canonicalize.h"
+
+Maintainer:
+Jim Meyering
+