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 Free Software Foundation, Inc.
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 3, or (at your option) any later
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
14 Public License for more details.
16 You should have received a copy of the GNU General Public License along
17 with this program; if not, write to the Free Software Foundation, Inc.,
18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
25 /* Incremental dump specialities. */
27 /* Which child files to save under a directory. */
35 #define DIRF_INIT 0x0001 /* directory structure is initialized
36 (procdir called at least once) */
37 #define DIRF_NFS 0x0002 /* directory is mounted on nfs */
38 #define DIRF_FOUND 0x0004 /* directory is found on fs */
39 #define DIRF_NEW 0x0008 /* directory is new (not found
40 in the previous dump) */
41 #define DIRF_RENAMED 0x0010 /* directory is renamed */
43 #define DIR_IS_INITED(d) ((d)->flags & DIRF_INIT)
44 #define DIR_IS_NFS(d) ((d)->flags & DIRF_NFS)
45 #define DIR_IS_FOUND(d) ((d)->flags & DIRF_FOUND)
46 #define DIR_IS_NEW(d) ((d)->flags & DIRF_NEW)
47 #define DIR_IS_RENAMED(d) ((d)->flags & DIRF_RENAMED)
49 #define DIR_SET_FLAG(d,f) (d)->flags |= (f)
50 #define DIR_CLEAR_FLAG(d,f) (d)->flags &= ~(f)
52 struct dumpdir
/* Dump directory listing */
54 char *contents
; /* Actual contents */
55 size_t total
; /* Total number of elements */
56 size_t elc
; /* Number of D/N/Y elements. */
57 char **elv
; /* Array of D/N/Y elements */
60 /* Directory attributes. */
63 struct directory
*next
;
64 struct timespec mtime
; /* Modification time */
65 dev_t device_number
; /* device number for directory */
66 ino_t inode_number
; /* inode number for directory */
67 struct dumpdir
*dump
; /* Directory contents */
68 struct dumpdir
*idump
; /* Initial contents if the directory was
70 enum children children
; /* What to save under this directory */
71 unsigned flags
; /* See DIRF_ macros above */
72 struct directory
*orig
; /* If the directory was renamed, points to
73 the original directory structure */
74 const char *tagfile
; /* Tag file, if the directory falls under
75 exclusion_tag_under */
76 char *name
; /* file name of directory */
80 dumpdir_create0 (const char *contents
, const char *cmask
)
83 size_t i
, total
, ctsize
, len
;
87 for (i
= 0, total
= 0, ctsize
= 1, q
= contents
; *q
; total
++, q
+= len
)
91 if (!cmask
|| strchr (cmask
, *q
))
94 dump
= xmalloc (sizeof (*dump
) + ctsize
);
95 dump
->contents
= (char*)(dump
+ 1);
96 memcpy (dump
->contents
, contents
, ctsize
);
99 dump
->elv
= xcalloc (i
+ 1, sizeof (dump
->elv
[0]));
101 for (i
= 0, p
= dump
->contents
; *p
; p
+= strlen (p
) + 1)
103 if (!cmask
|| strchr (cmask
, *p
))
104 dump
->elv
[i
++] = p
+ 1;
111 dumpdir_create (const char *contents
)
113 return dumpdir_create0 (contents
, "YND");
117 dumpdir_free (struct dumpdir
*dump
)
124 compare_dirnames (const void *first
, const void *second
)
126 char const *const *name1
= first
;
127 char const *const *name2
= second
;
128 return strcmp (*name1
, *name2
);
131 /* Locate NAME in the dumpdir array DUMP.
132 Return pointer to the slot in DUMP->contents, or NULL if not found */
134 dumpdir_locate (struct dumpdir
*dump
, const char *name
)
140 ptr
= bsearch (&name
, dump
->elv
, dump
->elc
, sizeof (dump
->elv
[0]),
142 return ptr
? *ptr
- 1: NULL
;
147 struct dumpdir
*dump
; /* Dumpdir being iterated */
148 int all
; /* Iterate over all entries, not only D/N/Y */
149 size_t next
; /* Index of the next element */
153 dumpdir_next (struct dumpdir_iter
*itr
)
155 size_t cur
= itr
->next
;
160 ret
= itr
->dump
->contents
+ cur
;
163 itr
->next
+= strlen (ret
) + 1;
165 else if (cur
< itr
->dump
->elc
)
167 ret
= itr
->dump
->elv
[cur
] - 1;
175 dumpdir_first (struct dumpdir
*dump
, int all
, struct dumpdir_iter
**pitr
)
177 struct dumpdir_iter
*itr
= xmalloc (sizeof (*itr
));
182 return dumpdir_next (itr
);
185 /* Return size in bytes of the dumpdir array P */
187 dumpdir_size (const char *p
)
193 size_t size
= strlen (p
) + 1;
201 static struct directory
*dirhead
, *dirtail
;
202 static Hash_table
*directory_table
;
203 static Hash_table
*directory_meta_table
;
205 #if HAVE_ST_FSTYPE_STRING
206 static char const nfs_string
[] = "nfs";
207 # define NFS_FILE_STAT(st) (strcmp ((st).st_fstype, nfs_string) == 0)
209 # define ST_DEV_MSB(st) (~ (dev_t) 0 << (sizeof (st).st_dev * CHAR_BIT - 1))
210 # define NFS_FILE_STAT(st) (((st).st_dev & ST_DEV_MSB (st)) != 0)
213 /* Calculate the hash of a directory. */
215 hash_directory_name (void const *entry
, size_t n_buckets
)
217 struct directory
const *directory
= entry
;
218 return hash_string (directory
->name
, n_buckets
);
221 /* Compare two directories for equality of their names. */
223 compare_directory_names (void const *entry1
, void const *entry2
)
225 struct directory
const *directory1
= entry1
;
226 struct directory
const *directory2
= entry2
;
227 return strcmp (directory1
->name
, directory2
->name
) == 0;
231 hash_directory_meta (void const *entry
, size_t n_buckets
)
233 struct directory
const *directory
= entry
;
234 /* FIXME: Work out a better algorytm */
235 return (directory
->device_number
+ directory
->inode_number
) % n_buckets
;
238 /* Compare two directories for equality of their device and inode numbers. */
240 compare_directory_meta (void const *entry1
, void const *entry2
)
242 struct directory
const *directory1
= entry1
;
243 struct directory
const *directory2
= entry2
;
244 return directory1
->device_number
== directory2
->device_number
245 && directory1
->inode_number
== directory2
->inode_number
;
248 /* Make a directory entry for given NAME */
249 static struct directory
*
250 make_directory (const char *name
)
252 size_t namelen
= strlen (name
);
253 struct directory
*directory
= xmalloc (sizeof (*directory
));
254 directory
->next
= NULL
;
255 directory
->dump
= directory
->idump
= NULL
;
256 directory
->orig
= NULL
;
257 directory
->flags
= false;
258 if (namelen
&& ISSLASH (name
[namelen
- 1]))
260 directory
->name
= xmalloc (namelen
+ 1);
261 memcpy (directory
->name
, name
, namelen
);
262 directory
->name
[namelen
] = 0;
263 directory
->tagfile
= NULL
;
268 free_directory (struct directory
*dir
)
274 static struct directory
*
275 attach_directory (const char *name
)
277 struct directory
*dir
= make_directory (name
);
288 replace_prefix (char **pname
, const char *samp
, size_t slen
,
289 const char *repl
, size_t rlen
)
292 size_t nlen
= strlen (name
);
293 if (nlen
> slen
&& memcmp (name
, samp
, slen
) == 0 && ISSLASH (name
[slen
]))
297 name
= xrealloc (name
, nlen
- slen
+ rlen
+ 1);
300 memmove (name
+ rlen
, name
+ slen
, nlen
- slen
+ 1);
301 memcpy (name
, repl
, rlen
);
306 dirlist_replace_prefix (const char *pref
, const char *repl
)
308 struct directory
*dp
;
309 size_t pref_len
= strlen (pref
);
310 size_t repl_len
= strlen (repl
);
311 for (dp
= dirhead
; dp
; dp
= dp
->next
)
312 replace_prefix (&dp
->name
, pref
, pref_len
, repl
, repl_len
);
315 /* Create and link a new directory entry for directory NAME, having a
316 device number DEV and an inode number INO, with NFS indicating
317 whether it is an NFS device and FOUND indicating whether we have
318 found that the directory exists. */
319 static struct directory
*
320 note_directory (char const *name
, struct timespec mtime
,
321 dev_t dev
, ino_t ino
, bool nfs
, bool found
,
322 const char *contents
)
324 struct directory
*directory
= attach_directory (name
);
326 directory
->mtime
= mtime
;
327 directory
->device_number
= dev
;
328 directory
->inode_number
= ino
;
329 directory
->children
= CHANGED_CHILDREN
;
331 DIR_SET_FLAG (directory
, DIRF_NFS
);
333 DIR_SET_FLAG (directory
, DIRF_FOUND
);
335 directory
->dump
= dumpdir_create (contents
);
337 directory
->dump
= NULL
;
339 if (! ((directory_table
340 || (directory_table
= hash_initialize (0, 0,
342 compare_directory_names
, 0)))
343 && hash_insert (directory_table
, directory
)))
346 if (! ((directory_meta_table
347 || (directory_meta_table
= hash_initialize (0, 0,
349 compare_directory_meta
,
351 && hash_insert (directory_meta_table
, directory
)))
357 /* Return a directory entry for a given file NAME, or zero if none found. */
358 static struct directory
*
359 find_directory (const char *name
)
361 if (! directory_table
)
365 struct directory
*dir
= make_directory (name
);
366 struct directory
*ret
= hash_lookup (directory_table
, dir
);
367 free_directory (dir
);
372 /* Return a directory entry for a given combination of device and inode
373 numbers, or zero if none found. */
374 static struct directory
*
375 find_directory_meta (dev_t dev
, ino_t ino
)
377 if (! directory_meta_table
)
381 struct directory
*dir
= make_directory ("");
382 struct directory
*ret
;
383 dir
->device_number
= dev
;
384 dir
->inode_number
= ino
;
385 ret
= hash_lookup (directory_meta_table
, dir
);
386 free_directory (dir
);
392 update_parent_directory (const char *name
)
394 struct directory
*directory
;
398 directory
= find_directory (p
);
402 if (deref_stat (dereference_option
, p
, &st
) != 0)
405 directory
->mtime
= get_stat_mtime (&st
);
410 #define PD_VERBOSE 0x10
411 #define PD_FORCE_CHILDREN 0x20
412 #define PD_CHILDREN(f) ((f) & 3)
414 static struct directory
*
415 procdir (char *name_buffer
, struct stat
*stat_data
,
420 struct directory
*directory
;
421 bool nfs
= NFS_FILE_STAT (*stat_data
);
423 if ((directory
= find_directory (name_buffer
)) != NULL
)
425 if (DIR_IS_INITED (directory
))
428 /* With NFS, the same file can have two different devices
429 if an NFS directory is mounted in multiple locations,
430 which is relatively common when automounting.
431 To avoid spurious incremental redumping of
432 directories, consider all NFS devices as equal,
433 relying on the i-node to establish differences. */
435 if (! ((!check_device_option
436 || (DIR_IS_NFS (directory
) && nfs
)
437 || directory
->device_number
== stat_data
->st_dev
)
438 && directory
->inode_number
== stat_data
->st_ino
))
440 /* FIXME: find_directory_meta ignores nfs */
441 struct directory
*d
= find_directory_meta (stat_data
->st_dev
,
445 if (strcmp (d
->name
, name_buffer
))
448 WARNOPT (WARN_RENAME_DIRECTORY
,
450 _("%s: Directory has been renamed from %s"),
451 quotearg_colon (name_buffer
),
452 quote_n (1, d
->name
)));
454 DIR_SET_FLAG (directory
, DIRF_RENAMED
);
455 dirlist_replace_prefix (d
->name
, name_buffer
);
457 directory
->children
= CHANGED_CHILDREN
;
462 WARNOPT (WARN_RENAME_DIRECTORY
,
463 (0, 0, _("%s: Directory has been renamed"),
464 quotearg_colon (name_buffer
)));
465 directory
->children
= ALL_CHILDREN
;
466 directory
->device_number
= stat_data
->st_dev
;
467 directory
->inode_number
= stat_data
->st_ino
;
470 DIR_SET_FLAG (directory
, DIRF_NFS
);
473 directory
->children
= CHANGED_CHILDREN
;
475 DIR_SET_FLAG (directory
, DIRF_FOUND
);
479 struct directory
*d
= find_directory_meta (stat_data
->st_dev
,
482 directory
= note_directory (name_buffer
,
483 get_stat_mtime(stat_data
),
492 if (strcmp (d
->name
, name_buffer
))
494 if (flag
& PD_VERBOSE
)
495 WARNOPT (WARN_RENAME_DIRECTORY
,
496 (0, 0, _("%s: Directory has been renamed from %s"),
497 quotearg_colon (name_buffer
),
498 quote_n (1, d
->name
)));
500 DIR_SET_FLAG (directory
, DIRF_RENAMED
);
501 dirlist_replace_prefix (d
->name
, name_buffer
);
503 directory
->children
= CHANGED_CHILDREN
;
507 DIR_SET_FLAG (directory
, DIRF_NEW
);
508 if (flag
& PD_VERBOSE
)
509 WARNOPT (WARN_NEW_DIRECTORY
,
510 (0, 0, _("%s: Directory is new"),
511 quotearg_colon (name_buffer
)));
512 directory
->children
=
513 (listed_incremental_option
514 || (OLDER_STAT_TIME (*stat_data
, m
)
515 || (after_date_option
516 && OLDER_STAT_TIME (*stat_data
, c
))))
522 /* If the directory is on another device and --one-file-system was given,
524 if (one_file_system_option
&& device
!= stat_data
->st_dev
525 /* ... except if it was explicitely given in the command line */
526 && !is_individual_file (name_buffer
))
527 directory
->children
= NO_CHILDREN
;
528 else if (flag
& PD_FORCE_CHILDREN
)
530 directory
->children
= PD_CHILDREN(flag
);
531 if (directory
->children
== NO_CHILDREN
)
535 DIR_SET_FLAG (directory
, DIRF_INIT
);
537 if (directory
->children
!= NO_CHILDREN
)
539 const char *tag_file_name
;
541 switch (check_exclusion_tags (name_buffer
, &tag_file_name
))
543 case exclusion_tag_all
:
544 /* This warning can be duplicated by code in dump_file0, but only
545 in case when the topmost directory being archived contains
547 exclusion_tag_warning (name_buffer
, tag_file_name
,
548 _("directory not dumped"));
551 directory
->children
= NO_CHILDREN
;
554 case exclusion_tag_contents
:
555 exclusion_tag_warning (name_buffer
, tag_file_name
,
556 _("contents not dumped"));
557 directory
->children
= NO_CHILDREN
;
560 case exclusion_tag_under
:
561 exclusion_tag_warning (name_buffer
, tag_file_name
,
562 _("contents not dumped"));
563 directory
->tagfile
= tag_file_name
;
566 case exclusion_tag_none
:
574 /* Compare dumpdir array from DIRECTORY with directory listing DIR and
575 build a new dumpdir template.
577 DIR must be returned by a previous call to savedir().
579 File names in DIRECTORY->dump->contents must be sorted
582 DIRECTORY->dump is replaced with the created template. Each entry is
583 prefixed with ' ' if it was present in DUMP and with 'Y' otherwise. */
586 makedumpdir (struct directory
*directory
, const char *dir
)
589 dirsize
, /* Number of elements in DIR */
590 len
; /* Length of DIR, including terminating nul */
593 char *new_dump
, *new_dump_ptr
;
594 struct dumpdir
*dump
;
596 if (directory
->children
== ALL_CHILDREN
)
598 else if (DIR_IS_RENAMED (directory
))
599 dump
= directory
->orig
->idump
?
600 directory
->orig
->idump
: directory
->orig
->dump
;
602 dump
= directory
->dump
;
604 /* Count the size of DIR and the number of elements it contains */
607 for (p
= dir
; *p
; p
+= strlen (p
) + 1, dirsize
++)
608 len
+= strlen (p
) + 2;
611 /* Create a sorted directory listing */
612 array
= xcalloc (dirsize
, sizeof array
[0]);
613 for (i
= 0, p
= dir
; *p
; p
+= strlen (p
) + 1, i
++)
616 qsort (array
, dirsize
, sizeof (array
[0]), compare_dirnames
);
618 /* Prepare space for new dumpdir */
619 new_dump
= xmalloc (len
);
620 new_dump_ptr
= new_dump
;
622 /* Fill in the dumpdir template */
623 for (i
= 0; i
< dirsize
; i
++)
625 const char *loc
= dumpdir_locate (dump
, array
[i
]);
628 if (directory
->tagfile
)
629 *new_dump_ptr
= strcmp (directory
->tagfile
, array
[i
]) == 0 ?
635 else if (directory
->tagfile
)
636 *new_dump_ptr
++ = strcmp (directory
->tagfile
, array
[i
]) == 0 ?
639 *new_dump_ptr
++ = 'Y'; /* New entry */
641 /* Copy the file name */
642 for (p
= array
[i
]; (*new_dump_ptr
++ = *p
++); )
646 directory
->idump
= directory
->dump
;
647 directory
->dump
= dumpdir_create0 (new_dump
, NULL
);
651 /* Recursively scan the given directory. */
653 scan_directory (char *dir
, dev_t device
)
655 char *dirp
= savedir (dir
); /* for scanning directory */
656 char *name_buffer
; /* directory, `/', and directory member */
657 size_t name_buffer_size
; /* allocated size of name_buffer, minus 2 */
658 size_t name_length
; /* used length in name_buffer */
659 struct stat stat_data
;
660 struct directory
*directory
;
665 name_buffer_size
= strlen (dir
) + NAME_FIELD_SIZE
;
666 name_buffer
= xmalloc (name_buffer_size
+ 2);
667 strcpy (name_buffer
, dir
);
668 if (! ISSLASH (dir
[strlen (dir
) - 1]))
669 strcat (name_buffer
, "/");
670 name_length
= strlen (name_buffer
);
672 if (deref_stat (dereference_option
, name_buffer
, &stat_data
))
674 stat_diag (name_buffer
);
676 children = CHANGED_CHILDREN;
683 directory
= procdir (name_buffer
, &stat_data
, device
, 0, NULL
);
685 if (dirp
&& directory
->children
!= NO_CHILDREN
)
687 char *entry
; /* directory entry being scanned */
688 size_t entrylen
; /* length of directory entry */
691 makedumpdir (directory
, dirp
);
693 for (entry
= dumpdir_first (directory
->dump
, 1, &itr
);
695 entry
= dumpdir_next (itr
))
697 entrylen
= strlen (entry
);
698 if (name_buffer_size
<= entrylen
- 1 + name_length
)
701 name_buffer_size
+= NAME_FIELD_SIZE
;
702 while (name_buffer_size
<= entrylen
- 1 + name_length
);
703 name_buffer
= xrealloc (name_buffer
, name_buffer_size
+ 2);
705 strcpy (name_buffer
+ name_length
, entry
+ 1);
707 if (*entry
== 'I') /* Ignored entry */
709 else if (excluded_name (name_buffer
))
713 if (deref_stat (dereference_option
, name_buffer
, &stat_data
))
715 stat_diag (name_buffer
);
720 if (S_ISDIR (stat_data
.st_mode
))
722 int pd_flag
= (verbose_option
? PD_VERBOSE
: 0);
723 if (!recursion_option
)
724 pd_flag
|= PD_FORCE_CHILDREN
| NO_CHILDREN
;
725 else if (directory
->children
== ALL_CHILDREN
)
726 pd_flag
|= PD_FORCE_CHILDREN
| ALL_CHILDREN
;
728 procdir (name_buffer
, &stat_data
, device
, pd_flag
, entry
);
731 else if (one_file_system_option
&& device
!= stat_data
.st_dev
)
734 else if (*entry
== 'Y')
735 /* New entry, skip further checks */;
737 /* FIXME: if (S_ISHIDDEN (stat_data.st_mode))?? */
739 else if (OLDER_STAT_TIME (stat_data
, m
)
740 && (!after_date_option
741 || OLDER_STAT_TIME (stat_data
, c
)))
754 return directory
->dump
? directory
->dump
->contents
: NULL
;
758 get_directory_contents (char *dir
, dev_t device
)
760 return scan_directory (dir
, device
);
765 obstack_code_rename (struct obstack
*stk
, char *from
, char *to
)
769 s
= from
[0] == 0 ? from
:
770 safer_name_suffix (from
, false, absolute_names_option
);
771 obstack_1grow (stk
, 'R');
772 obstack_grow (stk
, s
, strlen (s
) + 1);
775 safer_name_suffix (to
, false, absolute_names_option
);
776 obstack_1grow (stk
, 'T');
777 obstack_grow (stk
, s
, strlen (s
) + 1);
781 store_rename (struct directory
*dir
, struct obstack
*stk
)
783 if (DIR_IS_RENAMED (dir
))
785 struct directory
*prev
, *p
;
787 /* Detect eventual cycles and clear DIRF_RENAMED flag, so these entries
788 are ignored when hit by this function next time.
789 If the chain forms a cycle, prev points to the entry DIR is renamed
790 from. In this case it still retains DIRF_RENAMED flag, which will be
791 cleared in the `else' branch below */
792 for (prev
= dir
; prev
&& prev
->orig
!= dir
; prev
= prev
->orig
)
793 DIR_CLEAR_FLAG (prev
, DIRF_RENAMED
);
797 for (p
= dir
; p
&& p
->orig
; p
= p
->orig
)
798 obstack_code_rename (stk
, p
->orig
->name
, p
->name
);
804 DIR_CLEAR_FLAG (prev
, DIRF_RENAMED
);
806 /* Break the cycle by using a temporary name for one of its
808 First, create a temp name stub entry. */
809 temp_name
= dir_name (dir
->name
);
810 obstack_1grow (stk
, 'X');
811 obstack_grow (stk
, temp_name
, strlen (temp_name
) + 1);
813 obstack_code_rename (stk
, dir
->name
, "");
815 for (p
= dir
; p
!= prev
; p
= p
->orig
)
816 obstack_code_rename (stk
, p
->orig
->name
, p
->name
);
818 obstack_code_rename (stk
, "", prev
->name
);
824 append_incremental_renames (const char *dump
)
828 struct directory
*dp
;
836 size
= dumpdir_size (dump
) - 1;
837 obstack_grow (&stk
, dump
, size
);
842 for (dp
= dirhead
; dp
; dp
= dp
->next
)
843 store_rename (dp
, &stk
);
845 if (obstack_object_size (&stk
) != size
)
847 obstack_1grow (&stk
, 0);
848 dump
= obstack_finish (&stk
);
851 obstack_free (&stk
, NULL
);
857 static FILE *listed_incremental_stream
;
859 /* Version of incremental format snapshots (directory files) used by this
860 tar. Currently it is supposed to be a single decimal number. 0 means
861 incremental snapshots as per tar version before 1.15.2.
863 The current tar version supports incremental versions from
864 0 up to TAR_INCREMENTAL_VERSION, inclusive.
865 It is able to create only snapshots of TAR_INCREMENTAL_VERSION */
867 #define TAR_INCREMENTAL_VERSION 2
869 /* Read incremental snapshot formats 0 and 1 */
871 read_incr_db_01 (int version
, const char *initbuf
)
884 if (getline (&buf
, &bufsize
, listed_incremental_stream
) <= 0)
886 read_error (listed_incremental_option
);
894 buf
= strdup (initbuf
);
895 bufsize
= strlen (buf
) + 1;
898 sec
= TYPE_MINIMUM (time_t);
901 u
= strtoumax (buf
, &ebuf
, 10);
902 if (!errno
&& TYPE_MAXIMUM (time_t) < u
)
904 if (errno
|| buf
== ebuf
)
905 ERROR ((0, errno
, "%s:%ld: %s",
906 quotearg_colon (listed_incremental_option
),
908 _("Invalid time stamp")));
913 if (version
== 1 && *ebuf
)
915 char const *buf_ns
= ebuf
+ 1;
917 u
= strtoumax (buf_ns
, &ebuf
, 10);
918 if (!errno
&& BILLION
<= u
)
920 if (errno
|| buf_ns
== ebuf
)
922 ERROR ((0, errno
, "%s:%ld: %s",
923 quotearg_colon (listed_incremental_option
),
925 _("Invalid time stamp")));
926 sec
= TYPE_MINIMUM (time_t);
933 /* pre-1 incremental format does not contain nanoseconds */
937 newer_mtime_option
.tv_sec
= sec
;
938 newer_mtime_option
.tv_nsec
= nsec
;
941 while (0 < (n
= getline (&buf
, &bufsize
, listed_incremental_stream
)))
945 bool nfs
= buf
[0] == '+';
946 char *strp
= buf
+ nfs
;
947 struct timespec mtime
;
951 if (buf
[n
- 1] == '\n')
957 u
= strtoumax (strp
, &ebuf
, 10);
958 if (!errno
&& TYPE_MAXIMUM (time_t) < u
)
960 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
962 ERROR ((0, errno
, "%s:%ld: %s",
963 quotearg_colon (listed_incremental_option
), lineno
,
964 _("Invalid modification time (seconds)")));
972 u
= strtoumax (strp
, &ebuf
, 10);
973 if (!errno
&& BILLION
<= u
)
975 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
977 ERROR ((0, errno
, "%s:%ld: %s",
978 quotearg_colon (listed_incremental_option
), lineno
,
979 _("Invalid modification time (nanoseconds)")));
985 mtime
.tv_nsec
= nsec
;
989 memset (&mtime
, 0, sizeof mtime
);
992 u
= strtoumax (strp
, &ebuf
, 10);
993 if (!errno
&& TYPE_MAXIMUM (dev_t
) < u
)
995 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
997 ERROR ((0, errno
, "%s:%ld: %s",
998 quotearg_colon (listed_incremental_option
), lineno
,
999 _("Invalid device number")));
1007 u
= strtoumax (strp
, &ebuf
, 10);
1008 if (!errno
&& TYPE_MAXIMUM (ino_t
) < u
)
1010 if (errno
|| strp
== ebuf
|| *ebuf
!= ' ')
1012 ERROR ((0, errno
, "%s:%ld: %s",
1013 quotearg_colon (listed_incremental_option
), lineno
,
1014 _("Invalid inode number")));
1022 unquote_string (strp
);
1023 note_directory (strp
, mtime
, dev
, ino
, nfs
, false, NULL
);
1028 /* Read a nul-terminated string from FP and store it in STK.
1029 Store the number of bytes read (including nul terminator) in PCOUNT.
1031 Return the last character read or EOF on end of file. */
1033 read_obstack (FILE *fp
, struct obstack
*stk
, size_t *pcount
)
1038 for (i
= 0, c
= getc (fp
); c
!= EOF
&& c
!= 0; c
= getc (fp
), i
++)
1039 obstack_1grow (stk
, c
);
1040 obstack_1grow (stk
, 0);
1046 /* Read from file FP a nul-terminated string and convert it to
1047 intmax_t. Return the resulting value in PVAL. Assume '-' has
1050 Throw a fatal error if the string cannot be converted or if the
1051 converted value is less than MIN_VAL. */
1054 read_negative_num (FILE *fp
, intmax_t min_val
, intmax_t *pval
)
1058 char buf
[INT_BUFSIZE_BOUND (intmax_t)];
1062 for (i
= 1; ISDIGIT (c
= getc (fp
)); i
++)
1064 if (i
== sizeof buf
- 1)
1065 FATAL_ERROR ((0, 0, _("Field too long while reading snapshot file")));
1072 FATAL_ERROR ((0, errno
, _("Read error in snapshot file")));
1074 FATAL_ERROR ((0, 0, _("Unexpected EOF in snapshot file")));
1079 *pval
= strtoimax (buf
, &ep
, 10);
1080 if (c
|| errno
|| *pval
< min_val
)
1081 FATAL_ERROR ((0, errno
, _("Unexpected field value in snapshot file")));
1084 /* Read from file FP a nul-terminated string and convert it to
1085 uintmax_t. Return the resulting value in PVAL. Assume C has
1088 Throw a fatal error if the string cannot be converted or if the
1089 converted value exceeds MAX_VAL.
1091 Return the last character read or EOF on end of file. */
1094 read_unsigned_num (int c
, FILE *fp
, uintmax_t max_val
, uintmax_t *pval
)
1097 char buf
[UINTMAX_STRSIZE_BOUND
], *ep
;
1099 for (i
= 0; ISDIGIT (c
); i
++)
1101 if (i
== sizeof buf
- 1)
1102 FATAL_ERROR ((0, 0, _("Field too long while reading snapshot file")));
1110 FATAL_ERROR ((0, errno
, _("Read error in snapshot file")));
1114 FATAL_ERROR ((0, 0, _("Unexpected EOF in snapshot file")));
1119 *pval
= strtoumax (buf
, &ep
, 10);
1120 if (c
|| errno
|| max_val
< *pval
)
1121 FATAL_ERROR ((0, errno
, _("Unexpected field value in snapshot file")));
1125 /* Read from file FP a nul-terminated string and convert it to
1126 uintmax_t. Return the resulting value in PVAL.
1128 Throw a fatal error if the string cannot be converted or if the
1129 converted value exceeds MAX_VAL.
1131 Return the last character read or EOF on end of file. */
1134 read_num (FILE *fp
, uintmax_t max_val
, uintmax_t *pval
)
1136 return read_unsigned_num (getc (fp
), fp
, max_val
, pval
);
1139 /* Read from FP two NUL-terminated strings representing a struct
1140 timespec. Return the resulting value in PVAL.
1142 Throw a fatal error if the string cannot be converted. */
1145 read_timespec (FILE *fp
, struct timespec
*pval
)
1153 read_negative_num (fp
, TYPE_MINIMUM (time_t), &i
);
1159 c
= read_unsigned_num (c
, fp
, TYPE_MAXIMUM (time_t), &u
);
1163 if (c
|| read_num (fp
, BILLION
- 1, &u
))
1164 FATAL_ERROR ((0, 0, "%s: %s",
1165 quotearg_colon (listed_incremental_option
),
1166 _("Unexpected EOF in snapshot file")));
1170 /* Read incremental snapshot format 2 */
1177 obstack_init (&stk
);
1179 read_timespec (listed_incremental_stream
, &newer_mtime_option
);
1183 struct timespec mtime
;
1191 if (read_num (listed_incremental_stream
, 1, &u
))
1192 return; /* Normal return */
1196 read_timespec (listed_incremental_stream
, &mtime
);
1198 if (read_num (listed_incremental_stream
, TYPE_MAXIMUM (dev_t
), &u
))
1202 if (read_num (listed_incremental_stream
, TYPE_MAXIMUM (ino_t
), &u
))
1206 if (read_obstack (listed_incremental_stream
, &stk
, &s
))
1209 name
= obstack_finish (&stk
);
1211 while (read_obstack (listed_incremental_stream
, &stk
, &s
) == 0 && s
> 1)
1213 if (getc (listed_incremental_stream
) != 0)
1214 FATAL_ERROR ((0, 0, "%s: %s",
1215 quotearg_colon (listed_incremental_option
),
1216 _("Missing record terminator")));
1218 content
= obstack_finish (&stk
);
1219 note_directory (name
, mtime
, dev
, ino
, nfs
, false, content
);
1220 obstack_free (&stk
, content
);
1222 FATAL_ERROR ((0, 0, "%s: %s",
1223 quotearg_colon (listed_incremental_option
),
1224 _("Unexpected EOF in snapshot file")));
1227 /* Read incremental snapshot file (directory file).
1228 If the file has older incremental version, make sure that it is processed
1229 correctly and that tar will use the most conservative backup method among
1230 possible alternatives (i.e. prefer ALL_CHILDREN over CHANGED_CHILDREN,
1231 etc.) This ensures that the snapshots are updated to the recent version
1232 without any loss of data. */
1234 read_directory_file (void)
1240 /* Open the file for both read and write. That way, we can write
1241 it later without having to reopen it, and don't have to worry if
1242 we chdir in the meantime. */
1243 fd
= open (listed_incremental_option
, O_RDWR
| O_CREAT
, MODE_RW
);
1246 open_error (listed_incremental_option
);
1250 listed_incremental_stream
= fdopen (fd
, "r+");
1251 if (! listed_incremental_stream
)
1253 open_error (listed_incremental_option
);
1258 if (0 < getline (&buf
, &bufsize
, listed_incremental_stream
))
1261 uintmax_t incremental_version
;
1263 if (strncmp (buf
, PACKAGE_NAME
, sizeof PACKAGE_NAME
- 1) == 0)
1265 ebuf
= buf
+ sizeof PACKAGE_NAME
- 1;
1267 ERROR((1, 0, _("Bad incremental file format")));
1268 for (; *ebuf
!= '-'; ebuf
++)
1270 ERROR((1, 0, _("Bad incremental file format")));
1272 incremental_version
= strtoumax (ebuf
+ 1, NULL
, 10);
1275 incremental_version
= 0;
1277 switch (incremental_version
)
1281 read_incr_db_01 (incremental_version
, buf
);
1284 case TAR_INCREMENTAL_VERSION
:
1289 ERROR ((1, 0, _("Unsupported incremental format version: %"PRIuMAX
),
1290 incremental_version
));
1295 if (ferror (listed_incremental_stream
))
1296 read_error (listed_incremental_option
);
1301 /* Output incremental data for the directory ENTRY to the file DATA.
1302 Return nonzero if successful, preserving errno on write failure. */
1304 write_directory_file_entry (void *entry
, void *data
)
1306 struct directory
const *directory
= entry
;
1309 if (DIR_IS_FOUND (directory
))
1311 char buf
[UINTMAX_STRSIZE_BOUND
];
1314 s
= DIR_IS_NFS (directory
) ? "1" : "0";
1315 fwrite (s
, 2, 1, fp
);
1316 s
= (TYPE_SIGNED (time_t)
1317 ? imaxtostr (directory
->mtime
.tv_sec
, buf
)
1318 : umaxtostr (directory
->mtime
.tv_sec
, buf
));
1319 fwrite (s
, strlen (s
) + 1, 1, fp
);
1320 s
= umaxtostr (directory
->mtime
.tv_nsec
, buf
);
1321 fwrite (s
, strlen (s
) + 1, 1, fp
);
1322 s
= umaxtostr (directory
->device_number
, buf
);
1323 fwrite (s
, strlen (s
) + 1, 1, fp
);
1324 s
= umaxtostr (directory
->inode_number
, buf
);
1325 fwrite (s
, strlen (s
) + 1, 1, fp
);
1327 fwrite (directory
->name
, strlen (directory
->name
) + 1, 1, fp
);
1328 if (directory
->dump
)
1333 for (p
= dumpdir_first (directory
->dump
, 0, &itr
);
1335 p
= dumpdir_next (itr
))
1336 fwrite (p
, strlen (p
) + 1, 1, fp
);
1339 fwrite ("\0\0", 2, 1, fp
);
1342 return ! ferror (fp
);
1346 write_directory_file (void)
1348 FILE *fp
= listed_incremental_stream
;
1349 char buf
[UINTMAX_STRSIZE_BOUND
];
1355 if (fseek (fp
, 0L, SEEK_SET
) != 0)
1356 seek_error (listed_incremental_option
);
1357 if (sys_truncate (fileno (fp
)) != 0)
1358 truncate_error (listed_incremental_option
);
1360 fprintf (fp
, "%s-%s-%d\n", PACKAGE_NAME
, PACKAGE_VERSION
,
1361 TAR_INCREMENTAL_VERSION
);
1363 s
= (TYPE_SIGNED (time_t)
1364 ? imaxtostr (start_time
.tv_sec
, buf
)
1365 : umaxtostr (start_time
.tv_sec
, buf
));
1366 fwrite (s
, strlen (s
) + 1, 1, fp
);
1367 s
= umaxtostr (start_time
.tv_nsec
, buf
);
1368 fwrite (s
, strlen (s
) + 1, 1, fp
);
1370 if (! ferror (fp
) && directory_table
)
1371 hash_do_for_each (directory_table
, write_directory_file_entry
, fp
);
1374 write_error (listed_incremental_option
);
1375 if (fclose (fp
) != 0)
1376 close_error (listed_incremental_option
);
1380 /* Restoration of incremental dumps. */
1383 get_gnu_dumpdir (struct tar_stat_info
*stat_info
)
1387 union block
*data_block
;
1391 size
= stat_info
->stat
.st_size
;
1393 archive_dir
= xmalloc (size
);
1396 set_next_block_after (current_header
);
1397 mv_begin (stat_info
);
1399 for (; size
> 0; size
-= copied
)
1401 mv_size_left (size
);
1402 data_block
= find_next_block ();
1404 ERROR ((1, 0, _("Unexpected EOF in archive")));
1405 copied
= available_space_after (data_block
);
1408 memcpy (to
, data_block
->buffer
, copied
);
1410 set_next_block_after ((union block
*)
1411 (data_block
->buffer
+ copied
- 1));
1416 stat_info
->dumpdir
= archive_dir
;
1417 stat_info
->skipped
= true; /* For skip_member() and friends
1418 to work correctly */
1421 /* Return T if STAT_INFO represents a dumpdir archive member.
1422 Note: can invalidate current_header. It happens if flush_archive()
1423 gets called within get_gnu_dumpdir() */
1425 is_dumpdir (struct tar_stat_info
*stat_info
)
1427 if (stat_info
->is_dumpdir
&& !stat_info
->dumpdir
)
1428 get_gnu_dumpdir (stat_info
);
1429 return stat_info
->is_dumpdir
;
1433 dumpdir_ok (char *dumpdir
)
1436 int has_tempdir
= 0;
1439 for (p
= dumpdir
; *p
; p
+= strlen (p
) + 1)
1441 if (expect
&& *p
!= expect
)
1444 _("Malformed dumpdir: expected '%c' but found %#3o"),
1454 _("Malformed dumpdir: 'X' duplicated")));
1467 _("Malformed dumpdir: empty name in 'R'")));
1480 _("Malformed dumpdir: 'T' not preceeded by 'R'")));
1483 if (p
[1] == 0 && !has_tempdir
)
1486 _("Malformed dumpdir: empty name in 'T'")));
1498 /* FIXME: bail out? */
1506 _("Malformed dumpdir: expected '%c' but found end of data"),
1512 WARNOPT (WARN_BAD_DUMPDIR
,
1513 (0, 0, _("Malformed dumpdir: 'X' never used")));
1518 /* Examine the directories under directory_name and delete any
1519 files that were not there at the time of the back-up. */
1521 try_purge_directory (char const *directory_name
)
1524 char *cur
, *arc
, *p
;
1525 char *temp_stub
= NULL
;
1526 struct dumpdir
*dump
;
1528 if (!is_dumpdir (¤t_stat_info
))
1531 current_dir
= savedir (directory_name
);
1534 /* The directory doesn't exist now. It'll be created. In any
1535 case, we don't have to delete any files out of it. */
1538 /* Verify if dump directory is sane */
1539 if (!dumpdir_ok (current_stat_info
.dumpdir
))
1542 /* Process renames */
1543 for (arc
= current_stat_info
.dumpdir
; *arc
; arc
+= strlen (arc
) + 1)
1547 #define TEMP_DIR_TEMPLATE "tar.XXXXXX"
1548 size_t len
= strlen (arc
+ 1);
1549 temp_stub
= xrealloc (temp_stub
, len
+ 1 + sizeof TEMP_DIR_TEMPLATE
);
1550 memcpy (temp_stub
, arc
+ 1, len
);
1551 temp_stub
[len
] = '/';
1552 memcpy (temp_stub
+ len
+ 1, TEMP_DIR_TEMPLATE
,
1553 sizeof TEMP_DIR_TEMPLATE
);
1554 if (!mkdtemp (temp_stub
))
1557 _("Cannot create temporary directory using template %s"),
1558 quote (temp_stub
)));
1564 else if (*arc
== 'R')
1568 arc
+= strlen (arc
) + 1;
1571 /* Ensure that neither source nor destination are absolute file
1572 names (unless permitted by -P option), and that they do not
1573 contain dubious parts (e.g. ../).
1575 This is an extra safety precaution. Besides, it might be
1576 necessary to extract from archives created with tar versions
1580 src
= safer_name_suffix (src
, false, absolute_names_option
);
1582 dst
= safer_name_suffix (dst
, false, absolute_names_option
);
1589 if (!rename_directory (src
, dst
))
1593 /* FIXME: Make sure purge_directory(dst) will return
1602 /* Process deletes */
1603 dump
= dumpdir_create (current_stat_info
.dumpdir
);
1605 for (cur
= current_dir
; *cur
; cur
+= strlen (cur
) + 1)
1611 p
= new_name (directory_name
, cur
);
1613 if (deref_stat (false, p
, &st
))
1615 if (errno
!= ENOENT
) /* FIXME: Maybe keep a list of renamed
1616 dirs and check it here? */
1619 WARN ((0, 0, _("%s: Not purging directory: unable to stat"),
1620 quotearg_colon (p
)));
1625 if (!(entry
= dumpdir_locate (dump
, cur
))
1626 || (*entry
== 'D' && !S_ISDIR (st
.st_mode
))
1627 || (*entry
== 'Y' && S_ISDIR (st
.st_mode
)))
1629 if (one_file_system_option
&& st
.st_dev
!= root_device
)
1632 _("%s: directory is on a different device: not purging"),
1633 quotearg_colon (p
)));
1637 if (! interactive_option
|| confirm ("delete", p
))
1640 fprintf (stdlis
, _("%s: Deleting %s\n"),
1641 program_name
, quote (p
));
1642 if (! remove_any_file (p
, RECURSIVE_REMOVE_OPTION
))
1645 ERROR ((0, e
, _("%s: Cannot remove"), quotearg_colon (p
)));
1651 dumpdir_free (dump
);
1658 purge_directory (char const *directory_name
)
1660 if (!try_purge_directory (directory_name
))
1665 list_dumpdir (char *buffer
, size_t size
)
1678 fprintf (stdlis
, "%c", *buffer
);
1681 fprintf (stdlis
, " ");
1689 fputc ('\n', stdlis
);
1696 fputc (*buffer
, stdlis
);