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);
472 assign_string (&st
->file_name
, name
);
474 if (sizeof header
->header
.name
<= strlen (name
))
476 if (archive_format
== POSIX_FORMAT
)
477 xheader_store ("path", st
);
479 write_long (name
, GNUTYPE_LONGNAME
);
482 header
= find_next_block ();
483 memset (header
->buffer
, 0, sizeof (union block
));
485 assign_string (¤t_stat_info
.file_name
, name
);
487 strncpy (header
->header
.name
, name
, NAME_FIELD_SIZE
);
488 header
->header
.name
[NAME_FIELD_SIZE
- 1] = '\0';
490 /* Override some stat fields, if requested to do so. */
492 if (owner_option
!= (uid_t
) -1)
493 st
->stat
.st_uid
= owner_option
;
494 if (group_option
!= (gid_t
) -1)
495 st
->stat
.st_gid
= group_option
;
497 st
->stat
.st_mode
= ((st
->stat
.st_mode
& ~MODE_ALL
)
498 | mode_adjust (st
->stat
.st_mode
, mode_option
));
500 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
501 for a few tars and came up with the following interoperability
505 1 2 3 4 5 6 7 8 9 READER
506 . . . . . . . . . 1 = SunOS 4.2 tar
507 # . . # # . . # # 2 = NEC SVR4.0.2 tar
508 . . . # # . . # . 3 = Solaris 2.1 tar
509 . . . . . . . . . 4 = GNU tar 1.11.1
510 . . . . . . . . . 5 = HP-UX 8.07 tar
511 . . . . . . . . . 6 = Ultrix 4.1
512 . . . . . . . . . 7 = AIX 3.2
513 . . . . . . . . . 8 = Hitachi HI-UX 1.03
514 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
517 # = ``impossible file type''
519 The following mask for old archive removes the `#'s in column 4
520 above, thus making GNU tar both a universal donor and a universal
521 acceptor for Paul's test. */
523 if (archive_format
== V7_FORMAT
)
524 MODE_TO_CHARS (st
->stat
.st_mode
& MODE_ALL
, header
->header
.mode
);
526 MODE_TO_CHARS (st
->stat
.st_mode
, header
->header
.mode
);
528 if (st
->stat
.st_uid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
529 xheader_store ("uid", st
);
531 UID_TO_CHARS (st
->stat
.st_uid
, header
->header
.uid
);
533 if (st
->stat
.st_gid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
534 xheader_store ("gid", st
);
536 GID_TO_CHARS (st
->stat
.st_gid
, header
->header
.gid
);
538 if (st
->stat
.st_size
> MAXOCTAL11
&& archive_format
== POSIX_FORMAT
)
539 xheader_store ("size", st
);
541 OFF_TO_CHARS (st
->stat
.st_size
, header
->header
.size
);
543 TIME_TO_CHARS (st
->stat
.st_mtime
, header
->header
.mtime
);
546 if (S_ISCHR (st
->stat
.st_mode
)
547 || S_ISBLK (st
->stat
.st_mode
))
549 st
->devmajor
= major (st
->stat
.st_rdev
);
550 st
->devminor
= minor (st
->stat
.st_rdev
);
552 if (st
->devmajor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
553 xheader_store ("devmajor", st
);
555 MAJOR_TO_CHARS (st
->devmajor
, header
->header
.devmajor
);
557 if (st
->devminor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
558 xheader_store ("devminor", st
);
560 MAJOR_TO_CHARS (st
->devminor
, header
->header
.devminor
);
564 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
565 MINOR_TO_CHARS (0, header
->header
.devminor
);
568 if (archive_format
== POSIX_FORMAT
)
570 xheader_store ("atime", st
);
571 xheader_store ("ctime", st
);
573 else if (incremental_option
)
574 if (archive_format
== OLDGNU_FORMAT
)
576 TIME_TO_CHARS (st
->stat
.st_atime
, header
->oldgnu_header
.atime
);
577 TIME_TO_CHARS (st
->stat
.st_ctime
, header
->oldgnu_header
.ctime
);
580 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
582 switch (archive_format
)
588 /* Overwrite header->header.magic and header.version in one blow. */
589 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
594 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
595 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
602 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
604 /* header->header.[ug]name are left as the empty string. */
608 uid_to_uname (st
->stat
.st_uid
, &st
->uname
);
609 gid_to_gname (st
->stat
.st_gid
, &st
->gname
);
611 if (archive_format
== POSIX_FORMAT
612 && strlen (st
->uname
) > UNAME_FIELD_SIZE
)
613 xheader_store ("uname", st
);
615 UNAME_TO_CHARS (st
->uname
, header
->header
.uname
);
617 if (archive_format
== POSIX_FORMAT
618 && strlen (st
->gname
) > GNAME_FIELD_SIZE
)
619 xheader_store ("gname", st
);
621 GNAME_TO_CHARS (st
->gname
, header
->header
.gname
);
627 /* Finish off a filled-in header block and write it out. We also
628 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
629 is not negative, is the block ordinal of the first record for this
630 file, which may be a preceding long name or long link record. */
632 finish_header (union block
*header
, off_t block_ordinal
)
638 /* Note: It is important to do this before the call to write_extended(),
639 so that the actual ustar header is printed */
641 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
642 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
643 && header
->header
.typeflag
!= XHDTYPE
644 && header
->header
.typeflag
!= XGLTYPE
)
646 /* These globals are parameters to print_header, sigh. */
648 current_header
= header
;
649 /* current_stat_info is already set up. */
650 current_format
= archive_format
;
651 print_header (block_ordinal
);
654 header
= write_extended (header
, XHDTYPE
);
656 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
660 for (i
= sizeof *header
; i
-- != 0; )
661 /* We can't use unsigned char here because of old compilers, e.g. V7. */
664 /* Fill in the checksum field. It's formatted differently from the
665 other fields: it has [6] digits, a null, then a space -- rather than
666 digits, then a null. We use to_chars.
667 The final space is already there, from
668 checksumming, and to_chars doesn't modify it.
670 This is a fast way to do:
672 sprintf(header->header.chksum, "%6o", sum); */
674 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
676 set_next_block_after (header
);
679 /* Sparse file processing. */
681 /* Takes a blockful of data and basically cruises through it to see if
682 it's made *entirely* of zeros, returning a 0 the instant it finds
683 something that is a nonzero, i.e., useful data. */
685 zero_block_p (char *buffer
)
689 for (counter
= 0; counter
< BLOCKSIZE
; counter
++)
690 if (buffer
[counter
] != '\0')
696 init_sparsearray (void)
699 sp_array_size
= SPARSES_IN_OLDGNU_HEADER
;
700 sparsearray
= xmalloc (sp_array_size
* sizeof *sparsearray
);
704 find_new_file_size (int sparses
)
708 for (i
= 0; i
< sparses
; i
++)
709 s
+= sparsearray
[i
].numbytes
;
713 /* Make one pass over the file NAME, studying where any non-zero data
714 is, that is, how far into the file each instance of data is, and
715 how many bytes are there. Save this information in the
716 sparsearray, which will later be translated into header
719 /* There is little point in trimming small amounts of null data at the head
720 and tail of blocks, only avoid dumping full null blocks. */
722 /* FIXME: this routine might accept bits of algorithmic cleanup, it is
723 too kludgey for my taste... */
726 deal_with_sparse (char *name
, union block
*header
)
733 char buffer
[BLOCKSIZE
];
735 if (archive_format
== OLDGNU_FORMAT
)
736 header
->oldgnu_header
.isextended
= 0;
738 if (file
= open (name
, O_RDONLY
), file
< 0)
739 /* This problem will be caught later on, so just return. */
743 clear_buffer (buffer
);
747 /* Realloc the scratch area as necessary. FIXME: should reallocate
748 only at beginning of a new instance of non-zero data. */
750 if (sp_array_size
<= sparses
)
753 xrealloc (sparsearray
,
754 2 * sp_array_size
* sizeof (struct sp_array
));
758 count
= safe_read (file
, buffer
, sizeof buffer
);
762 /* Process one block. */
764 if (count
== sizeof buffer
)
766 if (zero_block_p (buffer
))
770 sparsearray
[sparses
++].numbytes
= numbytes
;
777 sparsearray
[sparses
].offset
= offset
;
783 /* Since count < sizeof buffer, we have the last bit of the file. */
785 if (!zero_block_p (buffer
))
788 sparsearray
[sparses
].offset
= offset
;
792 /* The next two lines are suggested by Andreas Degert, who says
793 they are required for trailing full blocks to be written to the
794 archive, when all zeroed. Yet, it seems to me that the case
795 does not apply. Further, at restore time, the file is not as
796 sparse as it should. So, some serious cleanup is *also* needed
797 in this area. Just one more... :-(. FIXME. */
801 /* Prepare for next block. */
804 /* FIXME: do not clear unless necessary. */
805 clear_buffer (buffer
);
809 sparsearray
[sparses
++].numbytes
= numbytes
;
812 sparsearray
[sparses
].offset
= offset
- 1;
813 sparsearray
[sparses
++].numbytes
= 1;
816 return close (file
) == 0 && 0 <= count
? sparses
: 0;
820 finish_sparse_file (int file
, off_t
*sizeleft
, off_t fullsize
, char *name
)
827 while (*sizeleft
> 0)
829 start
= find_next_block ();
830 memset (start
->buffer
, 0, BLOCKSIZE
);
831 bufsize
= sparsearray
[sparses
].numbytes
;
835 if (lseek (file
, sparsearray
[sparses
++].offset
, SEEK_SET
) < 0)
837 (ignore_failed_read_option
? seek_warn_details
: seek_error_details
)
838 (name
, sparsearray
[sparses
- 1].offset
);
842 /* If the number of bytes to be written here exceeds the size of
843 the temporary buffer, do it in steps. */
845 while (bufsize
> BLOCKSIZE
)
847 count
= safe_read (file
, start
->buffer
, BLOCKSIZE
);
850 (ignore_failed_read_option
852 : read_error_details
)
853 (name
, fullsize
- *sizeleft
, bufsize
);
858 set_next_block_after (start
);
859 start
= find_next_block ();
860 memset (start
->buffer
, 0, BLOCKSIZE
);
864 char buffer
[BLOCKSIZE
];
866 clear_buffer (buffer
);
867 count
= safe_read (file
, buffer
, bufsize
);
868 memcpy (start
->buffer
, buffer
, BLOCKSIZE
);
873 (ignore_failed_read_option
875 : read_error_details
)
876 (name
, fullsize
- *sizeleft
, bufsize
);
881 set_next_block_after (start
);
885 set_next_block_after (start
+ (count
- 1) / BLOCKSIZE
);
890 /* Main functions of this module. */
893 create_archive (void)
897 open_archive (ACCESS_WRITE
);
899 if (incremental_option
)
901 size_t buffer_size
= 1000;
902 char *buffer
= xmalloc (buffer_size
);
905 collect_and_sort_names ();
907 while (p
= name_from_list (), p
)
908 if (!excluded_name (p
))
909 dump_file (p
, -1, (dev_t
) 0);
912 while (p
= name_from_list (), p
)
913 if (!excluded_name (p
))
915 size_t plen
= strlen (p
);
916 if (buffer_size
<= plen
)
918 while ((buffer_size
*= 2) <= plen
)
920 buffer
= xrealloc (buffer
, buffer_size
);
922 memcpy (buffer
, p
, plen
);
923 if (! ISSLASH (buffer
[plen
- 1]))
924 buffer
[plen
++] = '/';
925 q
= gnu_list_name
->dir_contents
;
929 size_t qlen
= strlen (q
);
932 if (buffer_size
< plen
+ qlen
)
934 while ((buffer_size
*=2 ) < plen
+ qlen
)
936 buffer
= xrealloc (buffer
, buffer_size
);
938 strcpy (buffer
+ plen
, q
+ 1);
939 dump_file (buffer
, -1, (dev_t
) 0);
948 while (p
= name_next (1), p
)
949 if (!excluded_name (p
))
950 dump_file (p
, 1, (dev_t
) 0);
956 if (listed_incremental_option
)
957 write_directory_file ();
961 /* Calculate the hash of a link. */
963 hash_link (void const *entry
, unsigned n_buckets
)
965 struct link
const *link
= entry
;
966 return (uintmax_t) (link
->dev
^ link
->ino
) % n_buckets
;
969 /* Compare two links for equality. */
971 compare_links (void const *entry1
, void const *entry2
)
973 struct link
const *link1
= entry1
;
974 struct link
const *link2
= entry2
;
975 return ((link1
->dev
^ link2
->dev
) | (link1
->ino
^ link2
->ino
)) == 0;
978 /* Table of all non-directories that we've written so far. Any time
979 we see another, we check the table and avoid dumping the data
980 again if we've done it once already. */
981 static Hash_table
*link_table
;
983 /* Dump a single file, recursing on directories. P is the file name
984 to dump. TOP_LEVEL tells whether this is a top-level call; zero
985 means no, positive means yes, and negative means the top level
986 of an incremental dump. PARENT_DEVICE is the device of P's
987 parent directory; it is examined only if TOP_LEVEL is zero.
989 Set global CURRENT_STAT_INFO to stat output for this file. */
991 /* FIXME: One should make sure that for *every* path leading to setting
992 exit_status to failure, a clear diagnostic has been issued. */
995 dump_file (char *p
, int top_level
, dev_t parent_device
)
1001 time_t original_ctime
;
1002 struct utimbuf restore_times
;
1003 off_t block_ordinal
= -1;
1005 /* FIXME: `header' might be used uninitialized in this
1006 function. Reported by Bruno Haible. */
1008 if (interactive_option
&& !confirm ("add", p
))
1011 if (deref_stat (dereference_option
, p
, ¤t_stat_info
.stat
) != 0)
1013 if (ignore_failed_read_option
)
1020 original_ctime
= current_stat_info
.stat
.st_ctime
;
1021 restore_times
.actime
= current_stat_info
.stat
.st_atime
;
1022 restore_times
.modtime
= current_stat_info
.stat
.st_mtime
;
1025 if (S_ISHIDDEN (current_stat_info
.stat
.st_mode
))
1027 char *new = (char *) alloca (strlen (p
) + 2);
1037 /* See if we want only new files, and check if this one is too old to
1038 put in the archive. */
1040 if ((0 < top_level
|| !incremental_option
)
1041 && !S_ISDIR (current_stat_info
.stat
.st_mode
)
1042 && current_stat_info
.stat
.st_mtime
< newer_mtime_option
1043 && (!after_date_option
|| current_stat_info
.stat
.st_ctime
< newer_ctime_option
))
1046 WARN ((0, 0, _("%s: file is unchanged; not dumped"),
1047 quotearg_colon (p
)));
1048 /* FIXME: recheck this return. */
1053 /* See if we are trying to dump the archive. */
1055 if (ar_dev
&& current_stat_info
.stat
.st_dev
== ar_dev
&& current_stat_info
.stat
.st_ino
== ar_ino
)
1057 WARN ((0, 0, _("%s: file is the archive; not dumped"),
1058 quotearg_colon (p
)));
1063 if (S_ISDIR (current_stat_info
.stat
.st_mode
))
1071 dev_t our_device
= current_stat_info
.stat
.st_dev
;
1075 directory
= savedir (p
);
1078 if (ignore_failed_read_option
)
1085 /* Build new prototype name. Ensure exactly one trailing slash. */
1088 buflen
= len
+ NAME_FIELD_SIZE
;
1089 namebuf
= xmalloc (buflen
+ 1);
1090 memcpy (namebuf
, p
, len
);
1091 while (len
>= 1 && ISSLASH (namebuf
[len
- 1]))
1093 namebuf
[len
++] = '/';
1094 namebuf
[len
] = '\0';
1096 if (! is_avoided_name (namebuf
))
1098 /* The condition above used to be "archive_format != V7_FORMAT".
1099 GNU tar was not writing directory blocks at all. Daniel Trinkle
1100 writes: ``All old versions of tar I have ever seen have
1101 correctly archived an empty directory. The really old ones I
1102 checked included HP-UX 7 and Mt. Xinu More/BSD. There may be
1103 some subtle reason for the exclusion that I don't know, but the
1104 current behavior is broken.'' I do not know those subtle
1105 reasons either, so until these are reported (anew?), just allow
1106 directory blocks to be written even with old archives. */
1108 block_ordinal
= current_block_ordinal ();
1109 current_stat_info
.stat
.st_size
= 0; /* force 0 size on dir */
1111 /* FIXME: If people could really read standard archives, this
1115 = start_header (standard_option ? p : namebuf, ¤t_stat_info);
1117 but since they'd interpret DIRTYPE blocks as regular
1118 files, we'd better put the / on the name. */
1120 header
= start_header (namebuf
, ¤t_stat_info
);
1122 if (incremental_option
)
1123 header
->header
.typeflag
= GNUTYPE_DUMPDIR
;
1124 else /* if (standard_option) */
1125 header
->header
.typeflag
= DIRTYPE
;
1127 /* If we're gnudumping, we aren't done yet so don't close it. */
1129 if (!incremental_option
)
1130 finish_header (header
, block_ordinal
);
1133 if (incremental_option
&& gnu_list_name
->dir_contents
)
1140 const char *buffer
, *p_buffer
;
1142 buffer
= gnu_list_name
->dir_contents
; /* FOO */
1145 for (p_buffer
= buffer
; *p_buffer
; )
1147 size_t size
= strlen (p_buffer
) + 1;
1152 OFF_TO_CHARS (totsize
, header
->header
.size
);
1153 finish_header (header
, block_ordinal
);
1156 while (sizeleft
> 0)
1158 if (multi_volume_option
)
1160 assign_string (&save_name
, p
);
1161 save_sizeleft
= sizeleft
;
1162 save_totsize
= totsize
;
1164 start
= find_next_block ();
1165 bufsize
= available_space_after (start
);
1166 if (sizeleft
< bufsize
)
1169 count
= bufsize
% BLOCKSIZE
;
1171 memset (start
->buffer
+ sizeleft
, 0, BLOCKSIZE
- count
);
1173 memcpy (start
->buffer
, p_buffer
, bufsize
);
1174 sizeleft
-= bufsize
;
1175 p_buffer
+= bufsize
;
1176 set_next_block_after (start
+ (bufsize
- 1) / BLOCKSIZE
);
1178 if (multi_volume_option
)
1179 assign_string (&save_name
, 0);
1183 /* See if we are about to recurse into a directory, and avoid doing
1184 so if the user wants that we do not descend into directories. */
1186 if (! recursion_option
)
1189 /* See if we are crossing from one file system to another, and
1190 avoid doing so if the user only wants to dump one file system. */
1192 if (one_file_system_option
&& !top_level
1193 && parent_device
!= current_stat_info
.stat
.st_dev
)
1197 _("%s: file is on a different filesystem; not dumped"),
1198 quotearg_colon (p
)));
1202 /* Now output all the files in the directory. */
1204 /* FIXME: Should speed this up by cd-ing into the dir. */
1206 for (entry
= directory
;
1207 (entrylen
= strlen (entry
)) != 0;
1208 entry
+= entrylen
+ 1)
1210 if (buflen
< len
+ entrylen
)
1212 buflen
= len
+ entrylen
;
1213 namebuf
= xrealloc (namebuf
, buflen
+ 1);
1215 strcpy (namebuf
+ len
, entry
);
1216 if (!excluded_name (namebuf
))
1217 dump_file (namebuf
, 0, our_device
);
1224 if (atime_preserve_option
)
1225 utime (p
, &restore_times
);
1228 else if (is_avoided_name (p
))
1232 /* Check for multiple links. */
1234 if (1 < current_stat_info
.stat
.st_nlink
&& link_table
)
1238 lp
.ino
= current_stat_info
.stat
.st_ino
;
1239 lp
.dev
= current_stat_info
.stat
.st_dev
;
1241 if ((dup
= hash_lookup (link_table
, &lp
)))
1243 /* We found a link. */
1244 char const *link_name
= safer_name_suffix (dup
->name
, 1);
1248 block_ordinal
= current_block_ordinal ();
1249 if (NAME_FIELD_SIZE
<= strlen (link_name
))
1250 write_long (link_name
, GNUTYPE_LONGLINK
);
1251 assign_string (¤t_stat_info
.link_name
, link_name
);
1253 current_stat_info
.stat
.st_size
= 0;
1254 header
= start_header (p
, ¤t_stat_info
);
1255 strncpy (header
->header
.linkname
, link_name
, NAME_FIELD_SIZE
);
1257 /* Force null termination. */
1258 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = 0;
1260 header
->header
.typeflag
= LNKTYPE
;
1261 finish_header (header
, block_ordinal
);
1263 /* FIXME: Maybe remove from table after all links found? */
1265 if (remove_files_option
&& unlink (p
) != 0)
1268 /* We dumped it, and we don't need to put it in the
1274 /* This is not a link to a previously dumped file, so dump it. */
1276 if (S_ISREG (current_stat_info
.stat
.st_mode
)
1277 || S_ISCTG (current_stat_info
.stat
.st_mode
))
1279 int f
; /* file descriptor */
1285 char isextended
= 0;
1292 /* Check the size of the file against the number of blocks
1293 allocated for it, counting both data and indirect blocks.
1294 If there is a smaller number of blocks than would be
1295 necessary to accommodate a file of this size, this is safe
1296 to say that we have a sparse file: at least one of those
1297 blocks in the file is just a useless hole. For sparse
1298 files not having more hole blocks than indirect blocks, the
1299 sparseness will go undetected. */
1301 /* Bruno Haible sent me these statistics for Linux. It seems
1302 that some filesystems count indirect blocks in st_blocks,
1303 while others do not seem to:
1305 minix-fs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1306 extfs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1307 ext2fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1308 msdos-fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1310 Dick Streefland reports the previous numbers as misleading,
1311 because ext2fs use 12 direct blocks, while minix-fs uses only
1312 6 direct blocks. Dick gets:
1314 ext2 size=20480 ls listed blocks=21
1315 minix size=20480 ls listed blocks=21
1316 msdos size=20480 ls listed blocks=20
1318 It seems that indirect blocks *are* included in st_blocks.
1319 The minix filesystem does not account for phantom blocks in
1320 st_blocks, so `du' and `ls -s' give wrong results. So, the
1321 --sparse option would not work on a minix filesystem. */
1323 if (ST_NBLOCKS (current_stat_info
.stat
)
1324 < (current_stat_info
.stat
.st_size
/ ST_NBLOCKSIZE
1325 + (current_stat_info
.stat
.st_size
% ST_NBLOCKSIZE
!= 0)))
1329 block_ordinal
= current_block_ordinal ();
1330 header
= start_header (p
, ¤t_stat_info
);
1331 header
->header
.typeflag
= GNUTYPE_SPARSE
;
1334 /* Call the routine that figures out the layout of the
1335 sparse file in question. SPARSES is the index of the
1336 first unused element of the "sparsearray," i.e.,
1337 the number of elements it needed to describe the file. */
1339 sparses
= deal_with_sparse (p
, header
);
1341 /* See if we'll need an extended header later. */
1343 if (SPARSES_IN_OLDGNU_HEADER
< sparses
)
1344 header
->oldgnu_header
.isextended
= 1;
1346 /* We store the "real" file size so we can show that in
1347 case someone wants to list the archive, i.e., tar tvf
1348 <file>. It might be kind of disconcerting if the
1349 shrunken file size was the one that showed up. */
1351 OFF_TO_CHARS (current_stat_info
.stat
.st_size
,
1352 header
->oldgnu_header
.realsize
);
1354 /* This will be the new "size" of the file, i.e., the size
1355 of the file minus the blocks of holes that we're
1358 current_stat_info
.stat
.st_size
= find_new_file_size (sparses
);
1359 OFF_TO_CHARS (current_stat_info
.stat
.st_size
, header
->header
.size
);
1362 counter
< sparses
&& counter
< SPARSES_IN_OLDGNU_HEADER
;
1365 OFF_TO_CHARS (sparsearray
[counter
].offset
,
1366 header
->oldgnu_header
.sp
[counter
].offset
);
1367 SIZE_TO_CHARS (sparsearray
[counter
].numbytes
,
1368 header
->oldgnu_header
.sp
[counter
].numbytes
);
1373 sizeleft
= current_stat_info
.stat
.st_size
;
1375 /* Don't bother opening empty, world readable files. Also do not open
1376 files when archive is meant for /dev/null. */
1380 && MODE_R
== (MODE_R
& current_stat_info
.stat
.st_mode
)))
1384 f
= open (p
, O_RDONLY
| O_BINARY
);
1387 if (! top_level
&& errno
== ENOENT
)
1388 WARN ((0, 0, _("%s: File removed before we read it"),
1389 quotearg_colon (p
)));
1391 (ignore_failed_read_option
? open_warn
: open_error
) (p
);
1396 /* If the file is sparse, we've already taken care of this. */
1400 block_ordinal
= current_block_ordinal ();
1401 header
= start_header (p
, ¤t_stat_info
);
1404 /* Mark contiguous files, if we support them. */
1406 if (archive_format
!= V7_FORMAT
&& S_ISCTG (current_stat_info
.stat
.st_mode
))
1407 header
->header
.typeflag
= CONTTYPE
;
1409 isextended
= header
->oldgnu_header
.isextended
;
1410 save_typeflag
= header
->header
.typeflag
;
1411 finish_header (header
, block_ordinal
);
1414 int sparses_emitted
= SPARSES_IN_OLDGNU_HEADER
;
1419 exhdr
= find_next_block ();
1420 memset (exhdr
->buffer
, 0, BLOCKSIZE
);
1422 (i
< SPARSES_IN_SPARSE_HEADER
1423 && sparses_emitted
+ i
< sparses
);
1426 SIZE_TO_CHARS (sparsearray
[sparses_emitted
+ i
].numbytes
,
1427 exhdr
->sparse_header
.sp
[i
].numbytes
);
1428 OFF_TO_CHARS (sparsearray
[sparses_emitted
+ i
].offset
,
1429 exhdr
->sparse_header
.sp
[i
].offset
);
1431 set_next_block_after (exhdr
);
1432 sparses_emitted
+= i
;
1433 if (sparses
== sparses_emitted
)
1435 exhdr
->sparse_header
.isextended
= 1;
1438 if (save_typeflag
== GNUTYPE_SPARSE
)
1441 || finish_sparse_file (f
, &sizeleft
,
1442 current_stat_info
.stat
.st_size
, p
))
1446 while (sizeleft
> 0)
1448 if (multi_volume_option
)
1450 assign_string (&save_name
, p
);
1451 save_sizeleft
= sizeleft
;
1452 save_totsize
= current_stat_info
.stat
.st_size
;
1454 start
= find_next_block ();
1456 bufsize
= available_space_after (start
);
1458 if (sizeleft
< bufsize
)
1460 /* Last read -- zero out area beyond. */
1463 count
= bufsize
% BLOCKSIZE
;
1465 memset (start
->buffer
+ sizeleft
, 0, BLOCKSIZE
- count
);
1470 count
= safe_read (f
, start
->buffer
, bufsize
);
1473 (ignore_failed_read_option
1475 : read_error_details
)
1476 (p
, current_stat_info
.stat
.st_size
- sizeleft
, bufsize
);
1481 /* This is nonportable (the type of set_next_block_after's arg). */
1483 set_next_block_after (start
+ (bufsize
- 1) / BLOCKSIZE
);
1486 if (count
!= bufsize
)
1488 char buf
[UINTMAX_STRSIZE_BOUND
];
1489 memset (start
->buffer
+ count
, 0, bufsize
- count
);
1491 _("%s: File shrank by %s bytes; padding with zeros"),
1493 STRINGIFY_BIGINT (sizeleft
, buf
)));
1494 if (! ignore_failed_read_option
)
1495 exit_status
= TAREXIT_FAILURE
;
1496 goto padit
; /* short read */
1500 if (multi_volume_option
)
1501 assign_string (&save_name
, 0);
1505 struct stat final_stat
;
1506 if (fstat (f
, &final_stat
) != 0)
1508 if (ignore_failed_read_option
)
1513 else if (final_stat
.st_ctime
!= original_ctime
)
1515 char const *qp
= quotearg_colon (p
);
1516 WARN ((0, 0, _("%s: file changed as we read it"), qp
));
1520 if (ignore_failed_read_option
)
1525 if (atime_preserve_option
)
1526 utime (p
, &restore_times
);
1528 if (remove_files_option
)
1530 if (unlink (p
) == -1)
1533 goto file_was_dumped
;
1535 /* File shrunk or gave error, pad out tape to match the size we
1536 specified in the header. */
1539 while (sizeleft
> 0)
1541 save_sizeleft
= sizeleft
;
1542 start
= find_next_block ();
1543 memset (start
->buffer
, 0, BLOCKSIZE
);
1544 set_next_block_after (start
);
1545 sizeleft
-= BLOCKSIZE
;
1547 if (multi_volume_option
)
1548 assign_string (&save_name
, 0);
1552 if (atime_preserve_option
)
1553 utime (p
, &restore_times
);
1555 goto file_was_dumped
;
1557 #ifdef HAVE_READLINK
1558 else if (S_ISLNK (current_stat_info
.stat
.st_mode
))
1562 size_t linklen
= current_stat_info
.stat
.st_size
;
1563 if (linklen
!= current_stat_info
.stat
.st_size
|| linklen
+ 1 == 0)
1565 buffer
= (char *) alloca (linklen
+ 1);
1566 size
= readlink (p
, buffer
, linklen
+ 1);
1569 if (ignore_failed_read_option
)
1575 buffer
[size
] = '\0';
1576 if (size
>= NAME_FIELD_SIZE
)
1577 write_long (buffer
, GNUTYPE_LONGLINK
);
1578 assign_string (¤t_stat_info
.link_name
, buffer
);
1580 block_ordinal
= current_block_ordinal ();
1581 current_stat_info
.stat
.st_size
= 0; /* force 0 size on symlink */
1582 header
= start_header (p
, ¤t_stat_info
);
1583 strncpy (header
->header
.linkname
, buffer
, NAME_FIELD_SIZE
);
1584 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = '\0';
1585 header
->header
.typeflag
= SYMTYPE
;
1586 finish_header (header
, block_ordinal
);
1587 /* nothing more to do to it */
1589 if (remove_files_option
)
1591 if (unlink (p
) == -1)
1594 goto file_was_dumped
;
1597 else if (S_ISCHR (current_stat_info
.stat
.st_mode
))
1599 else if (S_ISBLK (current_stat_info
.stat
.st_mode
))
1601 else if (S_ISFIFO (current_stat_info
.stat
.st_mode
))
1603 else if (S_ISSOCK (current_stat_info
.stat
.st_mode
))
1605 WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1608 else if (S_ISDOOR (current_stat_info
.stat
.st_mode
))
1610 WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1617 if (archive_format
== V7_FORMAT
)
1620 block_ordinal
= current_block_ordinal ();
1621 current_stat_info
.stat
.st_size
= 0; /* force 0 size */
1622 header
= start_header (p
, ¤t_stat_info
);
1623 header
->header
.typeflag
= type
;
1625 if (type
!= FIFOTYPE
)
1627 MAJOR_TO_CHARS (major (current_stat_info
.stat
.st_rdev
), header
->header
.devmajor
);
1628 MINOR_TO_CHARS (minor (current_stat_info
.stat
.st_rdev
), header
->header
.devminor
);
1631 finish_header (header
, block_ordinal
);
1632 if (remove_files_option
)
1634 if (unlink (p
) == -1)
1637 goto file_was_dumped
;
1640 WARN ((0, 0, _("%s: Unknown file type; file ignored"),
1641 quotearg_colon (p
)));
1642 if (! ignore_failed_read_option
)
1643 exit_status
= TAREXIT_FAILURE
;
1647 if (1 < current_stat_info
.stat
.st_nlink
)
1650 struct link
*lp
= xmalloc (offsetof (struct link
, name
)
1652 lp
->ino
= current_stat_info
.stat
.st_ino
;
1653 lp
->dev
= current_stat_info
.stat
.st_dev
;
1654 lp
->nlink
= current_stat_info
.stat
.st_nlink
;
1655 strcpy (lp
->name
, p
);
1658 || (link_table
= hash_initialize (0, 0, hash_link
,
1660 && (dup
= hash_insert (link_table
, lp
))))
1670 /* For each dumped file, check if all its links were dumped. Emit
1671 warnings if it is not so. */
1680 for (lp
= hash_get_first (link_table
); lp
;
1681 lp
= hash_get_next (link_table
, lp
))
1685 WARN ((0, 0, _("Missing links to '%s'.\n"), lp
->name
));