(namelist_match): Allow partial matches only if recursive.

(hash_string_hasher): Renamed from hash_avoided_name.
(hash_string_compare): Renamed from compare_avoided_anames.
(hash_string_insert, hash_string_lookup): New functions.
(add_avoided_name, is_avoided_name): Use them.
(safer_name_suffix): New function.
(contains_dot_dot): Moved here from misc.c.  Now returns bool, not int.

diff --git a/src/names.c b/src/names.c
index eb17636965266518352d6e5b94b0eb2b2f63bdb8..99a60bdea612120d04ffd440261765ef8e394751 100644 (file)
--- a/src/names.c
+++ b/src/names.c
@@ -1,7 +1,7 @@
 /* Various processing of names.
 
-   Copyright 1988, 1992, 1994, 1996, 1997, 1998, 1999, 2000, 2001 Free
-   Software Foundation, Inc.
+   Copyright (C) 1988, 1992, 1994, 1996, 1997, 1998, 1999, 2000, 2001,
+   2003 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
@@ -531,7 +531,8 @@ namelist_match (char const *path, size_t length)
       if (p->regexp
          ? fnmatch (p->name, path, recursion_option) == 0
          : (p->length <= length
-            && (path[p->length] == '\0' || ISSLASH (path[p->length]))
+            && (path[p->length] == '\0'
+                || (ISSLASH (path[p->length]) && recursion_option))
             && memcmp (path, p->name, p->length) == 0))
        return p;
     }
@@ -572,7 +573,7 @@ name_match (const char *path)
              nametail = &namelist;
            }
          chdir_do (cursor->change_dir);
-  
+
          /* We got a match.  */
          return 1;
        }
@@ -896,46 +897,167 @@ new_name (const char *path, const char *name)
   return buffer;
 }
 
-/* Return nonzero if file NAME is excluded.  Exclude a name if its
-   prefix matches a pattern that contains slashes, or if one of its
-   components matches a pattern that contains no slashes.  */
+/* Return nonzero if file NAME is excluded.  */
 bool
 excluded_name (char const *name)
 {
   return excluded_filename (excluded, name + FILESYSTEM_PREFIX_LEN (name));
 }
 \f
-/* Names to avoid dumping.  */
-static Hash_table *avoided_name_table;
+/* Hash tables of strings.  */
 
-/* Calculate the hash of an avoided name.  */
+/* Calculate the hash of a string.  */
 static unsigned
-hash_avoided_name (void const *name, unsigned n_buckets)
+hash_string_hasher (void const *name, unsigned n_buckets)
 {
   return hash_string (name, n_buckets);
 }
 
-/* Compare two avoided names for equality.  */
+/* Compare two strings for equality.  */
 static bool
-compare_avoided_names (void const *name1, void const *name2)
+hash_string_compare (void const *name1, void const *name2)
 {
   return strcmp (name1, name2) == 0;
 }
 
+/* Return zero if TABLE contains a copy of STRING; otherwise, insert a
+   copy of STRING to TABLE and return 1.  */
+static bool
+hash_string_insert (Hash_table **table, char const *string)
+{
+  Hash_table *t = *table;
+  char *s = xstrdup (string);
+  char *e;
+
+  if (! ((t
+         || (*table = t = hash_initialize (0, 0, hash_string_hasher,
+                                           hash_string_compare, 0)))
+        && (e = hash_insert (t, s))))
+    xalloc_die ();
+
+  if (e == s)
+    return 1;
+  else
+    {
+      free (s);
+      return 0;
+    }
+}
+
+/* Return 1 if TABLE contains STRING.  */
+static bool
+hash_string_lookup (Hash_table const *table, char const *string)
+{
+  return table && hash_lookup (table, string);
+}
+\f
+/* Names to avoid dumping.  */
+static Hash_table *avoided_name_table;
+
 /* Remember to not archive NAME.  */
 void
 add_avoided_name (char const *name)
 {
-  if (! ((avoided_name_table
-         || (avoided_name_table = hash_initialize (0, 0, hash_avoided_name,
-                                                   compare_avoided_names, 0)))
-        && hash_insert (avoided_name_table, xstrdup (name))))
-    xalloc_die ();
+  hash_string_insert (&avoided_name_table, name);
 }
 
 /* Should NAME be avoided when archiving?  */
-int
+bool
 is_avoided_name (char const *name)
 {
-  return avoided_name_table && hash_lookup (avoided_name_table, name);
+  return hash_string_lookup (avoided_name_table, name);
+}
+\f
+/* Return a safer suffix of FILE_NAME, or "." if it has no safer
+   suffix.  Check for fully specified file names and other atrocities.
+   Warn the user if we do not return NAME.  If LINK_TARGET is 1,
+   FILE_NAME is the target of a hard link, not a member name.  */
+
+char *
+safer_name_suffix (char const *file_name, bool link_target)
+{
+  char const *p;
+
+  if (absolute_names_option)
+    p = file_name;
+  else
+    {
+      /* Skip file system prefixes, leading pathnames that contain
+        "..", and leading slashes.  */
+
+      size_t prefix_len = FILESYSTEM_PREFIX_LEN (file_name);
+
+      for (p = file_name + prefix_len; *p; )
+       {
+         if (p[0] == '.' && p[1] == '.' && (ISSLASH (p[2]) || !p[2]))
+           prefix_len = p + 2 - file_name;
+
+         do
+           {
+             char c = *p++;
+             if (ISSLASH (c))
+               break;
+           }
+         while (*p);
+       }
+
+      for (p = file_name + prefix_len; ISSLASH (*p); p++)
+       continue;
+      prefix_len = p - file_name;
+
+      if (prefix_len)
+       {
+         static Hash_table *prefix_table[2];
+         char *prefix = alloca (prefix_len + 1);
+         memcpy (prefix, file_name, prefix_len);
+         prefix[prefix_len] = '\0';
+
+         if (hash_string_insert (&prefix_table[link_target], prefix))
+           {
+             static char const *const diagnostic[] =
+             {
+               N_("Removing leading `%s' from member names"),
+               N_("Removing leading `%s' from hard link targets")
+             };
+             WARN ((0, 0, _(diagnostic[link_target]), prefix));
+           }
+       }
+    }
+
+  if (! *p)
+    {
+      if (p == file_name)
+       {
+         static char const *const diagnostic[] =
+         {
+           N_("Substituting `.' for empty member name"),
+           N_("Substituting `.' for empty hard link target")
+         };
+         WARN ((0, 0, _(diagnostic[link_target])));
+       }
+
+      p = ".";
+    }
+
+  return (char *) p;
+}
+\f
+/* Return nonzero if NAME contains ".." as a path name component.  */
+bool
+contains_dot_dot (char const *name)
+{
+  char const *p = name + FILESYSTEM_PREFIX_LEN (name);
+
+  for (;; p++)
+    {
+      if (p[0] == '.' && p[1] == '.' && (ISSLASH (p[2]) || !p[2]))
+       return 1;
+
+      do
+       {
+         if (! *p++)
+           return 0;
+       }
+      while (! ISSLASH (*p));
+    }
 }