1 /* Create a tar archive.
2 Copyright 1985, 92, 93, 94, 96, 97, 99, 2000 Free Software Foundation, Inc.
3 Written by John Gilmore, on 1985-08-25.
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 2, or (at your option) any later
10 This program is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
13 Public License for more details.
15 You should have received a copy of the GNU General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
53 /* The maximum uintmax_t value that can be represented with DIGITS digits,
54 assuming that each digit is BITS_PER_DIGIT wide. */
55 #define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
56 ((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
57 ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
60 /* Convert VALUE to an octal representation suitable for tar headers.
61 Output to buffer WHERE with size SIZE.
62 The result is undefined if SIZE is 0 or if VALUE is too large to fit. */
65 to_octal (uintmax_t value
, char *where
, size_t size
)
72 where
[--i
] = '0' + (v
& ((1 << LG_8
) - 1));
78 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
79 tar headers. NEGATIVE is 1 if VALUE was negative before being cast
80 to uintmax_t, 0 otherwise. Output to buffer WHERE with size SIZE.
81 The result is undefined if SIZE is 0 or if VALUE is too large to
85 to_base256 (int negative
, uintmax_t value
, char *where
, size_t size
)
88 uintmax_t propagated_sign_bits
=
89 ((uintmax_t) - negative
<< (CHAR_BIT
* sizeof v
- LG_256
));
94 where
[--i
] = v
& ((1 << LG_256
) - 1);
95 v
= propagated_sign_bits
| (v
>> LG_256
);
100 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
101 external form, using SUBSTITUTE (...) if VALUE won't fit. Output
102 to buffer WHERE with size SIZE. NEGATIVE is 1 iff VALUE was
103 negative before being cast to uintmax_t; its original bitpattern
104 can be deduced from VALSIZE, its original size before casting.
105 TYPE is the kind of value being output (useful for diagnostics).
106 Prefer the POSIX format of SIZE - 1 octal digits (with leading zero
107 digits), followed by '\0'. If this won't work, and if GNU or
108 OLDGNU format is allowed, use '\200' followed by base-256, or (if
109 NEGATIVE is nonzero) '\377' followed by two's complement base-256.
110 If neither format works, use SUBSTITUTE (...) instead. Pass to
111 SUBSTITUTE the address of an 0-or-1 flag recording whether the
112 substitute value is negative. */
115 to_chars (int negative
, uintmax_t value
, size_t valsize
,
116 uintmax_t (*substitute
) PARAMS ((int *)),
117 char *where
, size_t size
, const char *type
)
119 int base256_allowed
= (archive_format
== GNU_FORMAT
120 || archive_format
== OLDGNU_FORMAT
);
122 /* Generate the POSIX octal representation if the number fits. */
123 if (! negative
&& value
<= MAX_VAL_WITH_DIGITS (size
- 1, LG_8
))
125 where
[size
- 1] = '\0';
126 to_octal (value
, where
, size
- 1);
129 /* Otherwise, generate the base-256 representation if we are
130 generating an old or new GNU format and if the number fits. */
131 else if (((negative
? -1 - value
: value
)
132 <= MAX_VAL_WITH_DIGITS (size
- 1, LG_256
))
135 where
[0] = negative
? -1 : 1 << (LG_256
- 1);
136 to_base256 (negative
, value
, where
+ 1, size
- 1);
139 /* Otherwise, if the number is negative, and if it would not cause
140 ambiguity on this host by confusing positive with negative
141 values, then generate the POSIX octal representation of the value
142 modulo 2**(field bits). The resulting tar file is
143 machine-dependent, since it depends on the host word size. Yuck!
144 But this is the traditional behavior. */
145 else if (negative
&& valsize
* CHAR_BIT
<= (size
- 1) * LG_8
)
147 static int warned_once
;
151 WARN ((0, 0, _("Generating negative octal headers")));
153 where
[size
- 1] = '\0';
154 to_octal (value
& MAX_VAL_WITH_DIGITS (valsize
* CHAR_BIT
, 1),
158 /* Otherwise, output a substitute value if possible (with a
159 warning), and an error message if not. */
162 uintmax_t maxval
= (base256_allowed
163 ? MAX_VAL_WITH_DIGITS (size
- 1, LG_256
)
164 : MAX_VAL_WITH_DIGITS (size
- 1, LG_8
));
165 char valbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
166 char maxbuf
[UINTMAX_STRSIZE_BOUND
];
167 char minbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
168 char const *minval_string
;
169 char const *maxval_string
= STRINGIFY_BIGINT (maxval
, maxbuf
);
170 char const *value_string
;
174 uintmax_t m
= maxval
+ 1 ? maxval
+ 1 : maxval
/ 2 + 1;
175 char *p
= STRINGIFY_BIGINT (m
, minbuf
+ 1);
184 char *p
= STRINGIFY_BIGINT (- value
, valbuf
+ 1);
189 value_string
= STRINGIFY_BIGINT (value
, valbuf
);
194 uintmax_t sub
= substitute (&negsub
) & maxval
;
195 uintmax_t s
= (negsub
&= archive_format
== GNU_FORMAT
) ? - sub
: sub
;
196 char subbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
197 char *sub_string
= STRINGIFY_BIGINT (s
, subbuf
+ 1);
200 WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
201 value_string
, type
, minval_string
, maxval_string
,
203 to_chars (negsub
, s
, valsize
, 0, where
, size
, type
);
206 ERROR ((0, 0, _("value %s out of %s range %s..%s"),
207 value_string
, type
, minval_string
, maxval_string
));
212 gid_substitute (int *negative
)
218 static gid_t gid_nobody
;
219 if (!gid_nobody
&& !gname_to_gid ("nobody", &gid_nobody
))
228 gid_to_chars (gid_t v
, char *p
, size_t s
)
230 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, gid_substitute
, p
, s
, "gid_t");
234 major_to_chars (major_t v
, char *p
, size_t s
)
236 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "major_t");
240 minor_to_chars (minor_t v
, char *p
, size_t s
)
242 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "minor_t");
246 mode_to_chars (mode_t v
, char *p
, size_t s
)
248 /* In the common case where the internal and external mode bits are the same,
249 and we are not using POSIX or GNU format,
250 propagate all unknown bits to the external mode.
251 This matches historical practice.
252 Otherwise, just copy the bits we know about. */
255 if (S_ISUID
== TSUID
&& S_ISGID
== TSGID
&& S_ISVTX
== TSVTX
256 && S_IRUSR
== TUREAD
&& S_IWUSR
== TUWRITE
&& S_IXUSR
== TUEXEC
257 && S_IRGRP
== TGREAD
&& S_IWGRP
== TGWRITE
&& S_IXGRP
== TGEXEC
258 && S_IROTH
== TOREAD
&& S_IWOTH
== TOWRITE
&& S_IXOTH
== TOEXEC
259 && archive_format
!= POSIX_FORMAT
260 && archive_format
!= GNU_FORMAT
)
268 u
= ((v
& S_ISUID
? TSUID
: 0)
269 | (v
& S_ISGID
? TSGID
: 0)
270 | (v
& S_ISVTX
? TSVTX
: 0)
271 | (v
& S_IRUSR
? TUREAD
: 0)
272 | (v
& S_IWUSR
? TUWRITE
: 0)
273 | (v
& S_IXUSR
? TUEXEC
: 0)
274 | (v
& S_IRGRP
? TGREAD
: 0)
275 | (v
& S_IWGRP
? TGWRITE
: 0)
276 | (v
& S_IXGRP
? TGEXEC
: 0)
277 | (v
& S_IROTH
? TOREAD
: 0)
278 | (v
& S_IWOTH
? TOWRITE
: 0)
279 | (v
& S_IXOTH
? TOEXEC
: 0));
281 to_chars (negative
, u
, sizeof v
, 0, p
, s
, "mode_t");
285 off_to_chars (off_t v
, char *p
, size_t s
)
287 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "off_t");
291 size_to_chars (size_t v
, char *p
, size_t s
)
293 to_chars (0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "size_t");
297 time_to_chars (time_t v
, char *p
, size_t s
)
299 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "time_t");
303 uid_substitute (int *negative
)
309 static uid_t uid_nobody
;
310 if (!uid_nobody
&& !uname_to_uid ("nobody", &uid_nobody
))
319 uid_to_chars (uid_t v
, char *p
, size_t s
)
321 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, uid_substitute
, p
, s
, "uid_t");
325 uintmax_to_chars (uintmax_t v
, char *p
, size_t s
)
327 to_chars (0, v
, sizeof v
, 0, p
, s
, "uintmax_t");
330 /* Writing routines. */
332 /* Zero out the buffer so we don't confuse ourselves with leftover
335 clear_buffer (char *buffer
)
337 memset (buffer
, 0, BLOCKSIZE
);
340 /* Write the EOT block(s). Zero at least two blocks, through the end
341 of the record. Old tar, as previous versions of GNU tar, writes
342 garbage after two zeroed blocks. */
346 union block
*pointer
= find_next_block ();
347 memset (pointer
->buffer
, 0, BLOCKSIZE
);
348 set_next_block_after (pointer
);
349 pointer
= find_next_block ();
350 memset (pointer
->buffer
, 0, available_space_after (pointer
));
351 set_next_block_after (pointer
);
354 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. */
356 /* FIXME: Cross recursion between start_header and write_long! */
358 static union block
*start_header
PARAMS ((const char *, struct stat
*));
361 write_long (const char *p
, char type
)
363 size_t size
= strlen (p
) + 1;
368 memset (&foo
, 0, sizeof foo
);
371 header
= start_header ("././@LongLink", &foo
);
372 header
->header
.typeflag
= type
;
373 finish_header (header
);
375 header
= find_next_block ();
377 bufsize
= available_space_after (header
);
379 while (bufsize
< size
)
381 memcpy (header
->buffer
, p
, bufsize
);
384 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
385 header
= find_next_block ();
386 bufsize
= available_space_after (header
);
388 memcpy (header
->buffer
, p
, size
);
389 memset (header
->buffer
+ size
, 0, bufsize
- size
);
390 set_next_block_after (header
+ (size
- 1) / BLOCKSIZE
);
393 /* Header handling. */
395 /* Make a header block for the file whose stat info is st,
396 and return its address. */
399 start_header (const char *name
, struct stat
*st
)
403 if (!absolute_names_option
)
405 size_t prefix_len
= FILESYSTEM_PREFIX_LEN (name
);
409 static int warned_once
;
413 WARN ((0, 0, _("Removing leading `%.*s' from member names"),
414 (int) prefix_len
, name
));
421 static int warned_once
;
425 WARN ((0, 0, _("Removing leading `/' from member names")));
431 static int warned_once
;
432 if (! warned_once
&& contains_dot_dot (name
))
435 WARN ((0, 0, _("Member names contain `..'")));
440 if (sizeof header
->header
.name
<= strlen (name
))
441 write_long (name
, GNUTYPE_LONGNAME
);
442 header
= find_next_block ();
443 memset (header
->buffer
, 0, sizeof (union block
));
445 assign_string (¤t_file_name
, name
);
447 strncpy (header
->header
.name
, name
, NAME_FIELD_SIZE
);
448 header
->header
.name
[NAME_FIELD_SIZE
- 1] = '\0';
450 /* Override some stat fields, if requested to do so. */
452 if (owner_option
!= (uid_t
) -1)
453 st
->st_uid
= owner_option
;
454 if (group_option
!= (gid_t
) -1)
455 st
->st_gid
= group_option
;
457 st
->st_mode
= ((st
->st_mode
& ~MODE_ALL
)
458 | mode_adjust (st
->st_mode
, mode_option
));
460 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
461 for a few tars and came up with the following interoperability
465 1 2 3 4 5 6 7 8 9 READER
466 . . . . . . . . . 1 = SunOS 4.2 tar
467 # . . # # . . # # 2 = NEC SVR4.0.2 tar
468 . . . # # . . # . 3 = Solaris 2.1 tar
469 . . . . . . . . . 4 = GNU tar 1.11.1
470 . . . . . . . . . 5 = HP-UX 8.07 tar
471 . . . . . . . . . 6 = Ultrix 4.1
472 . . . . . . . . . 7 = AIX 3.2
473 . . . . . . . . . 8 = Hitachi HI-UX 1.03
474 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
477 # = ``impossible file type''
479 The following mask for old archive removes the `#'s in column 4
480 above, thus making GNU tar both a universal donor and a universal
481 acceptor for Paul's test. */
483 if (archive_format
== V7_FORMAT
)
484 MODE_TO_CHARS (st
->st_mode
& MODE_ALL
, header
->header
.mode
);
486 MODE_TO_CHARS (st
->st_mode
, header
->header
.mode
);
488 UID_TO_CHARS (st
->st_uid
, header
->header
.uid
);
489 GID_TO_CHARS (st
->st_gid
, header
->header
.gid
);
490 OFF_TO_CHARS (st
->st_size
, header
->header
.size
);
491 TIME_TO_CHARS (st
->st_mtime
, header
->header
.mtime
);
493 if (incremental_option
)
494 if (archive_format
== OLDGNU_FORMAT
)
496 TIME_TO_CHARS (st
->st_atime
, header
->oldgnu_header
.atime
);
497 TIME_TO_CHARS (st
->st_ctime
, header
->oldgnu_header
.ctime
);
500 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
502 switch (archive_format
)
508 /* Overwrite header->header.magic and header.version in one blow. */
509 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
514 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
515 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
522 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
524 /* header->header.[ug]name are left as the empty string. */
528 uid_to_uname (st
->st_uid
, header
->header
.uname
);
529 gid_to_gname (st
->st_gid
, header
->header
.gname
);
535 /* Finish off a filled-in header block and write it out. We also
536 print the file name and/or full info if verbose is on. */
538 finish_header (union block
*header
)
544 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
548 for (i
= sizeof *header
; i
-- != 0; )
549 /* We can't use unsigned char here because of old compilers, e.g. V7. */
552 /* Fill in the checksum field. It's formatted differently from the
553 other fields: it has [6] digits, a null, then a space -- rather than
554 digits, then a null. We use to_chars.
555 The final space is already there, from
556 checksumming, and to_chars doesn't modify it.
558 This is a fast way to do:
560 sprintf(header->header.chksum, "%6o", sum); */
562 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
565 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
566 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
)
568 /* These globals are parameters to print_header, sigh. */
570 current_header
= header
;
571 /* current_stat is already set up. */
572 current_format
= archive_format
;
576 set_next_block_after (header
);
579 /* Sparse file processing. */
581 /* Takes a blockful of data and basically cruises through it to see if
582 it's made *entirely* of zeros, returning a 0 the instant it finds
583 something that is a nonzero, i.e., useful data. */
585 zero_block_p (char *buffer
)
589 for (counter
= 0; counter
< BLOCKSIZE
; counter
++)
590 if (buffer
[counter
] != '\0')
596 init_sparsearray (void)
602 /* Make room for our scratch space -- initially is 10 elts long. */
604 sparsearray
= xmalloc (sp_array_size
* sizeof (struct sp_array
));
605 for (counter
= 0; counter
< sp_array_size
; counter
++)
607 sparsearray
[counter
].offset
= 0;
608 sparsearray
[counter
].numbytes
= 0;
613 find_new_file_size (int sparses
)
617 for (i
= 0; i
< sparses
; i
++)
618 s
+= sparsearray
[i
].numbytes
;
622 /* Make one pass over the file NAME, studying where any non-zero data
623 is, that is, how far into the file each instance of data is, and
624 how many bytes are there. Save this information in the
625 sparsearray, which will later be translated into header
628 /* There is little point in trimming small amounts of null data at the head
629 and tail of blocks, only avoid dumping full null blocks. */
631 /* FIXME: this routine might accept bits of algorithmic cleanup, it is
632 too kludgey for my taste... */
635 deal_with_sparse (char *name
, union block
*header
)
642 char buffer
[BLOCKSIZE
];
644 if (archive_format
== OLDGNU_FORMAT
)
645 header
->oldgnu_header
.isextended
= 0;
647 if (file
= open (name
, O_RDONLY
), file
< 0)
648 /* This problem will be caught later on, so just return. */
652 clear_buffer (buffer
);
654 while (0 < (count
= safe_read (file
, buffer
, sizeof buffer
)))
656 /* Realloc the scratch area as necessary. FIXME: should reallocate
657 only at beginning of a new instance of non-zero data. */
659 if (sp_array_size
<= sparses
)
662 xrealloc (sparsearray
,
663 2 * sp_array_size
* sizeof (struct sp_array
));
667 /* Process one block. */
669 if (count
== sizeof buffer
)
671 if (zero_block_p (buffer
))
675 sparsearray
[sparses
++].numbytes
= numbytes
;
682 sparsearray
[sparses
].offset
= offset
;
688 /* Since count < sizeof buffer, we have the last bit of the file. */
690 if (!zero_block_p (buffer
))
693 sparsearray
[sparses
].offset
= offset
;
697 /* The next two lines are suggested by Andreas Degert, who says
698 they are required for trailing full blocks to be written to the
699 archive, when all zeroed. Yet, it seems to me that the case
700 does not apply. Further, at restore time, the file is not as
701 sparse as it should. So, some serious cleanup is *also* needed
702 in this area. Just one more... :-(. FIXME. */
706 /* Prepare for next block. */
709 /* FIXME: do not clear unless necessary. */
710 clear_buffer (buffer
);
714 sparsearray
[sparses
++].numbytes
= numbytes
;
717 sparsearray
[sparses
].offset
= offset
- 1;
718 sparsearray
[sparses
++].numbytes
= 1;
721 return close (file
) == 0 && 0 <= count
? sparses
: 0;
725 finish_sparse_file (int file
, off_t
*sizeleft
, off_t fullsize
, char *name
)
732 while (*sizeleft
> 0)
734 start
= find_next_block ();
735 memset (start
->buffer
, 0, BLOCKSIZE
);
736 bufsize
= sparsearray
[sparses
].numbytes
;
740 if (lseek (file
, sparsearray
[sparses
++].offset
, SEEK_SET
) < 0)
742 (ignore_failed_read_option
? seek_warn_details
: seek_error_details
)
743 (name
, sparsearray
[sparses
- 1].offset
);
747 /* If the number of bytes to be written here exceeds the size of
748 the temporary buffer, do it in steps. */
750 while (bufsize
> BLOCKSIZE
)
752 count
= safe_read (file
, start
->buffer
, BLOCKSIZE
);
755 (ignore_failed_read_option
757 : read_error_details
)
758 (name
, fullsize
- *sizeleft
, bufsize
);
763 set_next_block_after (start
);
764 start
= find_next_block ();
765 memset (start
->buffer
, 0, BLOCKSIZE
);
769 char buffer
[BLOCKSIZE
];
771 clear_buffer (buffer
);
772 count
= safe_read (file
, buffer
, bufsize
);
773 memcpy (start
->buffer
, buffer
, BLOCKSIZE
);
778 (ignore_failed_read_option
780 : read_error_details
)
781 (name
, fullsize
- *sizeleft
, bufsize
);
786 set_next_block_after (start
);
790 set_next_block_after (start
+ (count
- 1) / BLOCKSIZE
);
795 /* Main functions of this module. */
798 create_archive (void)
802 open_archive (ACCESS_WRITE
);
804 if (incremental_option
)
806 size_t buffer_size
= 1000;
807 char *buffer
= xmalloc (buffer_size
);
810 collect_and_sort_names ();
812 while (p
= name_from_list (), p
)
813 if (!excluded_name (p
))
814 dump_file (p
, -1, (dev_t
) 0);
817 while (p
= name_from_list (), p
)
818 if (!excluded_name (p
))
820 size_t plen
= strlen (p
);
821 if (buffer_size
<= plen
)
823 while ((buffer_size
*= 2) <= plen
)
825 buffer
= xrealloc (buffer
, buffer_size
);
827 memcpy (buffer
, p
, plen
);
828 if (buffer
[plen
- 1] != '/')
829 buffer
[plen
++] = '/';
830 q
= gnu_list_name
->dir_contents
;
834 size_t qlen
= strlen (q
);
837 if (buffer_size
< plen
+ qlen
)
839 while ((buffer_size
*=2 ) < plen
+ qlen
)
841 buffer
= xrealloc (buffer
, buffer_size
);
843 strcpy (buffer
+ plen
, q
+ 1);
844 dump_file (buffer
, -1, (dev_t
) 0);
853 while (p
= name_next (1), p
)
854 if (!excluded_name (p
))
855 dump_file (p
, 1, (dev_t
) 0);
861 if (listed_incremental_option
)
862 write_directory_file ();
866 /* Calculate the hash of a link. */
868 hash_link (void const *entry
, unsigned n_buckets
)
870 struct link
const *link
= entry
;
871 return (uintmax_t) (link
->dev
^ link
->ino
) % n_buckets
;
874 /* Compare two links for equality. */
876 compare_links (void const *entry1
, void const *entry2
)
878 struct link
const *link1
= entry1
;
879 struct link
const *link2
= entry2
;
880 return ((link1
->dev
^ link2
->dev
) | (link1
->ino
^ link2
->ino
)) == 0;
883 /* Dump a single file, recursing on directories. P is the file name
884 to dump. TOP_LEVEL tells whether this is a top-level call; zero
885 means no, positive means yes, and negative means an incremental
886 dump. PARENT_DEVICE is the device of P's
887 parent directory; it is examined only if TOP_LEVEL is zero.
889 Set global CURRENT_STAT to stat output for this file. */
891 /* FIXME: One should make sure that for *every* path leading to setting
892 exit_status to failure, a clear diagnostic has been issued. */
895 dump_file (char *p
, int top_level
, dev_t parent_device
)
901 time_t original_ctime
;
902 struct utimbuf restore_times
;
904 /* FIXME: `header' might be used uninitialized in this
905 function. Reported by Bruno Haible. */
907 if (interactive_option
&& !confirm ("add", p
))
910 if (deref_stat (dereference_option
, p
, ¤t_stat
) != 0)
912 if (ignore_failed_read_option
)
919 original_ctime
= current_stat
.st_ctime
;
920 restore_times
.actime
= current_stat
.st_atime
;
921 restore_times
.modtime
= current_stat
.st_mtime
;
924 if (S_ISHIDDEN (current_stat
.st_mode
))
926 char *new = (char *) alloca (strlen (p
) + 2);
936 /* See if we want only new files, and check if this one is too old to
937 put in the archive. */
939 if ((0 < top_level
|| !incremental_option
)
940 && !S_ISDIR (current_stat
.st_mode
)
941 && current_stat
.st_mtime
< newer_mtime_option
942 && (!after_date_option
|| current_stat
.st_ctime
< newer_ctime_option
))
945 WARN ((0, 0, _("%s: file is unchanged; not dumped"),
946 quotearg_colon (p
)));
947 /* FIXME: recheck this return. */
952 /* See if we are trying to dump the archive. */
954 if (ar_dev
&& current_stat
.st_dev
== ar_dev
&& current_stat
.st_ino
== ar_ino
)
956 WARN ((0, 0, _("%s: file is the archive; not dumped"),
957 quotearg_colon (p
)));
962 if (S_ISDIR (current_stat
.st_mode
))
970 dev_t our_device
= current_stat
.st_dev
;
974 directory
= savedir (p
, current_stat
.st_size
);
977 if (ignore_failed_read_option
)
984 /* Build new prototype name. Ensure exactly one trailing slash. */
987 buflen
= len
+ NAME_FIELD_SIZE
;
988 namebuf
= xmalloc (buflen
+ 1);
989 memcpy (namebuf
, p
, len
);
990 while (len
>= 1 && namebuf
[len
- 1] == '/')
992 namebuf
[len
++] = '/';
995 if (! is_avoided_name (namebuf
))
997 /* The condition above used to be "archive_format != V7_FORMAT".
998 GNU tar was not writing directory blocks at all. Daniel Trinkle
999 writes: ``All old versions of tar I have ever seen have
1000 correctly archived an empty directory. The really old ones I
1001 checked included HP-UX 7 and Mt. Xinu More/BSD. There may be
1002 some subtle reason for the exclusion that I don't know, but the
1003 current behavior is broken.'' I do not know those subtle
1004 reasons either, so until these are reported (anew?), just allow
1005 directory blocks to be written even with old archives. */
1007 current_stat
.st_size
= 0; /* force 0 size on dir */
1009 /* FIXME: If people could really read standard archives, this
1013 = start_header (standard_option ? p : namebuf, ¤t_stat);
1015 but since they'd interpret DIRTYPE blocks as regular
1016 files, we'd better put the / on the name. */
1018 header
= start_header (namebuf
, ¤t_stat
);
1020 if (incremental_option
)
1021 header
->header
.typeflag
= GNUTYPE_DUMPDIR
;
1022 else /* if (standard_option) */
1023 header
->header
.typeflag
= DIRTYPE
;
1025 /* If we're gnudumping, we aren't done yet so don't close it. */
1027 if (!incremental_option
)
1028 finish_header (header
); /* done with directory header */
1031 if (incremental_option
&& gnu_list_name
->dir_contents
)
1038 const char *buffer
, *p_buffer
;
1040 buffer
= gnu_list_name
->dir_contents
; /* FOO */
1042 for (p_buffer
= buffer
; p_buffer
&& *p_buffer
;)
1046 tmp
= strlen (p_buffer
) + 1;
1051 OFF_TO_CHARS (totsize
, header
->header
.size
);
1052 finish_header (header
);
1055 while (sizeleft
> 0)
1057 if (multi_volume_option
)
1059 assign_string (&save_name
, p
);
1060 save_sizeleft
= sizeleft
;
1061 save_totsize
= totsize
;
1063 start
= find_next_block ();
1064 bufsize
= available_space_after (start
);
1065 if (sizeleft
< bufsize
)
1068 count
= bufsize
% BLOCKSIZE
;
1070 memset (start
->buffer
+ sizeleft
, 0, BLOCKSIZE
- count
);
1072 memcpy (start
->buffer
, p_buffer
, bufsize
);
1073 sizeleft
-= bufsize
;
1074 p_buffer
+= bufsize
;
1075 set_next_block_after (start
+ (bufsize
- 1) / BLOCKSIZE
);
1077 if (multi_volume_option
)
1078 assign_string (&save_name
, 0);
1082 /* See if we are about to recurse into a directory, and avoid doing
1083 so if the user wants that we do not descend into directories. */
1085 if (! recursion_option
)
1088 /* See if we are crossing from one file system to another, and
1089 avoid doing so if the user only wants to dump one file system. */
1091 if (one_file_system_option
&& !top_level
1092 && parent_device
!= current_stat
.st_dev
)
1096 _("%s: file is on a different filesystem; not dumped"),
1097 quotearg_colon (p
)));
1101 /* Now output all the files in the directory. */
1103 /* FIXME: Should speed this up by cd-ing into the dir. */
1105 for (entry
= directory
;
1106 (entrylen
= strlen (entry
)) != 0;
1107 entry
+= entrylen
+ 1)
1109 if (buflen
<= len
+ entrylen
)
1111 buflen
= len
+ entrylen
;
1112 namebuf
= xrealloc (namebuf
, buflen
+ 1);
1114 strcpy (namebuf
+ len
, entry
);
1115 if (!excluded_name (namebuf
))
1116 dump_file (namebuf
, 0, our_device
);
1123 if (atime_preserve_option
)
1124 utime (p
, &restore_times
);
1127 else if (is_avoided_name (p
))
1131 /* Check for multiple links.
1133 We maintain a table of all such files that we've written so
1134 far. Any time we see another, we check the table and avoid
1135 dumping the data again if we've done it once already. */
1137 if (1 < current_stat
.st_nlink
)
1139 static Hash_table
*link_table
;
1140 struct link
*lp
= xmalloc (sizeof *lp
+ strlen (p
));
1142 lp
->ino
= current_stat
.st_ino
;
1143 lp
->dev
= current_stat
.st_dev
;
1144 strcpy (lp
->name
, p
);
1147 || (link_table
= hash_initialize (0, 0, hash_link
,
1149 && (dup
= hash_insert (link_table
, lp
))))
1154 /* We found a link. */
1155 char const *link_name
= dup
->name
;
1159 if (! absolute_names_option
)
1160 for (; *link_name
== '/'; link_name
++)
1162 static int warned_once
;
1167 _("Removing leading `/' from link names")));
1171 if (NAME_FIELD_SIZE
<= strlen (link_name
))
1172 write_long (link_name
, GNUTYPE_LONGLINK
);
1173 assign_string (¤t_link_name
, link_name
);
1175 current_stat
.st_size
= 0;
1176 header
= start_header (p
, ¤t_stat
);
1177 strncpy (header
->header
.linkname
, link_name
, NAME_FIELD_SIZE
);
1179 /* Force null termination. */
1180 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = 0;
1182 header
->header
.typeflag
= LNKTYPE
;
1183 finish_header (header
);
1185 /* FIXME: Maybe remove from table after all links found? */
1187 if (remove_files_option
&& unlink (p
) != 0)
1195 /* This is not a link to a previously dumped file, so dump it. */
1197 if (S_ISREG (current_stat
.st_mode
)
1198 || S_ISCTG (current_stat
.st_mode
))
1200 int f
; /* file descriptor */
1206 char isextended
= 0;
1213 /* Check the size of the file against the number of blocks
1214 allocated for it, counting both data and indirect blocks.
1215 If there is a smaller number of blocks that would be
1216 necessary to accommodate a file of this size, this is safe
1217 to say that we have a sparse file: at least one of those
1218 blocks in the file is just a useless hole. For sparse
1219 files not having more hole blocks than indirect blocks, the
1220 sparseness will go undetected. */
1222 /* Bruno Haible sent me these statistics for Linux. It seems
1223 that some filesystems count indirect blocks in st_blocks,
1224 while others do not seem to:
1226 minix-fs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1227 extfs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1228 ext2fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1229 msdos-fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1231 Dick Streefland reports the previous numbers as misleading,
1232 because ext2fs use 12 direct blocks, while minix-fs uses only
1233 6 direct blocks. Dick gets:
1235 ext2 size=20480 ls listed blocks=21
1236 minix size=20480 ls listed blocks=21
1237 msdos size=20480 ls listed blocks=20
1239 It seems that indirect blocks *are* included in st_blocks.
1240 The minix filesystem does not account for phantom blocks in
1241 st_blocks, so `du' and `ls -s' give wrong results. So, the
1242 --sparse option would not work on a minix filesystem. */
1244 if (ST_NBLOCKS (current_stat
)
1245 < (current_stat
.st_size
/ ST_NBLOCKSIZE
1246 + (current_stat
.st_size
% ST_NBLOCKSIZE
!= 0)))
1250 header
= start_header (p
, ¤t_stat
);
1251 header
->header
.typeflag
= GNUTYPE_SPARSE
;
1254 /* Call the routine that figures out the layout of the
1255 sparse file in question. SPARSES is the index of the
1256 first unused element of the "sparsearray," i.e.,
1257 the number of elements it needed to describe the file. */
1259 sparses
= deal_with_sparse (p
, header
);
1261 /* See if we'll need an extended header later. */
1263 if (SPARSES_IN_OLDGNU_HEADER
< sparses
)
1264 header
->oldgnu_header
.isextended
= 1;
1266 /* We store the "real" file size so we can show that in
1267 case someone wants to list the archive, i.e., tar tvf
1268 <file>. It might be kind of disconcerting if the
1269 shrunken file size was the one that showed up. */
1271 OFF_TO_CHARS (current_stat
.st_size
,
1272 header
->oldgnu_header
.realsize
);
1274 /* This will be the new "size" of the file, i.e., the size
1275 of the file minus the blocks of holes that we're
1278 current_stat
.st_size
= find_new_file_size (sparses
);
1279 OFF_TO_CHARS (current_stat
.st_size
, header
->header
.size
);
1282 counter
< sparses
&& counter
< SPARSES_IN_OLDGNU_HEADER
;
1285 OFF_TO_CHARS (sparsearray
[counter
].offset
,
1286 header
->oldgnu_header
.sp
[counter
].offset
);
1287 SIZE_TO_CHARS (sparsearray
[counter
].numbytes
,
1288 header
->oldgnu_header
.sp
[counter
].numbytes
);
1293 sizeleft
= current_stat
.st_size
;
1295 /* Don't bother opening empty, world readable files. Also do not open
1296 files when archive is meant for /dev/null. */
1300 && MODE_R
== (MODE_R
& current_stat
.st_mode
)))
1304 f
= open (p
, O_RDONLY
| O_BINARY
);
1307 if (! top_level
&& errno
== ENOENT
)
1308 WARN ((0, 0, _("%s: File removed before we read it"),
1309 quotearg_colon (p
)));
1311 (ignore_failed_read_option
? open_warn
: open_error
) (p
);
1316 /* If the file is sparse, we've already taken care of this. */
1319 header
= start_header (p
, ¤t_stat
);
1321 /* Mark contiguous files, if we support them. */
1323 if (archive_format
!= V7_FORMAT
&& S_ISCTG (current_stat
.st_mode
))
1324 header
->header
.typeflag
= CONTTYPE
;
1326 isextended
= header
->oldgnu_header
.isextended
;
1327 save_typeflag
= header
->header
.typeflag
;
1328 finish_header (header
);
1331 int sparses_emitted
= SPARSES_IN_OLDGNU_HEADER
;
1336 exhdr
= find_next_block ();
1337 memset (exhdr
->buffer
, 0, BLOCKSIZE
);
1339 (i
< SPARSES_IN_SPARSE_HEADER
1340 && sparses_emitted
+ i
< sparses
);
1343 SIZE_TO_CHARS (sparsearray
[sparses_emitted
+ i
].numbytes
,
1344 exhdr
->sparse_header
.sp
[i
].numbytes
);
1345 OFF_TO_CHARS (sparsearray
[sparses_emitted
+ i
].offset
,
1346 exhdr
->sparse_header
.sp
[i
].offset
);
1348 set_next_block_after (exhdr
);
1349 sparses_emitted
+= i
;
1350 if (sparses
== sparses_emitted
)
1352 exhdr
->sparse_header
.isextended
= 1;
1355 if (save_typeflag
== GNUTYPE_SPARSE
)
1358 || finish_sparse_file (f
, &sizeleft
,
1359 current_stat
.st_size
, p
))
1363 while (sizeleft
> 0)
1365 if (multi_volume_option
)
1367 assign_string (&save_name
, p
);
1368 save_sizeleft
= sizeleft
;
1369 save_totsize
= current_stat
.st_size
;
1371 start
= find_next_block ();
1373 bufsize
= available_space_after (start
);
1375 if (sizeleft
< bufsize
)
1377 /* Last read -- zero out area beyond. */
1380 count
= bufsize
% BLOCKSIZE
;
1382 memset (start
->buffer
+ sizeleft
, 0, BLOCKSIZE
- count
);
1387 count
= safe_read (f
, start
->buffer
, bufsize
);
1390 (ignore_failed_read_option
1392 : read_error_details
)
1393 (p
, current_stat
.st_size
- sizeleft
, bufsize
);
1396 sizeleft
-= bufsize
;
1398 /* This is nonportable (the type of set_next_block_after's arg). */
1400 set_next_block_after (start
+ (bufsize
- 1) / BLOCKSIZE
);
1403 if (count
!= bufsize
)
1405 char buf
[UINTMAX_STRSIZE_BOUND
];
1406 memset (start
->buffer
+ count
, 0, bufsize
- count
);
1408 _("%s: File shrank by %s bytes; padding with zeros"),
1410 STRINGIFY_BIGINT (sizeleft
, buf
)));
1411 if (! ignore_failed_read_option
)
1412 exit_status
= TAREXIT_FAILURE
;
1413 goto padit
; /* short read */
1417 if (multi_volume_option
)
1418 assign_string (&save_name
, 0);
1422 struct stat final_stat
;
1423 if (fstat (f
, &final_stat
) != 0)
1425 if (ignore_failed_read_option
)
1430 else if (final_stat
.st_ctime
!= original_ctime
)
1432 char const *qp
= quotearg_colon (p
);
1433 WARN ((0, 0, _("%s: file changed as we read it"), qp
));
1434 if (! ignore_failed_read_option
)
1435 exit_status
= TAREXIT_FAILURE
;
1439 if (ignore_failed_read_option
)
1444 if (atime_preserve_option
)
1445 utime (p
, &restore_times
);
1447 if (remove_files_option
)
1449 if (unlink (p
) == -1)
1454 /* File shrunk or gave error, pad out tape to match the size we
1455 specified in the header. */
1458 while (sizeleft
> 0)
1460 save_sizeleft
= sizeleft
;
1461 start
= find_next_block ();
1462 memset (start
->buffer
, 0, BLOCKSIZE
);
1463 set_next_block_after (start
);
1464 sizeleft
-= BLOCKSIZE
;
1466 if (multi_volume_option
)
1467 assign_string (&save_name
, 0);
1471 if (atime_preserve_option
)
1472 utime (p
, &restore_times
);
1476 #ifdef HAVE_READLINK
1477 else if (S_ISLNK (current_stat
.st_mode
))
1481 size_t linklen
= current_stat
.st_size
;
1482 if (linklen
!= current_stat
.st_size
|| linklen
+ 1 == 0)
1484 buffer
= (char *) alloca (linklen
+ 1);
1485 size
= readlink (p
, buffer
, linklen
+ 1);
1488 if (ignore_failed_read_option
)
1494 buffer
[size
] = '\0';
1495 if (size
>= NAME_FIELD_SIZE
)
1496 write_long (buffer
, GNUTYPE_LONGLINK
);
1497 assign_string (¤t_link_name
, buffer
);
1499 current_stat
.st_size
= 0; /* force 0 size on symlink */
1500 header
= start_header (p
, ¤t_stat
);
1501 strncpy (header
->header
.linkname
, buffer
, NAME_FIELD_SIZE
);
1502 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = '\0';
1503 header
->header
.typeflag
= SYMTYPE
;
1504 finish_header (header
); /* nothing more to do to it */
1505 if (remove_files_option
)
1507 if (unlink (p
) == -1)
1513 else if (S_ISCHR (current_stat
.st_mode
))
1515 else if (S_ISBLK (current_stat
.st_mode
))
1517 else if (S_ISFIFO (current_stat
.st_mode
))
1519 else if (S_ISSOCK (current_stat
.st_mode
))
1521 WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1524 else if (S_ISDOOR (current_stat
.st_mode
))
1526 WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1533 if (archive_format
== V7_FORMAT
)
1536 current_stat
.st_size
= 0; /* force 0 size */
1537 header
= start_header (p
, ¤t_stat
);
1538 header
->header
.typeflag
= type
;
1540 if (type
!= FIFOTYPE
)
1542 MAJOR_TO_CHARS (major (current_stat
.st_rdev
), header
->header
.devmajor
);
1543 MINOR_TO_CHARS (minor (current_stat
.st_rdev
), header
->header
.devminor
);
1546 finish_header (header
);
1547 if (remove_files_option
)
1549 if (unlink (p
) == -1)
1555 WARN ((0, 0, _("%s: Unknown file type; file ignored"),
1556 quotearg_colon (p
)));
1557 if (! ignore_failed_read_option
)
1558 exit_status
= TAREXIT_FAILURE
;