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
)
521 union block
*header
= find_next_block ();
523 memset (header
->buffer
, 0, sizeof (union block
));
525 tar_name_copy_str (header
->header
.name
, name
, NAME_FIELD_SIZE
);
526 OFF_TO_CHARS (size
, header
->header
.size
);
529 TIME_TO_CHARS (t
, header
->header
.mtime
);
530 MODE_TO_CHARS (S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
, header
->header
.mode
);
531 UID_TO_CHARS (getuid (), header
->header
.uid
);
532 GID_TO_CHARS (getgid (), header
->header
.gid
);
533 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
534 MINOR_TO_CHARS (0, header
->header
.devminor
);
535 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
536 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
540 /* Create a new header and store there at most NAME_FIELD_SIZE bytes of
544 write_short_name (struct tar_stat_info
*st
)
546 union block
*header
= find_next_block ();
547 memset (header
->buffer
, 0, sizeof (union block
));
548 tar_name_copy_str (header
->header
.name
, st
->file_name
, NAME_FIELD_SIZE
);
552 #define FILL(field,byte) do { \
553 memset(field, byte, sizeof(field)-1); \
554 (field)[sizeof(field)-1] = 0; \
557 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. */
559 write_gnu_long_link (struct tar_stat_info
*st
, const char *p
, char type
)
561 size_t size
= strlen (p
) + 1;
566 header
= start_private_header ("././@LongLink", size
);
567 FILL(header
->header
.mtime
, '0');
568 FILL(header
->header
.mode
, '0');
569 FILL(header
->header
.uid
, '0');
570 FILL(header
->header
.gid
, '0');
571 FILL(header
->header
.devmajor
, 0);
572 FILL(header
->header
.devminor
, 0);
573 uid_to_uname (0, &tmpname
);
574 UNAME_TO_CHARS (tmpname
, header
->header
.uname
);
576 gid_to_gname (0, &tmpname
);
577 GNAME_TO_CHARS (tmpname
, header
->header
.gname
);
580 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
581 header
->header
.typeflag
= type
;
582 finish_header (st
, header
, -1);
584 header
= find_next_block ();
586 bufsize
= available_space_after (header
);
588 while (bufsize
< size
)
590 memcpy (header
->buffer
, p
, bufsize
);
593 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
594 header
= find_next_block ();
595 bufsize
= available_space_after (header
);
597 memcpy (header
->buffer
, p
, size
);
598 memset (header
->buffer
+ size
, 0, bufsize
- size
);
599 set_next_block_after (header
+ (size
- 1) / BLOCKSIZE
);
603 split_long_name (const char *name
, size_t length
)
607 if (length
> PREFIX_FIELD_SIZE
)
608 length
= PREFIX_FIELD_SIZE
+ 1;
609 for (i
= length
- 1; i
> 0; i
--)
610 if (ISSLASH (name
[i
]))
616 write_ustar_long_name (const char *name
)
618 size_t length
= strlen (name
);
622 if (length
> PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1)
624 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
625 quotearg_colon (name
),
626 PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1));
630 i
= split_long_name (name
, length
);
631 if (i
== 0 || length
- i
- 1 > NAME_FIELD_SIZE
)
634 _("%s: file name is too long (cannot be split); not dumped"),
635 quotearg_colon (name
)));
639 header
= find_next_block ();
640 memset (header
->buffer
, 0, sizeof (header
->buffer
));
641 memcpy (header
->header
.prefix
, name
, i
);
642 memcpy (header
->header
.name
, name
+ i
+ 1, length
- i
- 1);
647 /* Write a long link name, depending on the current archive format */
649 write_long_link (struct tar_stat_info
*st
)
651 switch (archive_format
)
654 xheader_store ("linkpath", st
, NULL
);
657 case V7_FORMAT
: /* old V7 tar format */
661 _("%s: link name is too long; not dumped"),
662 quotearg_colon (st
->link_name
)));
667 write_gnu_long_link (st
, st
->link_name
, GNUTYPE_LONGLINK
);
676 write_long_name (struct tar_stat_info
*st
)
678 switch (archive_format
)
681 xheader_store ("path", st
, NULL
);
685 if (strlen (st
->file_name
) > NAME_FIELD_SIZE
-1)
687 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
688 quotearg_colon (st
->file_name
),
689 NAME_FIELD_SIZE
- 1));
696 return write_ustar_long_name (st
->file_name
);
700 write_gnu_long_link (st
, st
->file_name
, GNUTYPE_LONGNAME
);
706 return write_short_name (st
);
710 write_extended (bool global
, struct tar_stat_info
*st
, union block
*old_header
)
712 union block
*header
, hp
;
716 if (st
->xhdr
.buffer
|| st
->xhdr
.stk
== NULL
)
719 xheader_finish (&st
->xhdr
);
720 memcpy (hp
.buffer
, old_header
, sizeof (hp
));
724 p
= xheader_ghdr_name ();
729 p
= xheader_xhdr_name (st
);
731 xheader_write (type
, p
, &st
->xhdr
);
733 header
= find_next_block ();
734 memcpy (header
, &hp
.buffer
, sizeof (hp
.buffer
));
739 write_header_name (struct tar_stat_info
*st
)
741 if (archive_format
== POSIX_FORMAT
&& !string_ascii_p (st
->file_name
))
743 xheader_store ("path", st
, NULL
);
744 return write_short_name (st
);
746 else if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
)
747 < strlen (st
->file_name
))
748 return write_long_name (st
);
750 return write_short_name (st
);
754 /* Header handling. */
756 /* Make a header block for the file whose stat info is st,
757 and return its address. */
760 start_header (struct tar_stat_info
*st
)
764 header
= write_header_name (st
);
768 /* Override some stat fields, if requested to do so. */
770 if (owner_option
!= (uid_t
) -1)
771 st
->stat
.st_uid
= owner_option
;
772 if (group_option
!= (gid_t
) -1)
773 st
->stat
.st_gid
= group_option
;
776 ((st
->stat
.st_mode
& ~MODE_ALL
)
777 | mode_adjust (st
->stat
.st_mode
, S_ISDIR (st
->stat
.st_mode
) != 0,
778 initial_umask
, mode_option
, NULL
));
780 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
781 for a few tars and came up with the following interoperability
785 1 2 3 4 5 6 7 8 9 READER
786 . . . . . . . . . 1 = SunOS 4.2 tar
787 # . . # # . . # # 2 = NEC SVR4.0.2 tar
788 . . . # # . . # . 3 = Solaris 2.1 tar
789 . . . . . . . . . 4 = GNU tar 1.11.1
790 . . . . . . . . . 5 = HP-UX 8.07 tar
791 . . . . . . . . . 6 = Ultrix 4.1
792 . . . . . . . . . 7 = AIX 3.2
793 . . . . . . . . . 8 = Hitachi HI-UX 1.03
794 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
797 # = ``impossible file type''
799 The following mask for old archive removes the `#'s in column 4
800 above, thus making GNU tar both a universal donor and a universal
801 acceptor for Paul's test. */
803 if (archive_format
== V7_FORMAT
|| archive_format
== USTAR_FORMAT
)
804 MODE_TO_CHARS (st
->stat
.st_mode
& MODE_ALL
, header
->header
.mode
);
806 MODE_TO_CHARS (st
->stat
.st_mode
, header
->header
.mode
);
809 uid_t uid
= st
->stat
.st_uid
;
810 if (archive_format
== POSIX_FORMAT
811 && MAX_OCTAL_VAL (header
->header
.uid
) < uid
)
813 xheader_store ("uid", st
, NULL
);
816 if (!UID_TO_CHARS (uid
, header
->header
.uid
))
821 gid_t gid
= st
->stat
.st_gid
;
822 if (archive_format
== POSIX_FORMAT
823 && MAX_OCTAL_VAL (header
->header
.gid
) < gid
)
825 xheader_store ("gid", st
, NULL
);
828 if (!GID_TO_CHARS (gid
, header
->header
.gid
))
833 off_t size
= st
->stat
.st_size
;
834 if (archive_format
== POSIX_FORMAT
835 && MAX_OCTAL_VAL (header
->header
.size
) < size
)
837 xheader_store ("size", st
, NULL
);
840 if (!OFF_TO_CHARS (size
, header
->header
.size
))
845 struct timespec mtime
= set_mtime_option
? mtime_option
: st
->mtime
;
846 if (archive_format
== POSIX_FORMAT
)
848 if (MAX_OCTAL_VAL (header
->header
.mtime
) < mtime
.tv_sec
849 || mtime
.tv_nsec
!= 0)
850 xheader_store ("mtime", st
, &mtime
);
851 if (MAX_OCTAL_VAL (header
->header
.mtime
) < mtime
.tv_sec
)
854 if (!TIME_TO_CHARS (mtime
.tv_sec
, header
->header
.mtime
))
859 if (S_ISCHR (st
->stat
.st_mode
)
860 || S_ISBLK (st
->stat
.st_mode
))
862 major_t devmajor
= major (st
->stat
.st_rdev
);
863 minor_t devminor
= minor (st
->stat
.st_rdev
);
865 if (archive_format
== POSIX_FORMAT
866 && MAX_OCTAL_VAL (header
->header
.devmajor
) < devmajor
)
868 xheader_store ("devmajor", st
, NULL
);
871 if (!MAJOR_TO_CHARS (devmajor
, header
->header
.devmajor
))
874 if (archive_format
== POSIX_FORMAT
875 && MAX_OCTAL_VAL (header
->header
.devminor
) < devminor
)
877 xheader_store ("devminor", st
, NULL
);
880 if (!MINOR_TO_CHARS (devminor
, header
->header
.devminor
))
883 else if (archive_format
!= GNU_FORMAT
&& archive_format
!= OLDGNU_FORMAT
)
885 if (!(MAJOR_TO_CHARS (0, header
->header
.devmajor
)
886 && MINOR_TO_CHARS (0, header
->header
.devminor
)))
890 if (archive_format
== POSIX_FORMAT
)
892 xheader_store ("atime", st
, NULL
);
893 xheader_store ("ctime", st
, NULL
);
895 else if (incremental_option
)
896 if (archive_format
== OLDGNU_FORMAT
|| archive_format
== GNU_FORMAT
)
898 TIME_TO_CHARS (st
->atime
.tv_sec
, header
->oldgnu_header
.atime
);
899 TIME_TO_CHARS (st
->ctime
.tv_sec
, header
->oldgnu_header
.ctime
);
902 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
904 switch (archive_format
)
910 case GNU_FORMAT
: /*FIXME?*/
911 /* Overwrite header->header.magic and header.version in one blow. */
912 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
917 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
918 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
925 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
927 /* header->header.[ug]name are left as the empty string. */
931 uid_to_uname (st
->stat
.st_uid
, &st
->uname
);
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
);
951 simple_finish_header (union block
*header
)
957 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
961 for (i
= sizeof *header
; i
-- != 0; )
962 /* We can't use unsigned char here because of old compilers, e.g. V7. */
965 /* Fill in the checksum field. It's formatted differently from the
966 other fields: it has [6] digits, a null, then a space -- rather than
967 digits, then a null. We use to_chars.
968 The final space is already there, from
969 checksumming, and to_chars doesn't modify it.
971 This is a fast way to do:
973 sprintf(header->header.chksum, "%6o", sum); */
975 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
977 set_next_block_after (header
);
980 /* Finish off a filled-in header block and write it out. We also
981 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
982 is not negative, is the block ordinal of the first record for this
983 file, which may be a preceding long name or long link record. */
985 finish_header (struct tar_stat_info
*st
,
986 union block
*header
, off_t block_ordinal
)
988 /* Note: It is important to do this before the call to write_extended(),
989 so that the actual ustar header is printed */
991 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
992 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
993 && header
->header
.typeflag
!= XHDTYPE
994 && header
->header
.typeflag
!= XGLTYPE
)
996 /* These globals are parameters to print_header, sigh. */
998 current_header
= header
;
999 current_format
= archive_format
;
1000 print_header (st
, block_ordinal
);
1003 header
= write_extended (false, st
, header
);
1004 simple_finish_header (header
);
1009 pad_archive (off_t size_left
)
1012 while (size_left
> 0)
1014 mv_size_left (size_left
);
1015 blk
= find_next_block ();
1016 memset (blk
->buffer
, 0, BLOCKSIZE
);
1017 set_next_block_after (blk
);
1018 size_left
-= BLOCKSIZE
;
1022 static enum dump_status
1023 dump_regular_file (int fd
, struct tar_stat_info
*st
)
1025 off_t size_left
= st
->stat
.st_size
;
1026 off_t block_ordinal
;
1029 block_ordinal
= current_block_ordinal ();
1030 blk
= start_header (st
);
1032 return dump_status_fail
;
1034 /* Mark contiguous files, if we support them. */
1035 if (archive_format
!= V7_FORMAT
&& S_ISCTG (st
->stat
.st_mode
))
1036 blk
->header
.typeflag
= CONTTYPE
;
1038 finish_header (st
, blk
, block_ordinal
);
1041 while (size_left
> 0)
1043 size_t bufsize
, count
;
1045 mv_size_left (size_left
);
1047 blk
= find_next_block ();
1049 bufsize
= available_space_after (blk
);
1051 if (size_left
< bufsize
)
1053 /* Last read -- zero out area beyond. */
1054 bufsize
= size_left
;
1055 count
= bufsize
% BLOCKSIZE
;
1057 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
1060 count
= (fd
< 0) ? bufsize
: safe_read (fd
, blk
->buffer
, bufsize
);
1061 if (count
== SAFE_READ_ERROR
)
1063 read_diag_details (st
->orig_file_name
,
1064 st
->stat
.st_size
- size_left
, bufsize
);
1065 pad_archive (size_left
);
1066 return dump_status_short
;
1069 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
1071 if (count
!= bufsize
)
1073 char buf
[UINTMAX_STRSIZE_BOUND
];
1074 memset (blk
->buffer
+ count
, 0, bufsize
- count
);
1075 WARNOPT (WARN_FILE_SHRANK
,
1077 ngettext ("%s: File shrank by %s byte; padding with zeros",
1078 "%s: File shrank by %s bytes; padding with zeros",
1080 quotearg_colon (st
->orig_file_name
),
1081 STRINGIFY_BIGINT (size_left
, buf
)));
1082 if (! ignore_failed_read_option
)
1083 set_exit_status (TAREXIT_DIFFERS
);
1084 pad_archive (size_left
- (bufsize
- count
));
1085 return dump_status_short
;
1088 return dump_status_ok
;
1093 dump_dir0 (char *directory
,
1094 struct tar_stat_info
*st
, bool top_level
, dev_t parent_device
)
1096 dev_t our_device
= st
->stat
.st_dev
;
1097 const char *tag_file_name
;
1099 if (!is_avoided_name (st
->orig_file_name
))
1101 union block
*blk
= NULL
;
1102 off_t block_ordinal
= current_block_ordinal ();
1103 st
->stat
.st_size
= 0; /* force 0 size on dir */
1105 blk
= start_header (st
);
1109 if (incremental_option
&& archive_format
!= POSIX_FORMAT
)
1110 blk
->header
.typeflag
= GNUTYPE_DUMPDIR
;
1111 else /* if (standard_option) */
1112 blk
->header
.typeflag
= DIRTYPE
;
1114 /* If we're gnudumping, we aren't done yet so don't close it. */
1116 if (!incremental_option
)
1117 finish_header (st
, blk
, block_ordinal
);
1118 else if (gnu_list_name
->directory
)
1120 if (archive_format
== POSIX_FORMAT
)
1122 xheader_store ("GNU.dumpdir", st
,
1123 safe_directory_contents (gnu_list_name
->directory
));
1124 finish_header (st
, blk
, block_ordinal
);
1132 const char *buffer
, *p_buffer
;
1134 block_ordinal
= current_block_ordinal ();
1135 buffer
= safe_directory_contents (gnu_list_name
->directory
);
1136 totsize
= dumpdir_size (buffer
);
1137 OFF_TO_CHARS (totsize
, blk
->header
.size
);
1138 finish_header (st
, blk
, block_ordinal
);
1140 size_left
= totsize
;
1143 mv_total_size (totsize
);
1144 while (size_left
> 0)
1146 mv_size_left (size_left
);
1147 blk
= find_next_block ();
1148 bufsize
= available_space_after (blk
);
1149 if (size_left
< bufsize
)
1151 bufsize
= size_left
;
1152 count
= bufsize
% BLOCKSIZE
;
1154 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
1156 memcpy (blk
->buffer
, p_buffer
, bufsize
);
1157 size_left
-= bufsize
;
1158 p_buffer
+= bufsize
;
1159 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
1167 if (!recursion_option
)
1170 if (one_file_system_option
1172 && parent_device
!= st
->stat
.st_dev
)
1177 _("%s: file is on a different filesystem; not dumped"),
1178 quotearg_colon (st
->orig_file_name
)));
1185 switch (check_exclusion_tags (st
->orig_file_name
, &tag_file_name
))
1187 case exclusion_tag_all
:
1188 /* Handled in dump_file0 */
1191 case exclusion_tag_none
:
1197 name_buf
= xstrdup (st
->orig_file_name
);
1198 name_size
= name_len
= strlen (name_buf
);
1200 /* Now output all the files in the directory. */
1201 /* FIXME: Should speed this up by cd-ing into the dir. */
1202 for (entry
= directory
; (entry_len
= strlen (entry
)) != 0;
1203 entry
+= entry_len
+ 1)
1205 if (name_size
< name_len
+ entry_len
)
1207 name_size
= name_len
+ entry_len
;
1208 name_buf
= xrealloc (name_buf
, name_size
+ 1);
1210 strcpy (name_buf
+ name_len
, entry
);
1211 if (!excluded_name (name_buf
))
1212 dump_file (name_buf
, false, our_device
);
1219 case exclusion_tag_contents
:
1220 exclusion_tag_warning (st
->orig_file_name
, tag_file_name
,
1221 _("contents not dumped"));
1222 name_size
= strlen (st
->orig_file_name
) + strlen (tag_file_name
) + 1;
1223 name_buf
= xmalloc (name_size
);
1224 strcpy (name_buf
, st
->orig_file_name
);
1225 strcat (name_buf
, tag_file_name
);
1226 dump_file (name_buf
, false, our_device
);
1230 case exclusion_tag_under
:
1231 exclusion_tag_warning (st
->orig_file_name
, tag_file_name
,
1232 _("contents not dumped"));
1238 /* Ensure exactly one trailing slash. */
1240 ensure_slash (char **pstr
)
1242 size_t len
= strlen (*pstr
);
1243 while (len
>= 1 && ISSLASH ((*pstr
)[len
- 1]))
1245 if (!ISSLASH ((*pstr
)[len
]))
1246 *pstr
= xrealloc (*pstr
, len
+ 2);
1247 (*pstr
)[len
++] = '/';
1248 (*pstr
)[len
] = '\0';
1252 dump_dir (int fd
, struct tar_stat_info
*st
, bool top_level
,
1253 dev_t parent_device
)
1255 char *directory
= fdsavedir (fd
);
1258 savedir_diag (st
->orig_file_name
);
1262 dump_dir0 (directory
, st
, top_level
, parent_device
);
1269 /* Main functions of this module. */
1272 create_archive (void)
1274 struct name
const *p
;
1276 open_archive (ACCESS_WRITE
);
1277 buffer_write_global_xheader ();
1279 if (incremental_option
)
1281 size_t buffer_size
= 1000;
1282 char *buffer
= xmalloc (buffer_size
);
1285 collect_and_sort_names ();
1287 while ((p
= name_from_list ()) != NULL
)
1288 if (!excluded_name (p
->name
))
1289 dump_file (p
->name
, p
->cmdline
, (dev_t
) 0);
1292 while ((p
= name_from_list ()) != NULL
)
1293 if (!excluded_name (p
->name
))
1295 size_t plen
= strlen (p
->name
);
1296 if (buffer_size
<= plen
)
1298 while ((buffer_size
*= 2) <= plen
)
1300 buffer
= xrealloc (buffer
, buffer_size
);
1302 memcpy (buffer
, p
->name
, plen
);
1303 if (! ISSLASH (buffer
[plen
- 1]))
1304 buffer
[plen
++] = DIRECTORY_SEPARATOR
;
1305 q
= directory_contents (gnu_list_name
->directory
);
1309 size_t qlen
= strlen (q
);
1312 if (buffer_size
< plen
+ qlen
)
1314 while ((buffer_size
*=2 ) < plen
+ qlen
)
1316 buffer
= xrealloc (buffer
, buffer_size
);
1318 strcpy (buffer
+ plen
, q
+ 1);
1319 dump_file (buffer
, false, (dev_t
) 0);
1329 while ((name
= name_next (1)) != NULL
)
1330 if (!excluded_name (name
))
1331 dump_file (name
, true, (dev_t
) 0);
1337 if (listed_incremental_option
)
1338 write_directory_file ();
1342 /* Calculate the hash of a link. */
1344 hash_link (void const *entry
, size_t n_buckets
)
1346 struct link
const *l
= entry
;
1347 uintmax_t num
= l
->dev
^ l
->ino
;
1348 return num
% n_buckets
;
1351 /* Compare two links for equality. */
1353 compare_links (void const *entry1
, void const *entry2
)
1355 struct link
const *link1
= entry1
;
1356 struct link
const *link2
= entry2
;
1357 return ((link1
->dev
^ link2
->dev
) | (link1
->ino
^ link2
->ino
)) == 0;
1361 unknown_file_error (char const *p
)
1363 WARNOPT (WARN_FILE_IGNORED
,
1364 (0, 0, _("%s: Unknown file type; file ignored"),
1365 quotearg_colon (p
)));
1366 if (!ignore_failed_read_option
)
1367 set_exit_status (TAREXIT_FAILURE
);
1371 /* Handling of hard links */
1373 /* Table of all non-directories that we've written so far. Any time
1374 we see another, we check the table and avoid dumping the data
1375 again if we've done it once already. */
1376 static Hash_table
*link_table
;
1378 /* Try to dump stat as a hard link to another file in the archive.
1379 Return true if successful. */
1381 dump_hard_link (struct tar_stat_info
*st
)
1383 if (link_table
&& (st
->stat
.st_nlink
> 1 || remove_files_option
))
1386 struct link
*duplicate
;
1387 off_t block_ordinal
;
1390 lp
.ino
= st
->stat
.st_ino
;
1391 lp
.dev
= st
->stat
.st_dev
;
1393 if ((duplicate
= hash_lookup (link_table
, &lp
)))
1395 /* We found a link. */
1396 char const *link_name
= safer_name_suffix (duplicate
->name
, true,
1397 absolute_names_option
);
1401 block_ordinal
= current_block_ordinal ();
1402 assign_string (&st
->link_name
, link_name
);
1403 if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
)
1404 < strlen (link_name
))
1405 write_long_link (st
);
1407 st
->stat
.st_size
= 0;
1408 blk
= start_header (st
);
1411 tar_copy_str (blk
->header
.linkname
, link_name
, NAME_FIELD_SIZE
);
1413 blk
->header
.typeflag
= LNKTYPE
;
1414 finish_header (st
, blk
, block_ordinal
);
1416 if (remove_files_option
&& unlink (st
->orig_file_name
) != 0)
1417 unlink_error (st
->orig_file_name
);
1426 file_count_links (struct tar_stat_info
*st
)
1428 if (hard_dereference_option
)
1430 if (st
->stat
.st_nlink
> 1)
1432 struct link
*duplicate
;
1433 char *linkname
= NULL
;
1436 assign_string (&linkname
, st
->orig_file_name
);
1437 transform_name (&linkname
, XFORM_LINK
);
1439 lp
= xmalloc (offsetof (struct link
, name
)
1440 + strlen (linkname
) + 1);
1441 lp
->ino
= st
->stat
.st_ino
;
1442 lp
->dev
= st
->stat
.st_dev
;
1443 lp
->nlink
= st
->stat
.st_nlink
;
1444 strcpy (lp
->name
, linkname
);
1448 || (link_table
= hash_initialize (0, 0, hash_link
,
1450 && (duplicate
= hash_insert (link_table
, lp
))))
1453 if (duplicate
!= lp
)
1459 /* For each dumped file, check if all its links were dumped. Emit
1460 warnings if it is not so. */
1469 for (lp
= hash_get_first (link_table
); lp
;
1470 lp
= hash_get_next (link_table
, lp
))
1474 WARN ((0, 0, _("Missing links to %s."), quote (lp
->name
)));
1479 /* Dump a single file, recursing on directories. P is the file name
1480 to dump. TOP_LEVEL tells whether this is a top-level call; zero
1481 means no, positive means yes, and negative means the top level
1482 of an incremental dump. PARENT_DEVICE is the device of P's
1483 parent directory; it is examined only if TOP_LEVEL is zero. */
1485 /* FIXME: One should make sure that for *every* path leading to setting
1486 exit_status to failure, a clear diagnostic has been issued. */
1489 dump_file0 (struct tar_stat_info
*st
, const char *p
,
1490 bool top_level
, dev_t parent_device
)
1492 union block
*header
;
1494 off_t original_size
;
1495 struct timespec original_ctime
;
1496 struct timespec restore_times
[2];
1497 off_t block_ordinal
= -1;
1500 if (interactive_option
&& !confirm ("add", p
))
1503 assign_string (&st
->orig_file_name
, p
);
1504 assign_string (&st
->file_name
,
1505 safer_name_suffix (p
, false, absolute_names_option
));
1507 transform_name (&st
->file_name
, XFORM_REGFILE
);
1509 if (deref_stat (dereference_option
, p
, &st
->stat
) != 0)
1511 file_removed_diag (p
, top_level
, stat_diag
);
1514 st
->archive_file_size
= original_size
= st
->stat
.st_size
;
1515 st
->atime
= restore_times
[0] = get_stat_atime (&st
->stat
);
1516 st
->mtime
= restore_times
[1] = get_stat_mtime (&st
->stat
);
1517 st
->ctime
= original_ctime
= get_stat_ctime (&st
->stat
);
1520 if (S_ISHIDDEN (st
->stat
.st_mode
))
1522 char *new = (char *) alloca (strlen (p
) + 2);
1532 /* See if we want only new files, and check if this one is too old to
1535 This check is omitted if incremental_option is set *and* the
1536 requested file is not explicitely listed in the command line. */
1538 if (!(incremental_option
&& !is_individual_file (p
))
1539 && !S_ISDIR (st
->stat
.st_mode
)
1540 && OLDER_TAR_STAT_TIME (*st
, m
)
1541 && (!after_date_option
|| OLDER_TAR_STAT_TIME (*st
, c
)))
1543 if (!incremental_option
&& verbose_option
)
1544 WARNOPT (WARN_FILE_UNCHANGED
,
1545 (0, 0, _("%s: file is unchanged; not dumped"),
1546 quotearg_colon (p
)));
1550 /* See if we are trying to dump the archive. */
1551 if (sys_file_is_archive (st
))
1553 WARNOPT (WARN_IGNORE_ARCHIVE
,
1554 (0, 0, _("%s: file is the archive; not dumped"),
1555 quotearg_colon (p
)));
1559 if (is_avoided_name (p
))
1562 is_dir
= S_ISDIR (st
->stat
.st_mode
) != 0;
1564 if (!is_dir
&& dump_hard_link (st
))
1567 if (is_dir
|| S_ISREG (st
->stat
.st_mode
) || S_ISCTG (st
->stat
.st_mode
))
1571 struct stat final_stat
;
1573 if (is_dir
|| file_dumpable_p (st
))
1576 (O_RDONLY
| O_BINARY
1577 | (is_dir
? O_DIRECTORY
| O_NONBLOCK
: 0)
1578 | (atime_preserve_option
== system_atime_preserve
1583 file_removed_diag (p
, top_level
, open_diag
);
1590 const char *tag_file_name
;
1591 ensure_slash (&st
->orig_file_name
);
1592 ensure_slash (&st
->file_name
);
1594 if (check_exclusion_tags (st
->orig_file_name
, &tag_file_name
)
1595 == exclusion_tag_all
)
1597 exclusion_tag_warning (st
->orig_file_name
, tag_file_name
,
1598 _("directory not dumped"));
1602 ok
= dump_dir (fd
, st
, top_level
, parent_device
);
1604 /* dump_dir consumes FD if successful. */
1610 enum dump_status status
;
1612 if (fd
!= -1 && sparse_option
&& ST_IS_SPARSE (st
->stat
))
1614 status
= sparse_dump_file (fd
, st
);
1615 if (status
== dump_status_not_implemented
)
1616 status
= dump_regular_file (fd
, st
);
1619 status
= dump_regular_file (fd
, st
);
1623 case dump_status_ok
:
1624 case dump_status_short
:
1626 file_count_links (st
);
1629 case dump_status_fail
:
1632 case dump_status_not_implemented
:
1636 ok
= status
== dump_status_ok
;
1641 /* If possible, reopen a directory if we are preserving
1642 atimes, so that we can set just the atime on systems with
1644 if (fd
< 0 && is_dir
1645 && atime_preserve_option
== replace_atime_preserve
)
1646 fd
= open (p
, O_RDONLY
| O_BINARY
| O_DIRECTORY
| O_NONBLOCK
);
1649 ? deref_stat (dereference_option
, p
, &final_stat
)
1650 : fstat (fd
, &final_stat
))
1653 file_removed_diag (p
, top_level
, stat_diag
);
1660 if ((timespec_cmp (get_stat_ctime (&final_stat
), original_ctime
) != 0
1661 /* Original ctime will change if the file is a directory and
1662 --remove-files is given */
1663 && !(remove_files_option
&& is_dir
))
1664 || original_size
< final_stat
.st_size
)
1666 WARNOPT (WARN_FILE_CHANGED
,
1667 (0, 0, _("%s: file changed as we read it"),
1668 quotearg_colon (p
)));
1669 set_exit_status (TAREXIT_DIFFERS
);
1671 else if (atime_preserve_option
== replace_atime_preserve
1672 && set_file_atime (fd
, p
, restore_times
) != 0)
1676 if (0 <= fd
&& close (fd
) != 0)
1682 if (ok
&& remove_files_option
)
1686 if (rmdir (p
) != 0 && errno
!= ENOTEMPTY
)
1691 if (unlink (p
) != 0)
1698 #ifdef HAVE_READLINK
1699 else if (S_ISLNK (st
->stat
.st_mode
))
1703 size_t linklen
= st
->stat
.st_size
;
1704 if (linklen
!= st
->stat
.st_size
|| linklen
+ 1 == 0)
1706 buffer
= (char *) alloca (linklen
+ 1);
1707 size
= readlink (p
, buffer
, linklen
+ 1);
1710 file_removed_diag (p
, top_level
, readlink_diag
);
1713 buffer
[size
] = '\0';
1714 assign_string (&st
->link_name
, buffer
);
1715 transform_name (&st
->link_name
, XFORM_SYMLINK
);
1716 if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
) < size
)
1717 write_long_link (st
);
1719 block_ordinal
= current_block_ordinal ();
1720 st
->stat
.st_size
= 0; /* force 0 size on symlink */
1721 header
= start_header (st
);
1724 tar_copy_str (header
->header
.linkname
, st
->link_name
, NAME_FIELD_SIZE
);
1725 header
->header
.typeflag
= SYMTYPE
;
1726 finish_header (st
, header
, block_ordinal
);
1727 /* nothing more to do to it */
1729 if (remove_files_option
)
1731 if (unlink (p
) == -1)
1734 file_count_links (st
);
1738 else if (S_ISCHR (st
->stat
.st_mode
))
1740 else if (S_ISBLK (st
->stat
.st_mode
))
1742 else if (S_ISFIFO (st
->stat
.st_mode
))
1744 else if (S_ISSOCK (st
->stat
.st_mode
))
1746 WARNOPT (WARN_FILE_IGNORED
,
1747 (0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1750 else if (S_ISDOOR (st
->stat
.st_mode
))
1752 WARNOPT (WARN_FILE_IGNORED
,
1753 (0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1758 unknown_file_error (p
);
1762 if (archive_format
== V7_FORMAT
)
1764 unknown_file_error (p
);
1768 block_ordinal
= current_block_ordinal ();
1769 st
->stat
.st_size
= 0; /* force 0 size */
1770 header
= start_header (st
);
1773 header
->header
.typeflag
= type
;
1775 if (type
!= FIFOTYPE
)
1777 MAJOR_TO_CHARS (major (st
->stat
.st_rdev
),
1778 header
->header
.devmajor
);
1779 MINOR_TO_CHARS (minor (st
->stat
.st_rdev
),
1780 header
->header
.devminor
);
1783 finish_header (st
, header
, block_ordinal
);
1784 if (remove_files_option
)
1786 if (unlink (p
) == -1)
1792 dump_file (const char *p
, bool top_level
, dev_t parent_device
)
1794 struct tar_stat_info st
;
1795 tar_stat_init (&st
);
1796 dump_file0 (&st
, p
, top_level
, parent_device
);
1797 if (listed_incremental_option
)
1798 update_parent_directory (p
);
1799 tar_stat_destroy (&st
);