]> Dogcows Code - chaz/tar/blob - src/names.c
6e251e3c159bd7d92b66efa323be8203024c64de
[chaz/tar] / 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, 2009 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 struct name *
183 make_name (const char *file_name)
184 {
185 struct name *p = xzalloc (sizeof (*p));
186 if (!file_name)
187 file_name = "";
188 p->name = xstrdup (file_name);
189 p->length = strlen (p->name);
190 return p;
191 }
192
193 void
194 free_name (struct name *p)
195 {
196 if (p)
197 {
198 free (p->name);
199 free (p->caname);
200 free (p);
201 }
202 }
203
204 \f
205 /* Names from the command call. */
206
207 static struct name *namelist; /* first name in list, if any */
208 static struct name **nametail = &namelist; /* end of name list */
209
210 /* File name arguments are processed in two stages: first a
211 name_array (see below) is filled, then the names from it
212 are moved into the namelist.
213
214 This awkward process is needed only to implement --same-order option,
215 which is meant to help process large archives on machines with
216 limited memory. With this option on, namelist contains at most one
217 entry, which diminishes the memory consumption.
218
219 However, I very much doubt if we still need this -- Sergey */
220
221 /* A name_array element contains entries of three types: */
222
223 #define NELT_NAME 0 /* File name */
224 #define NELT_CHDIR 1 /* Change directory request */
225 #define NELT_FMASK 2 /* Change fnmatch options request */
226
227 struct name_elt /* A name_array element. */
228 {
229 char type; /* Element type, see NELT_* constants above */
230 union
231 {
232 const char *name; /* File or directory name */
233 int matching_flags;/* fnmatch options if type == NELT_FMASK */
234 } v;
235 };
236
237 static struct name_elt *name_array; /* store an array of names */
238 static size_t allocated_names; /* how big is the array? */
239 static size_t names; /* how many entries does it have? */
240 static size_t name_index; /* how many of the entries have we scanned? */
241
242 /* Check the size of name_array, reallocating it as necessary. */
243 static void
244 check_name_alloc ()
245 {
246 if (names == allocated_names)
247 {
248 if (allocated_names == 0)
249 allocated_names = 10; /* Set initial allocation */
250 name_array = x2nrealloc (name_array, &allocated_names,
251 sizeof (name_array[0]));
252 }
253 }
254
255 /* Add to name_array the file NAME with fnmatch options MATCHING_FLAGS */
256 void
257 name_add_name (const char *name, int matching_flags)
258 {
259 static int prev_flags = 0; /* FIXME: Or EXCLUDE_ANCHORED? */
260 struct name_elt *ep;
261
262 check_name_alloc ();
263 ep = &name_array[names++];
264 if (prev_flags != matching_flags)
265 {
266 ep->type = NELT_FMASK;
267 ep->v.matching_flags = matching_flags;
268 prev_flags = matching_flags;
269 check_name_alloc ();
270 ep = &name_array[names++];
271 }
272 ep->type = NELT_NAME;
273 ep->v.name = name;
274 }
275
276 /* Add to name_array a chdir request for the directory NAME */
277 void
278 name_add_dir (const char *name)
279 {
280 struct name_elt *ep;
281 check_name_alloc ();
282 ep = &name_array[names++];
283 ep->type = NELT_CHDIR;
284 ep->v.name = name;
285 }
286
287 \f
288 /* Names from external name file. */
289
290 static char *name_buffer; /* buffer to hold the current file name */
291 static size_t name_buffer_length; /* allocated length of name_buffer */
292
293 /* Set up to gather file names for tar. They can either come from a
294 file or were saved from decoding arguments. */
295 void
296 name_init (void)
297 {
298 name_buffer = xmalloc (NAME_FIELD_SIZE + 2);
299 name_buffer_length = NAME_FIELD_SIZE;
300 }
301
302 void
303 name_term (void)
304 {
305 free (name_buffer);
306 free (name_array);
307 }
308
309 static int matching_flags; /* exclude_fnmatch options */
310
311 /* Get the next NELT_NAME element from name_array. Result is in
312 static storage and can't be relied upon across two calls.
313
314 If CHANGE_DIRS is true, treat any entries of type NELT_CHDIR as
315 the request to change to the given directory.
316
317 Entries of type NELT_FMASK cause updates of the matching_flags
318 value. */
319 struct name_elt *
320 name_next_elt (int change_dirs)
321 {
322 static struct name_elt entry;
323 const char *source;
324 char *cursor;
325
326 while (name_index != names)
327 {
328 struct name_elt *ep;
329 size_t source_len;
330
331 ep = &name_array[name_index++];
332 if (ep->type == NELT_FMASK)
333 {
334 matching_flags = ep->v.matching_flags;
335 continue;
336 }
337
338 source = ep->v.name;
339 source_len = strlen (source);
340 if (name_buffer_length < source_len)
341 {
342 do
343 {
344 name_buffer_length *= 2;
345 if (! name_buffer_length)
346 xalloc_die ();
347 }
348 while (name_buffer_length < source_len);
349
350 free (name_buffer);
351 name_buffer = xmalloc (name_buffer_length + 2);
352 }
353 strcpy (name_buffer, source);
354
355 /* Zap trailing slashes. */
356
357 cursor = name_buffer + strlen (name_buffer) - 1;
358 while (cursor > name_buffer && ISSLASH (*cursor))
359 *cursor-- = '\0';
360
361 if (change_dirs && ep->type == NELT_CHDIR)
362 {
363 if (chdir (name_buffer) < 0)
364 chdir_fatal (name_buffer);
365 }
366 else
367 {
368 if (unquote_option)
369 unquote_string (name_buffer);
370 if (incremental_option)
371 register_individual_file (name_buffer);
372 entry.type = ep->type;
373 entry.v.name = name_buffer;
374 return &entry;
375 }
376 }
377
378 return NULL;
379 }
380
381 const char *
382 name_next (int change_dirs)
383 {
384 struct name_elt *nelt = name_next_elt (change_dirs);
385 return nelt ? nelt->v.name : NULL;
386 }
387
388 /* Gather names in a list for scanning. Could hash them later if we
389 really care.
390
391 If the names are already sorted to match the archive, we just read
392 them one by one. name_gather reads the first one, and it is called
393 by name_match as appropriate to read the next ones. At EOF, the
394 last name read is just left in the buffer. This option lets users
395 of small machines extract an arbitrary number of files by doing
396 "tar t" and editing down the list of files. */
397
398 void
399 name_gather (void)
400 {
401 /* Buffer able to hold a single name. */
402 static struct name *buffer = NULL;
403
404 struct name_elt *ep;
405
406 if (same_order_option)
407 {
408 static int change_dir;
409
410 while ((ep = name_next_elt (0)) && ep->type == NELT_CHDIR)
411 change_dir = chdir_arg (xstrdup (ep->v.name));
412
413 if (ep)
414 {
415 free_name (buffer);
416 buffer = make_name (ep->v.name);
417 buffer->change_dir = change_dir;
418 buffer->next = 0;
419 buffer->found_count = 0;
420 buffer->matching_flags = matching_flags;
421 buffer->directory = NULL;
422 buffer->parent = NULL;
423 buffer->cmdline = true;
424
425 namelist = buffer;
426 nametail = &namelist->next;
427 }
428 else if (change_dir)
429 addname (0, change_dir, false, NULL);
430 }
431 else
432 {
433 /* Non sorted names -- read them all in. */
434 int change_dir = 0;
435
436 for (;;)
437 {
438 int change_dir0 = change_dir;
439 while ((ep = name_next_elt (0)) && ep->type == NELT_CHDIR)
440 change_dir = chdir_arg (xstrdup (ep->v.name));
441
442 if (ep)
443 addname (ep->v.name, change_dir, true, NULL);
444 else
445 {
446 if (change_dir != change_dir0)
447 addname (NULL, change_dir, false, NULL);
448 break;
449 }
450 }
451 }
452 }
453
454 /* Add a name to the namelist. */
455 struct name *
456 addname (char const *string, int change_dir, bool cmdline, struct name *parent)
457 {
458 struct name *name = make_name (string);
459
460 name->prev = *nametail;
461 name->next = NULL;
462 name->found_count = 0;
463 name->matching_flags = matching_flags;
464 name->change_dir = change_dir;
465 name->directory = NULL;
466 name->parent = parent;
467 name->cmdline = cmdline;
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 void
492 remname (struct name *name)
493 {
494 struct name *p;
495
496 if ((p = name->prev) != NULL)
497 p->next = name->next;
498 else
499 namelist = name->next;
500
501 if ((p = name->next) != NULL)
502 p->prev = name->prev;
503 else
504 nametail = &name->prev;
505 }
506
507 /* Return true if and only if name FILE_NAME (from an archive) matches any
508 name from the namelist. */
509 bool
510 name_match (const char *file_name)
511 {
512 size_t length = strlen (file_name);
513
514 while (1)
515 {
516 struct name *cursor = namelist;
517
518 if (!cursor)
519 return true;
520
521 if (cursor->name[0] == 0)
522 {
523 chdir_do (cursor->change_dir);
524 namelist = 0;
525 nametail = &namelist;
526 return true;
527 }
528
529 cursor = namelist_match (file_name, length);
530 if (cursor)
531 {
532 if (!(ISSLASH (file_name[cursor->length]) && recursion_option)
533 || cursor->found_count == 0)
534 cursor->found_count++; /* remember it matched */
535 if (starting_file_option)
536 {
537 free (namelist);
538 namelist = 0;
539 nametail = &namelist;
540 }
541 chdir_do (cursor->change_dir);
542
543 /* We got a match. */
544 return ISFOUND (cursor);
545 }
546
547 /* Filename from archive not found in namelist. If we have the whole
548 namelist here, just return 0. Otherwise, read the next name in and
549 compare it. If this was the last name, namelist->found_count will
550 remain on. If not, we loop to compare the newly read name. */
551
552 if (same_order_option && namelist->found_count)
553 {
554 name_gather (); /* read one more */
555 if (namelist->found_count)
556 return false;
557 }
558 else
559 return false;
560 }
561 }
562
563 /* Returns true if all names from the namelist were processed.
564 P is the stat_info of the most recently processed entry.
565 The decision is postponed until the next entry is read if:
566
567 1) P ended with a slash (i.e. it was a directory)
568 2) P matches any entry from the namelist *and* represents a subdirectory
569 or a file lying under this entry (in the terms of directory structure).
570
571 This is necessary to handle contents of directories. */
572 bool
573 all_names_found (struct tar_stat_info *p)
574 {
575 struct name const *cursor;
576 size_t len;
577
578 if (test_label_option)
579 return true;
580 if (!p->file_name || occurrence_option == 0 || p->had_trailing_slash)
581 return false;
582 len = strlen (p->file_name);
583 for (cursor = namelist; cursor; cursor = cursor->next)
584 {
585 if ((cursor->name[0] && !WASFOUND (cursor))
586 || (len >= cursor->length && ISSLASH (p->file_name[cursor->length])))
587 return false;
588 }
589 return true;
590 }
591
592 static void
593 regex_usage_warning (const char *name)
594 {
595 static int warned_once = 0;
596
597 if (warn_regex_usage && fnmatch_pattern_has_wildcards (name, 0))
598 {
599 warned_once = 1;
600 WARN ((0, 0,
601 /* TRANSLATORS: The following three msgids form a single sentence.
602 */
603 _("Pattern matching characters used in file names. Please,")));
604 WARN ((0, 0,
605 _("use --wildcards to enable pattern matching, or --no-wildcards to")));
606 WARN ((0, 0,
607 _("suppress this warning.")));
608 }
609 }
610
611 /* Print the names of things in the namelist that were not matched. */
612 void
613 names_notfound (void)
614 {
615 struct name const *cursor;
616
617 for (cursor = namelist; cursor; cursor = cursor->next)
618 if (!WASFOUND (cursor) && cursor->name[0])
619 {
620 regex_usage_warning (cursor->name);
621 if (cursor->found_count == 0)
622 ERROR ((0, 0, _("%s: Not found in archive"),
623 quotearg_colon (cursor->name)));
624 else
625 ERROR ((0, 0, _("%s: Required occurrence not found in archive"),
626 quotearg_colon (cursor->name)));
627 }
628
629 /* Don't bother freeing the name list; we're about to exit. */
630 namelist = 0;
631 nametail = &namelist;
632
633 if (same_order_option)
634 {
635 const char *name;
636
637 while ((name = name_next (1)) != NULL)
638 {
639 regex_usage_warning (name);
640 ERROR ((0, 0, _("%s: Not found in archive"),
641 quotearg_colon (name)));
642 }
643 }
644 }
645 \f
646 /* Sorting name lists. */
647
648 /* Sort *singly* linked LIST of names, of given LENGTH, using COMPARE
649 to order names. Return the sorted list. Note that after calling
650 this function, the `prev' links in list elements are messed up.
651
652 Apart from the type `struct name' and the definition of SUCCESSOR,
653 this is a generic list-sorting function, but it's too painful to
654 make it both generic and portable
655 in C. */
656
657 static struct name *
658 merge_sort_sll (struct name *list, int length,
659 int (*compare) (struct name const*, struct name const*))
660 {
661 struct name *first_list;
662 struct name *second_list;
663 int first_length;
664 int second_length;
665 struct name *result;
666 struct name **merge_point;
667 struct name *cursor;
668 int counter;
669
670 # define SUCCESSOR(name) ((name)->next)
671
672 if (length == 1)
673 return list;
674
675 if (length == 2)
676 {
677 if ((*compare) (list, SUCCESSOR (list)) > 0)
678 {
679 result = SUCCESSOR (list);
680 SUCCESSOR (result) = list;
681 SUCCESSOR (list) = 0;
682 return result;
683 }
684 return list;
685 }
686
687 first_list = list;
688 first_length = (length + 1) / 2;
689 second_length = length / 2;
690 for (cursor = list, counter = first_length - 1;
691 counter;
692 cursor = SUCCESSOR (cursor), counter--)
693 continue;
694 second_list = SUCCESSOR (cursor);
695 SUCCESSOR (cursor) = 0;
696
697 first_list = merge_sort_sll (first_list, first_length, compare);
698 second_list = merge_sort_sll (second_list, second_length, compare);
699
700 merge_point = &result;
701 while (first_list && second_list)
702 if ((*compare) (first_list, second_list) < 0)
703 {
704 cursor = SUCCESSOR (first_list);
705 *merge_point = first_list;
706 merge_point = &SUCCESSOR (first_list);
707 first_list = cursor;
708 }
709 else
710 {
711 cursor = SUCCESSOR (second_list);
712 *merge_point = second_list;
713 merge_point = &SUCCESSOR (second_list);
714 second_list = cursor;
715 }
716 if (first_list)
717 *merge_point = first_list;
718 else
719 *merge_point = second_list;
720
721 return result;
722
723 #undef SUCCESSOR
724 }
725
726 /* Sort doubly linked LIST of names, of given LENGTH, using COMPARE
727 to order names. Return the sorted list. */
728 static struct name *
729 merge_sort (struct name *list, int length,
730 int (*compare) (struct name const*, struct name const*))
731 {
732 struct name *head, *p, *prev;
733 head = merge_sort_sll (list, length, compare);
734 /* Fixup prev pointers */
735 for (prev = NULL, p = head; p; prev = p, p = p->next)
736 p->prev = prev;
737 return head;
738 }
739
740 /* A comparison function for sorting names. Put found names last;
741 break ties by string comparison. */
742
743 static int
744 compare_names_found (struct name const *n1, struct name const *n2)
745 {
746 int found_diff = WASFOUND (n2) - WASFOUND (n1);
747 return found_diff ? found_diff : strcmp (n1->name, n2->name);
748 }
749
750 /* Simple comparison by names. */
751 static int
752 compare_names (struct name const *n1, struct name const *n2)
753 {
754 return strcmp (n1->name, n2->name);
755 }
756
757 \f
758 /* Add all the dirs under NAME, which names a directory, to the namelist.
759 If any of the files is a directory, recurse on the subdirectory.
760 DEVICE is the device not to leave, if the -l option is specified.
761 CMDLINE is true, if the NAME appeared on the command line. */
762
763 static void
764 add_hierarchy_to_namelist (struct name *name, dev_t device, bool cmdline)
765 {
766 const char *buffer;
767
768 name_fill_directory (name, device, cmdline);
769 buffer = directory_contents (name->directory);
770 if (buffer)
771 {
772 struct name *child_head = NULL, *child_tail = NULL;
773 size_t name_length = name->length;
774 size_t allocated_length = (name_length >= NAME_FIELD_SIZE
775 ? name_length + NAME_FIELD_SIZE
776 : NAME_FIELD_SIZE);
777 char *namebuf = xmalloc (allocated_length + 1);
778 /* FIXME: + 2 above? */
779 const char *string;
780 size_t string_length;
781 int change_dir = name->change_dir;
782
783 strcpy (namebuf, name->name);
784 if (! ISSLASH (namebuf[name_length - 1]))
785 {
786 namebuf[name_length++] = '/';
787 namebuf[name_length] = '\0';
788 }
789
790 for (string = buffer; *string; string += string_length + 1)
791 {
792 string_length = strlen (string);
793 if (*string == 'D')
794 {
795 struct name *np;
796
797 if (allocated_length <= name_length + string_length)
798 {
799 do
800 {
801 allocated_length *= 2;
802 if (! allocated_length)
803 xalloc_die ();
804 }
805 while (allocated_length <= name_length + string_length);
806
807 namebuf = xrealloc (namebuf, allocated_length + 1);
808 }
809 strcpy (namebuf + name_length, string + 1);
810 np = addname (namebuf, change_dir, false, name);
811 if (!child_head)
812 child_head = np;
813 else
814 child_tail->sibling = np;
815 child_tail = np;
816 add_hierarchy_to_namelist (np, device, false);
817 }
818 }
819
820 free (namebuf);
821 name->child = child_head;
822 }
823 }
824 \f
825 /* Auxiliary functions for hashed table of struct name's. */
826
827 static size_t
828 name_hash (void const *entry, size_t n_buckets)
829 {
830 struct name const *name = entry;
831 return hash_string (name->caname, n_buckets);
832 }
833
834 /* Compare two directories for equality of their names. */
835 static bool
836 name_compare (void const *entry1, void const *entry2)
837 {
838 struct name const *name1 = entry1;
839 struct name const *name2 = entry2;
840 return strcmp (name1->caname, name2->caname) == 0;
841 }
842
843 \f
844 /* Rebase `name' member of CHILD and all its siblings to
845 the new PARENT. */
846 static void
847 rebase_child_list (struct name *child, struct name *parent)
848 {
849 size_t old_prefix_len = child->parent->length;
850 size_t new_prefix_len = parent->length;
851 char *new_prefix = parent->name;
852
853 for (; child; child = child->sibling)
854 {
855 size_t size = child->length - old_prefix_len + new_prefix_len;
856 char *newp = xmalloc (size + 1);
857 strcpy (newp, new_prefix);
858 strcat (newp, child->name + old_prefix_len);
859 free (child->name);
860 child->name = newp;
861 child->length = size;
862
863 rebase_directory (child->directory,
864 child->parent->name, old_prefix_len,
865 new_prefix, new_prefix_len);
866 }
867 }
868
869 /* Collect all the names from argv[] (or whatever), expand them into a
870 directory tree, and sort them. This gets only subdirectories, not
871 all files. */
872
873 void
874 collect_and_sort_names (void)
875 {
876 struct name *name;
877 struct name *next_name, *prev_name;
878 int num_names;
879 struct stat statbuf;
880 Hash_table *nametab;
881
882 name_gather ();
883
884 if (!namelist)
885 addname (".", 0, false, NULL);
886
887 if (listed_incremental_option)
888 {
889 switch (chdir_count ())
890 {
891 case 0:
892 break;
893
894 case 1:
895 if (namelist->change_dir == 0)
896 USAGE_ERROR ((0, 0,
897 _("Using -C option inside file list is not "
898 "allowed with --listed-incremental")));
899 break;
900
901 default:
902 USAGE_ERROR ((0, 0,
903 _("Only one -C option is allowed with "
904 "--listed-incremental")));
905 }
906 chdir_do (namelist->change_dir);
907 read_directory_file ();
908 }
909
910 num_names = 0;
911 for (name = namelist; name; name = name->next, num_names++)
912 {
913 if (name->found_count || name->directory)
914 continue;
915 if (name->matching_flags & EXCLUDE_WILDCARDS)
916 /* NOTE: EXCLUDE_ANCHORED is not relevant here */
917 /* FIXME: just skip regexps for now */
918 continue;
919 chdir_do (name->change_dir);
920
921 if (name->name[0] == 0)
922 continue;
923
924 if (deref_stat (dereference_option, name->name, &statbuf) != 0)
925 {
926 stat_diag (name->name);
927 continue;
928 }
929 if (S_ISDIR (statbuf.st_mode))
930 {
931 name->found_count++;
932 add_hierarchy_to_namelist (name, statbuf.st_dev, true);
933 }
934 }
935
936 namelist = merge_sort (namelist, num_names, compare_names);
937
938 num_names = 0;
939 nametab = hash_initialize (0, 0,
940 name_hash,
941 name_compare, NULL);
942 for (name = namelist; name; name = next_name)
943 {
944 next_name = name->next;
945 name->caname = normalize_filename (name->name);
946 if (prev_name)
947 {
948 struct name *p = hash_lookup (nametab, name);
949 if (p)
950 {
951 /* Keep the one listed in the command line */
952 if (!name->parent)
953 {
954 if (p->child)
955 rebase_child_list (p->child, name);
956 /* FIXME: remove_directory (p->caname); ? */
957 remname (p);
958 free_name (p);
959 num_names--;
960 }
961 else
962 {
963 if (name->child)
964 rebase_child_list (name->child, p);
965 /* FIXME: remove_directory (name->caname); ? */
966 remname (name);
967 free_name (name);
968 continue;
969 }
970 }
971 }
972 name->found_count = 0;
973 if (!hash_insert (nametab, name))
974 xalloc_die ();
975 prev_name = name;
976 num_names++;
977 }
978 nametail = &prev_name;
979 hash_free (nametab);
980
981 namelist = merge_sort (namelist, num_names, compare_names_found);
982
983 if (listed_incremental_option)
984 {
985 for (name = namelist; name && name->name[0] == 0; name++)
986 ;
987 if (name)
988 append_incremental_renames (name->directory);
989 }
990 }
991
992 /* This is like name_match, except that
993 1. It returns a pointer to the name it matched, and doesn't set FOUND
994 in structure. The caller will have to do that if it wants to.
995 2. If the namelist is empty, it returns null, unlike name_match, which
996 returns TRUE. */
997 struct name *
998 name_scan (const char *file_name)
999 {
1000 size_t length = strlen (file_name);
1001
1002 while (1)
1003 {
1004 struct name *cursor = namelist_match (file_name, length);
1005 if (cursor)
1006 return cursor;
1007
1008 /* Filename from archive not found in namelist. If we have the whole
1009 namelist here, just return 0. Otherwise, read the next name in and
1010 compare it. If this was the last name, namelist->found_count will
1011 remain on. If not, we loop to compare the newly read name. */
1012
1013 if (same_order_option && namelist && namelist->found_count)
1014 {
1015 name_gather (); /* read one more */
1016 if (namelist->found_count)
1017 return 0;
1018 }
1019 else
1020 return 0;
1021 }
1022 }
1023
1024 /* This returns a name from the namelist which doesn't have ->found
1025 set. It sets ->found before returning, so successive calls will
1026 find and return all the non-found names in the namelist. */
1027 struct name *gnu_list_name;
1028
1029 struct name const *
1030 name_from_list ()
1031 {
1032 if (!gnu_list_name)
1033 gnu_list_name = namelist;
1034 while (gnu_list_name
1035 && (gnu_list_name->found_count || gnu_list_name->name[0] == 0))
1036 gnu_list_name = gnu_list_name->next;
1037 if (gnu_list_name)
1038 {
1039 gnu_list_name->found_count++;
1040 chdir_do (gnu_list_name->change_dir);
1041 return gnu_list_name;
1042 }
1043 return NULL;
1044 }
1045
1046 void
1047 blank_name_list (void)
1048 {
1049 struct name *name;
1050
1051 gnu_list_name = 0;
1052 for (name = namelist; name; name = name->next)
1053 name->found_count = 0;
1054 }
1055
1056 /* Yield a newly allocated file name consisting of FILE_NAME concatenated to
1057 NAME, with an intervening slash if FILE_NAME does not already end in one. */
1058 char *
1059 new_name (const char *file_name, const char *name)
1060 {
1061 size_t file_name_len = strlen (file_name);
1062 size_t namesize = strlen (name) + 1;
1063 int slash = file_name_len && ! ISSLASH (file_name[file_name_len - 1]);
1064 char *buffer = xmalloc (file_name_len + slash + namesize);
1065 memcpy (buffer, file_name, file_name_len);
1066 buffer[file_name_len] = '/';
1067 memcpy (buffer + file_name_len + slash, name, namesize);
1068 return buffer;
1069 }
1070
1071 /* Return nonzero if file NAME is excluded. */
1072 bool
1073 excluded_name (char const *name)
1074 {
1075 return excluded_file_name (excluded, name + FILE_SYSTEM_PREFIX_LEN (name));
1076 }
1077 \f
1078 /* Names to avoid dumping. */
1079 static Hash_table *avoided_name_table;
1080
1081 /* Remember to not archive NAME. */
1082 void
1083 add_avoided_name (char const *name)
1084 {
1085 hash_string_insert (&avoided_name_table, name);
1086 }
1087
1088 /* Should NAME be avoided when archiving? */
1089 bool
1090 is_avoided_name (char const *name)
1091 {
1092 return hash_string_lookup (avoided_name_table, name);
1093 }
1094
1095 \f
1096 static Hash_table *individual_file_table;
1097
1098 static void
1099 register_individual_file (char const *name)
1100 {
1101 struct stat st;
1102
1103 if (deref_stat (dereference_option, name, &st) != 0)
1104 return; /* Will be complained about later */
1105 if (S_ISDIR (st.st_mode))
1106 return;
1107
1108 hash_string_insert (&individual_file_table, name);
1109 }
1110
1111 bool
1112 is_individual_file (char const *name)
1113 {
1114 return hash_string_lookup (individual_file_table, name);
1115 }
1116
1117 \f
1118
1119 /* Return the size of the prefix of FILE_NAME that is removed after
1120 stripping NUM leading file name components. NUM must be
1121 positive. */
1122
1123 size_t
1124 stripped_prefix_len (char const *file_name, size_t num)
1125 {
1126 char const *p = file_name + FILE_SYSTEM_PREFIX_LEN (file_name);
1127 while (ISSLASH (*p))
1128 p++;
1129 while (*p)
1130 {
1131 bool slash = ISSLASH (*p);
1132 p++;
1133 if (slash)
1134 {
1135 if (--num == 0)
1136 return p - file_name;
1137 while (ISSLASH (*p))
1138 p++;
1139 }
1140 }
1141 return -1;
1142 }
1143 \f
1144 /* Return nonzero if NAME contains ".." as a file name component. */
1145 bool
1146 contains_dot_dot (char const *name)
1147 {
1148 char const *p = name + FILE_SYSTEM_PREFIX_LEN (name);
1149
1150 for (;; p++)
1151 {
1152 if (p[0] == '.' && p[1] == '.' && (ISSLASH (p[2]) || !p[2]))
1153 return 1;
1154
1155 while (! ISSLASH (*p))
1156 {
1157 if (! *p++)
1158 return 0;
1159 }
1160 }
1161 }
This page took 0.091639 seconds and 4 git commands to generate.