1 /* Create a tar archive.
3 Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
4 2003, 2004 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
);
523 if (strlen (st
->file_name
) > NAME_FIELD_SIZE
-1)
525 WARN ((0, 0, _("%s: file name is too long (max %d); not dumped"),
526 quotearg_colon (st
->file_name
),
527 NAME_FIELD_SIZE
- 1));
534 return write_ustar_long_name (st
->file_name
);
538 write_gnu_long_link (st
, st
->file_name
, GNUTYPE_LONGNAME
);
544 return write_short_name (st
);
548 write_extended (struct tar_stat_info
*st
, union block
*old_header
)
550 union block
*header
, hp
;
554 if (extended_header
.buffer
|| extended_header
.stk
== NULL
)
557 xheader_finish (&extended_header
);
558 memcpy (hp
.buffer
, old_header
, sizeof (hp
));
559 p
= xheader_xhdr_name (st
);
560 xheader_write (XHDTYPE
, p
, &extended_header
);
562 header
= find_next_block ();
563 memcpy (header
, &hp
.buffer
, sizeof (hp
.buffer
));
568 write_header_name (struct tar_stat_info
*st
)
570 if (archive_format
== POSIX_FORMAT
&& !string_ascii_p (st
->file_name
))
572 xheader_store ("path", st
, NULL
);
573 return write_short_name (st
);
575 else if (NAME_FIELD_SIZE
< strlen (st
->file_name
))
576 return write_long_name (st
);
578 return write_short_name (st
);
582 /* Header handling. */
584 /* Make a header block for the file whose stat info is st,
585 and return its address. */
588 start_header (struct tar_stat_info
*st
)
592 header
= write_header_name (st
);
596 /* Override some stat fields, if requested to do so. */
598 if (owner_option
!= (uid_t
) -1)
599 st
->stat
.st_uid
= owner_option
;
600 if (group_option
!= (gid_t
) -1)
601 st
->stat
.st_gid
= group_option
;
603 st
->stat
.st_mode
= ((st
->stat
.st_mode
& ~MODE_ALL
)
604 | mode_adjust (st
->stat
.st_mode
, mode_option
));
606 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
607 for a few tars and came up with the following interoperability
611 1 2 3 4 5 6 7 8 9 READER
612 . . . . . . . . . 1 = SunOS 4.2 tar
613 # . . # # . . # # 2 = NEC SVR4.0.2 tar
614 . . . # # . . # . 3 = Solaris 2.1 tar
615 . . . . . . . . . 4 = GNU tar 1.11.1
616 . . . . . . . . . 5 = HP-UX 8.07 tar
617 . . . . . . . . . 6 = Ultrix 4.1
618 . . . . . . . . . 7 = AIX 3.2
619 . . . . . . . . . 8 = Hitachi HI-UX 1.03
620 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
623 # = ``impossible file type''
625 The following mask for old archive removes the `#'s in column 4
626 above, thus making GNU tar both a universal donor and a universal
627 acceptor for Paul's test. */
629 if (archive_format
== V7_FORMAT
|| archive_format
== USTAR_FORMAT
)
630 MODE_TO_CHARS (st
->stat
.st_mode
& MODE_ALL
, header
->header
.mode
);
632 MODE_TO_CHARS (st
->stat
.st_mode
, header
->header
.mode
);
634 if (st
->stat
.st_uid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
635 xheader_store ("uid", st
, NULL
);
637 UID_TO_CHARS (st
->stat
.st_uid
, header
->header
.uid
);
639 if (st
->stat
.st_gid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
640 xheader_store ("gid", st
, NULL
);
642 GID_TO_CHARS (st
->stat
.st_gid
, header
->header
.gid
);
644 if (st
->stat
.st_size
> MAXOCTAL11
&& archive_format
== POSIX_FORMAT
)
645 xheader_store ("size", st
, NULL
);
647 OFF_TO_CHARS (st
->stat
.st_size
, header
->header
.size
);
649 TIME_TO_CHARS (st
->stat
.st_mtime
, header
->header
.mtime
);
652 if (S_ISCHR (st
->stat
.st_mode
)
653 || S_ISBLK (st
->stat
.st_mode
))
655 st
->devmajor
= major (st
->stat
.st_rdev
);
656 st
->devminor
= minor (st
->stat
.st_rdev
);
658 if (st
->devmajor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
659 xheader_store ("devmajor", st
, NULL
);
661 MAJOR_TO_CHARS (st
->devmajor
, header
->header
.devmajor
);
663 if (st
->devminor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
664 xheader_store ("devminor", st
, NULL
);
666 MAJOR_TO_CHARS (st
->devminor
, header
->header
.devminor
);
670 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
671 MINOR_TO_CHARS (0, header
->header
.devminor
);
674 if (archive_format
== POSIX_FORMAT
)
676 xheader_store ("atime", st
, NULL
);
677 xheader_store ("ctime", st
, NULL
);
679 else if (incremental_option
)
680 if (archive_format
== OLDGNU_FORMAT
|| archive_format
== GNU_FORMAT
)
682 TIME_TO_CHARS (st
->stat
.st_atime
, header
->oldgnu_header
.atime
);
683 TIME_TO_CHARS (st
->stat
.st_ctime
, header
->oldgnu_header
.ctime
);
686 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
688 switch (archive_format
)
694 case GNU_FORMAT
: /*FIXME?*/
695 /* Overwrite header->header.magic and header.version in one blow. */
696 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
701 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
702 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
709 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
711 /* header->header.[ug]name are left as the empty string. */
715 uid_to_uname (st
->stat
.st_uid
, &st
->uname
);
716 gid_to_gname (st
->stat
.st_gid
, &st
->gname
);
718 if (archive_format
== POSIX_FORMAT
719 && (strlen (st
->uname
) > UNAME_FIELD_SIZE
720 || !string_ascii_p (st
->uname
)))
721 xheader_store ("uname", st
, NULL
);
723 UNAME_TO_CHARS (st
->uname
, header
->header
.uname
);
725 if (archive_format
== POSIX_FORMAT
726 && (strlen (st
->gname
) > GNAME_FIELD_SIZE
727 || !string_ascii_p (st
->gname
)))
728 xheader_store ("gname", st
, NULL
);
730 GNAME_TO_CHARS (st
->gname
, header
->header
.gname
);
737 simple_finish_header (union block
*header
)
743 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
747 for (i
= sizeof *header
; i
-- != 0; )
748 /* We can't use unsigned char here because of old compilers, e.g. V7. */
751 /* Fill in the checksum field. It's formatted differently from the
752 other fields: it has [6] digits, a null, then a space -- rather than
753 digits, then a null. We use to_chars.
754 The final space is already there, from
755 checksumming, and to_chars doesn't modify it.
757 This is a fast way to do:
759 sprintf(header->header.chksum, "%6o", sum); */
761 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
763 set_next_block_after (header
);
766 /* Finish off a filled-in header block and write it out. We also
767 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
768 is not negative, is the block ordinal of the first record for this
769 file, which may be a preceding long name or long link record. */
771 finish_header (struct tar_stat_info
*st
,
772 union block
*header
, off_t block_ordinal
)
778 /* Note: It is important to do this before the call to write_extended(),
779 so that the actual ustar header is printed */
781 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
782 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
783 && header
->header
.typeflag
!= XHDTYPE
784 && header
->header
.typeflag
!= XGLTYPE
)
786 /* These globals are parameters to print_header, sigh. */
788 current_header
= header
;
789 current_format
= archive_format
;
790 print_header (st
, block_ordinal
);
793 header
= write_extended (st
, header
);
794 simple_finish_header (header
);
799 pad_archive (off_t size_left
)
802 while (size_left
> 0)
804 save_sizeleft
= size_left
;
805 blk
= find_next_block ();
806 memset (blk
->buffer
, 0, BLOCKSIZE
);
807 set_next_block_after (blk
);
808 size_left
-= BLOCKSIZE
;
812 static enum dump_status
813 dump_regular_file (int fd
, struct tar_stat_info
*stat
)
815 off_t size_left
= stat
->stat
.st_size
;
819 block_ordinal
= current_block_ordinal ();
820 blk
= start_header (stat
);
822 return dump_status_fail
;
824 /* Mark contiguous files, if we support them. */
825 if (archive_format
!= V7_FORMAT
&& S_ISCTG (stat
->stat
.st_mode
))
826 blk
->header
.typeflag
= CONTTYPE
;
828 finish_header (stat
, blk
, block_ordinal
);
830 while (size_left
> 0)
832 size_t bufsize
, count
;
834 if (multi_volume_option
)
836 assign_string (&save_name
, stat
->file_name
);
837 save_sizeleft
= size_left
;
838 save_totsize
= stat
->stat
.st_size
;
840 blk
= find_next_block ();
842 bufsize
= available_space_after (blk
);
844 if (size_left
< bufsize
)
846 /* Last read -- zero out area beyond. */
848 count
= bufsize
% BLOCKSIZE
;
850 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
853 count
= (fd
< 0) ? bufsize
: safe_read (fd
, blk
->buffer
, bufsize
);
856 read_diag_details (stat
->orig_file_name
,
857 stat
->stat
.st_size
- size_left
, bufsize
);
858 pad_archive (size_left
);
859 return dump_status_short
;
863 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
865 if (count
!= bufsize
)
867 char buf
[UINTMAX_STRSIZE_BOUND
];
868 memset (blk
->buffer
+ count
, 0, bufsize
- count
);
870 ngettext ("%s: File shrank by %s byte; padding with zeros",
871 "%s: File shrank by %s bytes; padding with zeros",
873 quotearg_colon (stat
->orig_file_name
),
874 STRINGIFY_BIGINT (size_left
, buf
)));
875 if (! ignore_failed_read_option
)
876 exit_status
= TAREXIT_FAILURE
;
877 pad_archive (size_left
);
878 return dump_status_short
;
881 return dump_status_ok
;
885 dump_regular_finish (int fd
, struct tar_stat_info
*st
, time_t original_ctime
)
889 struct stat final_stat
;
890 if (fstat (fd
, &final_stat
) != 0)
892 stat_diag (st
->orig_file_name
);
894 else if (final_stat
.st_ctime
!= original_ctime
)
896 WARN ((0, 0, _("%s: file changed as we read it"),
897 quotearg_colon (st
->orig_file_name
)));
901 close_diag (st
->orig_file_name
);
904 if (remove_files_option
)
906 if (unlink (st
->orig_file_name
) == -1)
907 unlink_error (st
->orig_file_name
);
912 dump_dir0 (char *directory
,
913 struct tar_stat_info
*stat
, int top_level
, dev_t parent_device
)
915 dev_t our_device
= stat
->stat
.st_dev
;
917 if (!is_avoided_name (stat
->orig_file_name
))
919 union block
*blk
= NULL
;
920 off_t block_ordinal
= current_block_ordinal ();
921 stat
->stat
.st_size
= 0; /* force 0 size on dir */
923 blk
= start_header (stat
);
927 if (incremental_option
)
928 blk
->header
.typeflag
= GNUTYPE_DUMPDIR
;
929 else /* if (standard_option) */
930 blk
->header
.typeflag
= DIRTYPE
;
932 /* If we're gnudumping, we aren't done yet so don't close it. */
934 if (!incremental_option
)
935 finish_header (stat
, blk
, block_ordinal
);
936 else if (gnu_list_name
->dir_contents
)
942 const char *buffer
, *p_buffer
;
943 off_t block_ordinal
= current_block_ordinal ();
945 buffer
= gnu_list_name
->dir_contents
; /* FOO */
948 for (p_buffer
= buffer
; *p_buffer
; )
950 size_t size
= strlen (p_buffer
) + 1;
955 OFF_TO_CHARS (totsize
, blk
->header
.size
);
956 finish_header (stat
, blk
, block_ordinal
);
959 while (size_left
> 0)
961 if (multi_volume_option
)
963 assign_string (&save_name
, stat
->orig_file_name
);
964 save_sizeleft
= size_left
;
965 save_totsize
= totsize
;
967 blk
= find_next_block ();
968 bufsize
= available_space_after (blk
);
969 if (size_left
< bufsize
)
972 count
= bufsize
% BLOCKSIZE
;
974 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
976 memcpy (blk
->buffer
, p_buffer
, bufsize
);
977 size_left
-= bufsize
;
979 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
981 if (multi_volume_option
)
982 assign_string (&save_name
, 0);
987 if (!recursion_option
)
990 if (one_file_system_option
992 && parent_device
!= stat
->stat
.st_dev
)
996 _("%s: file is on a different filesystem; not dumped"),
997 quotearg_colon (stat
->orig_file_name
)));
1004 char *name_buf
= strdup (stat
->orig_file_name
);
1005 size_t name_size
= strlen (name_buf
);
1006 size_t name_len
= name_size
;
1008 /* Now output all the files in the directory. */
1009 /* FIXME: Should speed this up by cd-ing into the dir. */
1011 for (entry
= directory
; (entry_len
= strlen (entry
)) != 0;
1012 entry
+= entry_len
+ 1)
1014 if (name_size
< name_len
+ entry_len
)
1016 name_size
= name_len
+ entry_len
;
1017 name_buf
= xrealloc (name_buf
, name_size
+ 1);
1019 strcpy (name_buf
+ name_len
, entry
);
1020 if (!excluded_name (name_buf
))
1021 dump_file (name_buf
, 0, our_device
);
1028 /* Ensure exactly one trailing slash. */
1030 ensure_slash (char **pstr
)
1032 size_t len
= strlen (*pstr
);
1033 while (len
>= 1 && ISSLASH ((*pstr
)[len
- 1]))
1035 if (!ISSLASH ((*pstr
)[len
]))
1036 *pstr
= xrealloc (*pstr
, len
+ 2);
1037 (*pstr
)[len
++] = '/';
1038 (*pstr
)[len
] = '\0';
1042 dump_dir (struct tar_stat_info
*stat
, int top_level
, dev_t parent_device
)
1046 directory
= savedir (stat
->orig_file_name
);
1049 savedir_diag (stat
->orig_file_name
);
1053 ensure_slash (&stat
->orig_file_name
);
1054 ensure_slash (&stat
->file_name
);
1056 dump_dir0 (directory
, stat
, top_level
, parent_device
);
1063 /* Main functions of this module. */
1066 create_archive (void)
1070 open_archive (ACCESS_WRITE
);
1071 xheader_write_global ();
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 (!S_ISDIR (stat
->stat
.st_mode
)
1313 && stat
->stat
.st_mtime
< newer_mtime_option
1314 && (!after_date_option
|| stat
->stat
.st_ctime
< newer_ctime_option
))
1316 if (0 < top_level
) /* equivalent to !incremental_option */
1317 WARN ((0, 0, _("%s: file is unchanged; not dumped"),
1318 quotearg_colon (p
)));
1319 /* FIXME: recheck this return. */
1323 /* See if we are trying to dump the archive. */
1324 if (sys_file_is_archive (stat
))
1326 WARN ((0, 0, _("%s: file is the archive; not dumped"),
1327 quotearg_colon (p
)));
1331 if (S_ISDIR (stat
->stat
.st_mode
))
1333 dump_dir (stat
, top_level
, parent_device
);
1334 if (atime_preserve_option
)
1335 utime (p
, &restore_times
);
1338 else if (is_avoided_name (p
))
1342 /* Check for multiple links. */
1343 if (dump_hard_link (stat
))
1346 /* This is not a link to a previously dumped file, so dump it. */
1348 if (S_ISREG (stat
->stat
.st_mode
)
1349 || S_ISCTG (stat
->stat
.st_mode
))
1352 enum dump_status status
;
1354 if (file_dumpable_p (stat
))
1356 fd
= open (stat
->orig_file_name
,
1357 O_RDONLY
| O_BINARY
);
1360 if (!top_level
&& errno
== ENOENT
)
1361 WARN ((0, 0, _("%s: File removed before we read it"),
1362 quotearg_colon (stat
->orig_file_name
)));
1364 open_diag (stat
->orig_file_name
);
1371 if (sparse_option
&& sparse_file_p (stat
))
1373 status
= sparse_dump_file (fd
, stat
);
1374 if (status
== dump_status_not_implemented
)
1375 status
= dump_regular_file (fd
, stat
);
1378 status
= dump_regular_file (fd
, stat
);
1382 case dump_status_ok
:
1383 if (multi_volume_option
)
1384 assign_string (&save_name
, 0);
1385 dump_regular_finish (fd
, stat
, original_ctime
);
1388 case dump_status_short
:
1389 if (multi_volume_option
)
1390 assign_string (&save_name
, 0);
1394 case dump_status_fail
:
1398 case dump_status_not_implemented
:
1402 if (atime_preserve_option
)
1403 utime (stat
->orig_file_name
, &restore_times
);
1404 file_count_links (stat
);
1407 #ifdef HAVE_READLINK
1408 else if (S_ISLNK (stat
->stat
.st_mode
))
1412 size_t linklen
= stat
->stat
.st_size
;
1413 if (linklen
!= stat
->stat
.st_size
|| linklen
+ 1 == 0)
1415 buffer
= (char *) alloca (linklen
+ 1);
1416 size
= readlink (p
, buffer
, linklen
+ 1);
1422 buffer
[size
] = '\0';
1423 assign_string (&stat
->link_name
, buffer
);
1424 if (size
> NAME_FIELD_SIZE
)
1425 write_long_link (stat
);
1427 block_ordinal
= current_block_ordinal ();
1428 stat
->stat
.st_size
= 0; /* force 0 size on symlink */
1429 header
= start_header (stat
);
1432 tar_copy_str (header
->header
.linkname
, buffer
, NAME_FIELD_SIZE
);
1433 header
->header
.typeflag
= SYMTYPE
;
1434 finish_header (stat
, header
, block_ordinal
);
1435 /* nothing more to do to it */
1437 if (remove_files_option
)
1439 if (unlink (p
) == -1)
1442 file_count_links (stat
);
1446 else if (S_ISCHR (stat
->stat
.st_mode
))
1448 else if (S_ISBLK (stat
->stat
.st_mode
))
1450 else if (S_ISFIFO (stat
->stat
.st_mode
))
1452 else if (S_ISSOCK (stat
->stat
.st_mode
))
1454 WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1457 else if (S_ISDOOR (stat
->stat
.st_mode
))
1459 WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1464 unknown_file_error (p
);
1469 if (archive_format
== V7_FORMAT
)
1471 unknown_file_error (p
);
1475 block_ordinal
= current_block_ordinal ();
1476 stat
->stat
.st_size
= 0; /* force 0 size */
1477 header
= start_header (stat
);
1480 header
->header
.typeflag
= type
;
1482 if (type
!= FIFOTYPE
)
1484 MAJOR_TO_CHARS (major (stat
->stat
.st_rdev
),
1485 header
->header
.devmajor
);
1486 MINOR_TO_CHARS (minor (stat
->stat
.st_rdev
),
1487 header
->header
.devminor
);
1490 finish_header (stat
, header
, block_ordinal
);
1491 if (remove_files_option
)
1493 if (unlink (p
) == -1)
1499 dump_file (char *p
, int top_level
, dev_t parent_device
)
1501 struct tar_stat_info stat
;
1502 tar_stat_init (&stat
);
1503 dump_file0 (&stat
, p
, top_level
, parent_device
);
1504 tar_stat_destroy (&stat
);