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 /* FIXME: This is the only place where GNU_FORMAT differs from
190 OLDGNU_FORMAT. Apart from this they are completely identical. */
191 uintmax_t s
= (negsub
&= archive_format
== GNU_FORMAT
) ? - sub
: sub
;
192 char subbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
193 char *sub_string
= STRINGIFY_BIGINT (s
, subbuf
+ 1);
196 WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
197 value_string
, type
, minval_string
, maxval_string
,
199 to_chars (negsub
, s
, valsize
, 0, where
, size
, type
);
202 ERROR ((0, 0, _("value %s out of %s range %s..%s"),
203 value_string
, type
, minval_string
, maxval_string
));
208 gid_substitute (int *negative
)
214 static gid_t gid_nobody
;
215 if (!gid_nobody
&& !gname_to_gid ("nobody", &gid_nobody
))
224 gid_to_chars (gid_t v
, char *p
, size_t s
)
226 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, gid_substitute
, p
, s
, "gid_t");
230 major_to_chars (major_t v
, char *p
, size_t s
)
232 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "major_t");
236 minor_to_chars (minor_t v
, char *p
, size_t s
)
238 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "minor_t");
242 mode_to_chars (mode_t v
, char *p
, size_t s
)
244 /* In the common case where the internal and external mode bits are the same,
245 and we are not using POSIX or GNU format,
246 propagate all unknown bits to the external mode.
247 This matches historical practice.
248 Otherwise, just copy the bits we know about. */
251 if (S_ISUID
== TSUID
&& S_ISGID
== TSGID
&& S_ISVTX
== TSVTX
252 && S_IRUSR
== TUREAD
&& S_IWUSR
== TUWRITE
&& S_IXUSR
== TUEXEC
253 && S_IRGRP
== TGREAD
&& S_IWGRP
== TGWRITE
&& S_IXGRP
== TGEXEC
254 && S_IROTH
== TOREAD
&& S_IWOTH
== TOWRITE
&& S_IXOTH
== TOEXEC
255 && archive_format
!= POSIX_FORMAT
256 && archive_format
!= USTAR_FORMAT
257 && archive_format
!= GNU_FORMAT
)
265 u
= ((v
& S_ISUID
? TSUID
: 0)
266 | (v
& S_ISGID
? TSGID
: 0)
267 | (v
& S_ISVTX
? TSVTX
: 0)
268 | (v
& S_IRUSR
? TUREAD
: 0)
269 | (v
& S_IWUSR
? TUWRITE
: 0)
270 | (v
& S_IXUSR
? TUEXEC
: 0)
271 | (v
& S_IRGRP
? TGREAD
: 0)
272 | (v
& S_IWGRP
? TGWRITE
: 0)
273 | (v
& S_IXGRP
? TGEXEC
: 0)
274 | (v
& S_IROTH
? TOREAD
: 0)
275 | (v
& S_IWOTH
? TOWRITE
: 0)
276 | (v
& S_IXOTH
? TOEXEC
: 0));
278 to_chars (negative
, u
, sizeof v
, 0, p
, s
, "mode_t");
282 off_to_chars (off_t v
, char *p
, size_t s
)
284 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "off_t");
288 size_to_chars (size_t v
, char *p
, size_t s
)
290 to_chars (0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "size_t");
294 time_to_chars (time_t v
, char *p
, size_t s
)
296 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "time_t");
300 uid_substitute (int *negative
)
306 static uid_t uid_nobody
;
307 if (!uid_nobody
&& !uname_to_uid ("nobody", &uid_nobody
))
316 uid_to_chars (uid_t v
, char *p
, size_t s
)
318 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, uid_substitute
, p
, s
, "uid_t");
322 uintmax_to_chars (uintmax_t v
, char *p
, size_t s
)
324 to_chars (0, v
, sizeof v
, 0, p
, s
, "uintmax_t");
328 string_to_chars (char *str
, char *p
, size_t s
)
335 /* A file is not dumpable if
336 a) it is empty *and* world-readable, or
337 b) current archive is /dev/null */
340 file_dumpable_p (struct tar_stat_info
*stat
)
342 return !(dev_null_output
343 || (stat
->archive_file_size
== 0
344 && (stat
->stat
.st_mode
& MODE_R
) == MODE_R
));
348 /* Writing routines. */
350 /* Write the EOT block(s). Zero at least two blocks, through the end
351 of the record. Old tar, as previous versions of GNU tar, writes
352 garbage after two zeroed blocks. */
356 union block
*pointer
= find_next_block ();
357 memset (pointer
->buffer
, 0, BLOCKSIZE
);
358 set_next_block_after (pointer
);
359 pointer
= find_next_block ();
360 memset (pointer
->buffer
, 0, available_space_after (pointer
));
361 set_next_block_after (pointer
);
364 /* Copy at most LEN bytes from SRC to DST. Terminate with NUL unless
365 SRC is LEN characters long */
367 tar_copy_str (char *dst
, const char *src
, size_t len
)
370 strncpy (dst
, src
, len
);
373 /* Write a "private" header */
375 start_private_header (const char *name
, size_t size
)
378 union block
*header
= find_next_block ();
380 memset (header
->buffer
, 0, sizeof (union block
));
382 tar_copy_str (header
->header
.name
, name
, NAME_FIELD_SIZE
);
383 OFF_TO_CHARS (size
, header
->header
.size
);
386 TIME_TO_CHARS (t
, header
->header
.mtime
);
387 MODE_TO_CHARS (S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
, header
->header
.mode
);
388 UID_TO_CHARS (getuid (), header
->header
.uid
);
389 GID_TO_CHARS (getgid (), header
->header
.gid
);
390 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
391 MAJOR_TO_CHARS (0, header
->header
.devminor
);
392 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
393 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
397 /* Create a new header and store there at most NAME_FIELD_SIZE bytes of
401 write_short_name (struct tar_stat_info
*st
)
403 union block
*header
= find_next_block ();
404 memset (header
->buffer
, 0, sizeof (union block
));
405 tar_copy_str (header
->header
.name
, st
->file_name
, NAME_FIELD_SIZE
);
409 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. */
411 write_gnu_long_link (struct tar_stat_info
*st
, const char *p
, char type
)
413 size_t size
= strlen (p
) + 1;
417 header
= start_private_header ("././@LongLink", size
);
418 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
419 header
->header
.typeflag
= type
;
420 finish_header (st
, header
, -1);
422 header
= find_next_block ();
424 bufsize
= available_space_after (header
);
426 while (bufsize
< size
)
428 memcpy (header
->buffer
, p
, bufsize
);
431 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
432 header
= find_next_block ();
433 bufsize
= available_space_after (header
);
435 memcpy (header
->buffer
, p
, size
);
436 memset (header
->buffer
+ size
, 0, bufsize
- size
);
437 set_next_block_after (header
+ (size
- 1) / BLOCKSIZE
);
441 split_long_name (const char *name
, size_t length
)
445 if (length
> PREFIX_FIELD_SIZE
)
446 length
= PREFIX_FIELD_SIZE
+2;
447 for (i
= length
- 1; i
> 0; i
--)
448 if (ISSLASH (name
[i
]))
454 write_ustar_long_name (const char *name
)
456 size_t length
= strlen (name
);
460 if (length
> PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1)
462 WARN ((0, 0, _("%s: file name is too long (max %d); not dumped"),
463 quotearg_colon (name
),
464 PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1));
468 i
= split_long_name (name
, length
);
469 if (i
== 0 || length
- i
- 1 > NAME_FIELD_SIZE
)
472 _("%s: file name is too long (cannot be split); not dumped"),
473 quotearg_colon (name
)));
477 header
= find_next_block ();
478 memset (header
->buffer
, 0, sizeof (header
->buffer
));
479 memcpy (header
->header
.prefix
, name
, i
);
480 memcpy (header
->header
.name
, name
+ i
+ 1, length
- i
- 1);
485 /* Write a long link name, depending on the current archive format */
487 write_long_link (struct tar_stat_info
*st
)
489 switch (archive_format
)
492 xheader_store ("linkpath", st
, NULL
);
495 case V7_FORMAT
: /* old V7 tar format */
499 _("%s: link name is too long; not dumped"),
500 quotearg_colon (st
->link_name
)));
505 write_gnu_long_link (st
, st
->link_name
, GNUTYPE_LONGLINK
);
514 write_long_name (struct tar_stat_info
*st
)
516 switch (archive_format
)
519 xheader_store ("path", st
, NULL
);
525 return write_ustar_long_name (st
->file_name
);
529 write_gnu_long_link (st
, st
->file_name
, GNUTYPE_LONGNAME
);
535 return write_short_name (st
);
539 write_extended (struct tar_stat_info
*st
, union block
*old_header
, char type
)
541 union block
*header
, hp
;
545 if (extended_header
.buffer
|| extended_header
.stk
== NULL
)
548 xheader_finish (&extended_header
);
549 size
= extended_header
.size
;
551 memcpy (hp
.buffer
, old_header
, sizeof (hp
));
553 header
= start_private_header (p
= xheader_xhdr_name (st
), size
);
555 header
->header
.typeflag
= type
;
557 finish_header (st
, header
, -1);
559 p
= extended_header
.buffer
;
565 header
= find_next_block ();
569 memcpy (header
->buffer
, p
, len
);
571 memset (header
->buffer
+ len
, 0, BLOCKSIZE
- len
);
574 set_next_block_after (header
);
578 xheader_destroy (&extended_header
);
579 header
= find_next_block ();
580 memcpy (header
, &hp
.buffer
, sizeof (hp
.buffer
));
585 write_header_name (struct tar_stat_info
*st
)
587 if (NAME_FIELD_SIZE
< strlen (st
->file_name
))
588 return write_long_name (st
);
590 return write_short_name (st
);
594 /* Header handling. */
596 /* Make a header block for the file whose stat info is st,
597 and return its address. */
600 start_header (struct tar_stat_info
*st
)
604 header
= write_header_name (st
);
608 /* Override some stat fields, if requested to do so. */
610 if (owner_option
!= (uid_t
) -1)
611 st
->stat
.st_uid
= owner_option
;
612 if (group_option
!= (gid_t
) -1)
613 st
->stat
.st_gid
= group_option
;
615 st
->stat
.st_mode
= ((st
->stat
.st_mode
& ~MODE_ALL
)
616 | mode_adjust (st
->stat
.st_mode
, mode_option
));
618 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
619 for a few tars and came up with the following interoperability
623 1 2 3 4 5 6 7 8 9 READER
624 . . . . . . . . . 1 = SunOS 4.2 tar
625 # . . # # . . # # 2 = NEC SVR4.0.2 tar
626 . . . # # . . # . 3 = Solaris 2.1 tar
627 . . . . . . . . . 4 = GNU tar 1.11.1
628 . . . . . . . . . 5 = HP-UX 8.07 tar
629 . . . . . . . . . 6 = Ultrix 4.1
630 . . . . . . . . . 7 = AIX 3.2
631 . . . . . . . . . 8 = Hitachi HI-UX 1.03
632 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
635 # = ``impossible file type''
637 The following mask for old archive removes the `#'s in column 4
638 above, thus making GNU tar both a universal donor and a universal
639 acceptor for Paul's test. */
641 if (archive_format
== V7_FORMAT
|| archive_format
== USTAR_FORMAT
)
642 MODE_TO_CHARS (st
->stat
.st_mode
& MODE_ALL
, header
->header
.mode
);
644 MODE_TO_CHARS (st
->stat
.st_mode
, header
->header
.mode
);
646 if (st
->stat
.st_uid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
647 xheader_store ("uid", st
, NULL
);
649 UID_TO_CHARS (st
->stat
.st_uid
, header
->header
.uid
);
651 if (st
->stat
.st_gid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
652 xheader_store ("gid", st
, NULL
);
654 GID_TO_CHARS (st
->stat
.st_gid
, header
->header
.gid
);
656 if (st
->stat
.st_size
> MAXOCTAL11
&& archive_format
== POSIX_FORMAT
)
657 xheader_store ("size", st
, NULL
);
659 OFF_TO_CHARS (st
->stat
.st_size
, header
->header
.size
);
661 TIME_TO_CHARS (st
->stat
.st_mtime
, header
->header
.mtime
);
664 if (S_ISCHR (st
->stat
.st_mode
)
665 || S_ISBLK (st
->stat
.st_mode
))
667 st
->devmajor
= major (st
->stat
.st_rdev
);
668 st
->devminor
= minor (st
->stat
.st_rdev
);
670 if (st
->devmajor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
671 xheader_store ("devmajor", st
, NULL
);
673 MAJOR_TO_CHARS (st
->devmajor
, header
->header
.devmajor
);
675 if (st
->devminor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
676 xheader_store ("devminor", st
, NULL
);
678 MAJOR_TO_CHARS (st
->devminor
, header
->header
.devminor
);
682 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
683 MINOR_TO_CHARS (0, header
->header
.devminor
);
686 if (archive_format
== POSIX_FORMAT
)
688 xheader_store ("atime", st
, NULL
);
689 xheader_store ("ctime", st
, NULL
);
691 else if (incremental_option
)
692 if (archive_format
== OLDGNU_FORMAT
)
694 TIME_TO_CHARS (st
->stat
.st_atime
, header
->oldgnu_header
.atime
);
695 TIME_TO_CHARS (st
->stat
.st_ctime
, header
->oldgnu_header
.ctime
);
698 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
700 switch (archive_format
)
706 case GNU_FORMAT
: /*FIXME?*/
707 /* Overwrite header->header.magic and header.version in one blow. */
708 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
713 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
714 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
721 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
723 /* header->header.[ug]name are left as the empty string. */
727 uid_to_uname (st
->stat
.st_uid
, &st
->uname
);
728 gid_to_gname (st
->stat
.st_gid
, &st
->gname
);
730 if (archive_format
== POSIX_FORMAT
731 && strlen (st
->uname
) > UNAME_FIELD_SIZE
)
732 xheader_store ("uname", st
, NULL
);
734 UNAME_TO_CHARS (st
->uname
, header
->header
.uname
);
736 if (archive_format
== POSIX_FORMAT
737 && strlen (st
->gname
) > GNAME_FIELD_SIZE
)
738 xheader_store ("gname", st
, NULL
);
740 GNAME_TO_CHARS (st
->gname
, header
->header
.gname
);
746 /* Finish off a filled-in header block and write it out. We also
747 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
748 is not negative, is the block ordinal of the first record for this
749 file, which may be a preceding long name or long link record. */
751 finish_header (struct tar_stat_info
*st
,
752 union block
*header
, off_t block_ordinal
)
758 /* Note: It is important to do this before the call to write_extended(),
759 so that the actual ustar header is printed */
761 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
762 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
763 && header
->header
.typeflag
!= XHDTYPE
764 && header
->header
.typeflag
!= XGLTYPE
)
766 /* These globals are parameters to print_header, sigh. */
768 current_header
= header
;
769 current_format
= archive_format
;
770 print_header (st
, block_ordinal
);
773 header
= write_extended (st
, header
, XHDTYPE
);
775 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
779 for (i
= sizeof *header
; i
-- != 0; )
780 /* We can't use unsigned char here because of old compilers, e.g. V7. */
783 /* Fill in the checksum field. It's formatted differently from the
784 other fields: it has [6] digits, a null, then a space -- rather than
785 digits, then a null. We use to_chars.
786 The final space is already there, from
787 checksumming, and to_chars doesn't modify it.
789 This is a fast way to do:
791 sprintf(header->header.chksum, "%6o", sum); */
793 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
795 set_next_block_after (header
);
800 pad_archive (off_t size_left
)
803 while (size_left
> 0)
805 save_sizeleft
= size_left
;
806 blk
= find_next_block ();
807 memset (blk
->buffer
, 0, BLOCKSIZE
);
808 set_next_block_after (blk
);
809 size_left
-= BLOCKSIZE
;
813 static enum dump_status
814 dump_regular_file (int fd
, struct tar_stat_info
*stat
)
816 off_t size_left
= stat
->stat
.st_size
;
820 block_ordinal
= current_block_ordinal ();
821 blk
= start_header (stat
);
823 return dump_status_fail
;
825 /* Mark contiguous files, if we support them. */
826 if (archive_format
!= V7_FORMAT
&& S_ISCTG (stat
->stat
.st_mode
))
827 blk
->header
.typeflag
= CONTTYPE
;
829 finish_header (stat
, blk
, block_ordinal
);
831 while (size_left
> 0)
833 size_t bufsize
, count
;
835 if (multi_volume_option
)
837 assign_string (&save_name
, stat
->file_name
);
838 save_sizeleft
= size_left
;
839 save_totsize
= stat
->stat
.st_size
;
841 blk
= find_next_block ();
843 bufsize
= available_space_after (blk
);
845 if (size_left
< bufsize
)
847 /* Last read -- zero out area beyond. */
849 count
= bufsize
% BLOCKSIZE
;
851 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
854 count
= (fd
< 0) ? bufsize
: safe_read (fd
, blk
->buffer
, bufsize
);
857 read_diag_details (stat
->orig_file_name
,
858 stat
->stat
.st_size
- size_left
, bufsize
);
859 pad_archive (size_left
);
860 return dump_status_short
;
864 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
866 if (count
!= bufsize
)
868 char buf
[UINTMAX_STRSIZE_BOUND
];
869 memset (blk
->buffer
+ count
, 0, bufsize
- count
);
871 ngettext ("%s: File shrank by %s byte; padding with zeros",
872 "%s: File shrank by %s bytes; padding with zeros",
874 quotearg_colon (stat
->orig_file_name
),
875 STRINGIFY_BIGINT (size_left
, buf
)));
876 if (! ignore_failed_read_option
)
877 exit_status
= TAREXIT_FAILURE
;
878 pad_archive (size_left
);
879 return dump_status_short
;
882 return dump_status_ok
;
886 dump_regular_finish (int fd
, struct tar_stat_info
*st
, time_t original_ctime
)
890 struct stat final_stat
;
891 if (fstat (fd
, &final_stat
) != 0)
893 stat_diag (st
->orig_file_name
);
895 else if (final_stat
.st_ctime
!= original_ctime
)
897 WARN ((0, 0, _("%s: file changed as we read it"),
898 quotearg_colon (st
->orig_file_name
)));
902 close_diag (st
->orig_file_name
);
905 if (remove_files_option
)
907 if (unlink (st
->orig_file_name
) == -1)
908 unlink_error (st
->orig_file_name
);
913 dump_dir0 (char *directory
,
914 struct tar_stat_info
*stat
, int top_level
, dev_t parent_device
)
916 dev_t our_device
= stat
->stat
.st_dev
;
918 if (!is_avoided_name (stat
->orig_file_name
))
920 union block
*blk
= NULL
;
921 off_t block_ordinal
= current_block_ordinal ();
922 stat
->stat
.st_size
= 0; /* force 0 size on dir */
924 blk
= start_header (stat
);
928 if (incremental_option
)
929 blk
->header
.typeflag
= GNUTYPE_DUMPDIR
;
930 else /* if (standard_option) */
931 blk
->header
.typeflag
= DIRTYPE
;
933 /* If we're gnudumping, we aren't done yet so don't close it. */
935 if (!incremental_option
)
936 finish_header (stat
, blk
, block_ordinal
);
937 else if (gnu_list_name
->dir_contents
)
943 const char *buffer
, *p_buffer
;
944 off_t block_ordinal
= current_block_ordinal ();
946 buffer
= gnu_list_name
->dir_contents
; /* FOO */
949 for (p_buffer
= buffer
; *p_buffer
; )
951 size_t size
= strlen (p_buffer
) + 1;
956 OFF_TO_CHARS (totsize
, blk
->header
.size
);
957 finish_header (stat
, blk
, block_ordinal
);
960 while (size_left
> 0)
962 if (multi_volume_option
)
964 assign_string (&save_name
, stat
->orig_file_name
);
965 save_sizeleft
= size_left
;
966 save_totsize
= totsize
;
968 blk
= find_next_block ();
969 bufsize
= available_space_after (blk
);
970 if (size_left
< bufsize
)
973 count
= bufsize
% BLOCKSIZE
;
975 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
977 memcpy (blk
->buffer
, p_buffer
, bufsize
);
978 size_left
-= bufsize
;
980 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
982 if (multi_volume_option
)
983 assign_string (&save_name
, 0);
988 if (!recursion_option
)
991 if (one_file_system_option
993 && parent_device
!= stat
->stat
.st_dev
)
997 _("%s: file is on a different filesystem; not dumped"),
998 quotearg_colon (stat
->orig_file_name
)));
1005 char *name_buf
= strdup (stat
->orig_file_name
);
1006 size_t name_size
= strlen (name_buf
);
1007 size_t name_len
= name_size
;
1009 /* Now output all the files in the directory. */
1010 /* FIXME: Should speed this up by cd-ing into the dir. */
1012 for (entry
= directory
; (entry_len
= strlen (entry
)) != 0;
1013 entry
+= entry_len
+ 1)
1015 if (name_size
< name_len
+ entry_len
)
1017 name_size
= name_len
+ entry_len
;
1018 name_buf
= xrealloc (name_buf
, name_size
+ 1);
1020 strcpy (name_buf
+ name_len
, entry
);
1021 if (!excluded_name (name_buf
))
1022 dump_file (name_buf
, 0, our_device
);
1029 /* Ensure exactly one trailing slash. */
1031 ensure_slash (char **pstr
)
1033 size_t len
= strlen (*pstr
);
1034 while (len
>= 1 && ISSLASH ((*pstr
)[len
- 1]))
1036 if (!ISSLASH ((*pstr
)[len
]))
1037 *pstr
= xrealloc (*pstr
, len
+ 2);
1038 (*pstr
)[len
++] = '/';
1039 (*pstr
)[len
] = '\0';
1043 dump_dir (struct tar_stat_info
*stat
, int top_level
, dev_t parent_device
)
1047 directory
= savedir (stat
->orig_file_name
);
1050 savedir_diag (stat
->orig_file_name
);
1054 ensure_slash (&stat
->orig_file_name
);
1055 ensure_slash (&stat
->file_name
);
1057 dump_dir0 (directory
, stat
, top_level
, parent_device
);
1064 /* Main functions of this module. */
1067 create_archive (void)
1071 open_archive (ACCESS_WRITE
);
1073 if (incremental_option
)
1075 size_t buffer_size
= 1000;
1076 char *buffer
= xmalloc (buffer_size
);
1079 collect_and_sort_names ();
1081 while ((p
= name_from_list ()) != NULL
)
1082 if (!excluded_name (p
))
1083 dump_file (p
, -1, (dev_t
) 0);
1086 while ((p
= name_from_list ()) != NULL
)
1087 if (!excluded_name (p
))
1089 size_t plen
= strlen (p
);
1090 if (buffer_size
<= plen
)
1092 while ((buffer_size
*= 2) <= plen
)
1094 buffer
= xrealloc (buffer
, buffer_size
);
1096 memcpy (buffer
, p
, plen
);
1097 if (! ISSLASH (buffer
[plen
- 1]))
1098 buffer
[plen
++] = '/';
1099 q
= gnu_list_name
->dir_contents
;
1103 size_t qlen
= strlen (q
);
1106 if (buffer_size
< plen
+ qlen
)
1108 while ((buffer_size
*=2 ) < plen
+ qlen
)
1110 buffer
= xrealloc (buffer
, buffer_size
);
1112 strcpy (buffer
+ plen
, q
+ 1);
1113 dump_file (buffer
, -1, (dev_t
) 0);
1122 while ((p
= name_next (1)) != NULL
)
1123 if (!excluded_name (p
))
1124 dump_file (p
, 1, (dev_t
) 0);
1130 if (listed_incremental_option
)
1131 write_directory_file ();
1135 /* Calculate the hash of a link. */
1137 hash_link (void const *entry
, unsigned n_buckets
)
1139 struct link
const *link
= entry
;
1140 return (uintmax_t) (link
->dev
^ link
->ino
) % n_buckets
;
1143 /* Compare two links for equality. */
1145 compare_links (void const *entry1
, void const *entry2
)
1147 struct link
const *link1
= entry1
;
1148 struct link
const *link2
= entry2
;
1149 return ((link1
->dev
^ link2
->dev
) | (link1
->ino
^ link2
->ino
)) == 0;
1153 unknown_file_error (char *p
)
1155 WARN ((0, 0, _("%s: Unknown file type; file ignored"),
1156 quotearg_colon (p
)));
1157 if (!ignore_failed_read_option
)
1158 exit_status
= TAREXIT_FAILURE
;
1162 /* Handling of hard links */
1164 /* Table of all non-directories that we've written so far. Any time
1165 we see another, we check the table and avoid dumping the data
1166 again if we've done it once already. */
1167 static Hash_table
*link_table
;
1169 /* Try to dump stat as a hard link to another file in the archive. If
1170 succeeded returns true */
1172 dump_hard_link (struct tar_stat_info
*stat
)
1174 if (link_table
&& stat
->stat
.st_nlink
> 1)
1178 off_t block_ordinal
;
1181 lp
.ino
= stat
->stat
.st_ino
;
1182 lp
.dev
= stat
->stat
.st_dev
;
1184 if ((dup
= hash_lookup (link_table
, &lp
)))
1186 /* We found a link. */
1187 char const *link_name
= safer_name_suffix (dup
->name
, true);
1191 block_ordinal
= current_block_ordinal ();
1192 assign_string (&stat
->link_name
, link_name
);
1193 if (NAME_FIELD_SIZE
< strlen (link_name
))
1194 write_long_link (stat
);
1196 stat
->stat
.st_size
= 0;
1197 blk
= start_header (stat
);
1200 tar_copy_str (blk
->header
.linkname
, link_name
, NAME_FIELD_SIZE
);
1202 blk
->header
.typeflag
= LNKTYPE
;
1203 finish_header (stat
, blk
, block_ordinal
);
1205 if (remove_files_option
&& unlink (stat
->orig_file_name
) != 0)
1206 unlink_error (stat
->orig_file_name
);
1215 file_count_links (struct tar_stat_info
*stat
)
1217 if (stat
->stat
.st_nlink
> 1)
1220 struct link
*lp
= xmalloc (offsetof (struct link
, name
)
1221 + strlen (stat
->orig_file_name
) + 1);
1222 lp
->ino
= stat
->stat
.st_ino
;
1223 lp
->dev
= stat
->stat
.st_dev
;
1224 lp
->nlink
= stat
->stat
.st_nlink
;
1225 strcpy (lp
->name
, stat
->orig_file_name
);
1228 || (link_table
= hash_initialize (0, 0, hash_link
,
1230 && (dup
= hash_insert (link_table
, lp
))))
1239 /* For each dumped file, check if all its links were dumped. Emit
1240 warnings if it is not so. */
1249 for (lp
= hash_get_first (link_table
); lp
;
1250 lp
= hash_get_next (link_table
, lp
))
1254 WARN ((0, 0, _("Missing links to '%s'.\n"), lp
->name
));
1260 /* Dump a single file, recursing on directories. P is the file name
1261 to dump. TOP_LEVEL tells whether this is a top-level call; zero
1262 means no, positive means yes, and negative means the top level
1263 of an incremental dump. PARENT_DEVICE is the device of P's
1264 parent directory; it is examined only if TOP_LEVEL is zero. */
1266 /* FIXME: One should make sure that for *every* path leading to setting
1267 exit_status to failure, a clear diagnostic has been issued. */
1270 dump_file0 (struct tar_stat_info
*stat
, char *p
,
1271 int top_level
, dev_t parent_device
)
1273 union block
*header
;
1275 time_t original_ctime
;
1276 struct utimbuf restore_times
;
1277 off_t block_ordinal
= -1;
1279 if (interactive_option
&& !confirm ("add", p
))
1282 assign_string (&stat
->orig_file_name
, p
);
1283 assign_string (&stat
->file_name
, safer_name_suffix (p
, false));
1285 if (deref_stat (dereference_option
, p
, &stat
->stat
) != 0)
1290 stat
->archive_file_size
= stat
->stat
.st_size
;
1291 sys_stat_nanoseconds(stat
);
1292 original_ctime
= stat
->stat
.st_ctime
;
1293 restore_times
.actime
= stat
->stat
.st_atime
;
1294 restore_times
.modtime
= stat
->stat
.st_mtime
;
1297 if (S_ISHIDDEN (stat
->stat
.st_mode
))
1299 char *new = (char *) alloca (strlen (p
) + 2);
1309 /* See if we want only new files, and check if this one is too old to
1310 put in the archive. */
1312 if ((0 < top_level
|| !incremental_option
)
1313 && !S_ISDIR (stat
->stat
.st_mode
)
1314 && stat
->stat
.st_mtime
< newer_mtime_option
1315 && (!after_date_option
|| stat
->stat
.st_ctime
< newer_ctime_option
))
1318 WARN ((0, 0, _("%s: file is unchanged; not dumped"),
1319 quotearg_colon (p
)));
1320 /* FIXME: recheck this return. */
1324 /* See if we are trying to dump the archive. */
1325 if (sys_file_is_archive (stat
))
1327 WARN ((0, 0, _("%s: file is the archive; not dumped"),
1328 quotearg_colon (p
)));
1332 if (S_ISDIR (stat
->stat
.st_mode
))
1334 dump_dir (stat
, top_level
, parent_device
);
1335 if (atime_preserve_option
)
1336 utime (p
, &restore_times
);
1339 else if (is_avoided_name (p
))
1343 /* Check for multiple links. */
1344 if (dump_hard_link (stat
))
1347 /* This is not a link to a previously dumped file, so dump it. */
1349 if (S_ISREG (stat
->stat
.st_mode
)
1350 || S_ISCTG (stat
->stat
.st_mode
))
1353 enum dump_status status
;
1355 if (file_dumpable_p (stat
))
1357 fd
= open (stat
->orig_file_name
,
1358 O_RDONLY
| O_BINARY
);
1361 if (!top_level
&& errno
== ENOENT
)
1362 WARN ((0, 0, _("%s: File removed before we read it"),
1363 quotearg_colon (stat
->orig_file_name
)));
1365 open_diag (stat
->orig_file_name
);
1372 if (sparse_option
&& sparse_file_p (stat
))
1374 status
= sparse_dump_file (fd
, stat
);
1375 if (status
== dump_status_not_implemented
)
1376 status
= dump_regular_file (fd
, stat
);
1379 status
= dump_regular_file (fd
, stat
);
1383 case dump_status_ok
:
1384 if (multi_volume_option
)
1385 assign_string (&save_name
, 0);
1386 dump_regular_finish (fd
, stat
, original_ctime
);
1389 case dump_status_short
:
1390 if (multi_volume_option
)
1391 assign_string (&save_name
, 0);
1395 case dump_status_fail
:
1399 case dump_status_not_implemented
:
1403 if (atime_preserve_option
)
1404 utime (stat
->orig_file_name
, &restore_times
);
1405 file_count_links (stat
);
1408 #ifdef HAVE_READLINK
1409 else if (S_ISLNK (stat
->stat
.st_mode
))
1413 size_t linklen
= stat
->stat
.st_size
;
1414 if (linklen
!= stat
->stat
.st_size
|| linklen
+ 1 == 0)
1416 buffer
= (char *) alloca (linklen
+ 1);
1417 size
= readlink (p
, buffer
, linklen
+ 1);
1423 buffer
[size
] = '\0';
1424 assign_string (&stat
->link_name
, buffer
);
1425 if (size
> NAME_FIELD_SIZE
)
1426 write_long_link (stat
);
1428 block_ordinal
= current_block_ordinal ();
1429 stat
->stat
.st_size
= 0; /* force 0 size on symlink */
1430 header
= start_header (stat
);
1433 tar_copy_str (header
->header
.linkname
, buffer
, NAME_FIELD_SIZE
);
1434 header
->header
.typeflag
= SYMTYPE
;
1435 finish_header (stat
, header
, block_ordinal
);
1436 /* nothing more to do to it */
1438 if (remove_files_option
)
1440 if (unlink (p
) == -1)
1443 file_count_links (stat
);
1447 else if (S_ISCHR (stat
->stat
.st_mode
))
1449 else if (S_ISBLK (stat
->stat
.st_mode
))
1451 else if (S_ISFIFO (stat
->stat
.st_mode
))
1453 else if (S_ISSOCK (stat
->stat
.st_mode
))
1455 WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1458 else if (S_ISDOOR (stat
->stat
.st_mode
))
1460 WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1465 unknown_file_error (p
);
1470 if (archive_format
== V7_FORMAT
)
1472 unknown_file_error (p
);
1476 block_ordinal
= current_block_ordinal ();
1477 stat
->stat
.st_size
= 0; /* force 0 size */
1478 header
= start_header (stat
);
1481 header
->header
.typeflag
= type
;
1483 if (type
!= FIFOTYPE
)
1485 MAJOR_TO_CHARS (major (stat
->stat
.st_rdev
),
1486 header
->header
.devmajor
);
1487 MINOR_TO_CHARS (minor (stat
->stat
.st_rdev
),
1488 header
->header
.devminor
);
1491 finish_header (stat
, header
, block_ordinal
);
1492 if (remove_files_option
)
1494 if (unlink (p
) == -1)
1500 dump_file (char *p
, int top_level
, dev_t parent_device
)
1502 struct tar_stat_info stat
;
1503 tar_stat_init (&stat
);
1504 dump_file0 (&stat
, p
, top_level
, parent_device
);
1505 tar_stat_destroy (&stat
);