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. */
56 struct link
*linklist
= NULL
; /* points to first link in list */
59 /*------------------------------------------------------------------------.
60 | Convert VALUE (with substitute SUBSTITUTE if VALUE is out of range) |
61 | into a size-SIZE field at WHERE, including a |
62 | trailing space. For example, 3 for SIZE means two digits and a space. |
64 | We assume the trailing NUL is already there and don't fill it in. This |
65 | fact is used by start_header and finish_header, so don't change it! |
66 `------------------------------------------------------------------------*/
68 /* Output VALUE in octal, using SUBSTITUTE if value won't fit.
69 Output to buffer WHERE with size SIZE.
70 TYPE is the kind of value being output (useful for diagnostics).
71 Prefer SIZE - 1 octal digits (with leading '0's), followed by '\0';
72 but if SIZE octal digits would fit, omit the '\0'. */
75 to_oct (uintmax_t value
, uintmax_t substitute
, char *where
, size_t size
, const char *type
)
80 # define MAX_OCTAL_VAL_WITH_DIGITS(digits) \
81 ((digits) * 3 < sizeof (uintmax_t) * CHAR_BIT \
82 ? ((uintmax_t) 1 << ((digits) * 3)) - 1 \
85 /* Output a trailing NUL unless the value is too large. */
86 if (value
<= MAX_OCTAL_VAL_WITH_DIGITS (size
- 1))
89 /* Produce the digits -- at least one. */
93 where
[--i
] = '0' + (int) (v
& 7); /* one octal digit */
96 while (i
!= 0 && v
!= 0);
98 /* Leading zeros, if necessary. */
104 uintmax_t maxval
= MAX_OCTAL_VAL_WITH_DIGITS (size
);
105 char buf1
[UINTMAX_STRSIZE_BOUND
];
106 char buf2
[UINTMAX_STRSIZE_BOUND
];
107 char buf3
[UINTMAX_STRSIZE_BOUND
];
108 char *value_string
= STRINGIFY_BIGINT (value
, buf1
);
109 char *maxval_string
= STRINGIFY_BIGINT (maxval
, buf2
);
112 substitute
&= maxval
;
113 WARN ((0, 0, _("%s value %s too large (max=%s); substituting %s"),
114 type
, value_string
, maxval_string
,
115 STRINGIFY_BIGINT (substitute
, buf3
)));
116 to_oct (substitute
, (uintmax_t) 0, where
, size
, type
);
119 ERROR ((0, 0, _("%s value %s too large (max=%s)"),
120 type
, value_string
, maxval_string
));
127 gid_to_oct (gid_t v
, char *p
, size_t s
)
129 to_oct ((uintmax_t) v
, (uintmax_t) GID_NOBODY
, p
, s
, "gid_t");
132 major_to_oct (major_t v
, char *p
, size_t s
)
134 to_oct ((uintmax_t) v
, (uintmax_t) 0, p
, s
, "major_t");
137 minor_to_oct (minor_t v
, char *p
, size_t s
)
139 to_oct ((uintmax_t) v
, (uintmax_t) 0, p
, s
, "minor_t");
142 mode_to_oct (mode_t v
, char *p
, size_t s
)
144 /* In the common case where the internal and external mode bits are the same,
145 propagate all unknown bits to the external mode.
146 This matches historical practice.
147 Otherwise, just copy the bits we know about. */
149 ((S_ISUID
== TSUID
&& S_ISGID
== TSGID
&& S_ISVTX
== TSVTX
150 && S_IRUSR
== TUREAD
&& S_IWUSR
== TUWRITE
&& S_IXUSR
== TUEXEC
151 && S_IRGRP
== TGREAD
&& S_IWGRP
== TGWRITE
&& S_IXGRP
== TGEXEC
152 && S_IROTH
== TOREAD
&& S_IWOTH
== TOWRITE
&& S_IXOTH
== TOEXEC
)
154 : ((v
& S_ISUID
? TSUID
: 0)
155 | (v
& S_ISGID
? TSGID
: 0)
156 | (v
& S_ISVTX
? TSVTX
: 0)
157 | (v
& S_IRUSR
? TUREAD
: 0)
158 | (v
& S_IWUSR
? TUWRITE
: 0)
159 | (v
& S_IXUSR
? TUEXEC
: 0)
160 | (v
& S_IRGRP
? TGREAD
: 0)
161 | (v
& S_IWGRP
? TGWRITE
: 0)
162 | (v
& S_IXGRP
? TGEXEC
: 0)
163 | (v
& S_IROTH
? TOREAD
: 0)
164 | (v
& S_IWOTH
? TOWRITE
: 0)
165 | (v
& S_IXOTH
? TOEXEC
: 0)));
166 to_oct (u
, (uintmax_t) 0, p
, s
, "mode_t");
169 off_to_oct (off_t v
, char *p
, size_t s
)
171 to_oct ((uintmax_t) v
, (uintmax_t) 0, p
, s
, "off_t");
174 size_to_oct (size_t v
, char *p
, size_t s
)
176 to_oct ((uintmax_t) v
, (uintmax_t) 0, p
, s
, "size_t");
179 time_to_oct (time_t v
, char *p
, size_t s
)
181 to_oct ((uintmax_t) v
, (uintmax_t) 0, p
, s
, "time_t");
187 uid_to_oct (uid_t v
, char *p
, size_t s
)
189 to_oct ((uintmax_t) v
, (uintmax_t) UID_NOBODY
, p
, s
, "uid_t");
192 uintmax_to_oct (uintmax_t v
, char *p
, size_t s
)
194 to_oct (v
, (uintmax_t) 0, p
, s
, "uintmax_t");
197 /* Writing routines. */
199 /*-----------------------------------------------------------------------.
200 | Just zeroes out the buffer so we don't confuse ourselves with leftover |
202 `-----------------------------------------------------------------------*/
205 clear_buffer (char *buffer
)
207 memset (buffer
, 0, BLOCKSIZE
);
210 /*-------------------------------------------------------------------------.
211 | Write the EOT block(s). We actually zero at least one block, through |
212 | the end of the record. Old tar, as previous versions of GNU tar, writes |
213 | garbage after two zeroed blocks. |
214 `-------------------------------------------------------------------------*/
219 union block
*pointer
= find_next_block ();
223 size_t space
= available_space_after (pointer
);
225 memset (pointer
->buffer
, 0, space
);
226 set_next_block_after (pointer
);
230 /*-----------------------------------------------------.
231 | Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. |
232 `-----------------------------------------------------*/
234 /* FIXME: Cross recursion between start_header and write_long! */
236 static union block
*start_header
PARAMS ((const char *, struct stat
*));
239 write_long (const char *p
, char type
)
241 size_t size
= strlen (p
) + 1;
246 memset (&foo
, 0, sizeof foo
);
249 header
= start_header ("././@LongLink", &foo
);
250 header
->header
.typeflag
= type
;
251 finish_header (header
);
253 header
= find_next_block ();
255 bufsize
= available_space_after (header
);
257 while (bufsize
< size
)
259 memcpy (header
->buffer
, p
, bufsize
);
262 set_next_block_after (header
+ (bufsize
- 1) / BLOCKSIZE
);
263 header
= find_next_block ();
264 bufsize
= available_space_after (header
);
266 memcpy (header
->buffer
, p
, size
);
267 memset (header
->buffer
+ size
, 0, bufsize
- size
);
268 set_next_block_after (header
+ (size
- 1) / BLOCKSIZE
);
271 /* Header handling. */
273 /*---------------------------------------------------------------------.
274 | Make a header block for the file name whose stat info is st. Return |
275 | header pointer for success, NULL if the name is too long. |
276 `---------------------------------------------------------------------*/
279 start_header (const char *name
, struct stat
*st
)
283 if (!absolute_names_option
)
285 static int warned_once
= 0;
294 WARN ((0, 0, _("Removing drive spec from names in the archive")));
301 name
++; /* force relative path */
306 Removing leading `/' from absolute path names in the archive")));
311 /* Check the file name and put it in the block. */
313 if (strlen (name
) >= (size_t) NAME_FIELD_SIZE
)
314 write_long (name
, GNUTYPE_LONGNAME
);
315 header
= find_next_block ();
316 memset (header
->buffer
, 0, sizeof (union block
));
318 assign_string (¤t_file_name
, name
);
320 strncpy (header
->header
.name
, name
, NAME_FIELD_SIZE
);
321 header
->header
.name
[NAME_FIELD_SIZE
- 1] = '\0';
323 /* Override some stat fields, if requested to do so. */
325 if (owner_option
!= (uid_t
) -1)
326 st
->st_uid
= owner_option
;
327 if (group_option
!= (gid_t
) -1)
328 st
->st_gid
= group_option
;
330 st
->st_mode
= ((st
->st_mode
& ~MODE_ALL
)
331 | mode_adjust (st
->st_mode
, mode_option
));
333 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
334 for a few tars and came up with the following interoperability
338 1 2 3 4 5 6 7 8 9 READER
339 . . . . . . . . . 1 = SunOS 4.2 tar
340 # . . # # . . # # 2 = NEC SVR4.0.2 tar
341 . . . # # . . # . 3 = Solaris 2.1 tar
342 . . . . . . . . . 4 = GNU tar 1.11.1
343 . . . . . . . . . 5 = HP-UX 8.07 tar
344 . . . . . . . . . 6 = Ultrix 4.1
345 . . . . . . . . . 7 = AIX 3.2
346 . . . . . . . . . 8 = Hitachi HI-UX 1.03
347 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
350 # = ``impossible file type''
352 The following mask for old archive removes the `#'s in column 4
353 above, thus making GNU tar both a universal donor and a universal
354 acceptor for Paul's test. */
356 if (archive_format
== V7_FORMAT
)
357 MODE_TO_OCT (st
->st_mode
& MODE_ALL
, header
->header
.mode
);
359 MODE_TO_OCT (st
->st_mode
, header
->header
.mode
);
361 UID_TO_OCT (st
->st_uid
, header
->header
.uid
);
362 GID_TO_OCT (st
->st_gid
, header
->header
.gid
);
363 OFF_TO_OCT (st
->st_size
, header
->header
.size
);
364 TIME_TO_OCT (st
->st_mtime
, header
->header
.mtime
);
366 if (incremental_option
)
367 if (archive_format
== OLDGNU_FORMAT
)
369 TIME_TO_OCT (st
->st_atime
, header
->oldgnu_header
.atime
);
370 TIME_TO_OCT (st
->st_ctime
, header
->oldgnu_header
.ctime
);
373 header
->header
.typeflag
= archive_format
== V7_FORMAT
? AREGTYPE
: REGTYPE
;
375 switch (archive_format
)
382 /* Overwrite header->header.magic and header.version in one blow. */
383 strcpy (header
->header
.magic
, OLDGNU_MAGIC
);
388 strncpy (header
->header
.magic
, TMAGIC
, TMAGLEN
);
389 strncpy (header
->header
.version
, TVERSION
, TVERSLEN
);
393 if (archive_format
== V7_FORMAT
|| numeric_owner_option
)
395 /* header->header.[ug]name are left as the empty string. */
399 uid_to_uname (st
->st_uid
, header
->header
.uname
);
400 gid_to_gname (st
->st_gid
, header
->header
.gname
);
406 /*-------------------------------------------------------------------------.
407 | Finish off a filled-in header block and write it out. We also print the |
408 | file name and/or full info if verbose is on. |
409 `-------------------------------------------------------------------------*/
412 finish_header (union block
*header
)
418 memcpy (header
->header
.chksum
, CHKBLANKS
, sizeof (header
->header
.chksum
));
422 for (i
= sizeof (*header
); i
-- != 0; )
423 /* We can't use unsigned char here because of old compilers, e.g. V7. */
426 /* Fill in the checksum field. It's formatted differently from the
427 other fields: it has [6] digits, a null, then a space -- rather than
428 digits, then a null. We use to_oct.
429 The final space is already there, from
430 checksumming, and to_oct doesn't modify it.
432 This is a fast way to do:
434 sprintf(header->header.chksum, "%6o", sum); */
436 uintmax_to_oct ((uintmax_t) sum
, header
->header
.chksum
, 7);
438 set_next_block_after (header
);
441 && header
->header
.typeflag
!= GNUTYPE_LONGLINK
442 && header
->header
.typeflag
!= GNUTYPE_LONGNAME
)
444 /* These globals are parameters to print_header, sigh. */
446 current_header
= header
;
447 /* current_stat is already set up. */
448 current_format
= archive_format
;
453 /* Sparse file processing. */
455 /*-------------------------------------------------------------------------.
456 | Takes a blockful of data and basically cruises through it to see if it's |
457 | made *entirely* of zeros, returning a 0 the instant it finds something |
458 | that is a nonzero, i.e., useful data. |
459 `-------------------------------------------------------------------------*/
462 zero_block_p (char *buffer
)
466 for (counter
= 0; counter
< BLOCKSIZE
; counter
++)
467 if (buffer
[counter
] != '\0')
477 init_sparsearray (void)
483 /* Make room for our scratch space -- initially is 10 elts long. */
485 sparsearray
= (struct sp_array
*)
486 xmalloc (sp_array_size
* sizeof (struct sp_array
));
487 for (counter
= 0; counter
< sp_array_size
; counter
++)
489 sparsearray
[counter
].offset
= 0;
490 sparsearray
[counter
].numbytes
= 0;
499 find_new_file_size (off_t
*filesize
, int highest_index
)
505 sparsearray
[counter
].numbytes
&& counter
<= highest_index
;
507 *filesize
+= sparsearray
[counter
].numbytes
;
510 /*-----------------------------------------------------------------------.
511 | Make one pass over the file NAME, studying where any non-zero data is, |
512 | that is, how far into the file each instance of data is, and how many |
513 | bytes are there. Save this information in the sparsearray, which will |
514 | later be translated into header information. |
515 `-----------------------------------------------------------------------*/
517 /* There is little point in trimming small amounts of null data at the head
518 and tail of blocks, only avoid dumping full null blocks. */
520 /* FIXME: this routine might accept bits of algorithmic cleanup, it is
521 too kludgey for my taste... */
524 deal_with_sparse (char *name
, union block
*header
)
529 int sparse_index
= 0;
531 char buffer
[BLOCKSIZE
];
533 if (archive_format
== OLDGNU_FORMAT
)
534 header
->oldgnu_header
.isextended
= 0;
536 if (file
= open (name
, O_RDONLY
), file
< 0)
537 /* This problem will be caught later on, so just return. */
541 clear_buffer (buffer
);
543 while (count
= safe_read (file
, buffer
, sizeof buffer
), count
!= 0)
545 /* Realloc the scratch area as necessary. FIXME: should reallocate
546 only at beginning of a new instance of non-zero data. */
548 if (sparse_index
> sp_array_size
- 1)
551 sparsearray
= (struct sp_array
*)
552 xrealloc (sparsearray
,
553 2 * sp_array_size
* sizeof (struct sp_array
));
557 /* Process one block. */
559 if (count
== sizeof buffer
)
561 if (zero_block_p (buffer
))
565 sparsearray
[sparse_index
++].numbytes
= numbytes
;
572 sparsearray
[sparse_index
].offset
= offset
;
578 /* Since count < sizeof buffer, we have the last bit of the file. */
580 if (!zero_block_p (buffer
))
583 sparsearray
[sparse_index
].offset
= offset
;
587 /* The next two lines are suggested by Andreas Degert, who says
588 they are required for trailing full blocks to be written to the
589 archive, when all zeroed. Yet, it seems to me that the case
590 does not apply. Further, at restore time, the file is not as
591 sparse as it should. So, some serious cleanup is *also* needed
592 in this area. Just one more... :-(. FIXME. */
596 /* Prepare for next block. */
599 /* FIXME: do not clear unless necessary. */
600 clear_buffer (buffer
);
604 sparsearray
[sparse_index
++].numbytes
= numbytes
;
607 sparsearray
[sparse_index
].offset
= offset
- 1;
608 sparsearray
[sparse_index
++].numbytes
= 1;
612 return sparse_index
- 1;
620 finish_sparse_file (int file
, off_t
*sizeleft
, off_t fullsize
, char *name
)
624 int sparse_index
= 0;
627 while (*sizeleft
> 0)
629 start
= find_next_block ();
630 memset (start
->buffer
, 0, BLOCKSIZE
);
631 bufsize
= sparsearray
[sparse_index
].numbytes
;
634 /* We blew it, maybe. */
635 char buf1
[UINTMAX_STRSIZE_BOUND
];
636 char buf2
[UINTMAX_STRSIZE_BOUND
];
638 ERROR ((0, 0, _("Wrote %s of %s bytes to file %s"),
639 STRINGIFY_BIGINT (fullsize
- *sizeleft
, buf1
),
640 STRINGIFY_BIGINT (fullsize
, buf2
),
645 if (lseek (file
, sparsearray
[sparse_index
++].offset
, SEEK_SET
) < 0)
647 char buf
[UINTMAX_STRSIZE_BOUND
];
648 ERROR ((0, errno
, _("lseek error at byte %s in file %s"),
649 STRINGIFY_BIGINT (sparsearray
[sparse_index
- 1].offset
, buf
),
654 /* If the number of bytes to be written here exceeds the size of
655 the temporary buffer, do it in steps. */
657 while (bufsize
> BLOCKSIZE
)
662 count
= safe_read (file
, start
->buffer
+ amount_read
,
663 BLOCKSIZE
- amount_read
);
664 bufsize
-= BLOCKSIZE
- amount_read
;
666 set_next_block_after (start
);
667 start
= find_next_block ();
668 memset (start
->buffer
, 0, BLOCKSIZE
);
671 /* Store the data. */
673 count
= safe_read (file
, start
->buffer
, BLOCKSIZE
);
676 char buf
[UINTMAX_STRSIZE_BOUND
];
677 ERROR ((0, errno
, _("\
678 Read error at byte %s, reading %lu bytes, in file %s"),
679 STRINGIFY_BIGINT (fullsize
- *sizeleft
, buf
),
680 (unsigned long) bufsize
, name
));
685 set_next_block_after (start
);
686 start
= find_next_block ();
687 memset (start
->buffer
, 0, BLOCKSIZE
);
691 char buffer
[BLOCKSIZE
];
693 clear_buffer (buffer
);
694 count
= safe_read (file
, buffer
, bufsize
);
695 memcpy (start
->buffer
, buffer
, BLOCKSIZE
);
700 char buf
[UINTMAX_STRSIZE_BOUND
];
703 _("Read error at byte %s, reading %lu bytes, in file %s"),
704 STRINGIFY_BIGINT (fullsize
- *sizeleft
, buf
),
705 (unsigned long) bufsize
, name
));
709 if (amount_read
>= BLOCKSIZE
)
712 set_next_block_after (start
+ (count
- 1) / BLOCKSIZE
);
713 if (count
!= bufsize
)
716 _("File %s shrunk, padding with zeros"),
720 start
= find_next_block ();
723 amount_read
+= bufsize
;
726 set_next_block_after (start
);
731 set_next_block_after (start
+ (count
- 1) / BLOCKSIZE
);
736 /* Main functions of this module. */
743 create_archive (void)
747 open_archive (ACCESS_WRITE
);
749 if (incremental_option
)
751 char *buffer
= xmalloc (PATH_MAX
);
755 collect_and_sort_names ();
757 while (p
= name_from_list (), p
)
758 if (!excluded_pathname (excluded
, p
))
759 dump_file (p
, (dev_t
) -1, 1);
762 while (p
= name_from_list (), p
)
765 if (p
[strlen (p
) - 1] != '/')
766 strcat (buffer
, "/");
767 bufp
= buffer
+ strlen (buffer
);
768 for (q
= gnu_list_name
->dir_contents
;
774 strcpy (bufp
, q
+ 1);
775 dump_file (buffer
, (dev_t
) -1, 1);
783 while (p
= name_next (1), p
)
784 if (!excluded_pathname (excluded
, p
))
785 dump_file (p
, (dev_t
) -1, 1);
791 if (listed_incremental_option
)
795 /*----------------------------------------------------------------------.
796 | Dump a single file. Recurse on directories. Result is nonzero for |
797 | success. P is file name to dump. PARENT_DEVICE is device our parent |
798 | directory was on. TOP_LEVEL tells wether we are a toplevel call. |
800 | Sets global CURRENT_STAT to stat output for this file. |
801 `----------------------------------------------------------------------*/
803 /* FIXME: One should make sure that for *every* path leading to setting
804 exit_status to failure, a clear diagnostic has been issued. */
807 dump_file (char *p
, dev_t parent_device
, int top_level
)
813 struct utimbuf restore_times
;
816 /* FIXME: `header' and `upperbound' might be used uninitialized in this
817 function. Reported by Bruno Haible. */
819 if (interactive_option
&& !confirm ("add", p
))
822 /* Use stat if following (rather than dumping) 4.2BSD's symbolic links.
823 Otherwise, use lstat (which falls back to stat if no symbolic links). */
825 if (dereference_option
!= 0
826 #if STX_HIDDEN && !_LARGE_FILES /* AIX */
827 ? statx (p
, ¤t_stat
, STATSIZE
, STX_HIDDEN
)
828 : statx (p
, ¤t_stat
, STATSIZE
, STX_HIDDEN
| STX_LINK
)
830 ? stat (p
, ¤t_stat
) : lstat (p
, ¤t_stat
)
834 WARN ((0, errno
, _("Cannot add file %s"), p
));
835 if (!ignore_failed_read_option
)
836 exit_status
= TAREXIT_FAILURE
;
840 restore_times
.actime
= current_stat
.st_atime
;
841 restore_times
.modtime
= current_stat
.st_mtime
;
842 restore_size
= current_stat
.st_size
;
845 if (S_ISHIDDEN (current_stat
.st_mode
))
847 char *new = (char *) alloca (strlen (p
) + 2);
857 /* See if we only want new files, and check if this one is too old to
858 put in the archive. */
860 if (!incremental_option
&& !S_ISDIR (current_stat
.st_mode
)
861 && current_stat
.st_mtime
< newer_mtime_option
862 && (!after_date_option
|| current_stat
.st_ctime
< newer_ctime_option
))
864 if (parent_device
== (dev_t
) -1)
865 WARN ((0, 0, _("%s: is unchanged; not dumped"), p
));
866 /* FIXME: recheck this return. */
871 /* See if we are trying to dump the archive. */
873 if (ar_dev
&& current_stat
.st_dev
== ar_dev
&& current_stat
.st_ino
== ar_ino
)
875 WARN ((0, 0, _("%s is the archive; not dumped"), p
));
880 /* Check for multiple links.
882 We maintain a list of all such files that we've written so far. Any
883 time we see another, we check the list and avoid dumping the data
884 again if we've done it once already. */
886 if (current_stat
.st_nlink
> 1
887 && (S_ISREG (current_stat
.st_mode
)
889 || S_ISCTG (current_stat
.st_mode
)
892 || S_ISCHR (current_stat
.st_mode
)
895 || S_ISBLK (current_stat
.st_mode
)
898 || S_ISFIFO (current_stat
.st_mode
)
904 /* FIXME: First quick and dirty. Hashing, etc later. */
906 for (lp
= linklist
; lp
; lp
= lp
->next
)
907 if (lp
->ino
== current_stat
.st_ino
&& lp
->dev
== current_stat
.st_dev
)
909 char *link_name
= lp
->name
;
911 /* We found a link. */
913 while (!absolute_names_option
&& *link_name
== '/')
915 static int warned_once
= 0;
921 Removing leading `/' from absolute links")));
925 if (strlen (link_name
) >= NAME_FIELD_SIZE
)
926 write_long (link_name
, GNUTYPE_LONGLINK
);
927 assign_string (¤t_link_name
, link_name
);
929 current_stat
.st_size
= 0;
930 header
= start_header (p
, ¤t_stat
);
933 exit_status
= TAREXIT_FAILURE
;
936 strncpy (header
->header
.linkname
,
937 link_name
, NAME_FIELD_SIZE
);
939 /* Force null truncated. */
941 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = 0;
943 header
->header
.typeflag
= LNKTYPE
;
944 finish_header (header
);
946 /* FIXME: Maybe remove from list after all links found? */
948 if (remove_files_option
)
949 if (unlink (p
) == -1)
950 ERROR ((0, errno
, _("Cannot remove %s"), p
));
956 /* Not found. Add it to the list of possible links. */
959 xmalloc ((size_t) (sizeof (struct link
) + strlen (p
)));
960 lp
->ino
= current_stat
.st_ino
;
961 lp
->dev
= current_stat
.st_dev
;
962 strcpy (lp
->name
, p
);
967 /* This is not a link to a previously dumped file, so dump it. */
969 if (S_ISREG (current_stat
.st_mode
)
971 || S_ISCTG (current_stat
.st_mode
)
975 int f
; /* file descriptor */
984 static int cried_once
= 0;
991 /* Check the size of the file against the number of blocks
992 allocated for it, counting both data and indirect blocks.
993 If there is a smaller number of blocks that would be
994 necessary to accommodate a file of this size, this is safe
995 to say that we have a sparse file: at least one of those
996 blocks in the file is just a useless hole. For sparse
997 files not having more hole blocks than indirect blocks, the
998 sparseness will go undetected. */
1000 /* Bruno Haible sent me these statistics for Linux. It seems
1001 that some filesystems count indirect blocks in st_blocks,
1002 while others do not seem to:
1004 minix-fs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1005 extfs tar: size=7205, st_blocks=18 and ST_NBLOCKS=18
1006 ext2fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1007 msdos-fs tar: size=7205, st_blocks=16 and ST_NBLOCKS=16
1009 Dick Streefland reports the previous numbers as misleading,
1010 because ext2fs use 12 direct blocks, while minix-fs uses only
1011 6 direct blocks. Dick gets:
1013 ext2 size=20480 ls listed blocks=21
1014 minix size=20480 ls listed blocks=21
1015 msdos size=20480 ls listed blocks=20
1017 It seems that indirect blocks *are* included in st_blocks.
1018 The minix filesystem does not account for phantom blocks in
1019 st_blocks, so `du' and `ls -s' give wrong results. So, the
1020 --sparse option would not work on a minix filesystem. */
1022 if (ST_NBLOCKS (current_stat
)
1023 < (current_stat
.st_size
/ ST_NBLOCKSIZE
1024 + (current_stat
.st_size
% ST_NBLOCKSIZE
!= 0)))
1026 off_t filesize
= current_stat
.st_size
;
1029 header
= start_header (p
, ¤t_stat
);
1032 exit_status
= TAREXIT_FAILURE
;
1035 header
->header
.typeflag
= GNUTYPE_SPARSE
;
1038 /* Call the routine that figures out the layout of the
1039 sparse file in question. UPPERBOUND is the index of the
1040 last element of the "sparsearray," i.e., the number of
1041 elements it needed to describe the file. */
1043 upperbound
= deal_with_sparse (p
, header
);
1045 /* See if we'll need an extended header later. */
1047 if (upperbound
> SPARSES_IN_OLDGNU_HEADER
- 1)
1048 header
->oldgnu_header
.isextended
= 1;
1050 /* We store the "real" file size so we can show that in
1051 case someone wants to list the archive, i.e., tar tvf
1052 <file>. It might be kind of disconcerting if the
1053 shrunken file size was the one that showed up. */
1055 OFF_TO_OCT (current_stat
.st_size
,
1056 header
->oldgnu_header
.realsize
);
1058 /* This will be the new "size" of the file, i.e., the size
1059 of the file minus the blocks of holes that we're
1062 find_new_file_size (&filesize
, upperbound
);
1063 current_stat
.st_size
= filesize
;
1064 OFF_TO_OCT (filesize
, header
->header
.size
);
1066 for (counter
= 0; counter
< SPARSES_IN_OLDGNU_HEADER
; counter
++)
1068 if (!sparsearray
[counter
].numbytes
)
1071 OFF_TO_OCT (sparsearray
[counter
].offset
,
1072 header
->oldgnu_header
.sp
[counter
].offset
);
1073 SIZE_TO_OCT (sparsearray
[counter
].numbytes
,
1074 header
->oldgnu_header
.sp
[counter
].numbytes
);
1080 upperbound
= SPARSES_IN_OLDGNU_HEADER
- 1;
1082 sizeleft
= current_stat
.st_size
;
1084 /* Don't bother opening empty, world readable files. Also do not open
1085 files when archive is meant for /dev/null. */
1089 && MODE_R
== (MODE_R
& current_stat
.st_mode
)))
1093 f
= open (p
, O_RDONLY
| O_BINARY
);
1096 WARN ((0, errno
, _("Cannot add file %s"), p
));
1097 if (!ignore_failed_read_option
)
1098 exit_status
= TAREXIT_FAILURE
;
1103 /* If the file is sparse, we've already taken care of this. */
1107 header
= start_header (p
, ¤t_stat
);
1112 exit_status
= TAREXIT_FAILURE
;
1117 /* Mark contiguous files, if we support them. */
1119 if (archive_format
!= V7_FORMAT
&& S_ISCTG (current_stat
.st_mode
))
1120 header
->header
.typeflag
= CONTTYPE
;
1122 isextended
= header
->oldgnu_header
.isextended
;
1123 save_typeflag
= header
->header
.typeflag
;
1124 finish_header (header
);
1133 int arraybound
= SPARSES_IN_SPARSE_HEADER
;
1135 /* static */ int index_offset
= SPARSES_IN_OLDGNU_HEADER
;
1138 exhdr
= find_next_block ();
1142 exit_status
= TAREXIT_FAILURE
;
1145 memset (exhdr
->buffer
, 0, BLOCKSIZE
);
1146 for (counter
= 0; counter
< SPARSES_IN_SPARSE_HEADER
; counter
++)
1148 if (counter
+ index_offset
> upperbound
)
1151 SIZE_TO_OCT (sparsearray
[counter
+ index_offset
].numbytes
,
1152 exhdr
->sparse_header
.sp
[counter
].numbytes
);
1153 OFF_TO_OCT (sparsearray
[counter
+ index_offset
].offset
,
1154 exhdr
->sparse_header
.sp
[counter
].offset
);
1156 set_next_block_after (exhdr
);
1159 if (sum
< upperbound
)
1162 if (index_offset
+ counter
<= upperbound
)
1164 index_offset
+= counter
;
1165 exhdr
->sparse_header
.isextended
= 1;
1170 if (save_typeflag
== GNUTYPE_SPARSE
)
1173 || finish_sparse_file (f
, &sizeleft
, current_stat
.st_size
, p
))
1177 while (sizeleft
> 0)
1179 if (multi_volume_option
)
1181 assign_string (&save_name
, p
);
1182 save_sizeleft
= sizeleft
;
1183 save_totsize
= current_stat
.st_size
;
1185 start
= find_next_block ();
1187 bufsize
= available_space_after (start
);
1189 if (sizeleft
< bufsize
)
1191 /* Last read -- zero out area beyond. */
1194 count
= bufsize
% BLOCKSIZE
;
1196 memset (start
->buffer
+ sizeleft
, 0,
1197 (size_t) (BLOCKSIZE
- count
));
1202 count
= safe_read (f
, start
->buffer
, bufsize
);
1205 char buf
[UINTMAX_STRSIZE_BOUND
];
1206 ERROR ((0, errno
, _("\
1207 Read error at byte %s, reading %lu bytes, in file %s"),
1208 STRINGIFY_BIGINT (current_stat
.st_size
- sizeleft
,
1210 (unsigned long) bufsize
, p
));
1215 /* This is nonportable (the type of set_next_block_after's arg). */
1217 set_next_block_after (start
+ (count
- 1) / BLOCKSIZE
);
1219 if (count
== bufsize
)
1223 char buf
[UINTMAX_STRSIZE_BOUND
];
1225 _("File %s shrunk by %s bytes, padding with zeros"),
1226 p
, STRINGIFY_BIGINT (sizeleft
, buf
)));
1227 goto padit
; /* short read */
1231 if (multi_volume_option
)
1232 assign_string (&save_name
, NULL
);
1236 struct stat final_stat
;
1237 if (fstat (f
, &final_stat
) != 0)
1238 ERROR ((0, errno
, "%s: fstat", p
));
1239 else if (final_stat
.st_mtime
!= restore_times
.modtime
1240 || final_stat
.st_size
!= restore_size
)
1241 ERROR ((0, errno
, _("%s: file changed as we read it"), p
));
1243 ERROR ((0, errno
, _("%s: close"), p
));
1244 if (atime_preserve_option
)
1245 utime (p
, &restore_times
);
1247 if (remove_files_option
)
1249 if (unlink (p
) == -1)
1250 ERROR ((0, errno
, _("Cannot remove %s"), p
));
1254 /* File shrunk or gave error, pad out tape to match the size we
1255 specified in the header. */
1258 while (sizeleft
> 0)
1260 save_sizeleft
= sizeleft
;
1261 start
= find_next_block ();
1262 memset (start
->buffer
, 0, BLOCKSIZE
);
1263 set_next_block_after (start
);
1264 sizeleft
-= BLOCKSIZE
;
1266 if (multi_volume_option
)
1267 assign_string (&save_name
, NULL
);
1271 if (atime_preserve_option
)
1272 utime (p
, &restore_times
);
1278 else if (S_ISLNK (current_stat
.st_mode
))
1281 char *buffer
= (char *) alloca (PATH_MAX
+ 1);
1283 size
= readlink (p
, buffer
, PATH_MAX
+ 1);
1286 WARN ((0, errno
, _("Cannot add file %s"), p
));
1287 if (!ignore_failed_read_option
)
1288 exit_status
= TAREXIT_FAILURE
;
1291 buffer
[size
] = '\0';
1292 if (size
>= NAME_FIELD_SIZE
)
1293 write_long (buffer
, GNUTYPE_LONGLINK
);
1294 assign_string (¤t_link_name
, buffer
);
1296 current_stat
.st_size
= 0; /* force 0 size on symlink */
1297 header
= start_header (p
, ¤t_stat
);
1300 exit_status
= TAREXIT_FAILURE
;
1303 strncpy (header
->header
.linkname
, buffer
, NAME_FIELD_SIZE
);
1304 header
->header
.linkname
[NAME_FIELD_SIZE
- 1] = '\0';
1305 header
->header
.typeflag
= SYMTYPE
;
1306 finish_header (header
); /* nothing more to do to it */
1307 if (remove_files_option
)
1309 if (unlink (p
) == -1)
1310 ERROR ((0, errno
, _("Cannot remove %s"), p
));
1314 #endif /* S_ISLNK */
1316 else if (S_ISDIR (current_stat
.st_mode
))
1319 struct dirent
*entry
;
1323 dev_t our_device
= current_stat
.st_dev
;
1325 /* If this tar program is installed suid root, like for Amanda, the
1326 access might look like denied, while it is not really.
1328 FIXME: I have the feeling this test is done too early. Couldn't it
1329 just be bundled in later actions? I guess that the proper support
1330 of --ignore-failed-read is the key of the current writing. */
1332 if (access (p
, R_OK
) == -1 && geteuid () != 0)
1334 WARN ((0, errno
, _("Cannot add directory %s"), p
));
1335 if (!ignore_failed_read_option
)
1336 exit_status
= TAREXIT_FAILURE
;
1340 /* Build new prototype name. Ensure exactly one trailing slash. */
1343 buflen
= len
+ NAME_FIELD_SIZE
;
1344 namebuf
= xmalloc (buflen
+ 1);
1345 strncpy (namebuf
, p
, buflen
);
1346 while (len
>= 1 && namebuf
[len
- 1] == '/')
1348 namebuf
[len
++] = '/';
1349 namebuf
[len
] = '\0';
1353 /* The "1" above used to be "archive_format != V7_FORMAT", GNU tar
1354 was just not writing directory blocks at all. Daniel Trinkle
1355 writes: ``All old versions of tar I have ever seen have
1356 correctly archived an empty directory. The really old ones I
1357 checked included HP-UX 7 and Mt. Xinu More/BSD. There may be
1358 some subtle reason for the exclusion that I don't know, but the
1359 current behavior is broken.'' I do not know those subtle
1360 reasons either, so until these are reported (anew?), just allow
1361 directory blocks to be written even with old archives. */
1363 current_stat
.st_size
= 0; /* force 0 size on dir */
1365 /* FIXME: If people could really read standard archives, this
1369 = start_header (standard_option ? p : namebuf, ¤t_stat);
1371 but since they'd interpret DIRTYPE blocks as regular
1372 files, we'd better put the / on the name. */
1374 header
= start_header (namebuf
, ¤t_stat
);
1377 exit_status
= TAREXIT_FAILURE
;
1378 return; /* eg name too long */
1381 if (incremental_option
)
1382 header
->header
.typeflag
= GNUTYPE_DUMPDIR
;
1383 else /* if (standard_option) */
1384 header
->header
.typeflag
= DIRTYPE
;
1386 /* If we're gnudumping, we aren't done yet so don't close it. */
1388 if (!incremental_option
)
1389 finish_header (header
); /* done with directory header */
1392 if (incremental_option
&& gnu_list_name
->dir_contents
)
1399 const char *buffer
, *p_buffer
;
1401 buffer
= gnu_list_name
->dir_contents
; /* FOO */
1403 for (p_buffer
= buffer
; p_buffer
&& *p_buffer
;)
1407 tmp
= strlen (p_buffer
) + 1;
1412 OFF_TO_OCT (totsize
, header
->header
.size
);
1413 finish_header (header
);
1416 while (sizeleft
> 0)
1418 if (multi_volume_option
)
1420 assign_string (&save_name
, p
);
1421 save_sizeleft
= sizeleft
;
1422 save_totsize
= totsize
;
1424 start
= find_next_block ();
1425 bufsize
= available_space_after (start
);
1426 if (sizeleft
< bufsize
)
1429 count
= bufsize
% BLOCKSIZE
;
1431 memset (start
->buffer
+ sizeleft
, 0,
1432 (size_t) (BLOCKSIZE
- count
));
1434 memcpy (start
->buffer
, p_buffer
, bufsize
);
1435 sizeleft
-= bufsize
;
1436 p_buffer
+= bufsize
;
1437 set_next_block_after (start
+ (bufsize
- 1) / BLOCKSIZE
);
1439 if (multi_volume_option
)
1440 assign_string (&save_name
, NULL
);
1441 if (atime_preserve_option
)
1442 utime (p
, &restore_times
);
1446 /* See if we are about to recurse into a directory, and avoid doing
1447 so if the user wants that we do not descend into directories. */
1449 if (no_recurse_option
)
1452 /* See if we are crossing from one file system to another, and
1453 avoid doing so if the user only wants to dump one file system. */
1455 if (one_file_system_option
&& !top_level
1456 && parent_device
!= current_stat
.st_dev
)
1459 WARN ((0, 0, _("%s: On a different filesystem; not dumped"), p
));
1463 /* Now output all the files in the directory. */
1465 errno
= 0; /* FIXME: errno should be read-only */
1467 directory
= opendir (p
);
1470 ERROR ((0, errno
, _("Cannot open directory %s"), p
));
1474 /* Hack to remove "./" from the front of all the file names. */
1476 if (len
== 2 && namebuf
[0] == '.' && namebuf
[1] == '/')
1479 /* FIXME: Should speed this up by cd-ing into the dir. */
1481 while (entry
= readdir (directory
), entry
)
1483 /* Skip `.', `..', and excluded file names. */
1485 if (is_dot_or_dotdot (entry
->d_name
)
1486 || excluded_filename (excluded
, entry
->d_name
))
1489 if ((int) NAMLEN (entry
) + len
>= buflen
)
1491 buflen
= len
+ NAMLEN (entry
);
1492 namebuf
= (char *) xrealloc (namebuf
, buflen
+ 1);
1494 namebuf
[len
] = '\0';
1495 ERROR ((0, 0, _("File name %s%s too long"),
1496 namebuf
, entry
->d_name
));
1500 strcpy (namebuf
+ len
, entry
->d_name
);
1501 dump_file (namebuf
, our_device
, 0);
1504 closedir (directory
);
1506 if (atime_preserve_option
)
1507 utime (p
, &restore_times
);
1512 else if (S_ISCHR (current_stat
.st_mode
))
1517 else if (S_ISBLK (current_stat
.st_mode
))
1522 else if (S_ISFIFO (current_stat
.st_mode
))
1527 else if (S_ISSOCK (current_stat
.st_mode
))
1534 if (archive_format
== V7_FORMAT
)
1537 current_stat
.st_size
= 0; /* force 0 size */
1538 header
= start_header (p
, ¤t_stat
);
1541 exit_status
= TAREXIT_FAILURE
;
1542 return; /* eg name too long */
1545 header
->header
.typeflag
= type
;
1547 #if defined S_ISBLK || defined S_ISCHR
1548 if (type
!= FIFOTYPE
)
1550 MAJOR_TO_OCT (major (current_stat
.st_rdev
), header
->header
.devmajor
);
1551 MINOR_TO_OCT (minor (current_stat
.st_rdev
), header
->header
.devminor
);
1555 finish_header (header
);
1556 if (remove_files_option
)
1558 if (unlink (p
) == -1)
1559 ERROR ((0, errno
, _("Cannot remove %s"), p
));
1564 ERROR ((0, 0, _("%s: Unknown file type; file ignored"), p
));