1 /* Create a tar archive.
2 Copyright 1985, 92, 93, 94, 96, 97, 99, 2000 Free Software Foundation, Inc.
3 Written by John Gilmore, on 1985-08-25.
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 2, or (at your option) any later
10 This program is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
13 Public License for more details.
15 You should have received a copy of the GNU General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
45 extern struct name
*gnu_list_name
;
47 /* This module is the only one that cares about `struct link's. */
57 static struct link
*linklist
; /* points to first link in list */
59 /* The maximum uintmax_t value that can be represented with DIGITS digits,
60 assuming that each digit is BITS_PER_DIGIT wide. */
61 #define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
62 ((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
63 ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
66 /* Convert VALUE to an octal representation suitable for tar headers.
67 Output to buffer WHERE with size SIZE.
68 The result is undefined if SIZE is 0 or if VALUE is too large to fit. */
71 to_octal (uintmax_t value
, char *where
, size_t size
)
78 where
[--i
] = '0' + (v
& ((1 << LG_8
) - 1));
84 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
85 tar headers. NEGATIVE is 1 if VALUE was negative before being cast
86 to uintmax_t, 0 otherwise. Output to buffer WHERE with size SIZE.
87 The result is undefined if SIZE is 0 or if VALUE is too large to
91 to_base256 (int negative
, uintmax_t value
, char *where
, size_t size
)
94 uintmax_t propagated_sign_bits
=
95 ((uintmax_t) - negative
<< (CHAR_BIT
* sizeof v
- LG_256
));
100 where
[--i
] = v
& ((1 << LG_256
) - 1);
101 v
= propagated_sign_bits
| (v
>> LG_256
);
106 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
107 external form, using SUBSTITUTE (...) if VALUE won't fit. Output
108 to buffer WHERE with size SIZE. NEGATIVE is 1 iff VALUE was
109 negative before being cast to uintmax_t; its original bitpattern
110 can be deduced from VALSIZE, its original size before casting.
111 TYPE is the kind of value being output (useful for diagnostics).
112 Prefer the POSIX format of SIZE - 1 octal digits (with leading zero
113 digits), followed by '\0'. If this won't work, and if GNU or
114 OLDGNU format is allowed, use '\200' followed by base-256, or (if
115 NEGATIVE is nonzero) '\377' followed by two's complement base-256.
116 If neither format works, use SUBSTITUTE (...) instead. Pass to
117 SUBSTITUTE the address of an 0-or-1 flag recording whether the
118 substitute value is negative. */
121 to_chars (int negative
, uintmax_t value
, size_t valsize
,
122 uintmax_t (*substitute
) PARAMS ((int *)),
123 char *where
, size_t size
, const char *type
)
125 int base256_allowed
= (archive_format
== GNU_FORMAT
126 || archive_format
== OLDGNU_FORMAT
);
128 /* Generate the POSIX octal representation if the number fits. */
129 if (! negative
&& value
<= MAX_VAL_WITH_DIGITS (size
- 1, LG_8
))
131 where
[size
- 1] = '\0';
132 to_octal (value
, where
, size
- 1);
135 /* Otherwise, generate the base-256 representation if we are
136 generating an old or new GNU format and if the number fits. */
137 else if (((negative
? -1 - value
: value
)
138 <= MAX_VAL_WITH_DIGITS (size
- 1, LG_256
))
141 where
[0] = negative
? -1 : 1 << (LG_256
- 1);
142 to_base256 (negative
, value
, where
+ 1, size
- 1);
145 /* Otherwise, if the number is negative, and if it would not cause
146 ambiguity on this host by confusing positive with negative
147 values, then generate the POSIX octal representation of the value
148 modulo 2**(field bits). The resulting tar file is
149 machine-dependent, since it depends on the host word size. Yuck!
150 But this is the traditional behavior. */
151 else if (negative
&& valsize
* CHAR_BIT
<= (size
- 1) * LG_8
)
153 static int warned_once
;
157 WARN ((0, 0, _("Generating negative octal headers")));
159 where
[size
- 1] = '\0';
160 to_octal (value
& MAX_VAL_WITH_DIGITS (valsize
* CHAR_BIT
, 1),
164 /* Otherwise, output a substitute value if possible (with a
165 warning), and an error message if not. */
168 uintmax_t maxval
= (base256_allowed
169 ? MAX_VAL_WITH_DIGITS (size
- 1, LG_256
)
170 : MAX_VAL_WITH_DIGITS (size
- 1, LG_8
));
171 char valbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
172 char maxbuf
[UINTMAX_STRSIZE_BOUND
];
173 char minbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
174 char const *minval_string
;
175 char const *maxval_string
= STRINGIFY_BIGINT (maxval
, maxbuf
);
176 char const *value_string
;
180 uintmax_t m
= maxval
+ 1 ? maxval
+ 1 : maxval
/ 2 + 1;
181 char *p
= STRINGIFY_BIGINT (m
, minbuf
+ 1);
190 char *p
= STRINGIFY_BIGINT (- value
, valbuf
+ 1);
195 value_string
= STRINGIFY_BIGINT (value
, valbuf
);
200 uintmax_t sub
= substitute (&negsub
) & maxval
;
201 uintmax_t s
= (negsub
&= archive_format
== GNU_FORMAT
) ? - sub
: sub
;
202 char subbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
203 char *sub_string
= STRINGIFY_BIGINT (s
, subbuf
+ 1);
206 WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
207 value_string
, type
, minval_string
, maxval_string
,
209 to_chars (negsub
, s
, valsize
, 0, where
, size
, type
);
212 ERROR ((0, 0, _("value %s out of %s range %s..%s"),
213 value_string
, type
, minval_string
, maxval_string
));
218 gid_substitute (int *negative
)
224 static gid_t gid_nobody
;
225 if (!gid_nobody
&& !gname_to_gid ("nobody", &gid_nobody
))
234 gid_to_chars (gid_t v
, char *p
, size_t s
)
236 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, gid_substitute
, p
, s
, "gid_t");
240 major_to_chars (major_t v
, char *p
, size_t s
)
242 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "major_t");
246 minor_to_chars (minor_t v
, char *p
, size_t s
)
248 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "minor_t");
252 mode_to_chars (mode_t v
, char *p
, size_t s
)
254 /* In the common case where the internal and external mode bits are the same,
255 and we are not using POSIX or GNU format,
256 propagate all unknown bits to the external mode.
257 This matches historical practice.
258 Otherwise, just copy the bits we know about. */
261 if (S_ISUID
== TSUID
&& S_ISGID
== TSGID
&& S_ISVTX
== TSVTX
262 && S_IRUSR
== TUREAD
&& S_IWUSR
== TUWRITE
&& S_IXUSR
== TUEXEC
263 && S_IRGRP
== TGREAD
&& S_IWGRP
== TGWRITE
&& S_IXGRP
== TGEXEC
264 && S_IROTH
== TOREAD
&& S_IWOTH
== TOWRITE
&& S_IXOTH
== TOEXEC
265 && archive_format
!= POSIX_FORMAT
266 && archive_format
!= GNU_FORMAT
)
274 u
= ((v
& S_ISUID
? TSUID
: 0)
275 | (v
& S_ISGID
? TSGID
: 0)
276 | (v
& S_ISVTX
? TSVTX
: 0)
277 | (v
& S_IRUSR
? TUREAD
: 0)
278 | (v
& S_IWUSR
? TUWRITE
: 0)
279 | (v
& S_IXUSR
? TUEXEC
: 0)
280 | (v
& S_IRGRP
? TGREAD
: 0)
281 | (v
& S_IWGRP
? TGWRITE
: 0)
282 | (v
& S_IXGRP
? TGEXEC
: 0)
283 | (v
& S_IROTH
? TOREAD
: 0)
284 | (v
& S_IWOTH
? TOWRITE
: 0)
285 | (v
& S_IXOTH
? TOEXEC
: 0));
287 to_chars (negative
, u
, sizeof v
, 0, p
, s
, "mode_t");
291 off_to_chars (off_t v
, char *p
, size_t s
)
293 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "off_t");
297 size_to_chars (size_t v
, char *p
, size_t s
)
299 to_chars (0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "size_t");
303 time_to_chars (time_t v
, char *p
, size_t s
)
305 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "time_t");
309 uid_substitute (int *negative
)
315 static uid_t uid_nobody
;
316 if (!uid_nobody
&& !uname_to_uid ("nobody", &uid_nobody
))
325 uid_to_chars (uid_t v
, char *p
, size_t s
)
327 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, uid_substitute
, p
, s
, "uid_t");
331 uintmax_to_chars (uintmax_t v
, char *p
, size_t s
)
333 to_chars (0, v
, sizeof v
, 0, p
, s
, "uintmax_t");
336 /* Writing routines. */
338 /*-----------------------------------------------------------------------.
339 | Just zeroes out the buffer so we don't confuse ourselves with leftover |
341 `-----------------------------------------------------------------------*/
344 clear_buffer (char *buffer
)
346 memset (buffer
, 0, BLOCKSIZE
);
349 /*-------------------------------------------------------------------------.
350 | Write the EOT block(s). We zero at least two blocks, through |
351 | the end of the record. Old tar, as previous versions of GNU tar, writes |
352 | garbage after two zeroed blocks. |
353 `-------------------------------------------------------------------------*/
358 union block
*pointer
= find_next_block ();
359 memset (pointer
->buffer
, 0, BLOCKSIZE
);
360 set_next_block_after (pointer
);
361 pointer
= find_next_block ();
362 memset (pointer
->buffer
, 0, available_space_after (pointer
));
363 set_next_block_after (pointer
);
366 /*-----------------------------------------------------.
367 | Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. |
368 `-----------------------------------------------------*/
370 /* FIXME: Cross recursion between start_header and write_long! */
372 static union block
*start_header
PARAMS ((const char *, struct stat
*));
375 write_long (const char *p
, char type
)
377 size_t size
= strlen (p
) + 1;
382 memset (&foo
, 0, sizeof foo
);
385 header
= start_header ("././@LongLink", &foo
);
386 header
->header
.typeflag
= type
;
387 finish_header (header
);
389 header
= find_next_block ();
391 bufsize
= available_space_after (header
);
393 while (bufsize
< size
)
395 memcpy (header
->buffer
, p
, bufsize
);
398 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
399 header
= find_next_block ();
400 bufsize
= available_space_after (header
);
402 memcpy (header
->buffer
, p
, size
);
403 memset (header
->buffer
+ size
, 0, bufsize
- size
);
404 set_next_block_after (header
+ (size
- 1) / BLOCKSIZE
);
407 /* Header handling. */
409 /* Make a header block for the file whose stat info is st,
410 and return its address. */
413 start_header (const char *name
, struct stat
*st
)
417 if (!absolute_names_option
)
419 size_t prefix_len
= FILESYSTEM_PREFIX_LEN (name
);
423 static int warned_once
;
427 WARN ((0, 0, _("Removing `%.*s' prefix from member names"),
428 (int) prefix_len
, name
));
435 static int warned_once
;
439 WARN ((0, 0, _("Removing leading `/' from member names")));
445 static int warned_once
;
446 if (! warned_once
&& contains_dot_dot (name
))
449 WARN ((0, 0, _("Member names contain `..'")));
454 if (sizeof header
->header
.name
<= strlen (name
))
455 write_long (name
, GNUTYPE_LONGNAME
);
456 header
= find_next_block ();
457 memset (header
->buffer
, 0, sizeof (union block
));
459 assign_string (¤t_file_name
, name
);
461 strncpy (header
->header
.name
, name
, NAME_FIELD_SIZE
);
462 header
->header
.name
[NAME_FIELD_SIZE
- 1] = '\0';
464 /* Override some stat fields, if requested to do so. */
466 if (owner_option
!= (uid_t
) -1)
467 st
->st_uid
= owner_option
;
468 if (group_option
!= (gid_t
) -1)
469 st
->st_gid
= group_option
;
471 st
->st_mode
= ((st
->st_mode
& ~MODE_ALL
)
472 | mode_adjust (st
->st_mode
, mode_option
));
474 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
475 for a few tars and came up with the following interoperability
479 1 2 3 4 5 6 7 8 9 READER
480 . . . . . . . . . 1 = SunOS 4.2 tar
481 # . . # # . . # # 2 = NEC SVR4.0.2 tar
482 . . . # # . . # . 3 = Solaris 2.1 tar
483 . . . . . . . . . 4 = GNU tar 1.11.1
484 . . . . . . . . . 5 = HP-UX 8.07 tar
485 . . . . . . . . . 6 = Ultrix 4.1
486 . . . . . . . . . 7 = AIX 3.2
487 . . . . . . . . . 8 = Hitachi HI-UX 1.03
488 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
491 # = ``impossible file type''
493 The following mask for old archive removes the `#'s in column 4
494 above, thus making GNU tar both a universal donor and a universal
495 acceptor for Paul's test. */
497 if (archive_format
== V7_FORMAT
)
498 MODE_TO_CHARS (st
->st_mode
& MODE_ALL
, header
->header
.mode
);
500 MODE_TO_CHARS (st
->st_mode
, header
->header
.mode
);
502 UID_TO_CHARS (st
->st_uid
, header
->header
.uid
);
503 GID_TO_CHARS (st
->st_gid
, header
->header
.gid
);
504 OFF_TO_CHARS (st
->st_size
, header
->header
.size
);
505 TIME_TO_CHARS (st
->st_mtime
, header
->header
.mtime
);
507 if (incremental_option
)
508 if (archive_format
== OLDGNU_FORMAT
)
510 TIME_TO_CHARS (st
->st_atime
, header
->oldgnu_header
.atime
);
511 TIME_TO_CHARS (st
->st_ctime
, header
->oldgnu_header
.ctime
);
514 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
516 switch (archive_format
)
522 /* Overwrite header->header.magic and header.version in one blow. */
523 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
528 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
529 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
536 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
538 /* header->header.[ug]name are left as the empty string. */
542 uid_to_uname (st
->st_uid
, header
->header
.uname
);
543 gid_to_gname (st
->st_gid
, header
->header
.gname
);
549 /*-------------------------------------------------------------------------.
550 | Finish off a filled-in header block and write it out. We also print the |
551 | file name and/or full info if verbose is on. |
552 `-------------------------------------------------------------------------*/
555 finish_header (union block
*header
)
561 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
565 for (i
= sizeof *header
; i
-- != 0; )
566 /* We can't use unsigned char here because of old compilers, e.g. V7. */
569 /* Fill in the checksum field. It's formatted differently from the
570 other fields: it has [6] digits, a null, then a space -- rather than
571 digits, then a null. We use to_chars.
572 The final space is already there, from
573 checksumming, and to_chars doesn't modify it.
575 This is a fast way to do:
577 sprintf(header->header.chksum, "%6o", sum); */
579 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
582 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
583 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
)
585 /* These globals are parameters to print_header, sigh. */
587 current_header
= header
;
588 /* current_stat is already set up. */
589 current_format
= archive_format
;
593 set_next_block_after (header
);
596 /* Sparse file processing. */
598 /*-------------------------------------------------------------------------.
599 | Takes a blockful of data and basically cruises through it to see if it's |
600 | made *entirely* of zeros, returning a 0 the instant it finds something |
601 | that is a nonzero, i.e., useful data. |
602 `-------------------------------------------------------------------------*/
605 zero_block_p (char *buffer
)
609 for (counter
= 0; counter
< BLOCKSIZE
; counter
++)
610 if (buffer
[counter
] != '\0')
620 init_sparsearray (void)
626 /* Make room for our scratch space -- initially is 10 elts long. */
628 sparsearray
= xmalloc (sp_array_size
* sizeof (struct sp_array
));
629 for (counter
= 0; counter
< sp_array_size
; counter
++)
631 sparsearray
[counter
].offset
= 0;
632 sparsearray
[counter
].numbytes
= 0;
641 find_new_file_size (int sparses
)
645 for (i
= 0; i
< sparses
; i
++)
646 s
+= sparsearray
[i
].numbytes
;
650 /*-----------------------------------------------------------------------.
651 | Make one pass over the file NAME, studying where any non-zero data is, |
652 | that is, how far into the file each instance of data is, and how many |
653 | bytes are there. Save this information in the sparsearray, which will |
654 | later be translated into header information. |
655 `-----------------------------------------------------------------------*/
657 /* There is little point in trimming small amounts of null data at the head
658 and tail of blocks, only avoid dumping full null blocks. */
660 /* FIXME: this routine might accept bits of algorithmic cleanup, it is
661 too kludgey for my taste... */
664 deal_with_sparse (char *name
, union block
*header
)
671 char buffer
[BLOCKSIZE
];
673 if (archive_format
== OLDGNU_FORMAT
)
674 header
->oldgnu_header
.isextended
= 0;
676 if (file
= open (name
, O_RDONLY
), file
< 0)
677 /* This problem will be caught later on, so just return. */
681 clear_buffer (buffer
);
683 while (0 < (count
= safe_read (file
, buffer
, sizeof buffer
)))
685 /* Realloc the scratch area as necessary. FIXME: should reallocate
686 only at beginning of a new instance of non-zero data. */
688 if (sp_array_size
<= sparses
)
691 xrealloc (sparsearray
,
692 2 * sp_array_size
* sizeof (struct sp_array
));
696 /* Process one block. */
698 if (count
== sizeof buffer
)
700 if (zero_block_p (buffer
))
704 sparsearray
[sparses
++].numbytes
= numbytes
;
711 sparsearray
[sparses
].offset
= offset
;
717 /* Since count < sizeof buffer, we have the last bit of the file. */
719 if (!zero_block_p (buffer
))
722 sparsearray
[sparses
].offset
= offset
;
726 /* The next two lines are suggested by Andreas Degert, who says
727 they are required for trailing full blocks to be written to the
728 archive, when all zeroed. Yet, it seems to me that the case
729 does not apply. Further, at restore time, the file is not as
730 sparse as it should. So, some serious cleanup is *also* needed
731 in this area. Just one more... :-(. FIXME. */
735 /* Prepare for next block. */
738 /* FIXME: do not clear unless necessary. */
739 clear_buffer (buffer
);
743 sparsearray
[sparses
++].numbytes
= numbytes
;
746 sparsearray
[sparses
].offset
= offset
- 1;
747 sparsearray
[sparses
++].numbytes
= 1;
751 return count
< 0 ? 0 : sparses
;
759 finish_sparse_file (int file
, off_t
*sizeleft
, off_t fullsize
, char *name
)
766 while (*sizeleft
> 0)
768 start
= find_next_block ();
769 memset (start
->buffer
, 0, BLOCKSIZE
);
770 bufsize
= sparsearray
[sparses
].numbytes
;
774 if (lseek (file
, sparsearray
[sparses
++].offset
, SEEK_SET
) < 0)
776 (ignore_failed_read_option
? seek_warn_details
: seek_error_details
)
777 (name
, sparsearray
[sparses
- 1].offset
);
781 /* If the number of bytes to be written here exceeds the size of
782 the temporary buffer, do it in steps. */
784 while (bufsize
> BLOCKSIZE
)
786 count
= safe_read (file
, start
->buffer
, BLOCKSIZE
);
789 (ignore_failed_read_option
791 : read_error_details
)
792 (name
, fullsize
- *sizeleft
, bufsize
);
797 set_next_block_after (start
);
798 start
= find_next_block ();
799 memset (start
->buffer
, 0, BLOCKSIZE
);
803 char buffer
[BLOCKSIZE
];
805 clear_buffer (buffer
);
806 count
= safe_read (file
, buffer
, bufsize
);
807 memcpy (start
->buffer
, buffer
, BLOCKSIZE
);
812 (ignore_failed_read_option
814 : read_error_details
)
815 (name
, fullsize
- *sizeleft
, bufsize
);
820 set_next_block_after (start
);
824 set_next_block_after (start
+ (count
- 1) / BLOCKSIZE
);
829 /* Main functions of this module. */
836 create_archive (void)
840 open_archive (ACCESS_WRITE
);
842 if (incremental_option
)
844 char *buffer
= xmalloc (PATH_MAX
);
848 collect_and_sort_names ();
850 while (p
= name_from_list (), p
)
851 if (!excluded_name (p
))
852 dump_file (p
, -1, (dev_t
) 0);
855 while (p
= name_from_list (), p
)
856 if (!excluded_name (p
))
859 if (p
[strlen (p
) - 1] != '/')
860 strcat (buffer
, "/");
861 bufp
= buffer
+ strlen (buffer
);
862 q
= gnu_list_name
->dir_contents
;
864 for (; *q
; q
+= strlen (q
) + 1)
867 strcpy (bufp
, q
+ 1);
868 dump_file (buffer
, -1, (dev_t
) 0);
875 while (p
= name_next (1), p
)
876 if (!excluded_name (p
))
877 dump_file (p
, 1, (dev_t
) 0);
883 if (listed_incremental_option
)
884 write_directory_file ();
887 /* Dump a single file, recursing on directories. P is the file name
888 to dump. TOP_LEVEL tells whether this is a top-level call; zero
889 means no, positive means yes, and negative means an incremental
890 dump. PARENT_DEVICE is the device of P's
891 parent directory; it is examined only if TOP_LEVEL is zero.
893 Set global CURRENT_STAT to stat output for this file. */
895 /* FIXME: One should make sure that for *every* path leading to setting
896 exit_status to failure, a clear diagnostic has been issued. */
899 dump_file (char *p
, int top_level
, dev_t parent_device
)
905 time_t original_ctime
;
906 struct utimbuf restore_times
;
908 /* FIXME: `header' and `sparses' might be used uninitialized in this
909 function. Reported by Bruno Haible. */
911 if (interactive_option
&& !confirm ("add", p
))
914 if (deref_stat (dereference_option
, p
, ¤t_stat
) != 0)
916 if (ignore_failed_read_option
)
923 original_ctime
= current_stat
.st_ctime
;
924 restore_times
.actime
= current_stat
.st_atime
;
925 restore_times
.modtime
= current_stat
.st_mtime
;
928 if (S_ISHIDDEN (current_stat
.st_mode
))
930 char *new = (char *) alloca (strlen (p
) + 2);
940 /* See if we want only new files, and check if this one is too old to
941 put in the archive. */
943 if ((0 < top_level
|| !incremental_option
)
944 && !S_ISDIR (current_stat
.st_mode
)
945 && current_stat
.st_mtime
< newer_mtime_option
946 && (!after_date_option
|| current_stat
.st_ctime
< newer_ctime_option
))
949 WARN ((0, 0, _("%s: file is unchanged; not dumped"),
950 quotearg_colon (p
)));
951 /* FIXME: recheck this return. */
956 /* See if we are trying to dump the archive. */
958 if (ar_dev
&& current_stat
.st_dev
== ar_dev
&& current_stat
.st_ino
== ar_ino
)
960 WARN ((0, 0, _("%s: file is the archive; not dumped"),
961 quotearg_colon (p
)));
966 if (S_ISDIR (current_stat
.st_mode
))
969 struct dirent
*entry
;
973 dev_t our_device
= current_stat
.st_dev
;
977 directory
= opendir (p
);
980 if (ignore_failed_read_option
)
987 /* Build new prototype name. Ensure exactly one trailing slash. */
990 buflen
= len
+ NAME_FIELD_SIZE
;
991 namebuf
= xmalloc (buflen
+ 1);
992 strncpy (namebuf
, p
, buflen
);
993 while (len
>= 1 && namebuf
[len
- 1] == '/')
995 namebuf
[len
++] = '/';
998 if (! is_avoided_name (namebuf
))
1000 /* The condition above used to be "archive_format != V7_FORMAT".
1001 GNU tar was not writing directory blocks at all. Daniel Trinkle
1002 writes: ``All old versions of tar I have ever seen have
1003 correctly archived an empty directory. The really old ones I
1004 checked included HP-UX 7 and Mt. Xinu More/BSD. There may be
1005 some subtle reason for the exclusion that I don't know, but the
1006 current behavior is broken.'' I do not know those subtle
1007 reasons either, so until these are reported (anew?), just allow
1008 directory blocks to be written even with old archives. */
1010 current_stat
.st_size
= 0; /* force 0 size on dir */
1012 /* FIXME: If people could really read standard archives, this
1016 = start_header (standard_option ? p : namebuf, ¤t_stat);
1018 but since they'd interpret DIRTYPE blocks as regular
1019 files, we'd better put the / on the name. */
1021 header
= start_header (namebuf
, ¤t_stat
);
1023 if (incremental_option
)
1024 header
->header
.typeflag
= GNUTYPE_DUMPDIR
;
1025 else /* if (standard_option) */
1026 header
->header
.typeflag
= DIRTYPE
;
1028 /* If we're gnudumping, we aren't done yet so don't close it. */
1030 if (!incremental_option
)
1031 finish_header (header
); /* done with directory header */
1034 if (incremental_option
&& gnu_list_name
->dir_contents
)
1041 const char *buffer
, *p_buffer
;
1043 buffer
= gnu_list_name
->dir_contents
; /* FOO */
1045 for (p_buffer
= buffer
; p_buffer
&& *p_buffer
;)
1049 tmp
= strlen (p_buffer
) + 1;
1054 OFF_TO_CHARS (totsize
, header
->header
.size
);
1055 finish_header (header
);
1058 while (sizeleft
> 0)
1060 if (multi_volume_option
)
1062 assign_string (&save_name
, p
);
1063 save_sizeleft
= sizeleft
;
1064 save_totsize
= totsize
;
1066 start
= find_next_block ();
1067 bufsize
= available_space_after (start
);
1068 if (sizeleft
< bufsize
)
1071 count
= bufsize
% BLOCKSIZE
;
1073 memset (start
->buffer
+ sizeleft
, 0, BLOCKSIZE
- count
);
1075 memcpy (start
->buffer
, p_buffer
, bufsize
);
1076 sizeleft
-= bufsize
;
1077 p_buffer
+= bufsize
;
1078 set_next_block_after (start
+ (bufsize
- 1) / BLOCKSIZE
);
1080 if (multi_volume_option
)
1081 assign_string (&save_name
, 0);
1085 /* See if we are about to recurse into a directory, and avoid doing
1086 so if the user wants that we do not descend into directories. */
1088 if (no_recurse_option
)
1091 /* See if we are crossing from one file system to another, and
1092 avoid doing so if the user only wants to dump one file system. */
1094 if (one_file_system_option
&& !top_level
1095 && parent_device
!= current_stat
.st_dev
)
1099 _("%s: file is on a different filesystem; not dumped"),
1100 quotearg_colon (p
)));
1104 /* Now output all the files in the directory. */
1106 /* FIXME: Should speed this up by cd-ing into the dir. */
1108 while (errno
= 0, (entry
= readdir (directory
)))
1110 /* Skip `.', `..', and excluded file names. */
1112 if (is_dot_or_dotdot (entry
->d_name
))
1115 if ((int) NAMLEN (entry
) + len
>= buflen
)
1117 buflen
= len
+ NAMLEN (entry
);
1118 namebuf
= xrealloc (namebuf
, buflen
+ 1);
1120 strcpy (namebuf
+ len
, entry
->d_name
);
1121 if (!excluded_name (namebuf
))
1122 dump_file (namebuf
, 0, our_device
);
1127 if (ignore_failed_read_option
)
1134 if (closedir (directory
) != 0)
1136 if (ignore_failed_read_option
)
1143 if (atime_preserve_option
)
1144 utime (p
, &restore_times
);
1147 else if (is_avoided_name (p
))
1151 /* Check for multiple links.
1153 We maintain a list of all such files that we've written so far. Any
1154 time we see another, we check the list and avoid dumping the data
1155 again if we've done it once already. */
1157 if (1 < current_stat
.st_nlink
)
1161 /* FIXME: First quick and dirty. Hashing, etc later. */
1163 for (lp
= linklist
; lp
; lp
= lp
->next
)
1164 if (lp
->ino
== current_stat
.st_ino
1165 && lp
->dev
== current_stat
.st_dev
)
1167 char *link_name
= lp
->name
;
1169 /* We found a link. */
1171 while (!absolute_names_option
&& *link_name
== '/')
1173 static int warned_once
;
1178 _("Removing leading `/' from link names")));
1182 if (strlen (link_name
) >= NAME_FIELD_SIZE
)
1183 write_long (link_name
, GNUTYPE_LONGLINK
);
1184 assign_string (¤t_link_name
, link_name
);
1186 current_stat
.st_size
= 0;
1187 header
= start_header (p
, ¤t_stat
);
1188 strncpy (header
->header
.linkname
,
1189 link_name
, NAME_FIELD_SIZE
);
1191 /* Force null truncated. */
1193 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = 0;
1195 header
->header
.typeflag
= LNKTYPE
;
1196 finish_header (header
);
1198 /* FIXME: Maybe remove from list after all links found? */
1200 if (remove_files_option
)
1201 if (unlink (p
) == -1)
1208 /* Not found. Add it to the list of possible links. */
1210 lp
= xmalloc (sizeof (struct link
) + strlen (p
));
1211 lp
->ino
= current_stat
.st_ino
;
1212 lp
->dev
= current_stat
.st_dev
;
1213 strcpy (lp
->name
, p
);
1214 lp
->next
= linklist
;
1218 /* This is not a link to a previously dumped file, so dump it. */
1220 if (S_ISREG (current_stat
.st_mode
)
1221 || S_ISCTG (current_stat
.st_mode
))
1223 int f
; /* file descriptor */
1229 char isextended
= 0;
1236 /* Check the size of the file against the number of blocks
1237 allocated for it, counting both data and indirect blocks.
1238 If there is a smaller number of blocks that would be
1239 necessary to accommodate a file of this size, this is safe
1240 to say that we have a sparse file: at least one of those
1241 blocks in the file is just a useless hole. For sparse
1242 files not having more hole blocks than indirect blocks, the
1243 sparseness will go undetected. */
1245 /* Bruno Haible sent me these statistics for Linux. It seems
1246 that some filesystems count indirect blocks in st_blocks,
1247 while others do not seem to:
1249 minix-fs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1250 extfs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1251 ext2fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1252 msdos-fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1254 Dick Streefland reports the previous numbers as misleading,
1255 because ext2fs use 12 direct blocks, while minix-fs uses only
1256 6 direct blocks. Dick gets:
1258 ext2 size=20480 ls listed blocks=21
1259 minix size=20480 ls listed blocks=21
1260 msdos size=20480 ls listed blocks=20
1262 It seems that indirect blocks *are* included in st_blocks.
1263 The minix filesystem does not account for phantom blocks in
1264 st_blocks, so `du' and `ls -s' give wrong results. So, the
1265 --sparse option would not work on a minix filesystem. */
1267 if (ST_NBLOCKS (current_stat
)
1268 < (current_stat
.st_size
/ ST_NBLOCKSIZE
1269 + (current_stat
.st_size
% ST_NBLOCKSIZE
!= 0)))
1273 header
= start_header (p
, ¤t_stat
);
1274 header
->header
.typeflag
= GNUTYPE_SPARSE
;
1277 /* Call the routine that figures out the layout of the
1278 sparse file in question. SPARSES is the index of the
1279 first unused element of the "sparsearray," i.e.,
1280 the number of elements it needed to describe the file. */
1282 sparses
= deal_with_sparse (p
, header
);
1284 /* See if we'll need an extended header later. */
1286 if (SPARSES_IN_OLDGNU_HEADER
< sparses
)
1287 header
->oldgnu_header
.isextended
= 1;
1289 /* We store the "real" file size so we can show that in
1290 case someone wants to list the archive, i.e., tar tvf
1291 <file>. It might be kind of disconcerting if the
1292 shrunken file size was the one that showed up. */
1294 OFF_TO_CHARS (current_stat
.st_size
,
1295 header
->oldgnu_header
.realsize
);
1297 /* This will be the new "size" of the file, i.e., the size
1298 of the file minus the blocks of holes that we're
1301 current_stat
.st_size
= find_new_file_size (sparses
);
1302 OFF_TO_CHARS (current_stat
.st_size
, header
->header
.size
);
1305 counter
< sparses
&& counter
< SPARSES_IN_OLDGNU_HEADER
;
1308 OFF_TO_CHARS (sparsearray
[counter
].offset
,
1309 header
->oldgnu_header
.sp
[counter
].offset
);
1310 SIZE_TO_CHARS (sparsearray
[counter
].numbytes
,
1311 header
->oldgnu_header
.sp
[counter
].numbytes
);
1316 sparses
= SPARSES_IN_OLDGNU_HEADER
;
1318 sizeleft
= current_stat
.st_size
;
1320 /* Don't bother opening empty, world readable files. Also do not open
1321 files when archive is meant for /dev/null. */
1325 && MODE_R
== (MODE_R
& current_stat
.st_mode
)))
1329 f
= open (p
, O_RDONLY
| O_BINARY
);
1332 if (! top_level
&& errno
== ENOENT
)
1333 WARN ((0, 0, _("%s: File removed before we read it"),
1334 quotearg_colon (p
)));
1336 (ignore_failed_read_option
? open_warn
: open_error
) (p
);
1341 /* If the file is sparse, we've already taken care of this. */
1344 header
= start_header (p
, ¤t_stat
);
1346 /* Mark contiguous files, if we support them. */
1348 if (archive_format
!= V7_FORMAT
&& S_ISCTG (current_stat
.st_mode
))
1349 header
->header
.typeflag
= CONTTYPE
;
1351 isextended
= header
->oldgnu_header
.isextended
;
1352 save_typeflag
= header
->header
.typeflag
;
1353 finish_header (header
);
1357 /* static */ int index_offset
= SPARSES_IN_OLDGNU_HEADER
;
1360 exhdr
= find_next_block ();
1361 memset (exhdr
->buffer
, 0, BLOCKSIZE
);
1362 for (counter
= 0; counter
< SPARSES_IN_SPARSE_HEADER
; counter
++)
1364 if (sparses
<= counter
+ index_offset
)
1367 SIZE_TO_CHARS (sparsearray
[counter
+ index_offset
].numbytes
,
1368 exhdr
->sparse_header
.sp
[counter
].numbytes
);
1369 OFF_TO_CHARS (sparsearray
[counter
+ index_offset
].offset
,
1370 exhdr
->sparse_header
.sp
[counter
].offset
);
1372 set_next_block_after (exhdr
);
1373 if (counter
+ index_offset
< sparses
)
1375 index_offset
+= counter
;
1376 exhdr
->sparse_header
.isextended
= 1;
1381 if (save_typeflag
== GNUTYPE_SPARSE
)
1384 || finish_sparse_file (f
, &sizeleft
,
1385 current_stat
.st_size
, p
))
1389 while (sizeleft
> 0)
1391 if (multi_volume_option
)
1393 assign_string (&save_name
, p
);
1394 save_sizeleft
= sizeleft
;
1395 save_totsize
= current_stat
.st_size
;
1397 start
= find_next_block ();
1399 bufsize
= available_space_after (start
);
1401 if (sizeleft
< bufsize
)
1403 /* Last read -- zero out area beyond. */
1406 count
= bufsize
% BLOCKSIZE
;
1408 memset (start
->buffer
+ sizeleft
, 0, BLOCKSIZE
- count
);
1413 count
= safe_read (f
, start
->buffer
, bufsize
);
1416 (ignore_failed_read_option
1418 : read_error_details
)
1419 (p
, current_stat
.st_size
- sizeleft
, bufsize
);
1424 /* This is nonportable (the type of set_next_block_after's arg). */
1426 set_next_block_after (start
+ (count
- 1) / BLOCKSIZE
);
1428 if (count
== bufsize
)
1432 char buf
[UINTMAX_STRSIZE_BOUND
];
1434 _("%s: File shrank by %s bytes; padding with zeros"),
1436 STRINGIFY_BIGINT (sizeleft
, buf
)));
1437 if (! ignore_failed_read_option
)
1438 exit_status
= TAREXIT_FAILURE
;
1439 goto padit
; /* short read */
1443 if (multi_volume_option
)
1444 assign_string (&save_name
, 0);
1448 struct stat final_stat
;
1449 if (fstat (f
, &final_stat
) != 0)
1451 if (ignore_failed_read_option
)
1456 else if (final_stat
.st_ctime
!= original_ctime
)
1458 char const *qp
= quotearg_colon (p
);
1459 WARN ((0, 0, _("%s: file changed as we read it"), qp
));
1460 if (! ignore_failed_read_option
)
1461 exit_status
= TAREXIT_FAILURE
;
1465 if (ignore_failed_read_option
)
1470 if (atime_preserve_option
)
1471 utime (p
, &restore_times
);
1473 if (remove_files_option
)
1475 if (unlink (p
) == -1)
1480 /* File shrunk or gave error, pad out tape to match the size we
1481 specified in the header. */
1484 while (sizeleft
> 0)
1486 save_sizeleft
= sizeleft
;
1487 start
= find_next_block ();
1488 memset (start
->buffer
, 0, BLOCKSIZE
);
1489 set_next_block_after (start
);
1490 sizeleft
-= BLOCKSIZE
;
1492 if (multi_volume_option
)
1493 assign_string (&save_name
, 0);
1497 if (atime_preserve_option
)
1498 utime (p
, &restore_times
);
1502 #ifdef HAVE_READLINK
1503 else if (S_ISLNK (current_stat
.st_mode
))
1506 char *buffer
= (char *) alloca (PATH_MAX
+ 1);
1508 size
= readlink (p
, buffer
, PATH_MAX
+ 1);
1511 if (ignore_failed_read_option
)
1517 buffer
[size
] = '\0';
1518 if (size
>= NAME_FIELD_SIZE
)
1519 write_long (buffer
, GNUTYPE_LONGLINK
);
1520 assign_string (¤t_link_name
, buffer
);
1522 current_stat
.st_size
= 0; /* force 0 size on symlink */
1523 header
= start_header (p
, ¤t_stat
);
1524 strncpy (header
->header
.linkname
, buffer
, NAME_FIELD_SIZE
);
1525 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = '\0';
1526 header
->header
.typeflag
= SYMTYPE
;
1527 finish_header (header
); /* nothing more to do to it */
1528 if (remove_files_option
)
1530 if (unlink (p
) == -1)
1536 else if (S_ISCHR (current_stat
.st_mode
))
1538 else if (S_ISBLK (current_stat
.st_mode
))
1540 else if (S_ISFIFO (current_stat
.st_mode
))
1542 else if (S_ISSOCK (current_stat
.st_mode
))
1544 WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1547 else if (S_ISDOOR (current_stat
.st_mode
))
1549 WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1556 if (archive_format
== V7_FORMAT
)
1559 current_stat
.st_size
= 0; /* force 0 size */
1560 header
= start_header (p
, ¤t_stat
);
1561 header
->header
.typeflag
= type
;
1563 if (type
!= FIFOTYPE
)
1565 MAJOR_TO_CHARS (major (current_stat
.st_rdev
), header
->header
.devmajor
);
1566 MINOR_TO_CHARS (minor (current_stat
.st_rdev
), header
->header
.devminor
);
1569 finish_header (header
);
1570 if (remove_files_option
)
1572 if (unlink (p
) == -1)
1578 WARN ((0, 0, _("%s: Unknown file type; file ignored"),
1579 quotearg_colon (p
)));
1580 if (! ignore_failed_read_option
)
1581 exit_status
= TAREXIT_FAILURE
;