1 /* Create a tar archive.
3 Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
4 2003, 2004, 2005, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
6 Written by John Gilmore, on 1985-08-25.
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 3, or (at your option) any later
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
16 Public License for more details.
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
29 /* Error number to use when an impostor is discovered.
30 Pretend the impostor isn't there. */
31 enum { IMPOSTOR_ERRNO
= ENOENT
};
45 enum exclusion_tag_type type
;
46 bool (*predicate
) (int fd
);
47 struct exclusion_tag
*next
;
50 static struct exclusion_tag
*exclusion_tags
;
53 add_exclusion_tag (const char *name
, enum exclusion_tag_type type
,
54 bool (*predicate
) (int fd
))
56 struct exclusion_tag
*tag
= xmalloc (sizeof tag
[0]);
57 tag
->next
= exclusion_tags
;
60 tag
->predicate
= predicate
;
61 tag
->length
= strlen (name
);
66 exclusion_tag_warning (const char *dirname
, const char *tagname
,
70 WARNOPT (WARN_CACHEDIR
,
72 _("%s: contains a cache directory tag %s; %s"),
73 quotearg_colon (dirname
),
74 quotearg_n (1, tagname
),
78 enum exclusion_tag_type
79 check_exclusion_tags (struct tar_stat_info
const *st
, char const **tag_file_name
)
81 struct exclusion_tag
*tag
;
83 for (tag
= exclusion_tags
; tag
; tag
= tag
->next
)
85 int tagfd
= subfile_open (st
, tag
->name
, open_read_flags
);
88 bool satisfied
= !tag
->predicate
|| tag
->predicate (tagfd
);
93 *tag_file_name
= tag
->name
;
99 return exclusion_tag_none
;
102 /* Exclusion predicate to test if the named file (usually "CACHEDIR.TAG")
103 contains a valid header, as described at:
104 http://www.brynosaurus.com/cachedir
105 Applications can write this file into directories they create
106 for use as caches containing purely regenerable, non-precious data,
107 allowing us to avoid archiving them if --exclude-caches is specified. */
109 #define CACHEDIR_SIGNATURE "Signature: 8a477f597d28d172789f06886806bc55"
110 #define CACHEDIR_SIGNATURE_SIZE (sizeof CACHEDIR_SIGNATURE - 1)
113 cachedir_file_p (int fd
)
115 char tagbuf
[CACHEDIR_SIGNATURE_SIZE
];
118 (read (fd
, tagbuf
, CACHEDIR_SIGNATURE_SIZE
) == CACHEDIR_SIGNATURE_SIZE
119 && memcmp (tagbuf
, CACHEDIR_SIGNATURE
, CACHEDIR_SIGNATURE_SIZE
) == 0);
123 /* The maximum uintmax_t value that can be represented with DIGITS digits,
124 assuming that each digit is BITS_PER_DIGIT wide. */
125 #define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
126 ((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
127 ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
130 /* The maximum uintmax_t value that can be represented with octal
131 digits and a trailing NUL in BUFFER. */
132 #define MAX_OCTAL_VAL(buffer) MAX_VAL_WITH_DIGITS (sizeof (buffer) - 1, LG_8)
134 /* Convert VALUE to an octal representation suitable for tar headers.
135 Output to buffer WHERE with size SIZE.
136 The result is undefined if SIZE is 0 or if VALUE is too large to fit. */
139 to_octal (uintmax_t value
, char *where
, size_t size
)
146 where
[--i
] = '0' + (v
& ((1 << LG_8
) - 1));
152 /* Copy at most LEN bytes from the string SRC to DST. Terminate with
153 NUL unless SRC is LEN or more bytes long. */
156 tar_copy_str (char *dst
, const char *src
, size_t len
)
159 for (i
= 0; i
< len
; i
++)
160 if (! (dst
[i
] = src
[i
]))
164 /* Same as tar_copy_str, but always terminate with NUL if using
168 tar_name_copy_str (char *dst
, const char *src
, size_t len
)
170 tar_copy_str (dst
, src
, len
);
171 if (archive_format
== OLDGNU_FORMAT
)
175 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
176 tar headers. NEGATIVE is 1 if VALUE was negative before being cast
177 to uintmax_t, 0 otherwise. Output to buffer WHERE with size SIZE.
178 The result is undefined if SIZE is 0 or if VALUE is too large to
182 to_base256 (int negative
, uintmax_t value
, char *where
, size_t size
)
185 uintmax_t propagated_sign_bits
=
186 ((uintmax_t) - negative
<< (CHAR_BIT
* sizeof v
- LG_256
));
191 where
[--i
] = v
& ((1 << LG_256
) - 1);
192 v
= propagated_sign_bits
| (v
>> LG_256
);
197 #define GID_TO_CHARS(val, where) gid_to_chars (val, where, sizeof (where))
198 #define MAJOR_TO_CHARS(val, where) major_to_chars (val, where, sizeof (where))
199 #define MINOR_TO_CHARS(val, where) minor_to_chars (val, where, sizeof (where))
200 #define MODE_TO_CHARS(val, where) mode_to_chars (val, where, sizeof (where))
201 #define UID_TO_CHARS(val, where) uid_to_chars (val, where, sizeof (where))
203 #define UNAME_TO_CHARS(name,buf) string_to_chars (name, buf, sizeof(buf))
204 #define GNAME_TO_CHARS(name,buf) string_to_chars (name, buf, sizeof(buf))
207 to_chars (int negative
, uintmax_t value
, size_t valsize
,
208 uintmax_t (*substitute
) (int *),
209 char *where
, size_t size
, const char *type
);
212 to_chars_subst (int negative
, int gnu_format
, uintmax_t value
, size_t valsize
,
213 uintmax_t (*substitute
) (int *),
214 char *where
, size_t size
, const char *type
)
216 uintmax_t maxval
= (gnu_format
217 ? MAX_VAL_WITH_DIGITS (size
- 1, LG_256
)
218 : MAX_VAL_WITH_DIGITS (size
- 1, LG_8
));
219 char valbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
220 char maxbuf
[UINTMAX_STRSIZE_BOUND
];
221 char minbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
222 char const *minval_string
;
223 char const *maxval_string
= STRINGIFY_BIGINT (maxval
, maxbuf
);
224 char const *value_string
;
228 uintmax_t m
= maxval
+ 1 ? maxval
+ 1 : maxval
/ 2 + 1;
229 char *p
= STRINGIFY_BIGINT (m
, minbuf
+ 1);
238 char *p
= STRINGIFY_BIGINT (- value
, valbuf
+ 1);
243 value_string
= STRINGIFY_BIGINT (value
, valbuf
);
248 uintmax_t sub
= substitute (&negsub
) & maxval
;
249 /* NOTE: This is one of the few places where GNU_FORMAT differs from
250 OLDGNU_FORMAT. The actual differences are:
252 1. In OLDGNU_FORMAT all strings in a tar header end in \0
253 2. Incremental archives use oldgnu_header.
255 Apart from this they are completely identical. */
256 uintmax_t s
= (negsub
&= archive_format
== GNU_FORMAT
) ? - sub
: sub
;
257 char subbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
258 char *sub_string
= STRINGIFY_BIGINT (s
, subbuf
+ 1);
261 WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
262 value_string
, type
, minval_string
, maxval_string
,
264 return to_chars (negsub
, s
, valsize
, 0, where
, size
, type
);
267 ERROR ((0, 0, _("value %s out of %s range %s..%s"),
268 value_string
, type
, minval_string
, maxval_string
));
272 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
273 external form, using SUBSTITUTE (...) if VALUE won't fit. Output
274 to buffer WHERE with size SIZE. NEGATIVE is 1 iff VALUE was
275 negative before being cast to uintmax_t; its original bitpattern
276 can be deduced from VALSIZE, its original size before casting.
277 TYPE is the kind of value being output (useful for diagnostics).
278 Prefer the POSIX format of SIZE - 1 octal digits (with leading zero
279 digits), followed by '\0'. If this won't work, and if GNU or
280 OLDGNU format is allowed, use '\200' followed by base-256, or (if
281 NEGATIVE is nonzero) '\377' followed by two's complement base-256.
282 If neither format works, use SUBSTITUTE (...) instead. Pass to
283 SUBSTITUTE the address of an 0-or-1 flag recording whether the
284 substitute value is negative. */
287 to_chars (int negative
, uintmax_t value
, size_t valsize
,
288 uintmax_t (*substitute
) (int *),
289 char *where
, size_t size
, const char *type
)
291 int gnu_format
= (archive_format
== GNU_FORMAT
292 || archive_format
== OLDGNU_FORMAT
);
294 /* Generate the POSIX octal representation if the number fits. */
295 if (! negative
&& value
<= MAX_VAL_WITH_DIGITS (size
- 1, LG_8
))
297 where
[size
- 1] = '\0';
298 to_octal (value
, where
, size
- 1);
303 /* Try to cope with the number by using traditional GNU format
306 /* Generate the base-256 representation if the number fits. */
307 if (((negative
? -1 - value
: value
)
308 <= MAX_VAL_WITH_DIGITS (size
- 1, LG_256
)))
310 where
[0] = negative
? -1 : 1 << (LG_256
- 1);
311 to_base256 (negative
, value
, where
+ 1, size
- 1);
315 /* Otherwise, if the number is negative, and if it would not cause
316 ambiguity on this host by confusing positive with negative
317 values, then generate the POSIX octal representation of the value
318 modulo 2**(field bits). The resulting tar file is
319 machine-dependent, since it depends on the host word size. Yuck!
320 But this is the traditional behavior. */
321 else if (negative
&& valsize
* CHAR_BIT
<= (size
- 1) * LG_8
)
323 static int warned_once
;
327 WARN ((0, 0, _("Generating negative octal headers")));
329 where
[size
- 1] = '\0';
330 to_octal (value
& MAX_VAL_WITH_DIGITS (valsize
* CHAR_BIT
, 1),
334 /* Otherwise fall back to substitution, if possible: */
337 substitute
= NULL
; /* No substitution for formats, other than GNU */
339 return to_chars_subst (negative
, gnu_format
, value
, valsize
, substitute
,
344 gid_substitute (int *negative
)
350 static gid_t gid_nobody
;
351 if (!gid_nobody
&& !gname_to_gid ("nobody", &gid_nobody
))
360 gid_to_chars (gid_t v
, char *p
, size_t s
)
362 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, gid_substitute
, p
, s
, "gid_t");
366 major_to_chars (major_t v
, char *p
, size_t s
)
368 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "major_t");
372 minor_to_chars (minor_t v
, char *p
, size_t s
)
374 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "minor_t");
378 mode_to_chars (mode_t v
, char *p
, size_t s
)
380 /* In the common case where the internal and external mode bits are the same,
381 and we are not using POSIX or GNU format,
382 propagate all unknown bits to the external mode.
383 This matches historical practice.
384 Otherwise, just copy the bits we know about. */
387 if (S_ISUID
== TSUID
&& S_ISGID
== TSGID
&& S_ISVTX
== TSVTX
388 && S_IRUSR
== TUREAD
&& S_IWUSR
== TUWRITE
&& S_IXUSR
== TUEXEC
389 && S_IRGRP
== TGREAD
&& S_IWGRP
== TGWRITE
&& S_IXGRP
== TGEXEC
390 && S_IROTH
== TOREAD
&& S_IWOTH
== TOWRITE
&& S_IXOTH
== TOEXEC
391 && archive_format
!= POSIX_FORMAT
392 && archive_format
!= USTAR_FORMAT
393 && archive_format
!= GNU_FORMAT
)
401 u
= ((v
& S_ISUID
? TSUID
: 0)
402 | (v
& S_ISGID
? TSGID
: 0)
403 | (v
& S_ISVTX
? TSVTX
: 0)
404 | (v
& S_IRUSR
? TUREAD
: 0)
405 | (v
& S_IWUSR
? TUWRITE
: 0)
406 | (v
& S_IXUSR
? TUEXEC
: 0)
407 | (v
& S_IRGRP
? TGREAD
: 0)
408 | (v
& S_IWGRP
? TGWRITE
: 0)
409 | (v
& S_IXGRP
? TGEXEC
: 0)
410 | (v
& S_IROTH
? TOREAD
: 0)
411 | (v
& S_IWOTH
? TOWRITE
: 0)
412 | (v
& S_IXOTH
? TOEXEC
: 0));
414 return to_chars (negative
, u
, sizeof v
, 0, p
, s
, "mode_t");
418 off_to_chars (off_t v
, char *p
, size_t s
)
420 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "off_t");
424 time_to_chars (time_t v
, char *p
, size_t s
)
426 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "time_t");
430 uid_substitute (int *negative
)
436 static uid_t uid_nobody
;
437 if (!uid_nobody
&& !uname_to_uid ("nobody", &uid_nobody
))
446 uid_to_chars (uid_t v
, char *p
, size_t s
)
448 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, uid_substitute
, p
, s
, "uid_t");
452 uintmax_to_chars (uintmax_t v
, char *p
, size_t s
)
454 return to_chars (0, v
, sizeof v
, 0, p
, s
, "uintmax_t");
458 string_to_chars (char const *str
, char *p
, size_t s
)
460 tar_copy_str (p
, str
, s
);
465 /* A directory is always considered dumpable.
466 Otherwise, only regular and contiguous files are considered dumpable.
467 Such a file is dumpable if it is sparse and both --sparse and --totals
469 Otherwise, it is dumpable unless any of the following conditions occur:
471 a) it is empty *and* world-readable, or
472 b) current archive is /dev/null */
475 file_dumpable_p (struct stat
const *st
)
477 if (S_ISDIR (st
->st_mode
))
479 if (! (S_ISREG (st
->st_mode
) || S_ISCTG (st
->st_mode
)))
482 return totals_option
&& sparse_option
&& ST_IS_SPARSE (*st
);
483 return ! (st
->st_size
== 0 && (st
->st_mode
& MODE_R
) == MODE_R
);
487 /* Writing routines. */
489 /* Write the EOT block(s). Zero at least two blocks, through the end
490 of the record. Old tar, as previous versions of GNU tar, writes
491 garbage after two zeroed blocks. */
495 union block
*pointer
= find_next_block ();
496 memset (pointer
->buffer
, 0, BLOCKSIZE
);
497 set_next_block_after (pointer
);
498 pointer
= find_next_block ();
499 memset (pointer
->buffer
, 0, available_space_after (pointer
));
500 set_next_block_after (pointer
);
503 /* Write a "private" header */
505 start_private_header (const char *name
, size_t size
, time_t t
)
507 union block
*header
= find_next_block ();
509 memset (header
->buffer
, 0, sizeof (union block
));
511 tar_name_copy_str (header
->header
.name
, name
, NAME_FIELD_SIZE
);
512 OFF_TO_CHARS (size
, header
->header
.size
);
514 TIME_TO_CHARS (t
, header
->header
.mtime
);
515 MODE_TO_CHARS (S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
, header
->header
.mode
);
516 UID_TO_CHARS (getuid (), header
->header
.uid
);
517 GID_TO_CHARS (getgid (), header
->header
.gid
);
518 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
519 MINOR_TO_CHARS (0, header
->header
.devminor
);
520 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
521 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
525 /* Create a new header and store there at most NAME_FIELD_SIZE bytes of
529 write_short_name (struct tar_stat_info
*st
)
531 union block
*header
= find_next_block ();
532 memset (header
->buffer
, 0, sizeof (union block
));
533 tar_name_copy_str (header
->header
.name
, st
->file_name
, NAME_FIELD_SIZE
);
537 #define FILL(field,byte) do { \
538 memset(field, byte, sizeof(field)-1); \
539 (field)[sizeof(field)-1] = 0; \
542 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. */
544 write_gnu_long_link (struct tar_stat_info
*st
, const char *p
, char type
)
546 size_t size
= strlen (p
) + 1;
551 header
= start_private_header ("././@LongLink", size
, time (NULL
));
552 FILL (header
->header
.mtime
, '0');
553 FILL (header
->header
.mode
, '0');
554 FILL (header
->header
.uid
, '0');
555 FILL (header
->header
.gid
, '0');
556 FILL (header
->header
.devmajor
, 0);
557 FILL (header
->header
.devminor
, 0);
558 uid_to_uname (0, &tmpname
);
559 UNAME_TO_CHARS (tmpname
, header
->header
.uname
);
561 gid_to_gname (0, &tmpname
);
562 GNAME_TO_CHARS (tmpname
, header
->header
.gname
);
565 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
566 header
->header
.typeflag
= type
;
567 finish_header (st
, header
, -1);
569 header
= find_next_block ();
571 bufsize
= available_space_after (header
);
573 while (bufsize
< size
)
575 memcpy (header
->buffer
, p
, bufsize
);
578 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
579 header
= find_next_block ();
580 bufsize
= available_space_after (header
);
582 memcpy (header
->buffer
, p
, size
);
583 memset (header
->buffer
+ size
, 0, bufsize
- size
);
584 set_next_block_after (header
+ (size
- 1) / BLOCKSIZE
);
588 split_long_name (const char *name
, size_t length
)
592 if (length
> PREFIX_FIELD_SIZE
+ 1)
593 length
= PREFIX_FIELD_SIZE
+ 1;
594 else if (ISSLASH (name
[length
- 1]))
596 for (i
= length
- 1; i
> 0; i
--)
597 if (ISSLASH (name
[i
]))
603 write_ustar_long_name (const char *name
)
605 size_t length
= strlen (name
);
609 if (length
> PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1)
611 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
612 quotearg_colon (name
),
613 PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1));
617 i
= split_long_name (name
, length
);
618 if (i
== 0 || (nlen
= length
- i
- 1) > NAME_FIELD_SIZE
|| nlen
== 0)
621 _("%s: file name is too long (cannot be split); not dumped"),
622 quotearg_colon (name
)));
626 header
= find_next_block ();
627 memset (header
->buffer
, 0, sizeof (header
->buffer
));
628 memcpy (header
->header
.prefix
, name
, i
);
629 memcpy (header
->header
.name
, name
+ i
+ 1, length
- i
- 1);
634 /* Write a long link name, depending on the current archive format */
636 write_long_link (struct tar_stat_info
*st
)
638 switch (archive_format
)
641 xheader_store ("linkpath", st
, NULL
);
644 case V7_FORMAT
: /* old V7 tar format */
648 _("%s: link name is too long; not dumped"),
649 quotearg_colon (st
->link_name
)));
654 write_gnu_long_link (st
, st
->link_name
, GNUTYPE_LONGLINK
);
663 write_long_name (struct tar_stat_info
*st
)
665 switch (archive_format
)
668 xheader_store ("path", st
, NULL
);
672 if (strlen (st
->file_name
) > NAME_FIELD_SIZE
-1)
674 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
675 quotearg_colon (st
->file_name
),
676 NAME_FIELD_SIZE
- 1));
683 return write_ustar_long_name (st
->file_name
);
687 write_gnu_long_link (st
, st
->file_name
, GNUTYPE_LONGNAME
);
693 return write_short_name (st
);
697 write_extended (bool global
, struct tar_stat_info
*st
, union block
*old_header
)
699 union block
*header
, hp
;
704 if (st
->xhdr
.buffer
|| st
->xhdr
.stk
== NULL
)
707 xheader_finish (&st
->xhdr
);
708 memcpy (hp
.buffer
, old_header
, sizeof (hp
));
712 p
= xheader_ghdr_name ();
718 p
= xheader_xhdr_name (st
);
719 t
= st
->stat
.st_mtime
;
721 xheader_write (type
, p
, t
, &st
->xhdr
);
723 header
= find_next_block ();
724 memcpy (header
, &hp
.buffer
, sizeof (hp
.buffer
));
729 write_header_name (struct tar_stat_info
*st
)
731 if (archive_format
== POSIX_FORMAT
&& !string_ascii_p (st
->file_name
))
733 xheader_store ("path", st
, NULL
);
734 return write_short_name (st
);
736 else if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
)
737 < strlen (st
->file_name
))
738 return write_long_name (st
);
740 return write_short_name (st
);
744 /* Header handling. */
746 /* Make a header block for the file whose stat info is st,
747 and return its address. */
750 start_header (struct tar_stat_info
*st
)
754 header
= write_header_name (st
);
758 /* Override some stat fields, if requested to do so. */
760 if (owner_option
!= (uid_t
) -1)
761 st
->stat
.st_uid
= owner_option
;
762 if (group_option
!= (gid_t
) -1)
763 st
->stat
.st_gid
= group_option
;
766 ((st
->stat
.st_mode
& ~MODE_ALL
)
767 | mode_adjust (st
->stat
.st_mode
, S_ISDIR (st
->stat
.st_mode
) != 0,
768 initial_umask
, mode_option
, NULL
));
770 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
771 for a few tars and came up with the following interoperability
775 1 2 3 4 5 6 7 8 9 READER
776 . . . . . . . . . 1 = SunOS 4.2 tar
777 # . . # # . . # # 2 = NEC SVR4.0.2 tar
778 . . . # # . . # . 3 = Solaris 2.1 tar
779 . . . . . . . . . 4 = GNU tar 1.11.1
780 . . . . . . . . . 5 = HP-UX 8.07 tar
781 . . . . . . . . . 6 = Ultrix 4.1
782 . . . . . . . . . 7 = AIX 3.2
783 . . . . . . . . . 8 = Hitachi HI-UX 1.03
784 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
787 # = ``impossible file type''
789 The following mask for old archive removes the `#'s in column 4
790 above, thus making GNU tar both a universal donor and a universal
791 acceptor for Paul's test. */
793 if (archive_format
== V7_FORMAT
|| archive_format
== USTAR_FORMAT
)
794 MODE_TO_CHARS (st
->stat
.st_mode
& MODE_ALL
, header
->header
.mode
);
796 MODE_TO_CHARS (st
->stat
.st_mode
, header
->header
.mode
);
799 uid_t uid
= st
->stat
.st_uid
;
800 if (archive_format
== POSIX_FORMAT
801 && MAX_OCTAL_VAL (header
->header
.uid
) < uid
)
803 xheader_store ("uid", st
, NULL
);
806 if (!UID_TO_CHARS (uid
, header
->header
.uid
))
811 gid_t gid
= st
->stat
.st_gid
;
812 if (archive_format
== POSIX_FORMAT
813 && MAX_OCTAL_VAL (header
->header
.gid
) < gid
)
815 xheader_store ("gid", st
, NULL
);
818 if (!GID_TO_CHARS (gid
, header
->header
.gid
))
823 off_t size
= st
->stat
.st_size
;
824 if (archive_format
== POSIX_FORMAT
825 && MAX_OCTAL_VAL (header
->header
.size
) < size
)
827 xheader_store ("size", st
, NULL
);
830 if (!OFF_TO_CHARS (size
, header
->header
.size
))
835 struct timespec mtime
= set_mtime_option
? mtime_option
: st
->mtime
;
836 if (archive_format
== POSIX_FORMAT
)
838 if (MAX_OCTAL_VAL (header
->header
.mtime
) < mtime
.tv_sec
839 || mtime
.tv_nsec
!= 0)
840 xheader_store ("mtime", st
, &mtime
);
841 if (MAX_OCTAL_VAL (header
->header
.mtime
) < mtime
.tv_sec
)
844 if (!TIME_TO_CHARS (mtime
.tv_sec
, header
->header
.mtime
))
849 if (S_ISCHR (st
->stat
.st_mode
)
850 || S_ISBLK (st
->stat
.st_mode
))
852 major_t devmajor
= major (st
->stat
.st_rdev
);
853 minor_t devminor
= minor (st
->stat
.st_rdev
);
855 if (archive_format
== POSIX_FORMAT
856 && MAX_OCTAL_VAL (header
->header
.devmajor
) < devmajor
)
858 xheader_store ("devmajor", st
, NULL
);
861 if (!MAJOR_TO_CHARS (devmajor
, header
->header
.devmajor
))
864 if (archive_format
== POSIX_FORMAT
865 && MAX_OCTAL_VAL (header
->header
.devminor
) < devminor
)
867 xheader_store ("devminor", st
, NULL
);
870 if (!MINOR_TO_CHARS (devminor
, header
->header
.devminor
))
873 else if (archive_format
!= GNU_FORMAT
&& archive_format
!= OLDGNU_FORMAT
)
875 if (!(MAJOR_TO_CHARS (0, header
->header
.devmajor
)
876 && MINOR_TO_CHARS (0, header
->header
.devminor
)))
880 if (archive_format
== POSIX_FORMAT
)
882 xheader_store ("atime", st
, NULL
);
883 xheader_store ("ctime", st
, NULL
);
885 else if (incremental_option
)
886 if (archive_format
== OLDGNU_FORMAT
|| archive_format
== GNU_FORMAT
)
888 TIME_TO_CHARS (st
->atime
.tv_sec
, header
->oldgnu_header
.atime
);
889 TIME_TO_CHARS (st
->ctime
.tv_sec
, header
->oldgnu_header
.ctime
);
892 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
894 switch (archive_format
)
900 case GNU_FORMAT
: /*FIXME?*/
901 /* Overwrite header->header.magic and header.version in one blow. */
902 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
907 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
908 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
915 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
917 /* header->header.[ug]name are left as the empty string. */
921 uid_to_uname (st
->stat
.st_uid
, &st
->uname
);
922 gid_to_gname (st
->stat
.st_gid
, &st
->gname
);
924 if (archive_format
== POSIX_FORMAT
925 && (strlen (st
->uname
) > UNAME_FIELD_SIZE
926 || !string_ascii_p (st
->uname
)))
927 xheader_store ("uname", st
, NULL
);
928 UNAME_TO_CHARS (st
->uname
, header
->header
.uname
);
930 if (archive_format
== POSIX_FORMAT
931 && (strlen (st
->gname
) > GNAME_FIELD_SIZE
932 || !string_ascii_p (st
->gname
)))
933 xheader_store ("gname", st
, NULL
);
934 GNAME_TO_CHARS (st
->gname
, header
->header
.gname
);
941 simple_finish_header (union block
*header
)
947 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
951 for (i
= sizeof *header
; i
-- != 0; )
952 /* We can't use unsigned char here because of old compilers, e.g. V7. */
955 /* Fill in the checksum field. It's formatted differently from the
956 other fields: it has [6] digits, a null, then a space -- rather than
957 digits, then a null. We use to_chars.
958 The final space is already there, from
959 checksumming, and to_chars doesn't modify it.
961 This is a fast way to do:
963 sprintf(header->header.chksum, "%6o", sum); */
965 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
967 set_next_block_after (header
);
970 /* Finish off a filled-in header block and write it out. We also
971 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
972 is not negative, is the block ordinal of the first record for this
973 file, which may be a preceding long name or long link record. */
975 finish_header (struct tar_stat_info
*st
,
976 union block
*header
, off_t block_ordinal
)
978 /* Note: It is important to do this before the call to write_extended(),
979 so that the actual ustar header is printed */
981 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
982 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
983 && header
->header
.typeflag
!= XHDTYPE
984 && header
->header
.typeflag
!= XGLTYPE
)
986 /* FIXME: This global is used in print_header, sigh. */
987 current_format
= archive_format
;
988 print_header (st
, header
, block_ordinal
);
991 header
= write_extended (false, st
, header
);
992 simple_finish_header (header
);
997 pad_archive (off_t size_left
)
1000 while (size_left
> 0)
1002 blk
= find_next_block ();
1003 memset (blk
->buffer
, 0, BLOCKSIZE
);
1004 set_next_block_after (blk
);
1005 size_left
-= BLOCKSIZE
;
1009 static enum dump_status
1010 dump_regular_file (int fd
, struct tar_stat_info
*st
)
1012 off_t size_left
= st
->stat
.st_size
;
1013 off_t block_ordinal
;
1016 block_ordinal
= current_block_ordinal ();
1017 blk
= start_header (st
);
1019 return dump_status_fail
;
1021 /* Mark contiguous files, if we support them. */
1022 if (archive_format
!= V7_FORMAT
&& S_ISCTG (st
->stat
.st_mode
))
1023 blk
->header
.typeflag
= CONTTYPE
;
1025 finish_header (st
, blk
, block_ordinal
);
1027 mv_begin_write (st
->file_name
, st
->stat
.st_size
, st
->stat
.st_size
);
1028 while (size_left
> 0)
1030 size_t bufsize
, count
;
1032 blk
= find_next_block ();
1034 bufsize
= available_space_after (blk
);
1036 if (size_left
< bufsize
)
1038 /* Last read -- zero out area beyond. */
1039 bufsize
= size_left
;
1040 count
= bufsize
% BLOCKSIZE
;
1042 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
1045 count
= (fd
<= 0) ? bufsize
: safe_read (fd
, blk
->buffer
, bufsize
);
1046 if (count
== SAFE_READ_ERROR
)
1048 read_diag_details (st
->orig_file_name
,
1049 st
->stat
.st_size
- size_left
, bufsize
);
1050 pad_archive (size_left
);
1051 return dump_status_short
;
1054 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
1056 if (count
!= bufsize
)
1058 char buf
[UINTMAX_STRSIZE_BOUND
];
1059 memset (blk
->buffer
+ count
, 0, bufsize
- count
);
1060 WARNOPT (WARN_FILE_SHRANK
,
1062 ngettext ("%s: File shrank by %s byte; padding with zeros",
1063 "%s: File shrank by %s bytes; padding with zeros",
1065 quotearg_colon (st
->orig_file_name
),
1066 STRINGIFY_BIGINT (size_left
, buf
)));
1067 if (! ignore_failed_read_option
)
1068 set_exit_status (TAREXIT_DIFFERS
);
1069 pad_archive (size_left
- (bufsize
- count
));
1070 return dump_status_short
;
1073 return dump_status_ok
;
1077 /* Copy info from the directory identified by ST into the archive.
1078 DIRECTORY contains the directory's entries. */
1081 dump_dir0 (struct tar_stat_info
*st
, char const *directory
)
1083 bool top_level
= ! st
->parent
;
1084 const char *tag_file_name
;
1085 union block
*blk
= NULL
;
1086 off_t block_ordinal
= current_block_ordinal ();
1088 st
->stat
.st_size
= 0; /* force 0 size on dir */
1090 blk
= start_header (st
);
1094 if (incremental_option
&& archive_format
!= POSIX_FORMAT
)
1095 blk
->header
.typeflag
= GNUTYPE_DUMPDIR
;
1096 else /* if (standard_option) */
1097 blk
->header
.typeflag
= DIRTYPE
;
1099 /* If we're gnudumping, we aren't done yet so don't close it. */
1101 if (!incremental_option
)
1102 finish_header (st
, blk
, block_ordinal
);
1103 else if (gnu_list_name
->directory
)
1105 if (archive_format
== POSIX_FORMAT
)
1107 xheader_store ("GNU.dumpdir", st
,
1108 safe_directory_contents (gnu_list_name
->directory
));
1109 finish_header (st
, blk
, block_ordinal
);
1117 const char *buffer
, *p_buffer
;
1119 block_ordinal
= current_block_ordinal ();
1120 buffer
= safe_directory_contents (gnu_list_name
->directory
);
1121 totsize
= dumpdir_size (buffer
);
1122 OFF_TO_CHARS (totsize
, blk
->header
.size
);
1123 finish_header (st
, blk
, block_ordinal
);
1125 size_left
= totsize
;
1127 mv_begin_write (st
->file_name
, totsize
, totsize
);
1128 while (size_left
> 0)
1130 blk
= find_next_block ();
1131 bufsize
= available_space_after (blk
);
1132 if (size_left
< bufsize
)
1134 bufsize
= size_left
;
1135 count
= bufsize
% BLOCKSIZE
;
1137 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
1139 memcpy (blk
->buffer
, p_buffer
, bufsize
);
1140 size_left
-= bufsize
;
1141 p_buffer
+= bufsize
;
1142 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
1148 if (!recursion_option
)
1151 if (one_file_system_option
1153 && st
->parent
->stat
.st_dev
!= st
->stat
.st_dev
)
1158 _("%s: file is on a different filesystem; not dumped"),
1159 quotearg_colon (st
->orig_file_name
)));
1166 switch (check_exclusion_tags (st
, &tag_file_name
))
1168 case exclusion_tag_all
:
1169 /* Handled in dump_file0 */
1172 case exclusion_tag_none
:
1178 name_buf
= xstrdup (st
->orig_file_name
);
1179 name_size
= name_len
= strlen (name_buf
);
1181 /* Now output all the files in the directory. */
1182 for (entry
= directory
; (entry_len
= strlen (entry
)) != 0;
1183 entry
+= entry_len
+ 1)
1185 if (name_size
< name_len
+ entry_len
)
1187 name_size
= name_len
+ entry_len
;
1188 name_buf
= xrealloc (name_buf
, name_size
+ 1);
1190 strcpy (name_buf
+ name_len
, entry
);
1191 if (!excluded_name (name_buf
))
1192 dump_file (st
, entry
, name_buf
);
1199 case exclusion_tag_contents
:
1200 exclusion_tag_warning (st
->orig_file_name
, tag_file_name
,
1201 _("contents not dumped"));
1202 name_size
= strlen (st
->orig_file_name
) + strlen (tag_file_name
) + 1;
1203 name_buf
= xmalloc (name_size
);
1204 strcpy (name_buf
, st
->orig_file_name
);
1205 strcat (name_buf
, tag_file_name
);
1206 dump_file (st
, tag_file_name
, name_buf
);
1210 case exclusion_tag_under
:
1211 exclusion_tag_warning (st
->orig_file_name
, tag_file_name
,
1212 _("contents not dumped"));
1218 /* Ensure exactly one trailing slash. */
1220 ensure_slash (char **pstr
)
1222 size_t len
= strlen (*pstr
);
1223 while (len
>= 1 && ISSLASH ((*pstr
)[len
- 1]))
1225 if (!ISSLASH ((*pstr
)[len
]))
1226 *pstr
= xrealloc (*pstr
, len
+ 2);
1227 (*pstr
)[len
++] = '/';
1228 (*pstr
)[len
] = '\0';
1231 /* If we just ran out of file descriptors, release a file descriptor
1232 in the directory chain somewhere leading from DIR->parent->parent
1233 up through the root. Return true if successful, false (preserving
1234 errno == EMFILE) otherwise.
1236 Do not release DIR's file descriptor, or DIR's parent, as other
1237 code assumes that they work. On some operating systems, another
1238 process can claim file descriptor resources as we release them, and
1239 some calls or their emulations require multiple file descriptors,
1240 so callers should not give up if a single release doesn't work. */
1243 open_failure_recover (struct tar_stat_info
const *dir
)
1245 if (errno
== EMFILE
&& dir
&& dir
->parent
)
1247 struct tar_stat_info
*p
;
1248 for (p
= dir
->parent
->parent
; p
; p
= p
->parent
)
1249 if (0 < p
->fd
&& (! p
->parent
|| p
->parent
->fd
<= 0))
1260 /* Return the directory entries of ST, in a dynamically allocated buffer,
1261 each entry followed by '\0' and the last followed by an extra '\0'.
1262 Return null on failure, setting errno. */
1264 get_directory_entries (struct tar_stat_info
*st
)
1267 while (! (dirstream
= fdopendir (st
->fd
)) && open_failure_recover (st
))
1274 char *entries
= streamsavedir (dirstream
);
1275 int streamsavedir_errno
= errno
;
1277 int fd
= dirfd (dirstream
);
1280 /* The dirent.h implementation doesn't use file descriptors
1281 for directory streams, so open the directory again. */
1282 char const *name
= st
->orig_file_name
;
1283 if (closedir (dirstream
) != 0)
1286 fd
= subfile_open (st
->parent
,
1287 st
->parent
? last_component (name
) : name
,
1288 open_searchdir_flags
);
1294 if (! (fstat (fd
, &dirst
) == 0
1295 && st
->stat
.st_ino
== dirst
.st_ino
1296 && st
->stat
.st_dev
== dirst
.st_dev
))
1299 fd
= - IMPOSTOR_ERRNO
;
1305 st
->dirstream
= dirstream
;
1306 errno
= streamsavedir_errno
;
1311 /* Dump the directory ST. Return true if successful, false (emitting
1312 diagnostics) otherwise. Get ST's entries, recurse through its
1313 subdirectories, and clean up file descriptors afterwards. */
1315 dump_dir (struct tar_stat_info
*st
)
1317 char *directory
= get_directory_entries (st
);
1320 savedir_diag (st
->orig_file_name
);
1324 dump_dir0 (st
, directory
);
1326 restore_parent_fd (st
);
1332 /* Number of links a file can have without having to be entered into
1333 the link table. Typically this is 1, but in trickier circumstances
1335 static nlink_t trivial_link_count
;
1338 /* Main functions of this module. */
1341 create_archive (void)
1343 struct name
const *p
;
1345 trivial_link_count
= name_count
<= 1 && ! dereference_option
;
1347 open_archive (ACCESS_WRITE
);
1348 buffer_write_global_xheader ();
1350 if (incremental_option
)
1352 size_t buffer_size
= 1000;
1353 char *buffer
= xmalloc (buffer_size
);
1356 collect_and_sort_names ();
1358 while ((p
= name_from_list ()) != NULL
)
1359 if (!excluded_name (p
->name
))
1360 dump_file (0, p
->name
, p
->name
);
1363 while ((p
= name_from_list ()) != NULL
)
1364 if (!excluded_name (p
->name
))
1366 struct tar_stat_info st
;
1367 size_t plen
= strlen (p
->name
);
1368 if (buffer_size
<= plen
)
1370 while ((buffer_size
*= 2) <= plen
)
1372 buffer
= xrealloc (buffer
, buffer_size
);
1374 memcpy (buffer
, p
->name
, plen
);
1375 if (! ISSLASH (buffer
[plen
- 1]))
1376 buffer
[plen
++] = DIRECTORY_SEPARATOR
;
1377 tar_stat_init (&st
);
1378 q
= directory_contents (gnu_list_name
->directory
);
1382 size_t qlen
= strlen (q
);
1385 if (! st
.orig_file_name
)
1387 int fd
= open (p
->name
, open_searchdir_flags
);
1390 open_diag (p
->name
);
1394 if (fstat (fd
, &st
.stat
) != 0)
1396 stat_diag (p
->name
);
1399 st
.orig_file_name
= xstrdup (p
->name
);
1401 if (buffer_size
< plen
+ qlen
)
1403 while ((buffer_size
*=2 ) < plen
+ qlen
)
1405 buffer
= xrealloc (buffer
, buffer_size
);
1407 strcpy (buffer
+ plen
, q
+ 1);
1408 dump_file (&st
, q
+ 1, buffer
);
1412 tar_stat_destroy (&st
);
1419 while ((name
= name_next (1)) != NULL
)
1420 if (!excluded_name (name
))
1421 dump_file (0, name
, name
);
1426 finish_deferred_unlinks ();
1427 if (listed_incremental_option
)
1428 write_directory_file ();
1432 /* Calculate the hash of a link. */
1434 hash_link (void const *entry
, size_t n_buckets
)
1436 struct link
const *l
= entry
;
1437 uintmax_t num
= l
->dev
^ l
->ino
;
1438 return num
% n_buckets
;
1441 /* Compare two links for equality. */
1443 compare_links (void const *entry1
, void const *entry2
)
1445 struct link
const *link1
= entry1
;
1446 struct link
const *link2
= entry2
;
1447 return ((link1
->dev
^ link2
->dev
) | (link1
->ino
^ link2
->ino
)) == 0;
1451 unknown_file_error (char const *p
)
1453 WARNOPT (WARN_FILE_IGNORED
,
1454 (0, 0, _("%s: Unknown file type; file ignored"),
1455 quotearg_colon (p
)));
1456 if (!ignore_failed_read_option
)
1457 set_exit_status (TAREXIT_FAILURE
);
1461 /* Handling of hard links */
1463 /* Table of all non-directories that we've written so far. Any time
1464 we see another, we check the table and avoid dumping the data
1465 again if we've done it once already. */
1466 static Hash_table
*link_table
;
1468 /* Try to dump stat as a hard link to another file in the archive.
1469 Return true if successful. */
1471 dump_hard_link (struct tar_stat_info
*st
)
1474 && (trivial_link_count
< st
->stat
.st_nlink
|| remove_files_option
))
1477 struct link
*duplicate
;
1478 off_t block_ordinal
;
1481 lp
.ino
= st
->stat
.st_ino
;
1482 lp
.dev
= st
->stat
.st_dev
;
1484 if ((duplicate
= hash_lookup (link_table
, &lp
)))
1486 /* We found a link. */
1487 char const *link_name
= safer_name_suffix (duplicate
->name
, true,
1488 absolute_names_option
);
1492 block_ordinal
= current_block_ordinal ();
1493 assign_string (&st
->link_name
, link_name
);
1494 if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
)
1495 < strlen (link_name
))
1496 write_long_link (st
);
1498 st
->stat
.st_size
= 0;
1499 blk
= start_header (st
);
1502 tar_copy_str (blk
->header
.linkname
, link_name
, NAME_FIELD_SIZE
);
1504 blk
->header
.typeflag
= LNKTYPE
;
1505 finish_header (st
, blk
, block_ordinal
);
1507 if (remove_files_option
)
1508 queue_deferred_unlink (st
->orig_file_name
, false);
1517 file_count_links (struct tar_stat_info
*st
)
1519 if (hard_dereference_option
)
1521 if (trivial_link_count
< st
->stat
.st_nlink
)
1523 struct link
*duplicate
;
1524 char *linkname
= NULL
;
1527 assign_string (&linkname
, st
->orig_file_name
);
1528 transform_name (&linkname
, XFORM_LINK
);
1530 lp
= xmalloc (offsetof (struct link
, name
)
1531 + strlen (linkname
) + 1);
1532 lp
->ino
= st
->stat
.st_ino
;
1533 lp
->dev
= st
->stat
.st_dev
;
1534 lp
->nlink
= st
->stat
.st_nlink
;
1535 strcpy (lp
->name
, linkname
);
1539 || (link_table
= hash_initialize (0, 0, hash_link
,
1541 && (duplicate
= hash_insert (link_table
, lp
))))
1544 if (duplicate
!= lp
)
1550 /* For each dumped file, check if all its links were dumped. Emit
1551 warnings if it is not so. */
1560 for (lp
= hash_get_first (link_table
); lp
;
1561 lp
= hash_get_next (link_table
, lp
))
1565 WARN ((0, 0, _("Missing links to %s."), quote (lp
->name
)));
1570 /* Assuming DIR is the working directory, open FILE, using FLAGS to
1571 control the open. A null DIR means to use ".". If we are low on
1572 file descriptors, try to release one or more from DIR's parents to
1575 subfile_open (struct tar_stat_info
const *dir
, char const *file
, int flags
)
1579 static bool initialized
;
1582 /* Initialize any tables that might be needed when file
1583 descriptors are exhausted, and whose initialization might
1584 require a file descriptor. This includes the system message
1585 catalog and tar's message catalog. */
1591 while ((fd
= openat (dir
? dir
->fd
: AT_FDCWD
, file
, flags
)) < 0
1592 && open_failure_recover (dir
))
1597 /* Restore the file descriptor for ST->parent, if it was temporarily
1598 closed to conserve file descriptors. On failure, set the file
1599 descriptor to the negative of the corresponding errno value. Call
1600 this every time a subdirectory is ascended from. */
1602 restore_parent_fd (struct tar_stat_info
const *st
)
1604 struct tar_stat_info
*parent
= st
->parent
;
1605 if (parent
&& ! parent
->fd
)
1607 int parentfd
= openat (st
->fd
, "..", open_searchdir_flags
);
1608 struct stat parentstat
;
1612 else if (! (fstat (parentfd
, &parentstat
) == 0
1613 && parent
->stat
.st_ino
== parentstat
.st_ino
1614 && parent
->stat
.st_dev
== parentstat
.st_dev
))
1617 parentfd
= IMPOSTOR_ERRNO
;
1622 int origfd
= open (parent
->orig_file_name
, open_searchdir_flags
);
1625 if (fstat (parentfd
, &parentstat
) == 0
1626 && parent
->stat
.st_ino
== parentstat
.st_ino
1627 && parent
->stat
.st_dev
== parentstat
.st_dev
)
1634 parent
->fd
= parentfd
;
1638 /* Dump a single file, recursing on directories. ST is the file's
1639 status info, NAME its name relative to the parent directory, and P
1640 its full name (which may be relative to the working directory). */
1642 /* FIXME: One should make sure that for *every* path leading to setting
1643 exit_status to failure, a clear diagnostic has been issued. */
1646 dump_file0 (struct tar_stat_info
*st
, char const *name
, char const *p
)
1648 union block
*header
;
1650 off_t original_size
;
1651 struct timespec original_ctime
;
1652 struct timespec restore_times
[2];
1653 off_t block_ordinal
= -1;
1656 struct tar_stat_info
const *parent
= st
->parent
;
1657 bool top_level
= ! parent
;
1658 int parentfd
= top_level
? AT_FDCWD
: parent
->fd
;
1659 void (*diag
) (char const *) = 0;
1661 if (interactive_option
&& !confirm ("add", p
))
1664 assign_string (&st
->orig_file_name
, p
);
1665 assign_string (&st
->file_name
,
1666 safer_name_suffix (p
, false, absolute_names_option
));
1668 transform_name (&st
->file_name
, XFORM_REGFILE
);
1670 if (parentfd
< 0 && ! top_level
)
1675 else if (fstatat (parentfd
, name
, &st
->stat
, fstatat_flags
) != 0)
1677 else if (file_dumpable_p (&st
->stat
))
1679 fd
= subfile_open (parent
, name
, open_read_flags
);
1685 if (fstat (fd
, &st
->stat
) != 0)
1691 file_removed_diag (p
, top_level
, diag
);
1695 st
->archive_file_size
= original_size
= st
->stat
.st_size
;
1696 st
->atime
= restore_times
[0] = get_stat_atime (&st
->stat
);
1697 st
->mtime
= restore_times
[1] = get_stat_mtime (&st
->stat
);
1698 st
->ctime
= original_ctime
= get_stat_ctime (&st
->stat
);
1701 if (S_ISHIDDEN (st
->stat
.st_mode
))
1703 char *new = (char *) alloca (strlen (p
) + 2);
1713 /* See if we want only new files, and check if this one is too old to
1716 This check is omitted if incremental_option is set *and* the
1717 requested file is not explicitely listed in the command line. */
1719 if (!(incremental_option
&& !is_individual_file (p
))
1720 && !S_ISDIR (st
->stat
.st_mode
)
1721 && OLDER_TAR_STAT_TIME (*st
, m
)
1722 && (!after_date_option
|| OLDER_TAR_STAT_TIME (*st
, c
)))
1724 if (!incremental_option
&& verbose_option
)
1725 WARNOPT (WARN_FILE_UNCHANGED
,
1726 (0, 0, _("%s: file is unchanged; not dumped"),
1727 quotearg_colon (p
)));
1731 /* See if we are trying to dump the archive. */
1732 if (sys_file_is_archive (st
))
1734 WARNOPT (WARN_IGNORE_ARCHIVE
,
1735 (0, 0, _("%s: file is the archive; not dumped"),
1736 quotearg_colon (p
)));
1740 is_dir
= S_ISDIR (st
->stat
.st_mode
) != 0;
1742 if (!is_dir
&& dump_hard_link (st
))
1745 if (is_dir
|| S_ISREG (st
->stat
.st_mode
) || S_ISCTG (st
->stat
.st_mode
))
1748 struct stat final_stat
;
1752 const char *tag_file_name
;
1753 ensure_slash (&st
->orig_file_name
);
1754 ensure_slash (&st
->file_name
);
1756 if (check_exclusion_tags (st
, &tag_file_name
) == exclusion_tag_all
)
1758 exclusion_tag_warning (st
->orig_file_name
, tag_file_name
,
1759 _("directory not dumped"));
1766 parentfd
= top_level
? AT_FDCWD
: parent
->fd
;
1770 enum dump_status status
;
1772 if (fd
&& sparse_option
&& ST_IS_SPARSE (st
->stat
))
1774 status
= sparse_dump_file (fd
, st
);
1775 if (status
== dump_status_not_implemented
)
1776 status
= dump_regular_file (fd
, st
);
1779 status
= dump_regular_file (fd
, st
);
1783 case dump_status_ok
:
1784 case dump_status_short
:
1785 file_count_links (st
);
1788 case dump_status_fail
:
1791 case dump_status_not_implemented
:
1795 ok
= status
== dump_status_ok
;
1807 if (parentfd
< 0 && ! top_level
)
1813 ok
= fstatat (parentfd
, name
, &final_stat
, fstatat_flags
) == 0;
1816 ok
= fstat (fd
, &final_stat
) == 0;
1819 file_removed_diag (p
, top_level
, stat_diag
);
1824 if ((timespec_cmp (get_stat_ctime (&final_stat
), original_ctime
) != 0
1825 /* Original ctime will change if the file is a directory and
1826 --remove-files is given */
1827 && !(remove_files_option
&& is_dir
))
1828 || original_size
< final_stat
.st_size
)
1830 WARNOPT (WARN_FILE_CHANGED
,
1831 (0, 0, _("%s: file changed as we read it"),
1832 quotearg_colon (p
)));
1833 set_exit_status (TAREXIT_DIFFERS
);
1835 else if (atime_preserve_option
== replace_atime_preserve
1836 && set_file_atime (fd
, p
, restore_times
) != 0)
1840 ok
&= tar_stat_close (st
);
1841 if (ok
&& remove_files_option
)
1842 queue_deferred_unlink (p
, is_dir
);
1846 #ifdef HAVE_READLINK
1847 else if (S_ISLNK (st
->stat
.st_mode
))
1851 size_t linklen
= st
->stat
.st_size
;
1852 if (linklen
!= st
->stat
.st_size
|| linklen
+ 1 == 0)
1854 buffer
= (char *) alloca (linklen
+ 1);
1855 size
= readlinkat (parentfd
, name
, buffer
, linklen
+ 1);
1858 file_removed_diag (p
, top_level
, readlink_diag
);
1861 buffer
[size
] = '\0';
1862 assign_string (&st
->link_name
, buffer
);
1863 transform_name (&st
->link_name
, XFORM_SYMLINK
);
1864 if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
) < size
)
1865 write_long_link (st
);
1867 block_ordinal
= current_block_ordinal ();
1868 st
->stat
.st_size
= 0; /* force 0 size on symlink */
1869 header
= start_header (st
);
1872 tar_copy_str (header
->header
.linkname
, st
->link_name
, NAME_FIELD_SIZE
);
1873 header
->header
.typeflag
= SYMTYPE
;
1874 finish_header (st
, header
, block_ordinal
);
1875 /* nothing more to do to it */
1877 if (remove_files_option
)
1878 queue_deferred_unlink (p
, false);
1880 file_count_links (st
);
1884 else if (S_ISCHR (st
->stat
.st_mode
))
1886 else if (S_ISBLK (st
->stat
.st_mode
))
1888 else if (S_ISFIFO (st
->stat
.st_mode
))
1890 else if (S_ISSOCK (st
->stat
.st_mode
))
1892 WARNOPT (WARN_FILE_IGNORED
,
1893 (0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1896 else if (S_ISDOOR (st
->stat
.st_mode
))
1898 WARNOPT (WARN_FILE_IGNORED
,
1899 (0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1904 unknown_file_error (p
);
1908 if (archive_format
== V7_FORMAT
)
1910 unknown_file_error (p
);
1914 block_ordinal
= current_block_ordinal ();
1915 st
->stat
.st_size
= 0; /* force 0 size */
1916 header
= start_header (st
);
1919 header
->header
.typeflag
= type
;
1921 if (type
!= FIFOTYPE
)
1923 MAJOR_TO_CHARS (major (st
->stat
.st_rdev
),
1924 header
->header
.devmajor
);
1925 MINOR_TO_CHARS (minor (st
->stat
.st_rdev
),
1926 header
->header
.devminor
);
1929 finish_header (st
, header
, block_ordinal
);
1930 if (remove_files_option
)
1931 queue_deferred_unlink (p
, false);
1934 /* Dump a file, recursively. PARENT describes the file's parent
1935 directory, NAME is the file's name relative to PARENT, and FULLNAME
1936 its full name, possibly relative to the working directory. NAME
1937 may contain slashes at the top level of invocation. */
1940 dump_file (struct tar_stat_info
*parent
, char const *name
,
1941 char const *fullname
)
1943 struct tar_stat_info st
;
1944 tar_stat_init (&st
);
1946 dump_file0 (&st
, name
, fullname
);
1947 if (parent
&& listed_incremental_option
)
1948 update_parent_directory (parent
);
1949 tar_stat_destroy (&st
);