1 /* Create a tar archive.
2 Copyright 1985, 92, 93, 94, 96, 97, 1999 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. */
43 extern struct name
*gnu_list_name
;
45 /* This module is the only one that cares about `struct link's. */
55 static struct link
*linklist
; /* points to first link in list */
57 /* The maximum uintmax_t value that can be represented with DIGITS digits,
58 assuming that each digit is BITS_PER_DIGIT wide. */
59 #define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
60 ((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
61 ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
64 /* Convert VALUE to an octal representation suitable for tar headers.
65 Output to buffer WHERE with size SIZE.
66 The result is undefined if SIZE is 0 or if VALUE is too large to fit. */
69 to_octal (uintmax_t value
, char *where
, size_t size
)
76 where
[--i
] = '0' + (v
& ((1 << LG_8
) - 1));
82 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
83 tar headers. NEGATIVE is 1 if VALUE was negative before being cast
84 to uintmax_t, 0 otherwise. Output to buffer WHERE with size SIZE.
85 The result is undefined if SIZE is 0 or if VALUE is too large to
89 to_base256 (int negative
, uintmax_t value
, char *where
, size_t size
)
92 uintmax_t propagated_sign_bits
=
93 ((uintmax_t) - negative
<< (CHAR_BIT
* sizeof v
- LG_256
));
98 where
[--i
] = v
& ((1 << LG_256
) - 1);
99 v
= propagated_sign_bits
| (v
>> LG_256
);
104 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
105 external form, using SUBSTITUTE (...) if VALUE won't fit. Output
106 to buffer WHERE with size SIZE. NEGATIVE is 1 iff VALUE was
107 negative before being cast to uintmax_t; its original bitpattern
108 can be deduced from VALSIZE, its original size before casting.
109 TYPE is the kind of value being output (useful for diagnostics).
110 Prefer the POSIX format of SIZE - 1 octal digits (with leading zero
111 digits), followed by '\0'. If this won't work, and if GNU or
112 OLDGNU format is allowed, use '\200' followed by base-256, or (if
113 NEGATIVE is nonzero) '\377' followed by two's complement base-256.
114 If neither format works, use SUBSTITUTE (...) instead. Pass to
115 SUBSTITUTE the address of an 0-or-1 flag recording whether the
116 substitute value is negative. */
119 to_chars (int negative
, uintmax_t value
, size_t valsize
,
120 uintmax_t (*substitute
) PARAMS ((int *)),
121 char *where
, size_t size
, const char *type
)
123 int base256_allowed
= (archive_format
== GNU_FORMAT
124 || archive_format
== OLDGNU_FORMAT
);
126 /* Generate the POSIX octal representation if the number fits. */
127 if (! negative
&& value
<= MAX_VAL_WITH_DIGITS (size
- 1, LG_8
))
129 where
[size
- 1] = '\0';
130 to_octal (value
, where
, size
- 1);
133 /* Otherwise, generate the base-256 representation if we are
134 generating an old or new GNU format and if the number fits. */
135 else if (((negative
? -1 - value
: value
)
136 <= MAX_VAL_WITH_DIGITS (size
- 1, LG_256
))
139 where
[0] = negative
? -1 : 1 << (LG_256
- 1);
140 to_base256 (negative
, value
, where
+ 1, size
- 1);
143 /* Otherwise, if the number is negative, and if it would not cause
144 ambiguity on this host by confusing positive with negative
145 values, then generate the POSIX octal representation of the value
146 modulo 2**(field bits). The resulting tar file is
147 machine-dependent, since it depends on the host word size. Yuck!
148 But this is the traditional behavior. */
149 else if (negative
&& valsize
* CHAR_BIT
<= (size
- 1) * LG_8
)
151 static int warned_once
;
155 WARN ((0, 0, _("Generating negative octal headers")));
157 where
[size
- 1] = '\0';
158 to_octal (value
& MAX_VAL_WITH_DIGITS (valsize
* CHAR_BIT
, 1),
162 /* Otherwise, output a substitute value if possible (with a
163 warning), and an error message if not. */
166 uintmax_t maxval
= (base256_allowed
167 ? MAX_VAL_WITH_DIGITS (size
- 1, LG_256
)
168 : MAX_VAL_WITH_DIGITS (size
- 1, LG_8
));
169 char valbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
170 char maxbuf
[UINTMAX_STRSIZE_BOUND
];
171 char minbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
172 char const *minval_string
;
173 char const *maxval_string
= STRINGIFY_BIGINT (maxval
, maxbuf
);
174 char const *value_string
;
178 uintmax_t m
= maxval
+ 1 ? maxval
+ 1 : maxval
/ 2 + 1;
179 char *p
= STRINGIFY_BIGINT (m
, minbuf
+ 1);
188 char *p
= STRINGIFY_BIGINT (- value
, valbuf
+ 1);
193 value_string
= STRINGIFY_BIGINT (value
, valbuf
);
198 uintmax_t sub
= substitute (&negsub
) & maxval
;
199 uintmax_t s
= (negsub
&= archive_format
== GNU_FORMAT
) ? - sub
: sub
;
200 char subbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
201 char *sub_string
= STRINGIFY_BIGINT (s
, subbuf
+ 1);
204 WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
205 value_string
, type
, minval_string
, maxval_string
,
207 to_chars (negsub
, s
, valsize
, 0, where
, size
, type
);
210 ERROR ((0, 0, _("value %s out of %s range %s..%s"),
211 value_string
, type
, minval_string
, maxval_string
));
216 gid_substitute (int *negative
)
222 static gid_t gid_nobody
;
223 if (!gid_nobody
&& !gname_to_gid ("nobody", &gid_nobody
))
232 gid_to_chars (gid_t v
, char *p
, size_t s
)
234 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, gid_substitute
, p
, s
, "gid_t");
238 major_to_chars (major_t v
, char *p
, size_t s
)
240 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "major_t");
244 minor_to_chars (minor_t v
, char *p
, size_t s
)
246 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "minor_t");
250 mode_to_chars (mode_t v
, char *p
, size_t s
)
252 /* In the common case where the internal and external mode bits are the same,
253 and we are not using POSIX or GNU format,
254 propagate all unknown bits to the external mode.
255 This matches historical practice.
256 Otherwise, just copy the bits we know about. */
259 if (S_ISUID
== TSUID
&& S_ISGID
== TSGID
&& S_ISVTX
== TSVTX
260 && S_IRUSR
== TUREAD
&& S_IWUSR
== TUWRITE
&& S_IXUSR
== TUEXEC
261 && S_IRGRP
== TGREAD
&& S_IWGRP
== TGWRITE
&& S_IXGRP
== TGEXEC
262 && S_IROTH
== TOREAD
&& S_IWOTH
== TOWRITE
&& S_IXOTH
== TOEXEC
263 && archive_format
!= POSIX_FORMAT
264 && archive_format
!= GNU_FORMAT
)
272 u
= ((v
& S_ISUID
? TSUID
: 0)
273 | (v
& S_ISGID
? TSGID
: 0)
274 | (v
& S_ISVTX
? TSVTX
: 0)
275 | (v
& S_IRUSR
? TUREAD
: 0)
276 | (v
& S_IWUSR
? TUWRITE
: 0)
277 | (v
& S_IXUSR
? TUEXEC
: 0)
278 | (v
& S_IRGRP
? TGREAD
: 0)
279 | (v
& S_IWGRP
? TGWRITE
: 0)
280 | (v
& S_IXGRP
? TGEXEC
: 0)
281 | (v
& S_IROTH
? TOREAD
: 0)
282 | (v
& S_IWOTH
? TOWRITE
: 0)
283 | (v
& S_IXOTH
? TOEXEC
: 0));
285 to_chars (negative
, u
, sizeof v
, 0, p
, s
, "mode_t");
289 off_to_chars (off_t v
, char *p
, size_t s
)
291 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "off_t");
295 size_to_chars (size_t v
, char *p
, size_t s
)
297 to_chars (0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "size_t");
301 time_to_chars (time_t v
, char *p
, size_t s
)
303 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "time_t");
307 uid_substitute (int *negative
)
313 static uid_t uid_nobody
;
314 if (!uid_nobody
&& !uname_to_uid ("nobody", &uid_nobody
))
323 uid_to_chars (uid_t v
, char *p
, size_t s
)
325 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, uid_substitute
, p
, s
, "uid_t");
329 uintmax_to_chars (uintmax_t v
, char *p
, size_t s
)
331 to_chars (0, v
, sizeof v
, 0, p
, s
, "uintmax_t");
334 /* Writing routines. */
336 /*-----------------------------------------------------------------------.
337 | Just zeroes out the buffer so we don't confuse ourselves with leftover |
339 `-----------------------------------------------------------------------*/
342 clear_buffer (char *buffer
)
344 memset (buffer
, 0, BLOCKSIZE
);
347 /*-------------------------------------------------------------------------.
348 | Write the EOT block(s). We zero at least two blocks, through |
349 | the end of the record. Old tar, as previous versions of GNU tar, writes |
350 | garbage after two zeroed blocks. |
351 `-------------------------------------------------------------------------*/
356 union block
*pointer
= find_next_block ();
357 memset (pointer
->buffer
, 0, BLOCKSIZE
);
358 set_next_block_after (pointer
);
359 pointer
= find_next_block ();
360 memset (pointer
->buffer
, 0, available_space_after (pointer
));
361 set_next_block_after (pointer
);
364 /*-----------------------------------------------------.
365 | Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. |
366 `-----------------------------------------------------*/
368 /* FIXME: Cross recursion between start_header and write_long! */
370 static union block
*start_header
PARAMS ((const char *, struct stat
*));
373 write_long (const char *p
, char type
)
375 size_t size
= strlen (p
) + 1;
380 memset (&foo
, 0, sizeof foo
);
383 header
= start_header ("././@LongLink", &foo
);
384 header
->header
.typeflag
= type
;
385 finish_header (header
);
387 header
= find_next_block ();
389 bufsize
= available_space_after (header
);
391 while (bufsize
< size
)
393 memcpy (header
->buffer
, p
, bufsize
);
396 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
397 header
= find_next_block ();
398 bufsize
= available_space_after (header
);
400 memcpy (header
->buffer
, p
, size
);
401 memset (header
->buffer
+ size
, 0, bufsize
- size
);
402 set_next_block_after (header
+ (size
- 1) / BLOCKSIZE
);
405 /* Header handling. */
407 /* Make a header block for the file whose stat info is st,
408 and return its address. */
411 start_header (const char *name
, struct stat
*st
)
415 if (!absolute_names_option
)
417 size_t prefix_len
= FILESYSTEM_PREFIX_LEN (name
);
421 static int warned_once
;
425 WARN ((0, 0, _("Removing `%.*s' prefix from archive names"),
426 (int) prefix_len
, name
));
433 static int warned_once
;
437 WARN ((0, 0, _("Removing leading `/' from archive names")));
443 if (sizeof header
->header
.name
<= strlen (name
))
444 write_long (name
, GNUTYPE_LONGNAME
);
445 header
= find_next_block ();
446 memset (header
->buffer
, 0, sizeof (union block
));
448 assign_string (¤t_file_name
, name
);
450 strncpy (header
->header
.name
, name
, NAME_FIELD_SIZE
);
451 header
->header
.name
[NAME_FIELD_SIZE
- 1] = '\0';
453 /* Override some stat fields, if requested to do so. */
455 if (owner_option
!= (uid_t
) -1)
456 st
->st_uid
= owner_option
;
457 if (group_option
!= (gid_t
) -1)
458 st
->st_gid
= group_option
;
460 st
->st_mode
= ((st
->st_mode
& ~MODE_ALL
)
461 | mode_adjust (st
->st_mode
, mode_option
));
463 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
464 for a few tars and came up with the following interoperability
468 1 2 3 4 5 6 7 8 9 READER
469 . . . . . . . . . 1 = SunOS 4.2 tar
470 # . . # # . . # # 2 = NEC SVR4.0.2 tar
471 . . . # # . . # . 3 = Solaris 2.1 tar
472 . . . . . . . . . 4 = GNU tar 1.11.1
473 . . . . . . . . . 5 = HP-UX 8.07 tar
474 . . . . . . . . . 6 = Ultrix 4.1
475 . . . . . . . . . 7 = AIX 3.2
476 . . . . . . . . . 8 = Hitachi HI-UX 1.03
477 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
480 # = ``impossible file type''
482 The following mask for old archive removes the `#'s in column 4
483 above, thus making GNU tar both a universal donor and a universal
484 acceptor for Paul's test. */
486 if (archive_format
== V7_FORMAT
)
487 MODE_TO_CHARS (st
->st_mode
& MODE_ALL
, header
->header
.mode
);
489 MODE_TO_CHARS (st
->st_mode
, header
->header
.mode
);
491 UID_TO_CHARS (st
->st_uid
, header
->header
.uid
);
492 GID_TO_CHARS (st
->st_gid
, header
->header
.gid
);
493 OFF_TO_CHARS (st
->st_size
, header
->header
.size
);
494 TIME_TO_CHARS (st
->st_mtime
, header
->header
.mtime
);
496 if (incremental_option
)
497 if (archive_format
== OLDGNU_FORMAT
)
499 TIME_TO_CHARS (st
->st_atime
, header
->oldgnu_header
.atime
);
500 TIME_TO_CHARS (st
->st_ctime
, header
->oldgnu_header
.ctime
);
503 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
505 switch (archive_format
)
511 /* Overwrite header->header.magic and header.version in one blow. */
512 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
517 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
518 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
525 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
527 /* header->header.[ug]name are left as the empty string. */
531 uid_to_uname (st
->st_uid
, header
->header
.uname
);
532 gid_to_gname (st
->st_gid
, header
->header
.gname
);
538 /*-------------------------------------------------------------------------.
539 | Finish off a filled-in header block and write it out. We also print the |
540 | file name and/or full info if verbose is on. |
541 `-------------------------------------------------------------------------*/
544 finish_header (union block
*header
)
550 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
554 for (i
= sizeof *header
; i
-- != 0; )
555 /* We can't use unsigned char here because of old compilers, e.g. V7. */
558 /* Fill in the checksum field. It's formatted differently from the
559 other fields: it has [6] digits, a null, then a space -- rather than
560 digits, then a null. We use to_chars.
561 The final space is already there, from
562 checksumming, and to_chars doesn't modify it.
564 This is a fast way to do:
566 sprintf(header->header.chksum, "%6o", sum); */
568 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
571 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
572 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
)
574 /* These globals are parameters to print_header, sigh. */
576 current_header
= header
;
577 /* current_stat is already set up. */
578 current_format
= archive_format
;
582 set_next_block_after (header
);
585 /* Sparse file processing. */
587 /*-------------------------------------------------------------------------.
588 | Takes a blockful of data and basically cruises through it to see if it's |
589 | made *entirely* of zeros, returning a 0 the instant it finds something |
590 | that is a nonzero, i.e., useful data. |
591 `-------------------------------------------------------------------------*/
594 zero_block_p (char *buffer
)
598 for (counter
= 0; counter
< BLOCKSIZE
; counter
++)
599 if (buffer
[counter
] != '\0')
609 init_sparsearray (void)
615 /* Make room for our scratch space -- initially is 10 elts long. */
617 sparsearray
= xmalloc (sp_array_size
* sizeof (struct sp_array
));
618 for (counter
= 0; counter
< sp_array_size
; counter
++)
620 sparsearray
[counter
].offset
= 0;
621 sparsearray
[counter
].numbytes
= 0;
630 find_new_file_size (off_t
*filesize
, int highest_index
)
636 sparsearray
[counter
].numbytes
&& counter
<= highest_index
;
638 *filesize
+= sparsearray
[counter
].numbytes
;
641 /*-----------------------------------------------------------------------.
642 | Make one pass over the file NAME, studying where any non-zero data is, |
643 | that is, how far into the file each instance of data is, and how many |
644 | bytes are there. Save this information in the sparsearray, which will |
645 | later be translated into header information. |
646 `-----------------------------------------------------------------------*/
648 /* There is little point in trimming small amounts of null data at the head
649 and tail of blocks, only avoid dumping full null blocks. */
651 /* FIXME: this routine might accept bits of algorithmic cleanup, it is
652 too kludgey for my taste... */
655 deal_with_sparse (char *name
, union block
*header
)
660 int sparse_index
= 0;
662 char buffer
[BLOCKSIZE
];
664 if (archive_format
== OLDGNU_FORMAT
)
665 header
->oldgnu_header
.isextended
= 0;
667 if (file
= open (name
, O_RDONLY
), file
< 0)
668 /* This problem will be caught later on, so just return. */
672 clear_buffer (buffer
);
674 while (count
= safe_read (file
, buffer
, sizeof buffer
), count
!= 0)
676 /* Realloc the scratch area as necessary. FIXME: should reallocate
677 only at beginning of a new instance of non-zero data. */
679 if (sparse_index
> sp_array_size
- 1)
682 xrealloc (sparsearray
,
683 2 * sp_array_size
* sizeof (struct sp_array
));
687 /* Process one block. */
689 if (count
== sizeof buffer
)
691 if (zero_block_p (buffer
))
695 sparsearray
[sparse_index
++].numbytes
= numbytes
;
702 sparsearray
[sparse_index
].offset
= offset
;
708 /* Since count < sizeof buffer, we have the last bit of the file. */
710 if (!zero_block_p (buffer
))
713 sparsearray
[sparse_index
].offset
= offset
;
717 /* The next two lines are suggested by Andreas Degert, who says
718 they are required for trailing full blocks to be written to the
719 archive, when all zeroed. Yet, it seems to me that the case
720 does not apply. Further, at restore time, the file is not as
721 sparse as it should. So, some serious cleanup is *also* needed
722 in this area. Just one more... :-(. FIXME. */
726 /* Prepare for next block. */
729 /* FIXME: do not clear unless necessary. */
730 clear_buffer (buffer
);
734 sparsearray
[sparse_index
++].numbytes
= numbytes
;
737 sparsearray
[sparse_index
].offset
= offset
- 1;
738 sparsearray
[sparse_index
++].numbytes
= 1;
742 return sparse_index
- 1;
750 finish_sparse_file (int file
, off_t
*sizeleft
, off_t fullsize
, char *name
)
754 int sparse_index
= 0;
757 while (*sizeleft
> 0)
759 start
= find_next_block ();
760 memset (start
->buffer
, 0, BLOCKSIZE
);
761 bufsize
= sparsearray
[sparse_index
].numbytes
;
764 /* We blew it, maybe. */
765 char buf1
[UINTMAX_STRSIZE_BOUND
];
766 char buf2
[UINTMAX_STRSIZE_BOUND
];
768 ERROR ((0, 0, _("Wrote %s of %s bytes to file %s"),
769 STRINGIFY_BIGINT (fullsize
- *sizeleft
, buf1
),
770 STRINGIFY_BIGINT (fullsize
, buf2
),
775 if (lseek (file
, sparsearray
[sparse_index
++].offset
, SEEK_SET
) < 0)
777 char buf
[UINTMAX_STRSIZE_BOUND
];
778 ERROR ((0, errno
, _("lseek error at byte %s in file %s"),
779 STRINGIFY_BIGINT (sparsearray
[sparse_index
- 1].offset
, buf
),
784 /* If the number of bytes to be written here exceeds the size of
785 the temporary buffer, do it in steps. */
787 while (bufsize
> BLOCKSIZE
)
792 count
= safe_read (file
, start
->buffer
+ amount_read
,
793 BLOCKSIZE
- amount_read
);
794 bufsize
-= BLOCKSIZE
- amount_read
;
796 set_next_block_after (start
);
797 start
= find_next_block ();
798 memset (start
->buffer
, 0, BLOCKSIZE
);
801 /* Store the data. */
803 count
= safe_read (file
, start
->buffer
, BLOCKSIZE
);
806 char buf
[UINTMAX_STRSIZE_BOUND
];
808 _("Read error at byte %s, reading %lu bytes, in file %s"),
809 STRINGIFY_BIGINT (fullsize
- *sizeleft
, buf
),
810 (unsigned long) bufsize
, name
));
815 set_next_block_after (start
);
816 start
= find_next_block ();
817 memset (start
->buffer
, 0, BLOCKSIZE
);
821 char buffer
[BLOCKSIZE
];
823 clear_buffer (buffer
);
824 count
= safe_read (file
, buffer
, bufsize
);
825 memcpy (start
->buffer
, buffer
, BLOCKSIZE
);
830 char buf
[UINTMAX_STRSIZE_BOUND
];
833 _("Read error at byte %s, reading %lu bytes, in file %s"),
834 STRINGIFY_BIGINT (fullsize
- *sizeleft
, buf
),
835 (unsigned long) bufsize
, name
));
839 if (amount_read
>= BLOCKSIZE
)
842 set_next_block_after (start
+ (count
- 1) / BLOCKSIZE
);
843 if (count
!= bufsize
)
846 _("File %s shrunk, padding with zeros"),
850 start
= find_next_block ();
853 amount_read
+= bufsize
;
856 set_next_block_after (start
);
861 set_next_block_after (start
+ (count
- 1) / BLOCKSIZE
);
866 /* Main functions of this module. */
873 create_archive (void)
877 open_archive (ACCESS_WRITE
);
879 if (incremental_option
)
881 char *buffer
= xmalloc (PATH_MAX
);
885 collect_and_sort_names ();
887 while (p
= name_from_list (), p
)
888 if (!excluded_name (p
))
889 dump_file (p
, -1, (dev_t
) 0);
892 while (p
= name_from_list (), p
)
893 if (!excluded_name (p
))
896 if (p
[strlen (p
) - 1] != '/')
897 strcat (buffer
, "/");
898 bufp
= buffer
+ strlen (buffer
);
899 q
= gnu_list_name
->dir_contents
;
901 for (; *q
; q
+= strlen (q
) + 1)
904 strcpy (bufp
, q
+ 1);
905 dump_file (buffer
, -1, (dev_t
) 0);
912 while (p
= name_next (1), p
)
913 if (!excluded_name (p
))
914 dump_file (p
, 1, (dev_t
) 0);
920 if (listed_incremental_option
)
921 write_directory_file ();
924 /* Dump a single file, recursing on directories. P is the file name
925 to dump. TOP_LEVEL tells whether this is a top-level call; zero
926 means no, positive means yes, and negative means an incremental
927 dump. PARENT_DEVICE is the device of P's
928 parent directory; it is examined only if TOP_LEVEL is zero.
930 Set global CURRENT_STAT to stat output for this file. */
932 /* FIXME: One should make sure that for *every* path leading to setting
933 exit_status to failure, a clear diagnostic has been issued. */
936 dump_file (char *p
, int top_level
, dev_t parent_device
)
942 time_t original_ctime
;
943 struct utimbuf restore_times
;
945 /* FIXME: `header' and `upperbound' might be used uninitialized in this
946 function. Reported by Bruno Haible. */
948 if (interactive_option
&& !confirm ("add", p
))
951 if (deref_stat (dereference_option
, p
, ¤t_stat
) != 0)
953 WARN ((0, errno
, _("Cannot add file %s"), p
));
954 if (!ignore_failed_read_option
)
955 exit_status
= TAREXIT_FAILURE
;
959 original_ctime
= current_stat
.st_ctime
;
960 restore_times
.actime
= current_stat
.st_atime
;
961 restore_times
.modtime
= current_stat
.st_mtime
;
964 if (S_ISHIDDEN (current_stat
.st_mode
))
966 char *new = (char *) alloca (strlen (p
) + 2);
976 /* See if we want only new files, and check if this one is too old to
977 put in the archive. */
979 if ((0 < top_level
|| !incremental_option
)
980 && !S_ISDIR (current_stat
.st_mode
)
981 && current_stat
.st_mtime
< newer_mtime_option
982 && (!after_date_option
|| current_stat
.st_ctime
< newer_ctime_option
))
985 WARN ((0, 0, _("%s: is unchanged; not dumped"), p
));
986 /* FIXME: recheck this return. */
991 /* See if we are trying to dump the archive. */
993 if (ar_dev
&& current_stat
.st_dev
== ar_dev
&& current_stat
.st_ino
== ar_ino
)
995 WARN ((0, 0, _("%s is the archive; not dumped"), p
));
1000 if (S_ISDIR (current_stat
.st_mode
))
1003 struct dirent
*entry
;
1007 dev_t our_device
= current_stat
.st_dev
;
1009 /* If this tar program is installed suid root, like for Amanda, the
1010 access might look like denied, while it is not really.
1012 FIXME: I have the feeling this test is done too early. Couldn't it
1013 just be bundled in later actions? I guess that the proper support
1014 of --ignore-failed-read is the key of the current writing. */
1016 if (access (p
, R_OK
) == -1 && geteuid () != 0)
1018 WARN ((0, errno
, _("Cannot add directory %s"), p
));
1019 if (!ignore_failed_read_option
)
1020 exit_status
= TAREXIT_FAILURE
;
1024 /* Build new prototype name. Ensure exactly one trailing slash. */
1027 buflen
= len
+ NAME_FIELD_SIZE
;
1028 namebuf
= xmalloc (buflen
+ 1);
1029 strncpy (namebuf
, p
, buflen
);
1030 while (len
>= 1 && namebuf
[len
- 1] == '/')
1032 namebuf
[len
++] = '/';
1033 namebuf
[len
] = '\0';
1035 if (! is_avoided_name (namebuf
))
1037 /* The condition above used to be "archive_format != V7_FORMAT".
1038 GNU tar was not writing directory blocks at all. Daniel Trinkle
1039 writes: ``All old versions of tar I have ever seen have
1040 correctly archived an empty directory. The really old ones I
1041 checked included HP-UX 7 and Mt. Xinu More/BSD. There may be
1042 some subtle reason for the exclusion that I don't know, but the
1043 current behavior is broken.'' I do not know those subtle
1044 reasons either, so until these are reported (anew?), just allow
1045 directory blocks to be written even with old archives. */
1047 current_stat
.st_size
= 0; /* force 0 size on dir */
1049 /* FIXME: If people could really read standard archives, this
1053 = start_header (standard_option ? p : namebuf, ¤t_stat);
1055 but since they'd interpret DIRTYPE blocks as regular
1056 files, we'd better put the / on the name. */
1058 header
= start_header (namebuf
, ¤t_stat
);
1060 if (incremental_option
)
1061 header
->header
.typeflag
= GNUTYPE_DUMPDIR
;
1062 else /* if (standard_option) */
1063 header
->header
.typeflag
= DIRTYPE
;
1065 /* If we're gnudumping, we aren't done yet so don't close it. */
1067 if (!incremental_option
)
1068 finish_header (header
); /* done with directory header */
1071 if (incremental_option
&& gnu_list_name
->dir_contents
)
1078 const char *buffer
, *p_buffer
;
1080 buffer
= gnu_list_name
->dir_contents
; /* FOO */
1082 for (p_buffer
= buffer
; p_buffer
&& *p_buffer
;)
1086 tmp
= strlen (p_buffer
) + 1;
1091 OFF_TO_CHARS (totsize
, header
->header
.size
);
1092 finish_header (header
);
1095 while (sizeleft
> 0)
1097 if (multi_volume_option
)
1099 assign_string (&save_name
, p
);
1100 save_sizeleft
= sizeleft
;
1101 save_totsize
= totsize
;
1103 start
= find_next_block ();
1104 bufsize
= available_space_after (start
);
1105 if (sizeleft
< bufsize
)
1108 count
= bufsize
% BLOCKSIZE
;
1110 memset (start
->buffer
+ sizeleft
, 0, BLOCKSIZE
- count
);
1112 memcpy (start
->buffer
, p_buffer
, bufsize
);
1113 sizeleft
-= bufsize
;
1114 p_buffer
+= bufsize
;
1115 set_next_block_after (start
+ (bufsize
- 1) / BLOCKSIZE
);
1117 if (multi_volume_option
)
1118 assign_string (&save_name
, 0);
1119 if (atime_preserve_option
)
1120 utime (p
, &restore_times
);
1124 /* See if we are about to recurse into a directory, and avoid doing
1125 so if the user wants that we do not descend into directories. */
1127 if (no_recurse_option
)
1130 /* See if we are crossing from one file system to another, and
1131 avoid doing so if the user only wants to dump one file system. */
1133 if (one_file_system_option
&& !top_level
1134 && parent_device
!= current_stat
.st_dev
)
1137 WARN ((0, 0, _("%s: On a different filesystem; not dumped"), p
));
1141 /* Now output all the files in the directory. */
1145 directory
= opendir (p
);
1148 ERROR ((0, errno
, _("Cannot open directory %s"), p
));
1152 /* FIXME: Should speed this up by cd-ing into the dir. */
1154 while (entry
= readdir (directory
), entry
)
1156 /* Skip `.', `..', and excluded file names. */
1158 if (is_dot_or_dotdot (entry
->d_name
))
1161 if ((int) NAMLEN (entry
) + len
>= buflen
)
1163 buflen
= len
+ NAMLEN (entry
);
1164 namebuf
= xrealloc (namebuf
, buflen
+ 1);
1166 strcpy (namebuf
+ len
, entry
->d_name
);
1167 if (!excluded_name (namebuf
))
1168 dump_file (namebuf
, 0, our_device
);
1171 closedir (directory
);
1173 if (atime_preserve_option
)
1174 utime (p
, &restore_times
);
1177 else if (is_avoided_name (p
))
1181 /* Check for multiple links.
1183 We maintain a list of all such files that we've written so far. Any
1184 time we see another, we check the list and avoid dumping the data
1185 again if we've done it once already. */
1187 if (1 < current_stat
.st_nlink
)
1191 /* FIXME: First quick and dirty. Hashing, etc later. */
1193 for (lp
= linklist
; lp
; lp
= lp
->next
)
1194 if (lp
->ino
== current_stat
.st_ino
1195 && lp
->dev
== current_stat
.st_dev
)
1197 char *link_name
= lp
->name
;
1199 /* We found a link. */
1201 while (!absolute_names_option
&& *link_name
== '/')
1203 static int warned_once
;
1208 _("Removing leading `/' from link names")));
1212 if (strlen (link_name
) >= NAME_FIELD_SIZE
)
1213 write_long (link_name
, GNUTYPE_LONGLINK
);
1214 assign_string (¤t_link_name
, link_name
);
1216 current_stat
.st_size
= 0;
1217 header
= start_header (p
, ¤t_stat
);
1218 strncpy (header
->header
.linkname
,
1219 link_name
, NAME_FIELD_SIZE
);
1221 /* Force null truncated. */
1223 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = 0;
1225 header
->header
.typeflag
= LNKTYPE
;
1226 finish_header (header
);
1228 /* FIXME: Maybe remove from list after all links found? */
1230 if (remove_files_option
)
1231 if (unlink (p
) == -1)
1232 ERROR ((0, errno
, _("Cannot remove %s"), p
));
1238 /* Not found. Add it to the list of possible links. */
1240 lp
= xmalloc (sizeof (struct link
) + strlen (p
));
1241 lp
->ino
= current_stat
.st_ino
;
1242 lp
->dev
= current_stat
.st_dev
;
1243 strcpy (lp
->name
, p
);
1244 lp
->next
= linklist
;
1248 /* This is not a link to a previously dumped file, so dump it. */
1250 if (S_ISREG (current_stat
.st_mode
)
1251 || S_ISCTG (current_stat
.st_mode
))
1253 int f
; /* file descriptor */
1259 char isextended
= 0;
1266 /* Check the size of the file against the number of blocks
1267 allocated for it, counting both data and indirect blocks.
1268 If there is a smaller number of blocks that would be
1269 necessary to accommodate a file of this size, this is safe
1270 to say that we have a sparse file: at least one of those
1271 blocks in the file is just a useless hole. For sparse
1272 files not having more hole blocks than indirect blocks, the
1273 sparseness will go undetected. */
1275 /* Bruno Haible sent me these statistics for Linux. It seems
1276 that some filesystems count indirect blocks in st_blocks,
1277 while others do not seem to:
1279 minix-fs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1280 extfs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1281 ext2fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1282 msdos-fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1284 Dick Streefland reports the previous numbers as misleading,
1285 because ext2fs use 12 direct blocks, while minix-fs uses only
1286 6 direct blocks. Dick gets:
1288 ext2 size=20480 ls listed blocks=21
1289 minix size=20480 ls listed blocks=21
1290 msdos size=20480 ls listed blocks=20
1292 It seems that indirect blocks *are* included in st_blocks.
1293 The minix filesystem does not account for phantom blocks in
1294 st_blocks, so `du' and `ls -s' give wrong results. So, the
1295 --sparse option would not work on a minix filesystem. */
1297 if (ST_NBLOCKS (current_stat
)
1298 < (current_stat
.st_size
/ ST_NBLOCKSIZE
1299 + (current_stat
.st_size
% ST_NBLOCKSIZE
!= 0)))
1301 off_t filesize
= current_stat
.st_size
;
1304 header
= start_header (p
, ¤t_stat
);
1305 header
->header
.typeflag
= GNUTYPE_SPARSE
;
1308 /* Call the routine that figures out the layout of the
1309 sparse file in question. UPPERBOUND is the index of the
1310 last element of the "sparsearray," i.e., the number of
1311 elements it needed to describe the file. */
1313 upperbound
= deal_with_sparse (p
, header
);
1315 /* See if we'll need an extended header later. */
1317 if (upperbound
> SPARSES_IN_OLDGNU_HEADER
- 1)
1318 header
->oldgnu_header
.isextended
= 1;
1320 /* We store the "real" file size so we can show that in
1321 case someone wants to list the archive, i.e., tar tvf
1322 <file>. It might be kind of disconcerting if the
1323 shrunken file size was the one that showed up. */
1325 OFF_TO_CHARS (current_stat
.st_size
,
1326 header
->oldgnu_header
.realsize
);
1328 /* This will be the new "size" of the file, i.e., the size
1329 of the file minus the blocks of holes that we're
1332 find_new_file_size (&filesize
, upperbound
);
1333 current_stat
.st_size
= filesize
;
1334 OFF_TO_CHARS (filesize
, header
->header
.size
);
1336 for (counter
= 0; counter
< SPARSES_IN_OLDGNU_HEADER
; counter
++)
1338 if (!sparsearray
[counter
].numbytes
)
1341 OFF_TO_CHARS (sparsearray
[counter
].offset
,
1342 header
->oldgnu_header
.sp
[counter
].offset
);
1343 SIZE_TO_CHARS (sparsearray
[counter
].numbytes
,
1344 header
->oldgnu_header
.sp
[counter
].numbytes
);
1350 upperbound
= SPARSES_IN_OLDGNU_HEADER
- 1;
1352 sizeleft
= current_stat
.st_size
;
1354 /* Don't bother opening empty, world readable files. Also do not open
1355 files when archive is meant for /dev/null. */
1359 && MODE_R
== (MODE_R
& current_stat
.st_mode
)))
1363 f
= open (p
, O_RDONLY
| O_BINARY
);
1366 if (! top_level
&& errno
== ENOENT
)
1367 WARN ((0, 0, _("%s: file removed before we read it"), p
));
1369 WARN ((0, errno
, _("Cannot add file %s"), p
));
1370 if (!ignore_failed_read_option
)
1371 exit_status
= TAREXIT_FAILURE
;
1376 /* If the file is sparse, we've already taken care of this. */
1379 header
= start_header (p
, ¤t_stat
);
1381 /* Mark contiguous files, if we support them. */
1383 if (archive_format
!= V7_FORMAT
&& S_ISCTG (current_stat
.st_mode
))
1384 header
->header
.typeflag
= CONTTYPE
;
1386 isextended
= header
->oldgnu_header
.isextended
;
1387 save_typeflag
= header
->header
.typeflag
;
1388 finish_header (header
);
1392 /* static */ int index_offset
= SPARSES_IN_OLDGNU_HEADER
;
1395 exhdr
= find_next_block ();
1396 memset (exhdr
->buffer
, 0, BLOCKSIZE
);
1397 for (counter
= 0; counter
< SPARSES_IN_SPARSE_HEADER
; counter
++)
1399 if (counter
+ index_offset
> upperbound
)
1402 SIZE_TO_CHARS (sparsearray
[counter
+ index_offset
].numbytes
,
1403 exhdr
->sparse_header
.sp
[counter
].numbytes
);
1404 OFF_TO_CHARS (sparsearray
[counter
+ index_offset
].offset
,
1405 exhdr
->sparse_header
.sp
[counter
].offset
);
1407 set_next_block_after (exhdr
);
1408 if (index_offset
+ counter
<= upperbound
)
1410 index_offset
+= counter
;
1411 exhdr
->sparse_header
.isextended
= 1;
1416 if (save_typeflag
== GNUTYPE_SPARSE
)
1419 || finish_sparse_file (f
, &sizeleft
, current_stat
.st_size
, p
))
1423 while (sizeleft
> 0)
1425 if (multi_volume_option
)
1427 assign_string (&save_name
, p
);
1428 save_sizeleft
= sizeleft
;
1429 save_totsize
= current_stat
.st_size
;
1431 start
= find_next_block ();
1433 bufsize
= available_space_after (start
);
1435 if (sizeleft
< bufsize
)
1437 /* Last read -- zero out area beyond. */
1440 count
= bufsize
% BLOCKSIZE
;
1442 memset (start
->buffer
+ sizeleft
, 0, BLOCKSIZE
- count
);
1447 count
= safe_read (f
, start
->buffer
, bufsize
);
1450 char buf
[UINTMAX_STRSIZE_BOUND
];
1452 _("Read error at byte %s, reading %lu bytes, in file %s"),
1453 STRINGIFY_BIGINT (current_stat
.st_size
- sizeleft
,
1455 (unsigned long) bufsize
, p
));
1460 /* This is nonportable (the type of set_next_block_after's arg). */
1462 set_next_block_after (start
+ (count
- 1) / BLOCKSIZE
);
1464 if (count
== bufsize
)
1468 char buf
[UINTMAX_STRSIZE_BOUND
];
1470 _("File %s shrunk by %s bytes, padding with zeros"),
1471 p
, STRINGIFY_BIGINT (sizeleft
, buf
)));
1472 goto padit
; /* short read */
1476 if (multi_volume_option
)
1477 assign_string (&save_name
, 0);
1481 struct stat final_stat
;
1482 if (fstat (f
, &final_stat
) != 0)
1483 ERROR ((0, errno
, "%s: fstat", p
));
1484 else if (final_stat
.st_ctime
!= original_ctime
)
1485 ERROR ((0, 0, _("%s: file changed as we read it"), p
));
1487 ERROR ((0, errno
, _("%s: close"), p
));
1488 if (atime_preserve_option
)
1489 utime (p
, &restore_times
);
1491 if (remove_files_option
)
1493 if (unlink (p
) == -1)
1494 ERROR ((0, errno
, _("Cannot remove %s"), p
));
1498 /* File shrunk or gave error, pad out tape to match the size we
1499 specified in the header. */
1502 while (sizeleft
> 0)
1504 save_sizeleft
= sizeleft
;
1505 start
= find_next_block ();
1506 memset (start
->buffer
, 0, BLOCKSIZE
);
1507 set_next_block_after (start
);
1508 sizeleft
-= BLOCKSIZE
;
1510 if (multi_volume_option
)
1511 assign_string (&save_name
, 0);
1515 if (atime_preserve_option
)
1516 utime (p
, &restore_times
);
1520 #ifdef HAVE_READLINK
1521 else if (S_ISLNK (current_stat
.st_mode
))
1524 char *buffer
= (char *) alloca (PATH_MAX
+ 1);
1526 size
= readlink (p
, buffer
, PATH_MAX
+ 1);
1529 WARN ((0, errno
, _("Cannot add file %s"), p
));
1530 if (!ignore_failed_read_option
)
1531 exit_status
= TAREXIT_FAILURE
;
1534 buffer
[size
] = '\0';
1535 if (size
>= NAME_FIELD_SIZE
)
1536 write_long (buffer
, GNUTYPE_LONGLINK
);
1537 assign_string (¤t_link_name
, buffer
);
1539 current_stat
.st_size
= 0; /* force 0 size on symlink */
1540 header
= start_header (p
, ¤t_stat
);
1541 strncpy (header
->header
.linkname
, buffer
, NAME_FIELD_SIZE
);
1542 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = '\0';
1543 header
->header
.typeflag
= SYMTYPE
;
1544 finish_header (header
); /* nothing more to do to it */
1545 if (remove_files_option
)
1547 if (unlink (p
) == -1)
1548 ERROR ((0, errno
, _("Cannot remove %s"), p
));
1553 else if (S_ISCHR (current_stat
.st_mode
))
1555 else if (S_ISBLK (current_stat
.st_mode
))
1557 else if (S_ISFIFO (current_stat
.st_mode
)
1558 || S_ISSOCK (current_stat
.st_mode
))
1561 else if (S_ISDOOR (current_stat
.st_mode
))
1563 WARN ((0, 0, _("%s: door ignored"), p
));
1571 if (archive_format
== V7_FORMAT
)
1574 current_stat
.st_size
= 0; /* force 0 size */
1575 header
= start_header (p
, ¤t_stat
);
1576 header
->header
.typeflag
= type
;
1578 if (type
!= FIFOTYPE
)
1580 MAJOR_TO_CHARS (major (current_stat
.st_rdev
), header
->header
.devmajor
);
1581 MINOR_TO_CHARS (minor (current_stat
.st_rdev
), header
->header
.devminor
);
1584 finish_header (header
);
1585 if (remove_files_option
)
1587 if (unlink (p
) == -1)
1588 ERROR ((0, errno
, _("Cannot remove %s"), p
));
1593 ERROR ((0, 0, _("%s: Unknown file type; file ignored"), p
));