1 /* Functions for dealing with sparse files
3 Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
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 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
24 struct tar_sparse_file
;
25 static bool sparse_select_optab (struct tar_sparse_file
*file
);
27 enum sparse_scan_state
34 struct tar_sparse_optab
36 bool (*init
) (struct tar_sparse_file
*);
37 bool (*done
) (struct tar_sparse_file
*);
38 bool (*sparse_member_p
) (struct tar_sparse_file
*);
39 bool (*dump_header
) (struct tar_sparse_file
*);
40 bool (*fixup_header
) (struct tar_sparse_file
*);
41 bool (*decode_header
) (struct tar_sparse_file
*);
42 bool (*scan_block
) (struct tar_sparse_file
*, enum sparse_scan_state
,
44 bool (*dump_region
) (struct tar_sparse_file
*, size_t);
45 bool (*extract_region
) (struct tar_sparse_file
*, size_t);
48 struct tar_sparse_file
50 int fd
; /* File descriptor */
51 bool seekable
; /* Is fd seekable? */
52 off_t offset
; /* Current offset in fd if seekable==false.
54 off_t dumped_size
; /* Number of bytes actually written
56 struct tar_stat_info
*stat_info
; /* Information about the file */
57 struct tar_sparse_optab
const *optab
; /* Operation table */
58 void *closure
; /* Any additional data optab calls might
62 /* Dump zeros to file->fd until offset is reached. It is used instead of
63 lseek if the output file is not seekable */
65 dump_zeros (struct tar_sparse_file
*file
, off_t offset
)
67 static char const zero_buf
[BLOCKSIZE
];
69 if (offset
< file
->offset
)
75 while (file
->offset
< offset
)
77 size_t size
= (BLOCKSIZE
< offset
- file
->offset
79 : offset
- file
->offset
);
82 wrbytes
= write (file
->fd
, zero_buf
, size
);
89 file
->offset
+= wrbytes
;
96 tar_sparse_member_p (struct tar_sparse_file
*file
)
98 if (file
->optab
->sparse_member_p
)
99 return file
->optab
->sparse_member_p (file
);
104 tar_sparse_init (struct tar_sparse_file
*file
)
106 memset (file
, 0, sizeof *file
);
108 if (!sparse_select_optab (file
))
111 if (file
->optab
->init
)
112 return file
->optab
->init (file
);
118 tar_sparse_done (struct tar_sparse_file
*file
)
120 if (file
->optab
->done
)
121 return file
->optab
->done (file
);
126 tar_sparse_scan (struct tar_sparse_file
*file
, enum sparse_scan_state state
,
129 if (file
->optab
->scan_block
)
130 return file
->optab
->scan_block (file
, state
, block
);
135 tar_sparse_dump_region (struct tar_sparse_file
*file
, size_t i
)
137 if (file
->optab
->dump_region
)
138 return file
->optab
->dump_region (file
, i
);
143 tar_sparse_extract_region (struct tar_sparse_file
*file
, size_t i
)
145 if (file
->optab
->extract_region
)
146 return file
->optab
->extract_region (file
, i
);
151 tar_sparse_dump_header (struct tar_sparse_file
*file
)
153 if (file
->optab
->dump_header
)
154 return file
->optab
->dump_header (file
);
159 tar_sparse_decode_header (struct tar_sparse_file
*file
)
161 if (file
->optab
->decode_header
)
162 return file
->optab
->decode_header (file
);
167 tar_sparse_fixup_header (struct tar_sparse_file
*file
)
169 if (file
->optab
->fixup_header
)
170 return file
->optab
->fixup_header (file
);
176 lseek_or_error (struct tar_sparse_file
*file
, off_t offset
)
179 ? lseek (file
->fd
, offset
, SEEK_SET
) < 0
180 : ! dump_zeros (file
, offset
))
182 seek_diag_details (file
->stat_info
->orig_file_name
, offset
);
188 /* Takes a blockful of data and basically cruises through it to see if
189 it's made *entirely* of zeros, returning a 0 the instant it finds
190 something that is a nonzero, i.e., useful data. */
192 zero_block_p (char const *buffer
, size_t size
)
201 sparse_add_map (struct tar_stat_info
*st
, struct sp_array
const *sp
)
203 struct sp_array
*sparse_map
= st
->sparse_map
;
204 size_t avail
= st
->sparse_map_avail
;
205 if (avail
== st
->sparse_map_size
)
206 st
->sparse_map
= sparse_map
=
207 x2nrealloc (sparse_map
, &st
->sparse_map_size
, sizeof *sparse_map
);
208 sparse_map
[avail
] = *sp
;
209 st
->sparse_map_avail
= avail
+ 1;
212 /* Scan the sparse file and create its map */
214 sparse_scan_file (struct tar_sparse_file
*file
)
216 struct tar_stat_info
*st
= file
->stat_info
;
218 char buffer
[BLOCKSIZE
];
221 struct sp_array sp
= {0, 0};
223 if (!lseek_or_error (file
, 0))
226 st
->archive_file_size
= 0;
228 if (!tar_sparse_scan (file
, scan_begin
, NULL
))
231 while ((count
= safe_read (fd
, buffer
, sizeof buffer
)) != 0
232 && count
!= SAFE_READ_ERROR
)
234 /* Analyze the block. */
235 if (zero_block_p (buffer
, count
))
239 sparse_add_map (st
, &sp
);
241 if (!tar_sparse_scan (file
, scan_block
, NULL
))
247 if (sp
.numbytes
== 0)
249 sp
.numbytes
+= count
;
250 st
->archive_file_size
+= count
;
251 if (!tar_sparse_scan (file
, scan_block
, buffer
))
258 if (sp
.numbytes
== 0)
261 sparse_add_map (st
, &sp
);
262 st
->archive_file_size
+= count
;
263 return tar_sparse_scan (file
, scan_end
, NULL
);
266 static struct tar_sparse_optab
const oldgnu_optab
;
267 static struct tar_sparse_optab
const star_optab
;
268 static struct tar_sparse_optab
const pax_optab
;
271 sparse_select_optab (struct tar_sparse_file
*file
)
273 switch (current_format
== DEFAULT_FORMAT
? archive_format
: current_format
)
280 case GNU_FORMAT
: /*FIXME: This one should disappear? */
281 file
->optab
= &oldgnu_optab
;
285 file
->optab
= &pax_optab
;
289 file
->optab
= &star_optab
;
299 sparse_dump_region (struct tar_sparse_file
*file
, size_t i
)
302 off_t bytes_left
= file
->stat_info
->sparse_map
[i
].numbytes
;
304 if (!lseek_or_error (file
, file
->stat_info
->sparse_map
[i
].offset
))
307 while (bytes_left
> 0)
309 size_t bufsize
= (bytes_left
> BLOCKSIZE
) ? BLOCKSIZE
: bytes_left
;
312 blk
= find_next_block ();
313 bytes_read
= safe_read (file
->fd
, blk
->buffer
, bufsize
);
314 if (bytes_read
== SAFE_READ_ERROR
)
316 read_diag_details (file
->stat_info
->orig_file_name
,
317 (file
->stat_info
->sparse_map
[i
].offset
318 + file
->stat_info
->sparse_map
[i
].numbytes
324 memset (blk
->buffer
+ bytes_read
, 0, BLOCKSIZE
- bytes_read
);
325 bytes_left
-= bytes_read
;
326 file
->dumped_size
+= bytes_read
;
327 mv_size_left (file
->stat_info
->archive_file_size
- file
->dumped_size
);
328 set_next_block_after (blk
);
335 sparse_extract_region (struct tar_sparse_file
*file
, size_t i
)
339 if (!lseek_or_error (file
, file
->stat_info
->sparse_map
[i
].offset
))
342 write_size
= file
->stat_info
->sparse_map
[i
].numbytes
;
346 /* Last block of the file is a hole */
347 if (file
->seekable
&& sys_truncate (file
->fd
))
348 truncate_warn (file
->stat_info
->orig_file_name
);
350 else while (write_size
> 0)
353 size_t wrbytes
= (write_size
> BLOCKSIZE
) ? BLOCKSIZE
: write_size
;
354 union block
*blk
= find_next_block ();
357 ERROR ((0, 0, _("Unexpected EOF in archive")));
360 set_next_block_after (blk
);
361 count
= full_write (file
->fd
, blk
->buffer
, wrbytes
);
363 file
->dumped_size
+= count
;
364 mv_size_left (file
->stat_info
->archive_file_size
- file
->dumped_size
);
365 file
->offset
+= count
;
366 if (count
!= wrbytes
)
368 write_error_details (file
->stat_info
->orig_file_name
,
378 /* Interface functions */
380 sparse_dump_file (int fd
, struct tar_stat_info
*st
)
383 struct tar_sparse_file file
;
385 if (!tar_sparse_init (&file
))
386 return dump_status_not_implemented
;
390 file
.seekable
= true; /* File *must* be seekable for dump to work */
392 rc
= sparse_scan_file (&file
);
393 if (rc
&& file
.optab
->dump_region
)
395 tar_sparse_dump_header (&file
);
401 mv_begin (file
.stat_info
);
402 for (i
= 0; rc
&& i
< file
.stat_info
->sparse_map_avail
; i
++)
403 rc
= tar_sparse_dump_region (&file
, i
);
408 pad_archive (file
.stat_info
->archive_file_size
- file
.dumped_size
);
409 return (tar_sparse_done (&file
) && rc
) ? dump_status_ok
: dump_status_short
;
412 /* Returns true if the file represented by stat is a sparse one */
414 sparse_file_p (struct tar_stat_info
*st
)
416 return (ST_NBLOCKS (st
->stat
)
417 < (st
->stat
.st_size
/ ST_NBLOCKSIZE
418 + (st
->stat
.st_size
% ST_NBLOCKSIZE
!= 0)));
422 sparse_member_p (struct tar_stat_info
*st
)
424 struct tar_sparse_file file
;
426 if (!tar_sparse_init (&file
))
429 return tar_sparse_member_p (&file
);
433 sparse_fixup_header (struct tar_stat_info
*st
)
435 struct tar_sparse_file file
;
437 if (!tar_sparse_init (&file
))
440 return tar_sparse_fixup_header (&file
);
444 sparse_extract_file (int fd
, struct tar_stat_info
*st
, off_t
*size
)
447 struct tar_sparse_file file
;
450 if (!tar_sparse_init (&file
))
451 return dump_status_not_implemented
;
455 file
.seekable
= lseek (fd
, 0, SEEK_SET
) == 0;
458 rc
= tar_sparse_decode_header (&file
);
459 for (i
= 0; rc
&& i
< file
.stat_info
->sparse_map_avail
; i
++)
460 rc
= tar_sparse_extract_region (&file
, i
);
461 *size
= file
.stat_info
->archive_file_size
- file
.dumped_size
;
462 return (tar_sparse_done (&file
) && rc
) ? dump_status_ok
: dump_status_short
;
466 sparse_skip_file (struct tar_stat_info
*st
)
469 struct tar_sparse_file file
;
471 if (!tar_sparse_init (&file
))
472 return dump_status_not_implemented
;
477 rc
= tar_sparse_decode_header (&file
);
478 skip_file (file
.stat_info
->archive_file_size
);
479 return (tar_sparse_done (&file
) && rc
) ? dump_status_ok
: dump_status_short
;
484 check_sparse_region (struct tar_sparse_file
*file
, off_t beg
, off_t end
)
486 if (!lseek_or_error (file
, beg
))
492 size_t rdsize
= BLOCKSIZE
< end
- beg
? BLOCKSIZE
: end
- beg
;
493 char diff_buffer
[BLOCKSIZE
];
495 bytes_read
= safe_read (file
->fd
, diff_buffer
, rdsize
);
496 if (bytes_read
== SAFE_READ_ERROR
)
498 read_diag_details (file
->stat_info
->orig_file_name
,
503 if (!zero_block_p (diff_buffer
, bytes_read
))
505 char begbuf
[INT_BUFSIZE_BOUND (off_t
)];
506 report_difference (file
->stat_info
,
507 _("File fragment at %s is not a hole"),
508 offtostr (beg
, begbuf
));
518 check_data_region (struct tar_sparse_file
*file
, size_t i
)
522 if (!lseek_or_error (file
, file
->stat_info
->sparse_map
[i
].offset
))
524 size_left
= file
->stat_info
->sparse_map
[i
].numbytes
;
525 mv_size_left (file
->stat_info
->archive_file_size
- file
->dumped_size
);
527 while (size_left
> 0)
530 size_t rdsize
= (size_left
> BLOCKSIZE
) ? BLOCKSIZE
: size_left
;
531 char diff_buffer
[BLOCKSIZE
];
533 union block
*blk
= find_next_block ();
536 ERROR ((0, 0, _("Unexpected EOF in archive")));
539 set_next_block_after (blk
);
540 bytes_read
= safe_read (file
->fd
, diff_buffer
, rdsize
);
541 if (bytes_read
== SAFE_READ_ERROR
)
543 read_diag_details (file
->stat_info
->orig_file_name
,
544 (file
->stat_info
->sparse_map
[i
].offset
545 + file
->stat_info
->sparse_map
[i
].numbytes
550 file
->dumped_size
+= bytes_read
;
551 size_left
-= bytes_read
;
552 mv_size_left (file
->stat_info
->archive_file_size
- file
->dumped_size
);
553 if (memcmp (blk
->buffer
, diff_buffer
, rdsize
))
555 report_difference (file
->stat_info
, _("Contents differ"));
563 sparse_diff_file (int fd
, struct tar_stat_info
*st
)
566 struct tar_sparse_file file
;
570 if (!tar_sparse_init (&file
))
571 return dump_status_not_implemented
;
575 file
.seekable
= true; /* File *must* be seekable for compare to work */
577 rc
= tar_sparse_decode_header (&file
);
579 for (i
= 0; rc
&& i
< file
.stat_info
->sparse_map_avail
; i
++)
581 rc
= check_sparse_region (&file
,
582 offset
, file
.stat_info
->sparse_map
[i
].offset
)
583 && check_data_region (&file
, i
);
584 offset
= file
.stat_info
->sparse_map
[i
].offset
585 + file
.stat_info
->sparse_map
[i
].numbytes
;
589 skip_file (file
.stat_info
->archive_file_size
- file
.dumped_size
);
592 tar_sparse_done (&file
);
597 /* Old GNU Format. The sparse file information is stored in the
598 oldgnu_header in the following manner:
600 The header is marked with type 'S'. Its `size' field contains
601 the cumulative size of all non-empty blocks of the file. The
602 actual file size is stored in `realsize' member of oldgnu_header.
604 The map of the file is stored in a list of `struct sparse'.
605 Each struct contains offset to the block of data and its
606 size (both as octal numbers). The first file header contains
607 at most 4 such structs (SPARSES_IN_OLDGNU_HEADER). If the map
608 contains more structs, then the field `isextended' of the main
609 header is set to 1 (binary) and the `struct sparse_header'
610 header follows, containing at most 21 following structs
611 (SPARSES_IN_SPARSE_HEADER). If more structs follow, `isextended'
612 field of the extended header is set and next next extension header
615 enum oldgnu_add_status
623 oldgnu_sparse_member_p (struct tar_sparse_file
*file
__attribute__ ((unused
)))
625 return current_header
->header
.typeflag
== GNUTYPE_SPARSE
;
628 /* Add a sparse item to the sparse file and its obstack */
629 static enum oldgnu_add_status
630 oldgnu_add_sparse (struct tar_sparse_file
*file
, struct sparse
*s
)
634 if (s
->numbytes
[0] == '\0')
636 sp
.offset
= OFF_FROM_HEADER (s
->offset
);
637 sp
.numbytes
= SIZE_FROM_HEADER (s
->numbytes
);
639 || file
->stat_info
->stat
.st_size
< sp
.offset
+ sp
.numbytes
640 || file
->stat_info
->archive_file_size
< 0)
643 sparse_add_map (file
->stat_info
, &sp
);
648 oldgnu_fixup_header (struct tar_sparse_file
*file
)
650 /* NOTE! st_size was initialized from the header
651 which actually contains archived size. The following fixes it */
652 file
->stat_info
->archive_file_size
= file
->stat_info
->stat
.st_size
;
653 file
->stat_info
->stat
.st_size
=
654 OFF_FROM_HEADER (current_header
->oldgnu_header
.realsize
);
658 /* Convert old GNU format sparse data to internal representation */
660 oldgnu_get_sparse_info (struct tar_sparse_file
*file
)
663 union block
*h
= current_header
;
665 enum oldgnu_add_status rc
;
667 file
->stat_info
->sparse_map_avail
= 0;
668 for (i
= 0; i
< SPARSES_IN_OLDGNU_HEADER
; i
++)
670 rc
= oldgnu_add_sparse (file
, &h
->oldgnu_header
.sp
[i
]);
675 for (ext_p
= h
->oldgnu_header
.isextended
;
676 rc
== add_ok
&& ext_p
; ext_p
= h
->sparse_header
.isextended
)
678 h
= find_next_block ();
681 ERROR ((0, 0, _("Unexpected EOF in archive")));
684 set_next_block_after (h
);
685 for (i
= 0; i
< SPARSES_IN_SPARSE_HEADER
&& rc
== add_ok
; i
++)
686 rc
= oldgnu_add_sparse (file
, &h
->sparse_header
.sp
[i
]);
691 ERROR ((0, 0, _("%s: invalid sparse archive member"),
692 file
->stat_info
->orig_file_name
));
699 oldgnu_store_sparse_info (struct tar_sparse_file
*file
, size_t *pindex
,
700 struct sparse
*sp
, size_t sparse_size
)
702 for (; *pindex
< file
->stat_info
->sparse_map_avail
703 && sparse_size
> 0; sparse_size
--, sp
++, ++*pindex
)
705 OFF_TO_CHARS (file
->stat_info
->sparse_map
[*pindex
].offset
,
707 SIZE_TO_CHARS (file
->stat_info
->sparse_map
[*pindex
].numbytes
,
713 oldgnu_dump_header (struct tar_sparse_file
*file
)
715 off_t block_ordinal
= current_block_ordinal ();
719 blk
= start_header (file
->stat_info
);
720 blk
->header
.typeflag
= GNUTYPE_SPARSE
;
721 if (file
->stat_info
->sparse_map_avail
> SPARSES_IN_OLDGNU_HEADER
)
722 blk
->oldgnu_header
.isextended
= 1;
724 /* Store the real file size */
725 OFF_TO_CHARS (file
->stat_info
->stat
.st_size
, blk
->oldgnu_header
.realsize
);
726 /* Store the effective (shrunken) file size */
727 OFF_TO_CHARS (file
->stat_info
->archive_file_size
, blk
->header
.size
);
730 oldgnu_store_sparse_info (file
, &i
,
731 blk
->oldgnu_header
.sp
,
732 SPARSES_IN_OLDGNU_HEADER
);
733 blk
->oldgnu_header
.isextended
= i
< file
->stat_info
->sparse_map_avail
;
734 finish_header (file
->stat_info
, blk
, block_ordinal
);
736 while (i
< file
->stat_info
->sparse_map_avail
)
738 blk
= find_next_block ();
739 memset (blk
->buffer
, 0, BLOCKSIZE
);
740 oldgnu_store_sparse_info (file
, &i
,
741 blk
->sparse_header
.sp
,
742 SPARSES_IN_SPARSE_HEADER
);
743 if (i
< file
->stat_info
->sparse_map_avail
)
744 blk
->sparse_header
.isextended
= 1;
745 set_next_block_after (blk
);
750 static struct tar_sparse_optab
const oldgnu_optab
= {
751 NULL
, /* No init function */
752 NULL
, /* No done function */
753 oldgnu_sparse_member_p
,
756 oldgnu_get_sparse_info
,
757 NULL
, /* No scan_block function */
759 sparse_extract_region
,
766 star_sparse_member_p (struct tar_sparse_file
*file
__attribute__ ((unused
)))
768 return current_header
->header
.typeflag
== GNUTYPE_SPARSE
;
772 star_fixup_header (struct tar_sparse_file
*file
)
774 /* NOTE! st_size was initialized from the header
775 which actually contains archived size. The following fixes it */
776 file
->stat_info
->archive_file_size
= file
->stat_info
->stat
.st_size
;
777 file
->stat_info
->stat
.st_size
=
778 OFF_FROM_HEADER (current_header
->star_in_header
.realsize
);
782 /* Convert STAR format sparse data to internal representation */
784 star_get_sparse_info (struct tar_sparse_file
*file
)
787 union block
*h
= current_header
;
789 enum oldgnu_add_status rc
= add_ok
;
791 file
->stat_info
->sparse_map_avail
= 0;
793 if (h
->star_in_header
.prefix
[0] == '\0'
794 && h
->star_in_header
.sp
[0].offset
[10] != '\0')
796 /* Old star format */
797 for (i
= 0; i
< SPARSES_IN_STAR_HEADER
; i
++)
799 rc
= oldgnu_add_sparse (file
, &h
->star_in_header
.sp
[i
]);
803 ext_p
= h
->star_in_header
.isextended
;
808 for (; rc
== add_ok
&& ext_p
; ext_p
= h
->star_ext_header
.isextended
)
810 h
= find_next_block ();
813 ERROR ((0, 0, _("Unexpected EOF in archive")));
816 set_next_block_after (h
);
817 for (i
= 0; i
< SPARSES_IN_STAR_EXT_HEADER
&& rc
== add_ok
; i
++)
818 rc
= oldgnu_add_sparse (file
, &h
->star_ext_header
.sp
[i
]);
823 ERROR ((0, 0, _("%s: invalid sparse archive member"),
824 file
->stat_info
->orig_file_name
));
831 static struct tar_sparse_optab
const star_optab
= {
832 NULL
, /* No init function */
833 NULL
, /* No done function */
834 star_sparse_member_p
,
837 star_get_sparse_info
,
838 NULL
, /* No scan_block function */
839 NULL
, /* No dump region function */
840 sparse_extract_region
,
844 /* GNU PAX sparse file format. There are several versions:
849 The initial version of sparse format used by tar 1.14-1.15.1.
850 The sparse file map is stored in x header:
852 GNU.sparse.size Real size of the stored file
853 GNU.sparse.numblocks Number of blocks in the sparse map
854 repeat numblocks time
855 GNU.sparse.offset Offset of the next data block
856 GNU.sparse.numbytes Size of the next data block
859 This has been reported as conflicting with the POSIX specs. The reason is
860 that offsets and sizes of non-zero data blocks were stored in multiple
861 instances of GNU.sparse.offset/GNU.sparse.numbytes variables, whereas
862 POSIX requires the latest occurrence of the variable to override all
863 previous occurrences.
865 To avoid this incompatibility two following versions were introduced.
869 Used by tar 1.15.2 -- 1.15.91 (alpha releases).
871 The sparse file map is stored in
874 GNU.sparse.size Real size of the stored file
875 GNU.sparse.numblocks Number of blocks in the sparse map
876 GNU.sparse.map Map of non-null data chunks. A string consisting
877 of comma-separated values "offset,size[,offset,size]..."
879 The resulting GNU.sparse.map string can be *very* long. While POSIX does not
880 impose any limit on the length of a x header variable, this can confuse some
885 Starting from this version, the exact sparse format version is specified explicitely
886 in the header using the following variables:
888 GNU.sparse.major Major version
889 GNU.sparse.minor Minor version
891 X header keeps the following variables:
893 GNU.sparse.name Real file name of the sparse file
894 GNU.sparse.realsize Real size of the stored file (corresponds to the old
895 GNU.sparse.size variable)
897 The name field of the ustar header is constructed using the pattern
898 "%d/GNUSparseFile.%p/%f".
900 The sparse map itself is stored in the file data block, preceding the actual
901 file data. It consists of a series of octal numbers of arbitrary length, delimited
902 by newlines. The map is padded with nulls to the nearest block boundary.
904 The first number gives the number of entries in the map. Following are map entries,
905 each one consisting of two numbers giving the offset and size of the
906 data block it describes.
908 The format is designed in such a way that non-posix aware tars and tars not
909 supporting GNU.sparse.* keywords will extract each sparse file in its condensed
910 form with the file map attached and will place it into a separate directory.
911 Then, using a simple program it would be possible to expand the file to its
912 original form even without GNU tar.
914 Bu default, v.1.0 archives are created. To use other formats, --sparse-version
915 option is provided. Additionally, v.0.0 can be obtained by deleting GNU.sparse.map
916 from 0.1 format: --sparse-version 0.1 --pax-option delete=GNU.sparse.map
920 pax_sparse_member_p (struct tar_sparse_file
*file
)
922 return file
->stat_info
->sparse_map_avail
> 0
923 || file
->stat_info
->sparse_major
> 0;
927 pax_dump_header_0 (struct tar_sparse_file
*file
)
929 off_t block_ordinal
= current_block_ordinal ();
932 char nbuf
[UINTMAX_STRSIZE_BOUND
];
933 struct sp_array
*map
= file
->stat_info
->sparse_map
;
934 char *save_file_name
= NULL
;
936 /* Store the real file size */
937 xheader_store ("GNU.sparse.size", file
->stat_info
, NULL
);
938 xheader_store ("GNU.sparse.numblocks", file
->stat_info
, NULL
);
940 if (xheader_keyword_deleted_p ("GNU.sparse.map")
941 || tar_sparse_minor
== 0)
943 for (i
= 0; i
< file
->stat_info
->sparse_map_avail
; i
++)
945 xheader_store ("GNU.sparse.offset", file
->stat_info
, &i
);
946 xheader_store ("GNU.sparse.numbytes", file
->stat_info
, &i
);
951 xheader_store ("GNU.sparse.name", file
->stat_info
, NULL
);
952 save_file_name
= file
->stat_info
->file_name
;
953 file
->stat_info
->file_name
= xheader_format_name (file
->stat_info
,
954 "%d/GNUSparseFile.%p/%f", 0);
956 xheader_string_begin ();
957 for (i
= 0; i
< file
->stat_info
->sparse_map_avail
; i
++)
960 xheader_string_add (",");
961 xheader_string_add (umaxtostr (map
[i
].offset
, nbuf
));
962 xheader_string_add (",");
963 xheader_string_add (umaxtostr (map
[i
].numbytes
, nbuf
));
965 xheader_string_end ("GNU.sparse.map");
967 blk
= start_header (file
->stat_info
);
968 /* Store the effective (shrunken) file size */
969 OFF_TO_CHARS (file
->stat_info
->archive_file_size
, blk
->header
.size
);
970 finish_header (file
->stat_info
, blk
, block_ordinal
);
973 free (file
->stat_info
->file_name
);
974 file
->stat_info
->file_name
= save_file_name
;
980 pax_dump_header_1 (struct tar_sparse_file
*file
)
982 off_t block_ordinal
= current_block_ordinal ();
986 char nbuf
[UINTMAX_STRSIZE_BOUND
];
988 struct sp_array
*map
= file
->stat_info
->sparse_map
;
989 char *save_file_name
= file
->stat_info
->file_name
;
991 #define COPY_STRING(b,dst,src) do \
993 char *endp = b->buffer + BLOCKSIZE; \
999 set_next_block_after (b); \
1000 b = find_next_block (); \
1002 endp = b->buffer + BLOCKSIZE; \
1008 /* Compute stored file size */
1009 p
= umaxtostr (file
->stat_info
->sparse_map_avail
, nbuf
);
1010 size
+= strlen (p
) + 1;
1011 for (i
= 0; i
< file
->stat_info
->sparse_map_avail
; i
++)
1013 p
= umaxtostr (map
[i
].offset
, nbuf
);
1014 size
+= strlen (p
) + 1;
1015 p
= umaxtostr (map
[i
].numbytes
, nbuf
);
1016 size
+= strlen (p
) + 1;
1018 size
= (size
+ BLOCKSIZE
- 1) / BLOCKSIZE
;
1019 file
->stat_info
->archive_file_size
+= size
* BLOCKSIZE
;
1021 /* Store sparse file identification */
1022 xheader_store ("GNU.sparse.major", file
->stat_info
, NULL
);
1023 xheader_store ("GNU.sparse.minor", file
->stat_info
, NULL
);
1024 xheader_store ("GNU.sparse.name", file
->stat_info
, NULL
);
1025 xheader_store ("GNU.sparse.realsize", file
->stat_info
, NULL
);
1027 file
->stat_info
->file_name
= xheader_format_name (file
->stat_info
,
1028 "%d/GNUSparseFile.%p/%f", 0);
1030 blk
= start_header (file
->stat_info
);
1031 /* Store the effective (shrunken) file size */
1032 OFF_TO_CHARS (file
->stat_info
->archive_file_size
, blk
->header
.size
);
1033 finish_header (file
->stat_info
, blk
, block_ordinal
);
1034 free (file
->stat_info
->file_name
);
1035 file
->stat_info
->file_name
= save_file_name
;
1037 blk
= find_next_block ();
1039 p
= umaxtostr (file
->stat_info
->sparse_map_avail
, nbuf
);
1040 COPY_STRING (blk
, q
, p
);
1041 COPY_STRING (blk
, q
, "\n");
1042 for (i
= 0; i
< file
->stat_info
->sparse_map_avail
; i
++)
1044 p
= umaxtostr (map
[i
].offset
, nbuf
);
1045 COPY_STRING (blk
, q
, p
);
1046 COPY_STRING (blk
, q
, "\n");
1047 p
= umaxtostr (map
[i
].numbytes
, nbuf
);
1048 COPY_STRING (blk
, q
, p
);
1049 COPY_STRING (blk
, q
, "\n");
1051 memset (q
, 0, BLOCKSIZE
- (q
- blk
->buffer
));
1052 set_next_block_after (blk
);
1057 pax_dump_header (struct tar_sparse_file
*file
)
1059 file
->stat_info
->sparse_major
= tar_sparse_major
;
1060 file
->stat_info
->sparse_minor
= tar_sparse_minor
;
1062 if (file
->stat_info
->sparse_major
== 0)
1063 pax_dump_header_0 (file
);
1065 pax_dump_header_1 (file
);
1069 decode_num (uintmax_t *num
, char const *arg
, uintmax_t maxval
)
1074 if (!ISDIGIT (*arg
))
1077 u
= strtoumax (arg
, &arg_lim
, 10);
1079 if (! (u
<= maxval
&& errno
!= ERANGE
) || *arg_lim
)
1087 pax_decode_header (struct tar_sparse_file
*file
)
1089 if (file
->stat_info
->sparse_major
> 0)
1092 char nbuf
[UINTMAX_STRSIZE_BOUND
];
1097 #define COPY_BUF(b,buf,src) do \
1099 char *endp = b->buffer + BLOCKSIZE; \
1103 if (dst == buf + UINTMAX_STRSIZE_BOUND -1) \
1105 ERROR ((0, 0, _("%s: numeric overflow in sparse archive member"), \
1106 file->stat_info->orig_file_name)); \
1111 set_next_block_after (b); \
1112 b = find_next_block (); \
1114 endp = b->buffer + BLOCKSIZE; \
1118 while (*dst++ != '\n'); \
1122 set_next_block_after (current_header
);
1123 blk
= find_next_block ();
1125 COPY_BUF (blk
,nbuf
,p
);
1126 if (!decode_num (&u
, nbuf
, TYPE_MAXIMUM (size_t)))
1128 ERROR ((0, 0, _("%s: malformed sparse archive member"),
1129 file
->stat_info
->orig_file_name
));
1132 file
->stat_info
->sparse_map_size
= u
;
1133 file
->stat_info
->sparse_map
= xcalloc (file
->stat_info
->sparse_map_size
,
1134 sizeof (*file
->stat_info
->sparse_map
));
1135 file
->stat_info
->sparse_map_avail
= 0;
1136 for (i
= 0; i
< file
->stat_info
->sparse_map_size
; i
++)
1140 COPY_BUF (blk
,nbuf
,p
);
1141 if (!decode_num (&u
, nbuf
, TYPE_MAXIMUM (off_t
)))
1143 ERROR ((0, 0, _("%s: malformed sparse archive member"),
1144 file
->stat_info
->orig_file_name
));
1148 COPY_BUF (blk
,nbuf
,p
);
1149 if (!decode_num (&u
, nbuf
, TYPE_MAXIMUM (size_t)))
1151 ERROR ((0, 0, _("%s: malformed sparse archive member"),
1152 file
->stat_info
->orig_file_name
));
1156 sparse_add_map (file
->stat_info
, &sp
);
1158 set_next_block_after (blk
);
1164 static struct tar_sparse_optab
const pax_optab
= {
1165 NULL
, /* No init function */
1166 NULL
, /* No done function */
1167 pax_sparse_member_p
,
1171 NULL
, /* No scan_block function */
1173 sparse_extract_region
,