1 /* Create a tar archive.
3 Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
4 2003 Free Software Foundation, Inc.
6 Written by John Gilmore, on 1985-08-25.
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any later
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
16 Public License for more details.
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
47 /* The maximum uintmax_t value that can be represented with DIGITS digits,
48 assuming that each digit is BITS_PER_DIGIT wide. */
49 #define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
50 ((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
51 ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
54 /* Convert VALUE to an octal representation suitable for tar headers.
55 Output to buffer WHERE with size SIZE.
56 The result is undefined if SIZE is 0 or if VALUE is too large to fit. */
59 to_octal (uintmax_t value
, char *where
, size_t size
)
66 where
[--i
] = '0' + (v
& ((1 << LG_8
) - 1));
72 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
73 tar headers. NEGATIVE is 1 if VALUE was negative before being cast
74 to uintmax_t, 0 otherwise. Output to buffer WHERE with size SIZE.
75 The result is undefined if SIZE is 0 or if VALUE is too large to
79 to_base256 (int negative
, uintmax_t value
, char *where
, size_t size
)
82 uintmax_t propagated_sign_bits
=
83 ((uintmax_t) - negative
<< (CHAR_BIT
* sizeof v
- LG_256
));
88 where
[--i
] = v
& ((1 << LG_256
) - 1);
89 v
= propagated_sign_bits
| (v
>> LG_256
);
94 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
95 external form, using SUBSTITUTE (...) if VALUE won't fit. Output
96 to buffer WHERE with size SIZE. NEGATIVE is 1 iff VALUE was
97 negative before being cast to uintmax_t; its original bitpattern
98 can be deduced from VALSIZE, its original size before casting.
99 TYPE is the kind of value being output (useful for diagnostics).
100 Prefer the POSIX format of SIZE - 1 octal digits (with leading zero
101 digits), followed by '\0'. If this won't work, and if GNU or
102 OLDGNU format is allowed, use '\200' followed by base-256, or (if
103 NEGATIVE is nonzero) '\377' followed by two's complement base-256.
104 If neither format works, use SUBSTITUTE (...) instead. Pass to
105 SUBSTITUTE the address of an 0-or-1 flag recording whether the
106 substitute value is negative. */
109 to_chars (int negative
, uintmax_t value
, size_t valsize
,
110 uintmax_t (*substitute
) (int *),
111 char *where
, size_t size
, const char *type
)
113 int base256_allowed
= (archive_format
== GNU_FORMAT
114 || archive_format
== OLDGNU_FORMAT
);
116 /* Generate the POSIX octal representation if the number fits. */
117 if (! negative
&& value
<= MAX_VAL_WITH_DIGITS (size
- 1, LG_8
))
119 where
[size
- 1] = '\0';
120 to_octal (value
, where
, size
- 1);
123 /* Otherwise, generate the base-256 representation if we are
124 generating an old or new GNU format and if the number fits. */
125 else if (((negative
? -1 - value
: value
)
126 <= MAX_VAL_WITH_DIGITS (size
- 1, LG_256
))
129 where
[0] = negative
? -1 : 1 << (LG_256
- 1);
130 to_base256 (negative
, value
, where
+ 1, size
- 1);
133 /* Otherwise, if the number is negative, and if it would not cause
134 ambiguity on this host by confusing positive with negative
135 values, then generate the POSIX octal representation of the value
136 modulo 2**(field bits). The resulting tar file is
137 machine-dependent, since it depends on the host word size. Yuck!
138 But this is the traditional behavior. */
139 else if (negative
&& valsize
* CHAR_BIT
<= (size
- 1) * LG_8
)
141 static int warned_once
;
145 WARN ((0, 0, _("Generating negative octal headers")));
147 where
[size
- 1] = '\0';
148 to_octal (value
& MAX_VAL_WITH_DIGITS (valsize
* CHAR_BIT
, 1),
152 /* Otherwise, output a substitute value if possible (with a
153 warning), and an error message if not. */
156 uintmax_t maxval
= (base256_allowed
157 ? MAX_VAL_WITH_DIGITS (size
- 1, LG_256
)
158 : MAX_VAL_WITH_DIGITS (size
- 1, LG_8
));
159 char valbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
160 char maxbuf
[UINTMAX_STRSIZE_BOUND
];
161 char minbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
162 char const *minval_string
;
163 char const *maxval_string
= STRINGIFY_BIGINT (maxval
, maxbuf
);
164 char const *value_string
;
168 uintmax_t m
= maxval
+ 1 ? maxval
+ 1 : maxval
/ 2 + 1;
169 char *p
= STRINGIFY_BIGINT (m
, minbuf
+ 1);
178 char *p
= STRINGIFY_BIGINT (- value
, valbuf
+ 1);
183 value_string
= STRINGIFY_BIGINT (value
, valbuf
);
188 uintmax_t sub
= substitute (&negsub
) & maxval
;
189 uintmax_t s
= (negsub
&= archive_format
== GNU_FORMAT
) ? - sub
: sub
;
190 char subbuf
[UINTMAX_STRSIZE_BOUND
+ 1];
191 char *sub_string
= STRINGIFY_BIGINT (s
, subbuf
+ 1);
194 WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
195 value_string
, type
, minval_string
, maxval_string
,
197 to_chars (negsub
, s
, valsize
, 0, where
, size
, type
);
200 ERROR ((0, 0, _("value %s out of %s range %s..%s"),
201 value_string
, type
, minval_string
, maxval_string
));
206 gid_substitute (int *negative
)
212 static gid_t gid_nobody
;
213 if (!gid_nobody
&& !gname_to_gid ("nobody", &gid_nobody
))
222 gid_to_chars (gid_t v
, char *p
, size_t s
)
224 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, gid_substitute
, p
, s
, "gid_t");
228 major_to_chars (major_t v
, char *p
, size_t s
)
230 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "major_t");
234 minor_to_chars (minor_t v
, char *p
, size_t s
)
236 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "minor_t");
240 mode_to_chars (mode_t v
, char *p
, size_t s
)
242 /* In the common case where the internal and external mode bits are the same,
243 and we are not using POSIX or GNU format,
244 propagate all unknown bits to the external mode.
245 This matches historical practice.
246 Otherwise, just copy the bits we know about. */
249 if (S_ISUID
== TSUID
&& S_ISGID
== TSGID
&& S_ISVTX
== TSVTX
250 && S_IRUSR
== TUREAD
&& S_IWUSR
== TUWRITE
&& S_IXUSR
== TUEXEC
251 && S_IRGRP
== TGREAD
&& S_IWGRP
== TGWRITE
&& S_IXGRP
== TGEXEC
252 && S_IROTH
== TOREAD
&& S_IWOTH
== TOWRITE
&& S_IXOTH
== TOEXEC
253 && archive_format
!= POSIX_FORMAT
254 && archive_format
!= GNU_FORMAT
)
262 u
= ((v
& S_ISUID
? TSUID
: 0)
263 | (v
& S_ISGID
? TSGID
: 0)
264 | (v
& S_ISVTX
? TSVTX
: 0)
265 | (v
& S_IRUSR
? TUREAD
: 0)
266 | (v
& S_IWUSR
? TUWRITE
: 0)
267 | (v
& S_IXUSR
? TUEXEC
: 0)
268 | (v
& S_IRGRP
? TGREAD
: 0)
269 | (v
& S_IWGRP
? TGWRITE
: 0)
270 | (v
& S_IXGRP
? TGEXEC
: 0)
271 | (v
& S_IROTH
? TOREAD
: 0)
272 | (v
& S_IWOTH
? TOWRITE
: 0)
273 | (v
& S_IXOTH
? TOEXEC
: 0));
275 to_chars (negative
, u
, sizeof v
, 0, p
, s
, "mode_t");
279 off_to_chars (off_t v
, char *p
, size_t s
)
281 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "off_t");
285 size_to_chars (size_t v
, char *p
, size_t s
)
287 to_chars (0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "size_t");
291 time_to_chars (time_t v
, char *p
, size_t s
)
293 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, 0, p
, s
, "time_t");
297 uid_substitute (int *negative
)
303 static uid_t uid_nobody
;
304 if (!uid_nobody
&& !uname_to_uid ("nobody", &uid_nobody
))
313 uid_to_chars (uid_t v
, char *p
, size_t s
)
315 to_chars (v
< 0, (uintmax_t) v
, sizeof v
, uid_substitute
, p
, s
, "uid_t");
319 uintmax_to_chars (uintmax_t v
, char *p
, size_t s
)
321 to_chars (0, v
, sizeof v
, 0, p
, s
, "uintmax_t");
325 string_to_chars (char *str
, char *p
, size_t s
)
332 /* Writing routines. */
334 /* Zero out the buffer so we don't confuse ourselves with leftover
337 clear_buffer (char *buffer
)
339 memset (buffer
, 0, BLOCKSIZE
);
342 /* Write the EOT block(s). Zero at least two blocks, through the end
343 of the record. Old tar, as previous versions of GNU tar, writes
344 garbage after two zeroed blocks. */
348 union block
*pointer
= find_next_block ();
349 memset (pointer
->buffer
, 0, BLOCKSIZE
);
350 set_next_block_after (pointer
);
351 pointer
= find_next_block ();
352 memset (pointer
->buffer
, 0, available_space_after (pointer
));
353 set_next_block_after (pointer
);
356 /* Write a "private" header */
358 start_private_header (const char *name
, size_t size
)
361 union block
*header
= find_next_block ();
363 memset (header
->buffer
, 0, sizeof (union block
));
365 strncpy (header
->header
.name
, name
, NAME_FIELD_SIZE
);
366 header
->header
.name
[NAME_FIELD_SIZE
- 1] = '\0';
367 OFF_TO_CHARS (size
, header
->header
.size
);
370 TIME_TO_CHARS (t
, header
->header
.mtime
);
371 MODE_TO_CHARS (S_IFREG
|S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
, header
->header
.mode
);
372 UID_TO_CHARS (getuid (), header
->header
.uid
);
373 GID_TO_CHARS (getgid (), header
->header
.gid
);
374 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
375 MAJOR_TO_CHARS (0, header
->header
.devminor
);
376 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
377 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
381 /* Create a new header and store there at most NAME_FIELD_SIZE bytes of
385 write_short_name (struct tar_stat_info
*st
)
387 union block
*header
= find_next_block ();
388 memset (header
->buffer
, 0, sizeof (union block
));
390 strncpy (header
->header
.name
, st
->file_name
, NAME_FIELD_SIZE
);
391 header
->header
.name
[NAME_FIELD_SIZE
- 1] = '\0';
395 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. */
397 write_gnu_long_link (const char *p
, char type
)
399 size_t size
= strlen (p
) + 1;
403 header
= start_private_header ("././@LongLink", size
);
404 header
->header
.typeflag
= type
;
405 finish_header (header
, -1);
407 header
= find_next_block ();
409 bufsize
= available_space_after (header
);
411 while (bufsize
< size
)
413 memcpy (header
->buffer
, p
, bufsize
);
416 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
417 header
= find_next_block ();
418 bufsize
= available_space_after (header
);
420 memcpy (header
->buffer
, p
, size
);
421 memset (header
->buffer
+ size
, 0, bufsize
- size
);
422 set_next_block_after (header
+ (size
- 1) / BLOCKSIZE
);
426 split_long_name (const char *name
, size_t length
)
430 if (length
> PREFIX_FIELD_SIZE
)
431 length
= PREFIX_FIELD_SIZE
+2;
432 for (i
= length
- 1; i
> 0; i
--)
433 if (ISSLASH (name
[i
]))
439 write_ustar_long_name (const char *name
)
441 size_t length
= strlen (name
);
445 if (length
> PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1)
447 WARN ((0, 0, _("%s: file name is too long (max %d); not dumped"),
448 quotearg_colon (name
),
449 PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1));
453 i
= split_long_name (name
, length
);
457 _("%s: file name is too long (cannot be split); not dumped"),
458 quotearg_colon (name
),
459 PREFIX_FIELD_SIZE
+ NAME_FIELD_SIZE
+ 1));
463 header
= find_next_block ();
464 memset (header
->buffer
, 0, sizeof (header
->buffer
));
465 memcpy (header
->header
.prefix
, name
, i
);
466 memcpy (header
->header
.name
, name
+ i
+ 1, length
- i
);
471 /* Write a long link name, depending on the current archive format */
473 write_long_link (struct tar_stat_info
*st
)
475 switch (archive_format
)
478 xheader_store ("linkpath", st
);
481 case V7_FORMAT
: /* old V7 tar format */
485 _("%s: link name is too long; not dumped"),
486 quotearg_colon (st
->link_name
)));
491 write_gnu_long_link (st
->link_name
, GNUTYPE_LONGLINK
);
500 write_long_name (struct tar_stat_info
*st
)
502 switch (archive_format
)
505 xheader_store ("path", st
);
511 return write_ustar_long_name (st
->file_name
);
515 write_gnu_long_link (st
->file_name
, GNUTYPE_LONGNAME
);
521 return write_short_name (st
);
525 write_extended (union block
*old_header
, char type
)
527 union block
*header
, hp
;
528 struct tar_stat_info foo
;
532 if (extended_header
.buffer
|| extended_header
.stk
== NULL
)
535 xheader_finish (&extended_header
);
536 size
= extended_header
.size
;
538 memcpy (hp
.buffer
, old_header
, sizeof (hp
));
540 header
= start_private_header ("././@PaxHeader", size
);
541 header
->header
.typeflag
= type
;
543 finish_header (header
, -1);
545 p
= extended_header
.buffer
;
551 header
= find_next_block ();
555 memcpy (header
->buffer
, p
, len
);
557 memset (header
->buffer
+ len
, 0, BLOCKSIZE
- len
);
560 set_next_block_after (header
);
564 xheader_destroy (&extended_header
);
565 header
= find_next_block ();
566 memcpy (header
, &hp
.buffer
, sizeof (hp
.buffer
));
571 write_header_name (struct tar_stat_info
*st
)
573 if (NAME_FIELD_SIZE
<= strlen (st
->file_name
))
574 return write_long_name (st
);
576 return write_short_name (st
);
580 /* Header handling. */
582 /* Make a header block for the file whose stat info is st,
583 and return its address. */
586 start_header (const char *name
, struct tar_stat_info
*st
)
590 name
= safer_name_suffix (name
, 0);
591 if (name
[0] == '.' && name
[1] == 0) /*FIXME!!!*/
593 assign_string (&st
->file_name
, name
);
595 header
= write_header_name (st
);
599 assign_string (¤t_stat_info
.file_name
, name
);
601 /* Override some stat fields, if requested to do so. */
603 if (owner_option
!= (uid_t
) -1)
604 st
->stat
.st_uid
= owner_option
;
605 if (group_option
!= (gid_t
) -1)
606 st
->stat
.st_gid
= group_option
;
608 st
->stat
.st_mode
= ((st
->stat
.st_mode
& ~MODE_ALL
)
609 | mode_adjust (st
->stat
.st_mode
, mode_option
));
611 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
612 for a few tars and came up with the following interoperability
616 1 2 3 4 5 6 7 8 9 READER
617 . . . . . . . . . 1 = SunOS 4.2 tar
618 # . . # # . . # # 2 = NEC SVR4.0.2 tar
619 . . . # # . . # . 3 = Solaris 2.1 tar
620 . . . . . . . . . 4 = GNU tar 1.11.1
621 . . . . . . . . . 5 = HP-UX 8.07 tar
622 . . . . . . . . . 6 = Ultrix 4.1
623 . . . . . . . . . 7 = AIX 3.2
624 . . . . . . . . . 8 = Hitachi HI-UX 1.03
625 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
628 # = ``impossible file type''
630 The following mask for old archive removes the `#'s in column 4
631 above, thus making GNU tar both a universal donor and a universal
632 acceptor for Paul's test. */
634 if (archive_format
== V7_FORMAT
|| archive_format
== USTAR_FORMAT
)
635 MODE_TO_CHARS (st
->stat
.st_mode
& MODE_ALL
, header
->header
.mode
);
637 MODE_TO_CHARS (st
->stat
.st_mode
, header
->header
.mode
);
639 if (st
->stat
.st_uid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
640 xheader_store ("uid", st
);
642 UID_TO_CHARS (st
->stat
.st_uid
, header
->header
.uid
);
644 if (st
->stat
.st_gid
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
645 xheader_store ("gid", st
);
647 GID_TO_CHARS (st
->stat
.st_gid
, header
->header
.gid
);
649 if (st
->stat
.st_size
> MAXOCTAL11
&& archive_format
== POSIX_FORMAT
)
650 xheader_store ("size", st
);
652 OFF_TO_CHARS (st
->stat
.st_size
, header
->header
.size
);
654 TIME_TO_CHARS (st
->stat
.st_mtime
, header
->header
.mtime
);
657 if (S_ISCHR (st
->stat
.st_mode
)
658 || S_ISBLK (st
->stat
.st_mode
))
660 st
->devmajor
= major (st
->stat
.st_rdev
);
661 st
->devminor
= minor (st
->stat
.st_rdev
);
663 if (st
->devmajor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
664 xheader_store ("devmajor", st
);
666 MAJOR_TO_CHARS (st
->devmajor
, header
->header
.devmajor
);
668 if (st
->devminor
> MAXOCTAL7
&& archive_format
== POSIX_FORMAT
)
669 xheader_store ("devminor", st
);
671 MAJOR_TO_CHARS (st
->devminor
, header
->header
.devminor
);
675 MAJOR_TO_CHARS (0, header
->header
.devmajor
);
676 MINOR_TO_CHARS (0, header
->header
.devminor
);
679 if (archive_format
== POSIX_FORMAT
)
681 xheader_store ("atime", st
);
682 xheader_store ("ctime", st
);
684 else if (incremental_option
)
685 if (archive_format
== OLDGNU_FORMAT
)
687 TIME_TO_CHARS (st
->stat
.st_atime
, header
->oldgnu_header
.atime
);
688 TIME_TO_CHARS (st
->stat
.st_ctime
, header
->oldgnu_header
.ctime
);
691 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
693 switch (archive_format
)
699 /* Overwrite header->header.magic and header.version in one blow. */
700 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
705 case GNU_FORMAT
: /*FIXME?*/
706 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
707 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
714 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
716 /* header->header.[ug]name are left as the empty string. */
720 uid_to_uname (st
->stat
.st_uid
, &st
->uname
);
721 gid_to_gname (st
->stat
.st_gid
, &st
->gname
);
723 if (archive_format
== POSIX_FORMAT
724 && strlen (st
->uname
) > UNAME_FIELD_SIZE
)
725 xheader_store ("uname", st
);
727 UNAME_TO_CHARS (st
->uname
, header
->header
.uname
);
729 if (archive_format
== POSIX_FORMAT
730 && strlen (st
->gname
) > GNAME_FIELD_SIZE
)
731 xheader_store ("gname", st
);
733 GNAME_TO_CHARS (st
->gname
, header
->header
.gname
);
739 /* Finish off a filled-in header block and write it out. We also
740 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
741 is not negative, is the block ordinal of the first record for this
742 file, which may be a preceding long name or long link record. */
744 finish_header (union block
*header
, off_t block_ordinal
)
750 /* Note: It is important to do this before the call to write_extended(),
751 so that the actual ustar header is printed */
753 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
754 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
755 && header
->header
.typeflag
!= XHDTYPE
756 && header
->header
.typeflag
!= XGLTYPE
)
758 /* These globals are parameters to print_header, sigh. */
760 current_header
= header
;
761 /* current_stat_info is already set up. */
762 current_format
= archive_format
;
763 print_header (block_ordinal
);
766 header
= write_extended (header
, XHDTYPE
);
768 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof header
->header
.chksum
);
772 for (i
= sizeof *header
; i
-- != 0; )
773 /* We can't use unsigned char here because of old compilers, e.g. V7. */
776 /* Fill in the checksum field. It's formatted differently from the
777 other fields: it has [6] digits, a null, then a space -- rather than
778 digits, then a null. We use to_chars.
779 The final space is already there, from
780 checksumming, and to_chars doesn't modify it.
782 This is a fast way to do:
784 sprintf(header->header.chksum, "%6o", sum); */
786 uintmax_to_chars ((uintmax_t) sum
, header
->header
.chksum
, 7);
788 set_next_block_after (header
);
791 /* Sparse file processing. */
793 /* Takes a blockful of data and basically cruises through it to see if
794 it's made *entirely* of zeros, returning a 0 the instant it finds
795 something that is a nonzero, i.e., useful data. */
797 zero_block_p (char *buffer
)
801 for (counter
= 0; counter
< BLOCKSIZE
; counter
++)
802 if (buffer
[counter
] != '\0')
808 init_sparsearray (void)
811 sp_array_size
= SPARSES_IN_OLDGNU_HEADER
;
812 sparsearray
= xmalloc (sp_array_size
* sizeof *sparsearray
);
816 find_new_file_size (int sparses
)
820 for (i
= 0; i
< sparses
; i
++)
821 s
+= sparsearray
[i
].numbytes
;
825 /* Make one pass over the file NAME, studying where any non-zero data
826 is, that is, how far into the file each instance of data is, and
827 how many bytes are there. Save this information in the
828 sparsearray, which will later be translated into header
831 /* There is little point in trimming small amounts of null data at the head
832 and tail of blocks, only avoid dumping full null blocks. */
834 /* FIXME: this routine might accept bits of algorithmic cleanup, it is
835 too kludgey for my taste... */
838 deal_with_sparse (char *name
, union block
*header
)
845 char buffer
[BLOCKSIZE
];
847 if (archive_format
== OLDGNU_FORMAT
)
848 header
->oldgnu_header
.isextended
= 0;
850 if (file
= open (name
, O_RDONLY
), file
< 0)
851 /* This problem will be caught later on, so just return. */
855 clear_buffer (buffer
);
859 /* Realloc the scratch area as necessary. FIXME: should reallocate
860 only at beginning of a new instance of non-zero data. */
862 if (sp_array_size
<= sparses
)
865 xrealloc (sparsearray
,
866 2 * sp_array_size
* sizeof (struct sp_array
));
870 count
= safe_read (file
, buffer
, sizeof buffer
);
874 /* Process one block. */
876 if (count
== sizeof buffer
)
878 if (zero_block_p (buffer
))
882 sparsearray
[sparses
++].numbytes
= numbytes
;
889 sparsearray
[sparses
].offset
= offset
;
895 /* Since count < sizeof buffer, we have the last bit of the file. */
897 if (!zero_block_p (buffer
))
900 sparsearray
[sparses
].offset
= offset
;
904 /* The next two lines are suggested by Andreas Degert, who says
905 they are required for trailing full blocks to be written to the
906 archive, when all zeroed. Yet, it seems to me that the case
907 does not apply. Further, at restore time, the file is not as
908 sparse as it should. So, some serious cleanup is *also* needed
909 in this area. Just one more... :-(. FIXME. */
913 /* Prepare for next block. */
916 /* FIXME: do not clear unless necessary. */
917 clear_buffer (buffer
);
921 sparsearray
[sparses
++].numbytes
= numbytes
;
924 sparsearray
[sparses
].offset
= offset
- 1;
925 sparsearray
[sparses
++].numbytes
= 1;
928 return close (file
) == 0 && 0 <= count
? sparses
: 0;
932 finish_sparse_file (int file
, off_t
*sizeleft
, off_t fullsize
, char *name
)
939 while (*sizeleft
> 0)
941 start
= find_next_block ();
942 memset (start
->buffer
, 0, BLOCKSIZE
);
943 bufsize
= sparsearray
[sparses
].numbytes
;
947 if (lseek (file
, sparsearray
[sparses
++].offset
, SEEK_SET
) < 0)
949 (ignore_failed_read_option
? seek_warn_details
: seek_error_details
)
950 (name
, sparsearray
[sparses
- 1].offset
);
954 /* If the number of bytes to be written here exceeds the size of
955 the temporary buffer, do it in steps. */
957 while (bufsize
> BLOCKSIZE
)
959 count
= safe_read (file
, start
->buffer
, BLOCKSIZE
);
962 (ignore_failed_read_option
964 : read_error_details
)
965 (name
, fullsize
- *sizeleft
, bufsize
);
970 set_next_block_after (start
);
971 start
= find_next_block ();
972 memset (start
->buffer
, 0, BLOCKSIZE
);
976 char buffer
[BLOCKSIZE
];
978 clear_buffer (buffer
);
979 count
= safe_read (file
, buffer
, bufsize
);
980 memcpy (start
->buffer
, buffer
, BLOCKSIZE
);
985 (ignore_failed_read_option
987 : read_error_details
)
988 (name
, fullsize
- *sizeleft
, bufsize
);
993 set_next_block_after (start
);
997 set_next_block_after (start
+ (count
- 1) / BLOCKSIZE
);
1002 /* Main functions of this module. */
1005 create_archive (void)
1009 open_archive (ACCESS_WRITE
);
1011 if (incremental_option
)
1013 size_t buffer_size
= 1000;
1014 char *buffer
= xmalloc (buffer_size
);
1017 collect_and_sort_names ();
1019 while (p
= name_from_list (), p
)
1020 if (!excluded_name (p
))
1021 dump_file (p
, -1, (dev_t
) 0);
1024 while (p
= name_from_list (), p
)
1025 if (!excluded_name (p
))
1027 size_t plen
= strlen (p
);
1028 if (buffer_size
<= plen
)
1030 while ((buffer_size
*= 2) <= plen
)
1032 buffer
= xrealloc (buffer
, buffer_size
);
1034 memcpy (buffer
, p
, plen
);
1035 if (! ISSLASH (buffer
[plen
- 1]))
1036 buffer
[plen
++] = '/';
1037 q
= gnu_list_name
->dir_contents
;
1041 size_t qlen
= strlen (q
);
1044 if (buffer_size
< plen
+ qlen
)
1046 while ((buffer_size
*=2 ) < plen
+ qlen
)
1048 buffer
= xrealloc (buffer
, buffer_size
);
1050 strcpy (buffer
+ plen
, q
+ 1);
1051 dump_file (buffer
, -1, (dev_t
) 0);
1060 while (p
= name_next (1), p
)
1061 if (!excluded_name (p
))
1062 dump_file (p
, 1, (dev_t
) 0);
1068 if (listed_incremental_option
)
1069 write_directory_file ();
1073 /* Calculate the hash of a link. */
1075 hash_link (void const *entry
, unsigned n_buckets
)
1077 struct link
const *link
= entry
;
1078 return (uintmax_t) (link
->dev
^ link
->ino
) % n_buckets
;
1081 /* Compare two links for equality. */
1083 compare_links (void const *entry1
, void const *entry2
)
1085 struct link
const *link1
= entry1
;
1086 struct link
const *link2
= entry2
;
1087 return ((link1
->dev
^ link2
->dev
) | (link1
->ino
^ link2
->ino
)) == 0;
1090 /* Table of all non-directories that we've written so far. Any time
1091 we see another, we check the table and avoid dumping the data
1092 again if we've done it once already. */
1093 static Hash_table
*link_table
;
1095 /* Dump a single file, recursing on directories. P is the file name
1096 to dump. TOP_LEVEL tells whether this is a top-level call; zero
1097 means no, positive means yes, and negative means the top level
1098 of an incremental dump. PARENT_DEVICE is the device of P's
1099 parent directory; it is examined only if TOP_LEVEL is zero.
1101 Set global CURRENT_STAT_INFO to stat output for this file. */
1103 /* FIXME: One should make sure that for *every* path leading to setting
1104 exit_status to failure, a clear diagnostic has been issued. */
1107 dump_file (char *p
, int top_level
, dev_t parent_device
)
1109 union block
*header
;
1113 time_t original_ctime
;
1114 struct utimbuf restore_times
;
1115 off_t block_ordinal
= -1;
1117 /* FIXME: `header' might be used uninitialized in this
1118 function. Reported by Bruno Haible. */
1120 if (interactive_option
&& !confirm ("add", p
))
1123 if (deref_stat (dereference_option
, p
, ¤t_stat_info
.stat
) != 0)
1125 if (ignore_failed_read_option
)
1132 original_ctime
= current_stat_info
.stat
.st_ctime
;
1133 restore_times
.actime
= current_stat_info
.stat
.st_atime
;
1134 restore_times
.modtime
= current_stat_info
.stat
.st_mtime
;
1137 if (S_ISHIDDEN (current_stat_info
.stat
.st_mode
))
1139 char *new = (char *) alloca (strlen (p
) + 2);
1149 /* See if we want only new files, and check if this one is too old to
1150 put in the archive. */
1152 if ((0 < top_level
|| !incremental_option
)
1153 && !S_ISDIR (current_stat_info
.stat
.st_mode
)
1154 && current_stat_info
.stat
.st_mtime
< newer_mtime_option
1155 && (!after_date_option
|| current_stat_info
.stat
.st_ctime
< newer_ctime_option
))
1158 WARN ((0, 0, _("%s: file is unchanged; not dumped"),
1159 quotearg_colon (p
)));
1160 /* FIXME: recheck this return. */
1164 /* See if we are trying to dump the archive. */
1165 if (sys_file_is_archive (¤t_stat_info
))
1167 WARN ((0, 0, _("%s: file is the archive; not dumped"),
1168 quotearg_colon (p
)));
1172 if (S_ISDIR (current_stat_info
.stat
.st_mode
))
1180 dev_t our_device
= current_stat_info
.stat
.st_dev
;
1184 directory
= savedir (p
);
1187 if (ignore_failed_read_option
)
1194 /* Build new prototype name. Ensure exactly one trailing slash. */
1197 buflen
= len
+ NAME_FIELD_SIZE
;
1198 namebuf
= xmalloc (buflen
+ 1);
1199 memcpy (namebuf
, p
, len
);
1200 while (len
>= 1 && ISSLASH (namebuf
[len
- 1]))
1202 namebuf
[len
++] = '/';
1203 namebuf
[len
] = '\0';
1205 if (! is_avoided_name (namebuf
))
1207 /* The condition above used to be "archive_format != V7_FORMAT".
1208 GNU tar was not writing directory blocks at all. Daniel Trinkle
1209 writes: ``All old versions of tar I have ever seen have
1210 correctly archived an empty directory. The really old ones I
1211 checked included HP-UX 7 and Mt. Xinu More/BSD. There may be
1212 some subtle reason for the exclusion that I don't know, but the
1213 current behavior is broken.'' I do not know those subtle
1214 reasons either, so until these are reported (anew?), just allow
1215 directory blocks to be written even with old archives. */
1217 block_ordinal
= current_block_ordinal ();
1218 current_stat_info
.stat
.st_size
= 0; /* force 0 size on dir */
1220 /* FIXME: If people could really read standard archives, this
1224 = start_header (standard_option ? p : namebuf, ¤t_stat_info);
1226 but since they'd interpret DIRTYPE blocks as regular
1227 files, we'd better put the / on the name. */
1229 header
= start_header (namebuf
, ¤t_stat_info
);
1233 if (incremental_option
)
1234 header
->header
.typeflag
= GNUTYPE_DUMPDIR
;
1235 else /* if (standard_option) */
1236 header
->header
.typeflag
= DIRTYPE
;
1238 /* If we're gnudumping, we aren't done yet so don't close it. */
1240 if (!incremental_option
)
1241 finish_header (header
, block_ordinal
);
1244 if (incremental_option
&& gnu_list_name
->dir_contents
)
1251 const char *buffer
, *p_buffer
;
1253 buffer
= gnu_list_name
->dir_contents
; /* FOO */
1256 for (p_buffer
= buffer
; *p_buffer
; )
1258 size_t size
= strlen (p_buffer
) + 1;
1263 OFF_TO_CHARS (totsize
, header
->header
.size
);
1264 finish_header (header
, block_ordinal
);
1267 while (sizeleft
> 0)
1269 if (multi_volume_option
)
1271 assign_string (&save_name
, p
);
1272 save_sizeleft
= sizeleft
;
1273 save_totsize
= totsize
;
1275 start
= find_next_block ();
1276 bufsize
= available_space_after (start
);
1277 if (sizeleft
< bufsize
)
1280 count
= bufsize
% BLOCKSIZE
;
1282 memset (start
->buffer
+ sizeleft
, 0, BLOCKSIZE
- count
);
1284 memcpy (start
->buffer
, p_buffer
, bufsize
);
1285 sizeleft
-= bufsize
;
1286 p_buffer
+= bufsize
;
1287 set_next_block_after (start
+ (bufsize
- 1) / BLOCKSIZE
);
1289 if (multi_volume_option
)
1290 assign_string (&save_name
, 0);
1294 /* See if we are about to recurse into a directory, and avoid doing
1295 so if the user wants that we do not descend into directories. */
1297 if (! recursion_option
)
1300 /* See if we are crossing from one file system to another, and
1301 avoid doing so if the user only wants to dump one file system. */
1303 if (one_file_system_option
&& !top_level
1304 && parent_device
!= current_stat_info
.stat
.st_dev
)
1308 _("%s: file is on a different filesystem; not dumped"),
1309 quotearg_colon (p
)));
1313 /* Now output all the files in the directory. */
1315 /* FIXME: Should speed this up by cd-ing into the dir. */
1317 for (entry
= directory
;
1318 (entrylen
= strlen (entry
)) != 0;
1319 entry
+= entrylen
+ 1)
1321 if (buflen
< len
+ entrylen
)
1323 buflen
= len
+ entrylen
;
1324 namebuf
= xrealloc (namebuf
, buflen
+ 1);
1326 strcpy (namebuf
+ len
, entry
);
1327 if (!excluded_name (namebuf
))
1328 dump_file (namebuf
, 0, our_device
);
1335 if (atime_preserve_option
)
1336 utime (p
, &restore_times
);
1339 else if (is_avoided_name (p
))
1343 /* Check for multiple links. */
1345 if (1 < current_stat_info
.stat
.st_nlink
&& link_table
)
1349 lp
.ino
= current_stat_info
.stat
.st_ino
;
1350 lp
.dev
= current_stat_info
.stat
.st_dev
;
1352 if ((dup
= hash_lookup (link_table
, &lp
)))
1354 /* We found a link. */
1355 char const *link_name
= safer_name_suffix (dup
->name
, 1);
1359 block_ordinal
= current_block_ordinal ();
1360 assign_string (¤t_stat_info
.link_name
, link_name
);
1361 if (NAME_FIELD_SIZE
<= strlen (link_name
))
1362 write_long_link (¤t_stat_info
);
1364 current_stat_info
.stat
.st_size
= 0;
1365 header
= start_header (p
, ¤t_stat_info
);
1368 strncpy (header
->header
.linkname
, link_name
, NAME_FIELD_SIZE
);
1370 /* Force null termination. */
1371 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = 0;
1373 header
->header
.typeflag
= LNKTYPE
;
1374 finish_header (header
, block_ordinal
);
1376 /* FIXME: Maybe remove from table after all links found? */
1378 if (remove_files_option
&& unlink (p
) != 0)
1381 /* We dumped it, and we don't need to put it in the
1387 /* This is not a link to a previously dumped file, so dump it. */
1389 if (S_ISREG (current_stat_info
.stat
.st_mode
)
1390 || S_ISCTG (current_stat_info
.stat
.st_mode
))
1392 int f
; /* file descriptor */
1398 char isextended
= 0;
1405 /* Check the size of the file against the number of blocks
1406 allocated for it, counting both data and indirect blocks.
1407 If there is a smaller number of blocks than would be
1408 necessary to accommodate a file of this size, this is safe
1409 to say that we have a sparse file: at least one of those
1410 blocks in the file is just a useless hole. For sparse
1411 files not having more hole blocks than indirect blocks, the
1412 sparseness will go undetected. */
1414 /* Bruno Haible sent me these statistics for Linux. It seems
1415 that some filesystems count indirect blocks in st_blocks,
1416 while others do not seem to:
1418 minix-fs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1419 extfs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1420 ext2fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1421 msdos-fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1423 Dick Streefland reports the previous numbers as misleading,
1424 because ext2fs use 12 direct blocks, while minix-fs uses only
1425 6 direct blocks. Dick gets:
1427 ext2 size=20480 ls listed blocks=21
1428 minix size=20480 ls listed blocks=21
1429 msdos size=20480 ls listed blocks=20
1431 It seems that indirect blocks *are* included in st_blocks.
1432 The minix filesystem does not account for phantom blocks in
1433 st_blocks, so `du' and `ls -s' give wrong results. So, the
1434 --sparse option would not work on a minix filesystem. */
1436 if (ST_NBLOCKS (current_stat_info
.stat
)
1437 < (current_stat_info
.stat
.st_size
/ ST_NBLOCKSIZE
1438 + (current_stat_info
.stat
.st_size
% ST_NBLOCKSIZE
!= 0)))
1442 block_ordinal
= current_block_ordinal ();
1443 header
= start_header (p
, ¤t_stat_info
);
1446 header
->header
.typeflag
= GNUTYPE_SPARSE
;
1449 /* Call the routine that figures out the layout of the
1450 sparse file in question. SPARSES is the index of the
1451 first unused element of the "sparsearray," i.e.,
1452 the number of elements it needed to describe the file. */
1454 sparses
= deal_with_sparse (p
, header
);
1456 /* See if we'll need an extended header later. */
1458 if (SPARSES_IN_OLDGNU_HEADER
< sparses
)
1459 header
->oldgnu_header
.isextended
= 1;
1461 /* We store the "real" file size so we can show that in
1462 case someone wants to list the archive, i.e., tar tvf
1463 <file>. It might be kind of disconcerting if the
1464 shrunken file size was the one that showed up. */
1466 OFF_TO_CHARS (current_stat_info
.stat
.st_size
,
1467 header
->oldgnu_header
.realsize
);
1469 /* This will be the new "size" of the file, i.e., the size
1470 of the file minus the blocks of holes that we're
1473 current_stat_info
.stat
.st_size
= find_new_file_size (sparses
);
1474 OFF_TO_CHARS (current_stat_info
.stat
.st_size
, header
->header
.size
);
1477 counter
< sparses
&& counter
< SPARSES_IN_OLDGNU_HEADER
;
1480 OFF_TO_CHARS (sparsearray
[counter
].offset
,
1481 header
->oldgnu_header
.sp
[counter
].offset
);
1482 SIZE_TO_CHARS (sparsearray
[counter
].numbytes
,
1483 header
->oldgnu_header
.sp
[counter
].numbytes
);
1488 sizeleft
= current_stat_info
.stat
.st_size
;
1490 /* Don't bother opening empty, world readable files. Also do not open
1491 files when archive is meant for /dev/null. */
1495 && MODE_R
== (MODE_R
& current_stat_info
.stat
.st_mode
)))
1499 f
= open (p
, O_RDONLY
| O_BINARY
);
1502 if (! top_level
&& errno
== ENOENT
)
1503 WARN ((0, 0, _("%s: File removed before we read it"),
1504 quotearg_colon (p
)));
1506 (ignore_failed_read_option
? open_warn
: open_error
) (p
);
1511 /* If the file is sparse, we've already taken care of this. */
1515 block_ordinal
= current_block_ordinal ();
1516 header
= start_header (p
, ¤t_stat_info
);
1521 /* Mark contiguous files, if we support them. */
1523 if (archive_format
!= V7_FORMAT
1524 && S_ISCTG (current_stat_info
.stat
.st_mode
))
1525 header
->header
.typeflag
= CONTTYPE
;
1527 if (archive_format
== GNU_FORMAT
|| archive_format
== OLDGNU_FORMAT
)
1528 isextended
= header
->oldgnu_header
.isextended
;
1533 save_typeflag
= header
->header
.typeflag
;
1534 finish_header (header
, block_ordinal
);
1537 int sparses_emitted
= SPARSES_IN_OLDGNU_HEADER
;
1542 exhdr
= find_next_block ();
1543 memset (exhdr
->buffer
, 0, BLOCKSIZE
);
1545 (i
< SPARSES_IN_SPARSE_HEADER
1546 && sparses_emitted
+ i
< sparses
);
1549 SIZE_TO_CHARS (sparsearray
[sparses_emitted
+ i
].numbytes
,
1550 exhdr
->sparse_header
.sp
[i
].numbytes
);
1551 OFF_TO_CHARS (sparsearray
[sparses_emitted
+ i
].offset
,
1552 exhdr
->sparse_header
.sp
[i
].offset
);
1554 set_next_block_after (exhdr
);
1555 sparses_emitted
+= i
;
1556 if (sparses
== sparses_emitted
)
1558 exhdr
->sparse_header
.isextended
= 1;
1561 if (save_typeflag
== GNUTYPE_SPARSE
)
1564 || finish_sparse_file (f
, &sizeleft
,
1565 current_stat_info
.stat
.st_size
, p
))
1569 while (sizeleft
> 0)
1571 if (multi_volume_option
)
1573 assign_string (&save_name
, p
);
1574 save_sizeleft
= sizeleft
;
1575 save_totsize
= current_stat_info
.stat
.st_size
;
1577 start
= find_next_block ();
1579 bufsize
= available_space_after (start
);
1581 if (sizeleft
< bufsize
)
1583 /* Last read -- zero out area beyond. */
1586 count
= bufsize
% BLOCKSIZE
;
1588 memset (start
->buffer
+ sizeleft
, 0, BLOCKSIZE
- count
);
1593 count
= safe_read (f
, start
->buffer
, bufsize
);
1596 (ignore_failed_read_option
1598 : read_error_details
)
1599 (p
, current_stat_info
.stat
.st_size
- sizeleft
, bufsize
);
1604 /* This is nonportable (the type of set_next_block_after's arg). */
1606 set_next_block_after (start
+ (bufsize
- 1) / BLOCKSIZE
);
1609 if (count
!= bufsize
)
1611 char buf
[UINTMAX_STRSIZE_BOUND
];
1612 memset (start
->buffer
+ count
, 0, bufsize
- count
);
1614 ngettext ("%s: File shrank by %s byte; padding with zeros",
1615 "%s: File shrank by %s bytes; padding with zeros",
1618 STRINGIFY_BIGINT (sizeleft
, buf
)));
1619 if (! ignore_failed_read_option
)
1620 exit_status
= TAREXIT_FAILURE
;
1621 goto padit
; /* short read */
1625 if (multi_volume_option
)
1626 assign_string (&save_name
, 0);
1630 struct stat final_stat
;
1631 if (fstat (f
, &final_stat
) != 0)
1633 if (ignore_failed_read_option
)
1638 else if (final_stat
.st_ctime
!= original_ctime
)
1640 char const *qp
= quotearg_colon (p
);
1641 WARN ((0, 0, _("%s: file changed as we read it"), qp
));
1645 if (ignore_failed_read_option
)
1650 if (atime_preserve_option
)
1651 utime (p
, &restore_times
);
1653 if (remove_files_option
)
1655 if (unlink (p
) == -1)
1658 goto file_was_dumped
;
1660 /* File shrunk or gave error, pad out tape to match the size we
1661 specified in the header. */
1664 while (sizeleft
> 0)
1666 save_sizeleft
= sizeleft
;
1667 start
= find_next_block ();
1668 memset (start
->buffer
, 0, BLOCKSIZE
);
1669 set_next_block_after (start
);
1670 sizeleft
-= BLOCKSIZE
;
1672 if (multi_volume_option
)
1673 assign_string (&save_name
, 0);
1677 if (atime_preserve_option
)
1678 utime (p
, &restore_times
);
1680 goto file_was_dumped
;
1682 #ifdef HAVE_READLINK
1683 else if (S_ISLNK (current_stat_info
.stat
.st_mode
))
1687 size_t linklen
= current_stat_info
.stat
.st_size
;
1688 if (linklen
!= current_stat_info
.stat
.st_size
|| linklen
+ 1 == 0)
1690 buffer
= (char *) alloca (linklen
+ 1);
1691 size
= readlink (p
, buffer
, linklen
+ 1);
1694 if (ignore_failed_read_option
)
1700 buffer
[size
] = '\0';
1701 assign_string (¤t_stat_info
.link_name
, buffer
);
1702 if (size
>= NAME_FIELD_SIZE
)
1703 write_long_link (¤t_stat_info
);
1705 block_ordinal
= current_block_ordinal ();
1706 current_stat_info
.stat
.st_size
= 0; /* force 0 size on symlink */
1707 header
= start_header (p
, ¤t_stat_info
);
1710 strncpy (header
->header
.linkname
, buffer
, NAME_FIELD_SIZE
);
1711 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = '\0';
1712 header
->header
.typeflag
= SYMTYPE
;
1713 finish_header (header
, block_ordinal
);
1714 /* nothing more to do to it */
1716 if (remove_files_option
)
1718 if (unlink (p
) == -1)
1721 goto file_was_dumped
;
1724 else if (S_ISCHR (current_stat_info
.stat
.st_mode
))
1726 else if (S_ISBLK (current_stat_info
.stat
.st_mode
))
1728 else if (S_ISFIFO (current_stat_info
.stat
.st_mode
))
1730 else if (S_ISSOCK (current_stat_info
.stat
.st_mode
))
1732 WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p
)));
1735 else if (S_ISDOOR (current_stat_info
.stat
.st_mode
))
1737 WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p
)));
1744 if (archive_format
== V7_FORMAT
)
1747 block_ordinal
= current_block_ordinal ();
1748 current_stat_info
.stat
.st_size
= 0; /* force 0 size */
1749 header
= start_header (p
, ¤t_stat_info
);
1752 header
->header
.typeflag
= type
;
1754 if (type
!= FIFOTYPE
)
1756 MAJOR_TO_CHARS (major (current_stat_info
.stat
.st_rdev
), header
->header
.devmajor
);
1757 MINOR_TO_CHARS (minor (current_stat_info
.stat
.st_rdev
), header
->header
.devminor
);
1760 finish_header (header
, block_ordinal
);
1761 if (remove_files_option
)
1763 if (unlink (p
) == -1)
1766 goto file_was_dumped
;
1769 WARN ((0, 0, _("%s: Unknown file type; file ignored"),
1770 quotearg_colon (p
)));
1771 if (! ignore_failed_read_option
)
1772 exit_status
= TAREXIT_FAILURE
;
1776 if (1 < current_stat_info
.stat
.st_nlink
)
1779 struct link
*lp
= xmalloc (offsetof (struct link
, name
)
1781 lp
->ino
= current_stat_info
.stat
.st_ino
;
1782 lp
->dev
= current_stat_info
.stat
.st_dev
;
1783 lp
->nlink
= current_stat_info
.stat
.st_nlink
;
1784 strcpy (lp
->name
, p
);
1787 || (link_table
= hash_initialize (0, 0, hash_link
,
1789 && (dup
= hash_insert (link_table
, lp
))))
1799 /* For each dumped file, check if all its links were dumped. Emit
1800 warnings if it is not so. */
1809 for (lp
= hash_get_first (link_table
); lp
;
1810 lp
= hash_get_next (link_table
, lp
))
1814 WARN ((0, 0, _("Missing links to '%s'.\n"), lp
->name
));