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
;
416 if (extended_header
.buffer
|| extended_header
.stk
== NULL
)
417 return old_header
; /* Prevent recursion */
419 xheader_finish (&extended_header
);
420 size
= extended_header
.size
;
421 memset (&foo
, 0, sizeof foo
);
422 foo
.stat
.st_mode
= S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
;
423 time (&foo
.stat
.st_ctime
);
424 foo
.stat
.st_atime
= foo
.stat
.st_ctime
;
425 foo
.stat
.st_mtime
= foo
.stat
.st_ctime
;
426 foo
.stat
.st_size
= size
;
428 memcpy (hp
.buffer
, old_header
, sizeof (hp
));
430 header
= start_header ("././@PaxHeader", &foo
);
431 header
->header
.typeflag
= type
;
433 finish_header (header
, -1);
435 p
= extended_header
.buffer
;
441 header
= find_next_block ();
445 memcpy (header
->buffer
, p
, len
);
447 memset (header
->buffer
+ len
, 0, BLOCKSIZE
- len
);
450 set_next_block_after (header
);
454 xheader_destroy (&extended_header
);
455 header
= find_next_block ();
456 memcpy (header
, &hp
.buffer
, sizeof (hp
.buffer
));
461 /* Header handling. */
463 /* Make a header block for the file whose stat info is st,
464 and return its address. */
467 start_header (const char *name
, struct tar_stat_info
*st
)
471 name
= safer_name_suffix (name
, 0);
473 if (sizeof header
->header
.name
<= strlen (name
))
474 write_long (name
, GNUTYPE_LONGNAME
);
476 header
= find_next_block ();
477 memset (header
->buffer
, 0, sizeof (union block
));
479 assign_string (¤t_stat_info
.file_name
, name
);
481 strncpy (header
->header
.name
, name
, NAME_FIELD_SIZE
);
482 header
->header
.name
[NAME_FIELD_SIZE
- 1] = '\0';
484 /* Override some stat fields, if requested to do so. */
486 if (owner_option
!= (uid_t
) -1)
487 st
->stat
.st_uid
= owner_option
;
488 if (group_option
!= (gid_t
) -1)
489 st
->stat
.st_gid
= group_option
;
491 st
->stat
.st_mode
= ((st
->stat
.st_mode
& ~MODE_ALL
)
492 | mode_adjust (st
->stat
.st_mode
, mode_option
));
494 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
495 for a few tars and came up with the following interoperability
499 1 2 3 4 5 6 7 8 9 READER
500 . . . . . . . . . 1 = SunOS 4.2 tar
501 # . . # # . . # # 2 = NEC SVR4.0.2 tar
502 . . . # # . . # . 3 = Solaris 2.1 tar
503 . . . . . . . . . 4 = GNU tar 1.11.1
504 . . . . . . . . . 5 = HP-UX 8.07 tar
505 . . . . . . . . . 6 = Ultrix 4.1
506 . . . . . . . . . 7 = AIX 3.2
507 . . . . . . . . . 8 = Hitachi HI-UX 1.03
508 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
511 # = ``impossible file type''
513 The following mask for old archive removes the `#'s in column 4
514 above, thus making GNU tar both a universal donor and a universal
515 acceptor for Paul's test. */
517 if (archive_format
== V7_FORMAT
)
518 MODE_TO_CHARS (st
->stat
.st_mode
& MODE_ALL
, header
->header
.mode
);
520 MODE_TO_CHARS (st
->stat
.st_mode
, header
->header
.mode
);
522 if (st
->stat
.st_uid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
523 xheader_store ("uid", st
);
525 UID_TO_CHARS (st
->stat
.st_uid
, header
->header
.uid
);
527 if (st
->stat
.st_gid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
528 xheader_store ("gid", st
);
530 GID_TO_CHARS (st
->stat
.st_gid
, header
->header
.gid
);
532 if (st
->stat
.st_size
> MAXOCTAL11
&& archive_format
== POSIX_FORMAT
)
533 xheader_store ("size", st
);
535 OFF_TO_CHARS (st
->stat
.st_size
, header
->header
.size
);
537 TIME_TO_CHARS (st
->stat
.st_mtime
, header
->header
.mtime
);
540 if (S_ISCHR (st
->stat
.st_mode
)
541 || S_ISBLK (st
->stat
.st_mode
))
543 st
->devmajor
= major (st
->stat
.st_rdev
);
544 st
->devminor
= minor (st
->stat
.st_rdev
);
546 if (st
->devmajor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
547 xheader_store ("devmajor", st
);
549 MAJOR_TO_CHARS (st
->devmajor
, header
->header
.devmajor
);
551 if (st
->devminor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
552 xheader_store ("devminor", st
);
554 MAJOR_TO_CHARS (st
->devminor
, header
->header
.devminor
);
558 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
559 MINOR_TO_CHARS (0, header
->header
.devminor
);
562 if (archive_format
== POSIX_FORMAT
)
564 xheader_store ("atime", st
);
565 xheader_store ("ctime", st
);
567 else if (incremental_option
)
568 if (archive_format
== OLDGNU_FORMAT
)
570 TIME_TO_CHARS (st
->stat
.st_atime
, header
->oldgnu_header
.atime
);
571 TIME_TO_CHARS (st
->stat
.st_ctime
, header
->oldgnu_header
.ctime
);
574 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
576 switch (archive_format
)
582 /* Overwrite header->header.magic and header.version in one blow. */
583 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
588 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
589 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
596 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
598 /* header->header.[ug]name are left as the empty string. */
602 uid_to_uname (st
->stat
.st_uid
, &st
->uname
);
603 gid_to_gname (st
->stat
.st_gid
, &st
->gname
);
605 if (archive_format
== POSIX_FORMAT
606 && strlen (st
->uname
) > UNAME_FIELD_SIZE
)
607 xheader_store ("uname", st
);
609 UNAME_TO_CHARS (st
->uname
, header
->header
.uname
);
611 if (archive_format
== POSIX_FORMAT
612 && strlen (st
->gname
) > GNAME_FIELD_SIZE
)
613 xheader_store ("gname", st
);
615 GNAME_TO_CHARS (st
->gname
, header
->header
.gname
);
621 /* Finish off a filled-in header block and write it out. We also
622 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
623 is not negative, is the block ordinal of the first record for this
624 file, which may be a preceding long name or long link record. */
626 finish_header (union block
*header
, off_t block_ordinal
)
632 header
= write_extended (header
, XHDTYPE
);
634 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
638 for (i
= sizeof *header
; i
-- != 0; )
639 /* We can't use unsigned char here because of old compilers, e.g. V7. */
642 /* Fill in the checksum field. It's formatted differently from the
643 other fields: it has [6] digits, a null, then a space -- rather than
644 digits, then a null. We use to_chars.
645 The final space is already there, from
646 checksumming, and to_chars doesn't modify it.
648 This is a fast way to do:
650 sprintf(header->header.chksum, "%6o", sum); */
652 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
655 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
656 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
)
658 /* These globals are parameters to print_header, sigh. */
660 current_header
= header
;
661 /* current_stat_info is already set up. */
662 current_format
= archive_format
;
663 print_header (block_ordinal
);
666 set_next_block_after (header
);
669 /* Sparse file processing. */
671 /* Takes a blockful of data and basically cruises through it to see if
672 it's made *entirely* of zeros, returning a 0 the instant it finds
673 something that is a nonzero, i.e., useful data. */
675 zero_block_p (char *buffer
)
679 for (counter
= 0; counter
< BLOCKSIZE
; counter
++)
680 if (buffer
[counter
] != '\0')
686 init_sparsearray (void)
689 sp_array_size
= SPARSES_IN_OLDGNU_HEADER
;
690 sparsearray
= xmalloc (sp_array_size
* sizeof *sparsearray
);
694 find_new_file_size (int sparses
)
698 for (i
= 0; i
< sparses
; i
++)
699 s
+= sparsearray
[i
].numbytes
;
703 /* Make one pass over the file NAME, studying where any non-zero data
704 is, that is, how far into the file each instance of data is, and
705 how many bytes are there. Save this information in the
706 sparsearray, which will later be translated into header
709 /* There is little point in trimming small amounts of null data at the head
710 and tail of blocks, only avoid dumping full null blocks. */
712 /* FIXME: this routine might accept bits of algorithmic cleanup, it is
713 too kludgey for my taste... */
716 deal_with_sparse (char *name
, union block
*header
)
723 char buffer
[BLOCKSIZE
];
725 if (archive_format
== OLDGNU_FORMAT
)
726 header
->oldgnu_header
.isextended
= 0;
728 if (file
= open (name
, O_RDONLY
), file
< 0)
729 /* This problem will be caught later on, so just return. */
733 clear_buffer (buffer
);
737 /* Realloc the scratch area as necessary. FIXME: should reallocate
738 only at beginning of a new instance of non-zero data. */
740 if (sp_array_size
<= sparses
)
743 xrealloc (sparsearray
,
744 2 * sp_array_size
* sizeof (struct sp_array
));
748 count
= safe_read (file
, buffer
, sizeof buffer
);
752 /* Process one block. */
754 if (count
== sizeof buffer
)
756 if (zero_block_p (buffer
))
760 sparsearray
[sparses
++].numbytes
= numbytes
;
767 sparsearray
[sparses
].offset
= offset
;
773 /* Since count < sizeof buffer, we have the last bit of the file. */
775 if (!zero_block_p (buffer
))
778 sparsearray
[sparses
].offset
= offset
;
782 /* The next two lines are suggested by Andreas Degert, who says
783 they are required for trailing full blocks to be written to the
784 archive, when all zeroed. Yet, it seems to me that the case
785 does not apply. Further, at restore time, the file is not as
786 sparse as it should. So, some serious cleanup is *also* needed
787 in this area. Just one more... :-(. FIXME. */
791 /* Prepare for next block. */
794 /* FIXME: do not clear unless necessary. */
795 clear_buffer (buffer
);
799 sparsearray
[sparses
++].numbytes
= numbytes
;
802 sparsearray
[sparses
].offset
= offset
- 1;
803 sparsearray
[sparses
++].numbytes
= 1;
806 return close (file
) == 0 && 0 <= count
? sparses
: 0;
810 finish_sparse_file (int file
, off_t
*sizeleft
, off_t fullsize
, char *name
)
817 while (*sizeleft
> 0)
819 start
= find_next_block ();
820 memset (start
->buffer
, 0, BLOCKSIZE
);
821 bufsize
= sparsearray
[sparses
].numbytes
;
825 if (lseek (file
, sparsearray
[sparses
++].offset
, SEEK_SET
) < 0)
827 (ignore_failed_read_option
? seek_warn_details
: seek_error_details
)
828 (name
, sparsearray
[sparses
- 1].offset
);
832 /* If the number of bytes to be written here exceeds the size of
833 the temporary buffer, do it in steps. */
835 while (bufsize
> BLOCKSIZE
)
837 count
= safe_read (file
, start
->buffer
, BLOCKSIZE
);
840 (ignore_failed_read_option
842 : read_error_details
)
843 (name
, fullsize
- *sizeleft
, bufsize
);
848 set_next_block_after (start
);
849 start
= find_next_block ();
850 memset (start
->buffer
, 0, BLOCKSIZE
);
854 char buffer
[BLOCKSIZE
];
856 clear_buffer (buffer
);
857 count
= safe_read (file
, buffer
, bufsize
);
858 memcpy (start
->buffer
, buffer
, BLOCKSIZE
);
863 (ignore_failed_read_option
865 : read_error_details
)
866 (name
, fullsize
- *sizeleft
, bufsize
);
871 set_next_block_after (start
);
875 set_next_block_after (start
+ (count
- 1) / BLOCKSIZE
);
880 /* Main functions of this module. */
883 create_archive (void)
887 open_archive (ACCESS_WRITE
);
889 if (incremental_option
)
891 size_t buffer_size
= 1000;
892 char *buffer
= xmalloc (buffer_size
);
895 collect_and_sort_names ();
897 while (p
= name_from_list (), p
)
898 if (!excluded_name (p
))
899 dump_file (p
, -1, (dev_t
) 0);
902 while (p
= name_from_list (), p
)
903 if (!excluded_name (p
))
905 size_t plen
= strlen (p
);
906 if (buffer_size
<= plen
)
908 while ((buffer_size
*= 2) <= plen
)
910 buffer
= xrealloc (buffer
, buffer_size
);
912 memcpy (buffer
, p
, plen
);
913 if (! ISSLASH (buffer
[plen
- 1]))
914 buffer
[plen
++] = '/';
915 q
= gnu_list_name
->dir_contents
;
919 size_t qlen
= strlen (q
);
922 if (buffer_size
< plen
+ qlen
)
924 while ((buffer_size
*=2 ) < plen
+ qlen
)
926 buffer
= xrealloc (buffer
, buffer_size
);
928 strcpy (buffer
+ plen
, q
+ 1);
929 dump_file (buffer
, -1, (dev_t
) 0);
938 while (p
= name_next (1), p
)
939 if (!excluded_name (p
))
940 dump_file (p
, 1, (dev_t
) 0);
946 if (listed_incremental_option
)
947 write_directory_file ();
951 /* Calculate the hash of a link. */
953 hash_link (void const *entry
, unsigned n_buckets
)
955 struct link
const *link
= entry
;
956 return (uintmax_t) (link
->dev
^ link
->ino
) % n_buckets
;
959 /* Compare two links for equality. */
961 compare_links (void const *entry1
, void const *entry2
)
963 struct link
const *link1
= entry1
;
964 struct link
const *link2
= entry2
;
965 return ((link1
->dev
^ link2
->dev
) | (link1
->ino
^ link2
->ino
)) == 0;
968 /* Table of all non-directories that we've written so far. Any time
969 we see another, we check the table and avoid dumping the data
970 again if we've done it once already. */
971 static Hash_table
*link_table
;
973 /* Dump a single file, recursing on directories. P is the file name
974 to dump. TOP_LEVEL tells whether this is a top-level call; zero
975 means no, positive means yes, and negative means the top level
976 of an incremental dump. PARENT_DEVICE is the device of P's
977 parent directory; it is examined only if TOP_LEVEL is zero.
979 Set global CURRENT_STAT_INFO to stat output for this file. */
981 /* FIXME: One should make sure that for *every* path leading to setting
982 exit_status to failure, a clear diagnostic has been issued. */
985 dump_file (char *p
, int top_level
, dev_t parent_device
)
991 time_t original_ctime
;
992 struct utimbuf restore_times
;
993 off_t block_ordinal
= -1;
995 /* FIXME: `header' might be used uninitialized in this
996 function. Reported by Bruno Haible. */
998 if (interactive_option
&& !confirm ("add", p
))
1001 if (deref_stat (dereference_option
, p
, ¤t_stat_info
.stat
) != 0)
1003 if (ignore_failed_read_option
)
1010 original_ctime
= current_stat_info
.stat
.st_ctime
;
1011 restore_times
.actime
= current_stat_info
.stat
.st_atime
;
1012 restore_times
.modtime
= current_stat_info
.stat
.st_mtime
;
1015 if (S_ISHIDDEN (current_stat_info
.stat
.st_mode
))
1017 char *new = (char *) alloca (strlen (p
) + 2);
1027 /* See if we want only new files, and check if this one is too old to
1028 put in the archive. */
1030 if ((0 < top_level
|| !incremental_option
)
1031 && !S_ISDIR (current_stat_info
.stat
.st_mode
)
1032 && current_stat_info
.stat
.st_mtime
< newer_mtime_option
1033 && (!after_date_option
|| current_stat_info
.stat
.st_ctime
< newer_ctime_option
))
1036 WARN ((0, 0, _("%s: file is unchanged; not dumped"),
1037 quotearg_colon (p
)));
1038 /* FIXME: recheck this return. */
1043 /* See if we are trying to dump the archive. */
1045 if (ar_dev
&& current_stat_info
.stat
.st_dev
== ar_dev
&& current_stat_info
.stat
.st_ino
== ar_ino
)
1047 WARN ((0, 0, _("%s: file is the archive; not dumped"),
1048 quotearg_colon (p
)));
1053 if (S_ISDIR (current_stat_info
.stat
.st_mode
))
1061 dev_t our_device
= current_stat_info
.stat
.st_dev
;
1065 directory
= savedir (p
);
1068 if (ignore_failed_read_option
)
1075 /* Build new prototype name. Ensure exactly one trailing slash. */
1078 buflen
= len
+ NAME_FIELD_SIZE
;
1079 namebuf
= xmalloc (buflen
+ 1);
1080 memcpy (namebuf
, p
, len
);
1081 while (len
>= 1 && ISSLASH (namebuf
[len
- 1]))
1083 namebuf
[len
++] = '/';
1084 namebuf
[len
] = '\0';
1086 if (! is_avoided_name (namebuf
))
1088 /* The condition above used to be "archive_format != V7_FORMAT".
1089 GNU tar was not writing directory blocks at all. Daniel Trinkle
1090 writes: ``All old versions of tar I have ever seen have
1091 correctly archived an empty directory. The really old ones I
1092 checked included HP-UX 7 and Mt. Xinu More/BSD. There may be
1093 some subtle reason for the exclusion that I don't know, but the
1094 current behavior is broken.'' I do not know those subtle
1095 reasons either, so until these are reported (anew?), just allow
1096 directory blocks to be written even with old archives. */
1098 block_ordinal
= current_block_ordinal ();
1099 current_stat_info
.stat
.st_size
= 0; /* force 0 size on dir */
1101 /* FIXME: If people could really read standard archives, this
1105 = start_header (standard_option ? p : namebuf, ¤t_stat_info);
1107 but since they'd interpret DIRTYPE blocks as regular
1108 files, we'd better put the / on the name. */
1110 header
= start_header (namebuf
, ¤t_stat_info
);
1112 if (incremental_option
)
1113 header
->header
.typeflag
= GNUTYPE_DUMPDIR
;
1114 else /* if (standard_option) */
1115 header
->header
.typeflag
= DIRTYPE
;
1117 /* If we're gnudumping, we aren't done yet so don't close it. */
1119 if (!incremental_option
)
1120 finish_header (header
, block_ordinal
);
1123 if (incremental_option
&& gnu_list_name
->dir_contents
)
1130 const char *buffer
, *p_buffer
;
1132 buffer
= gnu_list_name
->dir_contents
; /* FOO */
1135 for (p_buffer
= buffer
; *p_buffer
; )
1137 size_t size
= strlen (p_buffer
) + 1;
1142 OFF_TO_CHARS (totsize
, header
->header
.size
);
1143 finish_header (header
, block_ordinal
);
1146 while (sizeleft
> 0)
1148 if (multi_volume_option
)
1150 assign_string (&save_name
, p
);
1151 save_sizeleft
= sizeleft
;
1152 save_totsize
= totsize
;
1154 start
= find_next_block ();
1155 bufsize
= available_space_after (start
);
1156 if (sizeleft
< bufsize
)
1159 count
= bufsize
% BLOCKSIZE
;
1161 memset (start
->buffer
+ sizeleft
, 0, BLOCKSIZE
- count
);
1163 memcpy (start
->buffer
, p_buffer
, bufsize
);
1164 sizeleft
-= bufsize
;
1165 p_buffer
+= bufsize
;
1166 set_next_block_after (start
+ (bufsize
- 1) / BLOCKSIZE
);
1168 if (multi_volume_option
)
1169 assign_string (&save_name
, 0);
1173 /* See if we are about to recurse into a directory, and avoid doing
1174 so if the user wants that we do not descend into directories. */
1176 if (! recursion_option
)
1179 /* See if we are crossing from one file system to another, and
1180 avoid doing so if the user only wants to dump one file system. */
1182 if (one_file_system_option
&& !top_level
1183 && parent_device
!= current_stat_info
.stat
.st_dev
)
1187 _("%s: file is on a different filesystem; not dumped"),
1188 quotearg_colon (p
)));
1192 /* Now output all the files in the directory. */
1194 /* FIXME: Should speed this up by cd-ing into the dir. */
1196 for (entry
= directory
;
1197 (entrylen
= strlen (entry
)) != 0;
1198 entry
+= entrylen
+ 1)
1200 if (buflen
< len
+ entrylen
)
1202 buflen
= len
+ entrylen
;
1203 namebuf
= xrealloc (namebuf
, buflen
+ 1);
1205 strcpy (namebuf
+ len
, entry
);
1206 if (!excluded_name (namebuf
))
1207 dump_file (namebuf
, 0, our_device
);
1214 if (atime_preserve_option
)
1215 utime (p
, &restore_times
);
1218 else if (is_avoided_name (p
))
1222 /* Check for multiple links. */
1224 if (1 < current_stat_info
.stat
.st_nlink
&& link_table
)
1228 lp
.ino
= current_stat_info
.stat
.st_ino
;
1229 lp
.dev
= current_stat_info
.stat
.st_dev
;
1231 if ((dup
= hash_lookup (link_table
, &lp
)))
1233 /* We found a link. */
1234 char const *link_name
= safer_name_suffix (dup
->name
, 1);
1238 block_ordinal
= current_block_ordinal ();
1239 if (NAME_FIELD_SIZE
<= strlen (link_name
))
1240 write_long (link_name
, GNUTYPE_LONGLINK
);
1241 assign_string (¤t_stat_info
.link_name
, link_name
);
1243 current_stat_info
.stat
.st_size
= 0;
1244 header
= start_header (p
, ¤t_stat_info
);
1245 strncpy (header
->header
.linkname
, link_name
, NAME_FIELD_SIZE
);
1247 /* Force null termination. */
1248 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = 0;
1250 header
->header
.typeflag
= LNKTYPE
;
1251 finish_header (header
, block_ordinal
);
1253 /* FIXME: Maybe remove from table after all links found? */
1255 if (remove_files_option
&& unlink (p
) != 0)
1258 /* We dumped it, and we don't need to put it in the
1264 /* This is not a link to a previously dumped file, so dump it. */
1266 if (S_ISREG (current_stat_info
.stat
.st_mode
)
1267 || S_ISCTG (current_stat_info
.stat
.st_mode
))
1269 int f
; /* file descriptor */
1275 char isextended
= 0;
1282 /* Check the size of the file against the number of blocks
1283 allocated for it, counting both data and indirect blocks.
1284 If there is a smaller number of blocks than would be
1285 necessary to accommodate a file of this size, this is safe
1286 to say that we have a sparse file: at least one of those
1287 blocks in the file is just a useless hole. For sparse
1288 files not having more hole blocks than indirect blocks, the
1289 sparseness will go undetected. */
1291 /* Bruno Haible sent me these statistics for Linux. It seems
1292 that some filesystems count indirect blocks in st_blocks,
1293 while others do not seem to:
1295 minix-fs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1296 extfs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1297 ext2fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1298 msdos-fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1300 Dick Streefland reports the previous numbers as misleading,
1301 because ext2fs use 12 direct blocks, while minix-fs uses only
1302 6 direct blocks. Dick gets:
1304 ext2 size=20480 ls listed blocks=21
1305 minix size=20480 ls listed blocks=21
1306 msdos size=20480 ls listed blocks=20
1308 It seems that indirect blocks *are* included in st_blocks.
1309 The minix filesystem does not account for phantom blocks in
1310 st_blocks, so `du' and `ls -s' give wrong results. So, the
1311 --sparse option would not work on a minix filesystem. */
1313 if (ST_NBLOCKS (current_stat_info
.stat
)
1314 < (current_stat_info
.stat
.st_size
/ ST_NBLOCKSIZE
1315 + (current_stat_info
.stat
.st_size
% ST_NBLOCKSIZE
!= 0)))
1319 block_ordinal
= current_block_ordinal ();
1320 header
= start_header (p
, ¤t_stat_info
);
1321 header
->header
.typeflag
= GNUTYPE_SPARSE
;
1324 /* Call the routine that figures out the layout of the
1325 sparse file in question. SPARSES is the index of the
1326 first unused element of the "sparsearray," i.e.,
1327 the number of elements it needed to describe the file. */
1329 sparses
= deal_with_sparse (p
, header
);
1331 /* See if we'll need an extended header later. */
1333 if (SPARSES_IN_OLDGNU_HEADER
< sparses
)
1334 header
->oldgnu_header
.isextended
= 1;
1336 /* We store the "real" file size so we can show that in
1337 case someone wants to list the archive, i.e., tar tvf
1338 <file>. It might be kind of disconcerting if the
1339 shrunken file size was the one that showed up. */
1341 OFF_TO_CHARS (current_stat_info
.stat
.st_size
,
1342 header
->oldgnu_header
.realsize
);
1344 /* This will be the new "size" of the file, i.e., the size
1345 of the file minus the blocks of holes that we're
1348 current_stat_info
.stat
.st_size
= find_new_file_size (sparses
);
1349 OFF_TO_CHARS (current_stat_info
.stat
.st_size
, header
->header
.size
);
1352 counter
< sparses
&& counter
< SPARSES_IN_OLDGNU_HEADER
;
1355 OFF_TO_CHARS (sparsearray
[counter
].offset
,
1356 header
->oldgnu_header
.sp
[counter
].offset
);
1357 SIZE_TO_CHARS (sparsearray
[counter
].numbytes
,
1358 header
->oldgnu_header
.sp
[counter
].numbytes
);
1363 sizeleft
= current_stat_info
.stat
.st_size
;
1365 /* Don't bother opening empty, world readable files. Also do not open
1366 files when archive is meant for /dev/null. */
1370 && MODE_R
== (MODE_R
& current_stat_info
.stat
.st_mode
)))
1374 f
= open (p
, O_RDONLY
| O_BINARY
);
1377 if (! top_level
&& errno
== ENOENT
)
1378 WARN ((0, 0, _("%s: File removed before we read it"),
1379 quotearg_colon (p
)));
1381 (ignore_failed_read_option
? open_warn
: open_error
) (p
);
1386 /* If the file is sparse, we've already taken care of this. */
1390 block_ordinal
= current_block_ordinal ();
1391 header
= start_header (p
, ¤t_stat_info
);
1394 /* Mark contiguous files, if we support them. */
1396 if (archive_format
!= V7_FORMAT
&& S_ISCTG (current_stat_info
.stat
.st_mode
))
1397 header
->header
.typeflag
= CONTTYPE
;
1399 isextended
= header
->oldgnu_header
.isextended
;
1400 save_typeflag
= header
->header
.typeflag
;
1401 finish_header (header
, block_ordinal
);
1404 int sparses_emitted
= SPARSES_IN_OLDGNU_HEADER
;
1409 exhdr
= find_next_block ();
1410 memset (exhdr
->buffer
, 0, BLOCKSIZE
);
1412 (i
< SPARSES_IN_SPARSE_HEADER
1413 && sparses_emitted
+ i
< sparses
);
1416 SIZE_TO_CHARS (sparsearray
[sparses_emitted
+ i
].numbytes
,
1417 exhdr
->sparse_header
.sp
[i
].numbytes
);
1418 OFF_TO_CHARS (sparsearray
[sparses_emitted
+ i
].offset
,
1419 exhdr
->sparse_header
.sp
[i
].offset
);
1421 set_next_block_after (exhdr
);
1422 sparses_emitted
+= i
;
1423 if (sparses
== sparses_emitted
)
1425 exhdr
->sparse_header
.isextended
= 1;
1428 if (save_typeflag
== GNUTYPE_SPARSE
)
1431 || finish_sparse_file (f
, &sizeleft
,
1432 current_stat_info
.stat
.st_size
, p
))
1436 while (sizeleft
> 0)
1438 if (multi_volume_option
)
1440 assign_string (&save_name
, p
);
1441 save_sizeleft
= sizeleft
;
1442 save_totsize
= current_stat_info
.stat
.st_size
;
1444 start
= find_next_block ();
1446 bufsize
= available_space_after (start
);
1448 if (sizeleft
< bufsize
)
1450 /* Last read -- zero out area beyond. */
1453 count
= bufsize
% BLOCKSIZE
;
1455 memset (start
->buffer
+ sizeleft
, 0, BLOCKSIZE
- count
);
1460 count
= safe_read (f
, start
->buffer
, bufsize
);
1463 (ignore_failed_read_option
1465 : read_error_details
)
1466 (p
, current_stat_info
.stat
.st_size
- sizeleft
, bufsize
);
1471 /* This is nonportable (the type of set_next_block_after's arg). */
1473 set_next_block_after (start
+ (bufsize
- 1) / BLOCKSIZE
);
1476 if (count
!= bufsize
)
1478 char buf
[UINTMAX_STRSIZE_BOUND
];
1479 memset (start
->buffer
+ count
, 0, bufsize
- count
);
1481 _("%s: File shrank by %s bytes; padding with zeros"),
1483 STRINGIFY_BIGINT (sizeleft
, buf
)));
1484 if (! ignore_failed_read_option
)
1485 exit_status
= TAREXIT_FAILURE
;
1486 goto padit
; /* short read */
1490 if (multi_volume_option
)
1491 assign_string (&save_name
, 0);
1495 struct stat final_stat
;
1496 if (fstat (f
, &final_stat
) != 0)
1498 if (ignore_failed_read_option
)
1503 else if (final_stat
.st_ctime
!= original_ctime
)
1505 char const *qp
= quotearg_colon (p
);
1506 WARN ((0, 0, _("%s: file changed as we read it"), qp
));
1510 if (ignore_failed_read_option
)
1515 if (atime_preserve_option
)
1516 utime (p
, &restore_times
);
1518 if (remove_files_option
)
1520 if (unlink (p
) == -1)
1523 goto file_was_dumped
;
1525 /* File shrunk or gave error, pad out tape to match the size we
1526 specified in the header. */
1529 while (sizeleft
> 0)
1531 save_sizeleft
= sizeleft
;
1532 start
= find_next_block ();
1533 memset (start
->buffer
, 0, BLOCKSIZE
);
1534 set_next_block_after (start
);
1535 sizeleft
-= BLOCKSIZE
;
1537 if (multi_volume_option
)
1538 assign_string (&save_name
, 0);
1542 if (atime_preserve_option
)
1543 utime (p
, &restore_times
);
1545 goto file_was_dumped
;
1547 #ifdef HAVE_READLINK
1548 else if (S_ISLNK (current_stat_info
.stat
.st_mode
))
1552 size_t linklen
= current_stat_info
.stat
.st_size
;
1553 if (linklen
!= current_stat_info
.stat
.st_size
|| linklen
+ 1 == 0)
1555 buffer
= (char *) alloca (linklen
+ 1);
1556 size
= readlink (p
, buffer
, linklen
+ 1);
1559 if (ignore_failed_read_option
)
1565 buffer
[size
] = '\0';
1566 if (size
>= NAME_FIELD_SIZE
)
1567 write_long (buffer
, GNUTYPE_LONGLINK
);
1568 assign_string (¤t_stat_info
.link_name
, buffer
);
1570 block_ordinal
= current_block_ordinal ();
1571 current_stat_info
.stat
.st_size
= 0; /* force 0 size on symlink */
1572 header
= start_header (p
, ¤t_stat_info
);
1573 strncpy (header
->header
.linkname
, buffer
, NAME_FIELD_SIZE
);
1574 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = '\0';
1575 header
->header
.typeflag
= SYMTYPE
;
1576 finish_header (header
, block_ordinal
);
1577 /* nothing more to do to it */
1579 if (remove_files_option
)
1581 if (unlink (p
) == -1)
1584 goto file_was_dumped
;
1587 else if (S_ISCHR (current_stat_info
.stat
.st_mode
))
1589 else if (S_ISBLK (current_stat_info
.stat
.st_mode
))
1591 else if (S_ISFIFO (current_stat_info
.stat
.st_mode
))
1593 else if (S_ISSOCK (current_stat_info
.stat
.st_mode
))
1595 WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1598 else if (S_ISDOOR (current_stat_info
.stat
.st_mode
))
1600 WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1607 if (archive_format
== V7_FORMAT
)
1610 block_ordinal
= current_block_ordinal ();
1611 current_stat_info
.stat
.st_size
= 0; /* force 0 size */
1612 header
= start_header (p
, ¤t_stat_info
);
1613 header
->header
.typeflag
= type
;
1615 if (type
!= FIFOTYPE
)
1617 MAJOR_TO_CHARS (major (current_stat_info
.stat
.st_rdev
), header
->header
.devmajor
);
1618 MINOR_TO_CHARS (minor (current_stat_info
.stat
.st_rdev
), header
->header
.devminor
);
1621 finish_header (header
, block_ordinal
);
1622 if (remove_files_option
)
1624 if (unlink (p
) == -1)
1627 goto file_was_dumped
;
1630 WARN ((0, 0, _("%s: Unknown file type; file ignored"),
1631 quotearg_colon (p
)));
1632 if (! ignore_failed_read_option
)
1633 exit_status
= TAREXIT_FAILURE
;
1637 if (1 < current_stat_info
.stat
.st_nlink
)
1640 struct link
*lp
= xmalloc (offsetof (struct link
, name
)
1642 lp
->ino
= current_stat_info
.stat
.st_ino
;
1643 lp
->dev
= current_stat_info
.stat
.st_dev
;
1644 lp
->nlink
= current_stat_info
.stat
.st_nlink
;
1645 strcpy (lp
->name
, p
);
1648 || (link_table
= hash_initialize (0, 0, hash_link
,
1650 && (dup
= hash_insert (link_table
, lp
))))
1660 /* For each dumped file, check if all its links were dumped. Emit
1661 warnings if it is not so. */
1670 for (lp
= hash_get_first (link_table
); lp
;
1671 lp
= hash_get_next (link_table
, lp
))
1675 WARN ((0, 0, _("Missing links to '%s'.\n"), lp
->name
));