1 /* Create a tar archive.
3 Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
4 2003, 2004 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 2, 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 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
47 /* The maximum uintmax_t value that can be represented with DIGITS digits,
48 assuming that each digit is BITS_PER_DIGIT wide. */
49 #define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
50 ((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
51 ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
54 /* Convert VALUE to an octal representation suitable for tar headers.
55 Output to buffer WHERE with size SIZE.
56 The result is undefined if SIZE is 0 or if VALUE is too large to fit. */
59 to_octal (uintmax_t value, char *where, size_t size)
66 where[--i] = '0' + (v & ((1 << LG_8) - 1));
72 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
73 tar headers. NEGATIVE is 1 if VALUE was negative before being cast
74 to uintmax_t, 0 otherwise. Output to buffer WHERE with size SIZE.
75 The result is undefined if SIZE is 0 or if VALUE is too large to
79 to_base256 (int negative, uintmax_t value, char *where, size_t size)
82 uintmax_t propagated_sign_bits =
83 ((uintmax_t) - negative << (CHAR_BIT * sizeof v - LG_256));
88 where[--i] = v & ((1 << LG_256) - 1);
89 v = propagated_sign_bits | (v >> LG_256);
94 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
95 external form, using SUBSTITUTE (...) if VALUE won't fit. Output
96 to buffer WHERE with size SIZE. NEGATIVE is 1 iff VALUE was
97 negative before being cast to uintmax_t; its original bitpattern
98 can be deduced from VALSIZE, its original size before casting.
99 TYPE is the kind of value being output (useful for diagnostics).
100 Prefer the POSIX format of SIZE - 1 octal digits (with leading zero
101 digits), followed by '\0'. If this won't work, and if GNU or
102 OLDGNU format is allowed, use '\200' followed by base-256, or (if
103 NEGATIVE is nonzero) '\377' followed by two's complement base-256.
104 If neither format works, use SUBSTITUTE (...) instead. Pass to
105 SUBSTITUTE the address of an 0-or-1 flag recording whether the
106 substitute value is negative. */
109 to_chars (int negative, uintmax_t value, size_t valsize,
110 uintmax_t (*substitute) (int *),
111 char *where, size_t size, const char *type)
113 int base256_allowed = (archive_format == GNU_FORMAT
114 || archive_format == OLDGNU_FORMAT);
116 /* Generate the POSIX octal representation if the number fits. */
117 if (! negative && value <= MAX_VAL_WITH_DIGITS (size - 1, LG_8))
119 where[size - 1] = '\0';
120 to_octal (value, where, size - 1);
123 /* Otherwise, generate the base-256 representation if we are
124 generating an old or new GNU format and if the number fits. */
125 else if (((negative ? -1 - value : value)
126 <= MAX_VAL_WITH_DIGITS (size - 1, LG_256))
129 where[0] = negative ? -1 : 1 << (LG_256 - 1);
130 to_base256 (negative, value, where + 1, size - 1);
133 /* Otherwise, if the number is negative, and if it would not cause
134 ambiguity on this host by confusing positive with negative
135 values, then generate the POSIX octal representation of the value
136 modulo 2**(field bits). The resulting tar file is
137 machine-dependent, since it depends on the host word size. Yuck!
138 But this is the traditional behavior. */
139 else if (negative && valsize * CHAR_BIT <= (size - 1) * LG_8)
141 static int warned_once;
145 WARN ((0, 0, _("Generating negative octal headers")));
147 where[size - 1] = '\0';
148 to_octal (value & MAX_VAL_WITH_DIGITS (valsize * CHAR_BIT, 1),
152 /* Otherwise, output a substitute value if possible (with a
153 warning), and an error message if not. */
156 uintmax_t maxval = (base256_allowed
157 ? MAX_VAL_WITH_DIGITS (size - 1, LG_256)
158 : MAX_VAL_WITH_DIGITS (size - 1, LG_8));
159 char valbuf[UINTMAX_STRSIZE_BOUND + 1];
160 char maxbuf[UINTMAX_STRSIZE_BOUND];
161 char minbuf[UINTMAX_STRSIZE_BOUND + 1];
162 char const *minval_string;
163 char const *maxval_string = STRINGIFY_BIGINT (maxval, maxbuf);
164 char const *value_string;
168 uintmax_t m = maxval + 1 ? maxval + 1 : maxval / 2 + 1;
169 char *p = STRINGIFY_BIGINT (m, minbuf + 1);
178 char *p = STRINGIFY_BIGINT (- value, valbuf + 1);
183 value_string = STRINGIFY_BIGINT (value, valbuf);
188 uintmax_t sub = substitute (&negsub) & maxval;
189 /* FIXME: This is the only place where GNU_FORMAT differs from
190 OLDGNU_FORMAT. Apart from this they are completely identical. */
191 uintmax_t s = (negsub &= archive_format == GNU_FORMAT) ? - sub : sub;
192 char subbuf[UINTMAX_STRSIZE_BOUND + 1];
193 char *sub_string = STRINGIFY_BIGINT (s, subbuf + 1);
196 WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
197 value_string, type, minval_string, maxval_string,
199 to_chars (negsub, s, valsize, 0, where, size, type);
202 ERROR ((0, 0, _("value %s out of %s range %s..%s"),
203 value_string, type, minval_string, maxval_string));
208 gid_substitute (int *negative)
214 static gid_t gid_nobody;
215 if (!gid_nobody && !gname_to_gid ("nobody", &gid_nobody))
224 gid_to_chars (gid_t v, char *p, size_t s)
226 to_chars (v < 0, (uintmax_t) v, sizeof v, gid_substitute, p, s, "gid_t");
230 major_to_chars (major_t v, char *p, size_t s)
232 to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "major_t");
236 minor_to_chars (minor_t v, char *p, size_t s)
238 to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "minor_t");
242 mode_to_chars (mode_t v, char *p, size_t s)
244 /* In the common case where the internal and external mode bits are the same,
245 and we are not using POSIX or GNU format,
246 propagate all unknown bits to the external mode.
247 This matches historical practice.
248 Otherwise, just copy the bits we know about. */
251 if (S_ISUID == TSUID && S_ISGID == TSGID && S_ISVTX == TSVTX
252 && S_IRUSR == TUREAD && S_IWUSR == TUWRITE && S_IXUSR == TUEXEC
253 && S_IRGRP == TGREAD && S_IWGRP == TGWRITE && S_IXGRP == TGEXEC
254 && S_IROTH == TOREAD && S_IWOTH == TOWRITE && S_IXOTH == TOEXEC
255 && archive_format != POSIX_FORMAT
256 && archive_format != USTAR_FORMAT
257 && archive_format != GNU_FORMAT)
265 u = ((v & S_ISUID ? TSUID : 0)
266 | (v & S_ISGID ? TSGID : 0)
267 | (v & S_ISVTX ? TSVTX : 0)
268 | (v & S_IRUSR ? TUREAD : 0)
269 | (v & S_IWUSR ? TUWRITE : 0)
270 | (v & S_IXUSR ? TUEXEC : 0)
271 | (v & S_IRGRP ? TGREAD : 0)
272 | (v & S_IWGRP ? TGWRITE : 0)
273 | (v & S_IXGRP ? TGEXEC : 0)
274 | (v & S_IROTH ? TOREAD : 0)
275 | (v & S_IWOTH ? TOWRITE : 0)
276 | (v & S_IXOTH ? TOEXEC : 0));
278 to_chars (negative, u, sizeof v, 0, p, s, "mode_t");
282 off_to_chars (off_t v, char *p, size_t s)
284 to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "off_t");
288 size_to_chars (size_t v, char *p, size_t s)
290 to_chars (0, (uintmax_t) v, sizeof v, 0, p, s, "size_t");
294 time_to_chars (time_t v, char *p, size_t s)
296 to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "time_t");
300 uid_substitute (int *negative)
306 static uid_t uid_nobody;
307 if (!uid_nobody && !uname_to_uid ("nobody", &uid_nobody))
316 uid_to_chars (uid_t v, char *p, size_t s)
318 to_chars (v < 0, (uintmax_t) v, sizeof v, uid_substitute, p, s, "uid_t");
322 uintmax_to_chars (uintmax_t v, char *p, size_t s)
324 to_chars (0, v, sizeof v, 0, p, s, "uintmax_t");
328 string_to_chars (char *str, char *p, size_t s)
335 /* A file is not dumpable if
336 a) it is empty *and* world-readable, or
337 b) current archive is /dev/null */
340 file_dumpable_p (struct tar_stat_info *st)
342 return !(dev_null_output
343 || (st->archive_file_size == 0
344 && (st->stat.st_mode & MODE_R) == MODE_R));
348 /* Writing routines. */
350 /* Write the EOT block(s). Zero at least two blocks, through the end
351 of the record. Old tar, as previous versions of GNU tar, writes
352 garbage after two zeroed blocks. */
356 union block *pointer = find_next_block ();
357 memset (pointer->buffer, 0, BLOCKSIZE);
358 set_next_block_after (pointer);
359 pointer = find_next_block ();
360 memset (pointer->buffer, 0, available_space_after (pointer));
361 set_next_block_after (pointer);
364 /* Copy at most LEN bytes from SRC to DST. Terminate with NUL unless
365 SRC is LEN characters long */
367 tar_copy_str (char *dst, const char *src, size_t len)
370 strncpy (dst, src, len);
373 /* Write a "private" header */
375 start_private_header (const char *name, size_t size)
378 union block *header = find_next_block ();
380 memset (header->buffer, 0, sizeof (union block));
382 tar_copy_str (header->header.name, name, NAME_FIELD_SIZE);
383 OFF_TO_CHARS (size, header->header.size);
386 TIME_TO_CHARS (t, header->header.mtime);
387 MODE_TO_CHARS (S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH, header->header.mode);
388 UID_TO_CHARS (getuid (), header->header.uid);
389 GID_TO_CHARS (getgid (), header->header.gid);
390 MAJOR_TO_CHARS (0, header->header.devmajor);
391 MAJOR_TO_CHARS (0, header->header.devminor);
392 strncpy (header->header.magic, TMAGIC, TMAGLEN);
393 strncpy (header->header.version, TVERSION, TVERSLEN);
397 /* Create a new header and store there at most NAME_FIELD_SIZE bytes of
401 write_short_name (struct tar_stat_info *st)
403 union block *header = find_next_block ();
404 memset (header->buffer, 0, sizeof (union block));
405 tar_copy_str (header->header.name, st->file_name, NAME_FIELD_SIZE);
409 #define FILL(field,byte) do { \
410 memset(field, byte, sizeof(field)-1); \
411 (field)[sizeof(field)-1] = 0; \
414 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. */
416 write_gnu_long_link (struct tar_stat_info *st, const char *p, char type)
418 size_t size = strlen (p) + 1;
423 header = start_private_header ("././@LongLink", size);
424 FILL(header->header.mtime, '0');
425 FILL(header->header.mode, '0');
426 FILL(header->header.uid, '0');
427 FILL(header->header.gid, '0');
428 FILL(header->header.devmajor, 0);
429 FILL(header->header.devminor, 0);
430 uid_to_uname (0, &tmpname);
431 UNAME_TO_CHARS (tmpname, header->header.uname);
433 gid_to_gname (0, &tmpname);
434 GNAME_TO_CHARS (tmpname, header->header.gname);
437 strcpy (header->header.magic, OLDGNU_MAGIC);
438 header->header.typeflag = type;
439 finish_header (st, header, -1);
441 header = find_next_block ();
443 bufsize = available_space_after (header);
445 while (bufsize < size)
447 memcpy (header->buffer, p, bufsize);
450 set_next_block_after (header + (bufsize - 1) / BLOCKSIZE);
451 header = find_next_block ();
452 bufsize = available_space_after (header);
454 memcpy (header->buffer, p, size);
455 memset (header->buffer + size, 0, bufsize - size);
456 set_next_block_after (header + (size - 1) / BLOCKSIZE);
460 split_long_name (const char *name, size_t length)
464 if (length > PREFIX_FIELD_SIZE)
465 length = PREFIX_FIELD_SIZE+2;
466 for (i = length - 1; i > 0; i--)
467 if (ISSLASH (name[i]))
473 write_ustar_long_name (const char *name)
475 size_t length = strlen (name);
479 if (length > PREFIX_FIELD_SIZE + NAME_FIELD_SIZE + 1)
481 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
482 quotearg_colon (name),
483 PREFIX_FIELD_SIZE + NAME_FIELD_SIZE + 1));
487 i = split_long_name (name, length);
488 if (i == 0 || length - i - 1 > NAME_FIELD_SIZE)
491 _("%s: file name is too long (cannot be split); not dumped"),
492 quotearg_colon (name)));
496 header = find_next_block ();
497 memset (header->buffer, 0, sizeof (header->buffer));
498 memcpy (header->header.prefix, name, i);
499 memcpy (header->header.name, name + i + 1, length - i - 1);
504 /* Write a long link name, depending on the current archive format */
506 write_long_link (struct tar_stat_info *st)
508 switch (archive_format)
511 xheader_store ("linkpath", st, NULL);
514 case V7_FORMAT: /* old V7 tar format */
518 _("%s: link name is too long; not dumped"),
519 quotearg_colon (st->link_name)));
524 write_gnu_long_link (st, st->link_name, GNUTYPE_LONGLINK);
533 write_long_name (struct tar_stat_info *st)
535 switch (archive_format)
538 xheader_store ("path", st, NULL);
542 if (strlen (st->file_name) > NAME_FIELD_SIZE-1)
544 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
545 quotearg_colon (st->file_name),
546 NAME_FIELD_SIZE - 1));
553 return write_ustar_long_name (st->file_name);
557 write_gnu_long_link (st, st->file_name, GNUTYPE_LONGNAME);
563 return write_short_name (st);
567 write_extended (struct tar_stat_info *st, union block *old_header)
569 union block *header, hp;
572 if (extended_header.buffer || extended_header.stk == NULL)
575 xheader_finish (&extended_header);
576 memcpy (hp.buffer, old_header, sizeof (hp));
577 p = xheader_xhdr_name (st);
578 xheader_write (XHDTYPE, p, &extended_header);
580 header = find_next_block ();
581 memcpy (header, &hp.buffer, sizeof (hp.buffer));
586 write_header_name (struct tar_stat_info *st)
588 if (archive_format == POSIX_FORMAT && !string_ascii_p (st->file_name))
590 xheader_store ("path", st, NULL);
591 return write_short_name (st);
593 else if (NAME_FIELD_SIZE < strlen (st->file_name))
594 return write_long_name (st);
596 return write_short_name (st);
600 /* Header handling. */
602 /* Make a header block for the file whose stat info is st,
603 and return its address. */
606 start_header (struct tar_stat_info *st)
610 header = write_header_name (st);
614 /* Override some stat fields, if requested to do so. */
616 if (owner_option != (uid_t) -1)
617 st->stat.st_uid = owner_option;
618 if (group_option != (gid_t) -1)
619 st->stat.st_gid = group_option;
621 st->stat.st_mode = ((st->stat.st_mode & ~MODE_ALL)
622 | mode_adjust (st->stat.st_mode, mode_option));
624 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
625 for a few tars and came up with the following interoperability
629 1 2 3 4 5 6 7 8 9 READER
630 . . . . . . . . . 1 = SunOS 4.2 tar
631 # . . # # . . # # 2 = NEC SVR4.0.2 tar
632 . . . # # . . # . 3 = Solaris 2.1 tar
633 . . . . . . . . . 4 = GNU tar 1.11.1
634 . . . . . . . . . 5 = HP-UX 8.07 tar
635 . . . . . . . . . 6 = Ultrix 4.1
636 . . . . . . . . . 7 = AIX 3.2
637 . . . . . . . . . 8 = Hitachi HI-UX 1.03
638 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
641 # = ``impossible file type''
643 The following mask for old archive removes the `#'s in column 4
644 above, thus making GNU tar both a universal donor and a universal
645 acceptor for Paul's test. */
647 if (archive_format == V7_FORMAT || archive_format == USTAR_FORMAT)
648 MODE_TO_CHARS (st->stat.st_mode & MODE_ALL, header->header.mode);
650 MODE_TO_CHARS (st->stat.st_mode, header->header.mode);
652 if (st->stat.st_uid > MAXOCTAL7 && archive_format == POSIX_FORMAT)
653 xheader_store ("uid", st, NULL);
655 UID_TO_CHARS (st->stat.st_uid, header->header.uid);
657 if (st->stat.st_gid > MAXOCTAL7 && archive_format == POSIX_FORMAT)
658 xheader_store ("gid", st, NULL);
660 GID_TO_CHARS (st->stat.st_gid, header->header.gid);
662 if (st->stat.st_size > MAXOCTAL11 && archive_format == POSIX_FORMAT)
663 xheader_store ("size", st, NULL);
665 OFF_TO_CHARS (st->stat.st_size, header->header.size);
667 TIME_TO_CHARS (st->stat.st_mtime, header->header.mtime);
670 if (S_ISCHR (st->stat.st_mode)
671 || S_ISBLK (st->stat.st_mode))
673 st->devmajor = major (st->stat.st_rdev);
674 st->devminor = minor (st->stat.st_rdev);
676 if (st->devmajor > MAXOCTAL7 && archive_format == POSIX_FORMAT)
677 xheader_store ("devmajor", st, NULL);
679 MAJOR_TO_CHARS (st->devmajor, header->header.devmajor);
681 if (st->devminor > MAXOCTAL7 && archive_format == POSIX_FORMAT)
682 xheader_store ("devminor", st, NULL);
684 MAJOR_TO_CHARS (st->devminor, header->header.devminor);
686 else if (archive_format != GNU_FORMAT && archive_format != OLDGNU_FORMAT)
688 MAJOR_TO_CHARS (0, header->header.devmajor);
689 MINOR_TO_CHARS (0, header->header.devminor);
692 if (archive_format == POSIX_FORMAT)
694 xheader_store ("atime", st, NULL);
695 xheader_store ("ctime", st, NULL);
697 else if (incremental_option)
698 if (archive_format == OLDGNU_FORMAT || archive_format == GNU_FORMAT)
700 TIME_TO_CHARS (st->stat.st_atime, header->oldgnu_header.atime);
701 TIME_TO_CHARS (st->stat.st_ctime, header->oldgnu_header.ctime);
704 header->header.typeflag = archive_format == V7_FORMAT ? AREGTYPE : REGTYPE;
706 switch (archive_format)
712 case GNU_FORMAT: /*FIXME?*/
713 /* Overwrite header->header.magic and header.version in one blow. */
714 strcpy (header->header.magic, OLDGNU_MAGIC);
719 strncpy (header->header.magic, TMAGIC, TMAGLEN);
720 strncpy (header->header.version, TVERSION, TVERSLEN);
727 if (archive_format == V7_FORMAT || numeric_owner_option)
729 /* header->header.[ug]name are left as the empty string. */
733 uid_to_uname (st->stat.st_uid, &st->uname);
734 gid_to_gname (st->stat.st_gid, &st->gname);
736 if (archive_format == POSIX_FORMAT
737 && (strlen (st->uname) > UNAME_FIELD_SIZE
738 || !string_ascii_p (st->uname)))
739 xheader_store ("uname", st, NULL);
741 UNAME_TO_CHARS (st->uname, header->header.uname);
743 if (archive_format == POSIX_FORMAT
744 && (strlen (st->gname) > GNAME_FIELD_SIZE
745 || !string_ascii_p (st->gname)))
746 xheader_store ("gname", st, NULL);
748 GNAME_TO_CHARS (st->gname, header->header.gname);
755 simple_finish_header (union block *header)
761 memcpy (header->header.chksum, CHKBLANKS, sizeof header->header.chksum);
765 for (i = sizeof *header; i-- != 0; )
766 /* We can't use unsigned char here because of old compilers, e.g. V7. */
769 /* Fill in the checksum field. It's formatted differently from the
770 other fields: it has [6] digits, a null, then a space -- rather than
771 digits, then a null. We use to_chars.
772 The final space is already there, from
773 checksumming, and to_chars doesn't modify it.
775 This is a fast way to do:
777 sprintf(header->header.chksum, "%6o", sum); */
779 uintmax_to_chars ((uintmax_t) sum, header->header.chksum, 7);
781 set_next_block_after (header);
784 /* Finish off a filled-in header block and write it out. We also
785 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
786 is not negative, is the block ordinal of the first record for this
787 file, which may be a preceding long name or long link record. */
789 finish_header (struct tar_stat_info *st,
790 union block *header, off_t block_ordinal)
792 /* Note: It is important to do this before the call to write_extended(),
793 so that the actual ustar header is printed */
795 && header->header.typeflag != GNUTYPE_LONGLINK
796 && header->header.typeflag != GNUTYPE_LONGNAME
797 && header->header.typeflag != XHDTYPE
798 && header->header.typeflag != XGLTYPE)
800 /* These globals are parameters to print_header, sigh. */
802 current_header = header;
803 current_format = archive_format;
804 print_header (st, block_ordinal);
807 header = write_extended (st, header);
808 simple_finish_header (header);
813 pad_archive (off_t size_left)
816 while (size_left > 0)
818 save_sizeleft = size_left;
819 blk = find_next_block ();
820 memset (blk->buffer, 0, BLOCKSIZE);
821 set_next_block_after (blk);
822 size_left -= BLOCKSIZE;
826 static enum dump_status
827 dump_regular_file (int fd, struct tar_stat_info *st)
829 off_t size_left = st->stat.st_size;
833 block_ordinal = current_block_ordinal ();
834 blk = start_header (st);
836 return dump_status_fail;
838 /* Mark contiguous files, if we support them. */
839 if (archive_format != V7_FORMAT && S_ISCTG (st->stat.st_mode))
840 blk->header.typeflag = CONTTYPE;
842 finish_header (st, blk, block_ordinal);
844 while (size_left > 0)
846 size_t bufsize, count;
848 if (multi_volume_option)
850 assign_string (&save_name, st->file_name);
851 save_sizeleft = size_left;
852 save_totsize = st->stat.st_size;
854 blk = find_next_block ();
856 bufsize = available_space_after (blk);
858 if (size_left < bufsize)
860 /* Last read -- zero out area beyond. */
862 count = bufsize % BLOCKSIZE;
864 memset (blk->buffer + size_left, 0, BLOCKSIZE - count);
867 count = (fd < 0) ? bufsize : safe_read (fd, blk->buffer, bufsize);
868 if (count == SAFE_READ_ERROR)
870 read_diag_details (st->orig_file_name,
871 st->stat.st_size - size_left, bufsize);
872 pad_archive (size_left);
873 return dump_status_short;
877 set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
879 if (count != bufsize)
881 char buf[UINTMAX_STRSIZE_BOUND];
882 memset (blk->buffer + count, 0, bufsize - count);
884 ngettext ("%s: File shrank by %s byte; padding with zeros",
885 "%s: File shrank by %s bytes; padding with zeros",
887 quotearg_colon (st->orig_file_name),
888 STRINGIFY_BIGINT (size_left, buf)));
889 if (! ignore_failed_read_option)
890 exit_status = TAREXIT_FAILURE;
891 pad_archive (size_left);
892 return dump_status_short;
895 return dump_status_ok;
899 dump_regular_finish (int fd, struct tar_stat_info *st, time_t original_ctime)
903 struct stat final_stat;
904 if (fstat (fd, &final_stat) != 0)
906 stat_diag (st->orig_file_name);
908 else if (final_stat.st_ctime != original_ctime)
910 WARN ((0, 0, _("%s: file changed as we read it"),
911 quotearg_colon (st->orig_file_name)));
915 close_diag (st->orig_file_name);
918 if (remove_files_option)
920 if (unlink (st->orig_file_name) == -1)
921 unlink_error (st->orig_file_name);
925 /* Look in directory DIRNAME for a cache directory tag file
926 with the magic name "CACHEDIR.TAG" and a standard header,
928 http://www.brynosaurus.com/cachedir
929 Applications can write this file into directories they create
930 for use as caches containing purely regenerable, non-precious data,
931 allowing us to avoid archiving them if --exclude-caches is specified. */
933 #define CACHEDIR_SIGNATURE "Signature: 8a477f597d28d172789f06886806bc55"
934 #define CACHEDIR_SIGNATURE_SIZE (sizeof CACHEDIR_SIGNATURE - 1)
937 check_cache_directory (char *dirname)
939 static char tagname[] = "CACHEDIR.TAG";
942 int tag_present = false;
944 tagpath = xmalloc (strlen (dirname) + strlen (tagname) + 1);
945 strcpy (tagpath, dirname);
946 strcat (tagpath, tagname);
948 fd = open (tagpath, O_RDONLY);
951 static char tagbuf[CACHEDIR_SIGNATURE_SIZE];
953 if (read (fd, tagbuf, CACHEDIR_SIGNATURE_SIZE)
954 == CACHEDIR_SIGNATURE_SIZE
955 && memcmp (tagbuf, CACHEDIR_SIGNATURE, CACHEDIR_SIGNATURE_SIZE) == 0)
967 dump_dir0 (char *directory,
968 struct tar_stat_info *st, int top_level, dev_t parent_device)
970 dev_t our_device = st->stat.st_dev;
972 if (!is_avoided_name (st->orig_file_name))
974 union block *blk = NULL;
975 off_t block_ordinal = current_block_ordinal ();
976 st->stat.st_size = 0; /* force 0 size on dir */
978 blk = start_header (st);
982 if (incremental_option)
983 blk->header.typeflag = GNUTYPE_DUMPDIR;
984 else /* if (standard_option) */
985 blk->header.typeflag = DIRTYPE;
987 /* If we're gnudumping, we aren't done yet so don't close it. */
989 if (!incremental_option)
990 finish_header (st, blk, block_ordinal);
991 else if (gnu_list_name->dir_contents)
997 const char *buffer, *p_buffer;
999 block_ordinal = current_block_ordinal ();
1000 buffer = gnu_list_name->dir_contents; /* FOO */
1003 for (p_buffer = buffer; *p_buffer; )
1005 size_t size = strlen (p_buffer) + 1;
1010 OFF_TO_CHARS (totsize, blk->header.size);
1011 finish_header (st, blk, block_ordinal);
1013 size_left = totsize;
1014 while (size_left > 0)
1016 if (multi_volume_option)
1018 assign_string (&save_name, st->orig_file_name);
1019 save_sizeleft = size_left;
1020 save_totsize = totsize;
1022 blk = find_next_block ();
1023 bufsize = available_space_after (blk);
1024 if (size_left < bufsize)
1026 bufsize = size_left;
1027 count = bufsize % BLOCKSIZE;
1029 memset (blk->buffer + size_left, 0, BLOCKSIZE - count);
1031 memcpy (blk->buffer, p_buffer, bufsize);
1032 size_left -= bufsize;
1033 p_buffer += bufsize;
1034 set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
1036 if (multi_volume_option)
1037 assign_string (&save_name, 0);
1042 if (!recursion_option)
1045 if (one_file_system_option
1047 && parent_device != st->stat.st_dev)
1051 _("%s: file is on a different filesystem; not dumped"),
1052 quotearg_colon (st->orig_file_name)));
1056 if (exclude_caches_option
1057 && check_cache_directory(st->orig_file_name))
1061 _("%s: contains a cache directory tag; not dumped"),
1062 quotearg_colon (st->orig_file_name)));
1069 char *name_buf = strdup (st->orig_file_name);
1070 size_t name_size = strlen (name_buf);
1071 size_t name_len = name_size;
1073 /* Now output all the files in the directory. */
1074 /* FIXME: Should speed this up by cd-ing into the dir. */
1076 for (entry = directory; (entry_len = strlen (entry)) != 0;
1077 entry += entry_len + 1)
1079 if (name_size < name_len + entry_len)
1081 name_size = name_len + entry_len;
1082 name_buf = xrealloc (name_buf, name_size + 1);
1084 strcpy (name_buf + name_len, entry);
1085 if (!excluded_name (name_buf))
1086 dump_file (name_buf, 0, our_device);
1093 /* Ensure exactly one trailing slash. */
1095 ensure_slash (char **pstr)
1097 size_t len = strlen (*pstr);
1098 while (len >= 1 && ISSLASH ((*pstr)[len - 1]))
1100 if (!ISSLASH ((*pstr)[len]))
1101 *pstr = xrealloc (*pstr, len + 2);
1102 (*pstr)[len++] = '/';
1103 (*pstr)[len] = '\0';
1107 dump_dir (struct tar_stat_info *st, int top_level, dev_t parent_device)
1111 directory = savedir (st->orig_file_name);
1114 savedir_diag (st->orig_file_name);
1118 ensure_slash (&st->orig_file_name);
1119 ensure_slash (&st->file_name);
1121 dump_dir0 (directory, st, top_level, parent_device);
1128 /* Main functions of this module. */
1131 create_archive (void)
1135 open_archive (ACCESS_WRITE);
1136 xheader_write_global ();
1138 if (incremental_option)
1140 size_t buffer_size = 1000;
1141 char *buffer = xmalloc (buffer_size);
1144 collect_and_sort_names ();
1146 while ((p = name_from_list ()) != NULL)
1147 if (!excluded_name (p))
1148 dump_file (p, -1, (dev_t) 0);
1151 while ((p = name_from_list ()) != NULL)
1152 if (!excluded_name (p))
1154 size_t plen = strlen (p);
1155 if (buffer_size <= plen)
1157 while ((buffer_size *= 2) <= plen)
1159 buffer = xrealloc (buffer, buffer_size);
1161 memcpy (buffer, p, plen);
1162 if (! ISSLASH (buffer[plen - 1]))
1163 buffer[plen++] = '/';
1164 q = gnu_list_name->dir_contents;
1168 size_t qlen = strlen (q);
1171 if (buffer_size < plen + qlen)
1173 while ((buffer_size *=2 ) < plen + qlen)
1175 buffer = xrealloc (buffer, buffer_size);
1177 strcpy (buffer + plen, q + 1);
1178 dump_file (buffer, -1, (dev_t) 0);
1187 while ((p = name_next (1)) != NULL)
1188 if (!excluded_name (p))
1189 dump_file (p, 1, (dev_t) 0);
1195 if (listed_incremental_option)
1196 write_directory_file ();
1200 /* Calculate the hash of a link. */
1202 hash_link (void const *entry, unsigned n_buckets)
1204 struct link const *l = entry;
1205 uintmax_t num = l->dev ^ l->ino;
1206 return num % n_buckets;
1209 /* Compare two links for equality. */
1211 compare_links (void const *entry1, void const *entry2)
1213 struct link const *link1 = entry1;
1214 struct link const *link2 = entry2;
1215 return ((link1->dev ^ link2->dev) | (link1->ino ^ link2->ino)) == 0;
1219 unknown_file_error (char *p)
1221 WARN ((0, 0, _("%s: Unknown file type; file ignored"),
1222 quotearg_colon (p)));
1223 if (!ignore_failed_read_option)
1224 exit_status = TAREXIT_FAILURE;
1228 /* Handling of hard links */
1230 /* Table of all non-directories that we've written so far. Any time
1231 we see another, we check the table and avoid dumping the data
1232 again if we've done it once already. */
1233 static Hash_table *link_table;
1235 /* Try to dump stat as a hard link to another file in the archive. If
1236 succeeded returns true */
1238 dump_hard_link (struct tar_stat_info *st)
1240 if (link_table && st->stat.st_nlink > 1)
1243 struct link *duplicate;
1244 off_t block_ordinal;
1247 lp.ino = st->stat.st_ino;
1248 lp.dev = st->stat.st_dev;
1250 if ((duplicate = hash_lookup (link_table, &lp)))
1252 /* We found a link. */
1253 char const *link_name = safer_name_suffix (duplicate->name, true);
1257 block_ordinal = current_block_ordinal ();
1258 assign_string (&st->link_name, link_name);
1259 if (NAME_FIELD_SIZE < strlen (link_name))
1260 write_long_link (st);
1262 st->stat.st_size = 0;
1263 blk = start_header (st);
1266 tar_copy_str (blk->header.linkname, link_name, NAME_FIELD_SIZE);
1268 blk->header.typeflag = LNKTYPE;
1269 finish_header (st, blk, block_ordinal);
1271 if (remove_files_option && unlink (st->orig_file_name) != 0)
1272 unlink_error (st->orig_file_name);
1281 file_count_links (struct tar_stat_info *st)
1283 if (st->stat.st_nlink > 1)
1285 struct link *duplicate;
1286 struct link *lp = xmalloc (offsetof (struct link, name)
1287 + strlen (st->orig_file_name) + 1);
1288 lp->ino = st->stat.st_ino;
1289 lp->dev = st->stat.st_dev;
1290 lp->nlink = st->stat.st_nlink;
1291 strcpy (lp->name, st->orig_file_name);
1294 || (link_table = hash_initialize (0, 0, hash_link,
1296 && (duplicate = hash_insert (link_table, lp))))
1299 if (duplicate != lp)
1305 /* For each dumped file, check if all its links were dumped. Emit
1306 warnings if it is not so. */
1315 for (lp = hash_get_first (link_table); lp;
1316 lp = hash_get_next (link_table, lp))
1320 WARN ((0, 0, _("Missing links to '%s'.\n"), lp->name));
1326 /* Dump a single file, recursing on directories. P is the file name
1327 to dump. TOP_LEVEL tells whether this is a top-level call; zero
1328 means no, positive means yes, and negative means the top level
1329 of an incremental dump. PARENT_DEVICE is the device of P's
1330 parent directory; it is examined only if TOP_LEVEL is zero. */
1332 /* FIXME: One should make sure that for *every* path leading to setting
1333 exit_status to failure, a clear diagnostic has been issued. */
1336 dump_file0 (struct tar_stat_info *st, char *p,
1337 int top_level, dev_t parent_device)
1339 union block *header;
1341 time_t original_ctime;
1342 struct utimbuf restore_times;
1343 off_t block_ordinal = -1;
1345 if (interactive_option && !confirm ("add", p))
1348 assign_string (&st->orig_file_name, p);
1349 assign_string (&st->file_name, safer_name_suffix (p, false));
1351 if (deref_stat (dereference_option, p, &st->stat) != 0)
1356 st->archive_file_size = st->stat.st_size;
1357 sys_stat_nanoseconds (st);
1358 original_ctime = st->stat.st_ctime;
1359 restore_times.actime = st->stat.st_atime;
1360 restore_times.modtime = st->stat.st_mtime;
1363 if (S_ISHIDDEN (st->stat.st_mode))
1365 char *new = (char *) alloca (strlen (p) + 2);
1375 /* See if we want only new files, and check if this one is too old to
1378 This check is omitted if incremental_option is set *and* the
1379 requested file is not explicitely listed in the command line. */
1381 if (!(incremental_option && !is_individual_file (p))
1382 && !S_ISDIR (st->stat.st_mode)
1383 && OLDER_STAT_TIME (st->stat, m)
1384 && (!after_date_option || OLDER_STAT_TIME (st->stat, c)))
1386 if (!incremental_option)
1387 WARN ((0, 0, _("%s: file is unchanged; not dumped"),
1388 quotearg_colon (p)));
1392 /* See if we are trying to dump the archive. */
1393 if (sys_file_is_archive (st))
1395 WARN ((0, 0, _("%s: file is the archive; not dumped"),
1396 quotearg_colon (p)));
1400 if (S_ISDIR (st->stat.st_mode))
1402 dump_dir (st, top_level, parent_device);
1403 if (atime_preserve_option)
1404 utime (p, &restore_times);
1407 else if (is_avoided_name (p))
1411 /* Check for multiple links. */
1412 if (dump_hard_link (st))
1415 /* This is not a link to a previously dumped file, so dump it. */
1417 if (S_ISREG (st->stat.st_mode)
1418 || S_ISCTG (st->stat.st_mode))
1421 enum dump_status status;
1423 if (file_dumpable_p (st))
1425 fd = open (st->orig_file_name,
1426 O_RDONLY | O_BINARY);
1429 if (!top_level && errno == ENOENT)
1430 WARN ((0, 0, _("%s: File removed before we read it"),
1431 quotearg_colon (st->orig_file_name)));
1433 open_diag (st->orig_file_name);
1440 if (sparse_option && sparse_file_p (st))
1442 status = sparse_dump_file (fd, st);
1443 if (status == dump_status_not_implemented)
1444 status = dump_regular_file (fd, st);
1447 status = dump_regular_file (fd, st);
1451 case dump_status_ok:
1452 if (multi_volume_option)
1453 assign_string (&save_name, 0);
1454 dump_regular_finish (fd, st, original_ctime);
1457 case dump_status_short:
1458 if (multi_volume_option)
1459 assign_string (&save_name, 0);
1463 case dump_status_fail:
1467 case dump_status_not_implemented:
1471 if (atime_preserve_option)
1472 utime (st->orig_file_name, &restore_times);
1473 file_count_links (st);
1476 #ifdef HAVE_READLINK
1477 else if (S_ISLNK (st->stat.st_mode))
1481 size_t linklen = st->stat.st_size;
1482 if (linklen != st->stat.st_size || linklen + 1 == 0)
1484 buffer = (char *) alloca (linklen + 1);
1485 size = readlink (p, buffer, linklen + 1);
1491 buffer[size] = '\0';
1492 assign_string (&st->link_name, buffer);
1493 if (size > NAME_FIELD_SIZE)
1494 write_long_link (st);
1496 block_ordinal = current_block_ordinal ();
1497 st->stat.st_size = 0; /* force 0 size on symlink */
1498 header = start_header (st);
1501 tar_copy_str (header->header.linkname, buffer, NAME_FIELD_SIZE);
1502 header->header.typeflag = SYMTYPE;
1503 finish_header (st, header, block_ordinal);
1504 /* nothing more to do to it */
1506 if (remove_files_option)
1508 if (unlink (p) == -1)
1511 file_count_links (st);
1515 else if (S_ISCHR (st->stat.st_mode))
1517 else if (S_ISBLK (st->stat.st_mode))
1519 else if (S_ISFIFO (st->stat.st_mode))
1521 else if (S_ISSOCK (st->stat.st_mode))
1523 WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p)));
1526 else if (S_ISDOOR (st->stat.st_mode))
1528 WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p)));
1533 unknown_file_error (p);
1538 if (archive_format == V7_FORMAT)
1540 unknown_file_error (p);
1544 block_ordinal = current_block_ordinal ();
1545 st->stat.st_size = 0; /* force 0 size */
1546 header = start_header (st);
1549 header->header.typeflag = type;
1551 if (type != FIFOTYPE)
1553 MAJOR_TO_CHARS (major (st->stat.st_rdev),
1554 header->header.devmajor);
1555 MINOR_TO_CHARS (minor (st->stat.st_rdev),
1556 header->header.devminor);
1559 finish_header (st, header, block_ordinal);
1560 if (remove_files_option)
1562 if (unlink (p) == -1)
1568 dump_file (char *p, int top_level, dev_t parent_device)
1570 struct tar_stat_info st;
1571 tar_stat_init (&st);
1572 dump_file0 (&st, p, top_level, parent_device);
1573 tar_stat_destroy (&st);