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
!= USTAR_FORMAT
255 && archive_format
!= GNU_FORMAT
)
263 u
= ((v
& S_ISUID
? TSUID
: 0)
264 | (v
& S_ISGID
? TSGID
: 0)
265 | (v
& S_ISVTX
? TSVTX
: 0)
266 | (v
& S_IRUSR
? TUREAD
: 0)
267 | (v
& S_IWUSR
? TUWRITE
: 0)
268 | (v
& S_IXUSR
? TUEXEC
: 0)
269 | (v
& S_IRGRP
? TGREAD
: 0)
270 | (v
& S_IWGRP
? TGWRITE
: 0)
271 | (v
& S_IXGRP
? TGEXEC
: 0)
272 | (v
& S_IROTH
? TOREAD
: 0)
273 | (v
& S_IWOTH
? TOWRITE
: 0)
274 | (v
& S_IXOTH
? TOEXEC
: 0));
276 to_chars (negative
, u
, sizeof v
, 0, p
, s
, "mode_t");
280 off_to_chars (off_t v
, char *p
, size_t s
)
282 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "off_t");
286 size_to_chars (size_t v
, char *p
, size_t s
)
288 to_chars (0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "size_t");
292 time_to_chars (time_t v
, char *p
, size_t s
)
294 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "time_t");
298 uid_substitute (int *negative
)
304 static uid_t uid_nobody
;
305 if (!uid_nobody
&& !uname_to_uid ("nobody", &uid_nobody
))
314 uid_to_chars (uid_t v
, char *p
, size_t s
)
316 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, uid_substitute
, p
, s
, "uid_t");
320 uintmax_to_chars (uintmax_t v
, char *p
, size_t s
)
322 to_chars (0, v
, sizeof v
, 0, p
, s
, "uintmax_t");
326 string_to_chars (char *str
, char *p
, size_t s
)
333 /* A file is not dumpable if
334 a) it is empty *and* world-readable, or
335 b) current archive is /dev/null */
338 file_dumpable_p (struct tar_stat_info
*stat
)
340 return !(dev_null_output
341 || (stat
->archive_file_size
== 0
342 && (stat
->stat
.st_mode
& MODE_R
) == MODE_R
));
346 /* Writing routines. */
348 /* Write the EOT block(s). Zero at least two blocks, through the end
349 of the record. Old tar, as previous versions of GNU tar, writes
350 garbage after two zeroed blocks. */
354 union block
*pointer
= find_next_block ();
355 memset (pointer
->buffer
, 0, BLOCKSIZE
);
356 set_next_block_after (pointer
);
357 pointer
= find_next_block ();
358 memset (pointer
->buffer
, 0, available_space_after (pointer
));
359 set_next_block_after (pointer
);
362 /* Copy at most LEN bytes from SRC to DST. Terminate with NUL unless
363 SRC is LEN characters long */
365 tar_copy_str (char *dst
, const char *src
, size_t len
)
368 strncpy (dst
, src
, len
);
371 /* Write a "private" header */
373 start_private_header (const char *name
, size_t size
)
376 union block
*header
= find_next_block ();
378 memset (header
->buffer
, 0, sizeof (union block
));
380 tar_copy_str (header
->header
.name
, name
, NAME_FIELD_SIZE
);
381 OFF_TO_CHARS (size
, header
->header
.size
);
384 TIME_TO_CHARS (t
, header
->header
.mtime
);
385 MODE_TO_CHARS (S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
, header
->header
.mode
);
386 UID_TO_CHARS (getuid (), header
->header
.uid
);
387 GID_TO_CHARS (getgid (), header
->header
.gid
);
388 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
389 MAJOR_TO_CHARS (0, header
->header
.devminor
);
390 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
391 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
395 /* Create a new header and store there at most NAME_FIELD_SIZE bytes of
399 write_short_name (struct tar_stat_info
*st
)
401 union block
*header
= find_next_block ();
402 memset (header
->buffer
, 0, sizeof (union block
));
403 tar_copy_str (header
->header
.name
, st
->file_name
, NAME_FIELD_SIZE
);
407 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. */
409 write_gnu_long_link (struct tar_stat_info
*st
, const char *p
, char type
)
411 size_t size
= strlen (p
) + 1;
415 header
= start_private_header ("././@LongLink", size
);
416 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
417 header
->header
.typeflag
= type
;
418 finish_header (st
, header
, -1);
420 header
= find_next_block ();
422 bufsize
= available_space_after (header
);
424 while (bufsize
< size
)
426 memcpy (header
->buffer
, p
, bufsize
);
429 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
430 header
= find_next_block ();
431 bufsize
= available_space_after (header
);
433 memcpy (header
->buffer
, p
, size
);
434 memset (header
->buffer
+ size
, 0, bufsize
- size
);
435 set_next_block_after (header
+ (size
- 1) / BLOCKSIZE
);
439 split_long_name (const char *name
, size_t length
)
443 if (length
> PREFIX_FIELD_SIZE
)
444 length
= PREFIX_FIELD_SIZE
+2;
445 for (i
= length
- 1; i
> 0; i
--)
446 if (ISSLASH (name
[i
]))
452 write_ustar_long_name (const char *name
)
454 size_t length
= strlen (name
);
458 if (length
> PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1)
460 WARN ((0, 0, _("%s: file name is too long (max %d); not dumped"),
461 quotearg_colon (name
),
462 PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1));
466 i
= split_long_name (name
, length
);
467 if (i
== 0 || length
- i
- 1 > NAME_FIELD_SIZE
)
470 _("%s: file name is too long (cannot be split); not dumped"),
471 quotearg_colon (name
)));
475 header
= find_next_block ();
476 memset (header
->buffer
, 0, sizeof (header
->buffer
));
477 memcpy (header
->header
.prefix
, name
, i
);
478 memcpy (header
->header
.name
, name
+ i
+ 1, length
- i
- 1);
483 /* Write a long link name, depending on the current archive format */
485 write_long_link (struct tar_stat_info
*st
)
487 switch (archive_format
)
490 xheader_store ("linkpath", st
, NULL
);
493 case V7_FORMAT
: /* old V7 tar format */
497 _("%s: link name is too long; not dumped"),
498 quotearg_colon (st
->link_name
)));
503 write_gnu_long_link (st
, st
->link_name
, GNUTYPE_LONGLINK
);
512 write_long_name (struct tar_stat_info
*st
)
514 switch (archive_format
)
517 xheader_store ("path", st
, NULL
);
523 return write_ustar_long_name (st
->file_name
);
527 write_gnu_long_link (st
, st
->file_name
, GNUTYPE_LONGNAME
);
533 return write_short_name (st
);
537 write_extended (struct tar_stat_info
*st
, union block
*old_header
, char type
)
539 union block
*header
, hp
;
543 if (extended_header
.buffer
|| extended_header
.stk
== NULL
)
546 xheader_finish (&extended_header
);
547 size
= extended_header
.size
;
549 memcpy (hp
.buffer
, old_header
, sizeof (hp
));
551 header
= start_private_header (p
= xheader_xhdr_name (st
), size
);
553 header
->header
.typeflag
= type
;
555 finish_header (st
, header
, -1);
557 p
= extended_header
.buffer
;
563 header
= find_next_block ();
567 memcpy (header
->buffer
, p
, len
);
569 memset (header
->buffer
+ len
, 0, BLOCKSIZE
- len
);
572 set_next_block_after (header
);
576 xheader_destroy (&extended_header
);
577 header
= find_next_block ();
578 memcpy (header
, &hp
.buffer
, sizeof (hp
.buffer
));
583 write_header_name (struct tar_stat_info
*st
)
585 if (NAME_FIELD_SIZE
< strlen (st
->file_name
))
586 return write_long_name (st
);
588 return write_short_name (st
);
592 /* Header handling. */
594 /* Make a header block for the file whose stat info is st,
595 and return its address. */
598 start_header (struct tar_stat_info
*st
)
602 header
= write_header_name (st
);
606 /* Override some stat fields, if requested to do so. */
608 if (owner_option
!= (uid_t
) -1)
609 st
->stat
.st_uid
= owner_option
;
610 if (group_option
!= (gid_t
) -1)
611 st
->stat
.st_gid
= group_option
;
613 st
->stat
.st_mode
= ((st
->stat
.st_mode
& ~MODE_ALL
)
614 | mode_adjust (st
->stat
.st_mode
, mode_option
));
616 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
617 for a few tars and came up with the following interoperability
621 1 2 3 4 5 6 7 8 9 READER
622 . . . . . . . . . 1 = SunOS 4.2 tar
623 # . . # # . . # # 2 = NEC SVR4.0.2 tar
624 . . . # # . . # . 3 = Solaris 2.1 tar
625 . . . . . . . . . 4 = GNU tar 1.11.1
626 . . . . . . . . . 5 = HP-UX 8.07 tar
627 . . . . . . . . . 6 = Ultrix 4.1
628 . . . . . . . . . 7 = AIX 3.2
629 . . . . . . . . . 8 = Hitachi HI-UX 1.03
630 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
633 # = ``impossible file type''
635 The following mask for old archive removes the `#'s in column 4
636 above, thus making GNU tar both a universal donor and a universal
637 acceptor for Paul's test. */
639 if (archive_format
== V7_FORMAT
|| archive_format
== USTAR_FORMAT
)
640 MODE_TO_CHARS (st
->stat
.st_mode
& MODE_ALL
, header
->header
.mode
);
642 MODE_TO_CHARS (st
->stat
.st_mode
, header
->header
.mode
);
644 if (st
->stat
.st_uid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
645 xheader_store ("uid", st
, NULL
);
647 UID_TO_CHARS (st
->stat
.st_uid
, header
->header
.uid
);
649 if (st
->stat
.st_gid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
650 xheader_store ("gid", st
, NULL
);
652 GID_TO_CHARS (st
->stat
.st_gid
, header
->header
.gid
);
654 if (st
->stat
.st_size
> MAXOCTAL11
&& archive_format
== POSIX_FORMAT
)
655 xheader_store ("size", st
, NULL
);
657 OFF_TO_CHARS (st
->stat
.st_size
, header
->header
.size
);
659 TIME_TO_CHARS (st
->stat
.st_mtime
, header
->header
.mtime
);
662 if (S_ISCHR (st
->stat
.st_mode
)
663 || S_ISBLK (st
->stat
.st_mode
))
665 st
->devmajor
= major (st
->stat
.st_rdev
);
666 st
->devminor
= minor (st
->stat
.st_rdev
);
668 if (st
->devmajor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
669 xheader_store ("devmajor", st
, NULL
);
671 MAJOR_TO_CHARS (st
->devmajor
, header
->header
.devmajor
);
673 if (st
->devminor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
674 xheader_store ("devminor", st
, NULL
);
676 MAJOR_TO_CHARS (st
->devminor
, header
->header
.devminor
);
680 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
681 MINOR_TO_CHARS (0, header
->header
.devminor
);
684 if (archive_format
== POSIX_FORMAT
)
686 xheader_store ("atime", st
, NULL
);
687 xheader_store ("ctime", st
, NULL
);
689 else if (incremental_option
)
690 if (archive_format
== OLDGNU_FORMAT
)
692 TIME_TO_CHARS (st
->stat
.st_atime
, header
->oldgnu_header
.atime
);
693 TIME_TO_CHARS (st
->stat
.st_ctime
, header
->oldgnu_header
.ctime
);
696 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
698 switch (archive_format
)
704 case GNU_FORMAT
: /*FIXME?*/
705 /* Overwrite header->header.magic and header.version in one blow. */
706 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
711 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
712 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
719 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
721 /* header->header.[ug]name are left as the empty string. */
725 uid_to_uname (st
->stat
.st_uid
, &st
->uname
);
726 gid_to_gname (st
->stat
.st_gid
, &st
->gname
);
728 if (archive_format
== POSIX_FORMAT
729 && strlen (st
->uname
) > UNAME_FIELD_SIZE
)
730 xheader_store ("uname", st
, NULL
);
732 UNAME_TO_CHARS (st
->uname
, header
->header
.uname
);
734 if (archive_format
== POSIX_FORMAT
735 && strlen (st
->gname
) > GNAME_FIELD_SIZE
)
736 xheader_store ("gname", st
, NULL
);
738 GNAME_TO_CHARS (st
->gname
, header
->header
.gname
);
744 /* Finish off a filled-in header block and write it out. We also
745 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
746 is not negative, is the block ordinal of the first record for this
747 file, which may be a preceding long name or long link record. */
749 finish_header (struct tar_stat_info
*st
,
750 union block
*header
, off_t block_ordinal
)
756 /* Note: It is important to do this before the call to write_extended(),
757 so that the actual ustar header is printed */
759 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
760 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
761 && header
->header
.typeflag
!= XHDTYPE
762 && header
->header
.typeflag
!= XGLTYPE
)
764 /* These globals are parameters to print_header, sigh. */
766 current_header
= header
;
767 current_format
= archive_format
;
768 print_header (st
, block_ordinal
);
771 header
= write_extended (st
, header
, XHDTYPE
);
773 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
777 for (i
= sizeof *header
; i
-- != 0; )
778 /* We can't use unsigned char here because of old compilers, e.g. V7. */
781 /* Fill in the checksum field. It's formatted differently from the
782 other fields: it has [6] digits, a null, then a space -- rather than
783 digits, then a null. We use to_chars.
784 The final space is already there, from
785 checksumming, and to_chars doesn't modify it.
787 This is a fast way to do:
789 sprintf(header->header.chksum, "%6o", sum); */
791 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
793 set_next_block_after (header
);
798 pad_archive (off_t size_left
)
801 while (size_left
> 0)
803 save_sizeleft
= size_left
;
804 blk
= find_next_block ();
805 memset (blk
->buffer
, 0, BLOCKSIZE
);
806 set_next_block_after (blk
);
807 size_left
-= BLOCKSIZE
;
811 static enum dump_status
812 dump_regular_file (int fd
, struct tar_stat_info
*stat
)
814 off_t size_left
= stat
->stat
.st_size
;
818 block_ordinal
= current_block_ordinal ();
819 blk
= start_header (stat
);
821 return dump_status_fail
;
823 /* Mark contiguous files, if we support them. */
824 if (archive_format
!= V7_FORMAT
&& S_ISCTG (stat
->stat
.st_mode
))
825 blk
->header
.typeflag
= CONTTYPE
;
827 finish_header (stat
, blk
, block_ordinal
);
829 while (size_left
> 0)
831 size_t bufsize
, count
;
833 if (multi_volume_option
)
835 assign_string (&save_name
, stat
->file_name
);
836 save_sizeleft
= size_left
;
837 save_totsize
= stat
->stat
.st_size
;
839 blk
= find_next_block ();
841 bufsize
= available_space_after (blk
);
843 if (size_left
< bufsize
)
845 /* Last read -- zero out area beyond. */
847 count
= bufsize
% BLOCKSIZE
;
849 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
852 count
= (fd
< 0) ? bufsize
: safe_read (fd
, blk
->buffer
, bufsize
);
855 read_diag_details (stat
->orig_file_name
,
856 stat
->stat
.st_size
- size_left
, bufsize
);
857 pad_archive (size_left
);
858 return dump_status_short
;
862 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
864 if (count
!= bufsize
)
866 char buf
[UINTMAX_STRSIZE_BOUND
];
867 memset (blk
->buffer
+ count
, 0, bufsize
- count
);
869 ngettext ("%s: File shrank by %s byte; padding with zeros",
870 "%s: File shrank by %s bytes; padding with zeros",
872 quotearg_colon (stat
->orig_file_name
),
873 STRINGIFY_BIGINT (size_left
, buf
)));
874 if (! ignore_failed_read_option
)
875 exit_status
= TAREXIT_FAILURE
;
876 pad_archive (size_left
);
877 return dump_status_short
;
880 return dump_status_ok
;
884 dump_regular_finish (int fd
, struct tar_stat_info
*st
, time_t original_ctime
)
888 struct stat final_stat
;
889 if (fstat (fd
, &final_stat
) != 0)
891 stat_diag (st
->orig_file_name
);
893 else if (final_stat
.st_ctime
!= original_ctime
)
895 WARN ((0, 0, _("%s: file changed as we read it"),
896 quotearg_colon (st
->orig_file_name
)));
900 close_diag (st
->orig_file_name
);
903 if (remove_files_option
)
905 if (unlink (st
->orig_file_name
) == -1)
906 unlink_error (st
->orig_file_name
);
911 dump_dir0 (char *directory
,
912 struct tar_stat_info
*stat
, int top_level
, dev_t parent_device
)
914 dev_t our_device
= stat
->stat
.st_dev
;
916 if (!is_avoided_name (stat
->orig_file_name
))
918 union block
*blk
= NULL
;
919 off_t block_ordinal
= current_block_ordinal ();
920 stat
->stat
.st_size
= 0; /* force 0 size on dir */
922 blk
= start_header (stat
);
926 if (incremental_option
)
927 blk
->header
.typeflag
= GNUTYPE_DUMPDIR
;
928 else /* if (standard_option) */
929 blk
->header
.typeflag
= DIRTYPE
;
931 /* If we're gnudumping, we aren't done yet so don't close it. */
933 if (!incremental_option
)
934 finish_header (stat
, blk
, block_ordinal
);
935 else if (gnu_list_name
->dir_contents
)
941 const char *buffer
, *p_buffer
;
942 off_t block_ordinal
= current_block_ordinal ();
944 buffer
= gnu_list_name
->dir_contents
; /* FOO */
947 for (p_buffer
= buffer
; *p_buffer
; )
949 size_t size
= strlen (p_buffer
) + 1;
954 OFF_TO_CHARS (totsize
, blk
->header
.size
);
955 finish_header (stat
, blk
, block_ordinal
);
958 while (size_left
> 0)
960 if (multi_volume_option
)
962 assign_string (&save_name
, stat
->orig_file_name
);
963 save_sizeleft
= size_left
;
964 save_totsize
= totsize
;
966 blk
= find_next_block ();
967 bufsize
= available_space_after (blk
);
968 if (size_left
< bufsize
)
971 count
= bufsize
% BLOCKSIZE
;
973 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
975 memcpy (blk
->buffer
, p_buffer
, bufsize
);
976 size_left
-= bufsize
;
978 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
980 if (multi_volume_option
)
981 assign_string (&save_name
, 0);
986 if (!recursion_option
)
989 if (one_file_system_option
991 && parent_device
!= stat
->stat
.st_dev
)
995 _("%s: file is on a different filesystem; not dumped"),
996 quotearg_colon (stat
->orig_file_name
)));
1003 char *name_buf
= strdup (stat
->orig_file_name
);
1004 size_t name_size
= strlen (name_buf
);
1005 size_t name_len
= name_size
;
1007 /* Now output all the files in the directory. */
1008 /* FIXME: Should speed this up by cd-ing into the dir. */
1010 for (entry
= directory
; (entry_len
= strlen (entry
)) != 0;
1011 entry
+= entry_len
+ 1)
1013 if (name_size
< name_len
+ entry_len
)
1015 name_size
= name_len
+ entry_len
;
1016 name_buf
= xrealloc (name_buf
, name_size
+ 1);
1018 strcpy (name_buf
+ name_len
, entry
);
1019 if (!excluded_name (name_buf
))
1020 dump_file (name_buf
, 0, our_device
);
1027 /* Ensure exactly one trailing slash. */
1029 ensure_slash (char **pstr
)
1031 size_t len
= strlen (*pstr
);
1032 while (len
>= 1 && ISSLASH ((*pstr
)[len
- 1]))
1034 if (!ISSLASH ((*pstr
)[len
]))
1035 *pstr
= xrealloc (*pstr
, len
+ 2);
1036 (*pstr
)[len
++] = '/';
1037 (*pstr
)[len
] = '\0';
1041 dump_dir (struct tar_stat_info
*stat
, int top_level
, dev_t parent_device
)
1045 directory
= savedir (stat
->orig_file_name
);
1048 savedir_diag (stat
->orig_file_name
);
1052 ensure_slash (&stat
->orig_file_name
);
1053 ensure_slash (&stat
->file_name
);
1055 dump_dir0 (directory
, stat
, top_level
, parent_device
);
1062 /* Main functions of this module. */
1065 create_archive (void)
1069 open_archive (ACCESS_WRITE
);
1071 if (incremental_option
)
1073 size_t buffer_size
= 1000;
1074 char *buffer
= xmalloc (buffer_size
);
1077 collect_and_sort_names ();
1079 while ((p
= name_from_list ()) != NULL
)
1080 if (!excluded_name (p
))
1081 dump_file (p
, -1, (dev_t
) 0);
1084 while ((p
= name_from_list ()) != NULL
)
1085 if (!excluded_name (p
))
1087 size_t plen
= strlen (p
);
1088 if (buffer_size
<= plen
)
1090 while ((buffer_size
*= 2) <= plen
)
1092 buffer
= xrealloc (buffer
, buffer_size
);
1094 memcpy (buffer
, p
, plen
);
1095 if (! ISSLASH (buffer
[plen
- 1]))
1096 buffer
[plen
++] = '/';
1097 q
= gnu_list_name
->dir_contents
;
1101 size_t qlen
= strlen (q
);
1104 if (buffer_size
< plen
+ qlen
)
1106 while ((buffer_size
*=2 ) < plen
+ qlen
)
1108 buffer
= xrealloc (buffer
, buffer_size
);
1110 strcpy (buffer
+ plen
, q
+ 1);
1111 dump_file (buffer
, -1, (dev_t
) 0);
1120 while ((p
= name_next (1)) != NULL
)
1121 if (!excluded_name (p
))
1122 dump_file (p
, 1, (dev_t
) 0);
1128 if (listed_incremental_option
)
1129 write_directory_file ();
1133 /* Calculate the hash of a link. */
1135 hash_link (void const *entry
, unsigned n_buckets
)
1137 struct link
const *link
= entry
;
1138 return (uintmax_t) (link
->dev
^ link
->ino
) % n_buckets
;
1141 /* Compare two links for equality. */
1143 compare_links (void const *entry1
, void const *entry2
)
1145 struct link
const *link1
= entry1
;
1146 struct link
const *link2
= entry2
;
1147 return ((link1
->dev
^ link2
->dev
) | (link1
->ino
^ link2
->ino
)) == 0;
1151 unknown_file_error (char *p
)
1153 WARN ((0, 0, _("%s: Unknown file type; file ignored"),
1154 quotearg_colon (p
)));
1155 if (!ignore_failed_read_option
)
1156 exit_status
= TAREXIT_FAILURE
;
1160 /* Handling of hard links */
1162 /* Table of all non-directories that we've written so far. Any time
1163 we see another, we check the table and avoid dumping the data
1164 again if we've done it once already. */
1165 static Hash_table
*link_table
;
1167 /* Try to dump stat as a hard link to another file in the archive. If
1168 succeeded returns true */
1170 dump_hard_link (struct tar_stat_info
*stat
)
1172 if (link_table
&& stat
->stat
.st_nlink
> 1)
1176 off_t block_ordinal
;
1179 lp
.ino
= stat
->stat
.st_ino
;
1180 lp
.dev
= stat
->stat
.st_dev
;
1182 if ((dup
= hash_lookup (link_table
, &lp
)))
1184 /* We found a link. */
1185 char const *link_name
= safer_name_suffix (dup
->name
, true);
1189 block_ordinal
= current_block_ordinal ();
1190 assign_string (&stat
->link_name
, link_name
);
1191 if (NAME_FIELD_SIZE
< strlen (link_name
))
1192 write_long_link (stat
);
1194 stat
->stat
.st_size
= 0;
1195 blk
= start_header (stat
);
1198 tar_copy_str (blk
->header
.linkname
, link_name
, NAME_FIELD_SIZE
);
1200 blk
->header
.typeflag
= LNKTYPE
;
1201 finish_header (stat
, blk
, block_ordinal
);
1203 if (remove_files_option
&& unlink (stat
->orig_file_name
) != 0)
1204 unlink_error (stat
->orig_file_name
);
1213 file_count_links (struct tar_stat_info
*stat
)
1215 if (stat
->stat
.st_nlink
> 1)
1218 struct link
*lp
= xmalloc (offsetof (struct link
, name
)
1219 + strlen (stat
->orig_file_name
) + 1);
1220 lp
->ino
= stat
->stat
.st_ino
;
1221 lp
->dev
= stat
->stat
.st_dev
;
1222 lp
->nlink
= stat
->stat
.st_nlink
;
1223 strcpy (lp
->name
, stat
->orig_file_name
);
1226 || (link_table
= hash_initialize (0, 0, hash_link
,
1228 && (dup
= hash_insert (link_table
, lp
))))
1237 /* For each dumped file, check if all its links were dumped. Emit
1238 warnings if it is not so. */
1247 for (lp
= hash_get_first (link_table
); lp
;
1248 lp
= hash_get_next (link_table
, lp
))
1252 WARN ((0, 0, _("Missing links to '%s'.\n"), lp
->name
));
1258 /* Dump a single file, recursing on directories. P is the file name
1259 to dump. TOP_LEVEL tells whether this is a top-level call; zero
1260 means no, positive means yes, and negative means the top level
1261 of an incremental dump. PARENT_DEVICE is the device of P's
1262 parent directory; it is examined only if TOP_LEVEL is zero. */
1264 /* FIXME: One should make sure that for *every* path leading to setting
1265 exit_status to failure, a clear diagnostic has been issued. */
1268 dump_file0 (struct tar_stat_info
*stat
, char *p
,
1269 int top_level
, dev_t parent_device
)
1271 union block
*header
;
1273 time_t original_ctime
;
1274 struct utimbuf restore_times
;
1275 off_t block_ordinal
= -1;
1277 if (interactive_option
&& !confirm ("add", p
))
1280 assign_string (&stat
->orig_file_name
, p
);
1281 assign_string (&stat
->file_name
, safer_name_suffix (p
, false));
1283 if (deref_stat (dereference_option
, p
, &stat
->stat
) != 0)
1288 stat
->archive_file_size
= stat
->stat
.st_size
;
1289 sys_stat_nanoseconds(stat
);
1290 original_ctime
= stat
->stat
.st_ctime
;
1291 restore_times
.actime
= stat
->stat
.st_atime
;
1292 restore_times
.modtime
= stat
->stat
.st_mtime
;
1295 if (S_ISHIDDEN (stat
->stat
.st_mode
))
1297 char *new = (char *) alloca (strlen (p
) + 2);
1307 /* See if we want only new files, and check if this one is too old to
1308 put in the archive. */
1310 if ((0 < top_level
|| !incremental_option
)
1311 && !S_ISDIR (stat
->stat
.st_mode
)
1312 && stat
->stat
.st_mtime
< newer_mtime_option
1313 && (!after_date_option
|| stat
->stat
.st_ctime
< newer_ctime_option
))
1316 WARN ((0, 0, _("%s: file is unchanged; not dumped"),
1317 quotearg_colon (p
)));
1318 /* FIXME: recheck this return. */
1322 /* See if we are trying to dump the archive. */
1323 if (sys_file_is_archive (stat
))
1325 WARN ((0, 0, _("%s: file is the archive; not dumped"),
1326 quotearg_colon (p
)));
1330 if (S_ISDIR (stat
->stat
.st_mode
))
1332 dump_dir (stat
, top_level
, parent_device
);
1333 if (atime_preserve_option
)
1334 utime (p
, &restore_times
);
1337 else if (is_avoided_name (p
))
1341 /* Check for multiple links. */
1342 if (dump_hard_link (stat
))
1345 /* This is not a link to a previously dumped file, so dump it. */
1347 if (S_ISREG (stat
->stat
.st_mode
)
1348 || S_ISCTG (stat
->stat
.st_mode
))
1351 enum dump_status status
;
1353 if (file_dumpable_p (stat
))
1355 fd
= open (stat
->orig_file_name
,
1356 O_RDONLY
| O_BINARY
);
1359 if (!top_level
&& errno
== ENOENT
)
1360 WARN ((0, 0, _("%s: File removed before we read it"),
1361 quotearg_colon (stat
->orig_file_name
)));
1363 open_diag (stat
->orig_file_name
);
1370 if (sparse_option
&& sparse_file_p (stat
))
1372 status
= sparse_dump_file (fd
, stat
);
1373 if (status
== dump_status_not_implemented
)
1374 status
= dump_regular_file (fd
, stat
);
1377 status
= dump_regular_file (fd
, stat
);
1381 case dump_status_ok
:
1382 if (multi_volume_option
)
1383 assign_string (&save_name
, 0);
1384 dump_regular_finish (fd
, stat
, original_ctime
);
1387 case dump_status_short
:
1388 if (multi_volume_option
)
1389 assign_string (&save_name
, 0);
1393 case dump_status_fail
:
1397 case dump_status_not_implemented
:
1401 if (atime_preserve_option
)
1402 utime (stat
->orig_file_name
, &restore_times
);
1403 file_count_links (stat
);
1406 #ifdef HAVE_READLINK
1407 else if (S_ISLNK (stat
->stat
.st_mode
))
1411 size_t linklen
= stat
->stat
.st_size
;
1412 if (linklen
!= stat
->stat
.st_size
|| linklen
+ 1 == 0)
1414 buffer
= (char *) alloca (linklen
+ 1);
1415 size
= readlink (p
, buffer
, linklen
+ 1);
1421 buffer
[size
] = '\0';
1422 assign_string (&stat
->link_name
, buffer
);
1423 if (size
> NAME_FIELD_SIZE
)
1424 write_long_link (stat
);
1426 block_ordinal
= current_block_ordinal ();
1427 stat
->stat
.st_size
= 0; /* force 0 size on symlink */
1428 header
= start_header (stat
);
1431 tar_copy_str (header
->header
.linkname
, buffer
, NAME_FIELD_SIZE
);
1432 header
->header
.typeflag
= SYMTYPE
;
1433 finish_header (stat
, header
, block_ordinal
);
1434 /* nothing more to do to it */
1436 if (remove_files_option
)
1438 if (unlink (p
) == -1)
1441 file_count_links (stat
);
1445 else if (S_ISCHR (stat
->stat
.st_mode
))
1447 else if (S_ISBLK (stat
->stat
.st_mode
))
1449 else if (S_ISFIFO (stat
->stat
.st_mode
))
1451 else if (S_ISSOCK (stat
->stat
.st_mode
))
1453 WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1456 else if (S_ISDOOR (stat
->stat
.st_mode
))
1458 WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1463 unknown_file_error (p
);
1468 if (archive_format
== V7_FORMAT
)
1470 unknown_file_error (p
);
1474 block_ordinal
= current_block_ordinal ();
1475 stat
->stat
.st_size
= 0; /* force 0 size */
1476 header
= start_header (stat
);
1479 header
->header
.typeflag
= type
;
1481 if (type
!= FIFOTYPE
)
1483 MAJOR_TO_CHARS (major (stat
->stat
.st_rdev
),
1484 header
->header
.devmajor
);
1485 MINOR_TO_CHARS (minor (stat
->stat
.st_rdev
),
1486 header
->header
.devminor
);
1489 finish_header (stat
, header
, block_ordinal
);
1490 if (remove_files_option
)
1492 if (unlink (p
) == -1)
1498 dump_file (char *p
, int top_level
, dev_t parent_device
)
1500 struct tar_stat_info stat
;
1501 tar_stat_init (&stat
);
1502 dump_file0 (&stat
, p
, top_level
, parent_device
);
1503 tar_stat_destroy (&stat
);