X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fnames.c;h=8674ec92613c052eb46d6bd4d76cd2cbe4eeb5ab;hb=04f1deefad399bcf5bec6bb6afc2a0a53c498025;hp=16cba031e72e0c4a63c244def2db49676db052b5;hpb=f74aea3ae3938a8a9744f96da1d89665c9d931af;p=chaz%2Ftar

diff --git a/src/names.c b/src/names.c
index 16cba03..8674ec9 100644
--- a/src/names.c
+++ b/src/names.c
@@ -44,20 +44,20 @@ extern struct group *getgrgid ();
    This code should also be modified for non-UNIX systems to do something
    reasonable.  */
 
-static char cached_uname[UNAME_FIELD_SIZE] = "";
-static char cached_gname[GNAME_FIELD_SIZE] = "";
+static char cached_uname[UNAME_FIELD_SIZE];
+static char cached_gname[GNAME_FIELD_SIZE];
 
 static uid_t cached_uid;	/* valid only if cached_uname is not empty */
 static gid_t cached_gid;	/* valid only if cached_gname is not empty */
 
 /* These variables are valid only if nonempty.  */
-static char cached_no_such_uname[UNAME_FIELD_SIZE] = "";
-static char cached_no_such_gname[GNAME_FIELD_SIZE] = "";
+static char cached_no_such_uname[UNAME_FIELD_SIZE];
+static char cached_no_such_gname[GNAME_FIELD_SIZE];
 
 /* These variables are valid only if nonzero.  It's not worth optimizing
    the case for weird systems where 0 is not a valid uid or gid.  */
-static uid_t cached_no_such_uid = 0;
-static gid_t cached_no_such_gid = 0;
+static uid_t cached_no_such_uid;
+static gid_t cached_no_such_gid;
 
 /*------------------------------------------.
 | Given UID, find the corresponding UNAME.  |
@@ -197,7 +197,7 @@ gname_to_gid (char gname[GNAME_FIELD_SIZE], gid_t *gidp)
 static const char **name_array;	/* store an array of names */
 static int allocated_names;	/* how big is the array? */
 static int names;		/* how many entries does it have? */
-static int name_index = 0;	/* how many of the entries have we scanned? */
+static int name_index;		/* how many of the entries have we scanned? */
 
 /*------------------------.
 | Initialize structures.  |
@@ -207,8 +207,7 @@ void
 init_names (void)
 {
   allocated_names = 10;
-  name_array = (const char **)
-    xmalloc (sizeof (const char *) * allocated_names);
+  name_array = xmalloc (sizeof (const char *) * allocated_names);
   names = 0;
 }
 
@@ -222,7 +221,7 @@ name_add (const char *name)
   if (names == allocated_names)
     {
       allocated_names *= 2;
-      name_array = (const char **)
+      name_array =
 	xrealloc (name_array, sizeof (const char *) * allocated_names);
     }
   name_array[names++] = name;
@@ -373,7 +372,9 @@ name_next (int change_dirs)
 
       if (chdir_flag)
 	{
-	  chdir_from_initial_wd (name_buffer);
+	  if (chdir (name_buffer) < 0)
+	    FATAL_ERROR ((0, errno, _("Cannot change to directory %s"),
+			  name_buffer));
 	  chdir_flag = 0;
 	}
       else if (change_dirs && strcmp (name_buffer, "-C") == 0)
@@ -390,7 +391,7 @@ name_next (int change_dirs)
   if (name_file && chdir_flag)
     FATAL_ERROR ((0, 0, _("Missing file name after -C")));
 
-  return NULL;
+  return 0;
 }
 
 /*------------------------------.
@@ -400,7 +401,7 @@ name_next (int change_dirs)
 void
 name_close (void)
 {
-  if (name_file != NULL && name_file != stdin)
+  if (name_file && name_file != stdin)
     if (fclose (name_file) == EOF)
       ERROR ((0, errno, "%s", name_buffer));
 }
@@ -422,18 +423,18 @@ name_gather (void)
 {
   /* Buffer able to hold a single name.  */
   static struct name *buffer;
-  static size_t allocated_length = 0;
+  static size_t allocated_length;
 
   char const *name;
 
   if (same_order_option)
     {
-      char *change_dir = NULL;
+      static int change_dir;
 
       if (allocated_length == 0)
 	{
 	  allocated_length = sizeof (struct name) + NAME_FIELD_SIZE;
-	  buffer = (struct name *) xmalloc (allocated_length);
+	  buffer = xmalloc (allocated_length);
 	  /* FIXME: This memset is overkill, and ugly...  */
 	  memset (buffer, 0, allocated_length);
 	}
@@ -443,9 +444,7 @@ name_gather (void)
 	  char const *dir = name_next (0);
 	  if (! dir)
 	    FATAL_ERROR ((0, 0, _("Missing file name after -C")));
-	  if (change_dir)
-	    free (change_dir);
-	  change_dir = xstrdup (dir);
+	  change_dir = chdir_arg (xstrdup (dir));
 	}
 
       if (name)
@@ -454,45 +453,42 @@ name_gather (void)
 	  if (sizeof (struct name) + buffer->length >= allocated_length)
 	    {
 	      allocated_length = sizeof (struct name) + buffer->length;
-	      buffer = (struct name *) xrealloc (buffer, allocated_length);
+	      buffer = xrealloc (buffer, allocated_length);
 	    }
 	  buffer->change_dir = change_dir;
-	  strncpy (buffer->name, name, (size_t) buffer->length);
+	  strncpy (buffer->name, name, buffer->length);
 	  buffer->name[buffer->length] = 0;
-	  buffer->next = NULL;
+	  buffer->next = 0;
 	  buffer->found = 0;
 
 	  /* FIXME: Poorly named globals, indeed...  */
 	  namelist = buffer;
 	  namelast = namelist;
 	}
-      else if (change_dir)
-	free (change_dir);
-
-      return;
     }
-
-  /* Non sorted names -- read them all in.  */
-
-  for (;;)
+  else
     {
-      char *change_dir = NULL;
-      while ((name = name_next (0)) && strcmp (name, "-C") == 0)
-	{
-	  char const *dir = name_next (0);
-	  if (! dir)
-	    FATAL_ERROR ((0, 0, _("Missing file name after -C")));
-	  if (change_dir)
-	    free (change_dir);
-	  change_dir = xstrdup (dir);
-	}
-      if (name)
-	addname (name, change_dir);
-      else
+      /* Non sorted names -- read them all in.  */
+      int change_dir = 0;
+
+      for (;;)
 	{
-	  if (change_dir)
-	    free (change_dir);
-	  break;
+	  int change_dir0 = change_dir;
+	  while ((name = name_next (0)) && strcmp (name, "-C") == 0)
+	    {
+	      char const *dir = name_next (0);
+	      if (! dir)
+		FATAL_ERROR ((0, 0, _("Missing file name after -C")));
+	      change_dir = chdir_arg (xstrdup (dir));
+	    }
+	  if (name)
+	    addname (name, change_dir);
+	  else
+	    {
+	      if (change_dir != change_dir0)
+		addname (0, change_dir);
+	      break;
+	    }
 	}
     }
 }
@@ -502,23 +498,21 @@ name_gather (void)
 `-----------------------------*/
 
 void
-addname (char const *string, char const *change_dir)
+addname (char const *string, int change_dir)
 {
   struct name *name;
   size_t length;
 
   length = string ? strlen (string) : 0;
-  name = (struct name *) xmalloc (sizeof (struct name) + length);
+  name = xmalloc (sizeof (struct name) + length);
   memset (name, 0, sizeof (struct name) + length);
-  name->next = NULL;
+  name->next = 0;
 
   if (string)
     {
       name->fake = 0;
       name->length = length;
-      /* FIXME: Possibly truncating a string, here?  Tss, tss, tss!  */
-      strncpy (name->name, string, length);
-      name->name[length] = '\0';
+      memcpy (name->name, string, length + 1);
     }
   else
     name->fake = 1;
@@ -558,13 +552,13 @@ name_match (const char *path)
       struct name *cursor = namelist;
 
       if (!cursor)
-	return 1;		/* empty namelist is easy */
+	return ! files_from_option;
 
       if (cursor->fake)
 	{
-	  chdir_from_initial_wd (cursor->change_dir);
+	  chdir_do (cursor->change_dir);
 	  namelist = 0;
-	  return 1;
+	  return ! files_from_option;
 	}
 
       for (; cursor; cursor = cursor->next)
@@ -574,44 +568,21 @@ name_match (const char *path)
 	  if (cursor->firstch && cursor->name[0] != path[0])
 	    continue;
 
-	  /* Regular expressions (shell globbing, actually).  */
-
-	  if (cursor->regexp)
-	    {
-	      if (fnmatch (cursor->name, path, FNM_LEADING_DIR) == 0)
-		{
-		  cursor->found = 1; /* remember it matched */
-		  if (starting_file_option)
-		    {
-		      free (namelist);
-		      namelist = NULL;
-		    }
-		  chdir_from_initial_wd (cursor->change_dir);
-
-		  /* We got a match.  */
-		  return 1;
-		}
-	      continue;
-	    }
-
-	  /* Plain Old Strings.  */
-
-	  if (cursor->length <= length
-				/* archive length >= specified */
-	      && (path[cursor->length] == '\0'
-		  || path[cursor->length] == '/')
-				/* full match on file/dirname */
-	      && strncmp (path, cursor->name, cursor->length) == 0)
-				/* name compare */
+	  if (cursor->regexp
+	      ? fnmatch (cursor->name, path, FNM_LEADING_DIR) == 0
+	      : (cursor->length <= length
+		 && (path[cursor->length] == '\0'
+		     || path[cursor->length] == '/')
+		 && memcmp (path, cursor->name, cursor->length) == 0))
 	    {
-	      cursor->found = 1;	/* remember it matched */
+	      cursor->found = 1; /* remember it matched */
 	      if (starting_file_option)
 		{
-		  free ((void *) namelist);
+		  free (namelist);
 		  namelist = 0;
 		}
-	      chdir_from_initial_wd (cursor->change_dir);
-
+	      chdir_do (cursor->change_dir);
+  
 	      /* We got a match.  */
 	      return 1;
 	    }
@@ -658,8 +629,8 @@ names_notfound (void)
 	free (cursor);
 #endif
     }
-  namelist = (struct name *) NULL;
-  namelast = (struct name *) NULL;
+  namelist = 0;
+  namelast = 0;
 
   if (same_order_option)
     {
@@ -669,20 +640,211 @@ names_notfound (void)
 	ERROR ((0, 0, _("%s: Not found in archive"), name));
     }
 }
+
+/* Sorting name lists.  */
+
+/* Sort linked LIST of names, of given LENGTH, using COMPARE to order
+   names.  Return the sorted list.  Apart from the type `struct name'
+   and the definition of SUCCESSOR, this is a generic list-sorting
+   function, but it's too painful to make it both generic and portable
+   in C.  */
+
+static struct name *
+merge_sort (struct name *list, int length,
+	    int (*compare) (struct name const*, struct name const*))
+{
+  struct name *first_list;
+  struct name *second_list;
+  int first_length;
+  int second_length;
+  struct name *result;
+  struct name **merge_point;
+  struct name *cursor;
+  int counter;
+
+# define SUCCESSOR(name) ((name)->next)
+
+  if (length == 1)
+    return list;
+
+  if (length == 2)
+    {
+      if ((*compare) (list, SUCCESSOR (list)) > 0)
+	{
+	  result = SUCCESSOR (list);
+	  SUCCESSOR (result) = list;
+	  SUCCESSOR (list) = 0;
+	  return result;
+	}
+      return list;
+    }
+
+  first_list = list;
+  first_length = (length + 1) / 2;
+  second_length = length / 2;
+  for (cursor = list, counter = first_length - 1;
+       counter;
+       cursor = SUCCESSOR (cursor), counter--)
+    continue;
+  second_list = SUCCESSOR (cursor);
+  SUCCESSOR (cursor) = 0;
+
+  first_list = merge_sort (first_list, first_length, compare);
+  second_list = merge_sort (second_list, second_length, compare);
+
+  merge_point = &result;
+  while (first_list && second_list)
+    if ((*compare) (first_list, second_list) < 0)
+      {
+	cursor = SUCCESSOR (first_list);
+	*merge_point = first_list;
+	merge_point = &SUCCESSOR (first_list);
+	first_list = cursor;
+      }
+    else
+      {
+	cursor = SUCCESSOR (second_list);
+	*merge_point = second_list;
+	merge_point = &SUCCESSOR (second_list);
+	second_list = cursor;
+      }
+  if (first_list)
+    *merge_point = first_list;
+  else
+    *merge_point = second_list;
+
+  return result;
+
+#undef SUCCESSOR
+}
 
-/*---.
-| ?  |
-`---*/
+/* A comparison function for sorting names.  Put found names last;
+   break ties by string comparison.  */
+
+static int
+compare_names (struct name const *n1, struct name const *n2)
+{
+  int found_diff = n2->found - n1->found;
+  return found_diff ? found_diff : strcmp (n1->name, n2->name);
+}
+
+/* Add all the dirs in PATH, which is a directory, to the namelist.
+   If any of the files is a directory, recurse on the subdirectory.
+   CHANGE_DIR is the number of the directory that PATH is relative to.
+   DEVICE is the device not to leave, if the -l option is specified.  */
+
+static void
+add_hierarchy_to_namelist (char *path, int change_dir, dev_t device)
+{
+  char *buffer = get_directory_contents (path, device);
+
+  {
+    struct name *name;
+
+    for (name = namelist; name; name = name->next)
+      if (strcmp (name->name, path) == 0)
+	break;
+    if (name)
+      name->dir_contents = buffer ? buffer : "\0\0\0\0";
+  }
+
+  if (buffer)
+    {
+      size_t name_length = strlen (path);
+      size_t allocated_length = (name_length >= NAME_FIELD_SIZE
+				 ? name_length + NAME_FIELD_SIZE
+				 : NAME_FIELD_SIZE);
+      char *name_buffer = xmalloc (allocated_length + 1);
+				/* FIXME: + 2 above?  */
+      char *string;
+      size_t string_length;
+
+      strcpy (name_buffer, path);
+      if (name_buffer[name_length - 1] != '/')
+	{
+	  name_buffer[name_length++] = '/';
+	  name_buffer[name_length] = '\0';
+	}
+
+      for (string = buffer; *string; string += string_length + 1)
+	{
+	  string_length = strlen (string);
+	  if (*string == 'D')
+	    {
+	      if (name_length + string_length >= allocated_length)
+		{
+		  while (name_length + string_length >= allocated_length)
+		    allocated_length += NAME_FIELD_SIZE;
+		  name_buffer = xrealloc (name_buffer, allocated_length + 1);
+		}
+	      strcpy (name_buffer + name_length, string + 1);
+	      addname (name_buffer, change_dir);
+	      if (*string == 'D')
+		add_hierarchy_to_namelist (name_buffer, change_dir, device);
+	    }
+	}
+
+      free (name_buffer);
+    }
+}
+
+/* Collect all the names from argv[] (or whatever), expand them into a
+   directory tree, and sort them.  This gets only subdirectories, not
+   all files.  */
 
 void
-name_expand (void)
+collect_and_sort_names (void)
 {
+  struct name *name;
+  struct name *next_name;
+  int num_names;
+  struct stat statbuf;
+
+  name_gather ();
+
+  if (listed_incremental_option)
+    read_directory_file ();
+
+  if (!namelist)
+    addname (".", 0);
+
+  for (name = namelist; name; name = next_name)
+    {
+      next_name = name->next;
+      if (name->found || name->dir_contents)
+	continue;
+      if (name->regexp)		/* FIXME: just skip regexps for now */
+	continue;
+      chdir_do (name->change_dir);
+      if (name->fake)
+	continue;
+
+      if (deref_stat (dereference_option, name->name, &statbuf) != 0)
+	{
+	  ERROR ((0, errno, _("Cannot stat %s"), name->name));
+	  continue;
+	}
+      if (S_ISDIR (statbuf.st_mode))
+	{
+	  name->found = 1;
+	  add_hierarchy_to_namelist (name->name, name->change_dir,
+				     statbuf.st_dev);
+	}
+    }
+
+  num_names = 0;
+  for (name = namelist; name; name = name->next)
+    num_names++;
+  namelist = merge_sort (namelist, num_names, compare_names);
+
+  for (name = namelist; name; name = name->next)
+    name->found = 0;
 }
 
 /*-------------------------------------------------------------------------.
 | This is like name_match, except that it returns a pointer to the name it |
 | matched, and doesn't set FOUND in structure.  The caller will have to do |
-| that if it wants to.  Oh, and if the namelist is empty, it returns NULL, |
+| that if it wants to.  Oh, and if the namelist is empty, it returns null, |
 | unlike name_match, which returns TRUE.                                   |
 `-------------------------------------------------------------------------*/
 
@@ -696,7 +858,7 @@ name_scan (const char *path)
       struct name *cursor = namelist;
 
       if (!cursor)
-	return NULL;		/* empty namelist is easy */
+	return 0;
 
       for (; cursor; cursor = cursor->next)
 	{
@@ -705,24 +867,12 @@ name_scan (const char *path)
 	  if (cursor->firstch && cursor->name[0] != path[0])
 	    continue;
 
-	  /* Regular expressions.  */
-
-	  if (cursor->regexp)
-	    {
-	      if (fnmatch (cursor->name, path, FNM_LEADING_DIR) == 0)
-		return cursor;	/* we got a match */
-	      continue;
-	    }
-
-	  /* Plain Old Strings.  */
-
-	  if (cursor->length <= length
-				/* archive length >= specified */
-	      && (path[cursor->length] == '\0'
-		  || path[cursor->length] == '/')
-				/* full match on file/dirname */
-	      && strncmp (path, cursor->name, cursor->length) == 0)
-				/* name compare */
+	  if (cursor->regexp
+	      ? fnmatch (cursor->name, path, FNM_LEADING_DIR) == 0
+	      : (cursor->length <= length
+		 && (path[cursor->length] == '\0'
+		     || path[cursor->length] == '/')
+		 && memcmp (path, cursor->name, cursor->length) == 0))
 	    return cursor;	/* we got a match */
 	}
 
@@ -735,10 +885,10 @@ name_scan (const char *path)
 	{
 	  name_gather ();	/* read one more */
 	  if (namelist->found)
-	    return NULL;
+	    return 0;
 	}
       else
-	return NULL;
+	return 0;
     }
 }
 
@@ -748,22 +898,22 @@ name_scan (const char *path)
 | return all the non-found names in the namelist			 |
 `-----------------------------------------------------------------------*/
 
-struct name *gnu_list_name = NULL;
+struct name *gnu_list_name;
 
 char *
 name_from_list (void)
 {
   if (!gnu_list_name)
     gnu_list_name = namelist;
-  while (gnu_list_name && gnu_list_name->found)
+  while (gnu_list_name && (gnu_list_name->found | gnu_list_name->fake))
     gnu_list_name = gnu_list_name->next;
   if (gnu_list_name)
     {
       gnu_list_name->found = 1;
-      chdir_from_initial_wd (gnu_list_name->change_dir);
+      chdir_do (gnu_list_name->change_dir);
       return gnu_list_name->name;
     }
-  return NULL;
+  return 0;
 }
 
 /*---.
@@ -787,7 +937,7 @@ blank_name_list (void)
 char *
 new_name (const char *path, const char *name)
 {
-  char *buffer = (char *) xmalloc (strlen (path) + strlen (name) + 2);
+  char *buffer = xmalloc (strlen (path) + strlen (name) + 2);
 
   sprintf (buffer, "%s/%s", path, name);
   return buffer;
@@ -814,3 +964,34 @@ excluded_name (char const *name)
 
   return 0;
 }
+
+/* Names to avoid dumping.  */
+
+struct avoided_name
+{
+  struct avoided_name const *next;
+  char name[1];
+};
+
+static struct avoided_name *avoided_names;
+
+/* Remember to not archive NAME.  */
+void
+add_avoided_name (char const *name)
+{
+  struct avoided_name *p = xmalloc (sizeof *p + strlen (name));
+  p->next = avoided_names;
+  avoided_names = p;
+  strcpy (p->name, name);
+}
+
+/* Should NAME be avoided when archiving?  */
+int
+is_avoided_name (char const *name)
+{
+  struct avoided_name const *p;
+  for (p = avoided_names; p; p = p->next)
+    if (strcmp (p->name, name) == 0)
+      return 1;
+  return 0;
+}