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, 2012
5 Free Software Foundation, Inc.
7 Written by John Gilmore, on 1985-08-25.
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 3, or (at your option) any later
14 This program is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
17 Public License for more details.
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
30 /* Error number to use when an impostor is discovered.
31 Pretend the impostor isn't there. */
32 enum { IMPOSTOR_ERRNO
= ENOENT
};
46 enum exclusion_tag_type type
;
47 bool (*predicate
) (int fd
);
48 struct exclusion_tag
*next
;
51 static struct exclusion_tag
*exclusion_tags
;
54 add_exclusion_tag (const char *name
, enum exclusion_tag_type type
,
55 bool (*predicate
) (int fd
))
57 struct exclusion_tag
*tag
= xmalloc (sizeof tag
[0]);
58 tag
->next
= exclusion_tags
;
61 tag
->predicate
= predicate
;
62 tag
->length
= strlen (name
);
67 exclusion_tag_warning (const char *dirname
, const char *tagname
,
71 WARNOPT (WARN_CACHEDIR
,
73 _("%s: contains a cache directory tag %s; %s"),
74 quotearg_colon (dirname
),
75 quotearg_n (1, tagname
),
79 enum exclusion_tag_type
80 check_exclusion_tags (struct tar_stat_info
const *st
, char const **tag_file_name
)
82 struct exclusion_tag
*tag
;
84 for (tag
= exclusion_tags
; tag
; tag
= tag
->next
)
86 int tagfd
= subfile_open (st
, tag
->name
, open_read_flags
);
89 bool satisfied
= !tag
->predicate
|| tag
->predicate (tagfd
);
94 *tag_file_name
= tag
->name
;
100 return exclusion_tag_none
;
103 /* Exclusion predicate to test if the named file (usually "CACHEDIR.TAG")
104 contains a valid header, as described at:
105 http://www.brynosaurus.com/cachedir
106 Applications can write this file into directories they create
107 for use as caches containing purely regenerable, non-precious data,
108 allowing us to avoid archiving them if --exclude-caches is specified. */
110 #define CACHEDIR_SIGNATURE "Signature: 8a477f597d28d172789f06886806bc55"
111 #define CACHEDIR_SIGNATURE_SIZE (sizeof CACHEDIR_SIGNATURE - 1)
114 cachedir_file_p (int fd
)
116 char tagbuf
[CACHEDIR_SIGNATURE_SIZE
];
119 (read (fd
, tagbuf
, CACHEDIR_SIGNATURE_SIZE
) == CACHEDIR_SIGNATURE_SIZE
120 && memcmp (tagbuf
, CACHEDIR_SIGNATURE
, CACHEDIR_SIGNATURE_SIZE
) == 0);
124 /* The maximum uintmax_t value that can be represented with DIGITS digits,
125 assuming that each digit is BITS_PER_DIGIT wide. */
126 #define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
127 ((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
128 ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
131 /* The maximum uintmax_t value that can be represented with octal
132 digits and a trailing NUL in BUFFER. */
133 #define MAX_OCTAL_VAL(buffer) MAX_VAL_WITH_DIGITS (sizeof (buffer) - 1, LG_8)
135 /* Convert VALUE to an octal representation suitable for tar headers.
136 Output to buffer WHERE with size SIZE.
137 The result is undefined if SIZE is 0 or if VALUE is too large to fit. */
140 to_octal (uintmax_t value
, char *where
, size_t size
)
147 where
[--i
] = '0' + (v
& ((1 << LG_8
) - 1));
153 /* Copy at most LEN bytes from the string SRC to DST. Terminate with
154 NUL unless SRC is LEN or more bytes long. */
157 tar_copy_str (char *dst
, const char *src
, size_t len
)
160 for (i
= 0; i
< len
; i
++)
161 if (! (dst
[i
] = src
[i
]))
165 /* Same as tar_copy_str, but always terminate with NUL if using
169 tar_name_copy_str (char *dst
, const char *src
, size_t len
)
171 tar_copy_str (dst
, src
, len
);
172 if (archive_format
== OLDGNU_FORMAT
)
176 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
177 tar headers. NEGATIVE is 1 if VALUE was negative before being cast
178 to uintmax_t, 0 otherwise. Output to buffer WHERE with size SIZE.
179 The result is undefined if SIZE is 0 or if VALUE is too large to
183 to_base256 (int negative
, uintmax_t value
, char *where
, size_t size
)
186 uintmax_t propagated_sign_bits
=
187 ((uintmax_t) - negative
<< (CHAR_BIT
* sizeof v
- LG_256
));
192 where
[--i
] = v
& ((1 << LG_256
) - 1);
193 v
= propagated_sign_bits
| (v
>> LG_256
);
198 #define GID_TO_CHARS(val, where) gid_to_chars (val, where, sizeof (where))
199 #define MAJOR_TO_CHARS(val, where) major_to_chars (val, where, sizeof (where))
200 #define MINOR_TO_CHARS(val, where) minor_to_chars (val, where, sizeof (where))
201 #define MODE_TO_CHARS(val, where) mode_to_chars (val, where, sizeof (where))
202 #define UID_TO_CHARS(val, where) uid_to_chars (val, where, sizeof (where))
204 #define UNAME_TO_CHARS(name,buf) string_to_chars (name, buf, sizeof(buf))
205 #define GNAME_TO_CHARS(name,buf) string_to_chars (name, buf, sizeof(buf))
208 to_chars (int negative
, uintmax_t value
, size_t valsize
,
209 uintmax_t (*substitute
) (int *),
210 char *where
, size_t size
, const char *type
);
213 to_chars_subst (int negative
, int gnu_format
, uintmax_t value
, size_t valsize
,
214 uintmax_t (*substitute
) (int *),
215 char *where
, size_t size
, const char *type
)
217 uintmax_t maxval
= (gnu_format
218 ? MAX_VAL_WITH_DIGITS (size
- 1, LG_256
)
219 : MAX_VAL_WITH_DIGITS (size
- 1, LG_8
));
220 char valbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
221 char maxbuf
[UINTMAX_STRSIZE_BOUND
];
222 char minbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
223 char const *minval_string
;
224 char const *maxval_string
= STRINGIFY_BIGINT (maxval
, maxbuf
);
225 char const *value_string
;
229 uintmax_t m
= maxval
+ 1 ? maxval
+ 1 : maxval
/ 2 + 1;
230 char *p
= STRINGIFY_BIGINT (m
, minbuf
+ 1);
239 char *p
= STRINGIFY_BIGINT (- value
, valbuf
+ 1);
244 value_string
= STRINGIFY_BIGINT (value
, valbuf
);
249 uintmax_t sub
= substitute (&negsub
) & maxval
;
250 /* NOTE: This is one of the few places where GNU_FORMAT differs from
251 OLDGNU_FORMAT. The actual differences are:
253 1. In OLDGNU_FORMAT all strings in a tar header end in \0
254 2. Incremental archives use oldgnu_header.
256 Apart from this they are completely identical. */
257 uintmax_t s
= (negsub
&= archive_format
== GNU_FORMAT
) ? - sub
: sub
;
258 char subbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
259 char *sub_string
= STRINGIFY_BIGINT (s
, subbuf
+ 1);
262 WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
263 value_string
, type
, minval_string
, maxval_string
,
265 return to_chars (negsub
, s
, valsize
, 0, where
, size
, type
);
268 ERROR ((0, 0, _("value %s out of %s range %s..%s"),
269 value_string
, type
, minval_string
, maxval_string
));
273 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
274 external form, using SUBSTITUTE (...) if VALUE won't fit. Output
275 to buffer WHERE with size SIZE. NEGATIVE is 1 iff VALUE was
276 negative before being cast to uintmax_t; its original bitpattern
277 can be deduced from VALSIZE, its original size before casting.
278 TYPE is the kind of value being output (useful for diagnostics).
279 Prefer the POSIX format of SIZE - 1 octal digits (with leading zero
280 digits), followed by '\0'. If this won't work, and if GNU or
281 OLDGNU format is allowed, use '\200' followed by base-256, or (if
282 NEGATIVE is nonzero) '\377' followed by two's complement base-256.
283 If neither format works, use SUBSTITUTE (...) instead. Pass to
284 SUBSTITUTE the address of an 0-or-1 flag recording whether the
285 substitute value is negative. */
288 to_chars (int negative
, uintmax_t value
, size_t valsize
,
289 uintmax_t (*substitute
) (int *),
290 char *where
, size_t size
, const char *type
)
292 int gnu_format
= (archive_format
== GNU_FORMAT
293 || archive_format
== OLDGNU_FORMAT
);
295 /* Generate the POSIX octal representation if the number fits. */
296 if (! negative
&& value
<= MAX_VAL_WITH_DIGITS (size
- 1, LG_8
))
298 where
[size
- 1] = '\0';
299 to_octal (value
, where
, size
- 1);
304 /* Try to cope with the number by using traditional GNU format
307 /* Generate the base-256 representation if the number fits. */
308 if (((negative
? -1 - value
: value
)
309 <= MAX_VAL_WITH_DIGITS (size
- 1, LG_256
)))
311 where
[0] = negative
? -1 : 1 << (LG_256
- 1);
312 to_base256 (negative
, value
, where
+ 1, size
- 1);
316 /* Otherwise, if the number is negative, and if it would not cause
317 ambiguity on this host by confusing positive with negative
318 values, then generate the POSIX octal representation of the value
319 modulo 2**(field bits). The resulting tar file is
320 machine-dependent, since it depends on the host word size. Yuck!
321 But this is the traditional behavior. */
322 else if (negative
&& valsize
* CHAR_BIT
<= (size
- 1) * LG_8
)
324 static int warned_once
;
328 WARN ((0, 0, _("Generating negative octal headers")));
330 where
[size
- 1] = '\0';
331 to_octal (value
& MAX_VAL_WITH_DIGITS (valsize
* CHAR_BIT
, 1),
335 /* Otherwise fall back to substitution, if possible: */
338 substitute
= NULL
; /* No substitution for formats, other than GNU */
340 return to_chars_subst (negative
, gnu_format
, value
, valsize
, substitute
,
345 gid_substitute (int *negative
)
351 static gid_t gid_nobody
;
352 if (!gid_nobody
&& !gname_to_gid ("nobody", &gid_nobody
))
361 gid_to_chars (gid_t v
, char *p
, size_t s
)
363 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, gid_substitute
, p
, s
, "gid_t");
367 major_to_chars (major_t v
, char *p
, size_t s
)
369 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "major_t");
373 minor_to_chars (minor_t v
, char *p
, size_t s
)
375 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "minor_t");
379 mode_to_chars (mode_t v
, char *p
, size_t s
)
381 /* In the common case where the internal and external mode bits are the same,
382 and we are not using POSIX or GNU format,
383 propagate all unknown bits to the external mode.
384 This matches historical practice.
385 Otherwise, just copy the bits we know about. */
388 if (S_ISUID
== TSUID
&& S_ISGID
== TSGID
&& S_ISVTX
== TSVTX
389 && S_IRUSR
== TUREAD
&& S_IWUSR
== TUWRITE
&& S_IXUSR
== TUEXEC
390 && S_IRGRP
== TGREAD
&& S_IWGRP
== TGWRITE
&& S_IXGRP
== TGEXEC
391 && S_IROTH
== TOREAD
&& S_IWOTH
== TOWRITE
&& S_IXOTH
== TOEXEC
392 && archive_format
!= POSIX_FORMAT
393 && archive_format
!= USTAR_FORMAT
394 && archive_format
!= GNU_FORMAT
)
402 u
= ((v
& S_ISUID
? TSUID
: 0)
403 | (v
& S_ISGID
? TSGID
: 0)
404 | (v
& S_ISVTX
? TSVTX
: 0)
405 | (v
& S_IRUSR
? TUREAD
: 0)
406 | (v
& S_IWUSR
? TUWRITE
: 0)
407 | (v
& S_IXUSR
? TUEXEC
: 0)
408 | (v
& S_IRGRP
? TGREAD
: 0)
409 | (v
& S_IWGRP
? TGWRITE
: 0)
410 | (v
& S_IXGRP
? TGEXEC
: 0)
411 | (v
& S_IROTH
? TOREAD
: 0)
412 | (v
& S_IWOTH
? TOWRITE
: 0)
413 | (v
& S_IXOTH
? TOEXEC
: 0));
415 return to_chars (negative
, u
, sizeof v
, 0, p
, s
, "mode_t");
419 off_to_chars (off_t v
, char *p
, size_t s
)
421 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "off_t");
425 time_to_chars (time_t v
, char *p
, size_t s
)
427 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "time_t");
431 uid_substitute (int *negative
)
437 static uid_t uid_nobody
;
438 if (!uid_nobody
&& !uname_to_uid ("nobody", &uid_nobody
))
447 uid_to_chars (uid_t v
, char *p
, size_t s
)
449 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, uid_substitute
, p
, s
, "uid_t");
453 uintmax_to_chars (uintmax_t v
, char *p
, size_t s
)
455 return to_chars (0, v
, sizeof v
, 0, p
, s
, "uintmax_t");
459 string_to_chars (char const *str
, char *p
, size_t s
)
461 tar_copy_str (p
, str
, s
);
466 /* A directory is always considered dumpable.
467 Otherwise, only regular and contiguous files are considered dumpable.
468 Such a file is dumpable if it is sparse and both --sparse and --totals
470 Otherwise, it is dumpable unless any of the following conditions occur:
472 a) it is empty *and* world-readable, or
473 b) current archive is /dev/null */
476 file_dumpable_p (struct stat
const *st
)
478 if (S_ISDIR (st
->st_mode
))
480 if (! (S_ISREG (st
->st_mode
) || S_ISCTG (st
->st_mode
)))
483 return totals_option
&& sparse_option
&& ST_IS_SPARSE (*st
);
484 return ! (st
->st_size
== 0 && (st
->st_mode
& MODE_R
) == MODE_R
);
488 /* Writing routines. */
490 /* Write the EOT block(s). Zero at least two blocks, through the end
491 of the record. Old tar, as previous versions of GNU tar, writes
492 garbage after two zeroed blocks. */
496 union block
*pointer
= find_next_block ();
497 memset (pointer
->buffer
, 0, BLOCKSIZE
);
498 set_next_block_after (pointer
);
499 pointer
= find_next_block ();
500 memset (pointer
->buffer
, 0, available_space_after (pointer
));
501 set_next_block_after (pointer
);
504 /* Write a "private" header */
506 start_private_header (const char *name
, size_t size
, time_t t
)
508 union block
*header
= find_next_block ();
510 memset (header
->buffer
, 0, sizeof (union block
));
512 tar_name_copy_str (header
->header
.name
, name
, NAME_FIELD_SIZE
);
513 OFF_TO_CHARS (size
, header
->header
.size
);
515 TIME_TO_CHARS (t
, header
->header
.mtime
);
516 MODE_TO_CHARS (S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
, header
->header
.mode
);
517 UID_TO_CHARS (getuid (), header
->header
.uid
);
518 GID_TO_CHARS (getgid (), header
->header
.gid
);
519 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
520 MINOR_TO_CHARS (0, header
->header
.devminor
);
521 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
522 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
526 /* Create a new header and store there at most NAME_FIELD_SIZE bytes of
530 write_short_name (struct tar_stat_info
*st
)
532 union block
*header
= find_next_block ();
533 memset (header
->buffer
, 0, sizeof (union block
));
534 tar_name_copy_str (header
->header
.name
, st
->file_name
, NAME_FIELD_SIZE
);
538 #define FILL(field,byte) do { \
539 memset(field, byte, sizeof(field)-1); \
540 (field)[sizeof(field)-1] = 0; \
543 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. */
545 write_gnu_long_link (struct tar_stat_info
*st
, const char *p
, char type
)
547 size_t size
= strlen (p
) + 1;
552 header
= start_private_header ("././@LongLink", size
, time (NULL
));
553 FILL (header
->header
.mtime
, '0');
554 FILL (header
->header
.mode
, '0');
555 FILL (header
->header
.uid
, '0');
556 FILL (header
->header
.gid
, '0');
557 FILL (header
->header
.devmajor
, 0);
558 FILL (header
->header
.devminor
, 0);
559 uid_to_uname (0, &tmpname
);
560 UNAME_TO_CHARS (tmpname
, header
->header
.uname
);
562 gid_to_gname (0, &tmpname
);
563 GNAME_TO_CHARS (tmpname
, header
->header
.gname
);
566 strcpy (header
->buffer
+ offsetof (struct posix_header
, magic
),
568 header
->header
.typeflag
= type
;
569 finish_header (st
, header
, -1);
571 header
= find_next_block ();
573 bufsize
= available_space_after (header
);
575 while (bufsize
< size
)
577 memcpy (header
->buffer
, p
, bufsize
);
580 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
581 header
= find_next_block ();
582 bufsize
= available_space_after (header
);
584 memcpy (header
->buffer
, p
, size
);
585 memset (header
->buffer
+ size
, 0, bufsize
- size
);
586 set_next_block_after (header
+ (size
- 1) / BLOCKSIZE
);
590 split_long_name (const char *name
, size_t length
)
594 if (length
> PREFIX_FIELD_SIZE
+ 1)
595 length
= PREFIX_FIELD_SIZE
+ 1;
596 else if (ISSLASH (name
[length
- 1]))
598 for (i
= length
- 1; i
> 0; i
--)
599 if (ISSLASH (name
[i
]))
605 write_ustar_long_name (const char *name
)
607 size_t length
= strlen (name
);
611 if (length
> PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1)
613 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
614 quotearg_colon (name
),
615 PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1));
619 i
= split_long_name (name
, length
);
620 if (i
== 0 || (nlen
= length
- i
- 1) > NAME_FIELD_SIZE
|| nlen
== 0)
623 _("%s: file name is too long (cannot be split); not dumped"),
624 quotearg_colon (name
)));
628 header
= find_next_block ();
629 memset (header
->buffer
, 0, sizeof (header
->buffer
));
630 memcpy (header
->header
.prefix
, name
, i
);
631 memcpy (header
->header
.name
, name
+ i
+ 1, length
- i
- 1);
636 /* Write a long link name, depending on the current archive format */
638 write_long_link (struct tar_stat_info
*st
)
640 switch (archive_format
)
643 xheader_store ("linkpath", st
, NULL
);
646 case V7_FORMAT
: /* old V7 tar format */
650 _("%s: link name is too long; not dumped"),
651 quotearg_colon (st
->link_name
)));
656 write_gnu_long_link (st
, st
->link_name
, GNUTYPE_LONGLINK
);
665 write_long_name (struct tar_stat_info
*st
)
667 switch (archive_format
)
670 xheader_store ("path", st
, NULL
);
674 if (strlen (st
->file_name
) > NAME_FIELD_SIZE
-1)
676 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
677 quotearg_colon (st
->file_name
),
678 NAME_FIELD_SIZE
- 1));
685 return write_ustar_long_name (st
->file_name
);
689 write_gnu_long_link (st
, st
->file_name
, GNUTYPE_LONGNAME
);
695 return write_short_name (st
);
699 write_extended (bool global
, struct tar_stat_info
*st
, union block
*old_header
)
701 union block
*header
, hp
;
706 if (st
->xhdr
.buffer
|| st
->xhdr
.stk
== NULL
)
709 xheader_finish (&st
->xhdr
);
710 memcpy (hp
.buffer
, old_header
, sizeof (hp
));
714 p
= xheader_ghdr_name ();
720 p
= xheader_xhdr_name (st
);
721 t
= st
->stat
.st_mtime
;
723 xheader_write (type
, p
, t
, &st
->xhdr
);
725 header
= find_next_block ();
726 memcpy (header
, &hp
.buffer
, sizeof (hp
.buffer
));
731 write_header_name (struct tar_stat_info
*st
)
733 if (archive_format
== POSIX_FORMAT
&& !string_ascii_p (st
->file_name
))
735 xheader_store ("path", st
, NULL
);
736 return write_short_name (st
);
738 else if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
)
739 < strlen (st
->file_name
))
740 return write_long_name (st
);
742 return write_short_name (st
);
746 /* Header handling. */
748 /* Make a header block for the file whose stat info is st,
749 and return its address. */
752 start_header (struct tar_stat_info
*st
)
756 header
= write_header_name (st
);
760 /* Override some stat fields, if requested to do so. */
762 if (owner_option
!= (uid_t
) -1)
763 st
->stat
.st_uid
= owner_option
;
764 if (group_option
!= (gid_t
) -1)
765 st
->stat
.st_gid
= group_option
;
768 ((st
->stat
.st_mode
& ~MODE_ALL
)
769 | mode_adjust (st
->stat
.st_mode
, S_ISDIR (st
->stat
.st_mode
) != 0,
770 initial_umask
, mode_option
, NULL
));
772 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
773 for a few tars and came up with the following interoperability
777 1 2 3 4 5 6 7 8 9 READER
778 . . . . . . . . . 1 = SunOS 4.2 tar
779 # . . # # . . # # 2 = NEC SVR4.0.2 tar
780 . . . # # . . # . 3 = Solaris 2.1 tar
781 . . . . . . . . . 4 = GNU tar 1.11.1
782 . . . . . . . . . 5 = HP-UX 8.07 tar
783 . . . . . . . . . 6 = Ultrix 4.1
784 . . . . . . . . . 7 = AIX 3.2
785 . . . . . . . . . 8 = Hitachi HI-UX 1.03
786 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
789 # = "impossible file type"
791 The following mask for old archive removes the '#'s in column 4
792 above, thus making GNU tar both a universal donor and a universal
793 acceptor for Paul's test. */
795 if (archive_format
== V7_FORMAT
|| archive_format
== USTAR_FORMAT
)
796 MODE_TO_CHARS (st
->stat
.st_mode
& MODE_ALL
, header
->header
.mode
);
798 MODE_TO_CHARS (st
->stat
.st_mode
, header
->header
.mode
);
801 uid_t uid
= st
->stat
.st_uid
;
802 if (archive_format
== POSIX_FORMAT
803 && MAX_OCTAL_VAL (header
->header
.uid
) < uid
)
805 xheader_store ("uid", st
, NULL
);
808 if (!UID_TO_CHARS (uid
, header
->header
.uid
))
813 gid_t gid
= st
->stat
.st_gid
;
814 if (archive_format
== POSIX_FORMAT
815 && MAX_OCTAL_VAL (header
->header
.gid
) < gid
)
817 xheader_store ("gid", st
, NULL
);
820 if (!GID_TO_CHARS (gid
, header
->header
.gid
))
825 off_t size
= st
->stat
.st_size
;
826 if (archive_format
== POSIX_FORMAT
827 && MAX_OCTAL_VAL (header
->header
.size
) < size
)
829 xheader_store ("size", st
, NULL
);
832 if (!OFF_TO_CHARS (size
, header
->header
.size
))
837 struct timespec mtime
= set_mtime_option
? mtime_option
: st
->mtime
;
838 if (archive_format
== POSIX_FORMAT
)
840 if (MAX_OCTAL_VAL (header
->header
.mtime
) < mtime
.tv_sec
841 || mtime
.tv_nsec
!= 0)
842 xheader_store ("mtime", st
, &mtime
);
843 if (MAX_OCTAL_VAL (header
->header
.mtime
) < mtime
.tv_sec
)
846 if (!TIME_TO_CHARS (mtime
.tv_sec
, header
->header
.mtime
))
851 if (S_ISCHR (st
->stat
.st_mode
)
852 || S_ISBLK (st
->stat
.st_mode
))
854 major_t devmajor
= major (st
->stat
.st_rdev
);
855 minor_t devminor
= minor (st
->stat
.st_rdev
);
857 if (archive_format
== POSIX_FORMAT
858 && MAX_OCTAL_VAL (header
->header
.devmajor
) < devmajor
)
860 xheader_store ("devmajor", st
, NULL
);
863 if (!MAJOR_TO_CHARS (devmajor
, header
->header
.devmajor
))
866 if (archive_format
== POSIX_FORMAT
867 && MAX_OCTAL_VAL (header
->header
.devminor
) < devminor
)
869 xheader_store ("devminor", st
, NULL
);
872 if (!MINOR_TO_CHARS (devminor
, header
->header
.devminor
))
875 else if (archive_format
!= GNU_FORMAT
&& archive_format
!= OLDGNU_FORMAT
)
877 if (!(MAJOR_TO_CHARS (0, header
->header
.devmajor
)
878 && MINOR_TO_CHARS (0, header
->header
.devminor
)))
882 if (archive_format
== POSIX_FORMAT
)
884 xheader_store ("atime", st
, NULL
);
885 xheader_store ("ctime", st
, NULL
);
887 else if (incremental_option
)
888 if (archive_format
== OLDGNU_FORMAT
|| archive_format
== GNU_FORMAT
)
890 TIME_TO_CHARS (st
->atime
.tv_sec
, header
->oldgnu_header
.atime
);
891 TIME_TO_CHARS (st
->ctime
.tv_sec
, header
->oldgnu_header
.ctime
);
894 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
896 switch (archive_format
)
902 case GNU_FORMAT
: /*FIXME?*/
903 /* Overwrite header->header.magic and header.version in one blow. */
904 strcpy (header
->buffer
+ offsetof (struct posix_header
, magic
),
910 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
911 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
918 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
920 /* header->header.[ug]name are left as the empty string. */
924 if (owner_name_option
)
925 st
->uname
= xstrdup (owner_name_option
);
927 uid_to_uname (st
->stat
.st_uid
, &st
->uname
);
929 if (group_name_option
)
930 st
->gname
= xstrdup (group_name_option
);
932 gid_to_gname (st
->stat
.st_gid
, &st
->gname
);
934 if (archive_format
== POSIX_FORMAT
935 && (strlen (st
->uname
) > UNAME_FIELD_SIZE
936 || !string_ascii_p (st
->uname
)))
937 xheader_store ("uname", st
, NULL
);
938 UNAME_TO_CHARS (st
->uname
, header
->header
.uname
);
940 if (archive_format
== POSIX_FORMAT
941 && (strlen (st
->gname
) > GNAME_FIELD_SIZE
942 || !string_ascii_p (st
->gname
)))
943 xheader_store ("gname", st
, NULL
);
944 GNAME_TO_CHARS (st
->gname
, header
->header
.gname
);
947 if (archive_format
== POSIX_FORMAT
)
952 xheader_store ("SCHILY.acl.access", st
, NULL
);
954 xheader_store ("SCHILY.acl.default", st
, NULL
);
956 if ((selinux_context_option
> 0) && st
->cntx_name
)
957 xheader_store ("RHT.security.selinux", st
, NULL
);
958 if (xattrs_option
> 0)
960 size_t scan_xattr
= 0;
961 struct xattr_array
*xattr_map
= st
->xattr_map
;
963 while (scan_xattr
< st
->xattr_map_size
)
965 xheader_store (xattr_map
[scan_xattr
].xkey
, st
, &scan_xattr
);
975 simple_finish_header (union block
*header
)
981 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
985 for (i
= sizeof *header
; i
-- != 0; )
986 /* We can't use unsigned char here because of old compilers, e.g. V7. */
989 /* Fill in the checksum field. It's formatted differently from the
990 other fields: it has [6] digits, a null, then a space -- rather than
991 digits, then a null. We use to_chars.
992 The final space is already there, from
993 checksumming, and to_chars doesn't modify it.
995 This is a fast way to do:
997 sprintf(header->header.chksum, "%6o", sum); */
999 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
1001 set_next_block_after (header
);
1004 /* Finish off a filled-in header block and write it out. We also
1005 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
1006 is not negative, is the block ordinal of the first record for this
1007 file, which may be a preceding long name or long link record. */
1009 finish_header (struct tar_stat_info
*st
,
1010 union block
*header
, off_t block_ordinal
)
1012 /* Note: It is important to do this before the call to write_extended(),
1013 so that the actual ustar header is printed */
1015 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
1016 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
1017 && header
->header
.typeflag
!= XHDTYPE
1018 && header
->header
.typeflag
!= XGLTYPE
)
1020 /* FIXME: This global is used in print_header, sigh. */
1021 current_format
= archive_format
;
1022 print_header (st
, header
, block_ordinal
);
1025 header
= write_extended (false, st
, header
);
1026 simple_finish_header (header
);
1031 pad_archive (off_t size_left
)
1034 while (size_left
> 0)
1036 blk
= find_next_block ();
1037 memset (blk
->buffer
, 0, BLOCKSIZE
);
1038 set_next_block_after (blk
);
1039 size_left
-= BLOCKSIZE
;
1043 static enum dump_status
1044 dump_regular_file (int fd
, struct tar_stat_info
*st
)
1046 off_t size_left
= st
->stat
.st_size
;
1047 off_t block_ordinal
;
1050 block_ordinal
= current_block_ordinal ();
1051 blk
= start_header (st
);
1053 return dump_status_fail
;
1055 /* Mark contiguous files, if we support them. */
1056 if (archive_format
!= V7_FORMAT
&& S_ISCTG (st
->stat
.st_mode
))
1057 blk
->header
.typeflag
= CONTTYPE
;
1059 finish_header (st
, blk
, block_ordinal
);
1061 mv_begin_write (st
->file_name
, st
->stat
.st_size
, st
->stat
.st_size
);
1062 while (size_left
> 0)
1064 size_t bufsize
, count
;
1066 blk
= find_next_block ();
1068 bufsize
= available_space_after (blk
);
1070 if (size_left
< bufsize
)
1072 /* Last read -- zero out area beyond. */
1073 bufsize
= size_left
;
1074 count
= bufsize
% BLOCKSIZE
;
1076 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
1079 count
= (fd
<= 0) ? bufsize
: blocking_read (fd
, blk
->buffer
, bufsize
);
1080 if (count
== SAFE_READ_ERROR
)
1082 read_diag_details (st
->orig_file_name
,
1083 st
->stat
.st_size
- size_left
, bufsize
);
1084 pad_archive (size_left
);
1085 return dump_status_short
;
1088 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
1090 if (count
!= bufsize
)
1092 char buf
[UINTMAX_STRSIZE_BOUND
];
1093 memset (blk
->buffer
+ count
, 0, bufsize
- count
);
1094 WARNOPT (WARN_FILE_SHRANK
,
1096 ngettext ("%s: File shrank by %s byte; padding with zeros",
1097 "%s: File shrank by %s bytes; padding with zeros",
1099 quotearg_colon (st
->orig_file_name
),
1100 STRINGIFY_BIGINT (size_left
, buf
)));
1101 if (! ignore_failed_read_option
)
1102 set_exit_status (TAREXIT_DIFFERS
);
1103 pad_archive (size_left
- (bufsize
- count
));
1104 return dump_status_short
;
1107 return dump_status_ok
;
1111 /* Copy info from the directory identified by ST into the archive.
1112 DIRECTORY contains the directory's entries. */
1115 dump_dir0 (struct tar_stat_info
*st
, char const *directory
)
1117 bool top_level
= ! st
->parent
;
1118 const char *tag_file_name
;
1119 union block
*blk
= NULL
;
1120 off_t block_ordinal
= current_block_ordinal ();
1122 st
->stat
.st_size
= 0; /* force 0 size on dir */
1124 blk
= start_header (st
);
1128 if (incremental_option
&& archive_format
!= POSIX_FORMAT
)
1129 blk
->header
.typeflag
= GNUTYPE_DUMPDIR
;
1130 else /* if (standard_option) */
1131 blk
->header
.typeflag
= DIRTYPE
;
1133 /* If we're gnudumping, we aren't done yet so don't close it. */
1135 if (!incremental_option
)
1136 finish_header (st
, blk
, block_ordinal
);
1137 else if (gnu_list_name
->directory
)
1139 if (archive_format
== POSIX_FORMAT
)
1141 xheader_store ("GNU.dumpdir", st
,
1142 safe_directory_contents (gnu_list_name
->directory
));
1143 finish_header (st
, blk
, block_ordinal
);
1151 const char *buffer
, *p_buffer
;
1153 block_ordinal
= current_block_ordinal ();
1154 buffer
= safe_directory_contents (gnu_list_name
->directory
);
1155 totsize
= dumpdir_size (buffer
);
1156 OFF_TO_CHARS (totsize
, blk
->header
.size
);
1157 finish_header (st
, blk
, block_ordinal
);
1159 size_left
= totsize
;
1161 mv_begin_write (st
->file_name
, totsize
, totsize
);
1162 while (size_left
> 0)
1164 blk
= find_next_block ();
1165 bufsize
= available_space_after (blk
);
1166 if (size_left
< bufsize
)
1168 bufsize
= size_left
;
1169 count
= bufsize
% BLOCKSIZE
;
1171 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
1173 memcpy (blk
->buffer
, p_buffer
, bufsize
);
1174 size_left
-= bufsize
;
1175 p_buffer
+= bufsize
;
1176 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
1182 if (!recursion_option
)
1185 if (one_file_system_option
1187 && st
->parent
->stat
.st_dev
!= st
->stat
.st_dev
)
1192 _("%s: file is on a different filesystem; not dumped"),
1193 quotearg_colon (st
->orig_file_name
)));
1200 switch (check_exclusion_tags (st
, &tag_file_name
))
1202 case exclusion_tag_all
:
1203 /* Handled in dump_file0 */
1206 case exclusion_tag_none
:
1212 name_buf
= xstrdup (st
->orig_file_name
);
1213 name_size
= name_len
= strlen (name_buf
);
1215 /* Now output all the files in the directory. */
1216 for (entry
= directory
; (entry_len
= strlen (entry
)) != 0;
1217 entry
+= entry_len
+ 1)
1219 if (name_size
< name_len
+ entry_len
)
1221 name_size
= name_len
+ entry_len
;
1222 name_buf
= xrealloc (name_buf
, name_size
+ 1);
1224 strcpy (name_buf
+ name_len
, entry
);
1225 if (!excluded_name (name_buf
))
1226 dump_file (st
, entry
, name_buf
);
1233 case exclusion_tag_contents
:
1234 exclusion_tag_warning (st
->orig_file_name
, tag_file_name
,
1235 _("contents not dumped"));
1236 name_size
= strlen (st
->orig_file_name
) + strlen (tag_file_name
) + 1;
1237 name_buf
= xmalloc (name_size
);
1238 strcpy (name_buf
, st
->orig_file_name
);
1239 strcat (name_buf
, tag_file_name
);
1240 dump_file (st
, tag_file_name
, name_buf
);
1244 case exclusion_tag_under
:
1245 exclusion_tag_warning (st
->orig_file_name
, tag_file_name
,
1246 _("contents not dumped"));
1252 /* Ensure exactly one trailing slash. */
1254 ensure_slash (char **pstr
)
1256 size_t len
= strlen (*pstr
);
1257 while (len
>= 1 && ISSLASH ((*pstr
)[len
- 1]))
1259 if (!ISSLASH ((*pstr
)[len
]))
1260 *pstr
= xrealloc (*pstr
, len
+ 2);
1261 (*pstr
)[len
++] = '/';
1262 (*pstr
)[len
] = '\0';
1265 /* If we just ran out of file descriptors, release a file descriptor
1266 in the directory chain somewhere leading from DIR->parent->parent
1267 up through the root. Return true if successful, false (preserving
1268 errno == EMFILE) otherwise.
1270 Do not release DIR's file descriptor, or DIR's parent, as other
1271 code assumes that they work. On some operating systems, another
1272 process can claim file descriptor resources as we release them, and
1273 some calls or their emulations require multiple file descriptors,
1274 so callers should not give up if a single release doesn't work. */
1277 open_failure_recover (struct tar_stat_info
const *dir
)
1279 if (errno
== EMFILE
&& dir
&& dir
->parent
)
1281 struct tar_stat_info
*p
;
1282 for (p
= dir
->parent
->parent
; p
; p
= p
->parent
)
1283 if (0 < p
->fd
&& (! p
->parent
|| p
->parent
->fd
<= 0))
1294 /* Return the directory entries of ST, in a dynamically allocated buffer,
1295 each entry followed by '\0' and the last followed by an extra '\0'.
1296 Return null on failure, setting errno. */
1298 get_directory_entries (struct tar_stat_info
*st
)
1300 while (! (st
->dirstream
= fdopendir (st
->fd
)))
1301 if (! open_failure_recover (st
))
1303 return streamsavedir (st
->dirstream
);
1306 /* Dump the directory ST. Return true if successful, false (emitting
1307 diagnostics) otherwise. Get ST's entries, recurse through its
1308 subdirectories, and clean up file descriptors afterwards. */
1310 dump_dir (struct tar_stat_info
*st
)
1312 char *directory
= get_directory_entries (st
);
1315 savedir_diag (st
->orig_file_name
);
1319 dump_dir0 (st
, directory
);
1321 restore_parent_fd (st
);
1327 /* Number of links a file can have without having to be entered into
1328 the link table. Typically this is 1, but in trickier circumstances
1330 static nlink_t trivial_link_count
;
1333 /* Main functions of this module. */
1336 create_archive (void)
1338 struct name
const *p
;
1340 trivial_link_count
= name_count
<= 1 && ! dereference_option
;
1342 open_archive (ACCESS_WRITE
);
1343 buffer_write_global_xheader ();
1345 if (incremental_option
)
1347 size_t buffer_size
= 1000;
1348 char *buffer
= xmalloc (buffer_size
);
1351 collect_and_sort_names ();
1353 while ((p
= name_from_list ()) != NULL
)
1354 if (!excluded_name (p
->name
))
1355 dump_file (0, p
->name
, p
->name
);
1358 while ((p
= name_from_list ()) != NULL
)
1359 if (!excluded_name (p
->name
))
1361 struct tar_stat_info st
;
1362 size_t plen
= strlen (p
->name
);
1363 if (buffer_size
<= plen
)
1365 while ((buffer_size
*= 2) <= plen
)
1367 buffer
= xrealloc (buffer
, buffer_size
);
1369 memcpy (buffer
, p
->name
, plen
);
1370 if (! ISSLASH (buffer
[plen
- 1]))
1371 buffer
[plen
++] = DIRECTORY_SEPARATOR
;
1372 tar_stat_init (&st
);
1373 q
= directory_contents (gnu_list_name
->directory
);
1377 size_t qlen
= strlen (q
);
1380 if (! st
.orig_file_name
)
1382 int fd
= openat (chdir_fd
, p
->name
,
1383 open_searchdir_flags
);
1386 open_diag (p
->name
);
1390 if (fstat (fd
, &st
.stat
) != 0)
1392 stat_diag (p
->name
);
1395 st
.orig_file_name
= xstrdup (p
->name
);
1397 if (buffer_size
< plen
+ qlen
)
1399 while ((buffer_size
*=2 ) < plen
+ qlen
)
1401 buffer
= xrealloc (buffer
, buffer_size
);
1403 strcpy (buffer
+ plen
, q
+ 1);
1404 dump_file (&st
, q
+ 1, buffer
);
1408 tar_stat_destroy (&st
);
1415 while ((name
= name_next (1)) != NULL
)
1416 if (!excluded_name (name
))
1417 dump_file (0, name
, name
);
1422 finish_deferred_unlinks ();
1423 if (listed_incremental_option
)
1424 write_directory_file ();
1428 /* Calculate the hash of a link. */
1430 hash_link (void const *entry
, size_t n_buckets
)
1432 struct link
const *l
= entry
;
1433 uintmax_t num
= l
->dev
^ l
->ino
;
1434 return num
% n_buckets
;
1437 /* Compare two links for equality. */
1439 compare_links (void const *entry1
, void const *entry2
)
1441 struct link
const *link1
= entry1
;
1442 struct link
const *link2
= entry2
;
1443 return ((link1
->dev
^ link2
->dev
) | (link1
->ino
^ link2
->ino
)) == 0;
1447 unknown_file_error (char const *p
)
1449 WARNOPT (WARN_FILE_IGNORED
,
1450 (0, 0, _("%s: Unknown file type; file ignored"),
1451 quotearg_colon (p
)));
1452 if (!ignore_failed_read_option
)
1453 set_exit_status (TAREXIT_FAILURE
);
1457 /* Handling of hard links */
1459 /* Table of all non-directories that we've written so far. Any time
1460 we see another, we check the table and avoid dumping the data
1461 again if we've done it once already. */
1462 static Hash_table
*link_table
;
1464 /* Try to dump stat as a hard link to another file in the archive.
1465 Return true if successful. */
1467 dump_hard_link (struct tar_stat_info
*st
)
1470 && (trivial_link_count
< st
->stat
.st_nlink
|| remove_files_option
))
1473 struct link
*duplicate
;
1474 off_t block_ordinal
;
1477 lp
.ino
= st
->stat
.st_ino
;
1478 lp
.dev
= st
->stat
.st_dev
;
1480 if ((duplicate
= hash_lookup (link_table
, &lp
)))
1482 /* We found a link. */
1483 char const *link_name
= safer_name_suffix (duplicate
->name
, true,
1484 absolute_names_option
);
1488 block_ordinal
= current_block_ordinal ();
1489 assign_string (&st
->link_name
, link_name
);
1490 if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
)
1491 < strlen (link_name
))
1492 write_long_link (st
);
1494 st
->stat
.st_size
= 0;
1495 blk
= start_header (st
);
1498 tar_copy_str (blk
->header
.linkname
, link_name
, NAME_FIELD_SIZE
);
1500 blk
->header
.typeflag
= LNKTYPE
;
1501 finish_header (st
, blk
, block_ordinal
);
1503 if (remove_files_option
)
1504 queue_deferred_unlink (st
->orig_file_name
, false);
1513 file_count_links (struct tar_stat_info
*st
)
1515 if (hard_dereference_option
)
1517 if (trivial_link_count
< st
->stat
.st_nlink
)
1519 struct link
*duplicate
;
1520 char *linkname
= NULL
;
1523 assign_string (&linkname
, st
->orig_file_name
);
1524 transform_name (&linkname
, XFORM_LINK
);
1526 lp
= xmalloc (offsetof (struct link
, name
)
1527 + strlen (linkname
) + 1);
1528 lp
->ino
= st
->stat
.st_ino
;
1529 lp
->dev
= st
->stat
.st_dev
;
1530 lp
->nlink
= st
->stat
.st_nlink
;
1531 strcpy (lp
->name
, linkname
);
1535 || (link_table
= hash_initialize (0, 0, hash_link
,
1537 && (duplicate
= hash_insert (link_table
, lp
))))
1540 if (duplicate
!= lp
)
1546 /* For each dumped file, check if all its links were dumped. Emit
1547 warnings if it is not so. */
1556 for (lp
= hash_get_first (link_table
); lp
;
1557 lp
= hash_get_next (link_table
, lp
))
1561 WARN ((0, 0, _("Missing links to %s."), quote (lp
->name
)));
1566 /* Assuming DIR is the working directory, open FILE, using FLAGS to
1567 control the open. A null DIR means to use ".". If we are low on
1568 file descriptors, try to release one or more from DIR's parents to
1571 subfile_open (struct tar_stat_info
const *dir
, char const *file
, int flags
)
1575 static bool initialized
;
1578 /* Initialize any tables that might be needed when file
1579 descriptors are exhausted, and whose initialization might
1580 require a file descriptor. This includes the system message
1581 catalog and tar's message catalog. */
1587 while ((fd
= openat (dir
? dir
->fd
: chdir_fd
, file
, flags
)) < 0
1588 && open_failure_recover (dir
))
1593 /* Restore the file descriptor for ST->parent, if it was temporarily
1594 closed to conserve file descriptors. On failure, set the file
1595 descriptor to the negative of the corresponding errno value. Call
1596 this every time a subdirectory is ascended from. */
1598 restore_parent_fd (struct tar_stat_info
const *st
)
1600 struct tar_stat_info
*parent
= st
->parent
;
1601 if (parent
&& ! parent
->fd
)
1603 int parentfd
= openat (st
->fd
, "..", open_searchdir_flags
);
1604 struct stat parentstat
;
1608 else if (! (fstat (parentfd
, &parentstat
) == 0
1609 && parent
->stat
.st_ino
== parentstat
.st_ino
1610 && parent
->stat
.st_dev
== parentstat
.st_dev
))
1613 parentfd
= IMPOSTOR_ERRNO
;
1618 int origfd
= openat (chdir_fd
, parent
->orig_file_name
,
1619 open_searchdir_flags
);
1622 if (fstat (parentfd
, &parentstat
) == 0
1623 && parent
->stat
.st_ino
== parentstat
.st_ino
1624 && parent
->stat
.st_dev
== parentstat
.st_dev
)
1631 parent
->fd
= parentfd
;
1635 /* Dump a single file, recursing on directories. ST is the file's
1636 status info, NAME its name relative to the parent directory, and P
1637 its full name (which may be relative to the working directory). */
1639 /* FIXME: One should make sure that for *every* path leading to setting
1640 exit_status to failure, a clear diagnostic has been issued. */
1643 dump_file0 (struct tar_stat_info
*st
, char const *name
, char const *p
)
1645 union block
*header
;
1647 off_t original_size
;
1648 struct timespec original_ctime
;
1649 off_t block_ordinal
= -1;
1652 struct tar_stat_info
const *parent
= st
->parent
;
1653 bool top_level
= ! parent
;
1654 int parentfd
= top_level
? chdir_fd
: parent
->fd
;
1655 void (*diag
) (char const *) = 0;
1657 if (interactive_option
&& !confirm ("add", p
))
1660 assign_string (&st
->orig_file_name
, p
);
1661 assign_string (&st
->file_name
,
1662 safer_name_suffix (p
, false, absolute_names_option
));
1664 transform_name (&st
->file_name
, XFORM_REGFILE
);
1666 if (parentfd
< 0 && ! top_level
)
1671 else if (fstatat (parentfd
, name
, &st
->stat
, fstatat_flags
) != 0)
1673 else if (file_dumpable_p (&st
->stat
))
1675 fd
= subfile_open (parent
, name
, open_read_flags
);
1681 if (fstat (fd
, &st
->stat
) != 0)
1687 file_removed_diag (p
, top_level
, diag
);
1691 st
->archive_file_size
= original_size
= st
->stat
.st_size
;
1692 st
->atime
= get_stat_atime (&st
->stat
);
1693 st
->mtime
= get_stat_mtime (&st
->stat
);
1694 st
->ctime
= original_ctime
= get_stat_ctime (&st
->stat
);
1697 if (S_ISHIDDEN (st
->stat
.st_mode
))
1699 char *new = (char *) alloca (strlen (p
) + 2);
1709 /* See if we want only new files, and check if this one is too old to
1712 This check is omitted if incremental_option is set *and* the
1713 requested file is not explicitly listed in the command line. */
1715 if (! (incremental_option
&& ! top_level
)
1716 && !S_ISDIR (st
->stat
.st_mode
)
1717 && OLDER_TAR_STAT_TIME (*st
, m
)
1718 && (!after_date_option
|| OLDER_TAR_STAT_TIME (*st
, c
)))
1720 if (!incremental_option
&& verbose_option
)
1721 WARNOPT (WARN_FILE_UNCHANGED
,
1722 (0, 0, _("%s: file is unchanged; not dumped"),
1723 quotearg_colon (p
)));
1727 /* See if we are trying to dump the archive. */
1728 if (sys_file_is_archive (st
))
1730 WARNOPT (WARN_IGNORE_ARCHIVE
,
1731 (0, 0, _("%s: file is the archive; not dumped"),
1732 quotearg_colon (p
)));
1736 is_dir
= S_ISDIR (st
->stat
.st_mode
) != 0;
1738 if (!is_dir
&& dump_hard_link (st
))
1741 if (is_dir
|| S_ISREG (st
->stat
.st_mode
) || S_ISCTG (st
->stat
.st_mode
))
1744 struct stat final_stat
;
1746 xattrs_acls_get (parentfd
, name
, st
, 0, !is_dir
);
1747 xattrs_selinux_get (parentfd
, name
, st
, fd
);
1748 xattrs_xattrs_get (parentfd
, name
, st
, fd
);
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
? chdir_fd
: 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 && fd
&& (is_dir
|| original_size
!= 0)
1837 && set_file_atime (fd
, parentfd
, name
, st
->atime
) != 0)
1841 ok
&= tar_stat_close (st
);
1842 if (ok
&& remove_files_option
)
1843 queue_deferred_unlink (p
, is_dir
);
1847 #ifdef HAVE_READLINK
1848 else if (S_ISLNK (st
->stat
.st_mode
))
1852 size_t linklen
= st
->stat
.st_size
;
1853 if (linklen
!= st
->stat
.st_size
|| linklen
+ 1 == 0)
1855 buffer
= (char *) alloca (linklen
+ 1);
1856 size
= readlinkat (parentfd
, name
, buffer
, linklen
+ 1);
1859 file_removed_diag (p
, top_level
, readlink_diag
);
1862 buffer
[size
] = '\0';
1863 assign_string (&st
->link_name
, buffer
);
1864 transform_name (&st
->link_name
, XFORM_SYMLINK
);
1865 if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
) < size
)
1866 write_long_link (st
);
1868 xattrs_selinux_get (parentfd
, name
, st
, 0);
1869 xattrs_xattrs_get (parentfd
, name
, st
, 0);
1871 block_ordinal
= current_block_ordinal ();
1872 st
->stat
.st_size
= 0; /* force 0 size on symlink */
1873 header
= start_header (st
);
1876 tar_copy_str (header
->header
.linkname
, st
->link_name
, NAME_FIELD_SIZE
);
1877 header
->header
.typeflag
= SYMTYPE
;
1878 finish_header (st
, header
, block_ordinal
);
1879 /* nothing more to do to it */
1881 if (remove_files_option
)
1882 queue_deferred_unlink (p
, false);
1884 file_count_links (st
);
1888 else if (S_ISCHR (st
->stat
.st_mode
))
1891 xattrs_acls_get (parentfd
, name
, st
, 0, true);
1892 xattrs_selinux_get (parentfd
, name
, st
, 0);
1893 xattrs_xattrs_get (parentfd
, name
, st
, 0);
1895 else if (S_ISBLK (st
->stat
.st_mode
))
1898 xattrs_acls_get (parentfd
, name
, st
, 0, true);
1899 xattrs_selinux_get (parentfd
, name
, st
, 0);
1900 xattrs_xattrs_get (parentfd
, name
, st
, 0);
1902 else if (S_ISFIFO (st
->stat
.st_mode
))
1905 xattrs_acls_get (parentfd
, name
, st
, 0, true);
1906 xattrs_selinux_get (parentfd
, name
, st
, 0);
1907 xattrs_xattrs_get (parentfd
, name
, st
, 0);
1909 else if (S_ISSOCK (st
->stat
.st_mode
))
1911 WARNOPT (WARN_FILE_IGNORED
,
1912 (0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1915 else if (S_ISDOOR (st
->stat
.st_mode
))
1917 WARNOPT (WARN_FILE_IGNORED
,
1918 (0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1923 unknown_file_error (p
);
1927 if (archive_format
== V7_FORMAT
)
1929 unknown_file_error (p
);
1933 block_ordinal
= current_block_ordinal ();
1934 st
->stat
.st_size
= 0; /* force 0 size */
1935 header
= start_header (st
);
1938 header
->header
.typeflag
= type
;
1940 if (type
!= FIFOTYPE
)
1942 MAJOR_TO_CHARS (major (st
->stat
.st_rdev
),
1943 header
->header
.devmajor
);
1944 MINOR_TO_CHARS (minor (st
->stat
.st_rdev
),
1945 header
->header
.devminor
);
1948 finish_header (st
, header
, block_ordinal
);
1949 if (remove_files_option
)
1950 queue_deferred_unlink (p
, false);
1953 /* Dump a file, recursively. PARENT describes the file's parent
1954 directory, NAME is the file's name relative to PARENT, and FULLNAME
1955 its full name, possibly relative to the working directory. NAME
1956 may contain slashes at the top level of invocation. */
1959 dump_file (struct tar_stat_info
*parent
, char const *name
,
1960 char const *fullname
)
1962 struct tar_stat_info st
;
1963 tar_stat_init (&st
);
1965 dump_file0 (&st
, name
, fullname
);
1966 if (parent
&& listed_incremental_option
)
1967 update_parent_directory (parent
);
1968 tar_stat_destroy (&st
);