git.cworth.org Git - tar/blob - src/names.c

   1 /* Various processing of names.
   2
   3    Copyright (C) 1988, 1992, 1994, 1996, 1997, 1998, 1999, 2000, 2001,
   4    2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 3, or (at your option) any later
   9    version.
  10
  11    This program is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
  14    Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License along
  17    with this program; if not, write to the Free Software Foundation, Inc.,
  18    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  19
  20 #include <system.h>
  21
  22 #include <fnmatch.h>
  23 #include <hash.h>
  24 #include <quotearg.h>
  25
  26 #include "common.h"
  27 \f
  28 /* User and group names.  */
  29
  30 struct group *getgrnam ();
  31 struct passwd *getpwnam ();
  32 #if ! HAVE_DECL_GETPWUID
  33 struct passwd *getpwuid ();
  34 #endif
  35 #if ! HAVE_DECL_GETGRGID
  36 struct group *getgrgid ();
  37 #endif
  38
  39 /* Make sure you link with the proper libraries if you are running the
  40    Yellow Peril (thanks for the good laugh, Ian J.!), or, euh... NIS.
  41    This code should also be modified for non-UNIX systems to do something
  42    reasonable.  */
  43
  44 static char *cached_uname;
  45 static char *cached_gname;
  46
  47 static uid_t cached_uid;        /* valid only if cached_uname is not empty */
  48 static gid_t cached_gid;        /* valid only if cached_gname is not empty */
  49
  50 /* These variables are valid only if nonempty.  */
  51 static char *cached_no_such_uname;
  52 static char *cached_no_such_gname;
  53
  54 /* These variables are valid only if nonzero.  It's not worth optimizing
  55    the case for weird systems where 0 is not a valid uid or gid.  */
  56 static uid_t cached_no_such_uid;
  57 static gid_t cached_no_such_gid;
  58
  59 static void register_individual_file (char const *name);
  60
  61 /* Given UID, find the corresponding UNAME.  */
  62 void
  63 uid_to_uname (uid_t uid, char **uname)
  64 {
  65   struct passwd *passwd;
  66
  67   if (uid != 0 && uid == cached_no_such_uid)
  68     {
  69       *uname = xstrdup ("");
  70       return;
  71     }
  72
  73   if (!cached_uname || uid != cached_uid)
  74     {
  75       passwd = getpwuid (uid);
  76       if (passwd)
  77         {
  78           cached_uid = uid;
  79           assign_string (&cached_uname, passwd->pw_name);
  80         }
  81       else
  82         {
  83           cached_no_such_uid = uid;
  84           *uname = xstrdup ("");
  85           return;
  86         }
  87     }
  88   *uname = xstrdup (cached_uname);
  89 }
  90
  91 /* Given GID, find the corresponding GNAME.  */
  92 void
  93 gid_to_gname (gid_t gid, char **gname)
  94 {
  95   struct group *group;
  96
  97   if (gid != 0 && gid == cached_no_such_gid)
  98     {
  99       *gname = xstrdup ("");
 100       return;
 101     }
 102
 103   if (!cached_gname || gid != cached_gid)
 104     {
 105       group = getgrgid (gid);
 106       if (group)
 107         {
 108           cached_gid = gid;
 109           assign_string (&cached_gname, group->gr_name);
 110         }
 111       else
 112         {
 113           cached_no_such_gid = gid;
 114           *gname = xstrdup ("");
 115           return;
 116         }
 117     }
 118   *gname = xstrdup (cached_gname);
 119 }
 120
 121 /* Given UNAME, set the corresponding UID and return 1, or else, return 0.  */
 122 int
 123 uname_to_uid (char const *uname, uid_t *uidp)
 124 {
 125   struct passwd *passwd;
 126
 127   if (cached_no_such_uname
 128       && strcmp (uname, cached_no_such_uname) == 0)
 129     return 0;
 130
 131   if (!cached_uname
 132       || uname[0] != cached_uname[0]
 133       || strcmp (uname, cached_uname) != 0)
 134     {
 135       passwd = getpwnam (uname);
 136       if (passwd)
 137         {
 138           cached_uid = passwd->pw_uid;
 139           assign_string (&cached_uname, passwd->pw_name);
 140         }
 141       else
 142         {
 143           assign_string (&cached_no_such_uname, uname);
 144           return 0;
 145         }
 146     }
 147   *uidp = cached_uid;
 148   return 1;
 149 }
 150
 151 /* Given GNAME, set the corresponding GID and return 1, or else, return 0.  */
 152 int
 153 gname_to_gid (char const *gname, gid_t *gidp)
 154 {
 155   struct group *group;
 156
 157   if (cached_no_such_gname
 158       && strcmp (gname, cached_no_such_gname) == 0)
 159     return 0;
 160
 161   if (!cached_gname
 162       || gname[0] != cached_gname[0]
 163       || strcmp (gname, cached_gname) != 0)
 164     {
 165       group = getgrnam (gname);
 166       if (group)
 167         {
 168           cached_gid = group->gr_gid;
 169           assign_string (&cached_gname, gname);
 170         }
 171       else
 172         {
 173           assign_string (&cached_no_such_gname, gname);
 174           return 0;
 175         }
 176     }
 177   *gidp = cached_gid;
 178   return 1;
 179 }
 180
 181 \f
 182 /* Names from the command call.  */
 183
 184 static struct name *namelist;   /* first name in list, if any */
 185 static struct name **nametail = &namelist;      /* end of name list */
 186
 187 /* File name arguments are processed in two stages: first a
 188    name_array (see below) is filled, then the names from it
 189    are moved into the namelist.
 190
 191    This awkward process is needed only to implement --same-order option,
 192    which is meant to help process large archives on machines with
 193    limited memory.  With this option on, namelist contains at most one
 194    entry, which diminishes the memory consumption.
 195
 196    However, I very much doubt if we still need this -- Sergey */
 197
 198 /* A name_array element contains entries of three types: */
 199
 200 #define NELT_NAME  0   /* File name */
 201 #define NELT_CHDIR 1   /* Change directory request */
 202 #define NELT_FMASK 2   /* Change fnmatch options request */
 203
 204 struct name_elt        /* A name_array element. */
 205 {
 206   char type;           /* Element type, see NELT_* constants above */
 207   union
 208   {
 209     const char *name;  /* File or directory name */
 210     int matching_flags;/* fnmatch options if type == NELT_FMASK */
 211   } v;
 212 };
 213
 214 static struct name_elt *name_array;  /* store an array of names */
 215 static size_t allocated_names;   /* how big is the array? */
 216 static size_t names;             /* how many entries does it have? */
 217 static size_t name_index;        /* how many of the entries have we scanned? */
 218
 219 /* Check the size of name_array, reallocating it as necessary.  */
 220 static void
 221 check_name_alloc ()
 222 {
 223   if (names == allocated_names)
 224     {
 225       if (allocated_names == 0)
 226         allocated_names = 10; /* Set initial allocation */
 227       name_array = x2nrealloc (name_array, &allocated_names,
 228                                sizeof (name_array[0]));
 229     }
 230 }
 231
 232 /* Add to name_array the file NAME with fnmatch options MATCHING_FLAGS */
 233 void
 234 name_add_name (const char *name, int matching_flags)
 235 {
 236   static int prev_flags = 0; /* FIXME: Or EXCLUDE_ANCHORED? */
 237   struct name_elt *ep;
 238
 239   check_name_alloc ();
 240   ep = &name_array[names++];
 241   if (prev_flags != matching_flags)
 242     {
 243       ep->type = NELT_FMASK;
 244       ep->v.matching_flags = matching_flags;
 245       prev_flags = matching_flags;
 246       check_name_alloc ();
 247       ep = &name_array[names++];
 248     }
 249   ep->type = NELT_NAME;
 250   ep->v.name = name;
 251 }
 252
 253 /* Add to name_array a chdir request for the directory NAME */
 254 void
 255 name_add_dir (const char *name)
 256 {
 257   struct name_elt *ep;
 258   check_name_alloc ();
 259   ep = &name_array[names++];
 260   ep->type = NELT_CHDIR;
 261   ep->v.name = name;
 262 }
 263
 264 \f
 265 /* Names from external name file.  */
 266
 267 static char *name_buffer;       /* buffer to hold the current file name */
 268 static size_t name_buffer_length; /* allocated length of name_buffer */
 269
 270 /* Set up to gather file names for tar.  They can either come from a
 271    file or were saved from decoding arguments.  */
 272 void
 273 name_init (void)
 274 {
 275   name_buffer = xmalloc (NAME_FIELD_SIZE + 2);
 276   name_buffer_length = NAME_FIELD_SIZE;
 277 }
 278
 279 void
 280 name_term (void)
 281 {
 282   free (name_buffer);
 283   free (name_array);
 284 }
 285
 286 static int matching_flags; /* exclude_fnmatch options */
 287
 288 /* Get the next NELT_NAME element from name_array.  Result is in
 289    static storage and can't be relied upon across two calls.
 290
 291    If CHANGE_DIRS is true, treat any entries of type NELT_CHDIR as
 292    the request to change to the given directory.
 293
 294    Entries of type NELT_FMASK cause updates of the matching_flags
 295    value. */
 296 struct name_elt *
 297 name_next_elt (int change_dirs)
 298 {
 299   static struct name_elt entry;
 300   const char *source;
 301   char *cursor;
 302
 303   while (name_index != names)
 304     {
 305       struct name_elt *ep;
 306       size_t source_len;
 307
 308       ep = &name_array[name_index++];
 309       if (ep->type == NELT_FMASK)
 310         {
 311           matching_flags = ep->v.matching_flags;
 312           continue;
 313         }
 314
 315       source = ep->v.name;
 316       source_len = strlen (source);
 317       if (name_buffer_length < source_len)
 318         {
 319           do
 320             {
 321               name_buffer_length *= 2;
 322               if (! name_buffer_length)
 323                 xalloc_die ();
 324             }
 325           while (name_buffer_length < source_len);
 326
 327           free (name_buffer);
 328           name_buffer = xmalloc (name_buffer_length + 2);
 329         }
 330       strcpy (name_buffer, source);
 331
 332       /* Zap trailing slashes.  */
 333
 334       cursor = name_buffer + strlen (name_buffer) - 1;
 335       while (cursor > name_buffer && ISSLASH (*cursor))
 336         *cursor-- = '\0';
 337
 338       if (change_dirs && ep->type == NELT_CHDIR)
 339         {
 340           if (chdir (name_buffer) < 0)
 341             chdir_fatal (name_buffer);
 342         }
 343       else
 344         {
 345           if (unquote_option)
 346             unquote_string (name_buffer);
 347           if (incremental_option)
 348             register_individual_file (name_buffer);
 349           entry.type = ep->type;
 350           entry.v.name = name_buffer;
 351           return &entry;
 352         }
 353     }
 354
 355   return NULL;
 356 }
 357
 358 const char *
 359 name_next (int change_dirs)
 360 {
 361   struct name_elt *nelt = name_next_elt (change_dirs);
 362   return nelt ? nelt->v.name : NULL;
 363 }
 364
 365 /* Gather names in a list for scanning.  Could hash them later if we
 366    really care.
 367
 368    If the names are already sorted to match the archive, we just read
 369    them one by one.  name_gather reads the first one, and it is called
 370    by name_match as appropriate to read the next ones.  At EOF, the
 371    last name read is just left in the buffer.  This option lets users
 372    of small machines extract an arbitrary number of files by doing
 373    "tar t" and editing down the list of files.  */
 374
 375 void
 376 name_gather (void)
 377 {
 378   /* Buffer able to hold a single name.  */
 379   static struct name *buffer;
 380   static size_t allocated_size;
 381
 382   struct name_elt *ep;
 383
 384   if (same_order_option)
 385     {
 386       static int change_dir;
 387
 388       if (allocated_size == 0)
 389         {
 390           allocated_size = offsetof (struct name, name) + NAME_FIELD_SIZE + 1;
 391           buffer = xzalloc (allocated_size);
 392         }
 393
 394       while ((ep = name_next_elt (0)) && ep->type == NELT_CHDIR)
 395         change_dir = chdir_arg (xstrdup (ep->v.name));
 396
 397       if (ep)
 398         {
 399           size_t needed_size;
 400
 401           buffer->length = strlen (ep->v.name);
 402           needed_size = offsetof (struct name, name) + buffer->length + 1;
 403           if (allocated_size < needed_size)
 404             {
 405               do
 406                 {
 407                   allocated_size *= 2;
 408                   if (! allocated_size)
 409                     xalloc_die ();
 410                 }
 411               while (allocated_size < needed_size);
 412
 413               buffer = xrealloc (buffer, allocated_size);
 414             }
 415           buffer->change_dir = change_dir;
 416           strcpy (buffer->name, ep->v.name);
 417           buffer->next = 0;
 418           buffer->found_count = 0;
 419           buffer->matching_flags = matching_flags;
 420
 421           namelist = buffer;
 422           nametail = &namelist->next;
 423         }
 424       else if (change_dir)
 425         addname (0, change_dir);
 426     }
 427   else
 428     {
 429       /* Non sorted names -- read them all in.  */
 430       int change_dir = 0;
 431
 432       for (;;)
 433         {
 434           int change_dir0 = change_dir;
 435           while ((ep = name_next_elt (0)) && ep->type == NELT_CHDIR)
 436             change_dir = chdir_arg (xstrdup (ep->v.name));
 437
 438           if (ep)
 439             addname (ep->v.name, change_dir);
 440           else
 441             {
 442               if (change_dir != change_dir0)
 443                 addname (0, change_dir);
 444               break;
 445             }
 446         }
 447     }
 448 }
 449
 450 /*  Add a name to the namelist.  */
 451 struct name *
 452 addname (char const *string, int change_dir)
 453 {
 454   size_t length = string ? strlen (string) : 0;
 455   struct name *name = xmalloc (offsetof (struct name, name) + length + 1);
 456
 457   if (string)
 458     strcpy (name->name, string);
 459   else
 460     name->name[0] = 0;
 461
 462   name->next = NULL;
 463   name->length = length;
 464   name->found_count = 0;
 465   name->matching_flags = matching_flags;
 466   name->change_dir = change_dir;
 467   name->dir_contents = NULL;
 468
 469   *nametail = name;
 470   nametail = &name->next;
 471   return name;
 472 }
 473
 474 /* Find a match for FILE_NAME (whose string length is LENGTH) in the name
 475    list.  */
 476 static struct name *
 477 namelist_match (char const *file_name, size_t length)
 478 {
 479   struct name *p;
 480
 481   for (p = namelist; p; p = p->next)
 482     {
 483       if (p->name[0]
 484           && exclude_fnmatch (p->name, file_name, p->matching_flags))
 485         return p;
 486     }
 487
 488   return NULL;
 489 }
 490
 491 /* Return true if and only if name FILE_NAME (from an archive) matches any
 492    name from the namelist.  */
 493 bool
 494 name_match (const char *file_name)
 495 {
 496   size_t length = strlen (file_name);
 497
 498   while (1)
 499     {
 500       struct name *cursor = namelist;
 501
 502       if (!cursor)
 503         return true;
 504
 505       if (cursor->name[0] == 0)
 506         {
 507           chdir_do (cursor->change_dir);
 508           namelist = 0;
 509           nametail = &namelist;
 510           return true;
 511         }
 512
 513       cursor = namelist_match (file_name, length);
 514       if (cursor)
 515         {
 516           if (!(ISSLASH (file_name[cursor->length]) && recursion_option)
 517               || cursor->found_count == 0)
 518             cursor->found_count++; /* remember it matched */
 519           if (starting_file_option)
 520             {
 521               free (namelist);
 522               namelist = 0;
 523               nametail = &namelist;
 524             }
 525           chdir_do (cursor->change_dir);
 526
 527           /* We got a match.  */
 528           return ISFOUND (cursor);
 529         }
 530
 531       /* Filename from archive not found in namelist.  If we have the whole
 532          namelist here, just return 0.  Otherwise, read the next name in and
 533          compare it.  If this was the last name, namelist->found_count will
 534          remain on.  If not, we loop to compare the newly read name.  */
 535
 536       if (same_order_option && namelist->found_count)
 537         {
 538           name_gather ();       /* read one more */
 539           if (namelist->found_count)
 540             return false;
 541         }
 542       else
 543         return false;
 544     }
 545 }
 546
 547 /* Returns true if all names from the namelist were processed.
 548    P is the stat_info of the most recently processed entry.
 549    The decision is postponed until the next entry is read if:
 550
 551    1) P ended with a slash (i.e. it was a directory)
 552    2) P matches any entry from the namelist *and* represents a subdirectory
 553    or a file lying under this entry (in the terms of directory structure).
 554
 555    This is necessary to handle contents of directories. */
 556 bool
 557 all_names_found (struct tar_stat_info *p)
 558 {
 559   struct name const *cursor;
 560   size_t len;
 561
 562   if (test_label_option)
 563     return true;
 564   if (!p->file_name || occurrence_option == 0 || p->had_trailing_slash)
 565     return false;
 566   len = strlen (p->file_name);
 567   for (cursor = namelist; cursor; cursor = cursor->next)
 568     {
 569       if ((cursor->name[0] && !WASFOUND (cursor))
 570           || (len >= cursor->length && ISSLASH (p->file_name[cursor->length])))
 571         return false;
 572     }
 573   return true;
 574 }
 575
 576 static inline int
 577 is_pattern (const char *string)
 578 {
 579   return strchr (string, '*') || strchr (string, '[') || strchr (string, '?');
 580 }
 581
 582 static void
 583 regex_usage_warning (const char *name)
 584 {
 585   static int warned_once = 0;
 586
 587   if (warn_regex_usage && is_pattern (name))
 588     {
 589       warned_once = 1;
 590       WARN ((0, 0,
 591              /* TRANSLATORS: The following three msgids form a single sentence.
 592               */
 593              _("Pattern matching characters used in file names. Please,")));
 594       WARN ((0, 0,
 595              _("use --wildcards to enable pattern matching, or --no-wildcards to")));
 596       WARN ((0, 0,
 597              _("suppress this warning.")));
 598     }
 599 }
 600
 601 /* Print the names of things in the namelist that were not matched.  */
 602 void
 603 names_notfound (void)
 604 {
 605   struct name const *cursor;
 606
 607   for (cursor = namelist; cursor; cursor = cursor->next)
 608     if (!WASFOUND (cursor) && cursor->name[0])
 609       {
 610         regex_usage_warning (cursor->name);
 611         if (cursor->found_count == 0)
 612           ERROR ((0, 0, _("%s: Not found in archive"),
 613                   quotearg_colon (cursor->name)));
 614         else
 615           ERROR ((0, 0, _("%s: Required occurrence not found in archive"),
 616                   quotearg_colon (cursor->name)));
 617       }
 618
 619   /* Don't bother freeing the name list; we're about to exit.  */
 620   namelist = 0;
 621   nametail = &namelist;
 622
 623   if (same_order_option)
 624     {
 625       const char *name;
 626
 627       while ((name = name_next (1)) != NULL)
 628         {
 629           regex_usage_warning (name);
 630           ERROR ((0, 0, _("%s: Not found in archive"),
 631                   quotearg_colon (name)));
 632         }
 633     }
 634 }
 635 \f
 636 /* Sorting name lists.  */
 637
 638 /* Sort linked LIST of names, of given LENGTH, using COMPARE to order
 639    names.  Return the sorted list.  Apart from the type `struct name'
 640    and the definition of SUCCESSOR, this is a generic list-sorting
 641    function, but it's too painful to make it both generic and portable
 642    in C.  */
 643
 644 static struct name *
 645 merge_sort (struct name *list, int length,
 646             int (*compare) (struct name const*, struct name const*))
 647 {
 648   struct name *first_list;
 649   struct name *second_list;
 650   int first_length;
 651   int second_length;
 652   struct name *result;
 653   struct name **merge_point;
 654   struct name *cursor;
 655   int counter;
 656
 657 # define SUCCESSOR(name) ((name)->next)
 658
 659   if (length == 1)
 660     return list;
 661
 662   if (length == 2)
 663     {
 664       if ((*compare) (list, SUCCESSOR (list)) > 0)
 665         {
 666           result = SUCCESSOR (list);
 667           SUCCESSOR (result) = list;
 668           SUCCESSOR (list) = 0;
 669           return result;
 670         }
 671       return list;
 672     }
 673
 674   first_list = list;
 675   first_length = (length + 1) / 2;
 676   second_length = length / 2;
 677   for (cursor = list, counter = first_length - 1;
 678        counter;
 679        cursor = SUCCESSOR (cursor), counter--)
 680     continue;
 681   second_list = SUCCESSOR (cursor);
 682   SUCCESSOR (cursor) = 0;
 683
 684   first_list = merge_sort (first_list, first_length, compare);
 685   second_list = merge_sort (second_list, second_length, compare);
 686
 687   merge_point = &result;
 688   while (first_list && second_list)
 689     if ((*compare) (first_list, second_list) < 0)
 690       {
 691         cursor = SUCCESSOR (first_list);
 692         *merge_point = first_list;
 693         merge_point = &SUCCESSOR (first_list);
 694         first_list = cursor;
 695       }
 696     else
 697       {
 698         cursor = SUCCESSOR (second_list);
 699         *merge_point = second_list;
 700         merge_point = &SUCCESSOR (second_list);
 701         second_list = cursor;
 702       }
 703   if (first_list)
 704     *merge_point = first_list;
 705   else
 706     *merge_point = second_list;
 707
 708   return result;
 709
 710 #undef SUCCESSOR
 711 }
 712
 713 /* A comparison function for sorting names.  Put found names last;
 714    break ties by string comparison.  */
 715
 716 static int
 717 compare_names (struct name const *n1, struct name const *n2)
 718 {
 719   int found_diff = WASFOUND(n2) - WASFOUND(n1);
 720   return found_diff ? found_diff : strcmp (n1->name, n2->name);
 721 }
 722 \f
 723 /* Add all the dirs under NAME, which names a directory, to the namelist.
 724    If any of the files is a directory, recurse on the subdirectory.
 725    DEVICE is the device not to leave, if the -l option is specified.  */
 726
 727 static void
 728 add_hierarchy_to_namelist (struct name *name, dev_t device)
 729 {
 730   char *file_name = name->name;
 731   const char *buffer = get_directory_contents (file_name, device);
 732
 733   if (! buffer)
 734     name->dir_contents = "\0\0\0\0";
 735   else
 736     {
 737       size_t name_length = name->length;
 738       size_t allocated_length = (name_length >= NAME_FIELD_SIZE
 739                                  ? name_length + NAME_FIELD_SIZE
 740                                  : NAME_FIELD_SIZE);
 741       char *namebuf = xmalloc (allocated_length + 1);
 742                                 /* FIXME: + 2 above?  */
 743       const char *string;
 744       size_t string_length;
 745       int change_dir = name->change_dir;
 746
 747       name->dir_contents = buffer;
 748       strcpy (namebuf, file_name);
 749       if (! ISSLASH (namebuf[name_length - 1]))
 750         {
 751           namebuf[name_length++] = '/';
 752           namebuf[name_length] = '\0';
 753         }
 754
 755       for (string = buffer; *string; string += string_length + 1)
 756         {
 757           string_length = strlen (string);
 758           if (*string == 'D')
 759             {
 760               struct name *np;
 761
 762               if (allocated_length <= name_length + string_length)
 763                 {
 764                   do
 765                     {
 766                       allocated_length *= 2;
 767                       if (! allocated_length)
 768                         xalloc_die ();
 769                     }
 770                   while (allocated_length <= name_length + string_length);
 771
 772                   namebuf = xrealloc (namebuf, allocated_length + 1);
 773                 }
 774               strcpy (namebuf + name_length, string + 1);
 775               np = addname (namebuf, change_dir);
 776               add_hierarchy_to_namelist (np, device);
 777             }
 778         }
 779
 780       free (namebuf);
 781     }
 782 }
 783 \f
 784 /* Collect all the names from argv[] (or whatever), expand them into a
 785    directory tree, and sort them.  This gets only subdirectories, not
 786    all files.  */
 787
 788 void
 789 collect_and_sort_names (void)
 790 {
 791   struct name *name;
 792   struct name *next_name;
 793   int num_names;
 794   struct stat statbuf;
 795
 796   name_gather ();
 797
 798   if (listed_incremental_option)
 799     read_directory_file ();
 800
 801   if (!namelist)
 802     addname (".", 0);
 803
 804   for (name = namelist; name; name = next_name)
 805     {
 806       next_name = name->next;
 807       if (name->found_count || name->dir_contents)
 808         continue;
 809       if (name->matching_flags & EXCLUDE_WILDCARDS)
 810         /* NOTE: EXCLUDE_ANCHORED is not relevant here */
 811         /* FIXME: just skip regexps for now */
 812         continue;
 813       chdir_do (name->change_dir);
 814       if (name->name[0] == 0)
 815         continue;
 816
 817       if (deref_stat (dereference_option, name->name, &statbuf) != 0)
 818         {
 819           stat_diag (name->name);
 820           continue;
 821         }
 822       if (S_ISDIR (statbuf.st_mode))
 823         {
 824           name->found_count++;
 825           add_hierarchy_to_namelist (name, statbuf.st_dev);
 826         }
 827     }
 828
 829   num_names = 0;
 830   for (name = namelist; name; name = name->next)
 831     num_names++;
 832   namelist = merge_sort (namelist, num_names, compare_names);
 833
 834   for (name = namelist; name; name = name->next)
 835     name->found_count = 0;
 836
 837   if (listed_incremental_option)
 838     {
 839       for (name = namelist; name && name->name[0] == 0; name++)
 840         ;
 841       if (name)
 842         name->dir_contents = append_incremental_renames (name->dir_contents);
 843     }
 844 }
 845
 846 /* This is like name_match, except that
 847     1. It returns a pointer to the name it matched, and doesn't set FOUND
 848     in structure. The caller will have to do that if it wants to.
 849     2. If the namelist is empty, it returns null, unlike name_match, which
 850     returns TRUE. */
 851 struct name *
 852 name_scan (const char *file_name)
 853 {
 854   size_t length = strlen (file_name);
 855
 856   while (1)
 857     {
 858       struct name *cursor = namelist_match (file_name, length);
 859       if (cursor)
 860         return cursor;
 861
 862       /* Filename from archive not found in namelist.  If we have the whole
 863          namelist here, just return 0.  Otherwise, read the next name in and
 864          compare it.  If this was the last name, namelist->found_count will
 865          remain on.  If not, we loop to compare the newly read name.  */
 866
 867       if (same_order_option && namelist && namelist->found_count)
 868         {
 869           name_gather ();       /* read one more */
 870           if (namelist->found_count)
 871             return 0;
 872         }
 873       else
 874         return 0;
 875     }
 876 }
 877
 878 /* This returns a name from the namelist which doesn't have ->found
 879    set.  It sets ->found before returning, so successive calls will
 880    find and return all the non-found names in the namelist.  */
 881 struct name *gnu_list_name;
 882
 883 char *
 884 name_from_list (void)
 885 {
 886   if (!gnu_list_name)
 887     gnu_list_name = namelist;
 888   while (gnu_list_name
 889          && (gnu_list_name->found_count || gnu_list_name->name[0] == 0))
 890     gnu_list_name = gnu_list_name->next;
 891   if (gnu_list_name)
 892     {
 893       gnu_list_name->found_count++;
 894       chdir_do (gnu_list_name->change_dir);
 895       return gnu_list_name->name;
 896     }
 897   return 0;
 898 }
 899
 900 void
 901 blank_name_list (void)
 902 {
 903   struct name *name;
 904
 905   gnu_list_name = 0;
 906   for (name = namelist; name; name = name->next)
 907     name->found_count = 0;
 908 }
 909
 910 /* Yield a newly allocated file name consisting of FILE_NAME concatenated to
 911    NAME, with an intervening slash if FILE_NAME does not already end in one. */
 912 char *
 913 new_name (const char *file_name, const char *name)
 914 {
 915   size_t file_name_len = strlen (file_name);
 916   size_t namesize = strlen (name) + 1;
 917   int slash = file_name_len && ! ISSLASH (file_name[file_name_len - 1]);
 918   char *buffer = xmalloc (file_name_len + slash + namesize);
 919   memcpy (buffer, file_name, file_name_len);
 920   buffer[file_name_len] = '/';
 921   memcpy (buffer + file_name_len + slash, name, namesize);
 922   return buffer;
 923 }
 924
 925 /* Return nonzero if file NAME is excluded.  */
 926 bool
 927 excluded_name (char const *name)
 928 {
 929   return excluded_file_name (excluded, name + FILE_SYSTEM_PREFIX_LEN (name));
 930 }
 931 \f
 932 /* Names to avoid dumping.  */
 933 static Hash_table *avoided_name_table;
 934
 935 /* Remember to not archive NAME.  */
 936 void
 937 add_avoided_name (char const *name)
 938 {
 939   hash_string_insert (&avoided_name_table, name);
 940 }
 941
 942 /* Should NAME be avoided when archiving?  */
 943 bool
 944 is_avoided_name (char const *name)
 945 {
 946   return hash_string_lookup (avoided_name_table, name);
 947 }
 948
 949 \f
 950 static Hash_table *individual_file_table;
 951
 952 static void
 953 register_individual_file (char const *name)
 954 {
 955   struct stat st;
 956
 957   if (deref_stat (dereference_option, name, &st) != 0)
 958     return; /* Will be complained about later */
 959   if (S_ISDIR (st.st_mode))
 960     return;
 961
 962   hash_string_insert (&individual_file_table, name);
 963 }
 964
 965 bool
 966 is_individual_file (char const *name)
 967 {
 968   return hash_string_lookup (individual_file_table, name);
 969 }
 970
 971 \f
 972
 973 /* Return the size of the prefix of FILE_NAME that is removed after
 974    stripping NUM leading file name components.  NUM must be
 975    positive.  */
 976
 977 size_t
 978 stripped_prefix_len (char const *file_name, size_t num)
 979 {
 980   char const *p = file_name + FILE_SYSTEM_PREFIX_LEN (file_name);
 981   while (ISSLASH (*p))
 982     p++;
 983   while (*p)
 984     {
 985       bool slash = ISSLASH (*p);
 986       p++;
 987       if (slash)
 988         {
 989           if (--num == 0)
 990             return p - file_name;
 991           while (ISSLASH (*p))
 992             p++;
 993         }
 994     }
 995   return -1;
 996 }
 997 \f
 998 /* Return nonzero if NAME contains ".." as a file name component.  */
 999 bool
1000 contains_dot_dot (char const *name)
1001 {
1002   char const *p = name + FILE_SYSTEM_PREFIX_LEN (name);
1003
1004   for (;; p++)
1005     {
1006       if (p[0] == '.' && p[1] == '.' && (ISSLASH (p[2]) || !p[2]))
1007         return 1;
1008
1009       while (! ISSLASH (*p))
1010         {
1011           if (! *p++)
1012             return 0;
1013         }
1014     }
1015 }