1 /* Create a tar archive.
3 Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
4 2003 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. */
57 /* The maximum uintmax_t value that can be represented with DIGITS digits,
58 assuming that each digit is BITS_PER_DIGIT wide. */
59 #define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
60 ((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
61 ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
64 /* Convert VALUE to an octal representation suitable for tar headers.
65 Output to buffer WHERE with size SIZE.
66 The result is undefined if SIZE is 0 or if VALUE is too large to fit. */
69 to_octal (uintmax_t value, char *where, size_t size)
76 where[--i] = '0' + (v & ((1 << LG_8) - 1));
82 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
83 tar headers. NEGATIVE is 1 if VALUE was negative before being cast
84 to uintmax_t, 0 otherwise. Output to buffer WHERE with size SIZE.
85 The result is undefined if SIZE is 0 or if VALUE is too large to
89 to_base256 (int negative, uintmax_t value, char *where, size_t size)
92 uintmax_t propagated_sign_bits =
93 ((uintmax_t) - negative << (CHAR_BIT * sizeof v - LG_256));
98 where[--i] = v & ((1 << LG_256) - 1);
99 v = propagated_sign_bits | (v >> LG_256);
104 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
105 external form, using SUBSTITUTE (...) if VALUE won't fit. Output
106 to buffer WHERE with size SIZE. NEGATIVE is 1 iff VALUE was
107 negative before being cast to uintmax_t; its original bitpattern
108 can be deduced from VALSIZE, its original size before casting.
109 TYPE is the kind of value being output (useful for diagnostics).
110 Prefer the POSIX format of SIZE - 1 octal digits (with leading zero
111 digits), followed by '\0'. If this won't work, and if GNU or
112 OLDGNU format is allowed, use '\200' followed by base-256, or (if
113 NEGATIVE is nonzero) '\377' followed by two's complement base-256.
114 If neither format works, use SUBSTITUTE (...) instead. Pass to
115 SUBSTITUTE the address of an 0-or-1 flag recording whether the
116 substitute value is negative. */
119 to_chars (int negative, uintmax_t value, size_t valsize,
120 uintmax_t (*substitute) (int *),
121 char *where, size_t size, const char *type)
123 int base256_allowed = (archive_format == GNU_FORMAT
124 || archive_format == OLDGNU_FORMAT);
126 /* Generate the POSIX octal representation if the number fits. */
127 if (! negative && value <= MAX_VAL_WITH_DIGITS (size - 1, LG_8))
129 where[size - 1] = '\0';
130 to_octal (value, where, size - 1);
133 /* Otherwise, generate the base-256 representation if we are
134 generating an old or new GNU format and if the number fits. */
135 else if (((negative ? -1 - value : value)
136 <= MAX_VAL_WITH_DIGITS (size - 1, LG_256))
139 where[0] = negative ? -1 : 1 << (LG_256 - 1);
140 to_base256 (negative, value, where + 1, size - 1);
143 /* Otherwise, if the number is negative, and if it would not cause
144 ambiguity on this host by confusing positive with negative
145 values, then generate the POSIX octal representation of the value
146 modulo 2**(field bits). The resulting tar file is
147 machine-dependent, since it depends on the host word size. Yuck!
148 But this is the traditional behavior. */
149 else if (negative && valsize * CHAR_BIT <= (size - 1) * LG_8)
151 static int warned_once;
155 WARN ((0, 0, _("Generating negative octal headers")));
157 where[size - 1] = '\0';
158 to_octal (value & MAX_VAL_WITH_DIGITS (valsize * CHAR_BIT, 1),
162 /* Otherwise, output a substitute value if possible (with a
163 warning), and an error message if not. */
166 uintmax_t maxval = (base256_allowed
167 ? MAX_VAL_WITH_DIGITS (size - 1, LG_256)
168 : MAX_VAL_WITH_DIGITS (size - 1, LG_8));
169 char valbuf[UINTMAX_STRSIZE_BOUND + 1];
170 char maxbuf[UINTMAX_STRSIZE_BOUND];
171 char minbuf[UINTMAX_STRSIZE_BOUND + 1];
172 char const *minval_string;
173 char const *maxval_string = STRINGIFY_BIGINT (maxval, maxbuf);
174 char const *value_string;
178 uintmax_t m = maxval + 1 ? maxval + 1 : maxval / 2 + 1;
179 char *p = STRINGIFY_BIGINT (m, minbuf + 1);
188 char *p = STRINGIFY_BIGINT (- value, valbuf + 1);
193 value_string = STRINGIFY_BIGINT (value, valbuf);
198 uintmax_t sub = substitute (&negsub) & maxval;
199 uintmax_t s = (negsub &= archive_format == GNU_FORMAT) ? - sub : sub;
200 char subbuf[UINTMAX_STRSIZE_BOUND + 1];
201 char *sub_string = STRINGIFY_BIGINT (s, subbuf + 1);
204 WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
205 value_string, type, minval_string, maxval_string,
207 to_chars (negsub, s, valsize, 0, where, size, type);
210 ERROR ((0, 0, _("value %s out of %s range %s..%s"),
211 value_string, type, minval_string, maxval_string));
216 gid_substitute (int *negative)
222 static gid_t gid_nobody;
223 if (!gid_nobody && !gname_to_gid ("nobody", &gid_nobody))
232 gid_to_chars (gid_t v, char *p, size_t s)
234 to_chars (v < 0, (uintmax_t) v, sizeof v, gid_substitute, p, s, "gid_t");
238 major_to_chars (major_t v, char *p, size_t s)
240 to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "major_t");
244 minor_to_chars (minor_t v, char *p, size_t s)
246 to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "minor_t");
250 mode_to_chars (mode_t v, char *p, size_t s)
252 /* In the common case where the internal and external mode bits are the same,
253 and we are not using POSIX or GNU format,
254 propagate all unknown bits to the external mode.
255 This matches historical practice.
256 Otherwise, just copy the bits we know about. */
259 if (S_ISUID == TSUID && S_ISGID == TSGID && S_ISVTX == TSVTX
260 && S_IRUSR == TUREAD && S_IWUSR == TUWRITE && S_IXUSR == TUEXEC
261 && S_IRGRP == TGREAD && S_IWGRP == TGWRITE && S_IXGRP == TGEXEC
262 && S_IROTH == TOREAD && S_IWOTH == TOWRITE && S_IXOTH == TOEXEC
263 && archive_format != POSIX_FORMAT
264 && archive_format != GNU_FORMAT)
272 u = ((v & S_ISUID ? TSUID : 0)
273 | (v & S_ISGID ? TSGID : 0)
274 | (v & S_ISVTX ? TSVTX : 0)
275 | (v & S_IRUSR ? TUREAD : 0)
276 | (v & S_IWUSR ? TUWRITE : 0)
277 | (v & S_IXUSR ? TUEXEC : 0)
278 | (v & S_IRGRP ? TGREAD : 0)
279 | (v & S_IWGRP ? TGWRITE : 0)
280 | (v & S_IXGRP ? TGEXEC : 0)
281 | (v & S_IROTH ? TOREAD : 0)
282 | (v & S_IWOTH ? TOWRITE : 0)
283 | (v & S_IXOTH ? TOEXEC : 0));
285 to_chars (negative, u, sizeof v, 0, p, s, "mode_t");
289 off_to_chars (off_t v, char *p, size_t s)
291 to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "off_t");
295 size_to_chars (size_t v, char *p, size_t s)
297 to_chars (0, (uintmax_t) v, sizeof v, 0, p, s, "size_t");
301 time_to_chars (time_t v, char *p, size_t s)
303 to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "time_t");
307 uid_substitute (int *negative)
313 static uid_t uid_nobody;
314 if (!uid_nobody && !uname_to_uid ("nobody", &uid_nobody))
323 uid_to_chars (uid_t v, char *p, size_t s)
325 to_chars (v < 0, (uintmax_t) v, sizeof v, uid_substitute, p, s, "uid_t");
329 uintmax_to_chars (uintmax_t v, char *p, size_t s)
331 to_chars (0, v, sizeof v, 0, p, s, "uintmax_t");
335 string_to_chars (char *str, char *p, size_t s)
342 /* Writing routines. */
344 /* Zero out the buffer so we don't confuse ourselves with leftover
347 clear_buffer (char *buffer)
349 memset (buffer, 0, BLOCKSIZE);
352 /* Write the EOT block(s). Zero at least two blocks, through the end
353 of the record. Old tar, as previous versions of GNU tar, writes
354 garbage after two zeroed blocks. */
358 union block *pointer = find_next_block ();
359 memset (pointer->buffer, 0, BLOCKSIZE);
360 set_next_block_after (pointer);
361 pointer = find_next_block ();
362 memset (pointer->buffer, 0, available_space_after (pointer));
363 set_next_block_after (pointer);
366 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. */
368 /* FIXME: Cross recursion between start_header and write_long! */
370 static union block *start_header (const char *, struct tar_stat_info *);
373 write_long (const char *p, char type)
375 size_t size = strlen (p) + 1;
378 struct tar_stat_info foo;
380 memset (&foo, 0, sizeof foo);
381 foo.stat.st_size = size;
383 header = start_header ("././@LongLink", &foo);
384 header->header.typeflag = type;
385 finish_header (header, -1);
387 header = find_next_block ();
389 bufsize = available_space_after (header);
391 while (bufsize < size)
393 memcpy (header->buffer, p, bufsize);
396 set_next_block_after (header + (bufsize - 1) / BLOCKSIZE);
397 header = find_next_block ();
398 bufsize = available_space_after (header);
400 memcpy (header->buffer, p, size);
401 memset (header->buffer + size, 0, bufsize - size);
402 set_next_block_after (header + (size - 1) / BLOCKSIZE);
405 /* NOTE: Cross recursion between start_header and write_extended */
408 write_extended (union block *old_header, char type)
410 union block *header, hp;
411 struct tar_stat_info foo;
415 if (extended_header.buffer || extended_header.stk == NULL)
416 return old_header; /* Prevent recursion */
418 xheader_finish (&extended_header);
419 size = extended_header.size;
420 memset (&foo, 0, sizeof foo);
421 foo.stat.st_mode = S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH;
422 time (&foo.stat.st_ctime);
423 foo.stat.st_atime = foo.stat.st_ctime;
424 foo.stat.st_mtime = foo.stat.st_ctime;
425 foo.stat.st_size = size;
427 memcpy (hp.buffer, old_header, sizeof (hp));
429 header = start_header ("././@PaxHeader", &foo);
430 header->header.typeflag = type;
432 finish_header (header, -1);
434 p = extended_header.buffer;
440 header = find_next_block ();
444 memcpy (header->buffer, p, len);
446 memset (header->buffer + len, 0, BLOCKSIZE - len);
449 set_next_block_after (header);
453 xheader_destroy (&extended_header);
454 header = find_next_block ();
455 memcpy (header, &hp.buffer, sizeof (hp.buffer));
460 /* Header handling. */
462 /* Make a header block for the file whose stat info is st,
463 and return its address. */
466 start_header (const char *name, struct tar_stat_info *st)
470 name = safer_name_suffix (name, 0);
471 assign_string (&st->file_name, name);
473 if (sizeof header->header.name <= strlen (name))
475 if (archive_format == POSIX_FORMAT)
476 xheader_store ("path", st);
478 write_long (name, GNUTYPE_LONGNAME);
481 header = find_next_block ();
482 memset (header->buffer, 0, sizeof (union block));
484 assign_string (¤t_stat_info.file_name, name);
486 strncpy (header->header.name, name, NAME_FIELD_SIZE);
487 header->header.name[NAME_FIELD_SIZE - 1] = '\0';
489 /* Override some stat fields, if requested to do so. */
491 if (owner_option != (uid_t) -1)
492 st->stat.st_uid = owner_option;
493 if (group_option != (gid_t) -1)
494 st->stat.st_gid = group_option;
496 st->stat.st_mode = ((st->stat.st_mode & ~MODE_ALL)
497 | mode_adjust (st->stat.st_mode, mode_option));
499 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
500 for a few tars and came up with the following interoperability
504 1 2 3 4 5 6 7 8 9 READER
505 . . . . . . . . . 1 = SunOS 4.2 tar
506 # . . # # . . # # 2 = NEC SVR4.0.2 tar
507 . . . # # . . # . 3 = Solaris 2.1 tar
508 . . . . . . . . . 4 = GNU tar 1.11.1
509 . . . . . . . . . 5 = HP-UX 8.07 tar
510 . . . . . . . . . 6 = Ultrix 4.1
511 . . . . . . . . . 7 = AIX 3.2
512 . . . . . . . . . 8 = Hitachi HI-UX 1.03
513 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
516 # = ``impossible file type''
518 The following mask for old archive removes the `#'s in column 4
519 above, thus making GNU tar both a universal donor and a universal
520 acceptor for Paul's test. */
522 if (archive_format == V7_FORMAT)
523 MODE_TO_CHARS (st->stat.st_mode & MODE_ALL, header->header.mode);
525 MODE_TO_CHARS (st->stat.st_mode, header->header.mode);
527 if (st->stat.st_uid > MAXOCTAL7 && archive_format == POSIX_FORMAT)
528 xheader_store ("uid", st);
530 UID_TO_CHARS (st->stat.st_uid, header->header.uid);
532 if (st->stat.st_gid > MAXOCTAL7 && archive_format == POSIX_FORMAT)
533 xheader_store ("gid", st);
535 GID_TO_CHARS (st->stat.st_gid, header->header.gid);
537 if (st->stat.st_size > MAXOCTAL11 && archive_format == POSIX_FORMAT)
538 xheader_store ("size", st);
540 OFF_TO_CHARS (st->stat.st_size, header->header.size);
542 TIME_TO_CHARS (st->stat.st_mtime, header->header.mtime);
545 if (S_ISCHR (st->stat.st_mode)
546 || S_ISBLK (st->stat.st_mode))
548 st->devmajor = major (st->stat.st_rdev);
549 st->devminor = minor (st->stat.st_rdev);
551 if (st->devmajor > MAXOCTAL7 && archive_format == POSIX_FORMAT)
552 xheader_store ("devmajor", st);
554 MAJOR_TO_CHARS (st->devmajor, header->header.devmajor);
556 if (st->devminor > MAXOCTAL7 && archive_format == POSIX_FORMAT)
557 xheader_store ("devminor", st);
559 MAJOR_TO_CHARS (st->devminor, header->header.devminor);
563 MAJOR_TO_CHARS (0, header->header.devmajor);
564 MINOR_TO_CHARS (0, header->header.devminor);
567 if (archive_format == POSIX_FORMAT)
569 xheader_store ("atime", st);
570 xheader_store ("ctime", st);
572 else if (incremental_option)
573 if (archive_format == OLDGNU_FORMAT)
575 TIME_TO_CHARS (st->stat.st_atime, header->oldgnu_header.atime);
576 TIME_TO_CHARS (st->stat.st_ctime, header->oldgnu_header.ctime);
579 header->header.typeflag = archive_format == V7_FORMAT ? AREGTYPE : REGTYPE;
581 switch (archive_format)
587 /* Overwrite header->header.magic and header.version in one blow. */
588 strcpy (header->header.magic, OLDGNU_MAGIC);
593 strncpy (header->header.magic, TMAGIC, TMAGLEN);
594 strncpy (header->header.version, TVERSION, TVERSLEN);
601 if (archive_format == V7_FORMAT || numeric_owner_option)
603 /* header->header.[ug]name are left as the empty string. */
607 uid_to_uname (st->stat.st_uid, &st->uname);
608 gid_to_gname (st->stat.st_gid, &st->gname);
610 if (archive_format == POSIX_FORMAT
611 && strlen (st->uname) > UNAME_FIELD_SIZE)
612 xheader_store ("uname", st);
614 UNAME_TO_CHARS (st->uname, header->header.uname);
616 if (archive_format == POSIX_FORMAT
617 && strlen (st->gname) > GNAME_FIELD_SIZE)
618 xheader_store ("gname", st);
620 GNAME_TO_CHARS (st->gname, header->header.gname);
626 /* Finish off a filled-in header block and write it out. We also
627 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
628 is not negative, is the block ordinal of the first record for this
629 file, which may be a preceding long name or long link record. */
631 finish_header (union block *header, off_t block_ordinal)
637 /* Note: It is important to do this before the call to write_extended(),
638 so that the actual ustar header is printed */
640 && header->header.typeflag != GNUTYPE_LONGLINK
641 && header->header.typeflag != GNUTYPE_LONGNAME
642 && header->header.typeflag != XHDTYPE
643 && header->header.typeflag != XGLTYPE)
645 /* These globals are parameters to print_header, sigh. */
647 current_header = header;
648 /* current_stat_info is already set up. */
649 current_format = archive_format;
650 print_header (block_ordinal);
653 header = write_extended (header, XHDTYPE);
655 memcpy (header->header.chksum, CHKBLANKS, sizeof header->header.chksum);
659 for (i = sizeof *header; i-- != 0; )
660 /* We can't use unsigned char here because of old compilers, e.g. V7. */
663 /* Fill in the checksum field. It's formatted differently from the
664 other fields: it has [6] digits, a null, then a space -- rather than
665 digits, then a null. We use to_chars.
666 The final space is already there, from
667 checksumming, and to_chars doesn't modify it.
669 This is a fast way to do:
671 sprintf(header->header.chksum, "%6o", sum); */
673 uintmax_to_chars ((uintmax_t) sum, header->header.chksum, 7);
675 set_next_block_after (header);
678 /* Sparse file processing. */
680 /* Takes a blockful of data and basically cruises through it to see if
681 it's made *entirely* of zeros, returning a 0 the instant it finds
682 something that is a nonzero, i.e., useful data. */
684 zero_block_p (char *buffer)
688 for (counter = 0; counter < BLOCKSIZE; counter++)
689 if (buffer[counter] != '\0')
695 init_sparsearray (void)
698 sp_array_size = SPARSES_IN_OLDGNU_HEADER;
699 sparsearray = xmalloc (sp_array_size * sizeof *sparsearray);
703 find_new_file_size (int sparses)
707 for (i = 0; i < sparses; i++)
708 s += sparsearray[i].numbytes;
712 /* Make one pass over the file NAME, studying where any non-zero data
713 is, that is, how far into the file each instance of data is, and
714 how many bytes are there. Save this information in the
715 sparsearray, which will later be translated into header
718 /* There is little point in trimming small amounts of null data at the head
719 and tail of blocks, only avoid dumping full null blocks. */
721 /* FIXME: this routine might accept bits of algorithmic cleanup, it is
722 too kludgey for my taste... */
725 deal_with_sparse (char *name, union block *header)
732 char buffer[BLOCKSIZE];
734 if (archive_format == OLDGNU_FORMAT)
735 header->oldgnu_header.isextended = 0;
737 if (file = open (name, O_RDONLY), file < 0)
738 /* This problem will be caught later on, so just return. */
742 clear_buffer (buffer);
746 /* Realloc the scratch area as necessary. FIXME: should reallocate
747 only at beginning of a new instance of non-zero data. */
749 if (sp_array_size <= sparses)
752 xrealloc (sparsearray,
753 2 * sp_array_size * sizeof (struct sp_array));
757 count = safe_read (file, buffer, sizeof buffer);
761 /* Process one block. */
763 if (count == sizeof buffer)
765 if (zero_block_p (buffer))
769 sparsearray[sparses++].numbytes = numbytes;
776 sparsearray[sparses].offset = offset;
782 /* Since count < sizeof buffer, we have the last bit of the file. */
784 if (!zero_block_p (buffer))
787 sparsearray[sparses].offset = offset;
791 /* The next two lines are suggested by Andreas Degert, who says
792 they are required for trailing full blocks to be written to the
793 archive, when all zeroed. Yet, it seems to me that the case
794 does not apply. Further, at restore time, the file is not as
795 sparse as it should. So, some serious cleanup is *also* needed
796 in this area. Just one more... :-(. FIXME. */
800 /* Prepare for next block. */
803 /* FIXME: do not clear unless necessary. */
804 clear_buffer (buffer);
808 sparsearray[sparses++].numbytes = numbytes;
811 sparsearray[sparses].offset = offset - 1;
812 sparsearray[sparses++].numbytes = 1;
815 return close (file) == 0 && 0 <= count ? sparses : 0;
819 finish_sparse_file (int file, off_t *sizeleft, off_t fullsize, char *name)
826 while (*sizeleft > 0)
828 start = find_next_block ();
829 memset (start->buffer, 0, BLOCKSIZE);
830 bufsize = sparsearray[sparses].numbytes;
834 if (lseek (file, sparsearray[sparses++].offset, SEEK_SET) < 0)
836 (ignore_failed_read_option ? seek_warn_details : seek_error_details)
837 (name, sparsearray[sparses - 1].offset);
841 /* If the number of bytes to be written here exceeds the size of
842 the temporary buffer, do it in steps. */
844 while (bufsize > BLOCKSIZE)
846 count = safe_read (file, start->buffer, BLOCKSIZE);
849 (ignore_failed_read_option
851 : read_error_details)
852 (name, fullsize - *sizeleft, bufsize);
857 set_next_block_after (start);
858 start = find_next_block ();
859 memset (start->buffer, 0, BLOCKSIZE);
863 char buffer[BLOCKSIZE];
865 clear_buffer (buffer);
866 count = safe_read (file, buffer, bufsize);
867 memcpy (start->buffer, buffer, BLOCKSIZE);
872 (ignore_failed_read_option
874 : read_error_details)
875 (name, fullsize - *sizeleft, bufsize);
880 set_next_block_after (start);
884 set_next_block_after (start + (count - 1) / BLOCKSIZE);
889 /* Main functions of this module. */
892 create_archive (void)
896 open_archive (ACCESS_WRITE);
898 if (incremental_option)
900 size_t buffer_size = 1000;
901 char *buffer = xmalloc (buffer_size);
904 collect_and_sort_names ();
906 while (p = name_from_list (), p)
907 if (!excluded_name (p))
908 dump_file (p, -1, (dev_t) 0);
911 while (p = name_from_list (), p)
912 if (!excluded_name (p))
914 size_t plen = strlen (p);
915 if (buffer_size <= plen)
917 while ((buffer_size *= 2) <= plen)
919 buffer = xrealloc (buffer, buffer_size);
921 memcpy (buffer, p, plen);
922 if (! ISSLASH (buffer[plen - 1]))
923 buffer[plen++] = '/';
924 q = gnu_list_name->dir_contents;
928 size_t qlen = strlen (q);
931 if (buffer_size < plen + qlen)
933 while ((buffer_size *=2 ) < plen + qlen)
935 buffer = xrealloc (buffer, buffer_size);
937 strcpy (buffer + plen, q + 1);
938 dump_file (buffer, -1, (dev_t) 0);
947 while (p = name_next (1), p)
948 if (!excluded_name (p))
949 dump_file (p, 1, (dev_t) 0);
955 if (listed_incremental_option)
956 write_directory_file ();
960 /* Calculate the hash of a link. */
962 hash_link (void const *entry, unsigned n_buckets)
964 struct link const *link = entry;
965 return (uintmax_t) (link->dev ^ link->ino) % n_buckets;
968 /* Compare two links for equality. */
970 compare_links (void const *entry1, void const *entry2)
972 struct link const *link1 = entry1;
973 struct link const *link2 = entry2;
974 return ((link1->dev ^ link2->dev) | (link1->ino ^ link2->ino)) == 0;
977 /* Table of all non-directories that we've written so far. Any time
978 we see another, we check the table and avoid dumping the data
979 again if we've done it once already. */
980 static Hash_table *link_table;
982 /* Dump a single file, recursing on directories. P is the file name
983 to dump. TOP_LEVEL tells whether this is a top-level call; zero
984 means no, positive means yes, and negative means the top level
985 of an incremental dump. PARENT_DEVICE is the device of P's
986 parent directory; it is examined only if TOP_LEVEL is zero.
988 Set global CURRENT_STAT_INFO to stat output for this file. */
990 /* FIXME: One should make sure that for *every* path leading to setting
991 exit_status to failure, a clear diagnostic has been issued. */
994 dump_file (char *p, int top_level, dev_t parent_device)
1000 time_t original_ctime;
1001 struct utimbuf restore_times;
1002 off_t block_ordinal = -1;
1004 /* FIXME: `header' might be used uninitialized in this
1005 function. Reported by Bruno Haible. */
1007 if (interactive_option && !confirm ("add", p))
1010 if (deref_stat (dereference_option, p, ¤t_stat_info.stat) != 0)
1012 if (ignore_failed_read_option)
1019 original_ctime = current_stat_info.stat.st_ctime;
1020 restore_times.actime = current_stat_info.stat.st_atime;
1021 restore_times.modtime = current_stat_info.stat.st_mtime;
1024 if (S_ISHIDDEN (current_stat_info.stat.st_mode))
1026 char *new = (char *) alloca (strlen (p) + 2);
1036 /* See if we want only new files, and check if this one is too old to
1037 put in the archive. */
1039 if ((0 < top_level || !incremental_option)
1040 && !S_ISDIR (current_stat_info.stat.st_mode)
1041 && current_stat_info.stat.st_mtime < newer_mtime_option
1042 && (!after_date_option || current_stat_info.stat.st_ctime < newer_ctime_option))
1045 WARN ((0, 0, _("%s: file is unchanged; not dumped"),
1046 quotearg_colon (p)));
1047 /* FIXME: recheck this return. */
1052 /* See if we are trying to dump the archive. */
1054 if (ar_dev && current_stat_info.stat.st_dev == ar_dev && current_stat_info.stat.st_ino == ar_ino)
1056 WARN ((0, 0, _("%s: file is the archive; not dumped"),
1057 quotearg_colon (p)));
1062 if (S_ISDIR (current_stat_info.stat.st_mode))
1070 dev_t our_device = current_stat_info.stat.st_dev;
1074 directory = savedir (p);
1077 if (ignore_failed_read_option)
1084 /* Build new prototype name. Ensure exactly one trailing slash. */
1087 buflen = len + NAME_FIELD_SIZE;
1088 namebuf = xmalloc (buflen + 1);
1089 memcpy (namebuf, p, len);
1090 while (len >= 1 && ISSLASH (namebuf[len - 1]))
1092 namebuf[len++] = '/';
1093 namebuf[len] = '\0';
1095 if (! is_avoided_name (namebuf))
1097 /* The condition above used to be "archive_format != V7_FORMAT".
1098 GNU tar was not writing directory blocks at all. Daniel Trinkle
1099 writes: ``All old versions of tar I have ever seen have
1100 correctly archived an empty directory. The really old ones I
1101 checked included HP-UX 7 and Mt. Xinu More/BSD. There may be
1102 some subtle reason for the exclusion that I don't know, but the
1103 current behavior is broken.'' I do not know those subtle
1104 reasons either, so until these are reported (anew?), just allow
1105 directory blocks to be written even with old archives. */
1107 block_ordinal = current_block_ordinal ();
1108 current_stat_info.stat.st_size = 0; /* force 0 size on dir */
1110 /* FIXME: If people could really read standard archives, this
1114 = start_header (standard_option ? p : namebuf, ¤t_stat_info);
1116 but since they'd interpret DIRTYPE blocks as regular
1117 files, we'd better put the / on the name. */
1119 header = start_header (namebuf, ¤t_stat_info);
1121 if (incremental_option)
1122 header->header.typeflag = GNUTYPE_DUMPDIR;
1123 else /* if (standard_option) */
1124 header->header.typeflag = DIRTYPE;
1126 /* If we're gnudumping, we aren't done yet so don't close it. */
1128 if (!incremental_option)
1129 finish_header (header, block_ordinal);
1132 if (incremental_option && gnu_list_name->dir_contents)
1139 const char *buffer, *p_buffer;
1141 buffer = gnu_list_name->dir_contents; /* FOO */
1144 for (p_buffer = buffer; *p_buffer; )
1146 size_t size = strlen (p_buffer) + 1;
1151 OFF_TO_CHARS (totsize, header->header.size);
1152 finish_header (header, block_ordinal);
1155 while (sizeleft > 0)
1157 if (multi_volume_option)
1159 assign_string (&save_name, p);
1160 save_sizeleft = sizeleft;
1161 save_totsize = totsize;
1163 start = find_next_block ();
1164 bufsize = available_space_after (start);
1165 if (sizeleft < bufsize)
1168 count = bufsize % BLOCKSIZE;
1170 memset (start->buffer + sizeleft, 0, BLOCKSIZE - count);
1172 memcpy (start->buffer, p_buffer, bufsize);
1173 sizeleft -= bufsize;
1174 p_buffer += bufsize;
1175 set_next_block_after (start + (bufsize - 1) / BLOCKSIZE);
1177 if (multi_volume_option)
1178 assign_string (&save_name, 0);
1182 /* See if we are about to recurse into a directory, and avoid doing
1183 so if the user wants that we do not descend into directories. */
1185 if (! recursion_option)
1188 /* See if we are crossing from one file system to another, and
1189 avoid doing so if the user only wants to dump one file system. */
1191 if (one_file_system_option && !top_level
1192 && parent_device != current_stat_info.stat.st_dev)
1196 _("%s: file is on a different filesystem; not dumped"),
1197 quotearg_colon (p)));
1201 /* Now output all the files in the directory. */
1203 /* FIXME: Should speed this up by cd-ing into the dir. */
1205 for (entry = directory;
1206 (entrylen = strlen (entry)) != 0;
1207 entry += entrylen + 1)
1209 if (buflen < len + entrylen)
1211 buflen = len + entrylen;
1212 namebuf = xrealloc (namebuf, buflen + 1);
1214 strcpy (namebuf + len, entry);
1215 if (!excluded_name (namebuf))
1216 dump_file (namebuf, 0, our_device);
1223 if (atime_preserve_option)
1224 utime (p, &restore_times);
1227 else if (is_avoided_name (p))
1231 /* Check for multiple links. */
1233 if (1 < current_stat_info.stat.st_nlink && link_table)
1237 lp.ino = current_stat_info.stat.st_ino;
1238 lp.dev = current_stat_info.stat.st_dev;
1240 if ((dup = hash_lookup (link_table, &lp)))
1242 /* We found a link. */
1243 char const *link_name = safer_name_suffix (dup->name, 1);
1247 block_ordinal = current_block_ordinal ();
1248 if (NAME_FIELD_SIZE <= strlen (link_name))
1249 write_long (link_name, GNUTYPE_LONGLINK);
1250 assign_string (¤t_stat_info.link_name, link_name);
1252 current_stat_info.stat.st_size = 0;
1253 header = start_header (p, ¤t_stat_info);
1254 strncpy (header->header.linkname, link_name, NAME_FIELD_SIZE);
1256 /* Force null termination. */
1257 header->header.linkname[NAME_FIELD_SIZE - 1] = 0;
1259 header->header.typeflag = LNKTYPE;
1260 finish_header (header, block_ordinal);
1262 /* FIXME: Maybe remove from table after all links found? */
1264 if (remove_files_option && unlink (p) != 0)
1267 /* We dumped it, and we don't need to put it in the
1273 /* This is not a link to a previously dumped file, so dump it. */
1275 if (S_ISREG (current_stat_info.stat.st_mode)
1276 || S_ISCTG (current_stat_info.stat.st_mode))
1278 int f; /* file descriptor */
1284 char isextended = 0;
1291 /* Check the size of the file against the number of blocks
1292 allocated for it, counting both data and indirect blocks.
1293 If there is a smaller number of blocks than would be
1294 necessary to accommodate a file of this size, this is safe
1295 to say that we have a sparse file: at least one of those
1296 blocks in the file is just a useless hole. For sparse
1297 files not having more hole blocks than indirect blocks, the
1298 sparseness will go undetected. */
1300 /* Bruno Haible sent me these statistics for Linux. It seems
1301 that some filesystems count indirect blocks in st_blocks,
1302 while others do not seem to:
1304 minix-fs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1305 extfs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1306 ext2fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1307 msdos-fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1309 Dick Streefland reports the previous numbers as misleading,
1310 because ext2fs use 12 direct blocks, while minix-fs uses only
1311 6 direct blocks. Dick gets:
1313 ext2 size=20480 ls listed blocks=21
1314 minix size=20480 ls listed blocks=21
1315 msdos size=20480 ls listed blocks=20
1317 It seems that indirect blocks *are* included in st_blocks.
1318 The minix filesystem does not account for phantom blocks in
1319 st_blocks, so `du' and `ls -s' give wrong results. So, the
1320 --sparse option would not work on a minix filesystem. */
1322 if (ST_NBLOCKS (current_stat_info.stat)
1323 < (current_stat_info.stat.st_size / ST_NBLOCKSIZE
1324 + (current_stat_info.stat.st_size % ST_NBLOCKSIZE != 0)))
1328 block_ordinal = current_block_ordinal ();
1329 header = start_header (p, ¤t_stat_info);
1330 header->header.typeflag = GNUTYPE_SPARSE;
1333 /* Call the routine that figures out the layout of the
1334 sparse file in question. SPARSES is the index of the
1335 first unused element of the "sparsearray," i.e.,
1336 the number of elements it needed to describe the file. */
1338 sparses = deal_with_sparse (p, header);
1340 /* See if we'll need an extended header later. */
1342 if (SPARSES_IN_OLDGNU_HEADER < sparses)
1343 header->oldgnu_header.isextended = 1;
1345 /* We store the "real" file size so we can show that in
1346 case someone wants to list the archive, i.e., tar tvf
1347 <file>. It might be kind of disconcerting if the
1348 shrunken file size was the one that showed up. */
1350 OFF_TO_CHARS (current_stat_info.stat.st_size,
1351 header->oldgnu_header.realsize);
1353 /* This will be the new "size" of the file, i.e., the size
1354 of the file minus the blocks of holes that we're
1357 current_stat_info.stat.st_size = find_new_file_size (sparses);
1358 OFF_TO_CHARS (current_stat_info.stat.st_size, header->header.size);
1361 counter < sparses && counter < SPARSES_IN_OLDGNU_HEADER;
1364 OFF_TO_CHARS (sparsearray[counter].offset,
1365 header->oldgnu_header.sp[counter].offset);
1366 SIZE_TO_CHARS (sparsearray[counter].numbytes,
1367 header->oldgnu_header.sp[counter].numbytes);
1372 sizeleft = current_stat_info.stat.st_size;
1374 /* Don't bother opening empty, world readable files. Also do not open
1375 files when archive is meant for /dev/null. */
1379 && MODE_R == (MODE_R & current_stat_info.stat.st_mode)))
1383 f = open (p, O_RDONLY | O_BINARY);
1386 if (! top_level && errno == ENOENT)
1387 WARN ((0, 0, _("%s: File removed before we read it"),
1388 quotearg_colon (p)));
1390 (ignore_failed_read_option ? open_warn : open_error) (p);
1395 /* If the file is sparse, we've already taken care of this. */
1399 block_ordinal = current_block_ordinal ();
1400 header = start_header (p, ¤t_stat_info);
1403 /* Mark contiguous files, if we support them. */
1405 if (archive_format != V7_FORMAT && S_ISCTG (current_stat_info.stat.st_mode))
1406 header->header.typeflag = CONTTYPE;
1408 isextended = header->oldgnu_header.isextended;
1409 save_typeflag = header->header.typeflag;
1410 finish_header (header, block_ordinal);
1413 int sparses_emitted = SPARSES_IN_OLDGNU_HEADER;
1418 exhdr = find_next_block ();
1419 memset (exhdr->buffer, 0, BLOCKSIZE);
1421 (i < SPARSES_IN_SPARSE_HEADER
1422 && sparses_emitted + i < sparses);
1425 SIZE_TO_CHARS (sparsearray[sparses_emitted + i].numbytes,
1426 exhdr->sparse_header.sp[i].numbytes);
1427 OFF_TO_CHARS (sparsearray[sparses_emitted + i].offset,
1428 exhdr->sparse_header.sp[i].offset);
1430 set_next_block_after (exhdr);
1431 sparses_emitted += i;
1432 if (sparses == sparses_emitted)
1434 exhdr->sparse_header.isextended = 1;
1437 if (save_typeflag == GNUTYPE_SPARSE)
1440 || finish_sparse_file (f, &sizeleft,
1441 current_stat_info.stat.st_size, p))
1445 while (sizeleft > 0)
1447 if (multi_volume_option)
1449 assign_string (&save_name, p);
1450 save_sizeleft = sizeleft;
1451 save_totsize = current_stat_info.stat.st_size;
1453 start = find_next_block ();
1455 bufsize = available_space_after (start);
1457 if (sizeleft < bufsize)
1459 /* Last read -- zero out area beyond. */
1462 count = bufsize % BLOCKSIZE;
1464 memset (start->buffer + sizeleft, 0, BLOCKSIZE - count);
1469 count = safe_read (f, start->buffer, bufsize);
1472 (ignore_failed_read_option
1474 : read_error_details)
1475 (p, current_stat_info.stat.st_size - sizeleft, bufsize);
1480 /* This is nonportable (the type of set_next_block_after's arg). */
1482 set_next_block_after (start + (bufsize - 1) / BLOCKSIZE);
1485 if (count != bufsize)
1487 char buf[UINTMAX_STRSIZE_BOUND];
1488 memset (start->buffer + count, 0, bufsize - count);
1490 _("%s: File shrank by %s bytes; padding with zeros"),
1492 STRINGIFY_BIGINT (sizeleft, buf)));
1493 if (! ignore_failed_read_option)
1494 exit_status = TAREXIT_FAILURE;
1495 goto padit; /* short read */
1499 if (multi_volume_option)
1500 assign_string (&save_name, 0);
1504 struct stat final_stat;
1505 if (fstat (f, &final_stat) != 0)
1507 if (ignore_failed_read_option)
1512 else if (final_stat.st_ctime != original_ctime)
1514 char const *qp = quotearg_colon (p);
1515 WARN ((0, 0, _("%s: file changed as we read it"), qp));
1519 if (ignore_failed_read_option)
1524 if (atime_preserve_option)
1525 utime (p, &restore_times);
1527 if (remove_files_option)
1529 if (unlink (p) == -1)
1532 goto file_was_dumped;
1534 /* File shrunk or gave error, pad out tape to match the size we
1535 specified in the header. */
1538 while (sizeleft > 0)
1540 save_sizeleft = sizeleft;
1541 start = find_next_block ();
1542 memset (start->buffer, 0, BLOCKSIZE);
1543 set_next_block_after (start);
1544 sizeleft -= BLOCKSIZE;
1546 if (multi_volume_option)
1547 assign_string (&save_name, 0);
1551 if (atime_preserve_option)
1552 utime (p, &restore_times);
1554 goto file_was_dumped;
1556 #ifdef HAVE_READLINK
1557 else if (S_ISLNK (current_stat_info.stat.st_mode))
1561 size_t linklen = current_stat_info.stat.st_size;
1562 if (linklen != current_stat_info.stat.st_size || linklen + 1 == 0)
1564 buffer = (char *) alloca (linklen + 1);
1565 size = readlink (p, buffer, linklen + 1);
1568 if (ignore_failed_read_option)
1574 buffer[size] = '\0';
1575 if (size >= NAME_FIELD_SIZE)
1576 write_long (buffer, GNUTYPE_LONGLINK);
1577 assign_string (¤t_stat_info.link_name, buffer);
1579 block_ordinal = current_block_ordinal ();
1580 current_stat_info.stat.st_size = 0; /* force 0 size on symlink */
1581 header = start_header (p, ¤t_stat_info);
1582 strncpy (header->header.linkname, buffer, NAME_FIELD_SIZE);
1583 header->header.linkname[NAME_FIELD_SIZE - 1] = '\0';
1584 header->header.typeflag = SYMTYPE;
1585 finish_header (header, block_ordinal);
1586 /* nothing more to do to it */
1588 if (remove_files_option)
1590 if (unlink (p) == -1)
1593 goto file_was_dumped;
1596 else if (S_ISCHR (current_stat_info.stat.st_mode))
1598 else if (S_ISBLK (current_stat_info.stat.st_mode))
1600 else if (S_ISFIFO (current_stat_info.stat.st_mode))
1602 else if (S_ISSOCK (current_stat_info.stat.st_mode))
1604 WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p)));
1607 else if (S_ISDOOR (current_stat_info.stat.st_mode))
1609 WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p)));
1616 if (archive_format == V7_FORMAT)
1619 block_ordinal = current_block_ordinal ();
1620 current_stat_info.stat.st_size = 0; /* force 0 size */
1621 header = start_header (p, ¤t_stat_info);
1622 header->header.typeflag = type;
1624 if (type != FIFOTYPE)
1626 MAJOR_TO_CHARS (major (current_stat_info.stat.st_rdev), header->header.devmajor);
1627 MINOR_TO_CHARS (minor (current_stat_info.stat.st_rdev), header->header.devminor);
1630 finish_header (header, block_ordinal);
1631 if (remove_files_option)
1633 if (unlink (p) == -1)
1636 goto file_was_dumped;
1639 WARN ((0, 0, _("%s: Unknown file type; file ignored"),
1640 quotearg_colon (p)));
1641 if (! ignore_failed_read_option)
1642 exit_status = TAREXIT_FAILURE;
1646 if (1 < current_stat_info.stat.st_nlink)
1649 struct link *lp = xmalloc (offsetof (struct link, name)
1651 lp->ino = current_stat_info.stat.st_ino;
1652 lp->dev = current_stat_info.stat.st_dev;
1653 lp->nlink = current_stat_info.stat.st_nlink;
1654 strcpy (lp->name, p);
1657 || (link_table = hash_initialize (0, 0, hash_link,
1659 && (dup = hash_insert (link_table, lp))))
1669 /* For each dumped file, check if all its links were dumped. Emit
1670 warnings if it is not so. */
1679 for (lp = hash_get_first (link_table); lp;
1680 lp = hash_get_next (link_table, lp))
1684 WARN ((0, 0, _("Missing links to '%s'.\n"), lp->name));