1 /* Create a tar archive.
3 Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
4 2003, 2004, 2005, 2006 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 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
37 /* The maximum uintmax_t value that can be represented with DIGITS digits,
38 assuming that each digit is BITS_PER_DIGIT wide. */
39 #define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
40 ((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
41 ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
44 /* The maximum uintmax_t value that can be represented with octal
45 digits and a trailing NUL in BUFFER. */
46 #define MAX_OCTAL_VAL(buffer) MAX_VAL_WITH_DIGITS (sizeof (buffer) - 1, LG_8)
48 /* Convert VALUE to an octal representation suitable for tar headers.
49 Output to buffer WHERE with size SIZE.
50 The result is undefined if SIZE is 0 or if VALUE is too large to fit. */
53 to_octal (uintmax_t value
, char *where
, size_t size
)
60 where
[--i
] = '0' + (v
& ((1 << LG_8
) - 1));
66 /* Copy at most LEN bytes from the string SRC to DST. Terminate with
67 NUL unless SRC is LEN or more bytes long. */
70 tar_copy_str (char *dst
, const char *src
, size_t len
)
73 for (i
= 0; i
< len
; i
++)
74 if (! (dst
[i
] = src
[i
]))
78 /* Same as tar_copy_str, but always terminate with NUL if using
82 tar_name_copy_str (char *dst
, const char *src
, size_t len
)
84 tar_copy_str (dst
, src
, len
);
85 if (archive_format
== OLDGNU_FORMAT
)
89 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
90 tar headers. NEGATIVE is 1 if VALUE was negative before being cast
91 to uintmax_t, 0 otherwise. Output to buffer WHERE with size SIZE.
92 The result is undefined if SIZE is 0 or if VALUE is too large to
96 to_base256 (int negative
, uintmax_t value
, char *where
, size_t size
)
99 uintmax_t propagated_sign_bits
=
100 ((uintmax_t) - negative
<< (CHAR_BIT
* sizeof v
- LG_256
));
105 where
[--i
] = v
& ((1 << LG_256
) - 1);
106 v
= propagated_sign_bits
| (v
>> LG_256
);
113 to_chars (int negative
, uintmax_t value
, size_t valsize
,
114 uintmax_t (*substitute
) (int *),
115 char *where
, size_t size
, const char *type
);
118 to_chars_subst (int negative
, int gnu_format
, uintmax_t value
, size_t valsize
,
119 uintmax_t (*substitute
) (int *),
120 char *where
, size_t size
, const char *type
)
122 uintmax_t maxval
= (gnu_format
123 ? MAX_VAL_WITH_DIGITS (size
- 1, LG_256
)
124 : MAX_VAL_WITH_DIGITS (size
- 1, LG_8
));
125 char valbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
126 char maxbuf
[UINTMAX_STRSIZE_BOUND
];
127 char minbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
128 char const *minval_string
;
129 char const *maxval_string
= STRINGIFY_BIGINT (maxval
, maxbuf
);
130 char const *value_string
;
134 uintmax_t m
= maxval
+ 1 ? maxval
+ 1 : maxval
/ 2 + 1;
135 char *p
= STRINGIFY_BIGINT (m
, minbuf
+ 1);
144 char *p
= STRINGIFY_BIGINT (- value
, valbuf
+ 1);
149 value_string
= STRINGIFY_BIGINT (value
, valbuf
);
154 uintmax_t sub
= substitute (&negsub
) & maxval
;
155 /* FIXME: This is the only place where GNU_FORMAT differs from
156 OLDGNU_FORMAT. Apart from this they are completely identical. */
157 uintmax_t s
= (negsub
&= archive_format
== GNU_FORMAT
) ? - sub
: sub
;
158 char subbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
159 char *sub_string
= STRINGIFY_BIGINT (s
, subbuf
+ 1);
162 WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
163 value_string
, type
, minval_string
, maxval_string
,
165 return to_chars (negsub
, s
, valsize
, 0, where
, size
, type
);
168 ERROR ((0, 0, _("value %s out of %s range %s..%s"),
169 value_string
, type
, minval_string
, maxval_string
));
173 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
174 external form, using SUBSTITUTE (...) if VALUE won't fit. Output
175 to buffer WHERE with size SIZE. NEGATIVE is 1 iff VALUE was
176 negative before being cast to uintmax_t; its original bitpattern
177 can be deduced from VALSIZE, its original size before casting.
178 TYPE is the kind of value being output (useful for diagnostics).
179 Prefer the POSIX format of SIZE - 1 octal digits (with leading zero
180 digits), followed by '\0'. If this won't work, and if GNU or
181 OLDGNU format is allowed, use '\200' followed by base-256, or (if
182 NEGATIVE is nonzero) '\377' followed by two's complement base-256.
183 If neither format works, use SUBSTITUTE (...) instead. Pass to
184 SUBSTITUTE the address of an 0-or-1 flag recording whether the
185 substitute value is negative. */
188 to_chars (int negative
, uintmax_t value
, size_t valsize
,
189 uintmax_t (*substitute
) (int *),
190 char *where
, size_t size
, const char *type
)
192 int gnu_format
= (archive_format
== GNU_FORMAT
193 || archive_format
== OLDGNU_FORMAT
);
195 /* Generate the POSIX octal representation if the number fits. */
196 if (! negative
&& value
<= MAX_VAL_WITH_DIGITS (size
- 1, LG_8
))
198 where
[size
- 1] = '\0';
199 to_octal (value
, where
, size
- 1);
204 /* Try to cope with the number by using traditional GNU format
207 /* Generate the base-256 representation if the number fits. */
208 if (((negative
? -1 - value
: value
)
209 <= MAX_VAL_WITH_DIGITS (size
- 1, LG_256
)))
211 where
[0] = negative
? -1 : 1 << (LG_256
- 1);
212 to_base256 (negative
, value
, where
+ 1, size
- 1);
216 /* Otherwise, if the number is negative, and if it would not cause
217 ambiguity on this host by confusing positive with negative
218 values, then generate the POSIX octal representation of the value
219 modulo 2**(field bits). The resulting tar file is
220 machine-dependent, since it depends on the host word size. Yuck!
221 But this is the traditional behavior. */
222 else if (negative
&& valsize
* CHAR_BIT
<= (size
- 1) * LG_8
)
224 static int warned_once
;
228 WARN ((0, 0, _("Generating negative octal headers")));
230 where
[size
- 1] = '\0';
231 to_octal (value
& MAX_VAL_WITH_DIGITS (valsize
* CHAR_BIT
, 1),
235 /* Otherwise fall back to substitution, if possible: */
238 substitute
= NULL
; /* No substitution for formats, other than GNU */
240 return to_chars_subst (negative
, gnu_format
, value
, valsize
, substitute
,
245 gid_substitute (int *negative
)
251 static gid_t gid_nobody
;
252 if (!gid_nobody
&& !gname_to_gid ("nobody", &gid_nobody
))
261 gid_to_chars (gid_t v
, char *p
, size_t s
)
263 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, gid_substitute
, p
, s
, "gid_t");
267 major_to_chars (major_t v
, char *p
, size_t s
)
269 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "major_t");
273 minor_to_chars (minor_t v
, char *p
, size_t s
)
275 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "minor_t");
279 mode_to_chars (mode_t v
, char *p
, size_t s
)
281 /* In the common case where the internal and external mode bits are the same,
282 and we are not using POSIX or GNU format,
283 propagate all unknown bits to the external mode.
284 This matches historical practice.
285 Otherwise, just copy the bits we know about. */
288 if (S_ISUID
== TSUID
&& S_ISGID
== TSGID
&& S_ISVTX
== TSVTX
289 && S_IRUSR
== TUREAD
&& S_IWUSR
== TUWRITE
&& S_IXUSR
== TUEXEC
290 && S_IRGRP
== TGREAD
&& S_IWGRP
== TGWRITE
&& S_IXGRP
== TGEXEC
291 && S_IROTH
== TOREAD
&& S_IWOTH
== TOWRITE
&& S_IXOTH
== TOEXEC
292 && archive_format
!= POSIX_FORMAT
293 && archive_format
!= USTAR_FORMAT
294 && archive_format
!= GNU_FORMAT
)
302 u
= ((v
& S_ISUID
? TSUID
: 0)
303 | (v
& S_ISGID
? TSGID
: 0)
304 | (v
& S_ISVTX
? TSVTX
: 0)
305 | (v
& S_IRUSR
? TUREAD
: 0)
306 | (v
& S_IWUSR
? TUWRITE
: 0)
307 | (v
& S_IXUSR
? TUEXEC
: 0)
308 | (v
& S_IRGRP
? TGREAD
: 0)
309 | (v
& S_IWGRP
? TGWRITE
: 0)
310 | (v
& S_IXGRP
? TGEXEC
: 0)
311 | (v
& S_IROTH
? TOREAD
: 0)
312 | (v
& S_IWOTH
? TOWRITE
: 0)
313 | (v
& S_IXOTH
? TOEXEC
: 0));
315 return to_chars (negative
, u
, sizeof v
, 0, p
, s
, "mode_t");
319 off_to_chars (off_t v
, char *p
, size_t s
)
321 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "off_t");
325 size_to_chars (size_t v
, char *p
, size_t s
)
327 return to_chars (0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "size_t");
331 time_to_chars (time_t v
, char *p
, size_t s
)
333 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "time_t");
337 uid_substitute (int *negative
)
343 static uid_t uid_nobody
;
344 if (!uid_nobody
&& !uname_to_uid ("nobody", &uid_nobody
))
353 uid_to_chars (uid_t v
, char *p
, size_t s
)
355 return to_chars (v
< 0, (uintmax_t) v
, sizeof v
, uid_substitute
, p
, s
, "uid_t");
359 uintmax_to_chars (uintmax_t v
, char *p
, size_t s
)
361 return to_chars (0, v
, sizeof v
, 0, p
, s
, "uintmax_t");
365 string_to_chars (char const *str
, char *p
, size_t s
)
367 tar_copy_str (p
, str
, s
);
372 /* A file is considered dumpable if it is sparse and both --sparse and --totals
374 Otherwise, it is dumpable unless any of the following conditions occur:
376 a) it is empty *and* world-readable, or
377 b) current archive is /dev/null */
380 file_dumpable_p (struct tar_stat_info
*st
)
383 return totals_option
&& sparse_option
&& sparse_file_p (st
);
384 return !(st
->archive_file_size
== 0
385 && (st
->stat
.st_mode
& MODE_R
) == MODE_R
);
389 /* Writing routines. */
391 /* Write the EOT block(s). Zero at least two blocks, through the end
392 of the record. Old tar, as previous versions of GNU tar, writes
393 garbage after two zeroed blocks. */
397 union block
*pointer
= find_next_block ();
398 memset (pointer
->buffer
, 0, BLOCKSIZE
);
399 set_next_block_after (pointer
);
400 pointer
= find_next_block ();
401 memset (pointer
->buffer
, 0, available_space_after (pointer
));
402 set_next_block_after (pointer
);
405 /* Write a "private" header */
407 start_private_header (const char *name
, size_t size
)
410 union block
*header
= find_next_block ();
412 memset (header
->buffer
, 0, sizeof (union block
));
414 tar_name_copy_str (header
->header
.name
, name
, NAME_FIELD_SIZE
);
415 OFF_TO_CHARS (size
, header
->header
.size
);
418 TIME_TO_CHARS (t
, header
->header
.mtime
);
419 MODE_TO_CHARS (S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
, header
->header
.mode
);
420 UID_TO_CHARS (getuid (), header
->header
.uid
);
421 GID_TO_CHARS (getgid (), header
->header
.gid
);
422 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
423 MINOR_TO_CHARS (0, header
->header
.devminor
);
424 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
425 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
429 /* Create a new header and store there at most NAME_FIELD_SIZE bytes of
433 write_short_name (struct tar_stat_info
*st
)
435 union block
*header
= find_next_block ();
436 memset (header
->buffer
, 0, sizeof (union block
));
437 tar_name_copy_str (header
->header
.name
, st
->file_name
, NAME_FIELD_SIZE
);
441 #define FILL(field,byte) do { \
442 memset(field, byte, sizeof(field)-1); \
443 (field)[sizeof(field)-1] = 0; \
446 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. */
448 write_gnu_long_link (struct tar_stat_info
*st
, const char *p
, char type
)
450 size_t size
= strlen (p
) + 1;
455 header
= start_private_header ("././@LongLink", size
);
456 FILL(header
->header
.mtime
, '0');
457 FILL(header
->header
.mode
, '0');
458 FILL(header
->header
.uid
, '0');
459 FILL(header
->header
.gid
, '0');
460 FILL(header
->header
.devmajor
, 0);
461 FILL(header
->header
.devminor
, 0);
462 uid_to_uname (0, &tmpname
);
463 UNAME_TO_CHARS (tmpname
, header
->header
.uname
);
465 gid_to_gname (0, &tmpname
);
466 GNAME_TO_CHARS (tmpname
, header
->header
.gname
);
469 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
470 header
->header
.typeflag
= type
;
471 finish_header (st
, header
, -1);
473 header
= find_next_block ();
475 bufsize
= available_space_after (header
);
477 while (bufsize
< size
)
479 memcpy (header
->buffer
, p
, bufsize
);
482 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
483 header
= find_next_block ();
484 bufsize
= available_space_after (header
);
486 memcpy (header
->buffer
, p
, size
);
487 memset (header
->buffer
+ size
, 0, bufsize
- size
);
488 set_next_block_after (header
+ (size
- 1) / BLOCKSIZE
);
492 split_long_name (const char *name
, size_t length
)
496 if (length
> PREFIX_FIELD_SIZE
)
497 length
= PREFIX_FIELD_SIZE
+ 1;
498 for (i
= length
- 1; i
> 0; i
--)
499 if (ISSLASH (name
[i
]))
505 write_ustar_long_name (const char *name
)
507 size_t length
= strlen (name
);
511 if (length
> PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1)
513 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
514 quotearg_colon (name
),
515 PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1));
519 i
= split_long_name (name
, length
);
520 if (i
== 0 || length
- i
- 1 > NAME_FIELD_SIZE
)
523 _("%s: file name is too long (cannot be split); not dumped"),
524 quotearg_colon (name
)));
528 header
= find_next_block ();
529 memset (header
->buffer
, 0, sizeof (header
->buffer
));
530 memcpy (header
->header
.prefix
, name
, i
);
531 memcpy (header
->header
.name
, name
+ i
+ 1, length
- i
- 1);
536 /* Write a long link name, depending on the current archive format */
538 write_long_link (struct tar_stat_info
*st
)
540 switch (archive_format
)
543 xheader_store ("linkpath", st
, NULL
);
546 case V7_FORMAT
: /* old V7 tar format */
550 _("%s: link name is too long; not dumped"),
551 quotearg_colon (st
->link_name
)));
556 write_gnu_long_link (st
, st
->link_name
, GNUTYPE_LONGLINK
);
565 write_long_name (struct tar_stat_info
*st
)
567 switch (archive_format
)
570 xheader_store ("path", st
, NULL
);
574 if (strlen (st
->file_name
) > NAME_FIELD_SIZE
-1)
576 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
577 quotearg_colon (st
->file_name
),
578 NAME_FIELD_SIZE
- 1));
585 return write_ustar_long_name (st
->file_name
);
589 write_gnu_long_link (st
, st
->file_name
, GNUTYPE_LONGNAME
);
595 return write_short_name (st
);
599 write_extended (bool global
, struct tar_stat_info
*st
, union block
*old_header
)
601 union block
*header
, hp
;
605 if (extended_header
.buffer
|| extended_header
.stk
== NULL
)
608 xheader_finish (&extended_header
);
609 memcpy (hp
.buffer
, old_header
, sizeof (hp
));
613 p
= xheader_ghdr_name ();
618 p
= xheader_xhdr_name (st
);
620 xheader_write (type
, p
, &extended_header
);
622 header
= find_next_block ();
623 memcpy (header
, &hp
.buffer
, sizeof (hp
.buffer
));
628 write_header_name (struct tar_stat_info
*st
)
630 if (archive_format
== POSIX_FORMAT
&& !string_ascii_p (st
->file_name
))
632 xheader_store ("path", st
, NULL
);
633 return write_short_name (st
);
635 else if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
)
636 < strlen (st
->file_name
))
637 return write_long_name (st
);
639 return write_short_name (st
);
643 /* Header handling. */
645 /* Make a header block for the file whose stat info is st,
646 and return its address. */
649 start_header (struct tar_stat_info
*st
)
653 header
= write_header_name (st
);
657 /* Override some stat fields, if requested to do so. */
659 if (owner_option
!= (uid_t
) -1)
660 st
->stat
.st_uid
= owner_option
;
661 if (group_option
!= (gid_t
) -1)
662 st
->stat
.st_gid
= group_option
;
665 ((st
->stat
.st_mode
& ~MODE_ALL
)
666 | mode_adjust (st
->stat
.st_mode
, mode_option
, initial_umask
));
668 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
669 for a few tars and came up with the following interoperability
673 1 2 3 4 5 6 7 8 9 READER
674 . . . . . . . . . 1 = SunOS 4.2 tar
675 # . . # # . . # # 2 = NEC SVR4.0.2 tar
676 . . . # # . . # . 3 = Solaris 2.1 tar
677 . . . . . . . . . 4 = GNU tar 1.11.1
678 . . . . . . . . . 5 = HP-UX 8.07 tar
679 . . . . . . . . . 6 = Ultrix 4.1
680 . . . . . . . . . 7 = AIX 3.2
681 . . . . . . . . . 8 = Hitachi HI-UX 1.03
682 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
685 # = ``impossible file type''
687 The following mask for old archive removes the `#'s in column 4
688 above, thus making GNU tar both a universal donor and a universal
689 acceptor for Paul's test. */
691 if (archive_format
== V7_FORMAT
|| archive_format
== USTAR_FORMAT
)
692 MODE_TO_CHARS (st
->stat
.st_mode
& MODE_ALL
, header
->header
.mode
);
694 MODE_TO_CHARS (st
->stat
.st_mode
, header
->header
.mode
);
697 uid_t uid
= st
->stat
.st_uid
;
698 if (archive_format
== POSIX_FORMAT
699 && MAX_OCTAL_VAL (header
->header
.uid
) < uid
)
701 xheader_store ("uid", st
, NULL
);
704 if (!UID_TO_CHARS (uid
, header
->header
.uid
))
709 gid_t gid
= st
->stat
.st_gid
;
710 if (archive_format
== POSIX_FORMAT
711 && MAX_OCTAL_VAL (header
->header
.gid
) < gid
)
713 xheader_store ("gid", st
, NULL
);
716 if (!GID_TO_CHARS (gid
, header
->header
.gid
))
721 off_t size
= st
->stat
.st_size
;
722 if (archive_format
== POSIX_FORMAT
723 && MAX_OCTAL_VAL (header
->header
.size
) < size
)
725 xheader_store ("size", st
, NULL
);
728 if (!OFF_TO_CHARS (size
, header
->header
.size
))
733 struct timespec mtime
= st
->mtime
;
734 if (archive_format
== POSIX_FORMAT
)
736 if (MAX_OCTAL_VAL (header
->header
.mtime
) < mtime
.tv_sec
737 || mtime
.tv_nsec
!= 0)
738 xheader_store ("mtime", st
, NULL
);
739 if (MAX_OCTAL_VAL (header
->header
.mtime
) < mtime
.tv_sec
)
742 if (!TIME_TO_CHARS (mtime
.tv_sec
, header
->header
.mtime
))
747 if (S_ISCHR (st
->stat
.st_mode
)
748 || S_ISBLK (st
->stat
.st_mode
))
750 major_t devmajor
= major (st
->stat
.st_rdev
);
751 minor_t devminor
= minor (st
->stat
.st_rdev
);
753 if (archive_format
== POSIX_FORMAT
754 && MAX_OCTAL_VAL (header
->header
.devmajor
) < devmajor
)
756 xheader_store ("devmajor", st
, NULL
);
759 if (!MAJOR_TO_CHARS (devmajor
, header
->header
.devmajor
))
762 if (archive_format
== POSIX_FORMAT
763 && MAX_OCTAL_VAL (header
->header
.devminor
) < devminor
)
765 xheader_store ("devminor", st
, NULL
);
768 if (!MINOR_TO_CHARS (devminor
, header
->header
.devminor
))
771 else if (archive_format
!= GNU_FORMAT
&& archive_format
!= OLDGNU_FORMAT
)
773 if (!(MAJOR_TO_CHARS (0, header
->header
.devmajor
)
774 && MINOR_TO_CHARS (0, header
->header
.devminor
)))
778 if (archive_format
== POSIX_FORMAT
)
780 xheader_store ("atime", st
, NULL
);
781 xheader_store ("ctime", st
, NULL
);
783 else if (incremental_option
)
784 if (archive_format
== OLDGNU_FORMAT
|| archive_format
== GNU_FORMAT
)
786 TIME_TO_CHARS (st
->atime
.tv_sec
, header
->oldgnu_header
.atime
);
787 TIME_TO_CHARS (st
->ctime
.tv_sec
, header
->oldgnu_header
.ctime
);
790 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
792 switch (archive_format
)
798 case GNU_FORMAT
: /*FIXME?*/
799 /* Overwrite header->header.magic and header.version in one blow. */
800 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
805 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
806 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
813 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
815 /* header->header.[ug]name are left as the empty string. */
819 uid_to_uname (st
->stat
.st_uid
, &st
->uname
);
820 gid_to_gname (st
->stat
.st_gid
, &st
->gname
);
822 if (archive_format
== POSIX_FORMAT
823 && (strlen (st
->uname
) > UNAME_FIELD_SIZE
824 || !string_ascii_p (st
->uname
)))
825 xheader_store ("uname", st
, NULL
);
826 UNAME_TO_CHARS (st
->uname
, header
->header
.uname
);
828 if (archive_format
== POSIX_FORMAT
829 && (strlen (st
->gname
) > GNAME_FIELD_SIZE
830 || !string_ascii_p (st
->gname
)))
831 xheader_store ("gname", st
, NULL
);
832 GNAME_TO_CHARS (st
->gname
, header
->header
.gname
);
839 simple_finish_header (union block
*header
)
845 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
849 for (i
= sizeof *header
; i
-- != 0; )
850 /* We can't use unsigned char here because of old compilers, e.g. V7. */
853 /* Fill in the checksum field. It's formatted differently from the
854 other fields: it has [6] digits, a null, then a space -- rather than
855 digits, then a null. We use to_chars.
856 The final space is already there, from
857 checksumming, and to_chars doesn't modify it.
859 This is a fast way to do:
861 sprintf(header->header.chksum, "%6o", sum); */
863 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
865 set_next_block_after (header
);
868 /* Finish off a filled-in header block and write it out. We also
869 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
870 is not negative, is the block ordinal of the first record for this
871 file, which may be a preceding long name or long link record. */
873 finish_header (struct tar_stat_info
*st
,
874 union block
*header
, off_t block_ordinal
)
876 /* Note: It is important to do this before the call to write_extended(),
877 so that the actual ustar header is printed */
879 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
880 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
881 && header
->header
.typeflag
!= XHDTYPE
882 && header
->header
.typeflag
!= XGLTYPE
)
884 /* These globals are parameters to print_header, sigh. */
886 current_header
= header
;
887 current_format
= archive_format
;
888 print_header (st
, block_ordinal
);
891 header
= write_extended (false, st
, header
);
892 simple_finish_header (header
);
897 pad_archive (off_t size_left
)
900 while (size_left
> 0)
902 mv_size_left (size_left
);
903 blk
= find_next_block ();
904 memset (blk
->buffer
, 0, BLOCKSIZE
);
905 set_next_block_after (blk
);
906 size_left
-= BLOCKSIZE
;
910 static enum dump_status
911 dump_regular_file (int fd
, struct tar_stat_info
*st
)
913 off_t size_left
= st
->stat
.st_size
;
917 block_ordinal
= current_block_ordinal ();
918 blk
= start_header (st
);
920 return dump_status_fail
;
922 /* Mark contiguous files, if we support them. */
923 if (archive_format
!= V7_FORMAT
&& S_ISCTG (st
->stat
.st_mode
))
924 blk
->header
.typeflag
= CONTTYPE
;
926 finish_header (st
, blk
, block_ordinal
);
929 while (size_left
> 0)
931 size_t bufsize
, count
;
933 mv_size_left (size_left
);
935 blk
= find_next_block ();
937 bufsize
= available_space_after (blk
);
939 if (size_left
< bufsize
)
941 /* Last read -- zero out area beyond. */
943 count
= bufsize
% BLOCKSIZE
;
945 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
948 count
= (fd
< 0) ? bufsize
: safe_read (fd
, blk
->buffer
, bufsize
);
949 if (count
== SAFE_READ_ERROR
)
951 read_diag_details (st
->orig_file_name
,
952 st
->stat
.st_size
- size_left
, bufsize
);
953 pad_archive (size_left
);
954 return dump_status_short
;
958 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
960 if (count
!= bufsize
)
962 char buf
[UINTMAX_STRSIZE_BOUND
];
963 memset (blk
->buffer
+ count
, 0, bufsize
- count
);
965 ngettext ("%s: File shrank by %s byte; padding with zeros",
966 "%s: File shrank by %s bytes; padding with zeros",
968 quotearg_colon (st
->orig_file_name
),
969 STRINGIFY_BIGINT (size_left
, buf
)));
970 if (! ignore_failed_read_option
)
971 exit_status
= TAREXIT_FAILURE
;
972 pad_archive (size_left
- (bufsize
-count
));
973 return dump_status_short
;
976 return dump_status_ok
;
979 /* Look in directory DIRNAME for a cache directory tag file
980 with the magic name "CACHEDIR.TAG" and a standard header,
982 http://www.brynosaurus.com/cachedir
983 Applications can write this file into directories they create
984 for use as caches containing purely regenerable, non-precious data,
985 allowing us to avoid archiving them if --exclude-caches is specified. */
987 #define CACHEDIR_SIGNATURE "Signature: 8a477f597d28d172789f06886806bc55"
988 #define CACHEDIR_SIGNATURE_SIZE (sizeof CACHEDIR_SIGNATURE - 1)
991 check_cache_directory (char *dirname
)
993 static char tagname
[] = "CACHEDIR.TAG";
996 int tag_present
= false;
998 tagpath
= xmalloc (strlen (dirname
) + strlen (tagname
) + 1);
999 strcpy (tagpath
, dirname
);
1000 strcat (tagpath
, tagname
);
1002 fd
= open (tagpath
, O_RDONLY
);
1005 static char tagbuf
[CACHEDIR_SIGNATURE_SIZE
];
1007 if (read (fd
, tagbuf
, CACHEDIR_SIGNATURE_SIZE
)
1008 == CACHEDIR_SIGNATURE_SIZE
1009 && memcmp (tagbuf
, CACHEDIR_SIGNATURE
, CACHEDIR_SIGNATURE_SIZE
) == 0)
1021 dump_dir0 (char *directory
,
1022 struct tar_stat_info
*st
, int top_level
, dev_t parent_device
)
1024 dev_t our_device
= st
->stat
.st_dev
;
1026 if (!is_avoided_name (st
->orig_file_name
))
1028 union block
*blk
= NULL
;
1029 off_t block_ordinal
= current_block_ordinal ();
1030 st
->stat
.st_size
= 0; /* force 0 size on dir */
1032 blk
= start_header (st
);
1036 if (incremental_option
&& archive_format
!= POSIX_FORMAT
)
1037 blk
->header
.typeflag
= GNUTYPE_DUMPDIR
;
1038 else /* if (standard_option) */
1039 blk
->header
.typeflag
= DIRTYPE
;
1041 /* If we're gnudumping, we aren't done yet so don't close it. */
1043 if (!incremental_option
)
1044 finish_header (st
, blk
, block_ordinal
);
1045 else if (gnu_list_name
->dir_contents
)
1047 if (archive_format
== POSIX_FORMAT
)
1049 xheader_store ("GNU.dumpdir", st
, gnu_list_name
->dir_contents
);
1050 finish_header (st
, blk
, block_ordinal
);
1058 const char *buffer
, *p_buffer
;
1060 block_ordinal
= current_block_ordinal ();
1061 buffer
= gnu_list_name
->dir_contents
;
1063 totsize
= dumpdir_size (buffer
);
1066 OFF_TO_CHARS (totsize
, blk
->header
.size
);
1067 finish_header (st
, blk
, block_ordinal
);
1069 size_left
= totsize
;
1072 mv_total_size (totsize
);
1073 while (size_left
> 0)
1075 mv_size_left (size_left
);
1076 blk
= find_next_block ();
1077 bufsize
= available_space_after (blk
);
1078 if (size_left
< bufsize
)
1080 bufsize
= size_left
;
1081 count
= bufsize
% BLOCKSIZE
;
1083 memset (blk
->buffer
+ size_left
, 0, BLOCKSIZE
- count
);
1085 memcpy (blk
->buffer
, p_buffer
, bufsize
);
1086 size_left
-= bufsize
;
1087 p_buffer
+= bufsize
;
1088 set_next_block_after (blk
+ (bufsize
- 1) / BLOCKSIZE
);
1096 if (!recursion_option
)
1099 if (one_file_system_option
1101 && parent_device
!= st
->stat
.st_dev
)
1105 _("%s: file is on a different filesystem; not dumped"),
1106 quotearg_colon (st
->orig_file_name
)));
1110 if (exclude_caches_option
1111 && check_cache_directory(st
->orig_file_name
))
1115 _("%s: contains a cache directory tag; not dumped"),
1116 quotearg_colon (st
->orig_file_name
)));
1123 char *name_buf
= xstrdup (st
->orig_file_name
);
1124 size_t name_size
= strlen (name_buf
);
1125 size_t name_len
= name_size
;
1127 /* Now output all the files in the directory. */
1128 /* FIXME: Should speed this up by cd-ing into the dir. */
1130 for (entry
= directory
; (entry_len
= strlen (entry
)) != 0;
1131 entry
+= entry_len
+ 1)
1133 if (name_size
< name_len
+ entry_len
)
1135 name_size
= name_len
+ entry_len
;
1136 name_buf
= xrealloc (name_buf
, name_size
+ 1);
1138 strcpy (name_buf
+ name_len
, entry
);
1139 if (!excluded_name (name_buf
))
1140 dump_file (name_buf
, 0, our_device
);
1147 /* Ensure exactly one trailing slash. */
1149 ensure_slash (char **pstr
)
1151 size_t len
= strlen (*pstr
);
1152 while (len
>= 1 && ISSLASH ((*pstr
)[len
- 1]))
1154 if (!ISSLASH ((*pstr
)[len
]))
1155 *pstr
= xrealloc (*pstr
, len
+ 2);
1156 (*pstr
)[len
++] = '/';
1157 (*pstr
)[len
] = '\0';
1161 dump_dir (int fd
, struct tar_stat_info
*st
, int top_level
, dev_t parent_device
)
1163 char *directory
= fdsavedir (fd
);
1166 savedir_diag (st
->orig_file_name
);
1170 ensure_slash (&st
->orig_file_name
);
1171 ensure_slash (&st
->file_name
);
1173 dump_dir0 (directory
, st
, top_level
, parent_device
);
1180 /* Main functions of this module. */
1183 create_archive (void)
1187 open_archive (ACCESS_WRITE
);
1188 xheader_write_global ();
1190 if (incremental_option
)
1192 size_t buffer_size
= 1000;
1193 char *buffer
= xmalloc (buffer_size
);
1196 collect_and_sort_names ();
1198 while ((p
= name_from_list ()) != NULL
)
1199 if (!excluded_name (p
))
1200 dump_file (p
, -1, (dev_t
) 0);
1203 while ((p
= name_from_list ()) != NULL
)
1204 if (!excluded_name (p
))
1206 size_t plen
= strlen (p
);
1207 if (buffer_size
<= plen
)
1209 while ((buffer_size
*= 2) <= plen
)
1211 buffer
= xrealloc (buffer
, buffer_size
);
1213 memcpy (buffer
, p
, plen
);
1214 if (! ISSLASH (buffer
[plen
- 1]))
1215 buffer
[plen
++] = '/';
1216 q
= gnu_list_name
->dir_contents
;
1220 size_t qlen
= strlen (q
);
1223 if (buffer_size
< plen
+ qlen
)
1225 while ((buffer_size
*=2 ) < plen
+ qlen
)
1227 buffer
= xrealloc (buffer
, buffer_size
);
1229 strcpy (buffer
+ plen
, q
+ 1);
1230 dump_file (buffer
, -1, (dev_t
) 0);
1239 while ((p
= name_next (1)) != NULL
)
1240 if (!excluded_name (p
))
1241 dump_file (p
, 1, (dev_t
) 0);
1247 if (listed_incremental_option
)
1248 write_directory_file ();
1252 /* Calculate the hash of a link. */
1254 hash_link (void const *entry
, size_t n_buckets
)
1256 struct link
const *l
= entry
;
1257 uintmax_t num
= l
->dev
^ l
->ino
;
1258 return num
% n_buckets
;
1261 /* Compare two links for equality. */
1263 compare_links (void const *entry1
, void const *entry2
)
1265 struct link
const *link1
= entry1
;
1266 struct link
const *link2
= entry2
;
1267 return ((link1
->dev
^ link2
->dev
) | (link1
->ino
^ link2
->ino
)) == 0;
1271 unknown_file_error (char const *p
)
1273 WARN ((0, 0, _("%s: Unknown file type; file ignored"),
1274 quotearg_colon (p
)));
1275 if (!ignore_failed_read_option
)
1276 exit_status
= TAREXIT_FAILURE
;
1280 /* Handling of hard links */
1282 /* Table of all non-directories that we've written so far. Any time
1283 we see another, we check the table and avoid dumping the data
1284 again if we've done it once already. */
1285 static Hash_table
*link_table
;
1287 /* Try to dump stat as a hard link to another file in the archive.
1288 Return true if successful. */
1290 dump_hard_link (struct tar_stat_info
*st
)
1292 if (link_table
&& st
->stat
.st_nlink
> 1)
1295 struct link
*duplicate
;
1296 off_t block_ordinal
;
1299 lp
.ino
= st
->stat
.st_ino
;
1300 lp
.dev
= st
->stat
.st_dev
;
1302 if ((duplicate
= hash_lookup (link_table
, &lp
)))
1304 /* We found a link. */
1305 char const *link_name
= safer_name_suffix (duplicate
->name
, true,
1306 absolute_names_option
);
1310 block_ordinal
= current_block_ordinal ();
1311 assign_string (&st
->link_name
, link_name
);
1312 if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
)
1313 < strlen (link_name
))
1314 write_long_link (st
);
1316 st
->stat
.st_size
= 0;
1317 blk
= start_header (st
);
1320 tar_copy_str (blk
->header
.linkname
, link_name
, NAME_FIELD_SIZE
);
1322 blk
->header
.typeflag
= LNKTYPE
;
1323 finish_header (st
, blk
, block_ordinal
);
1325 if (remove_files_option
&& unlink (st
->orig_file_name
) != 0)
1326 unlink_error (st
->orig_file_name
);
1335 file_count_links (struct tar_stat_info
*st
)
1337 if (st
->stat
.st_nlink
> 1)
1339 struct link
*duplicate
;
1340 struct link
*lp
= xmalloc (offsetof (struct link
, name
)
1341 + strlen (st
->orig_file_name
) + 1);
1342 lp
->ino
= st
->stat
.st_ino
;
1343 lp
->dev
= st
->stat
.st_dev
;
1344 lp
->nlink
= st
->stat
.st_nlink
;
1345 strcpy (lp
->name
, st
->orig_file_name
);
1348 || (link_table
= hash_initialize (0, 0, hash_link
,
1350 && (duplicate
= hash_insert (link_table
, lp
))))
1353 if (duplicate
!= lp
)
1359 /* For each dumped file, check if all its links were dumped. Emit
1360 warnings if it is not so. */
1369 for (lp
= hash_get_first (link_table
); lp
;
1370 lp
= hash_get_next (link_table
, lp
))
1374 WARN ((0, 0, _("Missing links to %s.\n"), quote (lp
->name
)));
1380 /* Dump a single file, recursing on directories. P is the file name
1381 to dump. TOP_LEVEL tells whether this is a top-level call; zero
1382 means no, positive means yes, and negative means the top level
1383 of an incremental dump. PARENT_DEVICE is the device of P's
1384 parent directory; it is examined only if TOP_LEVEL is zero. */
1386 /* FIXME: One should make sure that for *every* path leading to setting
1387 exit_status to failure, a clear diagnostic has been issued. */
1390 dump_file0 (struct tar_stat_info
*st
, const char *p
,
1391 int top_level
, dev_t parent_device
)
1393 union block
*header
;
1395 struct timespec original_ctime
;
1396 struct timespec restore_times
[2];
1397 off_t block_ordinal
= -1;
1400 if (interactive_option
&& !confirm ("add", p
))
1403 assign_string (&st
->orig_file_name
, p
);
1404 assign_string (&st
->file_name
,
1405 safer_name_suffix (p
, false, absolute_names_option
));
1407 transform_name (&st
->file_name
);
1409 if (deref_stat (dereference_option
, p
, &st
->stat
) != 0)
1414 st
->archive_file_size
= st
->stat
.st_size
;
1415 st
->atime
= restore_times
[0] = get_stat_atime (&st
->stat
);
1416 st
->mtime
= restore_times
[1] = get_stat_mtime (&st
->stat
);
1417 st
->ctime
= original_ctime
= get_stat_ctime (&st
->stat
);
1420 if (S_ISHIDDEN (st
->stat
.st_mode
))
1422 char *new = (char *) alloca (strlen (p
) + 2);
1432 /* See if we want only new files, and check if this one is too old to
1435 This check is omitted if incremental_option is set *and* the
1436 requested file is not explicitely listed in the command line. */
1438 if (!(incremental_option
&& !is_individual_file (p
))
1439 && !S_ISDIR (st
->stat
.st_mode
)
1440 && OLDER_TAR_STAT_TIME (*st
, m
)
1441 && (!after_date_option
|| OLDER_TAR_STAT_TIME (*st
, c
)))
1443 if (!incremental_option
&& verbose_option
)
1444 WARN ((0, 0, _("%s: file is unchanged; not dumped"),
1445 quotearg_colon (p
)));
1449 /* See if we are trying to dump the archive. */
1450 if (sys_file_is_archive (st
))
1452 WARN ((0, 0, _("%s: file is the archive; not dumped"),
1453 quotearg_colon (p
)));
1457 if (is_avoided_name (p
))
1460 is_dir
= S_ISDIR (st
->stat
.st_mode
) != 0;
1462 if (!is_dir
&& dump_hard_link (st
))
1465 if (is_dir
|| S_ISREG (st
->stat
.st_mode
) || S_ISCTG (st
->stat
.st_mode
))
1469 struct stat final_stat
;
1471 if (is_dir
|| file_dumpable_p (st
))
1474 (O_RDONLY
| O_BINARY
1475 | (is_dir
? O_DIRECTORY
| O_NONBLOCK
: 0)
1476 | (atime_preserve_option
== system_atime_preserve
1481 if (!top_level
&& errno
== ENOENT
)
1482 WARN ((0, 0, _("%s: File removed before we read it"),
1483 quotearg_colon (p
)));
1492 ok
= dump_dir (fd
, st
, top_level
, parent_device
);
1494 /* dump_dir consumes FD if successful. */
1500 enum dump_status status
;
1502 if (fd
!= -1 && sparse_option
&& sparse_file_p (st
))
1504 status
= sparse_dump_file (fd
, st
);
1505 if (status
== dump_status_not_implemented
)
1506 status
= dump_regular_file (fd
, st
);
1509 status
= dump_regular_file (fd
, st
);
1513 case dump_status_ok
:
1514 case dump_status_short
:
1518 case dump_status_fail
:
1521 case dump_status_not_implemented
:
1525 file_count_links (st
);
1527 ok
= status
== dump_status_ok
;
1532 /* If possible, reopen a directory if we are preserving
1533 atimes, so that we can set just the atime on systems with
1535 if (fd
< 0 && is_dir
1536 && atime_preserve_option
== replace_atime_preserve
)
1537 fd
= open (p
, O_RDONLY
| O_BINARY
| O_DIRECTORY
| O_NONBLOCK
);
1540 ? deref_stat (dereference_option
, p
, &final_stat
)
1541 : fstat (fd
, &final_stat
))
1551 if (timespec_cmp (get_stat_ctime (&final_stat
), original_ctime
) != 0)
1552 WARN ((0, 0, _("%s: file changed as we read it"),
1553 quotearg_colon (p
)));
1554 else if (atime_preserve_option
== replace_atime_preserve
1555 && set_file_atime (fd
, p
, restore_times
) != 0)
1559 if (0 <= fd
&& close (fd
) != 0)
1565 if (ok
&& remove_files_option
)
1569 if (rmdir (p
) != 0 && errno
!= ENOTEMPTY
)
1574 if (unlink (p
) != 0)
1581 #ifdef HAVE_READLINK
1582 else if (S_ISLNK (st
->stat
.st_mode
))
1586 size_t linklen
= st
->stat
.st_size
;
1587 if (linklen
!= st
->stat
.st_size
|| linklen
+ 1 == 0)
1589 buffer
= (char *) alloca (linklen
+ 1);
1590 size
= readlink (p
, buffer
, linklen
+ 1);
1596 buffer
[size
] = '\0';
1597 assign_string (&st
->link_name
, buffer
);
1598 if (NAME_FIELD_SIZE
- (archive_format
== OLDGNU_FORMAT
) < size
)
1599 write_long_link (st
);
1601 block_ordinal
= current_block_ordinal ();
1602 st
->stat
.st_size
= 0; /* force 0 size on symlink */
1603 header
= start_header (st
);
1606 tar_copy_str (header
->header
.linkname
, buffer
, NAME_FIELD_SIZE
);
1607 header
->header
.typeflag
= SYMTYPE
;
1608 finish_header (st
, header
, block_ordinal
);
1609 /* nothing more to do to it */
1611 if (remove_files_option
)
1613 if (unlink (p
) == -1)
1616 file_count_links (st
);
1620 else if (S_ISCHR (st
->stat
.st_mode
))
1622 else if (S_ISBLK (st
->stat
.st_mode
))
1624 else if (S_ISFIFO (st
->stat
.st_mode
))
1626 else if (S_ISSOCK (st
->stat
.st_mode
))
1628 WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1631 else if (S_ISDOOR (st
->stat
.st_mode
))
1633 WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1638 unknown_file_error (p
);
1642 if (archive_format
== V7_FORMAT
)
1644 unknown_file_error (p
);
1648 block_ordinal
= current_block_ordinal ();
1649 st
->stat
.st_size
= 0; /* force 0 size */
1650 header
= start_header (st
);
1653 header
->header
.typeflag
= type
;
1655 if (type
!= FIFOTYPE
)
1657 MAJOR_TO_CHARS (major (st
->stat
.st_rdev
),
1658 header
->header
.devmajor
);
1659 MINOR_TO_CHARS (minor (st
->stat
.st_rdev
),
1660 header
->header
.devminor
);
1663 finish_header (st
, header
, block_ordinal
);
1664 if (remove_files_option
)
1666 if (unlink (p
) == -1)
1672 dump_file (const char *p
, int top_level
, dev_t parent_device
)
1674 struct tar_stat_info st
;
1675 tar_stat_init (&st
);
1676 dump_file0 (&st
, p
, top_level
, parent_device
);
1677 if (listed_incremental_option
)
1678 update_parent_directory (p
);
1679 tar_stat_destroy (&st
);