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
);
303 /* Create and link a new directory entry for directory NAME, having a
304 device number DEV and an inode number INO, with NFS indicating
305 whether it is an NFS device and FOUND indicating whether we have
306 found that the directory exists. */
307 static struct directory
*
308 note_directory (char const *name
, struct timespec mtime
,
309 dev_t dev
, ino_t ino
, bool nfs
, bool found
,
310 const char *contents
)
312 struct directory
*directory
= attach_directory (name
);
314 directory
->mtime
= mtime
;
315 directory
->device_number
= dev
;
316 directory
->inode_number
= ino
;
317 directory
->children
= CHANGED_CHILDREN
;
319 DIR_SET_FLAG (directory
, DIRF_NFS
);
321 DIR_SET_FLAG (directory
, DIRF_FOUND
);
323 directory
->dump
= dumpdir_create (contents
);
325 directory
->dump
= NULL
;
327 if (! ((directory_table
328 || (directory_table
= hash_initialize (0, 0,
329 hash_directory_canonical_name
,
330 compare_directory_canonical_names
, 0)))
331 && hash_insert (directory_table
, directory
)))
334 if (! ((directory_meta_table
335 || (directory_meta_table
= hash_initialize (0, 0,
337 compare_directory_meta
,
339 && hash_insert (directory_meta_table
, directory
)))
345 /* Return a directory entry for a given file NAME, or zero if none found. */
346 static struct directory
*
347 find_directory (const char *name
)
349 if (! directory_table
)
353 char *caname
= normalize_filename (name
);
354 struct directory
*dir
= make_directory (name
, caname
);
355 struct directory
*ret
= hash_lookup (directory_table
, dir
);
356 free_directory (dir
);
362 /* Remove directory entry for the given CANAME */
364 remove_directory (const char *caname
)
366 struct directory
*dir
= make_directory (caname
, xstrdup (caname
));
367 struct directory
*ret
= hash_delete (directory_table
, dir
);
369 free_directory (ret
);
370 free_directory (dir
);
374 /* If first OLD_PREFIX_LEN bytes of DIR->NAME name match OLD_PREFIX,
375 replace them with NEW_PREFIX. */
377 rebase_directory (struct directory
*dir
,
378 const char *old_prefix
, size_t old_prefix_len
,
379 const char *new_prefix
, size_t new_prefix_len
)
381 replace_prefix (&dir
->name
, old_prefix
, old_prefix_len
,
382 new_prefix
, new_prefix_len
);
385 /* Return a directory entry for a given combination of device and inode
386 numbers, or zero if none found. */
387 static struct directory
*
388 find_directory_meta (dev_t dev
, ino_t ino
)
390 if (! directory_meta_table
)
394 struct directory
*dir
= make_directory ("", NULL
);
395 struct directory
*ret
;
396 dir
->device_number
= dev
;
397 dir
->inode_number
= ino
;
398 ret
= hash_lookup (directory_meta_table
, dir
);
399 free_directory (dir
);
405 update_parent_directory (struct tar_stat_info
*parent
)
407 struct directory
*directory
= find_directory (parent
->orig_file_name
);
411 if (fstat (parent
->fd
, &st
) != 0)
412 stat_diag (directory
->name
);
414 directory
->mtime
= get_stat_mtime (&st
);
418 #define PD_FORCE_CHILDREN 0x10
419 #define PD_FORCE_INIT 0x20
420 #define PD_CHILDREN(f) ((f) & 3)
422 static struct directory
*
423 procdir (const char *name_buffer
, struct tar_stat_info
*st
,
427 struct directory
*directory
;
428 struct stat
*stat_data
= &st
->stat
;
429 bool nfs
= NFS_FILE_STAT (*stat_data
);
431 if ((directory
= find_directory (name_buffer
)) != NULL
)
433 if (DIR_IS_INITED (directory
))
435 if (flag
& PD_FORCE_INIT
)
437 assign_string (&directory
->name
, name_buffer
);
441 *entry
= 'N'; /* Avoid duplicating this directory */
446 if (strcmp (directory
->name
, name_buffer
))
452 /* With NFS, the same file can have two different devices
453 if an NFS directory is mounted in multiple locations,
454 which is relatively common when automounting.
455 To avoid spurious incremental redumping of
456 directories, consider all NFS devices as equal,
457 relying on the i-node to establish differences. */
459 if (! ((!check_device_option
460 || (DIR_IS_NFS (directory
) && nfs
)
461 || directory
->device_number
== stat_data
->st_dev
)
462 && directory
->inode_number
== stat_data
->st_ino
))
464 /* FIXME: find_directory_meta ignores nfs */
465 struct directory
*d
= find_directory_meta (stat_data
->st_dev
,
469 if (strcmp (d
->name
, name_buffer
))
471 WARNOPT (WARN_RENAME_DIRECTORY
,
473 _("%s: Directory has been renamed from %s"),
474 quotearg_colon (name_buffer
),
475 quote_n (1, d
->name
)));
477 DIR_SET_FLAG (directory
, DIRF_RENAMED
);
478 dirlist_replace_prefix (d
->name
, name_buffer
);
480 directory
->children
= CHANGED_CHILDREN
;
484 WARNOPT (WARN_RENAME_DIRECTORY
,
485 (0, 0, _("%s: Directory has been renamed"),
486 quotearg_colon (name_buffer
)));
487 directory
->children
= ALL_CHILDREN
;
488 directory
->device_number
= stat_data
->st_dev
;
489 directory
->inode_number
= stat_data
->st_ino
;
492 DIR_SET_FLAG (directory
, DIRF_NFS
);
495 directory
->children
= CHANGED_CHILDREN
;
497 DIR_SET_FLAG (directory
, DIRF_FOUND
);
501 struct directory
*d
= find_directory_meta (stat_data
->st_dev
,
504 directory
= note_directory (name_buffer
,
505 get_stat_mtime(stat_data
),
514 if (strcmp (d
->name
, name_buffer
))
516 WARNOPT (WARN_RENAME_DIRECTORY
,
517 (0, 0, _("%s: Directory has been renamed from %s"),
518 quotearg_colon (name_buffer
),
519 quote_n (1, d
->name
)));
521 DIR_SET_FLAG (directory
, DIRF_RENAMED
);
522 dirlist_replace_prefix (d
->name
, name_buffer
);
524 directory
->children
= CHANGED_CHILDREN
;
528 DIR_SET_FLAG (directory
, DIRF_NEW
);
529 WARNOPT (WARN_NEW_DIRECTORY
,
530 (0, 0, _("%s: Directory is new"),
531 quotearg_colon (name_buffer
)));
532 directory
->children
=
533 (listed_incremental_option
534 || (OLDER_STAT_TIME (*stat_data
, m
)
535 || (after_date_option
536 && OLDER_STAT_TIME (*stat_data
, c
))))
542 if (one_file_system_option
&& st
->parent
543 && stat_data
->st_dev
!= st
->parent
->stat
.st_dev
)
547 _("%s: directory is on a different filesystem; not dumped"),
548 quotearg_colon (directory->name)));
550 directory
->children
= NO_CHILDREN
;
551 else if (flag
& PD_FORCE_CHILDREN
)
553 directory
->children
= PD_CHILDREN(flag
);
554 if (directory
->children
== NO_CHILDREN
)
558 DIR_SET_FLAG (directory
, DIRF_INIT
);
560 if (directory
->children
!= NO_CHILDREN
)
562 const char *tag_file_name
;
564 switch (check_exclusion_tags (st
, &tag_file_name
))
566 case exclusion_tag_all
:
567 /* This warning can be duplicated by code in dump_file0, but only
568 in case when the topmost directory being archived contains
570 exclusion_tag_warning (name_buffer
, tag_file_name
,
571 _("directory not dumped"));
573 directory
->children
= NO_CHILDREN
;
576 case exclusion_tag_contents
:
577 exclusion_tag_warning (name_buffer
, tag_file_name
,
578 _("contents not dumped"));
579 directory
->children
= NO_CHILDREN
;
582 case exclusion_tag_under
:
583 exclusion_tag_warning (name_buffer
, tag_file_name
,
584 _("contents not dumped"));
585 directory
->tagfile
= tag_file_name
;
588 case exclusion_tag_none
:
596 /* Compare dumpdir array from DIRECTORY with directory listing DIR and
597 build a new dumpdir template.
599 DIR must be returned by a previous call to savedir().
601 File names in DIRECTORY->dump->contents must be sorted
604 DIRECTORY->dump is replaced with the created template. Each entry is
605 prefixed with ' ' if it was present in DUMP and with 'Y' otherwise. */
608 makedumpdir (struct directory
*directory
, const char *dir
)
611 dirsize
, /* Number of elements in DIR */
612 len
; /* Length of DIR, including terminating nul */
615 char *new_dump
, *new_dump_ptr
;
616 struct dumpdir
*dump
;
618 if (directory
->children
== ALL_CHILDREN
)
620 else if (DIR_IS_RENAMED (directory
))
621 dump
= directory
->orig
->idump
?
622 directory
->orig
->idump
: directory
->orig
->dump
;
624 dump
= directory
->dump
;
626 /* Count the size of DIR and the number of elements it contains */
629 for (p
= dir
; *p
; p
+= strlen (p
) + 1, dirsize
++)
630 len
+= strlen (p
) + 2;
633 /* Create a sorted directory listing */
634 array
= xcalloc (dirsize
, sizeof array
[0]);
635 for (i
= 0, p
= dir
; *p
; p
+= strlen (p
) + 1, i
++)
638 qsort (array
, dirsize
, sizeof (array
[0]), compare_dirnames
);
640 /* Prepare space for new dumpdir */
641 new_dump
= xmalloc (len
);
642 new_dump_ptr
= new_dump
;
644 /* Fill in the dumpdir template */
645 for (i
= 0; i
< dirsize
; i
++)
647 const char *loc
= dumpdir_locate (dump
, array
[i
]);
650 if (directory
->tagfile
)
651 *new_dump_ptr
= strcmp (directory
->tagfile
, array
[i
]) == 0 ?
657 else if (directory
->tagfile
)
658 *new_dump_ptr
++ = strcmp (directory
->tagfile
, array
[i
]) == 0 ?
661 *new_dump_ptr
++ = 'Y'; /* New entry */
663 /* Copy the file name */
664 for (p
= array
[i
]; (*new_dump_ptr
++ = *p
++); )
668 directory
->idump
= directory
->dump
;
669 directory
->dump
= dumpdir_create0 (new_dump
, NULL
);
673 /* Recursively scan the directory identified by ST. */
675 scan_directory (struct tar_stat_info
*st
)
677 char const *dir
= st
->orig_file_name
;
678 char *dirp
= get_directory_entries (st
);
679 dev_t device
= st
->stat
.st_dev
;
680 bool cmdline
= ! st
->parent
;
683 struct directory
*directory
;
692 directory
= procdir (tmp
, st
,
693 (cmdline
? PD_FORCE_INIT
: 0),
698 nbuf
= namebuf_create (dir
);
700 if (dirp
&& directory
->children
!= NO_CHILDREN
)
702 char *entry
; /* directory entry being scanned */
703 struct dumpdir_iter
*itr
;
705 makedumpdir (directory
, dirp
);
707 for (entry
= dumpdir_first (directory
->dump
, 1, &itr
);
709 entry
= dumpdir_next (itr
))
711 char *full_name
= namebuf_name (nbuf
, entry
+ 1);
713 if (*entry
== 'I') /* Ignored entry */
715 else if (excluded_name (full_name
))
720 void (*diag
) (char const *) = 0;
721 struct tar_stat_info stsub
;
722 tar_stat_init (&stsub
);
729 else if (fstatat (fd
, entry
+ 1, &stsub
.stat
, fstatat_flags
) != 0)
731 else if (S_ISDIR (stsub
.stat
.st_mode
))
733 int subfd
= subfile_open (st
, entry
+ 1, open_read_flags
);
739 if (fstat (subfd
, &stsub
.stat
) != 0)
746 file_removed_diag (full_name
, false, diag
);
749 else if (S_ISDIR (stsub
.stat
.st_mode
))
752 if (!recursion_option
)
753 pd_flag
|= PD_FORCE_CHILDREN
| NO_CHILDREN
;
754 else if (directory
->children
== ALL_CHILDREN
)
755 pd_flag
|= PD_FORCE_CHILDREN
| ALL_CHILDREN
;
759 procdir (full_name
, &stsub
, pd_flag
, entry
);
760 restore_parent_fd (&stsub
);
762 else if (one_file_system_option
&& device
!= stsub
.stat
.st_dev
)
764 else if (*entry
== 'Y')
765 /* New entry, skip further checks */;
766 /* FIXME: if (S_ISHIDDEN (stat_data.st_mode))?? */
767 else if (OLDER_STAT_TIME (stsub
.stat
, m
)
768 && (!after_date_option
769 || OLDER_STAT_TIME (stsub
.stat
, c
)))
774 tar_stat_destroy (&stsub
);
788 /* Return pointer to the contents of the directory DIR */
790 directory_contents (struct directory
*dir
)
794 return dir
->dump
? dir
->dump
->contents
: NULL
;
797 /* A "safe" version of directory_contents, which never returns NULL. */
799 safe_directory_contents (struct directory
*dir
)
801 const char *ret
= directory_contents (dir
);
802 return ret
? ret
: "\0\0\0\0";
807 obstack_code_rename (struct obstack
*stk
, char const *from
, char const *to
)
811 s
= from
[0] == 0 ? from
:
812 safer_name_suffix (from
, false, absolute_names_option
);
813 obstack_1grow (stk
, 'R');
814 obstack_grow (stk
, s
, strlen (s
) + 1);
817 safer_name_suffix (to
, false, absolute_names_option
);
818 obstack_1grow (stk
, 'T');
819 obstack_grow (stk
, s
, strlen (s
) + 1);
823 store_rename (struct directory
*dir
, struct obstack
*stk
)
825 if (DIR_IS_RENAMED (dir
))
827 struct directory
*prev
, *p
;
829 /* Detect eventual cycles and clear DIRF_RENAMED flag, so these entries
830 are ignored when hit by this function next time.
831 If the chain forms a cycle, prev points to the entry DIR is renamed
832 from. In this case it still retains DIRF_RENAMED flag, which will be
833 cleared in the `else' branch below */
834 for (prev
= dir
; prev
&& prev
->orig
!= dir
; prev
= prev
->orig
)
835 DIR_CLEAR_FLAG (prev
, DIRF_RENAMED
);
839 for (p
= dir
; p
&& p
->orig
; p
= p
->orig
)
840 obstack_code_rename (stk
, p
->orig
->name
, p
->name
);
846 DIR_CLEAR_FLAG (prev
, DIRF_RENAMED
);
848 /* Break the cycle by using a temporary name for one of its
850 First, create a temp name stub entry. */
851 temp_name
= dir_name (dir
->name
);
852 obstack_1grow (stk
, 'X');
853 obstack_grow (stk
, temp_name
, strlen (temp_name
) + 1);
855 obstack_code_rename (stk
, dir
->name
, "");
857 for (p
= dir
; p
!= prev
; p
= p
->orig
)
858 obstack_code_rename (stk
, p
->orig
->name
, p
->name
);
860 obstack_code_rename (stk
, "", prev
->name
);
866 append_incremental_renames (struct directory
*dir
)
870 struct directory
*dp
;
877 dump
= directory_contents (dir
);
880 size
= dumpdir_size (dump
) - 1;
881 obstack_grow (&stk
, dump
, size
);
886 for (dp
= dirhead
; dp
; dp
= dp
->next
)
887 store_rename (dp
, &stk
);
889 /* FIXME: Is this the right thing to do when DIR is null? */
890 if (dir
&& obstack_object_size (&stk
) != size
)
892 obstack_1grow (&stk
, 0);
893 dumpdir_free (dir
->dump
);
894 dir
->dump
= dumpdir_create (obstack_finish (&stk
));
896 obstack_free (&stk
, NULL
);
901 static FILE *listed_incremental_stream
;
903 /* Version of incremental format snapshots (directory files) used by this
904 tar. Currently it is supposed to be a single decimal number. 0 means
905 incremental snapshots as per tar version before 1.15.2.
907 The current tar version supports incremental versions from
908 0 up to TAR_INCREMENTAL_VERSION, inclusive.
909 It is able to create only snapshots of TAR_INCREMENTAL_VERSION */
911 #define TAR_INCREMENTAL_VERSION 2
913 /* Read incremental snapshot formats 0 and 1 */
915 read_incr_db_01 (int version
, const char *initbuf
)
928 if (getline (&buf
, &bufsize
, listed_incremental_stream
) <= 0)
930 read_error (listed_incremental_option
);
938 buf
= strdup (initbuf
);
939 bufsize
= strlen (buf
) + 1;
942 sec
= TYPE_MINIMUM (time_t);
945 u
= strtoumax (buf
, &ebuf
, 10);
946 if (!errno
&& TYPE_MAXIMUM (time_t) < u
)
948 if (errno
|| buf
== ebuf
)
949 ERROR ((0, errno
, "%s:%ld: %s",
950 quotearg_colon (listed_incremental_option
),
952 _("Invalid time stamp")));
957 if (version
== 1 && *ebuf
)
959 char const *buf_ns
= ebuf
+ 1;
961 u
= strtoumax (buf_ns
, &ebuf
, 10);
962 if (!errno
&& BILLION
<= u
)
964 if (errno
|| buf_ns
== ebuf
)
966 ERROR ((0, errno
, "%s:%ld: %s",
967 quotearg_colon (listed_incremental_option
),
969 _("Invalid time stamp")));
970 sec
= TYPE_MINIMUM (time_t);
977 /* pre-1 incremental format does not contain nanoseconds */
981 newer_mtime_option
.tv_sec
= sec
;
982 newer_mtime_option
.tv_nsec
= nsec
;
985 while (0 < (n
= getline (&buf
, &bufsize
, listed_incremental_stream
)))
989 bool nfs
= buf
[0] == '+';
990 char *strp
= buf
+ nfs
;
991 struct timespec mtime
;
995 if (buf
[n
- 1] == '\n')
1001 u
= strtoumax (strp
, &ebuf
, 10);
1002 if (!errno
&& TYPE_MAXIMUM (time_t) < u
)
1004 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
1006 ERROR ((0, errno
, "%s:%ld: %s",
1007 quotearg_colon (listed_incremental_option
), lineno
,
1008 _("Invalid modification time (seconds)")));
1016 u
= strtoumax (strp
, &ebuf
, 10);
1017 if (!errno
&& BILLION
<= u
)
1019 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
1021 ERROR ((0, errno
, "%s:%ld: %s",
1022 quotearg_colon (listed_incremental_option
), lineno
,
1023 _("Invalid modification time (nanoseconds)")));
1029 mtime
.tv_nsec
= nsec
;
1033 memset (&mtime
, 0, sizeof mtime
);
1036 u
= strtoumax (strp
, &ebuf
, 10);
1037 if (!errno
&& TYPE_MAXIMUM (dev_t
) < u
)
1039 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
1041 ERROR ((0, errno
, "%s:%ld: %s",
1042 quotearg_colon (listed_incremental_option
), lineno
,
1043 _("Invalid device number")));
1051 u
= strtoumax (strp
, &ebuf
, 10);
1052 if (!errno
&& TYPE_MAXIMUM (ino_t
) < u
)
1054 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
1056 ERROR ((0, errno
, "%s:%ld: %s",
1057 quotearg_colon (listed_incremental_option
), lineno
,
1058 _("Invalid inode number")));
1066 unquote_string (strp
);
1067 note_directory (strp
, mtime
, dev
, ino
, nfs
, false, NULL
);
1072 /* Read a nul-terminated string from FP and store it in STK.
1073 Store the number of bytes read (including nul terminator) in PCOUNT.
1075 Return the last character read or EOF on end of file. */
1077 read_obstack (FILE *fp
, struct obstack
*stk
, size_t *pcount
)
1082 for (i
= 0, c
= getc (fp
); c
!= EOF
&& c
!= 0; c
= getc (fp
), i
++)
1083 obstack_1grow (stk
, c
);
1084 obstack_1grow (stk
, 0);
1090 /* Read from file FP a nul-terminated string and convert it to
1091 intmax_t. Return the resulting value in PVAL. Assume '-' has
1094 Throw a fatal error if the string cannot be converted or if the
1095 converted value is less than MIN_VAL. */
1098 read_negative_num (FILE *fp
, intmax_t min_val
, intmax_t *pval
)
1102 char buf
[INT_BUFSIZE_BOUND (intmax_t)];
1106 for (i
= 1; ISDIGIT (c
= getc (fp
)); i
++)
1108 if (i
== sizeof buf
- 1)
1109 FATAL_ERROR ((0, 0, _("Field too long while reading snapshot file")));
1116 FATAL_ERROR ((0, errno
, _("Read error in snapshot file")));
1118 FATAL_ERROR ((0, 0, _("Unexpected EOF in snapshot file")));
1123 *pval
= strtoimax (buf
, &ep
, 10);
1124 if (c
|| errno
|| *pval
< min_val
)
1125 FATAL_ERROR ((0, errno
, _("Unexpected field value in snapshot file")));
1128 /* Read from file FP a nul-terminated string and convert it to
1129 uintmax_t. Return the resulting value in PVAL. Assume C has
1132 Throw a fatal error if the string cannot be converted or if the
1133 converted value exceeds MAX_VAL.
1135 Return the last character read or EOF on end of file. */
1138 read_unsigned_num (int c
, FILE *fp
, uintmax_t max_val
, uintmax_t *pval
)
1141 char buf
[UINTMAX_STRSIZE_BOUND
], *ep
;
1143 for (i
= 0; ISDIGIT (c
); i
++)
1145 if (i
== sizeof buf
- 1)
1146 FATAL_ERROR ((0, 0, _("Field too long while reading snapshot file")));
1154 FATAL_ERROR ((0, errno
, _("Read error in snapshot file")));
1158 FATAL_ERROR ((0, 0, _("Unexpected EOF in snapshot file")));
1163 *pval
= strtoumax (buf
, &ep
, 10);
1164 if (c
|| errno
|| max_val
< *pval
)
1165 FATAL_ERROR ((0, errno
, _("Unexpected field value in snapshot file")));
1169 /* Read from file FP a nul-terminated string and convert it to
1170 uintmax_t. Return the resulting value in PVAL.
1172 Throw a fatal error if the string cannot be converted or if the
1173 converted value exceeds MAX_VAL.
1175 Return the last character read or EOF on end of file. */
1178 read_num (FILE *fp
, uintmax_t max_val
, uintmax_t *pval
)
1180 return read_unsigned_num (getc (fp
), fp
, max_val
, pval
);
1183 /* Read from FP two NUL-terminated strings representing a struct
1184 timespec. Return the resulting value in PVAL.
1186 Throw a fatal error if the string cannot be converted. */
1189 read_timespec (FILE *fp
, struct timespec
*pval
)
1197 read_negative_num (fp
, TYPE_MINIMUM (time_t), &i
);
1203 c
= read_unsigned_num (c
, fp
, TYPE_MAXIMUM (time_t), &u
);
1207 if (c
|| read_num (fp
, BILLION
- 1, &u
))
1208 FATAL_ERROR ((0, 0, "%s: %s",
1209 quotearg_colon (listed_incremental_option
),
1210 _("Unexpected EOF in snapshot file")));
1214 /* Read incremental snapshot format 2 */
1216 read_incr_db_2 (void)
1221 obstack_init (&stk
);
1223 read_timespec (listed_incremental_stream
, &newer_mtime_option
);
1227 struct timespec mtime
;
1235 if (read_num (listed_incremental_stream
, 1, &u
))
1236 return; /* Normal return */
1240 read_timespec (listed_incremental_stream
, &mtime
);
1242 if (read_num (listed_incremental_stream
, TYPE_MAXIMUM (dev_t
), &u
))
1246 if (read_num (listed_incremental_stream
, TYPE_MAXIMUM (ino_t
), &u
))
1250 if (read_obstack (listed_incremental_stream
, &stk
, &s
))
1253 name
= obstack_finish (&stk
);
1255 while (read_obstack (listed_incremental_stream
, &stk
, &s
) == 0 && s
> 1)
1257 if (getc (listed_incremental_stream
) != 0)
1258 FATAL_ERROR ((0, 0, "%s: %s",
1259 quotearg_colon (listed_incremental_option
),
1260 _("Missing record terminator")));
1262 content
= obstack_finish (&stk
);
1263 note_directory (name
, mtime
, dev
, ino
, nfs
, false, content
);
1264 obstack_free (&stk
, content
);
1266 FATAL_ERROR ((0, 0, "%s: %s",
1267 quotearg_colon (listed_incremental_option
),
1268 _("Unexpected EOF in snapshot file")));
1271 /* Read incremental snapshot file (directory file).
1272 If the file has older incremental version, make sure that it is processed
1273 correctly and that tar will use the most conservative backup method among
1274 possible alternatives (i.e. prefer ALL_CHILDREN over CHANGED_CHILDREN,
1275 etc.) This ensures that the snapshots are updated to the recent version
1276 without any loss of data. */
1278 read_directory_file (void)
1283 int flags
= O_RDWR
| O_CREAT
;
1285 if (incremental_level
== 0)
1287 /* Open the file for both read and write. That way, we can write
1288 it later without having to reopen it, and don't have to worry if
1289 we chdir in the meantime. */
1290 fd
= open (listed_incremental_option
, flags
, MODE_RW
);
1293 open_error (listed_incremental_option
);
1297 listed_incremental_stream
= fdopen (fd
, "r+");
1298 if (! listed_incremental_stream
)
1300 open_error (listed_incremental_option
);
1305 /* Consume the first name from the name list and reset the
1306 list afterwards. This is done to change to the new
1307 directory, if the first name is a chdir request (-C dir),
1308 which is necessary to recreate absolute file names. */
1312 if (0 < getline (&buf
, &bufsize
, listed_incremental_stream
))
1315 uintmax_t incremental_version
;
1317 if (strncmp (buf
, PACKAGE_NAME
, sizeof PACKAGE_NAME
- 1) == 0)
1319 ebuf
= buf
+ sizeof PACKAGE_NAME
- 1;
1321 ERROR((1, 0, _("Bad incremental file format")));
1322 for (; *ebuf
!= '-'; ebuf
++)
1324 ERROR((1, 0, _("Bad incremental file format")));
1326 incremental_version
= strtoumax (ebuf
+ 1, NULL
, 10);
1329 incremental_version
= 0;
1331 switch (incremental_version
)
1335 read_incr_db_01 (incremental_version
, buf
);
1338 case TAR_INCREMENTAL_VERSION
:
1343 ERROR ((1, 0, _("Unsupported incremental format version: %"PRIuMAX
),
1344 incremental_version
));
1349 if (ferror (listed_incremental_stream
))
1350 read_error (listed_incremental_option
);
1355 /* Output incremental data for the directory ENTRY to the file DATA.
1356 Return nonzero if successful, preserving errno on write failure. */
1358 write_directory_file_entry (void *entry
, void *data
)
1360 struct directory
const *directory
= entry
;
1363 if (DIR_IS_FOUND (directory
))
1365 char buf
[UINTMAX_STRSIZE_BOUND
];
1368 s
= DIR_IS_NFS (directory
) ? "1" : "0";
1369 fwrite (s
, 2, 1, fp
);
1370 s
= (TYPE_SIGNED (time_t)
1371 ? imaxtostr (directory
->mtime
.tv_sec
, buf
)
1372 : umaxtostr (directory
->mtime
.tv_sec
, buf
));
1373 fwrite (s
, strlen (s
) + 1, 1, fp
);
1374 s
= umaxtostr (directory
->mtime
.tv_nsec
, buf
);
1375 fwrite (s
, strlen (s
) + 1, 1, fp
);
1376 s
= umaxtostr (directory
->device_number
, buf
);
1377 fwrite (s
, strlen (s
) + 1, 1, fp
);
1378 s
= umaxtostr (directory
->inode_number
, buf
);
1379 fwrite (s
, strlen (s
) + 1, 1, fp
);
1381 fwrite (directory
->name
, strlen (directory
->name
) + 1, 1, fp
);
1382 if (directory
->dump
)
1385 struct dumpdir_iter
*itr
;
1387 for (p
= dumpdir_first (directory
->dump
, 0, &itr
);
1389 p
= dumpdir_next (itr
))
1390 fwrite (p
, strlen (p
) + 1, 1, fp
);
1393 fwrite ("\0\0", 2, 1, fp
);
1396 return ! ferror (fp
);
1400 write_directory_file (void)
1402 FILE *fp
= listed_incremental_stream
;
1403 char buf
[UINTMAX_STRSIZE_BOUND
];
1409 if (fseeko (fp
, 0L, SEEK_SET
) != 0)
1410 seek_error (listed_incremental_option
);
1411 if (sys_truncate (fileno (fp
)) != 0)
1412 truncate_error (listed_incremental_option
);
1414 fprintf (fp
, "%s-%s-%d\n", PACKAGE_NAME
, PACKAGE_VERSION
,
1415 TAR_INCREMENTAL_VERSION
);
1417 s
= (TYPE_SIGNED (time_t)
1418 ? imaxtostr (start_time
.tv_sec
, buf
)
1419 : umaxtostr (start_time
.tv_sec
, buf
));
1420 fwrite (s
, strlen (s
) + 1, 1, fp
);
1421 s
= umaxtostr (start_time
.tv_nsec
, buf
);
1422 fwrite (s
, strlen (s
) + 1, 1, fp
);
1424 if (! ferror (fp
) && directory_table
)
1425 hash_do_for_each (directory_table
, write_directory_file_entry
, fp
);
1428 write_error (listed_incremental_option
);
1429 if (fclose (fp
) != 0)
1430 close_error (listed_incremental_option
);
1434 /* Restoration of incremental dumps. */
1437 get_gnu_dumpdir (struct tar_stat_info
*stat_info
)
1441 union block
*data_block
;
1445 size
= stat_info
->stat
.st_size
;
1447 archive_dir
= xmalloc (size
);
1450 set_next_block_after (current_header
);
1451 mv_begin_read (stat_info
);
1453 for (; size
> 0; size
-= copied
)
1455 mv_size_left (size
);
1456 data_block
= find_next_block ();
1458 ERROR ((1, 0, _("Unexpected EOF in archive")));
1459 copied
= available_space_after (data_block
);
1462 memcpy (to
, data_block
->buffer
, copied
);
1464 set_next_block_after ((union block
*)
1465 (data_block
->buffer
+ copied
- 1));
1470 stat_info
->dumpdir
= archive_dir
;
1471 stat_info
->skipped
= true; /* For skip_member() and friends
1472 to work correctly */
1475 /* Return T if STAT_INFO represents a dumpdir archive member.
1476 Note: can invalidate current_header. It happens if flush_archive()
1477 gets called within get_gnu_dumpdir() */
1479 is_dumpdir (struct tar_stat_info
*stat_info
)
1481 if (stat_info
->is_dumpdir
&& !stat_info
->dumpdir
)
1482 get_gnu_dumpdir (stat_info
);
1483 return stat_info
->is_dumpdir
;
1487 dumpdir_ok (char *dumpdir
)
1490 int has_tempdir
= 0;
1493 for (p
= dumpdir
; *p
; p
+= strlen (p
) + 1)
1495 if (expect
&& *p
!= expect
)
1498 _("Malformed dumpdir: expected '%c' but found %#3o"),
1508 _("Malformed dumpdir: 'X' duplicated")));
1521 _("Malformed dumpdir: empty name in 'R'")));
1534 _("Malformed dumpdir: 'T' not preceeded by 'R'")));
1537 if (p
[1] == 0 && !has_tempdir
)
1540 _("Malformed dumpdir: empty name in 'T'")));
1552 /* FIXME: bail out? */
1560 _("Malformed dumpdir: expected '%c' but found end of data"),
1566 WARNOPT (WARN_BAD_DUMPDIR
,
1567 (0, 0, _("Malformed dumpdir: 'X' never used")));
1572 /* Examine the directories under directory_name and delete any
1573 files that were not there at the time of the back-up. */
1575 try_purge_directory (char const *directory_name
)
1578 char *cur
, *arc
, *p
;
1579 char *temp_stub
= NULL
;
1580 struct dumpdir
*dump
;
1582 if (!is_dumpdir (¤t_stat_info
))
1585 current_dir
= savedir (directory_name
);
1588 /* The directory doesn't exist now. It'll be created. In any
1589 case, we don't have to delete any files out of it. */
1592 /* Verify if dump directory is sane */
1593 if (!dumpdir_ok (current_stat_info
.dumpdir
))
1596 /* Process renames */
1597 for (arc
= current_stat_info
.dumpdir
; *arc
; arc
+= strlen (arc
) + 1)
1601 #define TEMP_DIR_TEMPLATE "tar.XXXXXX"
1602 size_t len
= strlen (arc
+ 1);
1603 temp_stub
= xrealloc (temp_stub
, len
+ 1 + sizeof TEMP_DIR_TEMPLATE
);
1604 memcpy (temp_stub
, arc
+ 1, len
);
1605 temp_stub
[len
] = '/';
1606 memcpy (temp_stub
+ len
+ 1, TEMP_DIR_TEMPLATE
,
1607 sizeof TEMP_DIR_TEMPLATE
);
1608 if (!mkdtemp (temp_stub
))
1611 _("Cannot create temporary directory using template %s"),
1612 quote (temp_stub
)));
1618 else if (*arc
== 'R')
1622 arc
+= strlen (arc
) + 1;
1625 /* Ensure that neither source nor destination are absolute file
1626 names (unless permitted by -P option), and that they do not
1627 contain dubious parts (e.g. ../).
1629 This is an extra safety precaution. Besides, it might be
1630 necessary to extract from archives created with tar versions
1634 src
= safer_name_suffix (src
, false, absolute_names_option
);
1636 dst
= safer_name_suffix (dst
, false, absolute_names_option
);
1643 if (!rename_directory (src
, dst
))
1647 /* FIXME: Make sure purge_directory(dst) will return
1656 /* Process deletes */
1657 dump
= dumpdir_create (current_stat_info
.dumpdir
);
1659 for (cur
= current_dir
; *cur
; cur
+= strlen (cur
) + 1)
1665 p
= new_name (directory_name
, cur
);
1667 if (deref_stat (p
, &st
) != 0)
1669 if (errno
!= ENOENT
) /* FIXME: Maybe keep a list of renamed
1670 dirs and check it here? */
1673 WARN ((0, 0, _("%s: Not purging directory: unable to stat"),
1674 quotearg_colon (p
)));
1679 if (!(entry
= dumpdir_locate (dump
, cur
))
1680 || (*entry
== 'D' && !S_ISDIR (st
.st_mode
))
1681 || (*entry
== 'Y' && S_ISDIR (st
.st_mode
)))
1683 if (one_file_system_option
&& st
.st_dev
!= root_device
)
1686 _("%s: directory is on a different device: not purging"),
1687 quotearg_colon (p
)));
1691 if (! interactive_option
|| confirm ("delete", p
))
1694 fprintf (stdlis
, _("%s: Deleting %s\n"),
1695 program_name
, quote (p
));
1696 if (! remove_any_file (p
, RECURSIVE_REMOVE_OPTION
))
1699 ERROR ((0, e
, _("%s: Cannot remove"), quotearg_colon (p
)));
1705 dumpdir_free (dump
);
1712 purge_directory (char const *directory_name
)
1714 if (!try_purge_directory (directory_name
))
1719 list_dumpdir (char *buffer
, size_t size
)
1732 fprintf (stdlis
, "%c", *buffer
);
1735 fprintf (stdlis
, " ");
1743 fputc ('\n', stdlis
);
1750 fputc (*buffer
, stdlis
);