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
);
450 if ((directory
= find_directory (name_buffer
)) != NULL
)
452 if (DIR_IS_INITED (directory
))
454 if (flag
& PD_FORCE_INIT
)
456 assign_string (&directory
->name
, name_buffer
);
460 *entry
= 'N'; /* Avoid duplicating this directory */
465 if (strcmp (directory
->name
, name_buffer
))
471 /* With NFS, the same file can have two different devices
472 if an NFS directory is mounted in multiple locations,
473 which is relatively common when automounting.
474 To avoid spurious incremental redumping of
475 directories, consider all NFS devices as equal,
476 relying on the i-node to establish differences. */
478 if (! ((!check_device_option
479 || (DIR_IS_NFS (directory
) && nfs
)
480 || directory
->device_number
== stat_data
->st_dev
)
481 && directory
->inode_number
== stat_data
->st_ino
))
483 /* FIXME: find_directory_meta ignores nfs */
484 struct directory
*d
= find_directory_meta (stat_data
->st_dev
,
488 if (strcmp (d
->name
, name_buffer
))
490 WARNOPT (WARN_RENAME_DIRECTORY
,
492 _("%s: Directory has been renamed from %s"),
493 quotearg_colon (name_buffer
),
494 quote_n (1, d
->name
)));
496 DIR_SET_FLAG (directory
, DIRF_RENAMED
);
497 dirlist_replace_prefix (d
->name
, name_buffer
);
499 directory
->children
= CHANGED_CHILDREN
;
503 WARNOPT (WARN_RENAME_DIRECTORY
,
504 (0, 0, _("%s: Directory has been renamed"),
505 quotearg_colon (name_buffer
)));
506 directory
->children
= ALL_CHILDREN
;
507 directory
->device_number
= stat_data
->st_dev
;
508 directory
->inode_number
= stat_data
->st_ino
;
511 DIR_SET_FLAG (directory
, DIRF_NFS
);
514 directory
->children
= CHANGED_CHILDREN
;
516 DIR_SET_FLAG (directory
, DIRF_FOUND
);
520 struct directory
*d
= find_directory_meta (stat_data
->st_dev
,
523 directory
= note_directory (name_buffer
,
524 get_stat_mtime(stat_data
),
533 if (strcmp (d
->name
, name_buffer
))
535 WARNOPT (WARN_RENAME_DIRECTORY
,
536 (0, 0, _("%s: Directory has been renamed from %s"),
537 quotearg_colon (name_buffer
),
538 quote_n (1, d
->name
)));
540 DIR_SET_FLAG (directory
, DIRF_RENAMED
);
541 dirlist_replace_prefix (d
->name
, name_buffer
);
543 directory
->children
= CHANGED_CHILDREN
;
547 DIR_SET_FLAG (directory
, DIRF_NEW
);
548 WARNOPT (WARN_NEW_DIRECTORY
,
549 (0, 0, _("%s: Directory is new"),
550 quotearg_colon (name_buffer
)));
551 directory
->children
=
552 (listed_incremental_option
553 || (OLDER_STAT_TIME (*stat_data
, m
)
554 || (after_date_option
555 && OLDER_STAT_TIME (*stat_data
, c
))))
561 if (one_file_system_option
&& st
->parent
562 && stat_data
->st_dev
!= st
->parent
->stat
.st_dev
)
566 _("%s: directory is on a different filesystem; not dumped"),
567 quotearg_colon (directory->name)));
569 directory
->children
= NO_CHILDREN
;
570 else if (flag
& PD_FORCE_CHILDREN
)
572 directory
->children
= PD_CHILDREN(flag
);
573 if (directory
->children
== NO_CHILDREN
)
577 DIR_SET_FLAG (directory
, DIRF_INIT
);
579 if (directory
->children
!= NO_CHILDREN
)
581 const char *tag_file_name
;
583 switch (check_exclusion_tags (st
, &tag_file_name
))
585 case exclusion_tag_all
:
586 /* This warning can be duplicated by code in dump_file0, but only
587 in case when the topmost directory being archived contains
589 exclusion_tag_warning (name_buffer
, tag_file_name
,
590 _("directory not dumped"));
592 directory
->children
= NO_CHILDREN
;
595 case exclusion_tag_contents
:
596 exclusion_tag_warning (name_buffer
, tag_file_name
,
597 _("contents not dumped"));
598 directory
->children
= NO_CHILDREN
;
601 case exclusion_tag_under
:
602 exclusion_tag_warning (name_buffer
, tag_file_name
,
603 _("contents not dumped"));
604 directory
->tagfile
= tag_file_name
;
607 case exclusion_tag_none
:
615 /* Compare dumpdir array from DIRECTORY with directory listing DIR and
616 build a new dumpdir template.
618 DIR must be returned by a previous call to savedir().
620 File names in DIRECTORY->dump->contents must be sorted
623 DIRECTORY->dump is replaced with the created template. Each entry is
624 prefixed with ' ' if it was present in DUMP and with 'Y' otherwise. */
627 makedumpdir (struct directory
*directory
, const char *dir
)
630 dirsize
, /* Number of elements in DIR */
631 len
; /* Length of DIR, including terminating nul */
634 char *new_dump
, *new_dump_ptr
;
635 struct dumpdir
*dump
;
637 if (directory
->children
== ALL_CHILDREN
)
639 else if (DIR_IS_RENAMED (directory
))
640 dump
= directory
->orig
->idump
?
641 directory
->orig
->idump
: directory
->orig
->dump
;
643 dump
= directory
->dump
;
645 /* Count the size of DIR and the number of elements it contains */
648 for (p
= dir
; *p
; p
+= strlen (p
) + 1, dirsize
++)
649 len
+= strlen (p
) + 2;
652 /* Create a sorted directory listing */
653 array
= xcalloc (dirsize
, sizeof array
[0]);
654 for (i
= 0, p
= dir
; *p
; p
+= strlen (p
) + 1, i
++)
657 qsort (array
, dirsize
, sizeof (array
[0]), compare_dirnames
);
659 /* Prepare space for new dumpdir */
660 new_dump
= xmalloc (len
);
661 new_dump_ptr
= new_dump
;
663 /* Fill in the dumpdir template */
664 for (i
= 0; i
< dirsize
; i
++)
666 const char *loc
= dumpdir_locate (dump
, array
[i
]);
669 if (directory
->tagfile
)
670 *new_dump_ptr
= strcmp (directory
->tagfile
, array
[i
]) == 0 ?
676 else if (directory
->tagfile
)
677 *new_dump_ptr
++ = strcmp (directory
->tagfile
, array
[i
]) == 0 ?
680 *new_dump_ptr
++ = 'Y'; /* New entry */
682 /* Copy the file name */
683 for (p
= array
[i
]; (*new_dump_ptr
++ = *p
++); )
687 directory
->idump
= directory
->dump
;
688 directory
->dump
= dumpdir_create0 (new_dump
, NULL
);
692 /* Recursively scan the directory identified by ST. */
694 scan_directory (struct tar_stat_info
*st
)
696 char const *dir
= st
->orig_file_name
;
697 char *dirp
= get_directory_entries (st
);
698 dev_t device
= st
->stat
.st_dev
;
699 bool cmdline
= ! st
->parent
;
702 struct directory
*directory
;
711 directory
= procdir (tmp
, st
,
712 (cmdline
? PD_FORCE_INIT
: 0),
717 nbuf
= namebuf_create (dir
);
719 if (dirp
&& directory
->children
!= NO_CHILDREN
)
721 char *entry
; /* directory entry being scanned */
722 struct dumpdir_iter
*itr
;
724 makedumpdir (directory
, dirp
);
726 for (entry
= dumpdir_first (directory
->dump
, 1, &itr
);
728 entry
= dumpdir_next (itr
))
730 char *full_name
= namebuf_name (nbuf
, entry
+ 1);
732 if (*entry
== 'I') /* Ignored entry */
734 else if (excluded_name (full_name
))
739 void (*diag
) (char const *) = 0;
740 struct tar_stat_info stsub
;
741 tar_stat_init (&stsub
);
748 else if (fstatat (fd
, entry
+ 1, &stsub
.stat
, fstatat_flags
) != 0)
750 else if (S_ISDIR (stsub
.stat
.st_mode
))
752 int subfd
= subfile_open (st
, entry
+ 1, open_read_flags
);
758 if (fstat (subfd
, &stsub
.stat
) != 0)
765 file_removed_diag (full_name
, false, diag
);
768 else if (S_ISDIR (stsub
.stat
.st_mode
))
771 if (!recursion_option
)
772 pd_flag
|= PD_FORCE_CHILDREN
| NO_CHILDREN
;
773 else if (directory
->children
== ALL_CHILDREN
)
774 pd_flag
|= PD_FORCE_CHILDREN
| ALL_CHILDREN
;
778 procdir (full_name
, &stsub
, pd_flag
, entry
);
779 restore_parent_fd (&stsub
);
781 else if (one_file_system_option
&& device
!= stsub
.stat
.st_dev
)
783 else if (*entry
== 'Y')
784 /* New entry, skip further checks */;
785 /* FIXME: if (S_ISHIDDEN (stat_data.st_mode))?? */
786 else if (OLDER_STAT_TIME (stsub
.stat
, m
)
787 && (!after_date_option
788 || OLDER_STAT_TIME (stsub
.stat
, c
)))
793 tar_stat_destroy (&stsub
);
806 /* Return pointer to the contents of the directory DIR */
808 directory_contents (struct directory
*dir
)
812 return dir
->dump
? dir
->dump
->contents
: NULL
;
815 /* A "safe" version of directory_contents, which never returns NULL. */
817 safe_directory_contents (struct directory
*dir
)
819 const char *ret
= directory_contents (dir
);
820 return ret
? ret
: "\0\0\0\0";
825 obstack_code_rename (struct obstack
*stk
, char const *from
, char const *to
)
829 s
= from
[0] == 0 ? from
:
830 safer_name_suffix (from
, false, absolute_names_option
);
831 obstack_1grow (stk
, 'R');
832 obstack_grow (stk
, s
, strlen (s
) + 1);
835 safer_name_suffix (to
, false, absolute_names_option
);
836 obstack_1grow (stk
, 'T');
837 obstack_grow (stk
, s
, strlen (s
) + 1);
841 store_rename (struct directory
*dir
, struct obstack
*stk
)
843 if (DIR_IS_RENAMED (dir
))
845 struct directory
*prev
, *p
;
847 /* Detect eventual cycles and clear DIRF_RENAMED flag, so these entries
848 are ignored when hit by this function next time.
849 If the chain forms a cycle, prev points to the entry DIR is renamed
850 from. In this case it still retains DIRF_RENAMED flag, which will be
851 cleared in the 'else' branch below */
852 for (prev
= dir
; prev
&& prev
->orig
!= dir
; prev
= prev
->orig
)
853 DIR_CLEAR_FLAG (prev
, DIRF_RENAMED
);
857 for (p
= dir
; p
&& p
->orig
; p
= p
->orig
)
858 obstack_code_rename (stk
, p
->orig
->name
, p
->name
);
864 DIR_CLEAR_FLAG (prev
, DIRF_RENAMED
);
866 /* Break the cycle by using a temporary name for one of its
868 First, create a temp name stub entry. */
869 temp_name
= dir_name (dir
->name
);
870 obstack_1grow (stk
, 'X');
871 obstack_grow (stk
, temp_name
, strlen (temp_name
) + 1);
873 obstack_code_rename (stk
, dir
->name
, "");
875 for (p
= dir
; p
!= prev
; p
= p
->orig
)
876 obstack_code_rename (stk
, p
->orig
->name
, p
->name
);
878 obstack_code_rename (stk
, "", prev
->name
);
884 append_incremental_renames (struct directory
*dir
)
888 struct directory
*dp
;
895 dump
= directory_contents (dir
);
898 size
= dumpdir_size (dump
) - 1;
899 obstack_grow (&stk
, dump
, size
);
904 for (dp
= dirhead
; dp
; dp
= dp
->next
)
905 store_rename (dp
, &stk
);
907 /* FIXME: Is this the right thing to do when DIR is null? */
908 if (dir
&& obstack_object_size (&stk
) != size
)
910 obstack_1grow (&stk
, 0);
911 dumpdir_free (dir
->dump
);
912 dir
->dump
= dumpdir_create (obstack_finish (&stk
));
914 obstack_free (&stk
, NULL
);
919 static FILE *listed_incremental_stream
;
921 /* Version of incremental format snapshots (directory files) used by this
922 tar. Currently it is supposed to be a single decimal number. 0 means
923 incremental snapshots as per tar version before 1.15.2.
925 The current tar version supports incremental versions from
926 0 up to TAR_INCREMENTAL_VERSION, inclusive.
927 It is able to create only snapshots of TAR_INCREMENTAL_VERSION */
929 #define TAR_INCREMENTAL_VERSION 2
931 /* Read incremental snapshot formats 0 and 1 */
933 read_incr_db_01 (int version
, const char *initbuf
)
946 if (getline (&buf
, &bufsize
, listed_incremental_stream
) <= 0)
948 read_error (listed_incremental_option
);
956 buf
= strdup (initbuf
);
957 bufsize
= strlen (buf
) + 1;
960 sec
= TYPE_MINIMUM (time_t);
963 u
= strtoumax (buf
, &ebuf
, 10);
964 if (!errno
&& TYPE_MAXIMUM (time_t) < u
)
966 if (errno
|| buf
== ebuf
)
967 ERROR ((0, errno
, "%s:%ld: %s",
968 quotearg_colon (listed_incremental_option
),
970 _("Invalid time stamp")));
975 if (version
== 1 && *ebuf
)
977 char const *buf_ns
= ebuf
+ 1;
979 u
= strtoumax (buf_ns
, &ebuf
, 10);
980 if (!errno
&& BILLION
<= u
)
982 if (errno
|| buf_ns
== ebuf
)
984 ERROR ((0, errno
, "%s:%ld: %s",
985 quotearg_colon (listed_incremental_option
),
987 _("Invalid time stamp")));
988 sec
= TYPE_MINIMUM (time_t);
995 /* pre-1 incremental format does not contain nanoseconds */
999 newer_mtime_option
.tv_sec
= sec
;
1000 newer_mtime_option
.tv_nsec
= nsec
;
1003 while (0 < (n
= getline (&buf
, &bufsize
, listed_incremental_stream
)))
1007 bool nfs
= buf
[0] == '+';
1008 char *strp
= buf
+ nfs
;
1009 struct timespec mtime
;
1013 if (buf
[n
- 1] == '\n')
1019 u
= strtoumax (strp
, &ebuf
, 10);
1020 if (!errno
&& TYPE_MAXIMUM (time_t) < u
)
1022 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
1024 ERROR ((0, errno
, "%s:%ld: %s",
1025 quotearg_colon (listed_incremental_option
), lineno
,
1026 _("Invalid modification time (seconds)")));
1034 u
= strtoumax (strp
, &ebuf
, 10);
1035 if (!errno
&& BILLION
<= u
)
1037 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
1039 ERROR ((0, errno
, "%s:%ld: %s",
1040 quotearg_colon (listed_incremental_option
), lineno
,
1041 _("Invalid modification time (nanoseconds)")));
1047 mtime
.tv_nsec
= nsec
;
1051 memset (&mtime
, 0, sizeof mtime
);
1054 u
= strtoumax (strp
, &ebuf
, 10);
1055 if (!errno
&& TYPE_MAXIMUM (dev_t
) < u
)
1057 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
1059 ERROR ((0, errno
, "%s:%ld: %s",
1060 quotearg_colon (listed_incremental_option
), lineno
,
1061 _("Invalid device number")));
1069 u
= strtoumax (strp
, &ebuf
, 10);
1070 if (!errno
&& TYPE_MAXIMUM (ino_t
) < u
)
1072 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
1074 ERROR ((0, errno
, "%s:%ld: %s",
1075 quotearg_colon (listed_incremental_option
), lineno
,
1076 _("Invalid inode number")));
1084 unquote_string (strp
);
1085 note_directory (strp
, mtime
, dev
, ino
, nfs
, false, NULL
);
1090 /* Read a nul-terminated string from FP and store it in STK.
1091 Store the number of bytes read (including nul terminator) in PCOUNT.
1093 Return the last character read or EOF on end of file. */
1095 read_obstack (FILE *fp
, struct obstack
*stk
, size_t *pcount
)
1100 for (i
= 0, c
= getc (fp
); c
!= EOF
&& c
!= 0; c
= getc (fp
), i
++)
1101 obstack_1grow (stk
, c
);
1102 obstack_1grow (stk
, 0);
1108 /* Read from file FP a nul-terminated string and convert it to
1109 intmax_t. Return the resulting value in PVAL. Assume '-' has
1112 Throw a fatal error if the string cannot be converted or if the
1113 converted value is less than MIN_VAL. */
1116 read_negative_num (FILE *fp
, intmax_t min_val
, intmax_t *pval
)
1120 char buf
[INT_BUFSIZE_BOUND (intmax_t)];
1124 for (i
= 1; ISDIGIT (c
= getc (fp
)); i
++)
1126 if (i
== sizeof buf
- 1)
1127 FATAL_ERROR ((0, 0, _("Field too long while reading snapshot file")));
1134 FATAL_ERROR ((0, errno
, _("Read error in snapshot file")));
1136 FATAL_ERROR ((0, 0, _("Unexpected EOF in snapshot file")));
1141 *pval
= strtoimax (buf
, &ep
, 10);
1142 if (c
|| errno
|| *pval
< min_val
)
1143 FATAL_ERROR ((0, errno
, _("Unexpected field value in snapshot file")));
1146 /* Read from file FP a nul-terminated string and convert it to
1147 uintmax_t. Return the resulting value in PVAL. Assume C has
1150 Throw a fatal error if the string cannot be converted or if the
1151 converted value exceeds MAX_VAL.
1153 Return the last character read or EOF on end of file. */
1156 read_unsigned_num (int c
, FILE *fp
, uintmax_t max_val
, uintmax_t *pval
)
1159 char buf
[UINTMAX_STRSIZE_BOUND
], *ep
;
1161 for (i
= 0; ISDIGIT (c
); i
++)
1163 if (i
== sizeof buf
- 1)
1164 FATAL_ERROR ((0, 0, _("Field too long while reading snapshot file")));
1172 FATAL_ERROR ((0, errno
, _("Read error in snapshot file")));
1176 FATAL_ERROR ((0, 0, _("Unexpected EOF in snapshot file")));
1181 *pval
= strtoumax (buf
, &ep
, 10);
1182 if (c
|| errno
|| max_val
< *pval
)
1183 FATAL_ERROR ((0, errno
, _("Unexpected field value in snapshot file")));
1187 /* Read from file FP a nul-terminated string and convert it to
1188 uintmax_t. Return the resulting value in PVAL.
1190 Throw a fatal error if the string cannot be converted or if the
1191 converted value exceeds MAX_VAL.
1193 Return the last character read or EOF on end of file. */
1196 read_num (FILE *fp
, uintmax_t max_val
, uintmax_t *pval
)
1198 return read_unsigned_num (getc (fp
), fp
, max_val
, pval
);
1201 /* Read from FP two NUL-terminated strings representing a struct
1202 timespec. Return the resulting value in PVAL.
1204 Throw a fatal error if the string cannot be converted. */
1207 read_timespec (FILE *fp
, struct timespec
*pval
)
1215 read_negative_num (fp
, TYPE_MINIMUM (time_t), &i
);
1221 c
= read_unsigned_num (c
, fp
, TYPE_MAXIMUM (time_t), &u
);
1225 if (c
|| read_num (fp
, BILLION
- 1, &u
))
1226 FATAL_ERROR ((0, 0, "%s: %s",
1227 quotearg_colon (listed_incremental_option
),
1228 _("Unexpected EOF in snapshot file")));
1232 /* Read incremental snapshot format 2 */
1234 read_incr_db_2 (void)
1239 obstack_init (&stk
);
1241 read_timespec (listed_incremental_stream
, &newer_mtime_option
);
1245 struct timespec mtime
;
1253 if (read_num (listed_incremental_stream
, 1, &u
))
1254 return; /* Normal return */
1258 read_timespec (listed_incremental_stream
, &mtime
);
1260 if (read_num (listed_incremental_stream
, TYPE_MAXIMUM (dev_t
), &u
))
1264 if (read_num (listed_incremental_stream
, TYPE_MAXIMUM (ino_t
), &u
))
1268 if (read_obstack (listed_incremental_stream
, &stk
, &s
))
1271 name
= obstack_finish (&stk
);
1273 while (read_obstack (listed_incremental_stream
, &stk
, &s
) == 0 && s
> 1)
1275 if (getc (listed_incremental_stream
) != 0)
1276 FATAL_ERROR ((0, 0, "%s: %s",
1277 quotearg_colon (listed_incremental_option
),
1278 _("Missing record terminator")));
1280 content
= obstack_finish (&stk
);
1281 note_directory (name
, mtime
, dev
, ino
, nfs
, false, content
);
1282 obstack_free (&stk
, content
);
1284 FATAL_ERROR ((0, 0, "%s: %s",
1285 quotearg_colon (listed_incremental_option
),
1286 _("Unexpected EOF in snapshot file")));
1289 /* Read incremental snapshot file (directory file).
1290 If the file has older incremental version, make sure that it is processed
1291 correctly and that tar will use the most conservative backup method among
1292 possible alternatives (i.e. prefer ALL_CHILDREN over CHANGED_CHILDREN,
1293 etc.) This ensures that the snapshots are updated to the recent version
1294 without any loss of data. */
1296 read_directory_file (void)
1301 int flags
= O_RDWR
| O_CREAT
;
1303 if (incremental_level
== 0)
1305 /* Open the file for both read and write. That way, we can write
1306 it later without having to reopen it, and don't have to worry if
1307 we chdir in the meantime. */
1308 fd
= open (listed_incremental_option
, flags
, MODE_RW
);
1311 open_error (listed_incremental_option
);
1315 listed_incremental_stream
= fdopen (fd
, "r+");
1316 if (! listed_incremental_stream
)
1318 open_error (listed_incremental_option
);
1323 /* Consume the first name from the name list and reset the
1324 list afterwards. This is done to change to the new
1325 directory, if the first name is a chdir request (-C dir),
1326 which is necessary to recreate absolute file names. */
1330 if (0 < getline (&buf
, &bufsize
, listed_incremental_stream
))
1333 uintmax_t incremental_version
;
1335 if (strncmp (buf
, PACKAGE_NAME
, sizeof PACKAGE_NAME
- 1) == 0)
1337 ebuf
= buf
+ sizeof PACKAGE_NAME
- 1;
1339 ERROR((1, 0, _("Bad incremental file format")));
1340 for (; *ebuf
!= '-'; ebuf
++)
1342 ERROR((1, 0, _("Bad incremental file format")));
1344 incremental_version
= strtoumax (ebuf
+ 1, NULL
, 10);
1347 incremental_version
= 0;
1349 switch (incremental_version
)
1353 read_incr_db_01 (incremental_version
, buf
);
1356 case TAR_INCREMENTAL_VERSION
:
1361 ERROR ((1, 0, _("Unsupported incremental format version: %"PRIuMAX
),
1362 incremental_version
));
1367 if (ferror (listed_incremental_stream
))
1368 read_error (listed_incremental_option
);
1372 /* Output incremental data for the directory ENTRY to the file DATA.
1373 Return nonzero if successful, preserving errno on write failure. */
1375 write_directory_file_entry (void *entry
, void *data
)
1377 struct directory
const *directory
= entry
;
1380 if (DIR_IS_FOUND (directory
))
1382 char buf
[UINTMAX_STRSIZE_BOUND
];
1385 s
= DIR_IS_NFS (directory
) ? "1" : "0";
1386 fwrite (s
, 2, 1, fp
);
1387 s
= (TYPE_SIGNED (time_t)
1388 ? imaxtostr (directory
->mtime
.tv_sec
, buf
)
1389 : umaxtostr (directory
->mtime
.tv_sec
, buf
));
1390 fwrite (s
, strlen (s
) + 1, 1, fp
);
1391 s
= umaxtostr (directory
->mtime
.tv_nsec
, buf
);
1392 fwrite (s
, strlen (s
) + 1, 1, fp
);
1393 s
= umaxtostr (directory
->device_number
, buf
);
1394 fwrite (s
, strlen (s
) + 1, 1, fp
);
1395 s
= umaxtostr (directory
->inode_number
, buf
);
1396 fwrite (s
, strlen (s
) + 1, 1, fp
);
1398 fwrite (directory
->name
, strlen (directory
->name
) + 1, 1, fp
);
1399 if (directory
->dump
)
1402 struct dumpdir_iter
*itr
;
1404 for (p
= dumpdir_first (directory
->dump
, 0, &itr
);
1406 p
= dumpdir_next (itr
))
1407 fwrite (p
, strlen (p
) + 1, 1, fp
);
1410 fwrite ("\0\0", 2, 1, fp
);
1413 return ! ferror (fp
);
1417 write_directory_file (void)
1419 FILE *fp
= listed_incremental_stream
;
1420 char buf
[UINTMAX_STRSIZE_BOUND
];
1426 if (fseeko (fp
, 0L, SEEK_SET
) != 0)
1427 seek_error (listed_incremental_option
);
1428 if (sys_truncate (fileno (fp
)) != 0)
1429 truncate_error (listed_incremental_option
);
1431 fprintf (fp
, "%s-%s-%d\n", PACKAGE_NAME
, PACKAGE_VERSION
,
1432 TAR_INCREMENTAL_VERSION
);
1434 s
= (TYPE_SIGNED (time_t)
1435 ? imaxtostr (start_time
.tv_sec
, buf
)
1436 : umaxtostr (start_time
.tv_sec
, buf
));
1437 fwrite (s
, strlen (s
) + 1, 1, fp
);
1438 s
= umaxtostr (start_time
.tv_nsec
, buf
);
1439 fwrite (s
, strlen (s
) + 1, 1, fp
);
1441 if (! ferror (fp
) && directory_table
)
1442 hash_do_for_each (directory_table
, write_directory_file_entry
, fp
);
1445 write_error (listed_incremental_option
);
1446 if (fclose (fp
) != 0)
1447 close_error (listed_incremental_option
);
1451 /* Restoration of incremental dumps. */
1454 get_gnu_dumpdir (struct tar_stat_info
*stat_info
)
1458 union block
*data_block
;
1462 size
= stat_info
->stat
.st_size
;
1464 archive_dir
= xmalloc (size
);
1467 set_next_block_after (current_header
);
1468 mv_begin_read (stat_info
);
1470 for (; size
> 0; size
-= copied
)
1472 mv_size_left (size
);
1473 data_block
= find_next_block ();
1475 ERROR ((1, 0, _("Unexpected EOF in archive")));
1476 copied
= available_space_after (data_block
);
1479 memcpy (to
, data_block
->buffer
, copied
);
1481 set_next_block_after ((union block
*)
1482 (data_block
->buffer
+ copied
- 1));
1487 stat_info
->dumpdir
= archive_dir
;
1488 stat_info
->skipped
= true; /* For skip_member() and friends
1489 to work correctly */
1492 /* Return T if STAT_INFO represents a dumpdir archive member.
1493 Note: can invalidate current_header. It happens if flush_archive()
1494 gets called within get_gnu_dumpdir() */
1496 is_dumpdir (struct tar_stat_info
*stat_info
)
1498 if (stat_info
->is_dumpdir
&& !stat_info
->dumpdir
)
1499 get_gnu_dumpdir (stat_info
);
1500 return stat_info
->is_dumpdir
;
1504 dumpdir_ok (char *dumpdir
)
1507 int has_tempdir
= 0;
1510 for (p
= dumpdir
; *p
; p
+= strlen (p
) + 1)
1512 if (expect
&& *p
!= expect
)
1515 _("Malformed dumpdir: expected '%c' but found %#3o"),
1525 _("Malformed dumpdir: 'X' duplicated")));
1538 _("Malformed dumpdir: empty name in 'R'")));
1551 _("Malformed dumpdir: 'T' not preceeded by 'R'")));
1554 if (p
[1] == 0 && !has_tempdir
)
1557 _("Malformed dumpdir: empty name in 'T'")));
1569 /* FIXME: bail out? */
1577 _("Malformed dumpdir: expected '%c' but found end of data"),
1583 WARNOPT (WARN_BAD_DUMPDIR
,
1584 (0, 0, _("Malformed dumpdir: 'X' never used")));
1589 /* Examine the directories under directory_name and delete any
1590 files that were not there at the time of the back-up. */
1592 try_purge_directory (char const *directory_name
)
1595 char *cur
, *arc
, *p
;
1596 char *temp_stub
= NULL
;
1597 struct dumpdir
*dump
;
1599 if (!is_dumpdir (¤t_stat_info
))
1602 current_dir
= savedir (directory_name
);
1605 /* The directory doesn't exist now. It'll be created. In any
1606 case, we don't have to delete any files out of it. */
1609 /* Verify if dump directory is sane */
1610 if (!dumpdir_ok (current_stat_info
.dumpdir
))
1613 /* Process renames */
1614 for (arc
= current_stat_info
.dumpdir
; *arc
; arc
+= strlen (arc
) + 1)
1618 #define TEMP_DIR_TEMPLATE "tar.XXXXXX"
1619 size_t len
= strlen (arc
+ 1);
1620 temp_stub
= xrealloc (temp_stub
, len
+ 1 + sizeof TEMP_DIR_TEMPLATE
);
1621 memcpy (temp_stub
, arc
+ 1, len
);
1622 temp_stub
[len
] = '/';
1623 memcpy (temp_stub
+ len
+ 1, TEMP_DIR_TEMPLATE
,
1624 sizeof TEMP_DIR_TEMPLATE
);
1625 if (!mkdtemp (temp_stub
))
1628 _("Cannot create temporary directory using template %s"),
1629 quote (temp_stub
)));
1635 else if (*arc
== 'R')
1639 arc
+= strlen (arc
) + 1;
1642 /* Ensure that neither source nor destination are absolute file
1643 names (unless permitted by -P option), and that they do not
1644 contain dubious parts (e.g. ../).
1646 This is an extra safety precaution. Besides, it might be
1647 necessary to extract from archives created with tar versions
1651 src
= safer_name_suffix (src
, false, absolute_names_option
);
1653 dst
= safer_name_suffix (dst
, false, absolute_names_option
);
1660 if (!rename_directory (src
, dst
))
1664 /* FIXME: Make sure purge_directory(dst) will return
1673 /* Process deletes */
1674 dump
= dumpdir_create (current_stat_info
.dumpdir
);
1676 for (cur
= current_dir
; *cur
; cur
+= strlen (cur
) + 1)
1681 p
= new_name (directory_name
, cur
);
1683 if (deref_stat (p
, &st
) != 0)
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
);