1 /*-
2 * Copyright (c) 2010-2012 Michihiro NAKAJIMA
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25 #include "test.h"
26 __FBSDID("$FreeBSD$");
27
28 #ifdef HAVE_SYS_IOCTL_H
29 #include <sys/ioctl.h>
30 #endif
31 #ifdef HAVE_SYS_PARAM_H
32 #include <sys/param.h>
33 #endif
34 #ifdef HAVE_FCNTL_H
35 #include <fcntl.h>
36 #endif
37 #ifdef HAVE_LIMITS_H
38 #include <limits.h>
39 #endif
40 #ifdef HAVE_UNISTD_H
41 #include <unistd.h>
42 #endif
43 #ifdef HAVE_LINUX_TYPES_H
44 #include <linux/types.h>
45 #endif
46 #ifdef HAVE_LINUX_FIEMAP_H
47 #include <linux/fiemap.h>
48 #endif
49 #ifdef HAVE_LINUX_FS_H
50 #include <linux/fs.h>
51 #endif
52
53 /* The logic to compare sparse file data read from disk with the
54 * specification is a little involved. Set to 1 to have the progress
55 * dumped. */
56 #define DEBUG 0
57
58 /*
59 * NOTE: On FreeBSD and Solaris, this test needs ZFS.
60 * You may perform this test as
61 * 'TMPDIR=<a directory on the ZFS> libarchive_test'.
62 */
63
64 struct sparse {
65 enum { DATA, HOLE, END } type;
66 size_t size;
67 };
68
69 static void create_sparse_file(const char *, const struct sparse *);
70
71 #if defined(__APPLE__)
72 /* On APFS holes need to be at least 4096x4097 bytes */
73 #define MIN_HOLE 16781312
74 #else
75 /* Elsewhere we work with 4096*10 bytes */
76 #define MIN_HOLE 409600
77 #endif
78
79 #if defined(_WIN32) && !defined(__CYGWIN__)
80 #include <winioctl.h>
81 /*
82 * Create a sparse file on Windows.
83 */
84
85 #if !defined(PATH_MAX)
86 #define PATH_MAX MAX_PATH
87 #endif
88 #if !defined(__BORLANDC__)
89 #define getcwd _getcwd
90 #endif
91
92 static int
is_sparse_supported(const char * path)93 is_sparse_supported(const char *path)
94 {
95 char root[MAX_PATH+1];
96 char vol[MAX_PATH+1];
97 char sys[MAX_PATH+1];
98 DWORD flags;
99 BOOL r;
100
101 strncpy(root, path, sizeof(root)-1);
102 if (((root[0] >= 'c' && root[0] <= 'z') ||
103 (root[0] >= 'C' && root[0] <= 'Z')) &&
104 root[1] == ':' &&
105 (root[2] == '\\' || root[2] == '/'))
106 root[3] = '\0';
107 else
108 return (0);
109 assertEqualInt((r = GetVolumeInformation(root, vol,
110 sizeof(vol), NULL, NULL, &flags, sys, sizeof(sys))), 1);
111 return (r != 0 && (flags & FILE_SUPPORTS_SPARSE_FILES) != 0);
112 }
113
114 static void
create_sparse_file(const char * path,const struct sparse * s)115 create_sparse_file(const char *path, const struct sparse *s)
116 {
117 char buff[1024];
118 HANDLE handle;
119 DWORD dmy;
120
121 memset(buff, ' ', sizeof(buff));
122
123 handle = CreateFileA(path, GENERIC_WRITE, 0,
124 NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL,
125 NULL);
126 assert(handle != INVALID_HANDLE_VALUE);
127 assert(DeviceIoControl(handle, FSCTL_SET_SPARSE, NULL, 0,
128 NULL, 0, &dmy, NULL) != 0);
129
130 uint64_t offsetSoFar = 0;
131
132 while (s->type != END) {
133 if (s->type == HOLE) {
134 LARGE_INTEGER fileOffset, beyondOffset, distanceToMove;
135 fileOffset.QuadPart = offsetSoFar;
136 beyondOffset.QuadPart = offsetSoFar + s->size;
137 distanceToMove.QuadPart = s->size;
138
139 FILE_ZERO_DATA_INFORMATION zeroInformation;
140 zeroInformation.FileOffset = fileOffset;
141 zeroInformation.BeyondFinalZero = beyondOffset;
142
143 DWORD bytesReturned;
144 assert(SetFilePointerEx(handle, distanceToMove,
145 NULL, FILE_CURRENT) != 0);
146 assert(SetEndOfFile(handle) != 0);
147 assert(DeviceIoControl(handle, FSCTL_SET_ZERO_DATA, &zeroInformation,
148 sizeof(FILE_ZERO_DATA_INFORMATION), NULL, 0, &bytesReturned, NULL) != 0);
149 } else {
150 DWORD w, wr;
151 size_t size;
152
153 size = s->size;
154 while (size) {
155 if (size > sizeof(buff))
156 w = sizeof(buff);
157 else
158 w = (DWORD)size;
159 assert(WriteFile(handle, buff, w, &wr, NULL) != 0);
160 size -= wr;
161 }
162 }
163 offsetSoFar += s->size;
164 s++;
165 }
166 assertEqualInt(CloseHandle(handle), 1);
167 }
168
169 #else
170
171 #if defined(HAVE_LINUX_FIEMAP_H)
172 /*
173 * FIEMAP, which can detect 'hole' of a sparse file, has
174 * been supported from 2.6.28
175 */
176
177 static int
is_sparse_supported_fiemap(const char * path)178 is_sparse_supported_fiemap(const char *path)
179 {
180 const struct sparse sparse_file[] = {
181 /* This hole size is too small to create a sparse
182 * files for almost filesystem. */
183 { HOLE, 1024 }, { DATA, 10240 },
184 { END, 0 }
185 };
186 int fd, r;
187 struct fiemap *fm;
188 char buff[1024];
189 const char *testfile = "can_sparse";
190
191 (void)path; /* UNUSED */
192 memset(buff, 0, sizeof(buff));
193 create_sparse_file(testfile, sparse_file);
194 fd = open(testfile, O_RDWR);
195 if (fd < 0)
196 return (0);
197 fm = (struct fiemap *)buff;
198 fm->fm_start = 0;
199 fm->fm_length = ~0ULL;;
200 fm->fm_flags = FIEMAP_FLAG_SYNC;
201 fm->fm_extent_count = (sizeof(buff) - sizeof(*fm))/
202 sizeof(struct fiemap_extent);
203 r = ioctl(fd, FS_IOC_FIEMAP, fm);
204 close(fd);
205 unlink(testfile);
206 return (r >= 0);
207 }
208
209 #if !defined(SEEK_HOLE) || !defined(SEEK_DATA)
210 static int
is_sparse_supported(const char * path)211 is_sparse_supported(const char *path)
212 {
213 return is_sparse_supported_fiemap(path);
214 }
215 #endif
216 #endif
217
218 #if defined(_PC_MIN_HOLE_SIZE)
219
220 /*
221 * FreeBSD and Solaris can detect 'hole' of a sparse file
222 * through lseek(HOLE) on ZFS. (UFS does not support yet)
223 */
224
225 static int
is_sparse_supported(const char * path)226 is_sparse_supported(const char *path)
227 {
228 return (pathconf(path, _PC_MIN_HOLE_SIZE) > 0);
229 }
230
231 #elif defined(SEEK_HOLE) && defined(SEEK_DATA)
232
233 static int
is_sparse_supported(const char * path)234 is_sparse_supported(const char *path)
235 {
236 const struct sparse sparse_file[] = {
237 /* This hole size is too small to create a sparse
238 * files for almost filesystem. */
239 { HOLE, 1024 }, { DATA, 10240 },
240 { END, 0 }
241 };
242 int fd, r;
243 const char *testfile = "can_sparse";
244
245 (void)path; /* UNUSED */
246 create_sparse_file(testfile, sparse_file);
247 fd = open(testfile, O_RDWR);
248 if (fd < 0)
249 return (0);
250 r = lseek(fd, 0, SEEK_HOLE);
251 close(fd);
252 unlink(testfile);
253 #if defined(HAVE_LINUX_FIEMAP_H)
254 if (r < 0)
255 return (is_sparse_supported_fiemap(path));
256 return (1);
257 #else
258 return (r >= 0);
259 #endif
260 }
261
262 #elif !defined(HAVE_LINUX_FIEMAP_H)
263
264 /*
265 * Other system may do not have the API such as lseek(HOLE),
266 * which detect 'hole' of a sparse file.
267 */
268
269 static int
is_sparse_supported(const char * path)270 is_sparse_supported(const char *path)
271 {
272 (void)path; /* UNUSED */
273 return (0);
274 }
275
276 #endif
277
278 /*
279 * Create a sparse file on POSIX like system.
280 */
281
282 static void
create_sparse_file(const char * path,const struct sparse * s)283 create_sparse_file(const char *path, const struct sparse *s)
284 {
285 char buff[1024];
286 int fd;
287 uint64_t total_size = 0;
288 const struct sparse *cur = s;
289
290 memset(buff, ' ', sizeof(buff));
291 assert((fd = open(path, O_CREAT | O_WRONLY, 0600)) != -1);
292
293 /* Handle holes at the end by extending the file */
294 while (cur->type != END) {
295 total_size += cur->size;
296 ++cur;
297 }
298 assert(ftruncate(fd, total_size) != -1);
299
300 while (s->type != END) {
301 if (s->type == HOLE) {
302 assert(lseek(fd, s->size, SEEK_CUR) != (off_t)-1);
303 } else {
304 size_t w, size;
305
306 size = s->size;
307 while (size) {
308 if (size > sizeof(buff))
309 w = sizeof(buff);
310 else
311 w = size;
312 assert(write(fd, buff, w) != (ssize_t)-1);
313 size -= w;
314 }
315 }
316 s++;
317 }
318 close(fd);
319 }
320
321 #endif
322
323 /*
324 * Sparse test with directory traversals.
325 */
326 static void
verify_sparse_file(struct archive * a,const char * path,const struct sparse * sparse,int expected_holes)327 verify_sparse_file(struct archive *a, const char *path,
328 const struct sparse *sparse, int expected_holes)
329 {
330 struct archive_entry *ae;
331 const void *buff;
332 size_t bytes_read;
333 int64_t offset, expected_offset, last_offset;
334 int holes_seen = 0;
335
336 create_sparse_file(path, sparse);
337 assert((ae = archive_entry_new()) != NULL);
338 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, path));
339 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
340
341 expected_offset = 0;
342 last_offset = 0;
343 while (ARCHIVE_OK == archive_read_data_block(a, &buff, &bytes_read,
344 &offset)) {
345 const char *start = buff;
346 #if DEBUG
347 fprintf(stderr, "%s: bytes_read=%d offset=%d\n", path, (int)bytes_read, (int)offset);
348 #endif
349 if (offset > last_offset) {
350 ++holes_seen;
351 }
352 /* Blocks entirely before the data we just read. */
353 while (expected_offset + (int64_t)sparse->size < offset) {
354 #if DEBUG
355 fprintf(stderr, " skipping expected_offset=%d, size=%d\n", (int)expected_offset, (int)sparse->size);
356 #endif
357 /* Must be holes. */
358 assert(sparse->type == HOLE);
359 expected_offset += sparse->size;
360 ++sparse;
361 }
362 /* Block that overlaps beginning of data */
363 if (expected_offset < offset
364 && expected_offset + (int64_t)sparse->size <= offset + (int64_t)bytes_read) {
365 const char *end = (const char *)buff + (expected_offset - offset) + (size_t)sparse->size;
366 #if DEBUG
367 fprintf(stderr, " overlapping hole expected_offset=%d, size=%d\n", (int)expected_offset, (int)sparse->size);
368 #endif
369 if (sparse->type == HOLE) {
370 assertMemoryFilledWith(start, end - start, '\0');
371 } else if (assert(sparse->type == DATA)) {
372 assertMemoryFilledWith(start, end - start, ' ');
373 }
374 start = end;
375 expected_offset += sparse->size;
376 ++sparse;
377 }
378 /* Blocks completely contained in data we just read. */
379 while (expected_offset + (int64_t)sparse->size <= offset + (int64_t)bytes_read) {
380 const char *end = (const char *)buff + (expected_offset - offset) + (size_t)sparse->size;
381 if (sparse->type == HOLE) {
382 #if DEBUG
383 fprintf(stderr, " contained hole expected_offset=%d, size=%d\n", (int)expected_offset, (int)sparse->size);
384 #endif
385
386 /* verify data corresponding to hole is '\0' */
387 if (end > (const char *)buff + bytes_read) {
388 end = (const char *)buff + bytes_read;
389 }
390 assertMemoryFilledWith(start, end - start, '\0');
391 start = end;
392 expected_offset += sparse->size;
393 ++sparse;
394 } else if (sparse->type == DATA) {
395 #if DEBUG
396 fprintf(stderr, " contained data expected_offset=%d, size=%d\n", (int)expected_offset, (int)sparse->size);
397 #endif
398 /* verify data corresponding to hole is ' ' */
399 if (assert(expected_offset + sparse->size <= offset + bytes_read)) {
400 assert(start == (const char *)buff + (size_t)(expected_offset - offset));
401 assertMemoryFilledWith(start, end - start, ' ');
402 }
403 start = end;
404 expected_offset += sparse->size;
405 ++sparse;
406 } else {
407 break;
408 }
409 }
410 /* Block that overlaps end of data */
411 if (expected_offset < offset + (int64_t)bytes_read) {
412 const char *end = (const char *)buff + bytes_read;
413 #if DEBUG
414 fprintf(stderr, " trailing overlap expected_offset=%d, size=%d\n", (int)expected_offset, (int)sparse->size);
415 #endif
416 if (sparse->type == HOLE) {
417 assertMemoryFilledWith(start, end - start, '\0');
418 } else if (assert(sparse->type == DATA)) {
419 assertMemoryFilledWith(start, end - start, ' ');
420 }
421 }
422 last_offset = offset + bytes_read;
423 }
424 /* Count a hole at EOF? */
425 if (last_offset < archive_entry_size(ae)) {
426 ++holes_seen;
427 }
428
429 /* Verify blocks after last read */
430 while (sparse->type == HOLE) {
431 expected_offset += sparse->size;
432 ++sparse;
433 }
434 assert(sparse->type == END);
435 assertEqualInt(expected_offset, archive_entry_size(ae));
436
437 failure("%s", path);
438 assertEqualInt(holes_seen, expected_holes);
439
440 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
441 archive_entry_free(ae);
442 }
443
444 #if defined(_WIN32) && !defined(__CYGWIN__)
445 #define close _close
446 #define open _open
447 #endif
448
449 /*
450 * Sparse test without directory traversals.
451 */
452 static void
verify_sparse_file2(struct archive * a,const char * path,const struct sparse * sparse,int blocks,int preopen)453 verify_sparse_file2(struct archive *a, const char *path,
454 const struct sparse *sparse, int blocks, int preopen)
455 {
456 struct archive_entry *ae;
457 int fd;
458
459 (void)sparse; /* UNUSED */
460 assert((ae = archive_entry_new()) != NULL);
461 archive_entry_set_pathname(ae, path);
462 if (preopen)
463 fd = open(path, O_RDONLY | O_BINARY);
464 else
465 fd = -1;
466 assertEqualIntA(a, ARCHIVE_OK,
467 archive_read_disk_entry_from_file(a, ae, fd, NULL));
468 if (fd >= 0)
469 close(fd);
470 /* Verify the number of holes only, not its offset nor its
471 * length because those alignments are deeply dependence on
472 * its filesystem. */
473 failure("%s", path);
474 assertEqualInt(blocks, archive_entry_sparse_count(ae));
475 archive_entry_free(ae);
476 }
477
478 static void
test_sparse_whole_file_data(void)479 test_sparse_whole_file_data(void)
480 {
481 struct archive_entry *ae;
482 int64_t offset;
483 int i;
484
485 assert((ae = archive_entry_new()) != NULL);
486 archive_entry_set_size(ae, 1024*10);
487
488 /*
489 * Add sparse block data up to the file size.
490 */
491 offset = 0;
492 for (i = 0; i < 10; i++) {
493 archive_entry_sparse_add_entry(ae, offset, 1024);
494 offset += 1024;
495 }
496
497 failure("There should be no sparse");
498 assertEqualInt(0, archive_entry_sparse_count(ae));
499 archive_entry_free(ae);
500 }
501
DEFINE_TEST(test_sparse_basic)502 DEFINE_TEST(test_sparse_basic)
503 {
504 char *cwd;
505 struct archive *a;
506 const char *skip_sparse_tests;
507 /*
508 * The alignment of the hole of sparse files deeply depends
509 * on filesystem. In my experience, sparse_file2 test with
510 * 204800 bytes hole size did not pass on ZFS and the result
511 * of that test seemed the size was too small, thus you should
512 * keep a hole size more than 409600 bytes to pass this test
513 * on all platform.
514 */
515 const struct sparse sparse_file0[] = {
516 // 0 // 1024
517 { DATA, 1024 }, { HOLE, MIN_HOLE + 1638400 },
518 // 2049024 // 2051072
519 { DATA, 2048 }, { HOLE, MIN_HOLE + 1638400 },
520 // 4099072 // 4103168
521 { DATA, 4096 }, { HOLE, MIN_HOLE + 20070400 },
522 // 24583168 // 24591360
523 { DATA, 8192 }, { HOLE, MIN_HOLE + 204390400 },
524 // 229391360 // 229391361
525 { DATA, 1 }, { END, 0 }
526 };
527 const struct sparse sparse_file1[] = {
528 { HOLE, MIN_HOLE }, { DATA, 1 },
529 { HOLE, MIN_HOLE }, { DATA, 1 },
530 { HOLE, MIN_HOLE }, { END, 0 }
531 };
532 const struct sparse sparse_file2[] = {
533 { HOLE, MIN_HOLE }, { DATA, 1024 },
534 { HOLE, MIN_HOLE + 409600 * 1 }, { DATA, 1024 },
535 { HOLE, MIN_HOLE + 409600 * 2 }, { DATA, 1024 },
536 { HOLE, MIN_HOLE + 409600 * 3 }, { DATA, 1024 },
537 { HOLE, MIN_HOLE + 409600 * 4 }, { DATA, 1024 },
538 { HOLE, MIN_HOLE + 409600 * 5 }, { DATA, 1024 },
539 { HOLE, MIN_HOLE + 409600 * 6 }, { DATA, 1024 },
540 { HOLE, MIN_HOLE + 409600 * 7 }, { DATA, 1024 },
541 { HOLE, MIN_HOLE + 409600 * 8 }, { DATA, 1024 },
542 { HOLE, MIN_HOLE + 409600 * 9}, { DATA, 1024 },/* 10 */
543 { HOLE, MIN_HOLE }, { DATA, 1024 * 1 },
544 { HOLE, MIN_HOLE + 409600 * 1 }, { DATA, 1024 * 2 },
545 { HOLE, MIN_HOLE + 409600 * 2 }, { DATA, 1024 * 3 },
546 { HOLE, MIN_HOLE + 409600 * 3 }, { DATA, 1024 * 4 },
547 { HOLE, MIN_HOLE + 409600 * 4 }, { DATA, 1024 * 5 },
548 { HOLE, MIN_HOLE + 409600 * 5 }, { DATA, 1024 * 6 },
549 { HOLE, MIN_HOLE + 409600 * 6 }, { DATA, 1024 * 7 },
550 { HOLE, MIN_HOLE + 409600 * 7 }, { DATA, 1024 * 8 },
551 { HOLE, MIN_HOLE + 409600 * 8 }, { DATA, 1024 * 9 },
552 { HOLE, MIN_HOLE + 409600 * 9}, { DATA, 1024 * 10},/* 20 */
553 { END, 0 }
554 };
555 const struct sparse sparse_file3[] = {
556 /* This hole size is too small to create a sparse file */
557 { HOLE, 1 }, { DATA, 10240 },
558 { HOLE, 1 }, { DATA, 10240 },
559 { HOLE, 1 }, { DATA, 10240 },
560 { END, 0 }
561 };
562 const struct sparse sparse_file4[] = {
563 { DATA, 4096 }, { HOLE, 0xc0000000 },
564 /* This hole overflows the offset if stored in 32 bits. */
565 { DATA, 4096 }, { HOLE, 0x50000000 },
566 { END, 0 }
567 };
568
569 /*
570 * Test for the case that sparse data indicates just the whole file
571 * data.
572 */
573 test_sparse_whole_file_data();
574
575 skip_sparse_tests = getenv("SKIP_TEST_SPARSE");
576 if (skip_sparse_tests != NULL) {
577 skipping("Skipping sparse tests due to SKIP_TEST_SPARSE "
578 "environment variable");
579 return;
580 }
581
582 /* Check if the filesystem where CWD on can
583 * report the number of the holes of a sparse file. */
584 #if defined(PATH_MAX) && !defined(__GLIBC__)
585 cwd = getcwd(NULL, PATH_MAX);/* Solaris getcwd needs the size. */
586 #else
587 cwd = getcwd(NULL, 0);
588 #endif
589 if (!assert(cwd != NULL))
590 return;
591 if (!is_sparse_supported(cwd)) {
592 free(cwd);
593 skipping("This filesystem or platform do not support "
594 "the reporting of the holes of a sparse file through "
595 "API such as lseek(HOLE)");
596 return;
597 }
598
599 /*
600 * Get sparse data through directory traversals.
601 */
602 assert((a = archive_read_disk_new()) != NULL);
603
604 verify_sparse_file(a, "file0", sparse_file0, 4);
605 verify_sparse_file(a, "file1", sparse_file1, 3);
606 verify_sparse_file(a, "file2", sparse_file2, 20);
607 /* Encoded non sparse; expect a data block but no sparse entries. */
608 verify_sparse_file(a, "file3", sparse_file3, 0);
609 verify_sparse_file(a, "file4", sparse_file4, 2);
610
611 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
612
613 /*
614 * Get sparse data through archive_read_disk_entry_from_file().
615 */
616 assert((a = archive_read_disk_new()) != NULL);
617
618 verify_sparse_file2(a, "file0", sparse_file0, 5, 0);
619 verify_sparse_file2(a, "file0", sparse_file0, 5, 1);
620
621 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
622
623 /*
624 * Test that setting ARCHIVE_READDISK_NO_SPARSE
625 * creates no sparse entries.
626 */
627 assert((a = archive_read_disk_new()) != NULL);
628
629 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_set_behavior(a,
630 ARCHIVE_READDISK_NO_SPARSE));
631
632 verify_sparse_file(a, "file0", sparse_file0, 0);
633 verify_sparse_file(a, "file1", sparse_file1, 0);
634 verify_sparse_file(a, "file2", sparse_file2, 0);
635 verify_sparse_file(a, "file3", sparse_file3, 0);
636 verify_sparse_file(a, "file4", sparse_file4, 0);
637
638 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
639
640 assert((a = archive_read_disk_new()) != NULL);
641
642 assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_set_behavior(a,
643 ARCHIVE_READDISK_NO_SPARSE));
644
645 verify_sparse_file2(a, "file0", sparse_file0, 0, 0);
646 verify_sparse_file2(a, "file0", sparse_file0, 0, 1);
647
648 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
649 free(cwd);
650 }
651
DEFINE_TEST(test_fully_sparse_files)652 DEFINE_TEST(test_fully_sparse_files)
653 {
654 char *cwd;
655 struct archive *a;
656 const char *skip_sparse_tests;
657
658 const struct sparse sparse_file[] = {
659 { HOLE, MIN_HOLE }, { END, 0 }
660 };
661
662 skip_sparse_tests = getenv("SKIP_TEST_SPARSE");
663 if (skip_sparse_tests != NULL) {
664 skipping("Skipping sparse tests due to SKIP_TEST_SPARSE "
665 "environment variable");
666 return;
667 }
668
669 /* Check if the filesystem where CWD on can
670 * report the number of the holes of a sparse file. */
671 #if defined(PATH_MAX) && !defined(__GLIBC__)
672 cwd = getcwd(NULL, PATH_MAX);/* Solaris getcwd needs the size. */
673 #else
674 cwd = getcwd(NULL, 0);
675 #endif
676 if (!assert(cwd != NULL))
677 return;
678 if (!is_sparse_supported(cwd)) {
679 free(cwd);
680 skipping("This filesystem or platform do not support "
681 "the reporting of the holes of a sparse file through "
682 "API such as lseek(HOLE)");
683 return;
684 }
685
686 assert((a = archive_read_disk_new()) != NULL);
687
688 /* Fully sparse files are encoded with a zero-length "data" block. */
689 verify_sparse_file(a, "file0", sparse_file, 1);
690
691 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
692 free(cwd);
693 }
694