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 ("././@PaxHeader", size
);
552 header
->header
.typeflag
= type
;
554 finish_header (st
, header
, -1);
556 p
= extended_header
.buffer
;
562 header
= find_next_block ();
566 memcpy (header
->buffer
, p
, len
);
568 memset (header
->buffer
+ len
, 0, BLOCKSIZE
- len
);
571 set_next_block_after (header
);
575 xheader_destroy (&extended_header
);
576 header
= find_next_block ();
577 memcpy (header
, &hp
.buffer
, sizeof (hp
.buffer
));
582 write_header_name (struct tar_stat_info
*st
)
584 if (NAME_FIELD_SIZE
< strlen (st
->file_name
))
585 return write_long_name (st
);
587 return write_short_name (st
);
591 /* Header handling. */
593 /* Make a header block for the file whose stat info is st,
594 and return its address. */
597 start_header (struct tar_stat_info
*st
)
601 header
= write_header_name (st
);
605 /* Override some stat fields, if requested to do so. */
607 if (owner_option
!= (uid_t
) -1)
608 st
->stat
.st_uid
= owner_option
;
609 if (group_option
!= (gid_t
) -1)
610 st
->stat
.st_gid
= group_option
;
612 st
->stat
.st_mode
= ((st
->stat
.st_mode
& ~MODE_ALL
)
613 | mode_adjust (st
->stat
.st_mode
, mode_option
));
615 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
616 for a few tars and came up with the following interoperability
620 1 2 3 4 5 6 7 8 9 READER
621 . . . . . . . . . 1 = SunOS 4.2 tar
622 # . . # # . . # # 2 = NEC SVR4.0.2 tar
623 . . . # # . . # . 3 = Solaris 2.1 tar
624 . . . . . . . . . 4 = GNU tar 1.11.1
625 . . . . . . . . . 5 = HP-UX 8.07 tar
626 . . . . . . . . . 6 = Ultrix 4.1
627 . . . . . . . . . 7 = AIX 3.2
628 . . . . . . . . . 8 = Hitachi HI-UX 1.03
629 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
632 # = ``impossible file type''
634 The following mask for old archive removes the `#'s in column 4
635 above, thus making GNU tar both a universal donor and a universal
636 acceptor for Paul's test. */
638 if (archive_format
== V7_FORMAT
|| archive_format
== USTAR_FORMAT
)
639 MODE_TO_CHARS (st
->stat
.st_mode
& MODE_ALL
, header
->header
.mode
);
641 MODE_TO_CHARS (st
->stat
.st_mode
, header
->header
.mode
);
643 if (st
->stat
.st_uid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
644 xheader_store ("uid", st
, NULL
);
646 UID_TO_CHARS (st
->stat
.st_uid
, header
->header
.uid
);
648 if (st
->stat
.st_gid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
649 xheader_store ("gid", st
, NULL
);
651 GID_TO_CHARS (st
->stat
.st_gid
, header
->header
.gid
);
653 if (st
->stat
.st_size
> MAXOCTAL11
&& archive_format
== POSIX_FORMAT
)
654 xheader_store ("size", st
, NULL
);
656 OFF_TO_CHARS (st
->stat
.st_size
, header
->header
.size
);
658 TIME_TO_CHARS (st
->stat
.st_mtime
, header
->header
.mtime
);
661 if (S_ISCHR (st
->stat
.st_mode
)
662 || S_ISBLK (st
->stat
.st_mode
))
664 st
->devmajor
= major (st
->stat
.st_rdev
);
665 st
->devminor
= minor (st
->stat
.st_rdev
);
667 if (st
->devmajor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
668 xheader_store ("devmajor", st
, NULL
);
670 MAJOR_TO_CHARS (st
->devmajor
, header
->header
.devmajor
);
672 if (st
->devminor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
673 xheader_store ("devminor", st
, NULL
);
675 MAJOR_TO_CHARS (st
->devminor
, header
->header
.devminor
);
679 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
680 MINOR_TO_CHARS (0, header
->header
.devminor
);
683 if (archive_format
== POSIX_FORMAT
)
685 xheader_store ("atime", st
, NULL
);
686 xheader_store ("ctime", st
, NULL
);
688 else if (incremental_option
)
689 if (archive_format
== OLDGNU_FORMAT
)
691 TIME_TO_CHARS (st
->stat
.st_atime
, header
->oldgnu_header
.atime
);
692 TIME_TO_CHARS (st
->stat
.st_ctime
, header
->oldgnu_header
.ctime
);
695 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
697 switch (archive_format
)
703 case GNU_FORMAT
: /*FIXME?*/
704 /* Overwrite header->header.magic and header.version in one blow. */
705 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
710 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
711 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
718 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
720 /* header->header.[ug]name are left as the empty string. */
724 uid_to_uname (st
->stat
.st_uid
, &st
->uname
);
725 gid_to_gname (st
->stat
.st_gid
, &st
->gname
);
727 if (archive_format
== POSIX_FORMAT
728 && strlen (st
->uname
) > UNAME_FIELD_SIZE
)
729 xheader_store ("uname", st
, NULL
);
731 UNAME_TO_CHARS (st
->uname
, header
->header
.uname
);
733 if (archive_format
== POSIX_FORMAT
734 && strlen (st
->gname
) > GNAME_FIELD_SIZE
)
735 xheader_store ("gname", st
, NULL
);
737 GNAME_TO_CHARS (st
->gname
, header
->header
.gname
);
743 /* Finish off a filled-in header block and write it out. We also
744 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
745 is not negative, is the block ordinal of the first record for this
746 file, which may be a preceding long name or long link record. */
748 finish_header (struct tar_stat_info
*st
,
749 union block
*header
, off_t block_ordinal
)
755 /* Note: It is important to do this before the call to write_extended(),
756 so that the actual ustar header is printed */
758 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
759 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
760 && header
->header
.typeflag
!= XHDTYPE
761 && header
->header
.typeflag
!= XGLTYPE
)
763 /* These globals are parameters to print_header, sigh. */
765 current_header
= header
;
766 current_format
= archive_format
;
767 print_header (st
, block_ordinal
);
770 header
= write_extended (st
, header
, XHDTYPE
);
772 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
776 for (i
= sizeof *header
; i
-- != 0; )
777 /* We can't use unsigned char here because of old compilers, e.g. V7. */
780 /* Fill in the checksum field. It's formatted differently from the
781 other fields: it has [6] digits, a null, then a space -- rather than
782 digits, then a null. We use to_chars.
783 The final space is already there, from
784 checksumming, and to_chars doesn't modify it.
786 This is a fast way to do:
788 sprintf(header->header.chksum, "%6o", sum); */
790 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
792 set_next_block_after (header
);
797 pad_archive (off_t size_left
)
800 while (size_left
> 0)
802 save_sizeleft
= size_left
;
803 blk
= find_next_block ();
804 memset (blk
->buffer
, 0, BLOCKSIZE
);
805 set_next_block_after (blk
);
806 size_left
-= BLOCKSIZE
;
810 static enum dump_status
811 dump_regular_file (int fd
, struct tar_stat_info
*stat
)
813 off_t size_left
= stat
->stat
.st_size
;
817 block_ordinal
= current_block_ordinal ();
818 blk
= start_header (stat
);
820 return dump_status_fail
;
822 /* Mark contiguous files, if we support them. */
823 if (archive_format
!= V7_FORMAT
&& S_ISCTG (stat
->stat
.st_mode
))
824 blk
->header
.typeflag
= CONTTYPE
;
826 finish_header (stat
, blk
, block_ordinal
);
828 while (size_left
> 0)
830 size_t bufsize
, count
;
832 if (multi_volume_option
)
834 assign_string (&save_name
, stat
->file_name
);
835 save_sizeleft
= size_left
;
836 save_totsize
= stat
->stat
.st_size
;
838 blk
= find_next_block ();
840 bufsize
= available_space_after (blk
);
842 if (size_left
< bufsize
)
844 /* Last read -- zero out area beyond. */
846 count
= bufsize
% BLOCKSIZE
;
848 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
851 count
= (fd
< 0) ? bufsize
: safe_read (fd
, blk
->buffer
, bufsize
);
854 read_diag_details (stat
->orig_file_name
,
855 stat
->stat
.st_size
- size_left
, bufsize
);
856 pad_archive (size_left
);
857 return dump_status_short
;
861 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
863 if (count
!= bufsize
)
865 char buf
[UINTMAX_STRSIZE_BOUND
];
866 memset (blk
->buffer
+ count
, 0, bufsize
- count
);
868 ngettext ("%s: File shrank by %s byte; padding with zeros",
869 "%s: File shrank by %s bytes; padding with zeros",
871 quotearg_colon (stat
->orig_file_name
),
872 STRINGIFY_BIGINT (size_left
, buf
)));
873 if (! ignore_failed_read_option
)
874 exit_status
= TAREXIT_FAILURE
;
875 pad_archive (size_left
);
876 return dump_status_short
;
879 return dump_status_ok
;
883 dump_regular_finish (int fd
, struct tar_stat_info
*st
, time_t original_ctime
)
887 struct stat final_stat
;
888 if (fstat (fd
, &final_stat
) != 0)
890 stat_diag (st
->orig_file_name
);
892 else if (final_stat
.st_ctime
!= original_ctime
)
894 WARN ((0, 0, _("%s: file changed as we read it"),
895 quotearg_colon (st
->orig_file_name
)));
899 close_diag (st
->orig_file_name
);
902 if (remove_files_option
)
904 if (unlink (st
->orig_file_name
) == -1)
905 unlink_error (st
->orig_file_name
);
910 dump_dir0 (char *directory
,
911 struct tar_stat_info
*stat
, int top_level
, dev_t parent_device
)
913 dev_t our_device
= stat
->stat
.st_dev
;
915 if (!is_avoided_name (stat
->orig_file_name
))
917 union block
*blk
= NULL
;
918 off_t block_ordinal
= current_block_ordinal ();
919 stat
->stat
.st_size
= 0; /* force 0 size on dir */
921 blk
= start_header (stat
);
925 if (incremental_option
)
926 blk
->header
.typeflag
= GNUTYPE_DUMPDIR
;
927 else /* if (standard_option) */
928 blk
->header
.typeflag
= DIRTYPE
;
930 /* If we're gnudumping, we aren't done yet so don't close it. */
932 if (!incremental_option
)
933 finish_header (stat
, blk
, block_ordinal
);
934 else if (gnu_list_name
->dir_contents
)
940 const char *buffer
, *p_buffer
;
941 off_t block_ordinal
= current_block_ordinal ();
943 buffer
= gnu_list_name
->dir_contents
; /* FOO */
946 for (p_buffer
= buffer
; *p_buffer
; )
948 size_t size
= strlen (p_buffer
) + 1;
953 OFF_TO_CHARS (totsize
, blk
->header
.size
);
954 finish_header (stat
, blk
, block_ordinal
);
957 while (size_left
> 0)
959 if (multi_volume_option
)
961 assign_string (&save_name
, stat
->orig_file_name
);
962 save_sizeleft
= size_left
;
963 save_totsize
= totsize
;
965 blk
= find_next_block ();
966 bufsize
= available_space_after (blk
);
967 if (size_left
< bufsize
)
970 count
= bufsize
% BLOCKSIZE
;
972 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
974 memcpy (blk
->buffer
, p_buffer
, bufsize
);
975 size_left
-= bufsize
;
977 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
979 if (multi_volume_option
)
980 assign_string (&save_name
, 0);
985 if (!recursion_option
)
988 if (one_file_system_option
990 && parent_device
!= stat
->stat
.st_dev
)
994 _("%s: file is on a different filesystem; not dumped"),
995 quotearg_colon (stat
->orig_file_name
)));
1002 char *name_buf
= strdup (stat
->orig_file_name
);
1003 size_t name_size
= strlen (name_buf
);
1004 size_t name_len
= name_size
;
1006 /* Now output all the files in the directory. */
1007 /* FIXME: Should speed this up by cd-ing into the dir. */
1009 for (entry
= directory
; (entry_len
= strlen (entry
)) != 0;
1010 entry
+= entry_len
+ 1)
1012 if (name_size
< name_len
+ entry_len
)
1014 name_size
= name_len
+ entry_len
;
1015 name_buf
= xrealloc (name_buf
, name_size
+ 1);
1017 strcpy (name_buf
+ name_len
, entry
);
1018 if (!excluded_name (name_buf
))
1019 dump_file (name_buf
, 0, our_device
);
1026 /* Ensure exactly one trailing slash. */
1028 ensure_slash (char **pstr
)
1030 size_t len
= strlen (*pstr
);
1031 while (len
>= 1 && ISSLASH ((*pstr
)[len
- 1]))
1033 if (!ISSLASH ((*pstr
)[len
]))
1034 *pstr
= xrealloc (*pstr
, len
+ 2);
1035 (*pstr
)[len
++] = '/';
1036 (*pstr
)[len
] = '\0';
1040 dump_dir (struct tar_stat_info
*stat
, int top_level
, dev_t parent_device
)
1044 directory
= savedir (stat
->orig_file_name
);
1047 savedir_diag (stat
->orig_file_name
);
1051 ensure_slash (&stat
->orig_file_name
);
1052 ensure_slash (&stat
->file_name
);
1054 dump_dir0 (directory
, stat
, top_level
, parent_device
);
1061 /* Main functions of this module. */
1064 create_archive (void)
1068 open_archive (ACCESS_WRITE
);
1070 if (incremental_option
)
1072 size_t buffer_size
= 1000;
1073 char *buffer
= xmalloc (buffer_size
);
1076 collect_and_sort_names ();
1078 while ((p
= name_from_list ()) != NULL
)
1079 if (!excluded_name (p
))
1080 dump_file (p
, -1, (dev_t
) 0);
1083 while ((p
= name_from_list ()) != NULL
)
1084 if (!excluded_name (p
))
1086 size_t plen
= strlen (p
);
1087 if (buffer_size
<= plen
)
1089 while ((buffer_size
*= 2) <= plen
)
1091 buffer
= xrealloc (buffer
, buffer_size
);
1093 memcpy (buffer
, p
, plen
);
1094 if (! ISSLASH (buffer
[plen
- 1]))
1095 buffer
[plen
++] = '/';
1096 q
= gnu_list_name
->dir_contents
;
1100 size_t qlen
= strlen (q
);
1103 if (buffer_size
< plen
+ qlen
)
1105 while ((buffer_size
*=2 ) < plen
+ qlen
)
1107 buffer
= xrealloc (buffer
, buffer_size
);
1109 strcpy (buffer
+ plen
, q
+ 1);
1110 dump_file (buffer
, -1, (dev_t
) 0);
1119 while ((p
= name_next (1)) != NULL
)
1120 if (!excluded_name (p
))
1121 dump_file (p
, 1, (dev_t
) 0);
1127 if (listed_incremental_option
)
1128 write_directory_file ();
1132 /* Calculate the hash of a link. */
1134 hash_link (void const *entry
, unsigned n_buckets
)
1136 struct link
const *link
= entry
;
1137 return (uintmax_t) (link
->dev
^ link
->ino
) % n_buckets
;
1140 /* Compare two links for equality. */
1142 compare_links (void const *entry1
, void const *entry2
)
1144 struct link
const *link1
= entry1
;
1145 struct link
const *link2
= entry2
;
1146 return ((link1
->dev
^ link2
->dev
) | (link1
->ino
^ link2
->ino
)) == 0;
1150 unknown_file_error (char *p
)
1152 WARN ((0, 0, _("%s: Unknown file type; file ignored"),
1153 quotearg_colon (p
)));
1154 if (!ignore_failed_read_option
)
1155 exit_status
= TAREXIT_FAILURE
;
1159 /* Handling of hard links */
1161 /* Table of all non-directories that we've written so far. Any time
1162 we see another, we check the table and avoid dumping the data
1163 again if we've done it once already. */
1164 static Hash_table
*link_table
;
1166 /* Try to dump stat as a hard link to another file in the archive. If
1167 succeeded returns true */
1169 dump_hard_link (struct tar_stat_info
*stat
)
1171 if (link_table
&& stat
->stat
.st_nlink
> 1)
1175 off_t block_ordinal
;
1178 lp
.ino
= stat
->stat
.st_ino
;
1179 lp
.dev
= stat
->stat
.st_dev
;
1181 if ((dup
= hash_lookup (link_table
, &lp
)))
1183 /* We found a link. */
1184 char const *link_name
= safer_name_suffix (dup
->name
, true);
1188 block_ordinal
= current_block_ordinal ();
1189 assign_string (&stat
->link_name
, link_name
);
1190 if (NAME_FIELD_SIZE
< strlen (link_name
))
1191 write_long_link (stat
);
1193 stat
->stat
.st_size
= 0;
1194 blk
= start_header (stat
);
1197 tar_copy_str (blk
->header
.linkname
, link_name
, NAME_FIELD_SIZE
);
1199 blk
->header
.typeflag
= LNKTYPE
;
1200 finish_header (stat
, blk
, block_ordinal
);
1202 if (remove_files_option
&& unlink (stat
->orig_file_name
) != 0)
1203 unlink_error (stat
->orig_file_name
);
1212 file_count_links (struct tar_stat_info
*stat
)
1214 if (stat
->stat
.st_nlink
> 1)
1217 struct link
*lp
= xmalloc (offsetof (struct link
, name
)
1218 + strlen (stat
->orig_file_name
) + 1);
1219 lp
->ino
= stat
->stat
.st_ino
;
1220 lp
->dev
= stat
->stat
.st_dev
;
1221 lp
->nlink
= stat
->stat
.st_nlink
;
1222 strcpy (lp
->name
, stat
->orig_file_name
);
1225 || (link_table
= hash_initialize (0, 0, hash_link
,
1227 && (dup
= hash_insert (link_table
, lp
))))
1236 /* For each dumped file, check if all its links were dumped. Emit
1237 warnings if it is not so. */
1246 for (lp
= hash_get_first (link_table
); lp
;
1247 lp
= hash_get_next (link_table
, lp
))
1251 WARN ((0, 0, _("Missing links to '%s'.\n"), lp
->name
));
1257 /* Dump a single file, recursing on directories. P is the file name
1258 to dump. TOP_LEVEL tells whether this is a top-level call; zero
1259 means no, positive means yes, and negative means the top level
1260 of an incremental dump. PARENT_DEVICE is the device of P's
1261 parent directory; it is examined only if TOP_LEVEL is zero. */
1263 /* FIXME: One should make sure that for *every* path leading to setting
1264 exit_status to failure, a clear diagnostic has been issued. */
1267 dump_file0 (struct tar_stat_info
*stat
, char *p
,
1268 int top_level
, dev_t parent_device
)
1270 union block
*header
;
1272 time_t original_ctime
;
1273 struct utimbuf restore_times
;
1274 off_t block_ordinal
= -1;
1276 if (interactive_option
&& !confirm ("add", p
))
1279 assign_string (&stat
->orig_file_name
, p
);
1280 assign_string (&stat
->file_name
, safer_name_suffix (p
, false));
1282 if (deref_stat (dereference_option
, p
, &stat
->stat
) != 0)
1287 stat
->archive_file_size
= stat
->stat
.st_size
;
1288 sys_stat_nanoseconds(stat
);
1289 original_ctime
= stat
->stat
.st_ctime
;
1290 restore_times
.actime
= stat
->stat
.st_atime
;
1291 restore_times
.modtime
= stat
->stat
.st_mtime
;
1294 if (S_ISHIDDEN (stat
->stat
.st_mode
))
1296 char *new = (char *) alloca (strlen (p
) + 2);
1306 /* See if we want only new files, and check if this one is too old to
1307 put in the archive. */
1309 if ((0 < top_level
|| !incremental_option
)
1310 && !S_ISDIR (stat
->stat
.st_mode
)
1311 && stat
->stat
.st_mtime
< newer_mtime_option
1312 && (!after_date_option
|| stat
->stat
.st_ctime
< newer_ctime_option
))
1315 WARN ((0, 0, _("%s: file is unchanged; not dumped"),
1316 quotearg_colon (p
)));
1317 /* FIXME: recheck this return. */
1321 /* See if we are trying to dump the archive. */
1322 if (sys_file_is_archive (stat
))
1324 WARN ((0, 0, _("%s: file is the archive; not dumped"),
1325 quotearg_colon (p
)));
1329 if (S_ISDIR (stat
->stat
.st_mode
))
1331 dump_dir (stat
, top_level
, parent_device
);
1332 if (atime_preserve_option
)
1333 utime (p
, &restore_times
);
1336 else if (is_avoided_name (p
))
1340 /* Check for multiple links. */
1341 if (dump_hard_link (stat
))
1344 /* This is not a link to a previously dumped file, so dump it. */
1346 if (S_ISREG (stat
->stat
.st_mode
)
1347 || S_ISCTG (stat
->stat
.st_mode
))
1350 enum dump_status status
;
1352 if (file_dumpable_p (stat
))
1354 fd
= open (stat
->orig_file_name
,
1355 O_RDONLY
| O_BINARY
);
1358 if (!top_level
&& errno
== ENOENT
)
1359 WARN ((0, 0, _("%s: File removed before we read it"),
1360 quotearg_colon (stat
->orig_file_name
)));
1362 open_diag (stat
->orig_file_name
);
1369 if (sparse_option
&& sparse_file_p (stat
))
1371 status
= sparse_dump_file (fd
, stat
);
1372 if (status
== dump_status_not_implemented
)
1373 status
= dump_regular_file (fd
, stat
);
1376 status
= dump_regular_file (fd
, stat
);
1380 case dump_status_ok
:
1381 if (multi_volume_option
)
1382 assign_string (&save_name
, 0);
1383 dump_regular_finish (fd
, stat
, original_ctime
);
1386 case dump_status_short
:
1387 if (multi_volume_option
)
1388 assign_string (&save_name
, 0);
1392 case dump_status_fail
:
1396 case dump_status_not_implemented
:
1400 if (atime_preserve_option
)
1401 utime (stat
->orig_file_name
, &restore_times
);
1402 file_count_links (stat
);
1405 #ifdef HAVE_READLINK
1406 else if (S_ISLNK (stat
->stat
.st_mode
))
1410 size_t linklen
= stat
->stat
.st_size
;
1411 if (linklen
!= stat
->stat
.st_size
|| linklen
+ 1 == 0)
1413 buffer
= (char *) alloca (linklen
+ 1);
1414 size
= readlink (p
, buffer
, linklen
+ 1);
1420 buffer
[size
] = '\0';
1421 assign_string (&stat
->link_name
, buffer
);
1422 if (size
> NAME_FIELD_SIZE
)
1423 write_long_link (stat
);
1425 block_ordinal
= current_block_ordinal ();
1426 stat
->stat
.st_size
= 0; /* force 0 size on symlink */
1427 header
= start_header (stat
);
1430 tar_copy_str (header
->header
.linkname
, buffer
, NAME_FIELD_SIZE
);
1431 header
->header
.typeflag
= SYMTYPE
;
1432 finish_header (stat
, header
, block_ordinal
);
1433 /* nothing more to do to it */
1435 if (remove_files_option
)
1437 if (unlink (p
) == -1)
1440 file_count_links (stat
);
1444 else if (S_ISCHR (stat
->stat
.st_mode
))
1446 else if (S_ISBLK (stat
->stat
.st_mode
))
1448 else if (S_ISFIFO (stat
->stat
.st_mode
))
1450 else if (S_ISSOCK (stat
->stat
.st_mode
))
1452 WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1455 else if (S_ISDOOR (stat
->stat
.st_mode
))
1457 WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1462 unknown_file_error (p
);
1467 if (archive_format
== V7_FORMAT
)
1469 unknown_file_error (p
);
1473 block_ordinal
= current_block_ordinal ();
1474 stat
->stat
.st_size
= 0; /* force 0 size */
1475 header
= start_header (stat
);
1478 header
->header
.typeflag
= type
;
1480 if (type
!= FIFOTYPE
)
1482 MAJOR_TO_CHARS (major (stat
->stat
.st_rdev
),
1483 header
->header
.devmajor
);
1484 MINOR_TO_CHARS (minor (stat
->stat
.st_rdev
),
1485 header
->header
.devminor
);
1488 finish_header (stat
, header
, block_ordinal
);
1489 if (remove_files_option
)
1491 if (unlink (p
) == -1)
1497 dump_file (char *p
, int top_level
, dev_t parent_device
)
1499 struct tar_stat_info stat
;
1500 tar_stat_init (&stat
);
1501 dump_file0 (&stat
, p
, top_level
, parent_device
);
1502 tar_stat_destroy (&stat
);