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) FIXME: not used */
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 */
80 static struct dumpdir
*
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;
111 static struct dumpdir
*
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
> 1 && 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 dirlist_replace_prefix (const char *pref
, const char *repl
)
296 struct directory
*dp
;
297 size_t pref_len
= strlen (pref
);
298 size_t repl_len
= strlen (repl
);
299 for (dp
= dirhead
; dp
; dp
= dp
->next
)
300 replace_prefix (&dp
->name
, pref
, pref_len
, repl
, repl_len
);
304 clear_directory_table (void)
306 struct directory
*dp
;
309 hash_clear (directory_table
);
310 if (directory_meta_table
)
311 hash_clear (directory_meta_table
);
312 for (dp
= dirhead
; dp
; )
314 struct directory
*next
= dp
->next
;
318 dirhead
= dirtail
= NULL
;
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
,
350 && hash_insert (directory_table
, directory
)))
353 if (! ((directory_meta_table
354 || (directory_meta_table
= hash_initialize (0, 0,
356 compare_directory_meta
,
358 && hash_insert (directory_meta_table
, directory
)))
364 /* Return a directory entry for a given file NAME, or zero if none found. */
365 static struct directory
*
366 find_directory (const char *name
)
368 if (! directory_table
)
372 char *caname
= normalize_filename (name
);
373 struct directory
*dir
= make_directory (name
, caname
);
374 struct directory
*ret
= hash_lookup (directory_table
, dir
);
375 free_directory (dir
);
381 /* Remove directory entry for the given CANAME */
383 remove_directory (const char *caname
)
385 struct directory
*dir
= make_directory (caname
, xstrdup (caname
));
386 struct directory
*ret
= hash_delete (directory_table
, dir
);
388 free_directory (ret
);
389 free_directory (dir
);
393 /* If first OLD_PREFIX_LEN bytes of DIR->NAME name match OLD_PREFIX,
394 replace them with NEW_PREFIX. */
396 rebase_directory (struct directory
*dir
,
397 const char *old_prefix
, size_t old_prefix_len
,
398 const char *new_prefix
, size_t new_prefix_len
)
400 replace_prefix (&dir
->name
, old_prefix
, old_prefix_len
,
401 new_prefix
, new_prefix_len
);
404 /* Return a directory entry for a given combination of device and inode
405 numbers, or zero if none found. */
406 static struct directory
*
407 find_directory_meta (dev_t dev
, ino_t ino
)
409 if (! directory_meta_table
)
413 struct directory
*dir
= make_directory ("", NULL
);
414 struct directory
*ret
;
415 dir
->device_number
= dev
;
416 dir
->inode_number
= ino
;
417 ret
= hash_lookup (directory_meta_table
, dir
);
418 free_directory (dir
);
424 update_parent_directory (struct tar_stat_info
*parent
)
426 struct directory
*directory
= find_directory (parent
->orig_file_name
);
430 if (fstat (parent
->fd
, &st
) != 0)
431 stat_diag (directory
->name
);
433 directory
->mtime
= get_stat_mtime (&st
);
437 #define PD_FORCE_CHILDREN 0x10
438 #define PD_FORCE_INIT 0x20
439 #define PD_CHILDREN(f) ((f) & 3)
441 static struct directory
*
442 procdir (const char *name_buffer
, struct tar_stat_info
*st
,
446 struct directory
*directory
;
447 struct stat
*stat_data
= &st
->stat
;
448 bool nfs
= NFS_FILE_STAT (*stat_data
);
449 bool perhaps_renamed
= false;
451 if ((directory
= find_directory (name_buffer
)) != NULL
)
453 if (DIR_IS_INITED (directory
))
455 if (flag
& PD_FORCE_INIT
)
457 assign_string (&directory
->name
, name_buffer
);
461 *entry
= 'N'; /* Avoid duplicating this directory */
466 if (strcmp (directory
->name
, name_buffer
))
472 /* With NFS, the same file can have two different devices
473 if an NFS directory is mounted in multiple locations,
474 which is relatively common when automounting.
475 To avoid spurious incremental redumping of
476 directories, consider all NFS devices as equal,
477 relying on the i-node to establish differences. */
479 if (! ((!check_device_option
480 || (DIR_IS_NFS (directory
) && nfs
)
481 || directory
->device_number
== stat_data
->st_dev
)
482 && directory
->inode_number
== stat_data
->st_ino
))
484 /* FIXME: find_directory_meta ignores nfs */
485 struct directory
*d
= find_directory_meta (stat_data
->st_dev
,
489 if (strcmp (d
->name
, name_buffer
))
491 WARNOPT (WARN_RENAME_DIRECTORY
,
493 _("%s: Directory has been renamed from %s"),
494 quotearg_colon (name_buffer
),
495 quote_n (1, d
->name
)));
497 DIR_SET_FLAG (directory
, DIRF_RENAMED
);
498 dirlist_replace_prefix (d
->name
, name_buffer
);
500 directory
->children
= CHANGED_CHILDREN
;
504 perhaps_renamed
= true;
505 directory
->children
= ALL_CHILDREN
;
506 directory
->device_number
= stat_data
->st_dev
;
507 directory
->inode_number
= stat_data
->st_ino
;
510 DIR_SET_FLAG (directory
, DIRF_NFS
);
513 directory
->children
= CHANGED_CHILDREN
;
515 DIR_SET_FLAG (directory
, DIRF_FOUND
);
519 struct directory
*d
= find_directory_meta (stat_data
->st_dev
,
522 directory
= note_directory (name_buffer
,
523 get_stat_mtime (stat_data
),
532 if (strcmp (d
->name
, name_buffer
))
534 WARNOPT (WARN_RENAME_DIRECTORY
,
535 (0, 0, _("%s: Directory has been renamed from %s"),
536 quotearg_colon (name_buffer
),
537 quote_n (1, d
->name
)));
539 DIR_SET_FLAG (directory
, DIRF_RENAMED
);
540 dirlist_replace_prefix (d
->name
, name_buffer
);
542 directory
->children
= CHANGED_CHILDREN
;
546 DIR_SET_FLAG (directory
, DIRF_NEW
);
547 WARNOPT (WARN_NEW_DIRECTORY
,
548 (0, 0, _("%s: Directory is new"),
549 quotearg_colon (name_buffer
)));
550 directory
->children
=
551 (listed_incremental_option
552 || (OLDER_STAT_TIME (*stat_data
, m
)
553 || (after_date_option
554 && OLDER_STAT_TIME (*stat_data
, c
))))
560 if (one_file_system_option
&& st
->parent
561 && stat_data
->st_dev
!= st
->parent
->stat
.st_dev
)
565 _("%s: directory is on a different filesystem; not dumped"),
566 quotearg_colon (directory
->name
)));
567 directory
->children
= NO_CHILDREN
;
568 /* If there is any dumpdir info in that directory, remove it */
571 dumpdir_free (directory
->dump
);
572 directory
->dump
= NULL
;
574 perhaps_renamed
= false;
577 else if (flag
& PD_FORCE_CHILDREN
)
579 directory
->children
= PD_CHILDREN(flag
);
580 if (directory
->children
== NO_CHILDREN
)
585 WARNOPT (WARN_RENAME_DIRECTORY
,
586 (0, 0, _("%s: Directory has been renamed"),
587 quotearg_colon (name_buffer
)));
589 DIR_SET_FLAG (directory
, DIRF_INIT
);
591 if (directory
->children
!= NO_CHILDREN
)
593 const char *tag_file_name
;
595 switch (check_exclusion_tags (st
, &tag_file_name
))
597 case exclusion_tag_all
:
598 /* This warning can be duplicated by code in dump_file0, but only
599 in case when the topmost directory being archived contains
601 exclusion_tag_warning (name_buffer
, tag_file_name
,
602 _("directory not dumped"));
604 directory
->children
= NO_CHILDREN
;
607 case exclusion_tag_contents
:
608 exclusion_tag_warning (name_buffer
, tag_file_name
,
609 _("contents not dumped"));
610 directory
->children
= NO_CHILDREN
;
613 case exclusion_tag_under
:
614 exclusion_tag_warning (name_buffer
, tag_file_name
,
615 _("contents not dumped"));
616 directory
->tagfile
= tag_file_name
;
619 case exclusion_tag_none
:
627 /* Compare dumpdir array from DIRECTORY with directory listing DIR and
628 build a new dumpdir template.
630 DIR must be returned by a previous call to savedir().
632 File names in DIRECTORY->dump->contents must be sorted
635 DIRECTORY->dump is replaced with the created template. Each entry is
636 prefixed with ' ' if it was present in DUMP and with 'Y' otherwise. */
639 makedumpdir (struct directory
*directory
, const char *dir
)
642 dirsize
, /* Number of elements in DIR */
643 len
; /* Length of DIR, including terminating nul */
646 char *new_dump
, *new_dump_ptr
;
647 struct dumpdir
*dump
;
649 if (directory
->children
== ALL_CHILDREN
)
651 else if (DIR_IS_RENAMED (directory
))
652 dump
= directory
->orig
->idump
?
653 directory
->orig
->idump
: directory
->orig
->dump
;
655 dump
= directory
->dump
;
657 /* Count the size of DIR and the number of elements it contains */
660 for (p
= dir
; *p
; p
+= strlen (p
) + 1, dirsize
++)
661 len
+= strlen (p
) + 2;
664 /* Create a sorted directory listing */
665 array
= xcalloc (dirsize
, sizeof array
[0]);
666 for (i
= 0, p
= dir
; *p
; p
+= strlen (p
) + 1, i
++)
669 qsort (array
, dirsize
, sizeof (array
[0]), compare_dirnames
);
671 /* Prepare space for new dumpdir */
672 new_dump
= xmalloc (len
);
673 new_dump_ptr
= new_dump
;
675 /* Fill in the dumpdir template */
676 for (i
= 0; i
< dirsize
; i
++)
678 const char *loc
= dumpdir_locate (dump
, array
[i
]);
681 if (directory
->tagfile
)
682 *new_dump_ptr
= strcmp (directory
->tagfile
, array
[i
]) == 0 ?
688 else if (directory
->tagfile
)
689 *new_dump_ptr
++ = strcmp (directory
->tagfile
, array
[i
]) == 0 ?
692 *new_dump_ptr
++ = 'Y'; /* New entry */
694 /* Copy the file name */
695 for (p
= array
[i
]; (*new_dump_ptr
++ = *p
++); )
699 directory
->idump
= directory
->dump
;
700 directory
->dump
= dumpdir_create0 (new_dump
, NULL
);
704 /* Recursively scan the directory identified by ST. */
706 scan_directory (struct tar_stat_info
*st
)
708 char const *dir
= st
->orig_file_name
;
709 char *dirp
= get_directory_entries (st
);
710 dev_t device
= st
->stat
.st_dev
;
711 bool cmdline
= ! st
->parent
;
714 struct directory
*directory
;
723 directory
= procdir (tmp
, st
,
724 (cmdline
? PD_FORCE_INIT
: 0),
729 nbuf
= namebuf_create (dir
);
731 if (dirp
&& directory
->children
!= NO_CHILDREN
)
733 char *entry
; /* directory entry being scanned */
734 struct dumpdir_iter
*itr
;
736 makedumpdir (directory
, dirp
);
738 for (entry
= dumpdir_first (directory
->dump
, 1, &itr
);
740 entry
= dumpdir_next (itr
))
742 char *full_name
= namebuf_name (nbuf
, entry
+ 1);
744 if (*entry
== 'I') /* Ignored entry */
746 else if (excluded_name (full_name
))
751 void (*diag
) (char const *) = 0;
752 struct tar_stat_info stsub
;
753 tar_stat_init (&stsub
);
760 else if (fstatat (fd
, entry
+ 1, &stsub
.stat
, fstatat_flags
) != 0)
762 else if (S_ISDIR (stsub
.stat
.st_mode
))
764 int subfd
= subfile_open (st
, entry
+ 1, open_read_flags
);
770 if (fstat (subfd
, &stsub
.stat
) != 0)
777 file_removed_diag (full_name
, false, diag
);
780 else if (S_ISDIR (stsub
.stat
.st_mode
))
783 if (!recursion_option
)
784 pd_flag
|= PD_FORCE_CHILDREN
| NO_CHILDREN
;
785 else if (directory
->children
== ALL_CHILDREN
)
786 pd_flag
|= PD_FORCE_CHILDREN
| ALL_CHILDREN
;
790 procdir (full_name
, &stsub
, pd_flag
, entry
);
791 restore_parent_fd (&stsub
);
793 else if (one_file_system_option
&& device
!= stsub
.stat
.st_dev
)
795 else if (*entry
== 'Y')
796 /* New entry, skip further checks */;
797 /* FIXME: if (S_ISHIDDEN (stat_data.st_mode))?? */
798 else if (OLDER_STAT_TIME (stsub
.stat
, m
)
799 && (!after_date_option
800 || OLDER_STAT_TIME (stsub
.stat
, c
)))
805 tar_stat_destroy (&stsub
);
818 /* Return pointer to the contents of the directory DIR */
820 directory_contents (struct directory
*dir
)
824 return dir
->dump
? dir
->dump
->contents
: NULL
;
827 /* A "safe" version of directory_contents, which never returns NULL. */
829 safe_directory_contents (struct directory
*dir
)
831 const char *ret
= directory_contents (dir
);
832 return ret
? ret
: "\0\0\0\0";
837 obstack_code_rename (struct obstack
*stk
, char const *from
, char const *to
)
841 s
= from
[0] == 0 ? from
:
842 safer_name_suffix (from
, false, absolute_names_option
);
843 obstack_1grow (stk
, 'R');
844 obstack_grow (stk
, s
, strlen (s
) + 1);
847 safer_name_suffix (to
, false, absolute_names_option
);
848 obstack_1grow (stk
, 'T');
849 obstack_grow (stk
, s
, strlen (s
) + 1);
853 store_rename (struct directory
*dir
, struct obstack
*stk
)
855 if (DIR_IS_RENAMED (dir
))
857 struct directory
*prev
, *p
;
859 /* Detect eventual cycles and clear DIRF_RENAMED flag, so these entries
860 are ignored when hit by this function next time.
861 If the chain forms a cycle, prev points to the entry DIR is renamed
862 from. In this case it still retains DIRF_RENAMED flag, which will be
863 cleared in the 'else' branch below */
864 for (prev
= dir
; prev
&& prev
->orig
!= dir
; prev
= prev
->orig
)
865 DIR_CLEAR_FLAG (prev
, DIRF_RENAMED
);
869 for (p
= dir
; p
&& p
->orig
; p
= p
->orig
)
870 obstack_code_rename (stk
, p
->orig
->name
, p
->name
);
876 DIR_CLEAR_FLAG (prev
, DIRF_RENAMED
);
878 /* Break the cycle by using a temporary name for one of its
880 First, create a temp name stub entry. */
881 temp_name
= dir_name (dir
->name
);
882 obstack_1grow (stk
, 'X');
883 obstack_grow (stk
, temp_name
, strlen (temp_name
) + 1);
885 obstack_code_rename (stk
, dir
->name
, "");
887 for (p
= dir
; p
!= prev
; p
= p
->orig
)
888 obstack_code_rename (stk
, p
->orig
->name
, p
->name
);
890 obstack_code_rename (stk
, "", prev
->name
);
896 append_incremental_renames (struct directory
*dir
)
900 struct directory
*dp
;
907 dump
= directory_contents (dir
);
910 size
= dumpdir_size (dump
) - 1;
911 obstack_grow (&stk
, dump
, size
);
916 for (dp
= dirhead
; dp
; dp
= dp
->next
)
917 store_rename (dp
, &stk
);
919 /* FIXME: Is this the right thing to do when DIR is null? */
920 if (dir
&& obstack_object_size (&stk
) != size
)
922 obstack_1grow (&stk
, 0);
923 dumpdir_free (dir
->dump
);
924 dir
->dump
= dumpdir_create (obstack_finish (&stk
));
926 obstack_free (&stk
, NULL
);
931 static FILE *listed_incremental_stream
;
933 /* Version of incremental format snapshots (directory files) used by this
934 tar. Currently it is supposed to be a single decimal number. 0 means
935 incremental snapshots as per tar version before 1.15.2.
937 The current tar version supports incremental versions from
938 0 up to TAR_INCREMENTAL_VERSION, inclusive.
939 It is able to create only snapshots of TAR_INCREMENTAL_VERSION */
941 #define TAR_INCREMENTAL_VERSION 2
943 /* Read incremental snapshot formats 0 and 1 */
945 read_incr_db_01 (int version
, const char *initbuf
)
956 if (getline (&buf
, &bufsize
, listed_incremental_stream
) <= 0)
958 read_error (listed_incremental_option
);
966 buf
= strdup (initbuf
);
967 bufsize
= strlen (buf
) + 1;
970 newer_mtime_option
= decode_timespec (buf
, &ebuf
, false);
972 if (! valid_timespec (newer_mtime_option
))
973 ERROR ((0, errno
, "%s:%ld: %s",
974 quotearg_colon (listed_incremental_option
),
976 _("Invalid time stamp")));
979 if (version
== 1 && *ebuf
)
981 char const *buf_ns
= ebuf
+ 1;
983 u
= strtoumax (buf_ns
, &ebuf
, 10);
984 if (!errno
&& BILLION
<= u
)
986 if (errno
|| buf_ns
== ebuf
)
988 ERROR ((0, errno
, "%s:%ld: %s",
989 quotearg_colon (listed_incremental_option
),
991 _("Invalid time stamp")));
992 newer_mtime_option
.tv_sec
= TYPE_MINIMUM (time_t);
993 newer_mtime_option
.tv_nsec
= -1;
996 newer_mtime_option
.tv_nsec
= u
;
1000 while (0 < (n
= getline (&buf
, &bufsize
, listed_incremental_stream
)))
1004 bool nfs
= buf
[0] == '+';
1005 char *strp
= buf
+ nfs
;
1006 struct timespec mtime
;
1010 if (buf
[n
- 1] == '\n')
1015 mtime
= decode_timespec (strp
, &ebuf
, false);
1017 if (!valid_timespec (mtime
) || *strp
!= ' ')
1018 ERROR ((0, errno
, "%s:%ld: %s",
1019 quotearg_colon (listed_incremental_option
), lineno
,
1020 _("Invalid modification time")));
1023 u
= strtoumax (strp
, &ebuf
, 10);
1024 if (!errno
&& BILLION
<= u
)
1026 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
1028 ERROR ((0, errno
, "%s:%ld: %s",
1029 quotearg_colon (listed_incremental_option
), lineno
,
1030 _("Invalid modification time (nanoseconds)")));
1038 mtime
.tv_sec
= mtime
.tv_nsec
= 0;
1040 dev
= strtosysint (strp
, &ebuf
,
1041 TYPE_MINIMUM (dev_t
), TYPE_MAXIMUM (dev_t
));
1043 if (errno
|| *strp
!= ' ')
1044 ERROR ((0, errno
, "%s:%ld: %s",
1045 quotearg_colon (listed_incremental_option
), lineno
,
1046 _("Invalid device number")));
1048 ino
= strtosysint (strp
, &ebuf
,
1049 TYPE_MINIMUM (ino_t
), TYPE_MAXIMUM (ino_t
));
1051 if (errno
|| *strp
!= ' ')
1052 ERROR ((0, errno
, "%s:%ld: %s",
1053 quotearg_colon (listed_incremental_option
), lineno
,
1054 _("Invalid inode number")));
1057 unquote_string (strp
);
1058 note_directory (strp
, mtime
, dev
, ino
, nfs
, false, NULL
);
1063 /* Read a nul-terminated string from FP and store it in STK.
1064 Store the number of bytes read (including nul terminator) in PCOUNT.
1066 Return the last character read or EOF on end of file. */
1068 read_obstack (FILE *fp
, struct obstack
*stk
, size_t *pcount
)
1073 for (i
= 0, c
= getc (fp
); c
!= EOF
&& c
!= 0; c
= getc (fp
), i
++)
1074 obstack_1grow (stk
, c
);
1075 obstack_1grow (stk
, 0);
1081 /* Read from file FP a nul-terminated string and convert it to
1082 intmax_t. Return the resulting value in PVAL. Assume '-' has
1085 Throw a fatal error if the string cannot be converted or if the
1086 converted value is less than MIN_VAL. */
1089 read_negative_num (FILE *fp
, intmax_t min_val
, intmax_t *pval
)
1093 char buf
[INT_BUFSIZE_BOUND (intmax_t)];
1097 for (i
= 1; ISDIGIT (c
= getc (fp
)); i
++)
1099 if (i
== sizeof buf
- 1)
1100 FATAL_ERROR ((0, 0, _("Field too long while reading snapshot file")));
1107 FATAL_ERROR ((0, errno
, _("Read error in snapshot file")));
1109 FATAL_ERROR ((0, 0, _("Unexpected EOF in snapshot file")));
1114 *pval
= strtoimax (buf
, &ep
, 10);
1115 if (c
|| errno
|| *pval
< min_val
)
1116 FATAL_ERROR ((0, errno
, _("Unexpected field value in snapshot file")));
1119 /* Read from file FP a nul-terminated string and convert it to
1120 uintmax_t. Return the resulting value in PVAL. Assume C has
1123 Throw a fatal error if the string cannot be converted or if the
1124 converted value exceeds MAX_VAL.
1126 Return the last character read or EOF on end of file. */
1129 read_unsigned_num (int c
, FILE *fp
, uintmax_t max_val
, uintmax_t *pval
)
1132 char buf
[UINTMAX_STRSIZE_BOUND
], *ep
;
1134 for (i
= 0; ISDIGIT (c
); i
++)
1136 if (i
== sizeof buf
- 1)
1137 FATAL_ERROR ((0, 0, _("Field too long while reading snapshot file")));
1145 FATAL_ERROR ((0, errno
, _("Read error in snapshot file")));
1149 FATAL_ERROR ((0, 0, _("Unexpected EOF in snapshot file")));
1154 *pval
= strtoumax (buf
, &ep
, 10);
1155 if (c
|| errno
|| max_val
< *pval
)
1156 FATAL_ERROR ((0, errno
, _("Unexpected field value in snapshot file")));
1160 /* Read from file FP a nul-terminated string and convert it to
1161 uintmax_t. Return the resulting value in PVAL.
1163 Throw a fatal error if the string cannot be converted or if the
1164 converted value exceeds MAX_VAL.
1166 Return the last character read or EOF on end of file. */
1169 read_num (FILE *fp
, uintmax_t max_val
, uintmax_t *pval
)
1171 return read_unsigned_num (getc (fp
), fp
, max_val
, pval
);
1174 /* Read from FP two NUL-terminated strings representing a struct
1175 timespec. Return the resulting value in PVAL.
1177 Throw a fatal error if the string cannot be converted. */
1180 read_timespec (FILE *fp
, struct timespec
*pval
)
1188 read_negative_num (fp
, TYPE_MINIMUM (time_t), &i
);
1194 c
= read_unsigned_num (c
, fp
, TYPE_MAXIMUM (time_t), &u
);
1198 if (c
|| read_num (fp
, BILLION
- 1, &u
))
1199 FATAL_ERROR ((0, 0, "%s: %s",
1200 quotearg_colon (listed_incremental_option
),
1201 _("Unexpected EOF in snapshot file")));
1205 /* Read incremental snapshot format 2 */
1207 read_incr_db_2 (void)
1212 obstack_init (&stk
);
1214 read_timespec (listed_incremental_stream
, &newer_mtime_option
);
1218 struct timespec mtime
;
1226 if (read_num (listed_incremental_stream
, 1, &u
))
1227 return; /* Normal return */
1231 read_timespec (listed_incremental_stream
, &mtime
);
1233 if (read_num (listed_incremental_stream
, TYPE_MAXIMUM (dev_t
), &u
))
1237 if (read_num (listed_incremental_stream
, TYPE_MAXIMUM (ino_t
), &u
))
1241 if (read_obstack (listed_incremental_stream
, &stk
, &s
))
1244 name
= obstack_finish (&stk
);
1246 while (read_obstack (listed_incremental_stream
, &stk
, &s
) == 0 && s
> 1)
1248 if (getc (listed_incremental_stream
) != 0)
1249 FATAL_ERROR ((0, 0, "%s: %s",
1250 quotearg_colon (listed_incremental_option
),
1251 _("Missing record terminator")));
1253 content
= obstack_finish (&stk
);
1254 note_directory (name
, mtime
, dev
, ino
, nfs
, false, content
);
1255 obstack_free (&stk
, content
);
1257 FATAL_ERROR ((0, 0, "%s: %s",
1258 quotearg_colon (listed_incremental_option
),
1259 _("Unexpected EOF in snapshot file")));
1262 /* Read incremental snapshot file (directory file).
1263 If the file has older incremental version, make sure that it is processed
1264 correctly and that tar will use the most conservative backup method among
1265 possible alternatives (i.e. prefer ALL_CHILDREN over CHANGED_CHILDREN,
1266 etc.) This ensures that the snapshots are updated to the recent version
1267 without any loss of data. */
1269 read_directory_file (void)
1274 int flags
= O_RDWR
| O_CREAT
;
1276 if (incremental_level
== 0)
1278 /* Open the file for both read and write. That way, we can write
1279 it later without having to reopen it, and don't have to worry if
1280 we chdir in the meantime. */
1281 fd
= open (listed_incremental_option
, flags
, MODE_RW
);
1284 open_error (listed_incremental_option
);
1288 listed_incremental_stream
= fdopen (fd
, "r+");
1289 if (! listed_incremental_stream
)
1291 open_error (listed_incremental_option
);
1296 /* Consume the first name from the name list and reset the
1297 list afterwards. This is done to change to the new
1298 directory, if the first name is a chdir request (-C dir),
1299 which is necessary to recreate absolute file names. */
1303 if (0 < getline (&buf
, &bufsize
, listed_incremental_stream
))
1306 uintmax_t incremental_version
;
1308 if (strncmp (buf
, PACKAGE_NAME
, sizeof PACKAGE_NAME
- 1) == 0)
1310 ebuf
= buf
+ sizeof PACKAGE_NAME
- 1;
1312 ERROR((1, 0, _("Bad incremental file format")));
1313 for (; *ebuf
!= '-'; ebuf
++)
1315 ERROR((1, 0, _("Bad incremental file format")));
1317 incremental_version
= strtoumax (ebuf
+ 1, NULL
, 10);
1320 incremental_version
= 0;
1322 switch (incremental_version
)
1326 read_incr_db_01 (incremental_version
, buf
);
1329 case TAR_INCREMENTAL_VERSION
:
1334 ERROR ((1, 0, _("Unsupported incremental format version: %"PRIuMAX
),
1335 incremental_version
));
1340 if (ferror (listed_incremental_stream
))
1341 read_error (listed_incremental_option
);
1345 /* Output incremental data for the directory ENTRY to the file DATA.
1346 Return nonzero if successful, preserving errno on write failure. */
1348 write_directory_file_entry (void *entry
, void *data
)
1350 struct directory
const *directory
= entry
;
1353 if (DIR_IS_FOUND (directory
))
1355 char buf
[max (SYSINT_BUFSIZE
, INT_BUFSIZE_BOUND (intmax_t))];
1358 s
= DIR_IS_NFS (directory
) ? "1" : "0";
1359 fwrite (s
, 2, 1, fp
);
1360 s
= sysinttostr (directory
->mtime
.tv_sec
, TYPE_MINIMUM (time_t),
1361 TYPE_MAXIMUM (time_t), buf
);
1362 fwrite (s
, strlen (s
) + 1, 1, fp
);
1363 s
= imaxtostr (directory
->mtime
.tv_nsec
, buf
);
1364 fwrite (s
, strlen (s
) + 1, 1, fp
);
1365 s
= sysinttostr (directory
->device_number
,
1366 TYPE_MINIMUM (dev_t
), TYPE_MAXIMUM (dev_t
), buf
);
1367 fwrite (s
, strlen (s
) + 1, 1, fp
);
1368 s
= sysinttostr (directory
->inode_number
,
1369 TYPE_MINIMUM (ino_t
), TYPE_MAXIMUM (ino_t
), buf
);
1370 fwrite (s
, strlen (s
) + 1, 1, fp
);
1372 fwrite (directory
->name
, strlen (directory
->name
) + 1, 1, fp
);
1373 if (directory
->dump
)
1376 struct dumpdir_iter
*itr
;
1378 for (p
= dumpdir_first (directory
->dump
, 0, &itr
);
1380 p
= dumpdir_next (itr
))
1381 fwrite (p
, strlen (p
) + 1, 1, fp
);
1384 fwrite ("\0\0", 2, 1, fp
);
1387 return ! ferror (fp
);
1391 write_directory_file (void)
1393 FILE *fp
= listed_incremental_stream
;
1394 char buf
[UINTMAX_STRSIZE_BOUND
];
1400 if (fseeko (fp
, 0L, SEEK_SET
) != 0)
1401 seek_error (listed_incremental_option
);
1402 if (sys_truncate (fileno (fp
)) != 0)
1403 truncate_error (listed_incremental_option
);
1405 fprintf (fp
, "%s-%s-%d\n", PACKAGE_NAME
, PACKAGE_VERSION
,
1406 TAR_INCREMENTAL_VERSION
);
1408 s
= (TYPE_SIGNED (time_t)
1409 ? imaxtostr (start_time
.tv_sec
, buf
)
1410 : umaxtostr (start_time
.tv_sec
, buf
));
1411 fwrite (s
, strlen (s
) + 1, 1, fp
);
1412 s
= umaxtostr (start_time
.tv_nsec
, buf
);
1413 fwrite (s
, strlen (s
) + 1, 1, fp
);
1415 if (! ferror (fp
) && directory_table
)
1416 hash_do_for_each (directory_table
, write_directory_file_entry
, fp
);
1419 write_error (listed_incremental_option
);
1420 if (fclose (fp
) != 0)
1421 close_error (listed_incremental_option
);
1425 /* Restoration of incremental dumps. */
1428 get_gnu_dumpdir (struct tar_stat_info
*stat_info
)
1432 union block
*data_block
;
1436 size
= stat_info
->stat
.st_size
;
1438 archive_dir
= xmalloc (size
);
1441 set_next_block_after (current_header
);
1442 mv_begin_read (stat_info
);
1444 for (; size
> 0; size
-= copied
)
1446 mv_size_left (size
);
1447 data_block
= find_next_block ();
1449 ERROR ((1, 0, _("Unexpected EOF in archive")));
1450 copied
= available_space_after (data_block
);
1453 memcpy (to
, data_block
->buffer
, copied
);
1455 set_next_block_after ((union block
*)
1456 (data_block
->buffer
+ copied
- 1));
1461 stat_info
->dumpdir
= archive_dir
;
1462 stat_info
->skipped
= true; /* For skip_member() and friends
1463 to work correctly */
1466 /* Return T if STAT_INFO represents a dumpdir archive member.
1467 Note: can invalidate current_header. It happens if flush_archive()
1468 gets called within get_gnu_dumpdir() */
1470 is_dumpdir (struct tar_stat_info
*stat_info
)
1472 if (stat_info
->is_dumpdir
&& !stat_info
->dumpdir
)
1473 get_gnu_dumpdir (stat_info
);
1474 return stat_info
->is_dumpdir
;
1478 dumpdir_ok (char *dumpdir
)
1481 int has_tempdir
= 0;
1484 for (p
= dumpdir
; *p
; p
+= strlen (p
) + 1)
1486 if (expect
&& *p
!= expect
)
1489 _("Malformed dumpdir: expected '%c' but found %#3o"),
1499 _("Malformed dumpdir: 'X' duplicated")));
1512 _("Malformed dumpdir: empty name in 'R'")));
1525 _("Malformed dumpdir: 'T' not preceeded by 'R'")));
1528 if (p
[1] == 0 && !has_tempdir
)
1531 _("Malformed dumpdir: empty name in 'T'")));
1543 /* FIXME: bail out? */
1551 _("Malformed dumpdir: expected '%c' but found end of data"),
1557 WARNOPT (WARN_BAD_DUMPDIR
,
1558 (0, 0, _("Malformed dumpdir: 'X' never used")));
1563 /* Examine the directories under directory_name and delete any
1564 files that were not there at the time of the back-up. */
1566 try_purge_directory (char const *directory_name
)
1569 char *cur
, *arc
, *p
;
1570 char *temp_stub
= NULL
;
1571 struct dumpdir
*dump
;
1573 if (!is_dumpdir (¤t_stat_info
))
1576 current_dir
= savedir (directory_name
);
1579 /* The directory doesn't exist now. It'll be created. In any
1580 case, we don't have to delete any files out of it. */
1583 /* Verify if dump directory is sane */
1584 if (!dumpdir_ok (current_stat_info
.dumpdir
))
1587 /* Process renames */
1588 for (arc
= current_stat_info
.dumpdir
; *arc
; arc
+= strlen (arc
) + 1)
1592 #define TEMP_DIR_TEMPLATE "tar.XXXXXX"
1593 size_t len
= strlen (arc
+ 1);
1594 temp_stub
= xrealloc (temp_stub
, len
+ 1 + sizeof TEMP_DIR_TEMPLATE
);
1595 memcpy (temp_stub
, arc
+ 1, len
);
1596 temp_stub
[len
] = '/';
1597 memcpy (temp_stub
+ len
+ 1, TEMP_DIR_TEMPLATE
,
1598 sizeof TEMP_DIR_TEMPLATE
);
1599 if (!mkdtemp (temp_stub
))
1602 _("Cannot create temporary directory using template %s"),
1603 quote (temp_stub
)));
1609 else if (*arc
== 'R')
1613 arc
+= strlen (arc
) + 1;
1616 /* Ensure that neither source nor destination are absolute file
1617 names (unless permitted by -P option), and that they do not
1618 contain dubious parts (e.g. ../).
1620 This is an extra safety precaution. Besides, it might be
1621 necessary to extract from archives created with tar versions
1625 src
= safer_name_suffix (src
, false, absolute_names_option
);
1627 dst
= safer_name_suffix (dst
, false, absolute_names_option
);
1634 if (!rename_directory (src
, dst
))
1638 /* FIXME: Make sure purge_directory(dst) will return
1647 /* Process deletes */
1648 dump
= dumpdir_create (current_stat_info
.dumpdir
);
1650 for (cur
= current_dir
; *cur
; cur
+= strlen (cur
) + 1)
1655 p
= new_name (directory_name
, cur
);
1657 if (deref_stat (p
, &st
) != 0)
1659 if (errno
!= ENOENT
) /* FIXME: Maybe keep a list of renamed
1660 dirs and check it here? */
1663 WARN ((0, 0, _("%s: Not purging directory: unable to stat"),
1664 quotearg_colon (p
)));
1669 if (!(entry
= dumpdir_locate (dump
, cur
))
1670 || (*entry
== 'D' && !S_ISDIR (st
.st_mode
))
1671 || (*entry
== 'Y' && S_ISDIR (st
.st_mode
)))
1673 if (one_file_system_option
&& st
.st_dev
!= root_device
)
1676 _("%s: directory is on a different device: not purging"),
1677 quotearg_colon (p
)));
1681 if (! interactive_option
|| confirm ("delete", p
))
1684 fprintf (stdlis
, _("%s: Deleting %s\n"),
1685 program_name
, quote (p
));
1686 if (! remove_any_file (p
, RECURSIVE_REMOVE_OPTION
))
1689 ERROR ((0, e
, _("%s: Cannot remove"), quotearg_colon (p
)));
1695 dumpdir_free (dump
);
1702 purge_directory (char const *directory_name
)
1704 if (!try_purge_directory (directory_name
))
1709 list_dumpdir (char *buffer
, size_t size
)
1722 fprintf (stdlis
, "%c", *buffer
);
1725 fprintf (stdlis
, " ");
1733 fputc ('\n', stdlis
);
1740 fputc (*buffer
, stdlis
);