1 /* Create a tar archive.
3 Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
4 2003, 2004, 2005, 2006, 2007 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
,
67 _("%s: contains a cache directory tag %s; %s"),
68 quotearg_colon (dirname
),
69 quotearg_n (1, tagname
),
73 enum exclusion_tag_type
74 check_exclusion_tags (char *dirname
, const char **tag_file_name
)
77 static size_t tagsize
;
78 struct exclusion_tag
*tag
;
79 size_t dlen
= strlen (dirname
);
80 int addslash
= dirname
[dlen
-1] != '/';
83 for (tag
= exclusion_tags
; tag
; tag
= tag
->next
)
85 size_t size
= dlen
+ addslash
+ tag
->length
+ 1;
89 tagname
= xrealloc (tagname
, tagsize
);
94 strcpy (tagname
, dirname
);
95 nptr
= tagname
+ dlen
;
99 strcpy (nptr
, tag
->name
);
100 if (access (tagname
, F_OK
) == 0
101 && (!tag
->predicate
|| tag
->predicate (tagname
)))
104 *tag_file_name
= tag
->name
;
109 return exclusion_tag_none
;
112 /* Exclusion predicate to test if the named file (usually "CACHEDIR.TAG")
113 contains a valid header, as described at:
114 http://www.brynosaurus.com/cachedir
115 Applications can write this file into directories they create
116 for use as caches containing purely regenerable, non-precious data,
117 allowing us to avoid archiving them if --exclude-caches is specified. */
119 #define CACHEDIR_SIGNATURE "Signature: 8a477f597d28d172789f06886806bc55"
120 #define CACHEDIR_SIGNATURE_SIZE (sizeof CACHEDIR_SIGNATURE - 1)
123 cachedir_file_p (const char *name
)
125 bool tag_present
= false;
126 int fd
= open (name
, O_RDONLY
);
129 static char tagbuf
[CACHEDIR_SIGNATURE_SIZE
];
131 if (read (fd
, tagbuf
, CACHEDIR_SIGNATURE_SIZE
)
132 == CACHEDIR_SIGNATURE_SIZE
133 && memcmp (tagbuf
, CACHEDIR_SIGNATURE
, CACHEDIR_SIGNATURE_SIZE
) == 0)
142 /* The maximum uintmax_t value that can be represented with DIGITS digits,
143 assuming that each digit is BITS_PER_DIGIT wide. */
144 #define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
145 ((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
146 ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
149 /* The maximum uintmax_t value that can be represented with octal
150 digits and a trailing NUL in BUFFER. */
151 #define MAX_OCTAL_VAL(buffer) MAX_VAL_WITH_DIGITS (sizeof (buffer) - 1, LG_8)
153 /* Convert VALUE to an octal representation suitable for tar headers.
154 Output to buffer WHERE with size SIZE.
155 The result is undefined if SIZE is 0 or if VALUE is too large to fit. */
158 to_octal (uintmax_t value
, char *where
, size_t size
)
165 where
[--i
] = '0' + (v
& ((1 << LG_8
) - 1));
171 /* Copy at most LEN bytes from the string SRC to DST. Terminate with
172 NUL unless SRC is LEN or more bytes long. */
175 tar_copy_str (char *dst
, const char *src
, size_t len
)
178 for (i
= 0; i
< len
; i
++)
179 if (! (dst
[i
] = src
[i
]))
183 /* Same as tar_copy_str, but always terminate with NUL if using
187 tar_name_copy_str (char *dst
, const char *src
, size_t len
)
189 tar_copy_str (dst
, src
, len
);
190 if (archive_format
== OLDGNU_FORMAT
)
194 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
195 tar headers. NEGATIVE is 1 if VALUE was negative before being cast
196 to uintmax_t, 0 otherwise. Output to buffer WHERE with size SIZE.
197 The result is undefined if SIZE is 0 or if VALUE is too large to
201 to_base256 (int negative
, uintmax_t value
, char *where
, size_t size
)
204 uintmax_t propagated_sign_bits
=
205 ((uintmax_t) - negative
<< (CHAR_BIT
* sizeof v
- LG_256
));
210 where
[--i
] = v
& ((1 << LG_256
) - 1);
211 v
= propagated_sign_bits
| (v
>> LG_256
);
218 to_chars (int negative
, uintmax_t value
, size_t valsize
,
219 uintmax_t (*substitute
) (int *),
220 char *where
, size_t size
, const char *type
);
223 to_chars_subst (int negative
, int gnu_format
, uintmax_t value
, size_t valsize
,
224 uintmax_t (*substitute
) (int *),
225 char *where
, size_t size
, const char *type
)
227 uintmax_t maxval
= (gnu_format
228 ? MAX_VAL_WITH_DIGITS (size
- 1, LG_256
)
229 : MAX_VAL_WITH_DIGITS (size
- 1, LG_8
));
230 char valbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
231 char maxbuf
[UINTMAX_STRSIZE_BOUND
];
232 char minbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
233 char const *minval_string
;
234 char const *maxval_string
= STRINGIFY_BIGINT (maxval
, maxbuf
);
235 char const *value_string
;
239 uintmax_t m
= maxval
+ 1 ? maxval
+ 1 : maxval
/ 2 + 1;
240 char *p
= STRINGIFY_BIGINT (m
, minbuf
+ 1);
249 char *p
= STRINGIFY_BIGINT (- value
, valbuf
+ 1);
254 value_string
= STRINGIFY_BIGINT (value
, valbuf
);
259 uintmax_t sub
= substitute (&negsub
) & maxval
;
260 /* NOTE: This is one of the few places where GNU_FORMAT differs from
261 OLDGNU_FORMAT. The actual differences are:
263 1. In OLDGNU_FORMAT all strings in a tar header end in \0
264 2. Incremental archives use oldgnu_header.
266 Apart from this they are completely identical. */
267 uintmax_t s
= (negsub
&= archive_format
== GNU_FORMAT
) ? - sub
: sub
;
268 char subbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
269 char *sub_string
= STRINGIFY_BIGINT (s
, subbuf
+ 1);
272 WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
273 value_string
, type
, minval_string
, maxval_string
,
275 return to_chars (negsub
, s
, valsize
, 0, where
, size
, type
);
278 ERROR ((0, 0, _("value %s out of %s range %s..%s"),
279 value_string
, type
, minval_string
, maxval_string
));
283 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
284 external form, using SUBSTITUTE (...) if VALUE won't fit. Output
285 to buffer WHERE with size SIZE. NEGATIVE is 1 iff VALUE was
286 negative before being cast to uintmax_t; its original bitpattern
287 can be deduced from VALSIZE, its original size before casting.
288 TYPE is the kind of value being output (useful for diagnostics).
289 Prefer the POSIX format of SIZE - 1 octal digits (with leading zero
290 digits), followed by '\0'. If this won't work, and if GNU or
291 OLDGNU format is allowed, use '\200' followed by base-256, or (if
292 NEGATIVE is nonzero) '\377' followed by two's complement base-256.
293 If neither format works, use SUBSTITUTE (...) instead. Pass to
294 SUBSTITUTE the address of an 0-or-1 flag recording whether the
295 substitute value is negative. */
298 to_chars (int negative
, uintmax_t value
, size_t valsize
,
299 uintmax_t (*substitute
) (int *),
300 char *where
, size_t size
, const char *type
)
302 int gnu_format
= (archive_format
== GNU_FORMAT
303 || archive_format
== OLDGNU_FORMAT
);
305 /* Generate the POSIX octal representation if the number fits. */
306 if (! negative
&& value
<= MAX_VAL_WITH_DIGITS (size
- 1, LG_8
))
308 where
[size
- 1] = '\0';
309 to_octal (value
, where
, size
- 1);
314 /* Try to cope with the number by using traditional GNU format
317 /* Generate the base-256 representation if the number fits. */
318 if (((negative
? -1 - value
: value
)
319 <= MAX_VAL_WITH_DIGITS (size
- 1, LG_256
)))
321 where
[0] = negative
? -1 : 1 << (LG_256
- 1);
322 to_base256 (negative
, value
, where
+ 1, size
- 1);
326 /* Otherwise, if the number is negative, and if it would not cause
327 ambiguity on this host by confusing positive with negative
328 values, then generate the POSIX octal representation of the value
329 modulo 2**(field bits). The resulting tar file is
330 machine-dependent, since it depends on the host word size. Yuck!
331 But this is the traditional behavior. */
332 else if (negative
&& valsize
* CHAR_BIT
<= (size
- 1) * LG_8
)
334 static int warned_once
;
338 WARN ((0, 0, _("Generating negative octal headers")));
340 where
[size
- 1] = '\0';
341 to_octal (value
& MAX_VAL_WITH_DIGITS (valsize
* CHAR_BIT
, 1),
345 /* Otherwise fall back to substitution, if possible: */
348 substitute
= NULL
; /* No substitution for formats, other than GNU */
350 return to_chars_subst (negative
, gnu_format
, value
, valsize
, substitute
,
355 gid_substitute (int *negative
)
361 static gid_t gid_nobody
;
362 if (!gid_nobody
&& !gname_to_gid ("nobody", &gid_nobody
))
371 gid_to_chars (gid_t v
, char *p
, size_t s
)
373 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, gid_substitute
, p
, s
, "gid_t");
377 major_to_chars (major_t v
, char *p
, size_t s
)
379 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "major_t");
383 minor_to_chars (minor_t v
, char *p
, size_t s
)
385 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "minor_t");
389 mode_to_chars (mode_t v
, char *p
, size_t s
)
391 /* In the common case where the internal and external mode bits are the same,
392 and we are not using POSIX or GNU format,
393 propagate all unknown bits to the external mode.
394 This matches historical practice.
395 Otherwise, just copy the bits we know about. */
398 if (S_ISUID
== TSUID
&& S_ISGID
== TSGID
&& S_ISVTX
== TSVTX
399 && S_IRUSR
== TUREAD
&& S_IWUSR
== TUWRITE
&& S_IXUSR
== TUEXEC
400 && S_IRGRP
== TGREAD
&& S_IWGRP
== TGWRITE
&& S_IXGRP
== TGEXEC
401 && S_IROTH
== TOREAD
&& S_IWOTH
== TOWRITE
&& S_IXOTH
== TOEXEC
402 && archive_format
!= POSIX_FORMAT
403 && archive_format
!= USTAR_FORMAT
404 && archive_format
!= GNU_FORMAT
405 && archive_format
!= OLDGNU_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
;
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
);
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 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
, int 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
->dir_contents
)
1120 if (archive_format
== POSIX_FORMAT
)
1122 xheader_store ("GNU.dumpdir", st
, gnu_list_name
->dir_contents
);
1123 finish_header (st
, blk
, block_ordinal
);
1131 const char *buffer
, *p_buffer
;
1133 block_ordinal
= current_block_ordinal ();
1134 buffer
= gnu_list_name
->dir_contents
;
1136 totsize
= dumpdir_size (buffer
);
1139 OFF_TO_CHARS (totsize
, blk
->header
.size
);
1140 finish_header (st
, blk
, block_ordinal
);
1142 size_left
= totsize
;
1145 mv_total_size (totsize
);
1146 while (size_left
> 0)
1148 mv_size_left (size_left
);
1149 blk
= find_next_block ();
1150 bufsize
= available_space_after (blk
);
1151 if (size_left
< bufsize
)
1153 bufsize
= size_left
;
1154 count
= bufsize
% BLOCKSIZE
;
1156 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
1158 memcpy (blk
->buffer
, p_buffer
, bufsize
);
1159 size_left
-= bufsize
;
1160 p_buffer
+= bufsize
;
1161 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
1169 if (!recursion_option
)
1172 if (one_file_system_option
1174 && 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
, 0, 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
, 0, 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
, int top_level
, 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)
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
))
1289 dump_file (p
, -1, (dev_t
) 0);
1292 while ((p
= name_from_list ()) != NULL
)
1293 if (!excluded_name (p
))
1295 size_t plen
= strlen (p
);
1296 if (buffer_size
<= plen
)
1298 while ((buffer_size
*= 2) <= plen
)
1300 buffer
= xrealloc (buffer
, buffer_size
);
1302 memcpy (buffer
, p
, plen
);
1303 if (! ISSLASH (buffer
[plen
- 1]))
1304 buffer
[plen
++] = '/';
1305 q
= gnu_list_name
->dir_contents
;
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
, -1, (dev_t
) 0);
1328 while ((p
= name_next (1)) != NULL
)
1329 if (!excluded_name (p
))
1330 dump_file (p
, 1, (dev_t
) 0);
1336 if (listed_incremental_option
)
1337 write_directory_file ();
1341 /* Calculate the hash of a link. */
1343 hash_link (void const *entry
, size_t n_buckets
)
1345 struct link
const *l
= entry
;
1346 uintmax_t num
= l
->dev
^ l
->ino
;
1347 return num
% n_buckets
;
1350 /* Compare two links for equality. */
1352 compare_links (void const *entry1
, void const *entry2
)
1354 struct link
const *link1
= entry1
;
1355 struct link
const *link2
= entry2
;
1356 return ((link1
->dev
^ link2
->dev
) | (link1
->ino
^ link2
->ino
)) == 0;
1360 unknown_file_error (char const *p
)
1362 WARN ((0, 0, _("%s: Unknown file type; file ignored"),
1363 quotearg_colon (p
)));
1364 if (!ignore_failed_read_option
)
1365 exit_status
= TAREXIT_FAILURE
;
1369 /* Handling of hard links */
1371 /* Table of all non-directories that we've written so far. Any time
1372 we see another, we check the table and avoid dumping the data
1373 again if we've done it once already. */
1374 static Hash_table
*link_table
;
1376 /* Try to dump stat as a hard link to another file in the archive.
1377 Return true if successful. */
1379 dump_hard_link (struct tar_stat_info
*st
)
1381 if (link_table
&& st
->stat
.st_nlink
> 1)
1384 struct link
*duplicate
;
1385 off_t block_ordinal
;
1388 lp
.ino
= st
->stat
.st_ino
;
1389 lp
.dev
= st
->stat
.st_dev
;
1391 if ((duplicate
= hash_lookup (link_table
, &lp
)))
1393 /* We found a link. */
1394 char const *link_name
= safer_name_suffix (duplicate
->name
, true,
1395 absolute_names_option
);
1399 block_ordinal
= current_block_ordinal ();
1400 assign_string (&st
->link_name
, link_name
);
1401 if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
)
1402 < strlen (link_name
))
1403 write_long_link (st
);
1405 st
->stat
.st_size
= 0;
1406 blk
= start_header (st
);
1409 tar_copy_str (blk
->header
.linkname
, link_name
, NAME_FIELD_SIZE
);
1411 blk
->header
.typeflag
= LNKTYPE
;
1412 finish_header (st
, blk
, block_ordinal
);
1414 if (remove_files_option
&& unlink (st
->orig_file_name
) != 0)
1415 unlink_error (st
->orig_file_name
);
1424 file_count_links (struct tar_stat_info
*st
)
1426 if (st
->stat
.st_nlink
> 1)
1428 struct link
*duplicate
;
1429 struct link
*lp
= xmalloc (offsetof (struct link
, name
)
1430 + strlen (st
->orig_file_name
) + 1);
1431 lp
->ino
= st
->stat
.st_ino
;
1432 lp
->dev
= st
->stat
.st_dev
;
1433 lp
->nlink
= st
->stat
.st_nlink
;
1434 strcpy (lp
->name
, st
->orig_file_name
);
1437 || (link_table
= hash_initialize (0, 0, hash_link
,
1439 && (duplicate
= hash_insert (link_table
, lp
))))
1442 if (duplicate
!= lp
)
1448 /* For each dumped file, check if all its links were dumped. Emit
1449 warnings if it is not so. */
1458 for (lp
= hash_get_first (link_table
); lp
;
1459 lp
= hash_get_next (link_table
, lp
))
1463 WARN ((0, 0, _("Missing links to %s.\n"), quote (lp
->name
)));
1469 /* Dump a single file, recursing on directories. P is the file name
1470 to dump. TOP_LEVEL tells whether this is a top-level call; zero
1471 means no, positive means yes, and negative means the top level
1472 of an incremental dump. PARENT_DEVICE is the device of P's
1473 parent directory; it is examined only if TOP_LEVEL is zero. */
1475 /* FIXME: One should make sure that for *every* path leading to setting
1476 exit_status to failure, a clear diagnostic has been issued. */
1479 dump_file0 (struct tar_stat_info
*st
, const char *p
,
1480 int top_level
, dev_t parent_device
)
1482 union block
*header
;
1484 off_t original_size
;
1485 struct timespec original_ctime
;
1486 struct timespec restore_times
[2];
1487 off_t block_ordinal
= -1;
1490 if (interactive_option
&& !confirm ("add", p
))
1493 assign_string (&st
->orig_file_name
, p
);
1494 assign_string (&st
->file_name
,
1495 safer_name_suffix (p
, false, absolute_names_option
));
1497 transform_name (&st
->file_name
);
1499 if (deref_stat (dereference_option
, p
, &st
->stat
) != 0)
1504 st
->archive_file_size
= original_size
= st
->stat
.st_size
;
1505 st
->atime
= restore_times
[0] = get_stat_atime (&st
->stat
);
1506 st
->mtime
= restore_times
[1] = get_stat_mtime (&st
->stat
);
1507 st
->ctime
= original_ctime
= get_stat_ctime (&st
->stat
);
1510 if (S_ISHIDDEN (st
->stat
.st_mode
))
1512 char *new = (char *) alloca (strlen (p
) + 2);
1522 /* See if we want only new files, and check if this one is too old to
1525 This check is omitted if incremental_option is set *and* the
1526 requested file is not explicitely listed in the command line. */
1528 if (!(incremental_option
&& !is_individual_file (p
))
1529 && !S_ISDIR (st
->stat
.st_mode
)
1530 && OLDER_TAR_STAT_TIME (*st
, m
)
1531 && (!after_date_option
|| OLDER_TAR_STAT_TIME (*st
, c
)))
1533 if (!incremental_option
&& verbose_option
)
1534 WARN ((0, 0, _("%s: file is unchanged; not dumped"),
1535 quotearg_colon (p
)));
1539 /* See if we are trying to dump the archive. */
1540 if (sys_file_is_archive (st
))
1542 WARN ((0, 0, _("%s: file is the archive; not dumped"),
1543 quotearg_colon (p
)));
1547 if (is_avoided_name (p
))
1550 is_dir
= S_ISDIR (st
->stat
.st_mode
) != 0;
1552 if (!is_dir
&& dump_hard_link (st
))
1555 if (is_dir
|| S_ISREG (st
->stat
.st_mode
) || S_ISCTG (st
->stat
.st_mode
))
1559 struct stat final_stat
;
1561 if (is_dir
|| file_dumpable_p (st
))
1564 (O_RDONLY
| O_BINARY
1565 | (is_dir
? O_DIRECTORY
| O_NONBLOCK
: 0)
1566 | (atime_preserve_option
== system_atime_preserve
1571 if (!top_level
&& errno
== ENOENT
)
1572 WARN ((0, 0, _("%s: File removed before we read it"),
1573 quotearg_colon (p
)));
1582 const char *tag_file_name
;
1583 ensure_slash (&st
->orig_file_name
);
1584 ensure_slash (&st
->file_name
);
1586 if (check_exclusion_tags (st
->orig_file_name
, &tag_file_name
)
1587 == exclusion_tag_all
)
1589 exclusion_tag_warning (st
->orig_file_name
, tag_file_name
,
1590 _("directory not dumped"));
1594 ok
= dump_dir (fd
, st
, top_level
, parent_device
);
1596 /* dump_dir consumes FD if successful. */
1602 enum dump_status status
;
1604 if (fd
!= -1 && sparse_option
&& ST_IS_SPARSE (st
->stat
))
1606 status
= sparse_dump_file (fd
, st
);
1607 if (status
== dump_status_not_implemented
)
1608 status
= dump_regular_file (fd
, st
);
1611 status
= dump_regular_file (fd
, st
);
1615 case dump_status_ok
:
1616 case dump_status_short
:
1620 case dump_status_fail
:
1623 case dump_status_not_implemented
:
1627 file_count_links (st
);
1629 ok
= status
== dump_status_ok
;
1634 /* If possible, reopen a directory if we are preserving
1635 atimes, so that we can set just the atime on systems with
1637 if (fd
< 0 && is_dir
1638 && atime_preserve_option
== replace_atime_preserve
)
1639 fd
= open (p
, O_RDONLY
| O_BINARY
| O_DIRECTORY
| O_NONBLOCK
);
1642 ? deref_stat (dereference_option
, p
, &final_stat
)
1643 : fstat (fd
, &final_stat
))
1653 if ((timespec_cmp (get_stat_ctime (&final_stat
), original_ctime
) != 0
1654 /* Original ctime will change if the file is a directory and
1655 --remove-files is given */
1656 && !(remove_files_option
&& is_dir
))
1657 || original_size
< final_stat
.st_size
)
1659 WARN ((0, 0, _("%s: file changed as we read it"),
1660 quotearg_colon (p
)));
1661 if (exit_status
== TAREXIT_SUCCESS
)
1662 exit_status
= TAREXIT_DIFFERS
;
1664 else if (atime_preserve_option
== replace_atime_preserve
1665 && set_file_atime (fd
, p
, restore_times
) != 0)
1669 if (0 <= fd
&& close (fd
) != 0)
1675 if (ok
&& remove_files_option
)
1679 if (rmdir (p
) != 0 && errno
!= ENOTEMPTY
)
1684 if (unlink (p
) != 0)
1691 #ifdef HAVE_READLINK
1692 else if (S_ISLNK (st
->stat
.st_mode
))
1696 size_t linklen
= st
->stat
.st_size
;
1697 if (linklen
!= st
->stat
.st_size
|| linklen
+ 1 == 0)
1699 buffer
= (char *) alloca (linklen
+ 1);
1700 size
= readlink (p
, buffer
, linklen
+ 1);
1706 buffer
[size
] = '\0';
1707 assign_string (&st
->link_name
, buffer
);
1708 if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
) < size
)
1709 write_long_link (st
);
1711 block_ordinal
= current_block_ordinal ();
1712 st
->stat
.st_size
= 0; /* force 0 size on symlink */
1713 header
= start_header (st
);
1716 tar_copy_str (header
->header
.linkname
, buffer
, NAME_FIELD_SIZE
);
1717 header
->header
.typeflag
= SYMTYPE
;
1718 finish_header (st
, header
, block_ordinal
);
1719 /* nothing more to do to it */
1721 if (remove_files_option
)
1723 if (unlink (p
) == -1)
1726 file_count_links (st
);
1730 else if (S_ISCHR (st
->stat
.st_mode
))
1732 else if (S_ISBLK (st
->stat
.st_mode
))
1734 else if (S_ISFIFO (st
->stat
.st_mode
))
1736 else if (S_ISSOCK (st
->stat
.st_mode
))
1738 WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1741 else if (S_ISDOOR (st
->stat
.st_mode
))
1743 WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1748 unknown_file_error (p
);
1752 if (archive_format
== V7_FORMAT
)
1754 unknown_file_error (p
);
1758 block_ordinal
= current_block_ordinal ();
1759 st
->stat
.st_size
= 0; /* force 0 size */
1760 header
= start_header (st
);
1763 header
->header
.typeflag
= type
;
1765 if (type
!= FIFOTYPE
)
1767 MAJOR_TO_CHARS (major (st
->stat
.st_rdev
),
1768 header
->header
.devmajor
);
1769 MINOR_TO_CHARS (minor (st
->stat
.st_rdev
),
1770 header
->header
.devminor
);
1773 finish_header (st
, header
, block_ordinal
);
1774 if (remove_files_option
)
1776 if (unlink (p
) == -1)
1782 dump_file (const char *p
, int top_level
, dev_t parent_device
)
1784 struct tar_stat_info st
;
1785 tar_stat_init (&st
);
1786 dump_file0 (&st
, p
, top_level
, parent_device
);
1787 if (listed_incremental_option
)
1788 update_parent_directory (p
);
1789 tar_stat_destroy (&st
);