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. */
47 /* The maximum uintmax_t value that can be represented with DIGITS digits,
48 assuming that each digit is BITS_PER_DIGIT wide. */
49 #define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
50 ((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
51 ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
54 /* Convert VALUE to an octal representation suitable for tar headers.
55 Output to buffer WHERE with size SIZE.
56 The result is undefined if SIZE is 0 or if VALUE is too large to fit. */
59 to_octal (uintmax_t value
, char *where
, size_t size
)
66 where
[--i
] = '0' + (v
& ((1 << LG_8
) - 1));
72 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
73 tar headers. NEGATIVE is 1 if VALUE was negative before being cast
74 to uintmax_t, 0 otherwise. Output to buffer WHERE with size SIZE.
75 The result is undefined if SIZE is 0 or if VALUE is too large to
79 to_base256 (int negative
, uintmax_t value
, char *where
, size_t size
)
82 uintmax_t propagated_sign_bits
=
83 ((uintmax_t) - negative
<< (CHAR_BIT
* sizeof v
- LG_256
));
88 where
[--i
] = v
& ((1 << LG_256
) - 1);
89 v
= propagated_sign_bits
| (v
>> LG_256
);
94 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
95 external form, using SUBSTITUTE (...) if VALUE won't fit. Output
96 to buffer WHERE with size SIZE. NEGATIVE is 1 iff VALUE was
97 negative before being cast to uintmax_t; its original bitpattern
98 can be deduced from VALSIZE, its original size before casting.
99 TYPE is the kind of value being output (useful for diagnostics).
100 Prefer the POSIX format of SIZE - 1 octal digits (with leading zero
101 digits), followed by '\0'. If this won't work, and if GNU or
102 OLDGNU format is allowed, use '\200' followed by base-256, or (if
103 NEGATIVE is nonzero) '\377' followed by two's complement base-256.
104 If neither format works, use SUBSTITUTE (...) instead. Pass to
105 SUBSTITUTE the address of an 0-or-1 flag recording whether the
106 substitute value is negative. */
109 to_chars (int negative
, uintmax_t value
, size_t valsize
,
110 uintmax_t (*substitute
) (int *),
111 char *where
, size_t size
, const char *type
)
113 int base256_allowed
= (archive_format
== GNU_FORMAT
114 || archive_format
== OLDGNU_FORMAT
);
116 /* Generate the POSIX octal representation if the number fits. */
117 if (! negative
&& value
<= MAX_VAL_WITH_DIGITS (size
- 1, LG_8
))
119 where
[size
- 1] = '\0';
120 to_octal (value
, where
, size
- 1);
123 /* Otherwise, generate the base-256 representation if we are
124 generating an old or new GNU format and if the number fits. */
125 else if (((negative
? -1 - value
: value
)
126 <= MAX_VAL_WITH_DIGITS (size
- 1, LG_256
))
129 where
[0] = negative
? -1 : 1 << (LG_256
- 1);
130 to_base256 (negative
, value
, where
+ 1, size
- 1);
133 /* Otherwise, if the number is negative, and if it would not cause
134 ambiguity on this host by confusing positive with negative
135 values, then generate the POSIX octal representation of the value
136 modulo 2**(field bits). The resulting tar file is
137 machine-dependent, since it depends on the host word size. Yuck!
138 But this is the traditional behavior. */
139 else if (negative
&& valsize
* CHAR_BIT
<= (size
- 1) * LG_8
)
141 static int warned_once
;
145 WARN ((0, 0, _("Generating negative octal headers")));
147 where
[size
- 1] = '\0';
148 to_octal (value
& MAX_VAL_WITH_DIGITS (valsize
* CHAR_BIT
, 1),
152 /* Otherwise, output a substitute value if possible (with a
153 warning), and an error message if not. */
156 uintmax_t maxval
= (base256_allowed
157 ? MAX_VAL_WITH_DIGITS (size
- 1, LG_256
)
158 : MAX_VAL_WITH_DIGITS (size
- 1, LG_8
));
159 char valbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
160 char maxbuf
[UINTMAX_STRSIZE_BOUND
];
161 char minbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
162 char const *minval_string
;
163 char const *maxval_string
= STRINGIFY_BIGINT (maxval
, maxbuf
);
164 char const *value_string
;
168 uintmax_t m
= maxval
+ 1 ? maxval
+ 1 : maxval
/ 2 + 1;
169 char *p
= STRINGIFY_BIGINT (m
, minbuf
+ 1);
178 char *p
= STRINGIFY_BIGINT (- value
, valbuf
+ 1);
183 value_string
= STRINGIFY_BIGINT (value
, valbuf
);
188 uintmax_t sub
= substitute (&negsub
) & maxval
;
189 uintmax_t s
= (negsub
&= archive_format
== GNU_FORMAT
) ? - sub
: sub
;
190 char subbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
191 char *sub_string
= STRINGIFY_BIGINT (s
, subbuf
+ 1);
194 WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
195 value_string
, type
, minval_string
, maxval_string
,
197 to_chars (negsub
, s
, valsize
, 0, where
, size
, type
);
200 ERROR ((0, 0, _("value %s out of %s range %s..%s"),
201 value_string
, type
, minval_string
, maxval_string
));
206 gid_substitute (int *negative
)
212 static gid_t gid_nobody
;
213 if (!gid_nobody
&& !gname_to_gid ("nobody", &gid_nobody
))
222 gid_to_chars (gid_t v
, char *p
, size_t s
)
224 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, gid_substitute
, p
, s
, "gid_t");
228 major_to_chars (major_t v
, char *p
, size_t s
)
230 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "major_t");
234 minor_to_chars (minor_t v
, char *p
, size_t s
)
236 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "minor_t");
240 mode_to_chars (mode_t v
, char *p
, size_t s
)
242 /* In the common case where the internal and external mode bits are the same,
243 and we are not using POSIX or GNU format,
244 propagate all unknown bits to the external mode.
245 This matches historical practice.
246 Otherwise, just copy the bits we know about. */
249 if (S_ISUID
== TSUID
&& S_ISGID
== TSGID
&& S_ISVTX
== TSVTX
250 && S_IRUSR
== TUREAD
&& S_IWUSR
== TUWRITE
&& S_IXUSR
== TUEXEC
251 && S_IRGRP
== TGREAD
&& S_IWGRP
== TGWRITE
&& S_IXGRP
== TGEXEC
252 && S_IROTH
== TOREAD
&& S_IWOTH
== TOWRITE
&& S_IXOTH
== TOEXEC
253 && archive_format
!= POSIX_FORMAT
254 && archive_format
!= GNU_FORMAT
)
262 u
= ((v
& S_ISUID
? TSUID
: 0)
263 | (v
& S_ISGID
? TSGID
: 0)
264 | (v
& S_ISVTX
? TSVTX
: 0)
265 | (v
& S_IRUSR
? TUREAD
: 0)
266 | (v
& S_IWUSR
? TUWRITE
: 0)
267 | (v
& S_IXUSR
? TUEXEC
: 0)
268 | (v
& S_IRGRP
? TGREAD
: 0)
269 | (v
& S_IWGRP
? TGWRITE
: 0)
270 | (v
& S_IXGRP
? TGEXEC
: 0)
271 | (v
& S_IROTH
? TOREAD
: 0)
272 | (v
& S_IWOTH
? TOWRITE
: 0)
273 | (v
& S_IXOTH
? TOEXEC
: 0));
275 to_chars (negative
, u
, sizeof v
, 0, p
, s
, "mode_t");
279 off_to_chars (off_t v
, char *p
, size_t s
)
281 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "off_t");
285 size_to_chars (size_t v
, char *p
, size_t s
)
287 to_chars (0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "size_t");
291 time_to_chars (time_t v
, char *p
, size_t s
)
293 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "time_t");
297 uid_substitute (int *negative
)
303 static uid_t uid_nobody
;
304 if (!uid_nobody
&& !uname_to_uid ("nobody", &uid_nobody
))
313 uid_to_chars (uid_t v
, char *p
, size_t s
)
315 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, uid_substitute
, p
, s
, "uid_t");
319 uintmax_to_chars (uintmax_t v
, char *p
, size_t s
)
321 to_chars (0, v
, sizeof v
, 0, p
, s
, "uintmax_t");
325 string_to_chars (char *str
, char *p
, size_t s
)
332 /* Writing routines. */
334 /* Zero out the buffer so we don't confuse ourselves with leftover
337 clear_buffer (char *buffer
)
339 memset (buffer
, 0, BLOCKSIZE
);
342 /* Write the EOT block(s). Zero at least two blocks, through the end
343 of the record. Old tar, as previous versions of GNU tar, writes
344 garbage after two zeroed blocks. */
348 union block
*pointer
= find_next_block ();
349 memset (pointer
->buffer
, 0, BLOCKSIZE
);
350 set_next_block_after (pointer
);
351 pointer
= find_next_block ();
352 memset (pointer
->buffer
, 0, available_space_after (pointer
));
353 set_next_block_after (pointer
);
356 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. */
358 /* FIXME: Cross recursion between start_header and write_long! */
360 static union block
*start_header (const char *, struct tar_stat_info
*);
363 write_long (const char *p
, char type
)
365 size_t size
= strlen (p
) + 1;
368 struct tar_stat_info foo
;
370 memset (&foo
, 0, sizeof foo
);
371 foo
.stat
.st_size
= size
;
373 header
= start_header ("././@LongLink", &foo
);
374 header
->header
.typeflag
= type
;
375 finish_header (header
, -1);
377 header
= find_next_block ();
379 bufsize
= available_space_after (header
);
381 while (bufsize
< size
)
383 memcpy (header
->buffer
, p
, bufsize
);
386 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
387 header
= find_next_block ();
388 bufsize
= available_space_after (header
);
390 memcpy (header
->buffer
, p
, size
);
391 memset (header
->buffer
+ size
, 0, bufsize
- size
);
392 set_next_block_after (header
+ (size
- 1) / BLOCKSIZE
);
395 /* Write a long link name, depending on the current archive format */
397 write_long_link (struct tar_stat_info
*st
)
399 if (archive_format
== POSIX_FORMAT
)
400 xheader_store ("linkpath", st
);
402 write_long (st
->link_name
, GNUTYPE_LONGNAME
);
405 /* NOTE: Cross recursion between start_header and write_extended */
408 write_extended (union block
*old_header
, char type
)
410 union block
*header
, hp
;
411 struct tar_stat_info foo
;
415 if (extended_header
.buffer
|| extended_header
.stk
== NULL
)
416 return old_header
; /* Prevent recursion */
418 xheader_finish (&extended_header
);
419 size
= extended_header
.size
;
420 memset (&foo
, 0, sizeof foo
);
421 foo
.stat
.st_mode
= S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
;
422 time (&foo
.stat
.st_ctime
);
423 foo
.stat
.st_atime
= foo
.stat
.st_ctime
;
424 foo
.stat
.st_mtime
= foo
.stat
.st_ctime
;
425 foo
.stat
.st_size
= size
;
427 memcpy (hp
.buffer
, old_header
, sizeof (hp
));
429 header
= start_header ("././@PaxHeader", &foo
);
430 header
->header
.typeflag
= type
;
432 finish_header (header
, -1);
434 p
= extended_header
.buffer
;
440 header
= find_next_block ();
444 memcpy (header
->buffer
, p
, len
);
446 memset (header
->buffer
+ len
, 0, BLOCKSIZE
- len
);
449 set_next_block_after (header
);
453 xheader_destroy (&extended_header
);
454 header
= find_next_block ();
455 memcpy (header
, &hp
.buffer
, sizeof (hp
.buffer
));
460 /* Header handling. */
462 /* Make a header block for the file whose stat info is st,
463 and return its address. */
466 start_header (const char *name
, struct tar_stat_info
*st
)
470 name
= safer_name_suffix (name
, 0);
471 assign_string (&st
->file_name
, name
);
473 if (sizeof header
->header
.name
<= strlen (name
))
475 if (archive_format
== POSIX_FORMAT
)
476 xheader_store ("path", st
);
478 write_long (name
, GNUTYPE_LONGNAME
);
481 header
= find_next_block ();
482 memset (header
->buffer
, 0, sizeof (union block
));
484 assign_string (¤t_stat_info
.file_name
, name
);
486 strncpy (header
->header
.name
, name
, NAME_FIELD_SIZE
);
487 header
->header
.name
[NAME_FIELD_SIZE
- 1] = '\0';
489 /* Override some stat fields, if requested to do so. */
491 if (owner_option
!= (uid_t
) -1)
492 st
->stat
.st_uid
= owner_option
;
493 if (group_option
!= (gid_t
) -1)
494 st
->stat
.st_gid
= group_option
;
496 st
->stat
.st_mode
= ((st
->stat
.st_mode
& ~MODE_ALL
)
497 | mode_adjust (st
->stat
.st_mode
, mode_option
));
499 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
500 for a few tars and came up with the following interoperability
504 1 2 3 4 5 6 7 8 9 READER
505 . . . . . . . . . 1 = SunOS 4.2 tar
506 # . . # # . . # # 2 = NEC SVR4.0.2 tar
507 . . . # # . . # . 3 = Solaris 2.1 tar
508 . . . . . . . . . 4 = GNU tar 1.11.1
509 . . . . . . . . . 5 = HP-UX 8.07 tar
510 . . . . . . . . . 6 = Ultrix 4.1
511 . . . . . . . . . 7 = AIX 3.2
512 . . . . . . . . . 8 = Hitachi HI-UX 1.03
513 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
516 # = ``impossible file type''
518 The following mask for old archive removes the `#'s in column 4
519 above, thus making GNU tar both a universal donor and a universal
520 acceptor for Paul's test. */
522 if (archive_format
== V7_FORMAT
)
523 MODE_TO_CHARS (st
->stat
.st_mode
& MODE_ALL
, header
->header
.mode
);
525 MODE_TO_CHARS (st
->stat
.st_mode
, header
->header
.mode
);
527 if (st
->stat
.st_uid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
528 xheader_store ("uid", st
);
530 UID_TO_CHARS (st
->stat
.st_uid
, header
->header
.uid
);
532 if (st
->stat
.st_gid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
533 xheader_store ("gid", st
);
535 GID_TO_CHARS (st
->stat
.st_gid
, header
->header
.gid
);
537 if (st
->stat
.st_size
> MAXOCTAL11
&& archive_format
== POSIX_FORMAT
)
538 xheader_store ("size", st
);
540 OFF_TO_CHARS (st
->stat
.st_size
, header
->header
.size
);
542 TIME_TO_CHARS (st
->stat
.st_mtime
, header
->header
.mtime
);
545 if (S_ISCHR (st
->stat
.st_mode
)
546 || S_ISBLK (st
->stat
.st_mode
))
548 st
->devmajor
= major (st
->stat
.st_rdev
);
549 st
->devminor
= minor (st
->stat
.st_rdev
);
551 if (st
->devmajor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
552 xheader_store ("devmajor", st
);
554 MAJOR_TO_CHARS (st
->devmajor
, header
->header
.devmajor
);
556 if (st
->devminor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
557 xheader_store ("devminor", st
);
559 MAJOR_TO_CHARS (st
->devminor
, header
->header
.devminor
);
563 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
564 MINOR_TO_CHARS (0, header
->header
.devminor
);
567 if (archive_format
== POSIX_FORMAT
)
569 xheader_store ("atime", st
);
570 xheader_store ("ctime", st
);
572 else if (incremental_option
)
573 if (archive_format
== OLDGNU_FORMAT
)
575 TIME_TO_CHARS (st
->stat
.st_atime
, header
->oldgnu_header
.atime
);
576 TIME_TO_CHARS (st
->stat
.st_ctime
, header
->oldgnu_header
.ctime
);
579 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
581 switch (archive_format
)
587 /* Overwrite header->header.magic and header.version in one blow. */
588 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
593 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
594 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
601 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
603 /* header->header.[ug]name are left as the empty string. */
607 uid_to_uname (st
->stat
.st_uid
, &st
->uname
);
608 gid_to_gname (st
->stat
.st_gid
, &st
->gname
);
610 if (archive_format
== POSIX_FORMAT
611 && strlen (st
->uname
) > UNAME_FIELD_SIZE
)
612 xheader_store ("uname", st
);
614 UNAME_TO_CHARS (st
->uname
, header
->header
.uname
);
616 if (archive_format
== POSIX_FORMAT
617 && strlen (st
->gname
) > GNAME_FIELD_SIZE
)
618 xheader_store ("gname", st
);
620 GNAME_TO_CHARS (st
->gname
, header
->header
.gname
);
626 /* Finish off a filled-in header block and write it out. We also
627 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
628 is not negative, is the block ordinal of the first record for this
629 file, which may be a preceding long name or long link record. */
631 finish_header (union block
*header
, off_t block_ordinal
)
637 /* Note: It is important to do this before the call to write_extended(),
638 so that the actual ustar header is printed */
640 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
641 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
642 && header
->header
.typeflag
!= XHDTYPE
643 && header
->header
.typeflag
!= XGLTYPE
)
645 /* These globals are parameters to print_header, sigh. */
647 current_header
= header
;
648 /* current_stat_info is already set up. */
649 current_format
= archive_format
;
650 print_header (block_ordinal
);
653 header
= write_extended (header
, XHDTYPE
);
655 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
659 for (i
= sizeof *header
; i
-- != 0; )
660 /* We can't use unsigned char here because of old compilers, e.g. V7. */
663 /* Fill in the checksum field. It's formatted differently from the
664 other fields: it has [6] digits, a null, then a space -- rather than
665 digits, then a null. We use to_chars.
666 The final space is already there, from
667 checksumming, and to_chars doesn't modify it.
669 This is a fast way to do:
671 sprintf(header->header.chksum, "%6o", sum); */
673 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
675 set_next_block_after (header
);
678 /* Sparse file processing. */
680 /* Takes a blockful of data and basically cruises through it to see if
681 it's made *entirely* of zeros, returning a 0 the instant it finds
682 something that is a nonzero, i.e., useful data. */
684 zero_block_p (char *buffer
)
688 for (counter
= 0; counter
< BLOCKSIZE
; counter
++)
689 if (buffer
[counter
] != '\0')
695 init_sparsearray (void)
698 sp_array_size
= SPARSES_IN_OLDGNU_HEADER
;
699 sparsearray
= xmalloc (sp_array_size
* sizeof *sparsearray
);
703 find_new_file_size (int sparses
)
707 for (i
= 0; i
< sparses
; i
++)
708 s
+= sparsearray
[i
].numbytes
;
712 /* Make one pass over the file NAME, studying where any non-zero data
713 is, that is, how far into the file each instance of data is, and
714 how many bytes are there. Save this information in the
715 sparsearray, which will later be translated into header
718 /* There is little point in trimming small amounts of null data at the head
719 and tail of blocks, only avoid dumping full null blocks. */
721 /* FIXME: this routine might accept bits of algorithmic cleanup, it is
722 too kludgey for my taste... */
725 deal_with_sparse (char *name
, union block
*header
)
732 char buffer
[BLOCKSIZE
];
734 if (archive_format
== OLDGNU_FORMAT
)
735 header
->oldgnu_header
.isextended
= 0;
737 if (file
= open (name
, O_RDONLY
), file
< 0)
738 /* This problem will be caught later on, so just return. */
742 clear_buffer (buffer
);
746 /* Realloc the scratch area as necessary. FIXME: should reallocate
747 only at beginning of a new instance of non-zero data. */
749 if (sp_array_size
<= sparses
)
752 xrealloc (sparsearray
,
753 2 * sp_array_size
* sizeof (struct sp_array
));
757 count
= safe_read (file
, buffer
, sizeof buffer
);
761 /* Process one block. */
763 if (count
== sizeof buffer
)
765 if (zero_block_p (buffer
))
769 sparsearray
[sparses
++].numbytes
= numbytes
;
776 sparsearray
[sparses
].offset
= offset
;
782 /* Since count < sizeof buffer, we have the last bit of the file. */
784 if (!zero_block_p (buffer
))
787 sparsearray
[sparses
].offset
= offset
;
791 /* The next two lines are suggested by Andreas Degert, who says
792 they are required for trailing full blocks to be written to the
793 archive, when all zeroed. Yet, it seems to me that the case
794 does not apply. Further, at restore time, the file is not as
795 sparse as it should. So, some serious cleanup is *also* needed
796 in this area. Just one more... :-(. FIXME. */
800 /* Prepare for next block. */
803 /* FIXME: do not clear unless necessary. */
804 clear_buffer (buffer
);
808 sparsearray
[sparses
++].numbytes
= numbytes
;
811 sparsearray
[sparses
].offset
= offset
- 1;
812 sparsearray
[sparses
++].numbytes
= 1;
815 return close (file
) == 0 && 0 <= count
? sparses
: 0;
819 finish_sparse_file (int file
, off_t
*sizeleft
, off_t fullsize
, char *name
)
826 while (*sizeleft
> 0)
828 start
= find_next_block ();
829 memset (start
->buffer
, 0, BLOCKSIZE
);
830 bufsize
= sparsearray
[sparses
].numbytes
;
834 if (lseek (file
, sparsearray
[sparses
++].offset
, SEEK_SET
) < 0)
836 (ignore_failed_read_option
? seek_warn_details
: seek_error_details
)
837 (name
, sparsearray
[sparses
- 1].offset
);
841 /* If the number of bytes to be written here exceeds the size of
842 the temporary buffer, do it in steps. */
844 while (bufsize
> BLOCKSIZE
)
846 count
= safe_read (file
, start
->buffer
, BLOCKSIZE
);
849 (ignore_failed_read_option
851 : read_error_details
)
852 (name
, fullsize
- *sizeleft
, bufsize
);
857 set_next_block_after (start
);
858 start
= find_next_block ();
859 memset (start
->buffer
, 0, BLOCKSIZE
);
863 char buffer
[BLOCKSIZE
];
865 clear_buffer (buffer
);
866 count
= safe_read (file
, buffer
, bufsize
);
867 memcpy (start
->buffer
, buffer
, BLOCKSIZE
);
872 (ignore_failed_read_option
874 : read_error_details
)
875 (name
, fullsize
- *sizeleft
, bufsize
);
880 set_next_block_after (start
);
884 set_next_block_after (start
+ (count
- 1) / BLOCKSIZE
);
889 /* Main functions of this module. */
892 create_archive (void)
896 open_archive (ACCESS_WRITE
);
898 if (incremental_option
)
900 size_t buffer_size
= 1000;
901 char *buffer
= xmalloc (buffer_size
);
904 collect_and_sort_names ();
906 while (p
= name_from_list (), p
)
907 if (!excluded_name (p
))
908 dump_file (p
, -1, (dev_t
) 0);
911 while (p
= name_from_list (), p
)
912 if (!excluded_name (p
))
914 size_t plen
= strlen (p
);
915 if (buffer_size
<= plen
)
917 while ((buffer_size
*= 2) <= plen
)
919 buffer
= xrealloc (buffer
, buffer_size
);
921 memcpy (buffer
, p
, plen
);
922 if (! ISSLASH (buffer
[plen
- 1]))
923 buffer
[plen
++] = '/';
924 q
= gnu_list_name
->dir_contents
;
928 size_t qlen
= strlen (q
);
931 if (buffer_size
< plen
+ qlen
)
933 while ((buffer_size
*=2 ) < plen
+ qlen
)
935 buffer
= xrealloc (buffer
, buffer_size
);
937 strcpy (buffer
+ plen
, q
+ 1);
938 dump_file (buffer
, -1, (dev_t
) 0);
947 while (p
= name_next (1), p
)
948 if (!excluded_name (p
))
949 dump_file (p
, 1, (dev_t
) 0);
955 if (listed_incremental_option
)
956 write_directory_file ();
960 /* Calculate the hash of a link. */
962 hash_link (void const *entry
, unsigned n_buckets
)
964 struct link
const *link
= entry
;
965 return (uintmax_t) (link
->dev
^ link
->ino
) % n_buckets
;
968 /* Compare two links for equality. */
970 compare_links (void const *entry1
, void const *entry2
)
972 struct link
const *link1
= entry1
;
973 struct link
const *link2
= entry2
;
974 return ((link1
->dev
^ link2
->dev
) | (link1
->ino
^ link2
->ino
)) == 0;
977 /* Table of all non-directories that we've written so far. Any time
978 we see another, we check the table and avoid dumping the data
979 again if we've done it once already. */
980 static Hash_table
*link_table
;
982 /* Dump a single file, recursing on directories. P is the file name
983 to dump. TOP_LEVEL tells whether this is a top-level call; zero
984 means no, positive means yes, and negative means the top level
985 of an incremental dump. PARENT_DEVICE is the device of P's
986 parent directory; it is examined only if TOP_LEVEL is zero.
988 Set global CURRENT_STAT_INFO to stat output for this file. */
990 /* FIXME: One should make sure that for *every* path leading to setting
991 exit_status to failure, a clear diagnostic has been issued. */
994 dump_file (char *p
, int top_level
, dev_t parent_device
)
1000 time_t original_ctime
;
1001 struct utimbuf restore_times
;
1002 off_t block_ordinal
= -1;
1004 /* FIXME: `header' might be used uninitialized in this
1005 function. Reported by Bruno Haible. */
1007 if (interactive_option
&& !confirm ("add", p
))
1010 if (deref_stat (dereference_option
, p
, ¤t_stat_info
.stat
) != 0)
1012 if (ignore_failed_read_option
)
1019 original_ctime
= current_stat_info
.stat
.st_ctime
;
1020 restore_times
.actime
= current_stat_info
.stat
.st_atime
;
1021 restore_times
.modtime
= current_stat_info
.stat
.st_mtime
;
1024 if (S_ISHIDDEN (current_stat_info
.stat
.st_mode
))
1026 char *new = (char *) alloca (strlen (p
) + 2);
1036 /* See if we want only new files, and check if this one is too old to
1037 put in the archive. */
1039 if ((0 < top_level
|| !incremental_option
)
1040 && !S_ISDIR (current_stat_info
.stat
.st_mode
)
1041 && current_stat_info
.stat
.st_mtime
< newer_mtime_option
1042 && (!after_date_option
|| current_stat_info
.stat
.st_ctime
< newer_ctime_option
))
1045 WARN ((0, 0, _("%s: file is unchanged; not dumped"),
1046 quotearg_colon (p
)));
1047 /* FIXME: recheck this return. */
1051 /* See if we are trying to dump the archive. */
1052 if (sys_file_is_archive (¤t_stat_info
))
1054 WARN ((0, 0, _("%s: file is the archive; not dumped"),
1055 quotearg_colon (p
)));
1059 if (S_ISDIR (current_stat_info
.stat
.st_mode
))
1067 dev_t our_device
= current_stat_info
.stat
.st_dev
;
1071 directory
= savedir (p
);
1074 if (ignore_failed_read_option
)
1081 /* Build new prototype name. Ensure exactly one trailing slash. */
1084 buflen
= len
+ NAME_FIELD_SIZE
;
1085 namebuf
= xmalloc (buflen
+ 1);
1086 memcpy (namebuf
, p
, len
);
1087 while (len
>= 1 && ISSLASH (namebuf
[len
- 1]))
1089 namebuf
[len
++] = '/';
1090 namebuf
[len
] = '\0';
1092 if (! is_avoided_name (namebuf
))
1094 /* The condition above used to be "archive_format != V7_FORMAT".
1095 GNU tar was not writing directory blocks at all. Daniel Trinkle
1096 writes: ``All old versions of tar I have ever seen have
1097 correctly archived an empty directory. The really old ones I
1098 checked included HP-UX 7 and Mt. Xinu More/BSD. There may be
1099 some subtle reason for the exclusion that I don't know, but the
1100 current behavior is broken.'' I do not know those subtle
1101 reasons either, so until these are reported (anew?), just allow
1102 directory blocks to be written even with old archives. */
1104 block_ordinal
= current_block_ordinal ();
1105 current_stat_info
.stat
.st_size
= 0; /* force 0 size on dir */
1107 /* FIXME: If people could really read standard archives, this
1111 = start_header (standard_option ? p : namebuf, ¤t_stat_info);
1113 but since they'd interpret DIRTYPE blocks as regular
1114 files, we'd better put the / on the name. */
1116 header
= start_header (namebuf
, ¤t_stat_info
);
1118 if (incremental_option
)
1119 header
->header
.typeflag
= GNUTYPE_DUMPDIR
;
1120 else /* if (standard_option) */
1121 header
->header
.typeflag
= DIRTYPE
;
1123 /* If we're gnudumping, we aren't done yet so don't close it. */
1125 if (!incremental_option
)
1126 finish_header (header
, block_ordinal
);
1129 if (incremental_option
&& gnu_list_name
->dir_contents
)
1136 const char *buffer
, *p_buffer
;
1138 buffer
= gnu_list_name
->dir_contents
; /* FOO */
1141 for (p_buffer
= buffer
; *p_buffer
; )
1143 size_t size
= strlen (p_buffer
) + 1;
1148 OFF_TO_CHARS (totsize
, header
->header
.size
);
1149 finish_header (header
, block_ordinal
);
1152 while (sizeleft
> 0)
1154 if (multi_volume_option
)
1156 assign_string (&save_name
, p
);
1157 save_sizeleft
= sizeleft
;
1158 save_totsize
= totsize
;
1160 start
= find_next_block ();
1161 bufsize
= available_space_after (start
);
1162 if (sizeleft
< bufsize
)
1165 count
= bufsize
% BLOCKSIZE
;
1167 memset (start
->buffer
+ sizeleft
, 0, BLOCKSIZE
- count
);
1169 memcpy (start
->buffer
, p_buffer
, bufsize
);
1170 sizeleft
-= bufsize
;
1171 p_buffer
+= bufsize
;
1172 set_next_block_after (start
+ (bufsize
- 1) / BLOCKSIZE
);
1174 if (multi_volume_option
)
1175 assign_string (&save_name
, 0);
1179 /* See if we are about to recurse into a directory, and avoid doing
1180 so if the user wants that we do not descend into directories. */
1182 if (! recursion_option
)
1185 /* See if we are crossing from one file system to another, and
1186 avoid doing so if the user only wants to dump one file system. */
1188 if (one_file_system_option
&& !top_level
1189 && parent_device
!= current_stat_info
.stat
.st_dev
)
1193 _("%s: file is on a different filesystem; not dumped"),
1194 quotearg_colon (p
)));
1198 /* Now output all the files in the directory. */
1200 /* FIXME: Should speed this up by cd-ing into the dir. */
1202 for (entry
= directory
;
1203 (entrylen
= strlen (entry
)) != 0;
1204 entry
+= entrylen
+ 1)
1206 if (buflen
< len
+ entrylen
)
1208 buflen
= len
+ entrylen
;
1209 namebuf
= xrealloc (namebuf
, buflen
+ 1);
1211 strcpy (namebuf
+ len
, entry
);
1212 if (!excluded_name (namebuf
))
1213 dump_file (namebuf
, 0, our_device
);
1220 if (atime_preserve_option
)
1221 utime (p
, &restore_times
);
1224 else if (is_avoided_name (p
))
1228 /* Check for multiple links. */
1230 if (1 < current_stat_info
.stat
.st_nlink
&& link_table
)
1234 lp
.ino
= current_stat_info
.stat
.st_ino
;
1235 lp
.dev
= current_stat_info
.stat
.st_dev
;
1237 if ((dup
= hash_lookup (link_table
, &lp
)))
1239 /* We found a link. */
1240 char const *link_name
= safer_name_suffix (dup
->name
, 1);
1244 block_ordinal
= current_block_ordinal ();
1245 assign_string (¤t_stat_info
.link_name
, link_name
);
1246 if (NAME_FIELD_SIZE
<= strlen (link_name
))
1247 write_long_link (¤t_stat_info
);
1249 current_stat_info
.stat
.st_size
= 0;
1250 header
= start_header (p
, ¤t_stat_info
);
1251 strncpy (header
->header
.linkname
, link_name
, NAME_FIELD_SIZE
);
1253 /* Force null termination. */
1254 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = 0;
1256 header
->header
.typeflag
= LNKTYPE
;
1257 finish_header (header
, block_ordinal
);
1259 /* FIXME: Maybe remove from table after all links found? */
1261 if (remove_files_option
&& unlink (p
) != 0)
1264 /* We dumped it, and we don't need to put it in the
1270 /* This is not a link to a previously dumped file, so dump it. */
1272 if (S_ISREG (current_stat_info
.stat
.st_mode
)
1273 || S_ISCTG (current_stat_info
.stat
.st_mode
))
1275 int f
; /* file descriptor */
1281 char isextended
= 0;
1288 /* Check the size of the file against the number of blocks
1289 allocated for it, counting both data and indirect blocks.
1290 If there is a smaller number of blocks than would be
1291 necessary to accommodate a file of this size, this is safe
1292 to say that we have a sparse file: at least one of those
1293 blocks in the file is just a useless hole. For sparse
1294 files not having more hole blocks than indirect blocks, the
1295 sparseness will go undetected. */
1297 /* Bruno Haible sent me these statistics for Linux. It seems
1298 that some filesystems count indirect blocks in st_blocks,
1299 while others do not seem to:
1301 minix-fs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1302 extfs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1303 ext2fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1304 msdos-fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1306 Dick Streefland reports the previous numbers as misleading,
1307 because ext2fs use 12 direct blocks, while minix-fs uses only
1308 6 direct blocks. Dick gets:
1310 ext2 size=20480 ls listed blocks=21
1311 minix size=20480 ls listed blocks=21
1312 msdos size=20480 ls listed blocks=20
1314 It seems that indirect blocks *are* included in st_blocks.
1315 The minix filesystem does not account for phantom blocks in
1316 st_blocks, so `du' and `ls -s' give wrong results. So, the
1317 --sparse option would not work on a minix filesystem. */
1319 if (ST_NBLOCKS (current_stat_info
.stat
)
1320 < (current_stat_info
.stat
.st_size
/ ST_NBLOCKSIZE
1321 + (current_stat_info
.stat
.st_size
% ST_NBLOCKSIZE
!= 0)))
1325 block_ordinal
= current_block_ordinal ();
1326 header
= start_header (p
, ¤t_stat_info
);
1327 header
->header
.typeflag
= GNUTYPE_SPARSE
;
1330 /* Call the routine that figures out the layout of the
1331 sparse file in question. SPARSES is the index of the
1332 first unused element of the "sparsearray," i.e.,
1333 the number of elements it needed to describe the file. */
1335 sparses
= deal_with_sparse (p
, header
);
1337 /* See if we'll need an extended header later. */
1339 if (SPARSES_IN_OLDGNU_HEADER
< sparses
)
1340 header
->oldgnu_header
.isextended
= 1;
1342 /* We store the "real" file size so we can show that in
1343 case someone wants to list the archive, i.e., tar tvf
1344 <file>. It might be kind of disconcerting if the
1345 shrunken file size was the one that showed up. */
1347 OFF_TO_CHARS (current_stat_info
.stat
.st_size
,
1348 header
->oldgnu_header
.realsize
);
1350 /* This will be the new "size" of the file, i.e., the size
1351 of the file minus the blocks of holes that we're
1354 current_stat_info
.stat
.st_size
= find_new_file_size (sparses
);
1355 OFF_TO_CHARS (current_stat_info
.stat
.st_size
, header
->header
.size
);
1358 counter
< sparses
&& counter
< SPARSES_IN_OLDGNU_HEADER
;
1361 OFF_TO_CHARS (sparsearray
[counter
].offset
,
1362 header
->oldgnu_header
.sp
[counter
].offset
);
1363 SIZE_TO_CHARS (sparsearray
[counter
].numbytes
,
1364 header
->oldgnu_header
.sp
[counter
].numbytes
);
1369 sizeleft
= current_stat_info
.stat
.st_size
;
1371 /* Don't bother opening empty, world readable files. Also do not open
1372 files when archive is meant for /dev/null. */
1376 && MODE_R
== (MODE_R
& current_stat_info
.stat
.st_mode
)))
1380 f
= open (p
, O_RDONLY
| O_BINARY
);
1383 if (! top_level
&& errno
== ENOENT
)
1384 WARN ((0, 0, _("%s: File removed before we read it"),
1385 quotearg_colon (p
)));
1387 (ignore_failed_read_option
? open_warn
: open_error
) (p
);
1392 /* If the file is sparse, we've already taken care of this. */
1396 block_ordinal
= current_block_ordinal ();
1397 header
= start_header (p
, ¤t_stat_info
);
1400 /* Mark contiguous files, if we support them. */
1402 if (archive_format
!= V7_FORMAT
&& S_ISCTG (current_stat_info
.stat
.st_mode
))
1403 header
->header
.typeflag
= CONTTYPE
;
1405 isextended
= header
->oldgnu_header
.isextended
;
1406 save_typeflag
= header
->header
.typeflag
;
1407 finish_header (header
, block_ordinal
);
1410 int sparses_emitted
= SPARSES_IN_OLDGNU_HEADER
;
1415 exhdr
= find_next_block ();
1416 memset (exhdr
->buffer
, 0, BLOCKSIZE
);
1418 (i
< SPARSES_IN_SPARSE_HEADER
1419 && sparses_emitted
+ i
< sparses
);
1422 SIZE_TO_CHARS (sparsearray
[sparses_emitted
+ i
].numbytes
,
1423 exhdr
->sparse_header
.sp
[i
].numbytes
);
1424 OFF_TO_CHARS (sparsearray
[sparses_emitted
+ i
].offset
,
1425 exhdr
->sparse_header
.sp
[i
].offset
);
1427 set_next_block_after (exhdr
);
1428 sparses_emitted
+= i
;
1429 if (sparses
== sparses_emitted
)
1431 exhdr
->sparse_header
.isextended
= 1;
1434 if (save_typeflag
== GNUTYPE_SPARSE
)
1437 || finish_sparse_file (f
, &sizeleft
,
1438 current_stat_info
.stat
.st_size
, p
))
1442 while (sizeleft
> 0)
1444 if (multi_volume_option
)
1446 assign_string (&save_name
, p
);
1447 save_sizeleft
= sizeleft
;
1448 save_totsize
= current_stat_info
.stat
.st_size
;
1450 start
= find_next_block ();
1452 bufsize
= available_space_after (start
);
1454 if (sizeleft
< bufsize
)
1456 /* Last read -- zero out area beyond. */
1459 count
= bufsize
% BLOCKSIZE
;
1461 memset (start
->buffer
+ sizeleft
, 0, BLOCKSIZE
- count
);
1466 count
= safe_read (f
, start
->buffer
, bufsize
);
1469 (ignore_failed_read_option
1471 : read_error_details
)
1472 (p
, current_stat_info
.stat
.st_size
- sizeleft
, bufsize
);
1477 /* This is nonportable (the type of set_next_block_after's arg). */
1479 set_next_block_after (start
+ (bufsize
- 1) / BLOCKSIZE
);
1482 if (count
!= bufsize
)
1484 char buf
[UINTMAX_STRSIZE_BOUND
];
1485 memset (start
->buffer
+ count
, 0, bufsize
- count
);
1487 ngettext ("%s: File shrank by %s byte; padding with zeros",
1488 "%s: File shrank by %s bytes; padding with zeros",
1491 STRINGIFY_BIGINT (sizeleft
, buf
)));
1492 if (! ignore_failed_read_option
)
1493 exit_status
= TAREXIT_FAILURE
;
1494 goto padit
; /* short read */
1498 if (multi_volume_option
)
1499 assign_string (&save_name
, 0);
1503 struct stat final_stat
;
1504 if (fstat (f
, &final_stat
) != 0)
1506 if (ignore_failed_read_option
)
1511 else if (final_stat
.st_ctime
!= original_ctime
)
1513 char const *qp
= quotearg_colon (p
);
1514 WARN ((0, 0, _("%s: file changed as we read it"), qp
));
1518 if (ignore_failed_read_option
)
1523 if (atime_preserve_option
)
1524 utime (p
, &restore_times
);
1526 if (remove_files_option
)
1528 if (unlink (p
) == -1)
1531 goto file_was_dumped
;
1533 /* File shrunk or gave error, pad out tape to match the size we
1534 specified in the header. */
1537 while (sizeleft
> 0)
1539 save_sizeleft
= sizeleft
;
1540 start
= find_next_block ();
1541 memset (start
->buffer
, 0, BLOCKSIZE
);
1542 set_next_block_after (start
);
1543 sizeleft
-= BLOCKSIZE
;
1545 if (multi_volume_option
)
1546 assign_string (&save_name
, 0);
1550 if (atime_preserve_option
)
1551 utime (p
, &restore_times
);
1553 goto file_was_dumped
;
1555 #ifdef HAVE_READLINK
1556 else if (S_ISLNK (current_stat_info
.stat
.st_mode
))
1560 size_t linklen
= current_stat_info
.stat
.st_size
;
1561 if (linklen
!= current_stat_info
.stat
.st_size
|| linklen
+ 1 == 0)
1563 buffer
= (char *) alloca (linklen
+ 1);
1564 size
= readlink (p
, buffer
, linklen
+ 1);
1567 if (ignore_failed_read_option
)
1573 buffer
[size
] = '\0';
1574 assign_string (¤t_stat_info
.link_name
, buffer
);
1575 if (size
>= NAME_FIELD_SIZE
)
1576 write_long_link (¤t_stat_info
);
1578 block_ordinal
= current_block_ordinal ();
1579 current_stat_info
.stat
.st_size
= 0; /* force 0 size on symlink */
1580 header
= start_header (p
, ¤t_stat_info
);
1581 strncpy (header
->header
.linkname
, buffer
, NAME_FIELD_SIZE
);
1582 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = '\0';
1583 header
->header
.typeflag
= SYMTYPE
;
1584 finish_header (header
, block_ordinal
);
1585 /* nothing more to do to it */
1587 if (remove_files_option
)
1589 if (unlink (p
) == -1)
1592 goto file_was_dumped
;
1595 else if (S_ISCHR (current_stat_info
.stat
.st_mode
))
1597 else if (S_ISBLK (current_stat_info
.stat
.st_mode
))
1599 else if (S_ISFIFO (current_stat_info
.stat
.st_mode
))
1601 else if (S_ISSOCK (current_stat_info
.stat
.st_mode
))
1603 WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1606 else if (S_ISDOOR (current_stat_info
.stat
.st_mode
))
1608 WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1615 if (archive_format
== V7_FORMAT
)
1618 block_ordinal
= current_block_ordinal ();
1619 current_stat_info
.stat
.st_size
= 0; /* force 0 size */
1620 header
= start_header (p
, ¤t_stat_info
);
1621 header
->header
.typeflag
= type
;
1623 if (type
!= FIFOTYPE
)
1625 MAJOR_TO_CHARS (major (current_stat_info
.stat
.st_rdev
), header
->header
.devmajor
);
1626 MINOR_TO_CHARS (minor (current_stat_info
.stat
.st_rdev
), header
->header
.devminor
);
1629 finish_header (header
, block_ordinal
);
1630 if (remove_files_option
)
1632 if (unlink (p
) == -1)
1635 goto file_was_dumped
;
1638 WARN ((0, 0, _("%s: Unknown file type; file ignored"),
1639 quotearg_colon (p
)));
1640 if (! ignore_failed_read_option
)
1641 exit_status
= TAREXIT_FAILURE
;
1645 if (1 < current_stat_info
.stat
.st_nlink
)
1648 struct link
*lp
= xmalloc (offsetof (struct link
, name
)
1650 lp
->ino
= current_stat_info
.stat
.st_ino
;
1651 lp
->dev
= current_stat_info
.stat
.st_dev
;
1652 lp
->nlink
= current_stat_info
.stat
.st_nlink
;
1653 strcpy (lp
->name
, p
);
1656 || (link_table
= hash_initialize (0, 0, hash_link
,
1658 && (dup
= hash_insert (link_table
, lp
))))
1668 /* For each dumped file, check if all its links were dumped. Emit
1669 warnings if it is not so. */
1678 for (lp
= hash_get_first (link_table
); lp
;
1679 lp
= hash_get_next (link_table
, lp
))
1683 WARN ((0, 0, _("Missing links to '%s'.\n"), lp
->name
));