1 /* Create a tar archive.
3 Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
4 2003, 2004, 2005, 2006, 2007, 2009 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. */
41 enum exclusion_tag_type type
;
42 bool (*predicate
) (const char *name
);
43 struct exclusion_tag
*next
;
46 static struct exclusion_tag
*exclusion_tags
;
49 add_exclusion_tag (const char *name
, enum exclusion_tag_type type
,
50 bool (*predicate
) (const char *name
))
52 struct exclusion_tag
*tag
= xmalloc (sizeof tag
[0]);
53 tag
->next
= exclusion_tags
;
56 tag
->predicate
= predicate
;
57 tag
->length
= strlen (name
);
62 exclusion_tag_warning (const char *dirname
, const char *tagname
,
66 WARNOPT (WARN_CACHEDIR
,
68 _("%s: contains a cache directory tag %s; %s"),
69 quotearg_colon (dirname
),
70 quotearg_n (1, tagname
),
74 enum exclusion_tag_type
75 check_exclusion_tags (const char *dirname
, const char **tag_file_name
)
78 static size_t tagsize
;
79 struct exclusion_tag
*tag
;
80 size_t dlen
= strlen (dirname
);
81 int addslash
= !ISSLASH (dirname
[dlen
-1]);
84 for (tag
= exclusion_tags
; tag
; tag
= tag
->next
)
86 size_t size
= dlen
+ addslash
+ tag
->length
+ 1;
90 tagname
= xrealloc (tagname
, tagsize
);
95 strcpy (tagname
, dirname
);
96 nptr
= tagname
+ dlen
;
100 strcpy (nptr
, tag
->name
);
101 if (access (tagname
, F_OK
) == 0
102 && (!tag
->predicate
|| tag
->predicate (tagname
)))
105 *tag_file_name
= tag
->name
;
110 return exclusion_tag_none
;
113 /* Exclusion predicate to test if the named file (usually "CACHEDIR.TAG")
114 contains a valid header, as described at:
115 http://www.brynosaurus.com/cachedir
116 Applications can write this file into directories they create
117 for use as caches containing purely regenerable, non-precious data,
118 allowing us to avoid archiving them if --exclude-caches is specified. */
120 #define CACHEDIR_SIGNATURE "Signature: 8a477f597d28d172789f06886806bc55"
121 #define CACHEDIR_SIGNATURE_SIZE (sizeof CACHEDIR_SIGNATURE - 1)
124 cachedir_file_p (const char *name
)
126 bool tag_present
= false;
127 int fd
= open (name
, O_RDONLY
);
130 static char tagbuf
[CACHEDIR_SIGNATURE_SIZE
];
132 if (read (fd
, tagbuf
, CACHEDIR_SIGNATURE_SIZE
)
133 == CACHEDIR_SIGNATURE_SIZE
134 && memcmp (tagbuf
, CACHEDIR_SIGNATURE
, CACHEDIR_SIGNATURE_SIZE
) == 0)
143 /* The maximum uintmax_t value that can be represented with DIGITS digits,
144 assuming that each digit is BITS_PER_DIGIT wide. */
145 #define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
146 ((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
147 ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
150 /* The maximum uintmax_t value that can be represented with octal
151 digits and a trailing NUL in BUFFER. */
152 #define MAX_OCTAL_VAL(buffer) MAX_VAL_WITH_DIGITS (sizeof (buffer) - 1, LG_8)
154 /* Convert VALUE to an octal representation suitable for tar headers.
155 Output to buffer WHERE with size SIZE.
156 The result is undefined if SIZE is 0 or if VALUE is too large to fit. */
159 to_octal (uintmax_t value
, char *where
, size_t size
)
166 where
[--i
] = '0' + (v
& ((1 << LG_8
) - 1));
172 /* Copy at most LEN bytes from the string SRC to DST. Terminate with
173 NUL unless SRC is LEN or more bytes long. */
176 tar_copy_str (char *dst
, const char *src
, size_t len
)
179 for (i
= 0; i
< len
; i
++)
180 if (! (dst
[i
] = src
[i
]))
184 /* Same as tar_copy_str, but always terminate with NUL if using
188 tar_name_copy_str (char *dst
, const char *src
, size_t len
)
190 tar_copy_str (dst
, src
, len
);
191 if (archive_format
== OLDGNU_FORMAT
)
195 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
196 tar headers. NEGATIVE is 1 if VALUE was negative before being cast
197 to uintmax_t, 0 otherwise. Output to buffer WHERE with size SIZE.
198 The result is undefined if SIZE is 0 or if VALUE is too large to
202 to_base256 (int negative
, uintmax_t value
, char *where
, size_t size
)
205 uintmax_t propagated_sign_bits
=
206 ((uintmax_t) - negative
<< (CHAR_BIT
* sizeof v
- LG_256
));
211 where
[--i
] = v
& ((1 << LG_256
) - 1);
212 v
= propagated_sign_bits
| (v
>> LG_256
);
219 to_chars (int negative
, uintmax_t value
, size_t valsize
,
220 uintmax_t (*substitute
) (int *),
221 char *where
, size_t size
, const char *type
);
224 to_chars_subst (int negative
, int gnu_format
, uintmax_t value
, size_t valsize
,
225 uintmax_t (*substitute
) (int *),
226 char *where
, size_t size
, const char *type
)
228 uintmax_t maxval
= (gnu_format
229 ? MAX_VAL_WITH_DIGITS (size
- 1, LG_256
)
230 : MAX_VAL_WITH_DIGITS (size
- 1, LG_8
));
231 char valbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
232 char maxbuf
[UINTMAX_STRSIZE_BOUND
];
233 char minbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
234 char const *minval_string
;
235 char const *maxval_string
= STRINGIFY_BIGINT (maxval
, maxbuf
);
236 char const *value_string
;
240 uintmax_t m
= maxval
+ 1 ? maxval
+ 1 : maxval
/ 2 + 1;
241 char *p
= STRINGIFY_BIGINT (m
, minbuf
+ 1);
250 char *p
= STRINGIFY_BIGINT (- value
, valbuf
+ 1);
255 value_string
= STRINGIFY_BIGINT (value
, valbuf
);
260 uintmax_t sub
= substitute (&negsub
) & maxval
;
261 /* NOTE: This is one of the few places where GNU_FORMAT differs from
262 OLDGNU_FORMAT. The actual differences are:
264 1. In OLDGNU_FORMAT all strings in a tar header end in \0
265 2. Incremental archives use oldgnu_header.
267 Apart from this they are completely identical. */
268 uintmax_t s
= (negsub
&= archive_format
== GNU_FORMAT
) ? - sub
: sub
;
269 char subbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
270 char *sub_string
= STRINGIFY_BIGINT (s
, subbuf
+ 1);
273 WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
274 value_string
, type
, minval_string
, maxval_string
,
276 return to_chars (negsub
, s
, valsize
, 0, where
, size
, type
);
279 ERROR ((0, 0, _("value %s out of %s range %s..%s"),
280 value_string
, type
, minval_string
, maxval_string
));
284 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
285 external form, using SUBSTITUTE (...) if VALUE won't fit. Output
286 to buffer WHERE with size SIZE. NEGATIVE is 1 iff VALUE was
287 negative before being cast to uintmax_t; its original bitpattern
288 can be deduced from VALSIZE, its original size before casting.
289 TYPE is the kind of value being output (useful for diagnostics).
290 Prefer the POSIX format of SIZE - 1 octal digits (with leading zero
291 digits), followed by '\0'. If this won't work, and if GNU or
292 OLDGNU format is allowed, use '\200' followed by base-256, or (if
293 NEGATIVE is nonzero) '\377' followed by two's complement base-256.
294 If neither format works, use SUBSTITUTE (...) instead. Pass to
295 SUBSTITUTE the address of an 0-or-1 flag recording whether the
296 substitute value is negative. */
299 to_chars (int negative
, uintmax_t value
, size_t valsize
,
300 uintmax_t (*substitute
) (int *),
301 char *where
, size_t size
, const char *type
)
303 int gnu_format
= (archive_format
== GNU_FORMAT
304 || archive_format
== OLDGNU_FORMAT
);
306 /* Generate the POSIX octal representation if the number fits. */
307 if (! negative
&& value
<= MAX_VAL_WITH_DIGITS (size
- 1, LG_8
))
309 where
[size
- 1] = '\0';
310 to_octal (value
, where
, size
- 1);
315 /* Try to cope with the number by using traditional GNU format
318 /* Generate the base-256 representation if the number fits. */
319 if (((negative
? -1 - value
: value
)
320 <= MAX_VAL_WITH_DIGITS (size
- 1, LG_256
)))
322 where
[0] = negative
? -1 : 1 << (LG_256
- 1);
323 to_base256 (negative
, value
, where
+ 1, size
- 1);
327 /* Otherwise, if the number is negative, and if it would not cause
328 ambiguity on this host by confusing positive with negative
329 values, then generate the POSIX octal representation of the value
330 modulo 2**(field bits). The resulting tar file is
331 machine-dependent, since it depends on the host word size. Yuck!
332 But this is the traditional behavior. */
333 else if (negative
&& valsize
* CHAR_BIT
<= (size
- 1) * LG_8
)
335 static int warned_once
;
339 WARN ((0, 0, _("Generating negative octal headers")));
341 where
[size
- 1] = '\0';
342 to_octal (value
& MAX_VAL_WITH_DIGITS (valsize
* CHAR_BIT
, 1),
346 /* Otherwise fall back to substitution, if possible: */
349 substitute
= NULL
; /* No substitution for formats, other than GNU */
351 return to_chars_subst (negative
, gnu_format
, value
, valsize
, substitute
,
356 gid_substitute (int *negative
)
362 static gid_t gid_nobody
;
363 if (!gid_nobody
&& !gname_to_gid ("nobody", &gid_nobody
))
372 gid_to_chars (gid_t v
, char *p
, size_t s
)
374 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, gid_substitute
, p
, s
, "gid_t");
378 major_to_chars (major_t v
, char *p
, size_t s
)
380 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "major_t");
384 minor_to_chars (minor_t v
, char *p
, size_t s
)
386 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "minor_t");
390 mode_to_chars (mode_t v
, char *p
, size_t s
)
392 /* In the common case where the internal and external mode bits are the same,
393 and we are not using POSIX or GNU format,
394 propagate all unknown bits to the external mode.
395 This matches historical practice.
396 Otherwise, just copy the bits we know about. */
399 if (S_ISUID
== TSUID
&& S_ISGID
== TSGID
&& S_ISVTX
== TSVTX
400 && S_IRUSR
== TUREAD
&& S_IWUSR
== TUWRITE
&& S_IXUSR
== TUEXEC
401 && S_IRGRP
== TGREAD
&& S_IWGRP
== TGWRITE
&& S_IXGRP
== TGEXEC
402 && S_IROTH
== TOREAD
&& S_IWOTH
== TOWRITE
&& S_IXOTH
== TOEXEC
403 && archive_format
!= POSIX_FORMAT
404 && archive_format
!= USTAR_FORMAT
405 && archive_format
!= GNU_FORMAT
)
413 u
= ((v
& S_ISUID
? TSUID
: 0)
414 | (v
& S_ISGID
? TSGID
: 0)
415 | (v
& S_ISVTX
? TSVTX
: 0)
416 | (v
& S_IRUSR
? TUREAD
: 0)
417 | (v
& S_IWUSR
? TUWRITE
: 0)
418 | (v
& S_IXUSR
? TUEXEC
: 0)
419 | (v
& S_IRGRP
? TGREAD
: 0)
420 | (v
& S_IWGRP
? TGWRITE
: 0)
421 | (v
& S_IXGRP
? TGEXEC
: 0)
422 | (v
& S_IROTH
? TOREAD
: 0)
423 | (v
& S_IWOTH
? TOWRITE
: 0)
424 | (v
& S_IXOTH
? TOEXEC
: 0));
426 return to_chars (negative
, u
, sizeof v
, 0, p
, s
, "mode_t");
430 off_to_chars (off_t v
, char *p
, size_t s
)
432 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "off_t");
436 size_to_chars (size_t v
, char *p
, size_t s
)
438 return to_chars (0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "size_t");
442 time_to_chars (time_t v
, char *p
, size_t s
)
444 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "time_t");
448 uid_substitute (int *negative
)
454 static uid_t uid_nobody
;
455 if (!uid_nobody
&& !uname_to_uid ("nobody", &uid_nobody
))
464 uid_to_chars (uid_t v
, char *p
, size_t s
)
466 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, uid_substitute
, p
, s
, "uid_t");
470 uintmax_to_chars (uintmax_t v
, char *p
, size_t s
)
472 return to_chars (0, v
, sizeof v
, 0, p
, s
, "uintmax_t");
476 string_to_chars (char const *str
, char *p
, size_t s
)
478 tar_copy_str (p
, str
, s
);
483 /* A file is considered dumpable if it is sparse and both --sparse and --totals
485 Otherwise, it is dumpable unless any of the following conditions occur:
487 a) it is empty *and* world-readable, or
488 b) current archive is /dev/null */
491 file_dumpable_p (struct tar_stat_info
*st
)
494 return totals_option
&& sparse_option
&& ST_IS_SPARSE (st
->stat
);
495 return !(st
->archive_file_size
== 0
496 && (st
->stat
.st_mode
& MODE_R
) == MODE_R
);
500 /* Writing routines. */
502 /* Write the EOT block(s). Zero at least two blocks, through the end
503 of the record. Old tar, as previous versions of GNU tar, writes
504 garbage after two zeroed blocks. */
508 union block
*pointer
= find_next_block ();
509 memset (pointer
->buffer
, 0, BLOCKSIZE
);
510 set_next_block_after (pointer
);
511 pointer
= find_next_block ();
512 memset (pointer
->buffer
, 0, available_space_after (pointer
));
513 set_next_block_after (pointer
);
516 /* Write a "private" header */
518 start_private_header (const char *name
, size_t size
, time_t t
)
520 union block
*header
= find_next_block ();
522 memset (header
->buffer
, 0, sizeof (union block
));
524 tar_name_copy_str (header
->header
.name
, name
, NAME_FIELD_SIZE
);
525 OFF_TO_CHARS (size
, header
->header
.size
);
527 TIME_TO_CHARS (t
, header
->header
.mtime
);
528 MODE_TO_CHARS (S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
, header
->header
.mode
);
529 UID_TO_CHARS (getuid (), header
->header
.uid
);
530 GID_TO_CHARS (getgid (), header
->header
.gid
);
531 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
532 MINOR_TO_CHARS (0, header
->header
.devminor
);
533 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
534 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
538 /* Create a new header and store there at most NAME_FIELD_SIZE bytes of
542 write_short_name (struct tar_stat_info
*st
)
544 union block
*header
= find_next_block ();
545 memset (header
->buffer
, 0, sizeof (union block
));
546 tar_name_copy_str (header
->header
.name
, st
->file_name
, NAME_FIELD_SIZE
);
550 #define FILL(field,byte) do { \
551 memset(field, byte, sizeof(field)-1); \
552 (field)[sizeof(field)-1] = 0; \
555 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. */
557 write_gnu_long_link (struct tar_stat_info
*st
, const char *p
, char type
)
559 size_t size
= strlen (p
) + 1;
564 header
= start_private_header ("././@LongLink", size
, time (NULL
));
565 FILL (header
->header
.mtime
, '0');
566 FILL (header
->header
.mode
, '0');
567 FILL (header
->header
.uid
, '0');
568 FILL (header
->header
.gid
, '0');
569 FILL (header
->header
.devmajor
, 0);
570 FILL (header
->header
.devminor
, 0);
571 uid_to_uname (0, &tmpname
);
572 UNAME_TO_CHARS (tmpname
, header
->header
.uname
);
574 gid_to_gname (0, &tmpname
);
575 GNAME_TO_CHARS (tmpname
, header
->header
.gname
);
578 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
579 header
->header
.typeflag
= type
;
580 finish_header (st
, header
, -1);
582 header
= find_next_block ();
584 bufsize
= available_space_after (header
);
586 while (bufsize
< size
)
588 memcpy (header
->buffer
, p
, bufsize
);
591 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
592 header
= find_next_block ();
593 bufsize
= available_space_after (header
);
595 memcpy (header
->buffer
, p
, size
);
596 memset (header
->buffer
+ size
, 0, bufsize
- size
);
597 set_next_block_after (header
+ (size
- 1) / BLOCKSIZE
);
601 split_long_name (const char *name
, size_t length
)
605 if (length
> PREFIX_FIELD_SIZE
)
606 length
= PREFIX_FIELD_SIZE
+ 1;
607 for (i
= length
- 1; i
> 0; i
--)
608 if (ISSLASH (name
[i
]))
614 write_ustar_long_name (const char *name
)
616 size_t length
= strlen (name
);
620 if (length
> PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1)
622 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
623 quotearg_colon (name
),
624 PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1));
628 i
= split_long_name (name
, length
);
629 if (i
== 0 || length
- i
- 1 > NAME_FIELD_SIZE
)
632 _("%s: file name is too long (cannot be split); not dumped"),
633 quotearg_colon (name
)));
637 header
= find_next_block ();
638 memset (header
->buffer
, 0, sizeof (header
->buffer
));
639 memcpy (header
->header
.prefix
, name
, i
);
640 memcpy (header
->header
.name
, name
+ i
+ 1, length
- i
- 1);
645 /* Write a long link name, depending on the current archive format */
647 write_long_link (struct tar_stat_info
*st
)
649 switch (archive_format
)
652 xheader_store ("linkpath", st
, NULL
);
655 case V7_FORMAT
: /* old V7 tar format */
659 _("%s: link name is too long; not dumped"),
660 quotearg_colon (st
->link_name
)));
665 write_gnu_long_link (st
, st
->link_name
, GNUTYPE_LONGLINK
);
674 write_long_name (struct tar_stat_info
*st
)
676 switch (archive_format
)
679 xheader_store ("path", st
, NULL
);
683 if (strlen (st
->file_name
) > NAME_FIELD_SIZE
-1)
685 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
686 quotearg_colon (st
->file_name
),
687 NAME_FIELD_SIZE
- 1));
694 return write_ustar_long_name (st
->file_name
);
698 write_gnu_long_link (st
, st
->file_name
, GNUTYPE_LONGNAME
);
704 return write_short_name (st
);
708 write_extended (bool global
, struct tar_stat_info
*st
, union block
*old_header
)
710 union block
*header
, hp
;
715 if (st
->xhdr
.buffer
|| st
->xhdr
.stk
== NULL
)
718 xheader_finish (&st
->xhdr
);
719 memcpy (hp
.buffer
, old_header
, sizeof (hp
));
723 p
= xheader_ghdr_name ();
729 p
= xheader_xhdr_name (st
);
730 t
= st
->stat
.st_mtime
;
732 xheader_write (type
, p
, t
, &st
->xhdr
);
734 header
= find_next_block ();
735 memcpy (header
, &hp
.buffer
, sizeof (hp
.buffer
));
740 write_header_name (struct tar_stat_info
*st
)
742 if (archive_format
== POSIX_FORMAT
&& !string_ascii_p (st
->file_name
))
744 xheader_store ("path", st
, NULL
);
745 return write_short_name (st
);
747 else if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
)
748 < strlen (st
->file_name
))
749 return write_long_name (st
);
751 return write_short_name (st
);
755 /* Header handling. */
757 /* Make a header block for the file whose stat info is st,
758 and return its address. */
761 start_header (struct tar_stat_info
*st
)
765 header
= write_header_name (st
);
769 /* Override some stat fields, if requested to do so. */
771 if (owner_option
!= (uid_t
) -1)
772 st
->stat
.st_uid
= owner_option
;
773 if (group_option
!= (gid_t
) -1)
774 st
->stat
.st_gid
= group_option
;
777 ((st
->stat
.st_mode
& ~MODE_ALL
)
778 | mode_adjust (st
->stat
.st_mode
, S_ISDIR (st
->stat
.st_mode
) != 0,
779 initial_umask
, mode_option
, NULL
));
781 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
782 for a few tars and came up with the following interoperability
786 1 2 3 4 5 6 7 8 9 READER
787 . . . . . . . . . 1 = SunOS 4.2 tar
788 # . . # # . . # # 2 = NEC SVR4.0.2 tar
789 . . . # # . . # . 3 = Solaris 2.1 tar
790 . . . . . . . . . 4 = GNU tar 1.11.1
791 . . . . . . . . . 5 = HP-UX 8.07 tar
792 . . . . . . . . . 6 = Ultrix 4.1
793 . . . . . . . . . 7 = AIX 3.2
794 . . . . . . . . . 8 = Hitachi HI-UX 1.03
795 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
798 # = ``impossible file type''
800 The following mask for old archive removes the `#'s in column 4
801 above, thus making GNU tar both a universal donor and a universal
802 acceptor for Paul's test. */
804 if (archive_format
== V7_FORMAT
|| archive_format
== USTAR_FORMAT
)
805 MODE_TO_CHARS (st
->stat
.st_mode
& MODE_ALL
, header
->header
.mode
);
807 MODE_TO_CHARS (st
->stat
.st_mode
, header
->header
.mode
);
810 uid_t uid
= st
->stat
.st_uid
;
811 if (archive_format
== POSIX_FORMAT
812 && MAX_OCTAL_VAL (header
->header
.uid
) < uid
)
814 xheader_store ("uid", st
, NULL
);
817 if (!UID_TO_CHARS (uid
, header
->header
.uid
))
822 gid_t gid
= st
->stat
.st_gid
;
823 if (archive_format
== POSIX_FORMAT
824 && MAX_OCTAL_VAL (header
->header
.gid
) < gid
)
826 xheader_store ("gid", st
, NULL
);
829 if (!GID_TO_CHARS (gid
, header
->header
.gid
))
834 off_t size
= st
->stat
.st_size
;
835 if (archive_format
== POSIX_FORMAT
836 && MAX_OCTAL_VAL (header
->header
.size
) < size
)
838 xheader_store ("size", st
, NULL
);
841 if (!OFF_TO_CHARS (size
, header
->header
.size
))
846 struct timespec mtime
= set_mtime_option
? mtime_option
: st
->mtime
;
847 if (archive_format
== POSIX_FORMAT
)
849 if (MAX_OCTAL_VAL (header
->header
.mtime
) < mtime
.tv_sec
850 || mtime
.tv_nsec
!= 0)
851 xheader_store ("mtime", st
, &mtime
);
852 if (MAX_OCTAL_VAL (header
->header
.mtime
) < mtime
.tv_sec
)
855 if (!TIME_TO_CHARS (mtime
.tv_sec
, header
->header
.mtime
))
860 if (S_ISCHR (st
->stat
.st_mode
)
861 || S_ISBLK (st
->stat
.st_mode
))
863 major_t devmajor
= major (st
->stat
.st_rdev
);
864 minor_t devminor
= minor (st
->stat
.st_rdev
);
866 if (archive_format
== POSIX_FORMAT
867 && MAX_OCTAL_VAL (header
->header
.devmajor
) < devmajor
)
869 xheader_store ("devmajor", st
, NULL
);
872 if (!MAJOR_TO_CHARS (devmajor
, header
->header
.devmajor
))
875 if (archive_format
== POSIX_FORMAT
876 && MAX_OCTAL_VAL (header
->header
.devminor
) < devminor
)
878 xheader_store ("devminor", st
, NULL
);
881 if (!MINOR_TO_CHARS (devminor
, header
->header
.devminor
))
884 else if (archive_format
!= GNU_FORMAT
&& archive_format
!= OLDGNU_FORMAT
)
886 if (!(MAJOR_TO_CHARS (0, header
->header
.devmajor
)
887 && MINOR_TO_CHARS (0, header
->header
.devminor
)))
891 if (archive_format
== POSIX_FORMAT
)
893 xheader_store ("atime", st
, NULL
);
894 xheader_store ("ctime", st
, NULL
);
896 else if (incremental_option
)
897 if (archive_format
== OLDGNU_FORMAT
|| archive_format
== GNU_FORMAT
)
899 TIME_TO_CHARS (st
->atime
.tv_sec
, header
->oldgnu_header
.atime
);
900 TIME_TO_CHARS (st
->ctime
.tv_sec
, header
->oldgnu_header
.ctime
);
903 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
905 switch (archive_format
)
911 case GNU_FORMAT
: /*FIXME?*/
912 /* Overwrite header->header.magic and header.version in one blow. */
913 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
918 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
919 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
926 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
928 /* header->header.[ug]name are left as the empty string. */
932 uid_to_uname (st
->stat
.st_uid
, &st
->uname
);
933 gid_to_gname (st
->stat
.st_gid
, &st
->gname
);
935 if (archive_format
== POSIX_FORMAT
936 && (strlen (st
->uname
) > UNAME_FIELD_SIZE
937 || !string_ascii_p (st
->uname
)))
938 xheader_store ("uname", st
, NULL
);
939 UNAME_TO_CHARS (st
->uname
, header
->header
.uname
);
941 if (archive_format
== POSIX_FORMAT
942 && (strlen (st
->gname
) > GNAME_FIELD_SIZE
943 || !string_ascii_p (st
->gname
)))
944 xheader_store ("gname", st
, NULL
);
945 GNAME_TO_CHARS (st
->gname
, header
->header
.gname
);
952 simple_finish_header (union block
*header
)
958 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
962 for (i
= sizeof *header
; i
-- != 0; )
963 /* We can't use unsigned char here because of old compilers, e.g. V7. */
966 /* Fill in the checksum field. It's formatted differently from the
967 other fields: it has [6] digits, a null, then a space -- rather than
968 digits, then a null. We use to_chars.
969 The final space is already there, from
970 checksumming, and to_chars doesn't modify it.
972 This is a fast way to do:
974 sprintf(header->header.chksum, "%6o", sum); */
976 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
978 set_next_block_after (header
);
981 /* Finish off a filled-in header block and write it out. We also
982 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
983 is not negative, is the block ordinal of the first record for this
984 file, which may be a preceding long name or long link record. */
986 finish_header (struct tar_stat_info
*st
,
987 union block
*header
, off_t block_ordinal
)
989 /* Note: It is important to do this before the call to write_extended(),
990 so that the actual ustar header is printed */
992 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
993 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
994 && header
->header
.typeflag
!= XHDTYPE
995 && header
->header
.typeflag
!= XGLTYPE
)
997 /* These globals are parameters to print_header, sigh. */
999 current_header
= header
;
1000 current_format
= archive_format
;
1001 print_header (st
, block_ordinal
);
1004 header
= write_extended (false, st
, header
);
1005 simple_finish_header (header
);
1010 pad_archive (off_t size_left
)
1013 while (size_left
> 0)
1015 mv_size_left (size_left
);
1016 blk
= find_next_block ();
1017 memset (blk
->buffer
, 0, BLOCKSIZE
);
1018 set_next_block_after (blk
);
1019 size_left
-= BLOCKSIZE
;
1023 static enum dump_status
1024 dump_regular_file (int fd
, struct tar_stat_info
*st
)
1026 off_t size_left
= st
->stat
.st_size
;
1027 off_t block_ordinal
;
1030 block_ordinal
= current_block_ordinal ();
1031 blk
= start_header (st
);
1033 return dump_status_fail
;
1035 /* Mark contiguous files, if we support them. */
1036 if (archive_format
!= V7_FORMAT
&& S_ISCTG (st
->stat
.st_mode
))
1037 blk
->header
.typeflag
= CONTTYPE
;
1039 finish_header (st
, blk
, block_ordinal
);
1042 while (size_left
> 0)
1044 size_t bufsize
, count
;
1046 mv_size_left (size_left
);
1048 blk
= find_next_block ();
1050 bufsize
= available_space_after (blk
);
1052 if (size_left
< bufsize
)
1054 /* Last read -- zero out area beyond. */
1055 bufsize
= size_left
;
1056 count
= bufsize
% BLOCKSIZE
;
1058 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
1061 count
= (fd
< 0) ? bufsize
: safe_read (fd
, blk
->buffer
, bufsize
);
1062 if (count
== SAFE_READ_ERROR
)
1064 read_diag_details (st
->orig_file_name
,
1065 st
->stat
.st_size
- size_left
, bufsize
);
1066 pad_archive (size_left
);
1067 return dump_status_short
;
1070 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
1072 if (count
!= bufsize
)
1074 char buf
[UINTMAX_STRSIZE_BOUND
];
1075 memset (blk
->buffer
+ count
, 0, bufsize
- count
);
1076 WARNOPT (WARN_FILE_SHRANK
,
1078 ngettext ("%s: File shrank by %s byte; padding with zeros",
1079 "%s: File shrank by %s bytes; padding with zeros",
1081 quotearg_colon (st
->orig_file_name
),
1082 STRINGIFY_BIGINT (size_left
, buf
)));
1083 if (! ignore_failed_read_option
)
1084 set_exit_status (TAREXIT_DIFFERS
);
1085 pad_archive (size_left
- (bufsize
- count
));
1086 return dump_status_short
;
1089 return dump_status_ok
;
1094 dump_dir0 (char *directory
,
1095 struct tar_stat_info
*st
, bool top_level
, dev_t parent_device
)
1097 dev_t our_device
= st
->stat
.st_dev
;
1098 const char *tag_file_name
;
1100 if (!is_avoided_name (st
->orig_file_name
))
1102 union block
*blk
= NULL
;
1103 off_t block_ordinal
= current_block_ordinal ();
1104 st
->stat
.st_size
= 0; /* force 0 size on dir */
1106 blk
= start_header (st
);
1110 if (incremental_option
&& archive_format
!= POSIX_FORMAT
)
1111 blk
->header
.typeflag
= GNUTYPE_DUMPDIR
;
1112 else /* if (standard_option) */
1113 blk
->header
.typeflag
= DIRTYPE
;
1115 /* If we're gnudumping, we aren't done yet so don't close it. */
1117 if (!incremental_option
)
1118 finish_header (st
, blk
, block_ordinal
);
1119 else if (gnu_list_name
->directory
)
1121 if (archive_format
== POSIX_FORMAT
)
1123 xheader_store ("GNU.dumpdir", st
,
1124 safe_directory_contents (gnu_list_name
->directory
));
1125 finish_header (st
, blk
, block_ordinal
);
1133 const char *buffer
, *p_buffer
;
1135 block_ordinal
= current_block_ordinal ();
1136 buffer
= safe_directory_contents (gnu_list_name
->directory
);
1137 totsize
= dumpdir_size (buffer
);
1138 OFF_TO_CHARS (totsize
, blk
->header
.size
);
1139 finish_header (st
, blk
, block_ordinal
);
1141 size_left
= totsize
;
1144 mv_total_size (totsize
);
1145 while (size_left
> 0)
1147 mv_size_left (size_left
);
1148 blk
= find_next_block ();
1149 bufsize
= available_space_after (blk
);
1150 if (size_left
< bufsize
)
1152 bufsize
= size_left
;
1153 count
= bufsize
% BLOCKSIZE
;
1155 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
1157 memcpy (blk
->buffer
, p_buffer
, bufsize
);
1158 size_left
-= bufsize
;
1159 p_buffer
+= bufsize
;
1160 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
1168 if (!recursion_option
)
1171 if (one_file_system_option
1173 && parent_device
!= st
->stat
.st_dev
)
1178 _("%s: file is on a different filesystem; not dumped"),
1179 quotearg_colon (st
->orig_file_name
)));
1186 switch (check_exclusion_tags (st
->orig_file_name
, &tag_file_name
))
1188 case exclusion_tag_all
:
1189 /* Handled in dump_file0 */
1192 case exclusion_tag_none
:
1198 name_buf
= xstrdup (st
->orig_file_name
);
1199 name_size
= name_len
= strlen (name_buf
);
1201 /* Now output all the files in the directory. */
1202 /* FIXME: Should speed this up by cd-ing into the dir. */
1203 for (entry
= directory
; (entry_len
= strlen (entry
)) != 0;
1204 entry
+= entry_len
+ 1)
1206 if (name_size
< name_len
+ entry_len
)
1208 name_size
= name_len
+ entry_len
;
1209 name_buf
= xrealloc (name_buf
, name_size
+ 1);
1211 strcpy (name_buf
+ name_len
, entry
);
1212 if (!excluded_name (name_buf
))
1213 dump_file (name_buf
, false, our_device
);
1220 case exclusion_tag_contents
:
1221 exclusion_tag_warning (st
->orig_file_name
, tag_file_name
,
1222 _("contents not dumped"));
1223 name_size
= strlen (st
->orig_file_name
) + strlen (tag_file_name
) + 1;
1224 name_buf
= xmalloc (name_size
);
1225 strcpy (name_buf
, st
->orig_file_name
);
1226 strcat (name_buf
, tag_file_name
);
1227 dump_file (name_buf
, false, our_device
);
1231 case exclusion_tag_under
:
1232 exclusion_tag_warning (st
->orig_file_name
, tag_file_name
,
1233 _("contents not dumped"));
1239 /* Ensure exactly one trailing slash. */
1241 ensure_slash (char **pstr
)
1243 size_t len
= strlen (*pstr
);
1244 while (len
>= 1 && ISSLASH ((*pstr
)[len
- 1]))
1246 if (!ISSLASH ((*pstr
)[len
]))
1247 *pstr
= xrealloc (*pstr
, len
+ 2);
1248 (*pstr
)[len
++] = '/';
1249 (*pstr
)[len
] = '\0';
1253 dump_dir (int fd
, struct tar_stat_info
*st
, bool top_level
,
1254 dev_t parent_device
)
1256 char *directory
= fdsavedir (fd
);
1259 savedir_diag (st
->orig_file_name
);
1263 dump_dir0 (directory
, st
, top_level
, parent_device
);
1270 /* Main functions of this module. */
1273 create_archive (void)
1275 struct name
const *p
;
1277 open_archive (ACCESS_WRITE
);
1278 buffer_write_global_xheader ();
1280 if (incremental_option
)
1282 size_t buffer_size
= 1000;
1283 char *buffer
= xmalloc (buffer_size
);
1286 collect_and_sort_names ();
1288 while ((p
= name_from_list ()) != NULL
)
1289 if (!excluded_name (p
->name
))
1290 dump_file (p
->name
, p
->cmdline
, (dev_t
) 0);
1293 while ((p
= name_from_list ()) != NULL
)
1294 if (!excluded_name (p
->name
))
1296 size_t plen
= strlen (p
->name
);
1297 if (buffer_size
<= plen
)
1299 while ((buffer_size
*= 2) <= plen
)
1301 buffer
= xrealloc (buffer
, buffer_size
);
1303 memcpy (buffer
, p
->name
, plen
);
1304 if (! ISSLASH (buffer
[plen
- 1]))
1305 buffer
[plen
++] = DIRECTORY_SEPARATOR
;
1306 q
= directory_contents (gnu_list_name
->directory
);
1310 size_t qlen
= strlen (q
);
1313 if (buffer_size
< plen
+ qlen
)
1315 while ((buffer_size
*=2 ) < plen
+ qlen
)
1317 buffer
= xrealloc (buffer
, buffer_size
);
1319 strcpy (buffer
+ plen
, q
+ 1);
1320 dump_file (buffer
, false, (dev_t
) 0);
1330 while ((name
= name_next (1)) != NULL
)
1331 if (!excluded_name (name
))
1332 dump_file (name
, true, (dev_t
) 0);
1337 finish_deferred_unlinks ();
1338 if (listed_incremental_option
)
1339 write_directory_file ();
1343 /* Calculate the hash of a link. */
1345 hash_link (void const *entry
, size_t n_buckets
)
1347 struct link
const *l
= entry
;
1348 uintmax_t num
= l
->dev
^ l
->ino
;
1349 return num
% n_buckets
;
1352 /* Compare two links for equality. */
1354 compare_links (void const *entry1
, void const *entry2
)
1356 struct link
const *link1
= entry1
;
1357 struct link
const *link2
= entry2
;
1358 return ((link1
->dev
^ link2
->dev
) | (link1
->ino
^ link2
->ino
)) == 0;
1362 unknown_file_error (char const *p
)
1364 WARNOPT (WARN_FILE_IGNORED
,
1365 (0, 0, _("%s: Unknown file type; file ignored"),
1366 quotearg_colon (p
)));
1367 if (!ignore_failed_read_option
)
1368 set_exit_status (TAREXIT_FAILURE
);
1372 /* Handling of hard links */
1374 /* Table of all non-directories that we've written so far. Any time
1375 we see another, we check the table and avoid dumping the data
1376 again if we've done it once already. */
1377 static Hash_table
*link_table
;
1379 /* Try to dump stat as a hard link to another file in the archive.
1380 Return true if successful. */
1382 dump_hard_link (struct tar_stat_info
*st
)
1384 if (link_table
&& (st
->stat
.st_nlink
> 1 || remove_files_option
))
1387 struct link
*duplicate
;
1388 off_t block_ordinal
;
1391 lp
.ino
= st
->stat
.st_ino
;
1392 lp
.dev
= st
->stat
.st_dev
;
1394 if ((duplicate
= hash_lookup (link_table
, &lp
)))
1396 /* We found a link. */
1397 char const *link_name
= safer_name_suffix (duplicate
->name
, true,
1398 absolute_names_option
);
1402 block_ordinal
= current_block_ordinal ();
1403 assign_string (&st
->link_name
, link_name
);
1404 if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
)
1405 < strlen (link_name
))
1406 write_long_link (st
);
1408 st
->stat
.st_size
= 0;
1409 blk
= start_header (st
);
1412 tar_copy_str (blk
->header
.linkname
, link_name
, NAME_FIELD_SIZE
);
1414 blk
->header
.typeflag
= LNKTYPE
;
1415 finish_header (st
, blk
, block_ordinal
);
1417 if (remove_files_option
)
1418 queue_deferred_unlink (st
->orig_file_name
, false);
1427 file_count_links (struct tar_stat_info
*st
)
1429 if (hard_dereference_option
)
1431 if (st
->stat
.st_nlink
> 1)
1433 struct link
*duplicate
;
1434 char *linkname
= NULL
;
1437 assign_string (&linkname
, st
->orig_file_name
);
1438 transform_name (&linkname
, XFORM_LINK
);
1440 lp
= xmalloc (offsetof (struct link
, name
)
1441 + strlen (linkname
) + 1);
1442 lp
->ino
= st
->stat
.st_ino
;
1443 lp
->dev
= st
->stat
.st_dev
;
1444 lp
->nlink
= st
->stat
.st_nlink
;
1445 strcpy (lp
->name
, linkname
);
1449 || (link_table
= hash_initialize (0, 0, hash_link
,
1451 && (duplicate
= hash_insert (link_table
, lp
))))
1454 if (duplicate
!= lp
)
1460 /* For each dumped file, check if all its links were dumped. Emit
1461 warnings if it is not so. */
1470 for (lp
= hash_get_first (link_table
); lp
;
1471 lp
= hash_get_next (link_table
, lp
))
1475 WARN ((0, 0, _("Missing links to %s."), quote (lp
->name
)));
1480 /* Dump a single file, recursing on directories. P is the file name
1481 to dump. TOP_LEVEL tells whether this is a top-level call; zero
1482 means no, positive means yes, and negative means the top level
1483 of an incremental dump. PARENT_DEVICE is the device of P's
1484 parent directory; it is examined only if TOP_LEVEL is zero. */
1486 /* FIXME: One should make sure that for *every* path leading to setting
1487 exit_status to failure, a clear diagnostic has been issued. */
1490 dump_file0 (struct tar_stat_info
*st
, const char *p
,
1491 bool top_level
, dev_t parent_device
)
1493 union block
*header
;
1495 off_t original_size
;
1496 struct timespec original_ctime
;
1497 struct timespec restore_times
[2];
1498 off_t block_ordinal
= -1;
1501 if (interactive_option
&& !confirm ("add", p
))
1504 assign_string (&st
->orig_file_name
, p
);
1505 assign_string (&st
->file_name
,
1506 safer_name_suffix (p
, false, absolute_names_option
));
1508 transform_name (&st
->file_name
, XFORM_REGFILE
);
1510 if (deref_stat (dereference_option
, p
, &st
->stat
) != 0)
1512 file_removed_diag (p
, top_level
, stat_diag
);
1515 st
->archive_file_size
= original_size
= st
->stat
.st_size
;
1516 st
->atime
= restore_times
[0] = get_stat_atime (&st
->stat
);
1517 st
->mtime
= restore_times
[1] = get_stat_mtime (&st
->stat
);
1518 st
->ctime
= original_ctime
= get_stat_ctime (&st
->stat
);
1521 if (S_ISHIDDEN (st
->stat
.st_mode
))
1523 char *new = (char *) alloca (strlen (p
) + 2);
1533 /* See if we want only new files, and check if this one is too old to
1536 This check is omitted if incremental_option is set *and* the
1537 requested file is not explicitely listed in the command line. */
1539 if (!(incremental_option
&& !is_individual_file (p
))
1540 && !S_ISDIR (st
->stat
.st_mode
)
1541 && OLDER_TAR_STAT_TIME (*st
, m
)
1542 && (!after_date_option
|| OLDER_TAR_STAT_TIME (*st
, c
)))
1544 if (!incremental_option
&& verbose_option
)
1545 WARNOPT (WARN_FILE_UNCHANGED
,
1546 (0, 0, _("%s: file is unchanged; not dumped"),
1547 quotearg_colon (p
)));
1551 /* See if we are trying to dump the archive. */
1552 if (sys_file_is_archive (st
))
1554 WARNOPT (WARN_IGNORE_ARCHIVE
,
1555 (0, 0, _("%s: file is the archive; not dumped"),
1556 quotearg_colon (p
)));
1560 if (is_avoided_name (p
))
1563 is_dir
= S_ISDIR (st
->stat
.st_mode
) != 0;
1565 if (!is_dir
&& dump_hard_link (st
))
1568 if (is_dir
|| S_ISREG (st
->stat
.st_mode
) || S_ISCTG (st
->stat
.st_mode
))
1572 struct stat final_stat
;
1574 if (is_dir
|| file_dumpable_p (st
))
1577 (O_RDONLY
| O_BINARY
1578 | (is_dir
? O_DIRECTORY
| O_NONBLOCK
: 0)
1579 | (atime_preserve_option
== system_atime_preserve
1584 file_removed_diag (p
, top_level
, open_diag
);
1591 const char *tag_file_name
;
1592 ensure_slash (&st
->orig_file_name
);
1593 ensure_slash (&st
->file_name
);
1595 if (check_exclusion_tags (st
->orig_file_name
, &tag_file_name
)
1596 == exclusion_tag_all
)
1598 exclusion_tag_warning (st
->orig_file_name
, tag_file_name
,
1599 _("directory not dumped"));
1603 ok
= dump_dir (fd
, st
, top_level
, parent_device
);
1605 /* dump_dir consumes FD if successful. */
1611 enum dump_status status
;
1613 if (fd
!= -1 && sparse_option
&& ST_IS_SPARSE (st
->stat
))
1615 status
= sparse_dump_file (fd
, st
);
1616 if (status
== dump_status_not_implemented
)
1617 status
= dump_regular_file (fd
, st
);
1620 status
= dump_regular_file (fd
, st
);
1624 case dump_status_ok
:
1625 case dump_status_short
:
1627 file_count_links (st
);
1630 case dump_status_fail
:
1633 case dump_status_not_implemented
:
1637 ok
= status
== dump_status_ok
;
1642 /* If possible, reopen a directory if we are preserving
1643 atimes, so that we can set just the atime on systems with
1645 if (fd
< 0 && is_dir
1646 && atime_preserve_option
== replace_atime_preserve
)
1647 fd
= open (p
, O_RDONLY
| O_BINARY
| O_DIRECTORY
| O_NONBLOCK
);
1650 ? deref_stat (dereference_option
, p
, &final_stat
)
1651 : fstat (fd
, &final_stat
))
1654 file_removed_diag (p
, top_level
, stat_diag
);
1661 if ((timespec_cmp (get_stat_ctime (&final_stat
), original_ctime
) != 0
1662 /* Original ctime will change if the file is a directory and
1663 --remove-files is given */
1664 && !(remove_files_option
&& is_dir
))
1665 || original_size
< final_stat
.st_size
)
1667 WARNOPT (WARN_FILE_CHANGED
,
1668 (0, 0, _("%s: file changed as we read it"),
1669 quotearg_colon (p
)));
1670 set_exit_status (TAREXIT_DIFFERS
);
1672 else if (atime_preserve_option
== replace_atime_preserve
1673 && set_file_atime (fd
, p
, restore_times
) != 0)
1677 if (0 <= fd
&& close (fd
) != 0)
1683 if (ok
&& remove_files_option
)
1684 queue_deferred_unlink (p
, is_dir
);
1688 #ifdef HAVE_READLINK
1689 else if (S_ISLNK (st
->stat
.st_mode
))
1693 size_t linklen
= st
->stat
.st_size
;
1694 if (linklen
!= st
->stat
.st_size
|| linklen
+ 1 == 0)
1696 buffer
= (char *) alloca (linklen
+ 1);
1697 size
= readlink (p
, buffer
, linklen
+ 1);
1700 file_removed_diag (p
, top_level
, readlink_diag
);
1703 buffer
[size
] = '\0';
1704 assign_string (&st
->link_name
, buffer
);
1705 transform_name (&st
->link_name
, XFORM_SYMLINK
);
1706 if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
) < size
)
1707 write_long_link (st
);
1709 block_ordinal
= current_block_ordinal ();
1710 st
->stat
.st_size
= 0; /* force 0 size on symlink */
1711 header
= start_header (st
);
1714 tar_copy_str (header
->header
.linkname
, st
->link_name
, NAME_FIELD_SIZE
);
1715 header
->header
.typeflag
= SYMTYPE
;
1716 finish_header (st
, header
, block_ordinal
);
1717 /* nothing more to do to it */
1719 if (remove_files_option
)
1720 queue_deferred_unlink (p
, false);
1722 file_count_links (st
);
1726 else if (S_ISCHR (st
->stat
.st_mode
))
1728 else if (S_ISBLK (st
->stat
.st_mode
))
1730 else if (S_ISFIFO (st
->stat
.st_mode
))
1732 else if (S_ISSOCK (st
->stat
.st_mode
))
1734 WARNOPT (WARN_FILE_IGNORED
,
1735 (0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1738 else if (S_ISDOOR (st
->stat
.st_mode
))
1740 WARNOPT (WARN_FILE_IGNORED
,
1741 (0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1746 unknown_file_error (p
);
1750 if (archive_format
== V7_FORMAT
)
1752 unknown_file_error (p
);
1756 block_ordinal
= current_block_ordinal ();
1757 st
->stat
.st_size
= 0; /* force 0 size */
1758 header
= start_header (st
);
1761 header
->header
.typeflag
= type
;
1763 if (type
!= FIFOTYPE
)
1765 MAJOR_TO_CHARS (major (st
->stat
.st_rdev
),
1766 header
->header
.devmajor
);
1767 MINOR_TO_CHARS (minor (st
->stat
.st_rdev
),
1768 header
->header
.devminor
);
1771 finish_header (st
, header
, block_ordinal
);
1772 if (remove_files_option
)
1773 queue_deferred_unlink (p
, false);
1777 dump_file (const char *p
, bool top_level
, dev_t parent_device
)
1779 struct tar_stat_info st
;
1780 tar_stat_init (&st
);
1781 dump_file0 (&st
, p
, top_level
, parent_device
);
1782 if (listed_incremental_option
)
1783 update_parent_directory (p
);
1784 tar_stat_destroy (&st
);