1 /* Create a tar archive.
3 Copyright 1985, 1992-1994, 1996-1997, 1999-2001, 2003-2007,
4 2009-2010, 2012-2014, 2016 Free Software Foundation, Inc.
6 This file is part of GNU tar.
8 GNU tar is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 GNU tar is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 Written by John Gilmore, on 1985-08-25. */
25 #include <areadlink.h>
31 /* Error number to use when an impostor is discovered.
32 Pretend the impostor isn't there. */
33 enum { IMPOSTOR_ERRNO = ENOENT };
47 enum exclusion_tag_type type;
48 bool (*predicate) (int fd);
49 struct exclusion_tag *next;
52 static struct exclusion_tag *exclusion_tags;
55 add_exclusion_tag (const char *name, enum exclusion_tag_type type,
56 bool (*predicate) (int fd))
58 struct exclusion_tag *tag = xmalloc (sizeof tag[0]);
59 tag->next = exclusion_tags;
62 tag->predicate = predicate;
63 tag->length = strlen (name);
68 exclusion_tag_warning (const char *dirname, const char *tagname,
72 WARNOPT (WARN_CACHEDIR,
74 _("%s: contains a cache directory tag %s; %s"),
75 quotearg_colon (dirname),
76 quotearg_n (1, tagname),
80 enum exclusion_tag_type
81 check_exclusion_tags (struct tar_stat_info const *st, char const **tag_file_name)
83 struct exclusion_tag *tag;
85 for (tag = exclusion_tags; tag; tag = tag->next)
87 int tagfd = subfile_open (st, tag->name, open_read_flags);
90 bool satisfied = !tag->predicate || tag->predicate (tagfd);
95 *tag_file_name = tag->name;
101 return exclusion_tag_none;
104 /* Exclusion predicate to test if the named file (usually "CACHEDIR.TAG")
105 contains a valid header, as described at:
106 http://www.brynosaurus.com/cachedir
107 Applications can write this file into directories they create
108 for use as caches containing purely regenerable, non-precious data,
109 allowing us to avoid archiving them if --exclude-caches is specified. */
111 #define CACHEDIR_SIGNATURE "Signature: 8a477f597d28d172789f06886806bc55"
112 #define CACHEDIR_SIGNATURE_SIZE (sizeof CACHEDIR_SIGNATURE - 1)
115 cachedir_file_p (int fd)
117 char tagbuf[CACHEDIR_SIGNATURE_SIZE];
120 (read (fd, tagbuf, CACHEDIR_SIGNATURE_SIZE) == CACHEDIR_SIGNATURE_SIZE
121 && memcmp (tagbuf, CACHEDIR_SIGNATURE, CACHEDIR_SIGNATURE_SIZE) == 0);
125 /* The maximum uintmax_t value that can be represented with DIGITS digits,
126 assuming that each digit is BITS_PER_DIGIT wide. */
127 #define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
128 ((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
129 ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
132 /* The maximum uintmax_t value that can be represented with octal
133 digits and a trailing NUL in BUFFER. */
134 #define MAX_OCTAL_VAL(buffer) MAX_VAL_WITH_DIGITS (sizeof (buffer) - 1, LG_8)
136 /* Convert VALUE to an octal representation suitable for tar headers.
137 Output to buffer WHERE with size SIZE.
138 The result is undefined if SIZE is 0 or if VALUE is too large to fit. */
141 to_octal (uintmax_t value, char *where, size_t size)
148 where[--i] = '0' + (v & ((1 << LG_8) - 1));
154 /* Copy at most LEN bytes from the string SRC to DST. Terminate with
155 NUL unless SRC is LEN or more bytes long. */
158 tar_copy_str (char *dst, const char *src, size_t len)
161 for (i = 0; i < len; i++)
162 if (! (dst[i] = src[i]))
166 /* Same as tar_copy_str, but always terminate with NUL if using
170 tar_name_copy_str (char *dst, const char *src, size_t len)
172 tar_copy_str (dst, src, len);
173 if (archive_format == OLDGNU_FORMAT)
177 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
178 tar headers. NEGATIVE is 1 if VALUE was negative before being cast
179 to uintmax_t, 0 otherwise. Output to buffer WHERE with size SIZE.
180 The result is undefined if SIZE is 0 or if VALUE is too large to
184 to_base256 (int negative, uintmax_t value, char *where, size_t size)
187 uintmax_t propagated_sign_bits =
188 ((uintmax_t) - negative << (CHAR_BIT * sizeof v - LG_256));
193 where[--i] = v & ((1 << LG_256) - 1);
194 v = propagated_sign_bits | (v >> LG_256);
199 #define GID_TO_CHARS(val, where) gid_to_chars (val, where, sizeof (where))
200 #define MAJOR_TO_CHARS(val, where) major_to_chars (val, where, sizeof (where))
201 #define MINOR_TO_CHARS(val, where) minor_to_chars (val, where, sizeof (where))
202 #define MODE_TO_CHARS(val, where) mode_to_chars (val, where, sizeof (where))
203 #define UID_TO_CHARS(val, where) uid_to_chars (val, where, sizeof (where))
205 #define UNAME_TO_CHARS(name,buf) string_to_chars (name, buf, sizeof(buf))
206 #define GNAME_TO_CHARS(name,buf) string_to_chars (name, buf, sizeof(buf))
209 to_chars (int negative, uintmax_t value, size_t valsize,
210 uintmax_t (*substitute) (int *),
211 char *where, size_t size, const char *type);
214 to_chars_subst (int negative, int gnu_format, uintmax_t value, size_t valsize,
215 uintmax_t (*substitute) (int *),
216 char *where, size_t size, const char *type)
218 uintmax_t maxval = (gnu_format
219 ? MAX_VAL_WITH_DIGITS (size - 1, LG_256)
220 : MAX_VAL_WITH_DIGITS (size - 1, LG_8));
221 char valbuf[UINTMAX_STRSIZE_BOUND + 1];
222 char maxbuf[UINTMAX_STRSIZE_BOUND];
223 char minbuf[UINTMAX_STRSIZE_BOUND + 1];
224 char const *minval_string;
225 char const *maxval_string = STRINGIFY_BIGINT (maxval, maxbuf);
226 char const *value_string;
230 uintmax_t m = maxval + 1 ? maxval + 1 : maxval / 2 + 1;
231 char *p = STRINGIFY_BIGINT (m, minbuf + 1);
240 char *p = STRINGIFY_BIGINT (- value, valbuf + 1);
245 value_string = STRINGIFY_BIGINT (value, valbuf);
250 uintmax_t sub = substitute (&negsub) & maxval;
251 /* NOTE: This is one of the few places where GNU_FORMAT differs from
252 OLDGNU_FORMAT. The actual differences are:
254 1. In OLDGNU_FORMAT all strings in a tar header end in \0
255 2. Incremental archives use oldgnu_header.
257 Apart from this they are completely identical. */
258 uintmax_t s = (negsub &= archive_format == GNU_FORMAT) ? - sub : sub;
259 char subbuf[UINTMAX_STRSIZE_BOUND + 1];
260 char *sub_string = STRINGIFY_BIGINT (s, subbuf + 1);
263 WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
264 value_string, type, minval_string, maxval_string,
266 return to_chars (negsub, s, valsize, 0, where, size, type);
269 ERROR ((0, 0, _("value %s out of %s range %s..%s"),
270 value_string, type, minval_string, maxval_string));
274 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
275 external form, using SUBSTITUTE (...) if VALUE won't fit. Output
276 to buffer WHERE with size SIZE. NEGATIVE is 1 iff VALUE was
277 negative before being cast to uintmax_t; its original bitpattern
278 can be deduced from VALSIZE, its original size before casting.
279 TYPE is the kind of value being output (useful for diagnostics).
280 Prefer the POSIX format of SIZE - 1 octal digits (with leading zero
281 digits), followed by '\0'. If this won't work, and if GNU or
282 OLDGNU format is allowed, use '\200' followed by base-256, or (if
283 NEGATIVE is nonzero) '\377' followed by two's complement base-256.
284 If neither format works, use SUBSTITUTE (...) instead. Pass to
285 SUBSTITUTE the address of an 0-or-1 flag recording whether the
286 substitute value is negative. */
289 to_chars (int negative, uintmax_t value, size_t valsize,
290 uintmax_t (*substitute) (int *),
291 char *where, size_t size, const char *type)
293 int gnu_format = (archive_format == GNU_FORMAT
294 || archive_format == OLDGNU_FORMAT);
296 /* Generate the POSIX octal representation if the number fits. */
297 if (! negative && value <= MAX_VAL_WITH_DIGITS (size - 1, LG_8))
299 where[size - 1] = '\0';
300 to_octal (value, where, size - 1);
305 /* Try to cope with the number by using traditional GNU format
308 /* Generate the base-256 representation if the number fits. */
309 if (((negative ? -1 - value : value)
310 <= MAX_VAL_WITH_DIGITS (size - 1, LG_256)))
312 where[0] = negative ? -1 : 1 << (LG_256 - 1);
313 to_base256 (negative, value, where + 1, size - 1);
317 /* Otherwise, if the number is negative, and if it would not cause
318 ambiguity on this host by confusing positive with negative
319 values, then generate the POSIX octal representation of the value
320 modulo 2**(field bits). The resulting tar file is
321 machine-dependent, since it depends on the host word size. Yuck!
322 But this is the traditional behavior. */
323 else if (negative && valsize * CHAR_BIT <= (size - 1) * LG_8)
325 static int warned_once;
329 WARN ((0, 0, _("Generating negative octal headers")));
331 where[size - 1] = '\0';
332 to_octal (value & MAX_VAL_WITH_DIGITS (valsize * CHAR_BIT, 1),
336 /* Otherwise fall back to substitution, if possible: */
339 substitute = NULL; /* No substitution for formats, other than GNU */
341 return to_chars_subst (negative, gnu_format, value, valsize, substitute,
346 gid_substitute (int *negative)
352 static gid_t gid_nobody;
353 if (!gid_nobody && !gname_to_gid ("nobody", &gid_nobody))
362 gid_to_chars (gid_t v, char *p, size_t s)
364 return to_chars (v < 0, (uintmax_t) v, sizeof v, gid_substitute, p, s, "gid_t");
368 major_to_chars (major_t v, char *p, size_t s)
370 return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "major_t");
374 minor_to_chars (minor_t v, char *p, size_t s)
376 return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "minor_t");
380 mode_to_chars (mode_t v, char *p, size_t s)
382 /* In the common case where the internal and external mode bits are the same,
383 and we are not using POSIX or GNU format,
384 propagate all unknown bits to the external mode.
385 This matches historical practice.
386 Otherwise, just copy the bits we know about. */
389 if (S_ISUID == TSUID && S_ISGID == TSGID && S_ISVTX == TSVTX
390 && S_IRUSR == TUREAD && S_IWUSR == TUWRITE && S_IXUSR == TUEXEC
391 && S_IRGRP == TGREAD && S_IWGRP == TGWRITE && S_IXGRP == TGEXEC
392 && S_IROTH == TOREAD && S_IWOTH == TOWRITE && S_IXOTH == TOEXEC
393 && archive_format != POSIX_FORMAT
394 && archive_format != USTAR_FORMAT
395 && archive_format != GNU_FORMAT)
403 u = ((v & S_ISUID ? TSUID : 0)
404 | (v & S_ISGID ? TSGID : 0)
405 | (v & S_ISVTX ? TSVTX : 0)
406 | (v & S_IRUSR ? TUREAD : 0)
407 | (v & S_IWUSR ? TUWRITE : 0)
408 | (v & S_IXUSR ? TUEXEC : 0)
409 | (v & S_IRGRP ? TGREAD : 0)
410 | (v & S_IWGRP ? TGWRITE : 0)
411 | (v & S_IXGRP ? TGEXEC : 0)
412 | (v & S_IROTH ? TOREAD : 0)
413 | (v & S_IWOTH ? TOWRITE : 0)
414 | (v & S_IXOTH ? TOEXEC : 0));
416 return to_chars (negative, u, sizeof v, 0, p, s, "mode_t");
420 off_to_chars (off_t v, char *p, size_t s)
422 return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "off_t");
426 time_to_chars (time_t v, char *p, size_t s)
428 return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "time_t");
432 uid_substitute (int *negative)
438 static uid_t uid_nobody;
439 if (!uid_nobody && !uname_to_uid ("nobody", &uid_nobody))
448 uid_to_chars (uid_t v, char *p, size_t s)
450 return to_chars (v < 0, (uintmax_t) v, sizeof v, uid_substitute, p, s, "uid_t");
454 uintmax_to_chars (uintmax_t v, char *p, size_t s)
456 return to_chars (0, v, sizeof v, 0, p, s, "uintmax_t");
460 string_to_chars (char const *str, char *p, size_t s)
462 tar_copy_str (p, str, s);
467 /* A directory is always considered dumpable.
468 Otherwise, only regular and contiguous files are considered dumpable.
469 Such a file is dumpable if it is sparse and both --sparse and --totals
471 Otherwise, it is dumpable unless any of the following conditions occur:
473 a) it is empty *and* world-readable, or
474 b) current archive is /dev/null */
477 file_dumpable_p (struct stat const *st)
479 if (S_ISDIR (st->st_mode))
481 if (! (S_ISREG (st->st_mode) || S_ISCTG (st->st_mode)))
484 return totals_option && sparse_option && ST_IS_SPARSE (*st);
485 return ! (st->st_size == 0 && (st->st_mode & MODE_R) == MODE_R);
489 /* Writing routines. */
491 /* Write the EOT block(s). Zero at least two blocks, through the end
492 of the record. Old tar, as previous versions of GNU tar, writes
493 garbage after two zeroed blocks. */
497 union block *pointer = find_next_block ();
498 memset (pointer->buffer, 0, BLOCKSIZE);
499 set_next_block_after (pointer);
500 pointer = find_next_block ();
501 memset (pointer->buffer, 0, available_space_after (pointer));
502 set_next_block_after (pointer);
505 /* Write a "private" header */
507 start_private_header (const char *name, size_t size, time_t t)
509 union block *header = find_next_block ();
511 memset (header->buffer, 0, sizeof (union block));
513 tar_name_copy_str (header->header.name, name, NAME_FIELD_SIZE);
514 OFF_TO_CHARS (size, header->header.size);
516 TIME_TO_CHARS (t < 0 ? 0 : min (t, MAX_OCTAL_VAL (header->header.mtime)),
517 header->header.mtime);
518 MODE_TO_CHARS (S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH, header->header.mode);
519 UID_TO_CHARS (0, header->header.uid);
520 GID_TO_CHARS (0, header->header.gid);
521 strncpy (header->header.magic, TMAGIC, TMAGLEN);
522 strncpy (header->header.version, TVERSION, TVERSLEN);
526 /* Create a new header and store there at most NAME_FIELD_SIZE bytes of
530 write_short_name (struct tar_stat_info *st)
532 union block *header = find_next_block ();
533 memset (header->buffer, 0, sizeof (union block));
534 tar_name_copy_str (header->header.name, st->file_name, NAME_FIELD_SIZE);
538 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. */
540 write_gnu_long_link (struct tar_stat_info *st, const char *p, char type)
542 size_t size = strlen (p) + 1;
547 header = start_private_header ("././@LongLink", size, 0);
548 uid_to_uname (0, &tmpname);
549 UNAME_TO_CHARS (tmpname, header->header.uname);
551 gid_to_gname (0, &tmpname);
552 GNAME_TO_CHARS (tmpname, header->header.gname);
555 strcpy (header->buffer + offsetof (struct posix_header, magic),
557 header->header.typeflag = type;
558 finish_header (st, header, -1);
560 header = find_next_block ();
562 bufsize = available_space_after (header);
564 while (bufsize < size)
566 memcpy (header->buffer, p, bufsize);
569 set_next_block_after (header + (bufsize - 1) / BLOCKSIZE);
570 header = find_next_block ();
571 bufsize = available_space_after (header);
573 memcpy (header->buffer, p, size);
574 memset (header->buffer + size, 0, bufsize - size);
575 set_next_block_after (header + (size - 1) / BLOCKSIZE);
579 split_long_name (const char *name, size_t length)
583 if (length > PREFIX_FIELD_SIZE + 1)
584 length = PREFIX_FIELD_SIZE + 1;
585 else if (ISSLASH (name[length - 1]))
587 for (i = length - 1; i > 0; i--)
588 if (ISSLASH (name[i]))
594 write_ustar_long_name (const char *name)
596 size_t length = strlen (name);
600 if (length > PREFIX_FIELD_SIZE + NAME_FIELD_SIZE + 1)
602 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
603 quotearg_colon (name),
604 PREFIX_FIELD_SIZE + NAME_FIELD_SIZE + 1));
608 i = split_long_name (name, length);
609 if (i == 0 || (nlen = length - i - 1) > NAME_FIELD_SIZE || nlen == 0)
612 _("%s: file name is too long (cannot be split); not dumped"),
613 quotearg_colon (name)));
617 header = find_next_block ();
618 memset (header->buffer, 0, sizeof (header->buffer));
619 memcpy (header->header.prefix, name, i);
620 memcpy (header->header.name, name + i + 1, length - i - 1);
625 /* Write a long link name, depending on the current archive format */
627 write_long_link (struct tar_stat_info *st)
629 switch (archive_format)
632 xheader_store ("linkpath", st, NULL);
635 case V7_FORMAT: /* old V7 tar format */
639 _("%s: link name is too long; not dumped"),
640 quotearg_colon (st->link_name)));
645 write_gnu_long_link (st, st->link_name, GNUTYPE_LONGLINK);
654 write_long_name (struct tar_stat_info *st)
656 switch (archive_format)
659 xheader_store ("path", st, NULL);
663 if (strlen (st->file_name) > NAME_FIELD_SIZE-1)
665 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
666 quotearg_colon (st->file_name),
667 NAME_FIELD_SIZE - 1));
674 return write_ustar_long_name (st->file_name);
678 write_gnu_long_link (st, st->file_name, GNUTYPE_LONGNAME);
684 return write_short_name (st);
688 write_extended (bool global, struct tar_stat_info *st, union block *old_header)
690 union block *header, hp;
695 if (st->xhdr.buffer || st->xhdr.stk == NULL)
698 xheader_finish (&st->xhdr);
699 memcpy (hp.buffer, old_header, sizeof (hp));
703 p = xheader_ghdr_name ();
704 t = start_time.tv_sec;
709 p = xheader_xhdr_name (st);
710 t = set_mtime_option ? mtime_option.tv_sec : st->stat.st_mtime;
712 xheader_write (type, p, t, &st->xhdr);
714 header = find_next_block ();
715 memcpy (header, &hp.buffer, sizeof (hp.buffer));
720 write_header_name (struct tar_stat_info *st)
722 if (archive_format == POSIX_FORMAT && !string_ascii_p (st->file_name))
724 xheader_store ("path", st, NULL);
725 return write_short_name (st);
727 else if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT)
728 < strlen (st->file_name))
729 return write_long_name (st);
731 return write_short_name (st);
735 /* Header handling. */
737 /* Make a header block for the file whose stat info is st,
738 and return its address. */
741 start_header (struct tar_stat_info *st)
744 char const *uname = NULL;
745 char const *gname = NULL;
747 header = write_header_name (st);
751 /* Override some stat fields, if requested to do so. */
752 owner_map_translate (st->stat.st_uid, &st->stat.st_uid, &uname);
753 group_map_translate (st->stat.st_gid, &st->stat.st_gid, &gname);
757 ((st->stat.st_mode & ~MODE_ALL)
758 | mode_adjust (st->stat.st_mode, S_ISDIR (st->stat.st_mode) != 0,
759 initial_umask, mode_option, NULL));
761 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
762 for a few tars and came up with the following interoperability
766 1 2 3 4 5 6 7 8 9 READER
767 . . . . . . . . . 1 = SunOS 4.2 tar
768 # . . # # . . # # 2 = NEC SVR4.0.2 tar
769 . . . # # . . # . 3 = Solaris 2.1 tar
770 . . . . . . . . . 4 = GNU tar 1.11.1
771 . . . . . . . . . 5 = HP-UX 8.07 tar
772 . . . . . . . . . 6 = Ultrix 4.1
773 . . . . . . . . . 7 = AIX 3.2
774 . . . . . . . . . 8 = Hitachi HI-UX 1.03
775 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
778 # = "impossible file type"
780 The following mask for old archive removes the '#'s in column 4
781 above, thus making GNU tar both a universal donor and a universal
782 acceptor for Paul's test. */
784 if (archive_format == V7_FORMAT || archive_format == USTAR_FORMAT)
785 MODE_TO_CHARS (st->stat.st_mode & MODE_ALL, header->header.mode);
787 MODE_TO_CHARS (st->stat.st_mode, header->header.mode);
790 uid_t uid = st->stat.st_uid;
791 if (archive_format == POSIX_FORMAT
792 && MAX_OCTAL_VAL (header->header.uid) < uid)
794 xheader_store ("uid", st, NULL);
797 if (!UID_TO_CHARS (uid, header->header.uid))
802 gid_t gid = st->stat.st_gid;
803 if (archive_format == POSIX_FORMAT
804 && MAX_OCTAL_VAL (header->header.gid) < gid)
806 xheader_store ("gid", st, NULL);
809 if (!GID_TO_CHARS (gid, header->header.gid))
814 off_t size = st->stat.st_size;
815 if (archive_format == POSIX_FORMAT
816 && MAX_OCTAL_VAL (header->header.size) < size)
818 xheader_store ("size", st, NULL);
821 if (!OFF_TO_CHARS (size, header->header.size))
826 struct timespec mtime;
828 switch (set_mtime_option)
835 mtime = mtime_option;
839 mtime = timespec_cmp (st->mtime, mtime_option) > 0
840 ? mtime_option : st->mtime;
844 if (archive_format == POSIX_FORMAT)
846 if (MAX_OCTAL_VAL (header->header.mtime) < mtime.tv_sec
847 || mtime.tv_nsec != 0)
848 xheader_store ("mtime", st, &mtime);
849 if (MAX_OCTAL_VAL (header->header.mtime) < mtime.tv_sec)
852 if (!TIME_TO_CHARS (mtime.tv_sec, header->header.mtime))
857 if (S_ISCHR (st->stat.st_mode)
858 || S_ISBLK (st->stat.st_mode))
860 major_t devmajor = major (st->stat.st_rdev);
861 minor_t devminor = minor (st->stat.st_rdev);
863 if (archive_format == POSIX_FORMAT
864 && MAX_OCTAL_VAL (header->header.devmajor) < devmajor)
866 xheader_store ("devmajor", st, NULL);
869 if (!MAJOR_TO_CHARS (devmajor, header->header.devmajor))
872 if (archive_format == POSIX_FORMAT
873 && MAX_OCTAL_VAL (header->header.devminor) < devminor)
875 xheader_store ("devminor", st, NULL);
878 if (!MINOR_TO_CHARS (devminor, header->header.devminor))
881 else if (archive_format != GNU_FORMAT && archive_format != OLDGNU_FORMAT)
883 if (!(MAJOR_TO_CHARS (0, header->header.devmajor)
884 && MINOR_TO_CHARS (0, header->header.devminor)))
888 if (archive_format == POSIX_FORMAT)
890 xheader_store ("atime", st, NULL);
891 xheader_store ("ctime", st, NULL);
893 else if (incremental_option)
894 if (archive_format == OLDGNU_FORMAT || archive_format == GNU_FORMAT)
896 TIME_TO_CHARS (st->atime.tv_sec, header->oldgnu_header.atime);
897 TIME_TO_CHARS (st->ctime.tv_sec, header->oldgnu_header.ctime);
900 header->header.typeflag = archive_format == V7_FORMAT ? AREGTYPE : REGTYPE;
902 switch (archive_format)
908 case GNU_FORMAT: /*FIXME?*/
909 /* Overwrite header->header.magic and header.version in one blow. */
910 strcpy (header->buffer + offsetof (struct posix_header, magic),
916 strncpy (header->header.magic, TMAGIC, TMAGLEN);
917 strncpy (header->header.version, TVERSION, TVERSLEN);
924 if (archive_format == V7_FORMAT || numeric_owner_option)
926 /* header->header.[ug]name are left as the empty string. */
931 st->uname = xstrdup (uname);
933 uid_to_uname (st->stat.st_uid, &st->uname);
936 st->gname = xstrdup (gname);
938 gid_to_gname (st->stat.st_gid, &st->gname);
940 if (archive_format == POSIX_FORMAT
941 && (strlen (st->uname) > UNAME_FIELD_SIZE
942 || !string_ascii_p (st->uname)))
943 xheader_store ("uname", st, NULL);
944 UNAME_TO_CHARS (st->uname, header->header.uname);
946 if (archive_format == POSIX_FORMAT
947 && (strlen (st->gname) > GNAME_FIELD_SIZE
948 || !string_ascii_p (st->gname)))
949 xheader_store ("gname", st, NULL);
950 GNAME_TO_CHARS (st->gname, header->header.gname);
953 if (archive_format == POSIX_FORMAT)
958 xheader_store ("SCHILY.acl.access", st, NULL);
960 xheader_store ("SCHILY.acl.default", st, NULL);
962 if ((selinux_context_option > 0) && st->cntx_name)
963 xheader_store ("RHT.security.selinux", st, NULL);
964 if (xattrs_option > 0)
966 size_t scan_xattr = 0;
967 struct xattr_array *xattr_map = st->xattr_map;
969 while (scan_xattr < st->xattr_map_size)
971 xheader_store (xattr_map[scan_xattr].xkey, st, &scan_xattr);
981 simple_finish_header (union block *header)
987 memcpy (header->header.chksum, CHKBLANKS, sizeof header->header.chksum);
991 for (i = sizeof *header; i-- != 0; )
992 /* We can't use unsigned char here because of old compilers, e.g. V7. */
995 /* Fill in the checksum field. It's formatted differently from the
996 other fields: it has [6] digits, a null, then a space -- rather than
997 digits, then a null. We use to_chars.
998 The final space is already there, from
999 checksumming, and to_chars doesn't modify it.
1001 This is a fast way to do:
1003 sprintf(header->header.chksum, "%6o", sum); */
1005 uintmax_to_chars ((uintmax_t) sum, header->header.chksum, 7);
1007 set_next_block_after (header);
1010 /* Finish off a filled-in header block and write it out. We also
1011 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
1012 is not negative, is the block ordinal of the first record for this
1013 file, which may be a preceding long name or long link record. */
1015 finish_header (struct tar_stat_info *st,
1016 union block *header, off_t block_ordinal)
1018 /* Note: It is important to do this before the call to write_extended(),
1019 so that the actual ustar header is printed */
1021 && header->header.typeflag != GNUTYPE_LONGLINK
1022 && header->header.typeflag != GNUTYPE_LONGNAME
1023 && header->header.typeflag != XHDTYPE
1024 && header->header.typeflag != XGLTYPE)
1026 /* FIXME: This global is used in print_header, sigh. */
1027 current_format = archive_format;
1028 print_header (st, header, block_ordinal);
1031 header = write_extended (false, st, header);
1032 simple_finish_header (header);
1037 pad_archive (off_t size_left)
1040 while (size_left > 0)
1042 blk = find_next_block ();
1043 memset (blk->buffer, 0, BLOCKSIZE);
1044 set_next_block_after (blk);
1045 size_left -= BLOCKSIZE;
1049 static enum dump_status
1050 dump_regular_file (int fd, struct tar_stat_info *st)
1052 off_t size_left = st->stat.st_size;
1053 off_t block_ordinal;
1056 block_ordinal = current_block_ordinal ();
1057 blk = start_header (st);
1059 return dump_status_fail;
1061 /* Mark contiguous files, if we support them. */
1062 if (archive_format != V7_FORMAT && S_ISCTG (st->stat.st_mode))
1063 blk->header.typeflag = CONTTYPE;
1065 finish_header (st, blk, block_ordinal);
1067 mv_begin_write (st->file_name, st->stat.st_size, st->stat.st_size);
1068 while (size_left > 0)
1070 size_t bufsize, count;
1072 blk = find_next_block ();
1074 bufsize = available_space_after (blk);
1076 if (size_left < bufsize)
1078 /* Last read -- zero out area beyond. */
1079 bufsize = size_left;
1080 count = bufsize % BLOCKSIZE;
1082 memset (blk->buffer + size_left, 0, BLOCKSIZE - count);
1085 count = (fd <= 0) ? bufsize : blocking_read (fd, blk->buffer, bufsize);
1086 if (count == SAFE_READ_ERROR)
1088 read_diag_details (st->orig_file_name,
1089 st->stat.st_size - size_left, bufsize);
1090 pad_archive (size_left);
1091 return dump_status_short;
1094 set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
1096 if (count != bufsize)
1098 char buf[UINTMAX_STRSIZE_BOUND];
1099 memset (blk->buffer + count, 0, bufsize - count);
1100 WARNOPT (WARN_FILE_SHRANK,
1102 ngettext ("%s: File shrank by %s byte; padding with zeros",
1103 "%s: File shrank by %s bytes; padding with zeros",
1105 quotearg_colon (st->orig_file_name),
1106 STRINGIFY_BIGINT (size_left, buf)));
1107 if (! ignore_failed_read_option)
1108 set_exit_status (TAREXIT_DIFFERS);
1109 pad_archive (size_left - (bufsize - count));
1110 return dump_status_short;
1113 return dump_status_ok;
1117 /* Copy info from the directory identified by ST into the archive.
1118 DIRECTORY contains the directory's entries. */
1121 dump_dir0 (struct tar_stat_info *st, char const *directory)
1123 bool top_level = ! st->parent;
1124 const char *tag_file_name;
1125 union block *blk = NULL;
1126 off_t block_ordinal = current_block_ordinal ();
1128 st->stat.st_size = 0; /* force 0 size on dir */
1130 blk = start_header (st);
1134 info_attach_exclist (st);
1136 if (incremental_option && archive_format != POSIX_FORMAT)
1137 blk->header.typeflag = GNUTYPE_DUMPDIR;
1138 else /* if (standard_option) */
1139 blk->header.typeflag = DIRTYPE;
1141 /* If we're gnudumping, we aren't done yet so don't close it. */
1143 if (!incremental_option)
1144 finish_header (st, blk, block_ordinal);
1145 else if (gnu_list_name->directory)
1147 if (archive_format == POSIX_FORMAT)
1149 xheader_store ("GNU.dumpdir", st,
1150 safe_directory_contents (gnu_list_name->directory));
1151 finish_header (st, blk, block_ordinal);
1159 const char *buffer, *p_buffer;
1161 block_ordinal = current_block_ordinal ();
1162 buffer = safe_directory_contents (gnu_list_name->directory);
1163 totsize = dumpdir_size (buffer);
1164 OFF_TO_CHARS (totsize, blk->header.size);
1165 finish_header (st, blk, block_ordinal);
1167 size_left = totsize;
1169 mv_begin_write (st->file_name, totsize, totsize);
1170 while (size_left > 0)
1172 blk = find_next_block ();
1173 bufsize = available_space_after (blk);
1174 if (size_left < bufsize)
1176 bufsize = size_left;
1177 count = bufsize % BLOCKSIZE;
1179 memset (blk->buffer + size_left, 0, BLOCKSIZE - count);
1181 memcpy (blk->buffer, p_buffer, bufsize);
1182 size_left -= bufsize;
1183 p_buffer += bufsize;
1184 set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
1190 if (!recursion_option)
1193 if (one_file_system_option
1195 && st->parent->stat.st_dev != st->stat.st_dev)
1200 _("%s: file is on a different filesystem; not dumped"),
1201 quotearg_colon (st->orig_file_name)));
1208 switch (check_exclusion_tags (st, &tag_file_name))
1210 case exclusion_tag_all:
1211 /* Handled in dump_file0 */
1214 case exclusion_tag_none:
1220 name_buf = xstrdup (st->orig_file_name);
1221 name_size = name_len = strlen (name_buf);
1223 /* Now output all the files in the directory. */
1224 for (entry = directory; (entry_len = strlen (entry)) != 0;
1225 entry += entry_len + 1)
1227 if (name_size < name_len + entry_len)
1229 name_size = name_len + entry_len;
1230 name_buf = xrealloc (name_buf, name_size + 1);
1232 strcpy (name_buf + name_len, entry);
1233 if (!excluded_name (name_buf, st))
1234 dump_file (st, entry, name_buf);
1241 case exclusion_tag_contents:
1242 exclusion_tag_warning (st->orig_file_name, tag_file_name,
1243 _("contents not dumped"));
1244 name_size = strlen (st->orig_file_name) + strlen (tag_file_name) + 1;
1245 name_buf = xmalloc (name_size);
1246 strcpy (name_buf, st->orig_file_name);
1247 strcat (name_buf, tag_file_name);
1248 dump_file (st, tag_file_name, name_buf);
1252 case exclusion_tag_under:
1253 exclusion_tag_warning (st->orig_file_name, tag_file_name,
1254 _("contents not dumped"));
1260 /* Ensure exactly one trailing slash. */
1262 ensure_slash (char **pstr)
1264 size_t len = strlen (*pstr);
1265 while (len >= 1 && ISSLASH ((*pstr)[len - 1]))
1267 if (!ISSLASH ((*pstr)[len]))
1268 *pstr = xrealloc (*pstr, len + 2);
1269 (*pstr)[len++] = '/';
1270 (*pstr)[len] = '\0';
1273 /* If we just ran out of file descriptors, release a file descriptor
1274 in the directory chain somewhere leading from DIR->parent->parent
1275 up through the root. Return true if successful, false (preserving
1276 errno == EMFILE) otherwise.
1278 Do not release DIR's file descriptor, or DIR's parent, as other
1279 code assumes that they work. On some operating systems, another
1280 process can claim file descriptor resources as we release them, and
1281 some calls or their emulations require multiple file descriptors,
1282 so callers should not give up if a single release doesn't work. */
1285 open_failure_recover (struct tar_stat_info const *dir)
1287 if (errno == EMFILE && dir && dir->parent)
1289 struct tar_stat_info *p;
1290 for (p = dir->parent->parent; p; p = p->parent)
1291 if (0 < p->fd && (! p->parent || p->parent->fd <= 0))
1302 /* Return the directory entries of ST, in a dynamically allocated buffer,
1303 each entry followed by '\0' and the last followed by an extra '\0'.
1304 Return null on failure, setting errno. */
1306 get_directory_entries (struct tar_stat_info *st)
1308 while (! (st->dirstream = fdopendir (st->fd)))
1309 if (! open_failure_recover (st))
1311 return streamsavedir (st->dirstream, savedir_sort_order);
1314 /* Dump the directory ST. Return true if successful, false (emitting
1315 diagnostics) otherwise. Get ST's entries, recurse through its
1316 subdirectories, and clean up file descriptors afterwards. */
1318 dump_dir (struct tar_stat_info *st)
1320 char *directory = get_directory_entries (st);
1323 savedir_diag (st->orig_file_name);
1327 dump_dir0 (st, directory);
1329 restore_parent_fd (st);
1335 /* Number of links a file can have without having to be entered into
1336 the link table. Typically this is 1, but in trickier circumstances
1338 static nlink_t trivial_link_count;
1341 /* Main functions of this module. */
1344 create_archive (void)
1346 struct name const *p;
1348 trivial_link_count = name_count <= 1 && ! dereference_option;
1350 open_archive (ACCESS_WRITE);
1351 buffer_write_global_xheader ();
1353 if (incremental_option)
1355 size_t buffer_size = 1000;
1356 char *buffer = xmalloc (buffer_size);
1359 collect_and_sort_names ();
1361 while ((p = name_from_list ()) != NULL)
1362 if (!excluded_name (p->name, NULL))
1363 dump_file (0, p->name, p->name);
1366 while ((p = name_from_list ()) != NULL)
1367 if (!excluded_name (p->name, NULL))
1369 struct tar_stat_info st;
1370 size_t plen = strlen (p->name);
1371 if (buffer_size <= plen)
1373 while ((buffer_size *= 2) <= plen)
1375 buffer = xrealloc (buffer, buffer_size);
1377 memcpy (buffer, p->name, plen);
1378 if (! ISSLASH (buffer[plen - 1]))
1379 buffer[plen++] = DIRECTORY_SEPARATOR;
1380 tar_stat_init (&st);
1381 q = directory_contents (p->directory);
1385 size_t qlen = strlen (q);
1388 if (! st.orig_file_name)
1390 int fd = openat (chdir_fd, p->name,
1391 open_searchdir_flags);
1394 open_diag (p->name);
1398 if (fstat (fd, &st.stat) != 0)
1400 stat_diag (p->name);
1403 st.orig_file_name = xstrdup (p->name);
1405 if (buffer_size < plen + qlen)
1407 while ((buffer_size *=2 ) < plen + qlen)
1409 buffer = xrealloc (buffer, buffer_size);
1411 strcpy (buffer + plen, q + 1);
1412 dump_file (&st, q + 1, buffer);
1416 tar_stat_destroy (&st);
1423 while ((name = name_next (1)) != NULL)
1424 if (!excluded_name (name, NULL))
1425 dump_file (0, name, name);
1430 finish_deferred_unlinks ();
1431 if (listed_incremental_option)
1432 write_directory_file ();
1436 /* Calculate the hash of a link. */
1438 hash_link (void const *entry, size_t n_buckets)
1440 struct link const *l = entry;
1441 uintmax_t num = l->dev ^ l->ino;
1442 return num % n_buckets;
1445 /* Compare two links for equality. */
1447 compare_links (void const *entry1, void const *entry2)
1449 struct link const *link1 = entry1;
1450 struct link const *link2 = entry2;
1451 return ((link1->dev ^ link2->dev) | (link1->ino ^ link2->ino)) == 0;
1455 unknown_file_error (char const *p)
1457 WARNOPT (WARN_FILE_IGNORED,
1458 (0, 0, _("%s: Unknown file type; file ignored"),
1459 quotearg_colon (p)));
1460 if (!ignore_failed_read_option)
1461 set_exit_status (TAREXIT_FAILURE);
1465 /* Handling of hard links */
1467 /* Table of all non-directories that we've written so far. Any time
1468 we see another, we check the table and avoid dumping the data
1469 again if we've done it once already. */
1470 static Hash_table *link_table;
1472 /* Try to dump stat as a hard link to another file in the archive.
1473 Return true if successful. */
1475 dump_hard_link (struct tar_stat_info *st)
1478 && (trivial_link_count < st->stat.st_nlink || remove_files_option))
1481 struct link *duplicate;
1482 off_t block_ordinal;
1485 lp.ino = st->stat.st_ino;
1486 lp.dev = st->stat.st_dev;
1488 if ((duplicate = hash_lookup (link_table, &lp)))
1490 /* We found a link. */
1491 char const *link_name = safer_name_suffix (duplicate->name, true,
1492 absolute_names_option);
1493 if (duplicate->nlink)
1496 block_ordinal = current_block_ordinal ();
1497 assign_string (&st->link_name, link_name);
1498 if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT)
1499 < strlen (link_name))
1500 write_long_link (st);
1502 st->stat.st_size = 0;
1503 blk = start_header (st);
1506 tar_copy_str (blk->header.linkname, link_name, NAME_FIELD_SIZE);
1508 blk->header.typeflag = LNKTYPE;
1509 finish_header (st, blk, block_ordinal);
1511 if (remove_files_option)
1512 queue_deferred_unlink (st->orig_file_name, false);
1521 file_count_links (struct tar_stat_info *st)
1523 if (hard_dereference_option)
1525 if (trivial_link_count < st->stat.st_nlink)
1527 struct link *duplicate;
1528 char *linkname = NULL;
1531 assign_string (&linkname, st->orig_file_name);
1532 transform_name (&linkname, XFORM_LINK);
1534 lp = xmalloc (offsetof (struct link, name)
1535 + strlen (linkname) + 1);
1536 lp->ino = st->stat.st_ino;
1537 lp->dev = st->stat.st_dev;
1538 lp->nlink = st->stat.st_nlink;
1539 strcpy (lp->name, linkname);
1543 || (link_table = hash_initialize (0, 0, hash_link,
1545 && (duplicate = hash_insert (link_table, lp))))
1548 if (duplicate != lp)
1554 /* For each dumped file, check if all its links were dumped. Emit
1555 warnings if it is not so. */
1564 for (lp = hash_get_first (link_table); lp;
1565 lp = hash_get_next (link_table, lp))
1569 WARN ((0, 0, _("Missing links to %s."), quote (lp->name)));
1574 /* Assuming DIR is the working directory, open FILE, using FLAGS to
1575 control the open. A null DIR means to use ".". If we are low on
1576 file descriptors, try to release one or more from DIR's parents to
1579 subfile_open (struct tar_stat_info const *dir, char const *file, int flags)
1583 static bool initialized;
1586 /* Initialize any tables that might be needed when file
1587 descriptors are exhausted, and whose initialization might
1588 require a file descriptor. This includes the system message
1589 catalog and tar's message catalog. */
1595 while ((fd = openat (dir ? dir->fd : chdir_fd, file, flags)) < 0
1596 && open_failure_recover (dir))
1601 /* Restore the file descriptor for ST->parent, if it was temporarily
1602 closed to conserve file descriptors. On failure, set the file
1603 descriptor to the negative of the corresponding errno value. Call
1604 this every time a subdirectory is ascended from. */
1606 restore_parent_fd (struct tar_stat_info const *st)
1608 struct tar_stat_info *parent = st->parent;
1609 if (parent && ! parent->fd)
1611 int parentfd = openat (st->fd, "..", open_searchdir_flags);
1612 struct stat parentstat;
1616 else if (! (fstat (parentfd, &parentstat) == 0
1617 && parent->stat.st_ino == parentstat.st_ino
1618 && parent->stat.st_dev == parentstat.st_dev))
1621 parentfd = IMPOSTOR_ERRNO;
1626 int origfd = openat (chdir_fd, parent->orig_file_name,
1627 open_searchdir_flags);
1630 if (fstat (parentfd, &parentstat) == 0
1631 && parent->stat.st_ino == parentstat.st_ino
1632 && parent->stat.st_dev == parentstat.st_dev)
1639 parent->fd = parentfd;
1643 /* Dump a single file, recursing on directories. ST is the file's
1644 status info, NAME its name relative to the parent directory, and P
1645 its full name (which may be relative to the working directory). */
1647 /* FIXME: One should make sure that for *every* path leading to setting
1648 exit_status to failure, a clear diagnostic has been issued. */
1651 dump_file0 (struct tar_stat_info *st, char const *name, char const *p)
1653 union block *header;
1655 off_t original_size;
1656 struct timespec original_ctime;
1657 off_t block_ordinal = -1;
1660 struct tar_stat_info const *parent = st->parent;
1661 bool top_level = ! parent;
1662 int parentfd = top_level ? chdir_fd : parent->fd;
1663 void (*diag) (char const *) = 0;
1665 if (interactive_option && !confirm ("add", p))
1668 assign_string (&st->orig_file_name, p);
1669 assign_string (&st->file_name,
1670 safer_name_suffix (p, false, absolute_names_option));
1672 transform_name (&st->file_name, XFORM_REGFILE);
1674 if (parentfd < 0 && ! top_level)
1679 else if (fstatat (parentfd, name, &st->stat, fstatat_flags) != 0)
1681 else if (file_dumpable_p (&st->stat))
1683 fd = subfile_open (parent, name, open_read_flags);
1689 if (fstat (fd, &st->stat) != 0)
1695 file_removed_diag (p, top_level, diag);
1699 st->archive_file_size = original_size = st->stat.st_size;
1700 st->atime = get_stat_atime (&st->stat);
1701 st->mtime = get_stat_mtime (&st->stat);
1702 st->ctime = original_ctime = get_stat_ctime (&st->stat);
1705 if (S_ISHIDDEN (st->stat.st_mode))
1707 char *new = (char *) alloca (strlen (p) + 2);
1717 /* See if we want only new files, and check if this one is too old to
1720 This check is omitted if incremental_option is set *and* the
1721 requested file is not explicitly listed in the command line. */
1723 if (! (incremental_option && ! top_level)
1724 && !S_ISDIR (st->stat.st_mode)
1725 && OLDER_TAR_STAT_TIME (*st, m)
1726 && (!after_date_option || OLDER_TAR_STAT_TIME (*st, c)))
1728 if (!incremental_option && verbose_option)
1729 WARNOPT (WARN_FILE_UNCHANGED,
1730 (0, 0, _("%s: file is unchanged; not dumped"),
1731 quotearg_colon (p)));
1735 /* See if we are trying to dump the archive. */
1736 if (sys_file_is_archive (st))
1738 WARNOPT (WARN_IGNORE_ARCHIVE,
1739 (0, 0, _("%s: file is the archive; not dumped"),
1740 quotearg_colon (p)));
1744 is_dir = S_ISDIR (st->stat.st_mode) != 0;
1746 if (!is_dir && dump_hard_link (st))
1749 if (is_dir || S_ISREG (st->stat.st_mode) || S_ISCTG (st->stat.st_mode))
1752 struct stat final_stat;
1754 xattrs_acls_get (parentfd, name, st, 0, !is_dir);
1755 xattrs_selinux_get (parentfd, name, st, fd);
1756 xattrs_xattrs_get (parentfd, name, st, fd);
1760 const char *tag_file_name;
1761 ensure_slash (&st->orig_file_name);
1762 ensure_slash (&st->file_name);
1764 if (check_exclusion_tags (st, &tag_file_name) == exclusion_tag_all)
1766 exclusion_tag_warning (st->orig_file_name, tag_file_name,
1767 _("directory not dumped"));
1774 parentfd = top_level ? chdir_fd : parent->fd;
1778 enum dump_status status;
1780 if (fd && sparse_option && ST_IS_SPARSE (st->stat))
1782 status = sparse_dump_file (fd, st);
1783 if (status == dump_status_not_implemented)
1784 status = dump_regular_file (fd, st);
1787 status = dump_regular_file (fd, st);
1791 case dump_status_ok:
1792 case dump_status_short:
1793 file_count_links (st);
1796 case dump_status_fail:
1799 case dump_status_not_implemented:
1803 ok = status == dump_status_ok;
1815 if (parentfd < 0 && ! top_level)
1821 ok = fstatat (parentfd, name, &final_stat, fstatat_flags) == 0;
1824 ok = fstat (fd, &final_stat) == 0;
1827 file_removed_diag (p, top_level, stat_diag);
1832 if ((timespec_cmp (get_stat_ctime (&final_stat), original_ctime) != 0
1833 /* Original ctime will change if the file is a directory and
1834 --remove-files is given */
1835 && !(remove_files_option && is_dir))
1836 || original_size < final_stat.st_size)
1838 WARNOPT (WARN_FILE_CHANGED,
1839 (0, 0, _("%s: file changed as we read it"),
1840 quotearg_colon (p)));
1841 set_exit_status (TAREXIT_DIFFERS);
1843 else if (atime_preserve_option == replace_atime_preserve
1844 && fd && (is_dir || original_size != 0)
1845 && set_file_atime (fd, parentfd, name, st->atime) != 0)
1849 ok &= tar_stat_close (st);
1850 if (ok && remove_files_option)
1851 queue_deferred_unlink (p, is_dir);
1855 #ifdef HAVE_READLINK
1856 else if (S_ISLNK (st->stat.st_mode))
1858 st->link_name = areadlinkat_with_size (parentfd, name, st->stat.st_size);
1861 if (errno == ENOMEM)
1863 file_removed_diag (p, top_level, readlink_diag);
1866 transform_name (&st->link_name, XFORM_SYMLINK);
1867 if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT)
1868 < strlen (st->link_name))
1869 write_long_link (st);
1871 xattrs_selinux_get (parentfd, name, st, 0);
1872 xattrs_xattrs_get (parentfd, name, st, 0);
1874 block_ordinal = current_block_ordinal ();
1875 st->stat.st_size = 0; /* force 0 size on symlink */
1876 header = start_header (st);
1879 tar_copy_str (header->header.linkname, st->link_name, NAME_FIELD_SIZE);
1880 header->header.typeflag = SYMTYPE;
1881 finish_header (st, header, block_ordinal);
1882 /* nothing more to do to it */
1884 if (remove_files_option)
1885 queue_deferred_unlink (p, false);
1887 file_count_links (st);
1891 else if (S_ISCHR (st->stat.st_mode))
1894 xattrs_acls_get (parentfd, name, st, 0, true);
1895 xattrs_selinux_get (parentfd, name, st, 0);
1896 xattrs_xattrs_get (parentfd, name, st, 0);
1898 else if (S_ISBLK (st->stat.st_mode))
1901 xattrs_acls_get (parentfd, name, st, 0, true);
1902 xattrs_selinux_get (parentfd, name, st, 0);
1903 xattrs_xattrs_get (parentfd, name, st, 0);
1905 else if (S_ISFIFO (st->stat.st_mode))
1908 xattrs_acls_get (parentfd, name, st, 0, true);
1909 xattrs_selinux_get (parentfd, name, st, 0);
1910 xattrs_xattrs_get (parentfd, name, st, 0);
1912 else if (S_ISSOCK (st->stat.st_mode))
1914 WARNOPT (WARN_FILE_IGNORED,
1915 (0, 0, _("%s: socket ignored"), quotearg_colon (p)));
1918 else if (S_ISDOOR (st->stat.st_mode))
1920 WARNOPT (WARN_FILE_IGNORED,
1921 (0, 0, _("%s: door ignored"), quotearg_colon (p)));
1926 unknown_file_error (p);
1930 if (archive_format == V7_FORMAT)
1932 unknown_file_error (p);
1936 block_ordinal = current_block_ordinal ();
1937 st->stat.st_size = 0; /* force 0 size */
1938 header = start_header (st);
1941 header->header.typeflag = type;
1943 if (type != FIFOTYPE)
1945 MAJOR_TO_CHARS (major (st->stat.st_rdev),
1946 header->header.devmajor);
1947 MINOR_TO_CHARS (minor (st->stat.st_rdev),
1948 header->header.devminor);
1951 finish_header (st, header, block_ordinal);
1952 if (remove_files_option)
1953 queue_deferred_unlink (p, false);
1956 /* Dump a file, recursively. PARENT describes the file's parent
1957 directory, NAME is the file's name relative to PARENT, and FULLNAME
1958 its full name, possibly relative to the working directory. NAME
1959 may contain slashes at the top level of invocation. */
1962 dump_file (struct tar_stat_info *parent, char const *name,
1963 char const *fullname)
1965 struct tar_stat_info st;
1966 tar_stat_init (&st);
1968 dump_file0 (&st, name, fullname);
1969 if (parent && listed_incremental_option)
1970 update_parent_directory (parent);
1971 tar_stat_destroy (&st);