1 /* GNU dump extensions to tar.
3 Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
4 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
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
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.
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. */
25 /* Incremental dump specialities. */
27 /* Which child files to save under a directory. */
35 #define DIRF_INIT 0x0001 /* directory structure is initialized
36 (procdir called at least once) */
37 #define DIRF_NFS 0x0002 /* directory is mounted on nfs */
38 #define DIRF_FOUND 0x0004 /* directory is found on fs */
39 #define DIRF_NEW 0x0008 /* directory is new (not found
40 in the previous dump) */
41 #define DIRF_RENAMED 0x0010 /* directory is renamed */
43 #define DIR_IS_INITED(d) ((d)->flags & DIRF_INIT)
44 #define DIR_IS_NFS(d) ((d)->flags & DIRF_NFS)
45 #define DIR_IS_FOUND(d) ((d)->flags & DIRF_FOUND)
46 #define DIR_IS_NEW(d) ((d)->flags & DIRF_NEW)
47 #define DIR_IS_RENAMED(d) ((d)->flags & DIRF_RENAMED)
49 #define DIR_SET_FLAG(d,f) (d)->flags |= (f)
50 #define DIR_CLEAR_FLAG(d,f) (d)->flags &= ~(f)
52 struct dumpdir
/* Dump directory listing */
54 char *contents
; /* Actual contents */
55 size_t total
; /* Total number of elements */
56 size_t elc
; /* Number of D/N/Y elements. */
57 char **elv
; /* Array of D/N/Y elements */
60 /* Directory attributes. */
63 struct directory
*next
;
64 struct timespec mtime
; /* Modification time */
65 dev_t device_number
; /* device number for directory */
66 ino_t inode_number
; /* inode number for directory */
67 struct dumpdir
*dump
; /* Directory contents */
68 struct dumpdir
*idump
; /* Initial contents if the directory was
70 enum children children
; /* What to save under this directory */
71 unsigned flags
; /* See DIRF_ macros above */
72 struct directory
*orig
; /* If the directory was renamed, points to
73 the original directory structure */
74 const char *tagfile
; /* Tag file, if the directory falls under
75 exclusion_tag_under */
76 char *caname
; /* canonical name */
77 char *name
; /* file name of directory */
81 dumpdir_create0 (const char *contents
, const char *cmask
)
84 size_t i
, total
, ctsize
, len
;
88 for (i
= 0, total
= 0, ctsize
= 1, q
= contents
; *q
; total
++, q
+= len
)
92 if (!cmask
|| strchr (cmask
, *q
))
95 dump
= xmalloc (sizeof (*dump
) + ctsize
);
96 dump
->contents
= (char*)(dump
+ 1);
97 memcpy (dump
->contents
, contents
, ctsize
);
100 dump
->elv
= xcalloc (i
+ 1, sizeof (dump
->elv
[0]));
102 for (i
= 0, p
= dump
->contents
; *p
; p
+= strlen (p
) + 1)
104 if (!cmask
|| strchr (cmask
, *p
))
105 dump
->elv
[i
++] = p
+ 1;
112 dumpdir_create (const char *contents
)
114 return dumpdir_create0 (contents
, "YND");
118 dumpdir_free (struct dumpdir
*dump
)
125 compare_dirnames (const void *first
, const void *second
)
127 char const *const *name1
= first
;
128 char const *const *name2
= second
;
129 return strcmp (*name1
, *name2
);
132 /* Locate NAME in the dumpdir array DUMP.
133 Return pointer to the slot in DUMP->contents, or NULL if not found */
135 dumpdir_locate (struct dumpdir
*dump
, const char *name
)
141 ptr
= bsearch (&name
, dump
->elv
, dump
->elc
, sizeof (dump
->elv
[0]),
143 return ptr
? *ptr
- 1: NULL
;
148 struct dumpdir
*dump
; /* Dumpdir being iterated */
149 int all
; /* Iterate over all entries, not only D/N/Y */
150 size_t next
; /* Index of the next element */
154 dumpdir_next (struct dumpdir_iter
*itr
)
156 size_t cur
= itr
->next
;
161 ret
= itr
->dump
->contents
+ cur
;
164 itr
->next
+= strlen (ret
) + 1;
166 else if (cur
< itr
->dump
->elc
)
168 ret
= itr
->dump
->elv
[cur
] - 1;
176 dumpdir_first (struct dumpdir
*dump
, int all
, struct dumpdir_iter
**pitr
)
178 struct dumpdir_iter
*itr
= xmalloc (sizeof (*itr
));
183 return dumpdir_next (itr
);
186 /* Return size in bytes of the dumpdir array P */
188 dumpdir_size (const char *p
)
194 size_t size
= strlen (p
) + 1;
202 static struct directory
*dirhead
, *dirtail
;
203 static Hash_table
*directory_table
;
204 static Hash_table
*directory_meta_table
;
206 #if HAVE_ST_FSTYPE_STRING
207 static char const nfs_string
[] = "nfs";
208 # define NFS_FILE_STAT(st) (strcmp ((st).st_fstype, nfs_string) == 0)
210 # define ST_DEV_MSB(st) (~ (dev_t) 0 << (sizeof (st).st_dev * CHAR_BIT - 1))
211 # define NFS_FILE_STAT(st) (((st).st_dev & ST_DEV_MSB (st)) != 0)
214 /* Calculate the hash of a directory. */
216 hash_directory_canonical_name (void const *entry
, size_t n_buckets
)
218 struct directory
const *directory
= entry
;
219 return hash_string (directory
->caname
, n_buckets
);
222 /* Compare two directories for equality of their names. */
224 compare_directory_canonical_names (void const *entry1
, void const *entry2
)
226 struct directory
const *directory1
= entry1
;
227 struct directory
const *directory2
= entry2
;
228 return strcmp (directory1
->caname
, directory2
->caname
) == 0;
232 hash_directory_meta (void const *entry
, size_t n_buckets
)
234 struct directory
const *directory
= entry
;
235 /* FIXME: Work out a better algorytm */
236 return (directory
->device_number
+ directory
->inode_number
) % n_buckets
;
239 /* Compare two directories for equality of their device and inode numbers. */
241 compare_directory_meta (void const *entry1
, void const *entry2
)
243 struct directory
const *directory1
= entry1
;
244 struct directory
const *directory2
= entry2
;
245 return directory1
->device_number
== directory2
->device_number
246 && directory1
->inode_number
== directory2
->inode_number
;
249 /* Make a directory entry for given relative NAME and canonical name CANAME.
250 The latter is "stolen", i.e. the returned directory contains pointer to
252 static struct directory
*
253 make_directory (const char *name
, char *caname
)
255 size_t namelen
= strlen (name
);
256 struct directory
*directory
= xmalloc (sizeof (*directory
));
257 directory
->next
= NULL
;
258 directory
->dump
= directory
->idump
= NULL
;
259 directory
->orig
= NULL
;
260 directory
->flags
= false;
261 if (namelen
&& ISSLASH (name
[namelen
- 1]))
263 directory
->name
= xmalloc (namelen
+ 1);
264 memcpy (directory
->name
, name
, namelen
);
265 directory
->name
[namelen
] = 0;
266 directory
->caname
= caname
;
267 directory
->tagfile
= NULL
;
272 free_directory (struct directory
*dir
)
279 static struct directory
*
280 attach_directory (const char *name
)
282 char *cname
= normalize_filename (name
);
283 struct directory
*dir
= make_directory (name
, cname
);
294 replace_prefix (char **pname
, const char *samp
, size_t slen
,
295 const char *repl
, size_t rlen
)
298 size_t nlen
= strlen (name
);
299 if (nlen
> slen
&& memcmp (name
, samp
, slen
) == 0 && ISSLASH (name
[slen
]))
303 name
= xrealloc (name
, nlen
- slen
+ rlen
+ 1);
306 memmove (name
+ rlen
, name
+ slen
, nlen
- slen
+ 1);
307 memcpy (name
, repl
, rlen
);
312 dirlist_replace_prefix (const char *pref
, const char *repl
)
314 struct directory
*dp
;
315 size_t pref_len
= strlen (pref
);
316 size_t repl_len
= strlen (repl
);
317 for (dp
= dirhead
; dp
; dp
= dp
->next
)
318 replace_prefix (&dp
->name
, pref
, pref_len
, repl
, repl_len
);
321 /* Create and link a new directory entry for directory NAME, having a
322 device number DEV and an inode number INO, with NFS indicating
323 whether it is an NFS device and FOUND indicating whether we have
324 found that the directory exists. */
325 static struct directory
*
326 note_directory (char const *name
, struct timespec mtime
,
327 dev_t dev
, ino_t ino
, bool nfs
, bool found
,
328 const char *contents
)
330 struct directory
*directory
= attach_directory (name
);
332 directory
->mtime
= mtime
;
333 directory
->device_number
= dev
;
334 directory
->inode_number
= ino
;
335 directory
->children
= CHANGED_CHILDREN
;
337 DIR_SET_FLAG (directory
, DIRF_NFS
);
339 DIR_SET_FLAG (directory
, DIRF_FOUND
);
341 directory
->dump
= dumpdir_create (contents
);
343 directory
->dump
= NULL
;
345 if (! ((directory_table
346 || (directory_table
= hash_initialize (0, 0,
347 hash_directory_canonical_name
,
348 compare_directory_canonical_names
, 0)))
349 && hash_insert (directory_table
, directory
)))
352 if (! ((directory_meta_table
353 || (directory_meta_table
= hash_initialize (0, 0,
355 compare_directory_meta
,
357 && hash_insert (directory_meta_table
, directory
)))
363 /* Return a directory entry for a given file NAME, or zero if none found. */
364 static struct directory
*
365 find_directory (const char *name
)
367 if (! directory_table
)
371 char *caname
= normalize_filename (name
);
372 struct directory
*dir
= make_directory (name
, caname
);
373 struct directory
*ret
= hash_lookup (directory_table
, dir
);
374 free_directory (dir
);
380 /* Remove directory entry for the given CANAME */
382 remove_directory (const char *caname
)
384 struct directory
*dir
= make_directory (caname
, xstrdup (caname
));
385 struct directory
*ret
= hash_delete (directory_table
, dir
);
387 free_directory (ret
);
388 free_directory (dir
);
392 /* Find a directory entry for NAME. If first OLD_PREFIX_LEN
393 bytes of its name match OLD_PREFIX, replace them with
396 rebase_directory (const char *name
, size_t old_prefix_len
,
397 const char *old_prefix
,
398 const char *new_prefix
)
400 struct directory
*dir
= find_directory (name
);
403 size_t len
= strlen (dir
->name
);
404 if (len
> old_prefix_len
405 && memcmp (dir
->name
, old_prefix
, old_prefix_len
) == 0)
407 char *newp
= xmalloc (len
- old_prefix_len
+ strlen (new_prefix
));
408 strcpy (newp
, new_prefix
);
409 strcat (newp
, dir
->name
+ old_prefix_len
);
416 /* Return a directory entry for a given combination of device and inode
417 numbers, or zero if none found. */
418 static struct directory
*
419 find_directory_meta (dev_t dev
, ino_t ino
)
421 if (! directory_meta_table
)
425 struct directory
*dir
= make_directory ("", NULL
);
426 struct directory
*ret
;
427 dir
->device_number
= dev
;
428 dir
->inode_number
= ino
;
429 ret
= hash_lookup (directory_meta_table
, dir
);
430 free_directory (dir
);
436 update_parent_directory (const char *name
)
438 struct directory
*directory
;
442 directory
= find_directory (p
);
446 if (deref_stat (dereference_option
, p
, &st
) != 0)
449 directory
->mtime
= get_stat_mtime (&st
);
454 #define PD_FORCE_CHILDREN 0x10
455 #define PD_FORCE_INIT 0x20
456 #define PD_CHILDREN(f) ((f) & 3)
458 static struct directory
*
459 procdir (const char *name_buffer
, struct stat
*stat_data
,
464 struct directory
*directory
;
465 bool nfs
= NFS_FILE_STAT (*stat_data
);
467 if ((directory
= find_directory (name_buffer
)) != NULL
)
469 if (DIR_IS_INITED (directory
))
471 if (flag
& PD_FORCE_INIT
)
473 assign_string (&directory
->name
, name_buffer
);
477 *entry
= 'N'; /* Avoid duplicating this directory */
482 if (strcmp (directory
->name
, name_buffer
))
488 /* With NFS, the same file can have two different devices
489 if an NFS directory is mounted in multiple locations,
490 which is relatively common when automounting.
491 To avoid spurious incremental redumping of
492 directories, consider all NFS devices as equal,
493 relying on the i-node to establish differences. */
495 if (! ((!check_device_option
496 || (DIR_IS_NFS (directory
) && nfs
)
497 || directory
->device_number
== stat_data
->st_dev
)
498 && directory
->inode_number
== stat_data
->st_ino
))
500 /* FIXME: find_directory_meta ignores nfs */
501 struct directory
*d
= find_directory_meta (stat_data
->st_dev
,
505 if (strcmp (d
->name
, name_buffer
))
507 WARNOPT (WARN_RENAME_DIRECTORY
,
509 _("%s: Directory has been renamed from %s"),
510 quotearg_colon (name_buffer
),
511 quote_n (1, d
->name
)));
513 DIR_SET_FLAG (directory
, DIRF_RENAMED
);
514 dirlist_replace_prefix (d
->name
, name_buffer
);
516 directory
->children
= CHANGED_CHILDREN
;
520 WARNOPT (WARN_RENAME_DIRECTORY
,
521 (0, 0, _("%s: Directory has been renamed"),
522 quotearg_colon (name_buffer
)));
523 directory
->children
= ALL_CHILDREN
;
524 directory
->device_number
= stat_data
->st_dev
;
525 directory
->inode_number
= stat_data
->st_ino
;
528 DIR_SET_FLAG (directory
, DIRF_NFS
);
531 directory
->children
= CHANGED_CHILDREN
;
533 DIR_SET_FLAG (directory
, DIRF_FOUND
);
537 struct directory
*d
= find_directory_meta (stat_data
->st_dev
,
540 directory
= note_directory (name_buffer
,
541 get_stat_mtime(stat_data
),
550 if (strcmp (d
->name
, name_buffer
))
552 WARNOPT (WARN_RENAME_DIRECTORY
,
553 (0, 0, _("%s: Directory has been renamed from %s"),
554 quotearg_colon (name_buffer
),
555 quote_n (1, d
->name
)));
557 DIR_SET_FLAG (directory
, DIRF_RENAMED
);
558 dirlist_replace_prefix (d
->name
, name_buffer
);
560 directory
->children
= CHANGED_CHILDREN
;
564 DIR_SET_FLAG (directory
, DIRF_NEW
);
565 WARNOPT (WARN_NEW_DIRECTORY
,
566 (0, 0, _("%s: Directory is new"),
567 quotearg_colon (name_buffer
)));
568 directory
->children
=
569 (listed_incremental_option
570 || (OLDER_STAT_TIME (*stat_data
, m
)
571 || (after_date_option
572 && OLDER_STAT_TIME (*stat_data
, c
))))
578 /* If the directory is on another device and --one-file-system was given,
580 if (one_file_system_option
&& device
!= stat_data
->st_dev
581 /* ... except if it was explicitely given in the command line */
582 && !is_individual_file (name_buffer
))
583 directory
->children
= NO_CHILDREN
;
584 else if (flag
& PD_FORCE_CHILDREN
)
586 directory
->children
= PD_CHILDREN(flag
);
587 if (directory
->children
== NO_CHILDREN
)
591 DIR_SET_FLAG (directory
, DIRF_INIT
);
593 if (directory
->children
!= NO_CHILDREN
)
595 const char *tag_file_name
;
597 switch (check_exclusion_tags (name_buffer
, &tag_file_name
))
599 case exclusion_tag_all
:
600 /* This warning can be duplicated by code in dump_file0, but only
601 in case when the topmost directory being archived contains
603 exclusion_tag_warning (name_buffer
, tag_file_name
,
604 _("directory not dumped"));
606 directory
->children
= NO_CHILDREN
;
609 case exclusion_tag_contents
:
610 exclusion_tag_warning (name_buffer
, tag_file_name
,
611 _("contents not dumped"));
612 directory
->children
= NO_CHILDREN
;
615 case exclusion_tag_under
:
616 exclusion_tag_warning (name_buffer
, tag_file_name
,
617 _("contents not dumped"));
618 directory
->tagfile
= tag_file_name
;
621 case exclusion_tag_none
:
629 /* Compare dumpdir array from DIRECTORY with directory listing DIR and
630 build a new dumpdir template.
632 DIR must be returned by a previous call to savedir().
634 File names in DIRECTORY->dump->contents must be sorted
637 DIRECTORY->dump is replaced with the created template. Each entry is
638 prefixed with ' ' if it was present in DUMP and with 'Y' otherwise. */
641 makedumpdir (struct directory
*directory
, const char *dir
)
644 dirsize
, /* Number of elements in DIR */
645 len
; /* Length of DIR, including terminating nul */
648 char *new_dump
, *new_dump_ptr
;
649 struct dumpdir
*dump
;
651 if (directory
->children
== ALL_CHILDREN
)
653 else if (DIR_IS_RENAMED (directory
))
654 dump
= directory
->orig
->idump
?
655 directory
->orig
->idump
: directory
->orig
->dump
;
657 dump
= directory
->dump
;
659 /* Count the size of DIR and the number of elements it contains */
662 for (p
= dir
; *p
; p
+= strlen (p
) + 1, dirsize
++)
663 len
+= strlen (p
) + 2;
666 /* Create a sorted directory listing */
667 array
= xcalloc (dirsize
, sizeof array
[0]);
668 for (i
= 0, p
= dir
; *p
; p
+= strlen (p
) + 1, i
++)
671 qsort (array
, dirsize
, sizeof (array
[0]), compare_dirnames
);
673 /* Prepare space for new dumpdir */
674 new_dump
= xmalloc (len
);
675 new_dump_ptr
= new_dump
;
677 /* Fill in the dumpdir template */
678 for (i
= 0; i
< dirsize
; i
++)
680 const char *loc
= dumpdir_locate (dump
, array
[i
]);
683 if (directory
->tagfile
)
684 *new_dump_ptr
= strcmp (directory
->tagfile
, array
[i
]) == 0 ?
690 else if (directory
->tagfile
)
691 *new_dump_ptr
++ = strcmp (directory
->tagfile
, array
[i
]) == 0 ?
694 *new_dump_ptr
++ = 'Y'; /* New entry */
696 /* Copy the file name */
697 for (p
= array
[i
]; (*new_dump_ptr
++ = *p
++); )
701 directory
->idump
= directory
->dump
;
702 directory
->dump
= dumpdir_create0 (new_dump
, NULL
);
706 /* Recursively scan the given directory DIR.
707 DEVICE is the device number where DIR resides (for --one-file-system).
708 If CMDLINE is true, the directory name was explicitly listed in the
711 scan_directory (char *dir
, dev_t device
, bool cmdline
)
713 char *dirp
= savedir (dir
); /* for scanning directory */
714 char *name_buffer
; /* directory, `/', and directory member */
715 size_t name_buffer_size
; /* allocated size of name_buffer, minus 2 */
716 size_t name_length
; /* used length in name_buffer */
717 struct stat stat_data
;
718 struct directory
*directory
;
724 name_buffer_size
= strlen (dir
) + NAME_FIELD_SIZE
;
725 name_buffer
= xmalloc (name_buffer_size
+ 2);
726 strcpy (name_buffer
, dir
);
727 zap_slashes (name_buffer
);
729 if (deref_stat (dereference_option
, name_buffer
, &stat_data
))
731 stat_diag (name_buffer
);
733 children = CHANGED_CHILDREN;
740 directory
= procdir (name_buffer
, &stat_data
, device
,
741 (cmdline
? PD_FORCE_INIT
: 0),
744 name_length
= strlen (name_buffer
);
745 if (! ISSLASH (name_buffer
[name_length
- 1]))
747 name_buffer
[name_length
] = DIRECTORY_SEPARATOR
;
748 /* name_buffer has been allocated an extra slot */
749 name_buffer
[++name_length
] = 0;
752 if (dirp
&& directory
->children
!= NO_CHILDREN
)
754 char *entry
; /* directory entry being scanned */
755 size_t entrylen
; /* length of directory entry */
758 makedumpdir (directory
, dirp
);
760 for (entry
= dumpdir_first (directory
->dump
, 1, &itr
);
762 entry
= dumpdir_next (itr
))
764 entrylen
= strlen (entry
);
765 if (name_buffer_size
<= entrylen
- 1 + name_length
)
768 name_buffer_size
+= NAME_FIELD_SIZE
;
769 while (name_buffer_size
<= entrylen
- 1 + name_length
);
770 name_buffer
= xrealloc (name_buffer
, name_buffer_size
+ 2);
772 strcpy (name_buffer
+ name_length
, entry
+ 1);
774 if (*entry
== 'I') /* Ignored entry */
776 else if (excluded_name (name_buffer
))
780 if (deref_stat (dereference_option
, name_buffer
, &stat_data
))
782 stat_diag (name_buffer
);
787 if (S_ISDIR (stat_data
.st_mode
))
790 if (!recursion_option
)
791 pd_flag
|= PD_FORCE_CHILDREN
| NO_CHILDREN
;
792 else if (directory
->children
== ALL_CHILDREN
)
793 pd_flag
|= PD_FORCE_CHILDREN
| ALL_CHILDREN
;
795 procdir (name_buffer
, &stat_data
, device
, pd_flag
, entry
);
798 else if (one_file_system_option
&& device
!= stat_data
.st_dev
)
801 else if (*entry
== 'Y')
802 /* New entry, skip further checks */;
804 /* FIXME: if (S_ISHIDDEN (stat_data.st_mode))?? */
806 else if (OLDER_STAT_TIME (stat_data
, m
)
807 && (!after_date_option
808 || OLDER_STAT_TIME (stat_data
, c
)))
821 return directory
->dump
? directory
->dump
->contents
: NULL
;
825 get_directory_contents (char *dir
, dev_t device
, bool force
)
827 return scan_directory (dir
, device
, force
);
832 obstack_code_rename (struct obstack
*stk
, char *from
, char *to
)
836 s
= from
[0] == 0 ? from
:
837 safer_name_suffix (from
, false, absolute_names_option
);
838 obstack_1grow (stk
, 'R');
839 obstack_grow (stk
, s
, strlen (s
) + 1);
842 safer_name_suffix (to
, false, absolute_names_option
);
843 obstack_1grow (stk
, 'T');
844 obstack_grow (stk
, s
, strlen (s
) + 1);
848 store_rename (struct directory
*dir
, struct obstack
*stk
)
850 if (DIR_IS_RENAMED (dir
))
852 struct directory
*prev
, *p
;
854 /* Detect eventual cycles and clear DIRF_RENAMED flag, so these entries
855 are ignored when hit by this function next time.
856 If the chain forms a cycle, prev points to the entry DIR is renamed
857 from. In this case it still retains DIRF_RENAMED flag, which will be
858 cleared in the `else' branch below */
859 for (prev
= dir
; prev
&& prev
->orig
!= dir
; prev
= prev
->orig
)
860 DIR_CLEAR_FLAG (prev
, DIRF_RENAMED
);
864 for (p
= dir
; p
&& p
->orig
; p
= p
->orig
)
865 obstack_code_rename (stk
, p
->orig
->name
, p
->name
);
871 DIR_CLEAR_FLAG (prev
, DIRF_RENAMED
);
873 /* Break the cycle by using a temporary name for one of its
875 First, create a temp name stub entry. */
876 temp_name
= dir_name (dir
->name
);
877 obstack_1grow (stk
, 'X');
878 obstack_grow (stk
, temp_name
, strlen (temp_name
) + 1);
880 obstack_code_rename (stk
, dir
->name
, "");
882 for (p
= dir
; p
!= prev
; p
= p
->orig
)
883 obstack_code_rename (stk
, p
->orig
->name
, p
->name
);
885 obstack_code_rename (stk
, "", prev
->name
);
891 append_incremental_renames (const char *dump
)
895 struct directory
*dp
;
903 size
= dumpdir_size (dump
) - 1;
904 obstack_grow (&stk
, dump
, size
);
909 for (dp
= dirhead
; dp
; dp
= dp
->next
)
910 store_rename (dp
, &stk
);
912 if (obstack_object_size (&stk
) != size
)
914 obstack_1grow (&stk
, 0);
915 dump
= obstack_finish (&stk
);
918 obstack_free (&stk
, NULL
);
924 static FILE *listed_incremental_stream
;
926 /* Version of incremental format snapshots (directory files) used by this
927 tar. Currently it is supposed to be a single decimal number. 0 means
928 incremental snapshots as per tar version before 1.15.2.
930 The current tar version supports incremental versions from
931 0 up to TAR_INCREMENTAL_VERSION, inclusive.
932 It is able to create only snapshots of TAR_INCREMENTAL_VERSION */
934 #define TAR_INCREMENTAL_VERSION 2
936 /* Read incremental snapshot formats 0 and 1 */
938 read_incr_db_01 (int version
, const char *initbuf
)
951 if (getline (&buf
, &bufsize
, listed_incremental_stream
) <= 0)
953 read_error (listed_incremental_option
);
961 buf
= strdup (initbuf
);
962 bufsize
= strlen (buf
) + 1;
965 sec
= TYPE_MINIMUM (time_t);
968 u
= strtoumax (buf
, &ebuf
, 10);
969 if (!errno
&& TYPE_MAXIMUM (time_t) < u
)
971 if (errno
|| buf
== ebuf
)
972 ERROR ((0, errno
, "%s:%ld: %s",
973 quotearg_colon (listed_incremental_option
),
975 _("Invalid time stamp")));
980 if (version
== 1 && *ebuf
)
982 char const *buf_ns
= ebuf
+ 1;
984 u
= strtoumax (buf_ns
, &ebuf
, 10);
985 if (!errno
&& BILLION
<= u
)
987 if (errno
|| buf_ns
== ebuf
)
989 ERROR ((0, errno
, "%s:%ld: %s",
990 quotearg_colon (listed_incremental_option
),
992 _("Invalid time stamp")));
993 sec
= TYPE_MINIMUM (time_t);
1000 /* pre-1 incremental format does not contain nanoseconds */
1004 newer_mtime_option
.tv_sec
= sec
;
1005 newer_mtime_option
.tv_nsec
= nsec
;
1008 while (0 < (n
= getline (&buf
, &bufsize
, listed_incremental_stream
)))
1012 bool nfs
= buf
[0] == '+';
1013 char *strp
= buf
+ nfs
;
1014 struct timespec mtime
;
1018 if (buf
[n
- 1] == '\n')
1024 u
= strtoumax (strp
, &ebuf
, 10);
1025 if (!errno
&& TYPE_MAXIMUM (time_t) < u
)
1027 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
1029 ERROR ((0, errno
, "%s:%ld: %s",
1030 quotearg_colon (listed_incremental_option
), lineno
,
1031 _("Invalid modification time (seconds)")));
1039 u
= strtoumax (strp
, &ebuf
, 10);
1040 if (!errno
&& BILLION
<= u
)
1042 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
1044 ERROR ((0, errno
, "%s:%ld: %s",
1045 quotearg_colon (listed_incremental_option
), lineno
,
1046 _("Invalid modification time (nanoseconds)")));
1052 mtime
.tv_nsec
= nsec
;
1056 memset (&mtime
, 0, sizeof mtime
);
1059 u
= strtoumax (strp
, &ebuf
, 10);
1060 if (!errno
&& TYPE_MAXIMUM (dev_t
) < u
)
1062 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
1064 ERROR ((0, errno
, "%s:%ld: %s",
1065 quotearg_colon (listed_incremental_option
), lineno
,
1066 _("Invalid device number")));
1074 u
= strtoumax (strp
, &ebuf
, 10);
1075 if (!errno
&& TYPE_MAXIMUM (ino_t
) < u
)
1077 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
1079 ERROR ((0, errno
, "%s:%ld: %s",
1080 quotearg_colon (listed_incremental_option
), lineno
,
1081 _("Invalid inode number")));
1089 unquote_string (strp
);
1090 note_directory (strp
, mtime
, dev
, ino
, nfs
, false, NULL
);
1095 /* Read a nul-terminated string from FP and store it in STK.
1096 Store the number of bytes read (including nul terminator) in PCOUNT.
1098 Return the last character read or EOF on end of file. */
1100 read_obstack (FILE *fp
, struct obstack
*stk
, size_t *pcount
)
1105 for (i
= 0, c
= getc (fp
); c
!= EOF
&& c
!= 0; c
= getc (fp
), i
++)
1106 obstack_1grow (stk
, c
);
1107 obstack_1grow (stk
, 0);
1113 /* Read from file FP a nul-terminated string and convert it to
1114 intmax_t. Return the resulting value in PVAL. Assume '-' has
1117 Throw a fatal error if the string cannot be converted or if the
1118 converted value is less than MIN_VAL. */
1121 read_negative_num (FILE *fp
, intmax_t min_val
, intmax_t *pval
)
1125 char buf
[INT_BUFSIZE_BOUND (intmax_t)];
1129 for (i
= 1; ISDIGIT (c
= getc (fp
)); i
++)
1131 if (i
== sizeof buf
- 1)
1132 FATAL_ERROR ((0, 0, _("Field too long while reading snapshot file")));
1139 FATAL_ERROR ((0, errno
, _("Read error in snapshot file")));
1141 FATAL_ERROR ((0, 0, _("Unexpected EOF in snapshot file")));
1146 *pval
= strtoimax (buf
, &ep
, 10);
1147 if (c
|| errno
|| *pval
< min_val
)
1148 FATAL_ERROR ((0, errno
, _("Unexpected field value in snapshot file")));
1151 /* Read from file FP a nul-terminated string and convert it to
1152 uintmax_t. Return the resulting value in PVAL. Assume C has
1155 Throw a fatal error if the string cannot be converted or if the
1156 converted value exceeds MAX_VAL.
1158 Return the last character read or EOF on end of file. */
1161 read_unsigned_num (int c
, FILE *fp
, uintmax_t max_val
, uintmax_t *pval
)
1164 char buf
[UINTMAX_STRSIZE_BOUND
], *ep
;
1166 for (i
= 0; ISDIGIT (c
); i
++)
1168 if (i
== sizeof buf
- 1)
1169 FATAL_ERROR ((0, 0, _("Field too long while reading snapshot file")));
1177 FATAL_ERROR ((0, errno
, _("Read error in snapshot file")));
1181 FATAL_ERROR ((0, 0, _("Unexpected EOF in snapshot file")));
1186 *pval
= strtoumax (buf
, &ep
, 10);
1187 if (c
|| errno
|| max_val
< *pval
)
1188 FATAL_ERROR ((0, errno
, _("Unexpected field value in snapshot file")));
1192 /* Read from file FP a nul-terminated string and convert it to
1193 uintmax_t. Return the resulting value in PVAL.
1195 Throw a fatal error if the string cannot be converted or if the
1196 converted value exceeds MAX_VAL.
1198 Return the last character read or EOF on end of file. */
1201 read_num (FILE *fp
, uintmax_t max_val
, uintmax_t *pval
)
1203 return read_unsigned_num (getc (fp
), fp
, max_val
, pval
);
1206 /* Read from FP two NUL-terminated strings representing a struct
1207 timespec. Return the resulting value in PVAL.
1209 Throw a fatal error if the string cannot be converted. */
1212 read_timespec (FILE *fp
, struct timespec
*pval
)
1220 read_negative_num (fp
, TYPE_MINIMUM (time_t), &i
);
1226 c
= read_unsigned_num (c
, fp
, TYPE_MAXIMUM (time_t), &u
);
1230 if (c
|| read_num (fp
, BILLION
- 1, &u
))
1231 FATAL_ERROR ((0, 0, "%s: %s",
1232 quotearg_colon (listed_incremental_option
),
1233 _("Unexpected EOF in snapshot file")));
1237 /* Read incremental snapshot format 2 */
1244 obstack_init (&stk
);
1246 read_timespec (listed_incremental_stream
, &newer_mtime_option
);
1250 struct timespec mtime
;
1258 if (read_num (listed_incremental_stream
, 1, &u
))
1259 return; /* Normal return */
1263 read_timespec (listed_incremental_stream
, &mtime
);
1265 if (read_num (listed_incremental_stream
, TYPE_MAXIMUM (dev_t
), &u
))
1269 if (read_num (listed_incremental_stream
, TYPE_MAXIMUM (ino_t
), &u
))
1273 if (read_obstack (listed_incremental_stream
, &stk
, &s
))
1276 name
= obstack_finish (&stk
);
1278 while (read_obstack (listed_incremental_stream
, &stk
, &s
) == 0 && s
> 1)
1280 if (getc (listed_incremental_stream
) != 0)
1281 FATAL_ERROR ((0, 0, "%s: %s",
1282 quotearg_colon (listed_incremental_option
),
1283 _("Missing record terminator")));
1285 content
= obstack_finish (&stk
);
1286 note_directory (name
, mtime
, dev
, ino
, nfs
, false, content
);
1287 obstack_free (&stk
, content
);
1289 FATAL_ERROR ((0, 0, "%s: %s",
1290 quotearg_colon (listed_incremental_option
),
1291 _("Unexpected EOF in snapshot file")));
1294 /* Read incremental snapshot file (directory file).
1295 If the file has older incremental version, make sure that it is processed
1296 correctly and that tar will use the most conservative backup method among
1297 possible alternatives (i.e. prefer ALL_CHILDREN over CHANGED_CHILDREN,
1298 etc.) This ensures that the snapshots are updated to the recent version
1299 without any loss of data. */
1301 read_directory_file (void)
1306 int flags
= O_RDWR
| O_CREAT
;
1308 if (incremental_level
== 0)
1310 /* Open the file for both read and write. That way, we can write
1311 it later without having to reopen it, and don't have to worry if
1312 we chdir in the meantime. */
1313 fd
= open (listed_incremental_option
, flags
, MODE_RW
);
1316 open_error (listed_incremental_option
);
1320 listed_incremental_stream
= fdopen (fd
, "r+");
1321 if (! listed_incremental_stream
)
1323 open_error (listed_incremental_option
);
1328 if (0 < getline (&buf
, &bufsize
, listed_incremental_stream
))
1331 uintmax_t incremental_version
;
1333 if (strncmp (buf
, PACKAGE_NAME
, sizeof PACKAGE_NAME
- 1) == 0)
1335 ebuf
= buf
+ sizeof PACKAGE_NAME
- 1;
1337 ERROR((1, 0, _("Bad incremental file format")));
1338 for (; *ebuf
!= '-'; ebuf
++)
1340 ERROR((1, 0, _("Bad incremental file format")));
1342 incremental_version
= strtoumax (ebuf
+ 1, NULL
, 10);
1345 incremental_version
= 0;
1347 switch (incremental_version
)
1351 read_incr_db_01 (incremental_version
, buf
);
1354 case TAR_INCREMENTAL_VERSION
:
1359 ERROR ((1, 0, _("Unsupported incremental format version: %"PRIuMAX
),
1360 incremental_version
));
1365 if (ferror (listed_incremental_stream
))
1366 read_error (listed_incremental_option
);
1371 /* Output incremental data for the directory ENTRY to the file DATA.
1372 Return nonzero if successful, preserving errno on write failure. */
1374 write_directory_file_entry (void *entry
, void *data
)
1376 struct directory
const *directory
= entry
;
1379 if (DIR_IS_FOUND (directory
))
1381 char buf
[UINTMAX_STRSIZE_BOUND
];
1384 s
= DIR_IS_NFS (directory
) ? "1" : "0";
1385 fwrite (s
, 2, 1, fp
);
1386 s
= (TYPE_SIGNED (time_t)
1387 ? imaxtostr (directory
->mtime
.tv_sec
, buf
)
1388 : umaxtostr (directory
->mtime
.tv_sec
, buf
));
1389 fwrite (s
, strlen (s
) + 1, 1, fp
);
1390 s
= umaxtostr (directory
->mtime
.tv_nsec
, buf
);
1391 fwrite (s
, strlen (s
) + 1, 1, fp
);
1392 s
= umaxtostr (directory
->device_number
, buf
);
1393 fwrite (s
, strlen (s
) + 1, 1, fp
);
1394 s
= umaxtostr (directory
->inode_number
, buf
);
1395 fwrite (s
, strlen (s
) + 1, 1, fp
);
1397 fwrite (directory
->name
, strlen (directory
->name
) + 1, 1, fp
);
1398 if (directory
->dump
)
1403 for (p
= dumpdir_first (directory
->dump
, 0, &itr
);
1405 p
= dumpdir_next (itr
))
1406 fwrite (p
, strlen (p
) + 1, 1, fp
);
1409 fwrite ("\0\0", 2, 1, fp
);
1412 return ! ferror (fp
);
1416 write_directory_file (void)
1418 FILE *fp
= listed_incremental_stream
;
1419 char buf
[UINTMAX_STRSIZE_BOUND
];
1425 if (fseek (fp
, 0L, SEEK_SET
) != 0)
1426 seek_error (listed_incremental_option
);
1427 if (sys_truncate (fileno (fp
)) != 0)
1428 truncate_error (listed_incremental_option
);
1430 fprintf (fp
, "%s-%s-%d\n", PACKAGE_NAME
, PACKAGE_VERSION
,
1431 TAR_INCREMENTAL_VERSION
);
1433 s
= (TYPE_SIGNED (time_t)
1434 ? imaxtostr (start_time
.tv_sec
, buf
)
1435 : umaxtostr (start_time
.tv_sec
, buf
));
1436 fwrite (s
, strlen (s
) + 1, 1, fp
);
1437 s
= umaxtostr (start_time
.tv_nsec
, buf
);
1438 fwrite (s
, strlen (s
) + 1, 1, fp
);
1440 if (! ferror (fp
) && directory_table
)
1441 hash_do_for_each (directory_table
, write_directory_file_entry
, fp
);
1444 write_error (listed_incremental_option
);
1445 if (fclose (fp
) != 0)
1446 close_error (listed_incremental_option
);
1450 /* Restoration of incremental dumps. */
1453 get_gnu_dumpdir (struct tar_stat_info
*stat_info
)
1457 union block
*data_block
;
1461 size
= stat_info
->stat
.st_size
;
1463 archive_dir
= xmalloc (size
);
1466 set_next_block_after (current_header
);
1467 mv_begin (stat_info
);
1469 for (; size
> 0; size
-= copied
)
1471 mv_size_left (size
);
1472 data_block
= find_next_block ();
1474 ERROR ((1, 0, _("Unexpected EOF in archive")));
1475 copied
= available_space_after (data_block
);
1478 memcpy (to
, data_block
->buffer
, copied
);
1480 set_next_block_after ((union block
*)
1481 (data_block
->buffer
+ copied
- 1));
1486 stat_info
->dumpdir
= archive_dir
;
1487 stat_info
->skipped
= true; /* For skip_member() and friends
1488 to work correctly */
1491 /* Return T if STAT_INFO represents a dumpdir archive member.
1492 Note: can invalidate current_header. It happens if flush_archive()
1493 gets called within get_gnu_dumpdir() */
1495 is_dumpdir (struct tar_stat_info
*stat_info
)
1497 if (stat_info
->is_dumpdir
&& !stat_info
->dumpdir
)
1498 get_gnu_dumpdir (stat_info
);
1499 return stat_info
->is_dumpdir
;
1503 dumpdir_ok (char *dumpdir
)
1506 int has_tempdir
= 0;
1509 for (p
= dumpdir
; *p
; p
+= strlen (p
) + 1)
1511 if (expect
&& *p
!= expect
)
1514 _("Malformed dumpdir: expected '%c' but found %#3o"),
1524 _("Malformed dumpdir: 'X' duplicated")));
1537 _("Malformed dumpdir: empty name in 'R'")));
1550 _("Malformed dumpdir: 'T' not preceeded by 'R'")));
1553 if (p
[1] == 0 && !has_tempdir
)
1556 _("Malformed dumpdir: empty name in 'T'")));
1568 /* FIXME: bail out? */
1576 _("Malformed dumpdir: expected '%c' but found end of data"),
1582 WARNOPT (WARN_BAD_DUMPDIR
,
1583 (0, 0, _("Malformed dumpdir: 'X' never used")));
1588 /* Examine the directories under directory_name and delete any
1589 files that were not there at the time of the back-up. */
1591 try_purge_directory (char const *directory_name
)
1594 char *cur
, *arc
, *p
;
1595 char *temp_stub
= NULL
;
1596 struct dumpdir
*dump
;
1598 if (!is_dumpdir (¤t_stat_info
))
1601 current_dir
= savedir (directory_name
);
1604 /* The directory doesn't exist now. It'll be created. In any
1605 case, we don't have to delete any files out of it. */
1608 /* Verify if dump directory is sane */
1609 if (!dumpdir_ok (current_stat_info
.dumpdir
))
1612 /* Process renames */
1613 for (arc
= current_stat_info
.dumpdir
; *arc
; arc
+= strlen (arc
) + 1)
1617 #define TEMP_DIR_TEMPLATE "tar.XXXXXX"
1618 size_t len
= strlen (arc
+ 1);
1619 temp_stub
= xrealloc (temp_stub
, len
+ 1 + sizeof TEMP_DIR_TEMPLATE
);
1620 memcpy (temp_stub
, arc
+ 1, len
);
1621 temp_stub
[len
] = '/';
1622 memcpy (temp_stub
+ len
+ 1, TEMP_DIR_TEMPLATE
,
1623 sizeof TEMP_DIR_TEMPLATE
);
1624 if (!mkdtemp (temp_stub
))
1627 _("Cannot create temporary directory using template %s"),
1628 quote (temp_stub
)));
1634 else if (*arc
== 'R')
1638 arc
+= strlen (arc
) + 1;
1641 /* Ensure that neither source nor destination are absolute file
1642 names (unless permitted by -P option), and that they do not
1643 contain dubious parts (e.g. ../).
1645 This is an extra safety precaution. Besides, it might be
1646 necessary to extract from archives created with tar versions
1650 src
= safer_name_suffix (src
, false, absolute_names_option
);
1652 dst
= safer_name_suffix (dst
, false, absolute_names_option
);
1659 if (!rename_directory (src
, dst
))
1663 /* FIXME: Make sure purge_directory(dst) will return
1672 /* Process deletes */
1673 dump
= dumpdir_create (current_stat_info
.dumpdir
);
1675 for (cur
= current_dir
; *cur
; cur
+= strlen (cur
) + 1)
1681 p
= new_name (directory_name
, cur
);
1683 if (deref_stat (false, p
, &st
))
1685 if (errno
!= ENOENT
) /* FIXME: Maybe keep a list of renamed
1686 dirs and check it here? */
1689 WARN ((0, 0, _("%s: Not purging directory: unable to stat"),
1690 quotearg_colon (p
)));
1695 if (!(entry
= dumpdir_locate (dump
, cur
))
1696 || (*entry
== 'D' && !S_ISDIR (st
.st_mode
))
1697 || (*entry
== 'Y' && S_ISDIR (st
.st_mode
)))
1699 if (one_file_system_option
&& st
.st_dev
!= root_device
)
1702 _("%s: directory is on a different device: not purging"),
1703 quotearg_colon (p
)));
1707 if (! interactive_option
|| confirm ("delete", p
))
1710 fprintf (stdlis
, _("%s: Deleting %s\n"),
1711 program_name
, quote (p
));
1712 if (! remove_any_file (p
, RECURSIVE_REMOVE_OPTION
))
1715 ERROR ((0, e
, _("%s: Cannot remove"), quotearg_colon (p
)));
1721 dumpdir_free (dump
);
1728 purge_directory (char const *directory_name
)
1730 if (!try_purge_directory (directory_name
))
1735 list_dumpdir (char *buffer
, size_t size
)
1748 fprintf (stdlis
, "%c", *buffer
);
1751 fprintf (stdlis
, " ");
1759 fputc ('\n', stdlis
);
1766 fputc (*buffer
, stdlis
);