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_FIEMAP_H
44#include <linux/fiemap.h>
45#endif
46#ifdef HAVE_LINUX_FS_H
47#include <linux/fs.h>
48#endif
49
50/*
51 * NOTE: On FreeBSD and Solaris, this test needs ZFS.
52 * You may should perfom this test as
53 * 'TMPDIR=<a directory on the ZFS> libarchive_test'.
54 */
55
56struct sparse {
57	enum { DATA, HOLE, END } type;
58	size_t	size;
59};
60
61static void create_sparse_file(const char *, const struct sparse *);
62
63#if defined(_WIN32) && !defined(__CYGWIN__)
64#include <winioctl.h>
65/*
66 * Create a sparse file on Windows.
67 */
68
69#if !defined(PATH_MAX)
70#define	PATH_MAX	MAX_PATH
71#endif
72#if !defined(__BORLANDC__)
73#define getcwd _getcwd
74#endif
75
76static int
77is_sparse_supported(const char *path)
78{
79	char root[MAX_PATH+1];
80	char vol[MAX_PATH+1];
81	char sys[MAX_PATH+1];
82	DWORD flags;
83	BOOL r;
84
85	strncpy(root, path, sizeof(root)-1);
86	if (((root[0] >= 'c' && root[0] <= 'z') ||
87	    (root[0] >= 'C' && root[0] <= 'Z')) &&
88		root[1] == ':' &&
89	    (root[2] == '\\' || root[2] == '/'))
90		root[3] = '\0';
91	else
92		return (0);
93	assertEqualInt((r = GetVolumeInformation(root, vol,
94	    sizeof(vol), NULL, NULL, &flags, sys, sizeof(sys))), 1);
95	return (r != 0 && (flags & FILE_SUPPORTS_SPARSE_FILES) != 0);
96}
97
98static void
99create_sparse_file(const char *path, const struct sparse *s)
100{
101	char buff[1024];
102	HANDLE handle;
103	DWORD dmy;
104
105	memset(buff, ' ', sizeof(buff));
106
107	handle = CreateFileA(path, GENERIC_WRITE, 0,
108	    NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL,
109	    NULL);
110	assert(handle != INVALID_HANDLE_VALUE);
111	assert(DeviceIoControl(handle, FSCTL_SET_SPARSE, NULL, 0,
112	    NULL, 0, &dmy, NULL) != 0);
113	while (s->type != END) {
114		if (s->type == HOLE) {
115			LARGE_INTEGER distance;
116
117			distance.QuadPart = s->size;
118			assert(SetFilePointerEx(handle, distance,
119			    NULL, FILE_CURRENT) != 0);
120		} else {
121			DWORD w, wr;
122			size_t size;
123
124			size = s->size;
125			while (size) {
126				if (size > sizeof(buff))
127					w = sizeof(buff);
128				else
129					w = (DWORD)size;
130				assert(WriteFile(handle, buff, w, &wr, NULL) != 0);
131				size -= wr;
132			}
133		}
134		s++;
135	}
136	assertEqualInt(CloseHandle(handle), 1);
137}
138
139#else
140
141#if defined(_PC_MIN_HOLE_SIZE)
142
143/*
144 * FreeBSD and Solaris can detect 'hole' of a sparse file
145 * through lseek(HOLE) on ZFS. (UFS does not support yet)
146 */
147
148static int
149is_sparse_supported(const char *path)
150{
151	return (pathconf(path, _PC_MIN_HOLE_SIZE) > 0);
152}
153
154#elif defined(__linux__)&& defined(HAVE_LINUX_FIEMAP_H)
155
156/*
157 * FIEMAP, which can detect 'hole' of a sparse file, has
158 * been supported from 2.6.28
159 */
160
161static int
162is_sparse_supported(const char *path)
163{
164	const struct sparse sparse_file[] = {
165 		/* This hole size is too small to create a sparse
166		 * files for almost filesystem. */
167		{ HOLE,	 1024 }, { DATA, 10240 },
168		{ END,	0 }
169	};
170	int fd, r;
171	struct fiemap *fm;
172	char buff[1024];
173	const char *testfile = "can_sparse";
174
175	(void)path; /* UNUSED */
176	memset(buff, 0, sizeof(buff));
177	create_sparse_file(testfile, sparse_file);
178	fd = open(testfile,  O_RDWR);
179	if (fd < 0)
180		return (0);
181	fm = (struct fiemap *)buff;
182	fm->fm_start = 0;
183	fm->fm_length = ~0ULL;;
184	fm->fm_flags = FIEMAP_FLAG_SYNC;
185	fm->fm_extent_count = (sizeof(buff) - sizeof(*fm))/
186		sizeof(struct fiemap_extent);
187	r = ioctl(fd, FS_IOC_FIEMAP, fm);
188	close(fd);
189	unlink(testfile);
190	return (r >= 0);
191}
192
193#else
194
195/*
196 * Other system may do not have the API such as lseek(HOLE),
197 * which detect 'hole' of a sparse file.
198 */
199
200static int
201is_sparse_supported(const char *path)
202{
203	(void)path; /* UNUSED */
204	return (0);
205}
206
207#endif
208
209/*
210 * Create a sparse file on POSIX like system.
211 */
212
213static void
214create_sparse_file(const char *path, const struct sparse *s)
215{
216	char buff[1024];
217	int fd;
218
219	memset(buff, ' ', sizeof(buff));
220	assert((fd = open(path, O_CREAT | O_WRONLY, 0600)) != -1);
221	while (s->type != END) {
222		if (s->type == HOLE) {
223			assert(lseek(fd, s->size, SEEK_CUR) != (off_t)-1);
224		} else {
225			size_t w, size;
226
227			size = s->size;
228			while (size) {
229				if (size > sizeof(buff))
230					w = sizeof(buff);
231				else
232					w = size;
233				assert(write(fd, buff, w) != (ssize_t)-1);
234				size -= w;
235			}
236		}
237		s++;
238	}
239	close(fd);
240}
241
242#endif
243
244/*
245 * Sparse test with directory traversals.
246 */
247static void
248verify_sparse_file(struct archive *a, const char *path,
249    const struct sparse *sparse, int blocks)
250{
251	struct archive_entry *ae;
252	const void *buff;
253	size_t bytes_read;
254	int64_t offset;
255	int64_t total;
256	int data_blocks, hole;
257
258	create_sparse_file(path, sparse);
259	assert((ae = archive_entry_new()) != NULL);
260	assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, path));
261	assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header2(a, ae));
262	/* Verify the number of holes only, not its offset nor its
263	 * length because those alignments are deeply dependence on
264	 * its filesystem. */
265	assertEqualInt(blocks, archive_entry_sparse_count(ae));
266	total = 0;
267	data_blocks = 0;
268	hole = 0;
269	while (ARCHIVE_OK == archive_read_data_block(a, &buff, &bytes_read,
270	    &offset)) {
271		if (offset > total || offset == 0) {
272			if (offset > total)
273				hole = 1;
274			data_blocks++;
275		}
276		total = offset + bytes_read;
277	}
278	if (!hole && data_blocks == 1)
279		data_blocks = 0;/* There are no holes */
280	assertEqualInt(blocks, data_blocks);
281
282	assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
283	archive_entry_free(ae);
284}
285
286#if defined(_WIN32) && !defined(__CYGWIN__)
287#define	close		_close
288#define	open		_open
289#endif
290
291/*
292 * Sparse test without directory traversals.
293 */
294static void
295verify_sparse_file2(struct archive *a, const char *path,
296    const struct sparse *sparse, int blocks, int preopen)
297{
298	struct archive_entry *ae;
299	int fd;
300
301	(void)sparse; /* UNUSED */
302	assert((ae = archive_entry_new()) != NULL);
303	archive_entry_set_pathname(ae, path);
304	if (preopen)
305		fd = open(path, O_RDONLY | O_BINARY);
306	else
307		fd = -1;
308	assertEqualIntA(a, ARCHIVE_OK,
309	    archive_read_disk_entry_from_file(a, ae, fd, NULL));
310	if (fd >= 0)
311		close(fd);
312	/* Verify the number of holes only, not its offset nor its
313	 * length because those alignments are deeply dependence on
314	 * its filesystem. */
315	assertEqualInt(blocks, archive_entry_sparse_count(ae));
316	archive_entry_free(ae);
317}
318
319static void
320test_sparse_whole_file_data()
321{
322	struct archive_entry *ae;
323	int64_t offset;
324	int i;
325
326	assert((ae = archive_entry_new()) != NULL);
327	archive_entry_set_size(ae, 1024*10);
328
329	/*
330	 * Add sparse block data up to the file size.
331	 */
332	offset = 0;
333	for (i = 0; i < 10; i++) {
334		archive_entry_sparse_add_entry(ae, offset, 1024);
335		offset += 1024;
336	}
337
338	failure("There should be no sparse");
339	assertEqualInt(0, archive_entry_sparse_count(ae));
340	archive_entry_free(ae);
341}
342
343DEFINE_TEST(test_sparse_basic)
344{
345	char *cwd;
346	struct archive *a;
347	/*
348	 * The alignment of the hole of sparse files deeply depends
349	 * on filesystem. In my experience, sparse_file2 test with
350	 * 204800 bytes hole size did not pass on ZFS and the result
351	 * of that test seemed the size was too small, thus you should
352	 * keep a hole size more than 409600 bytes to pass this test
353	 * on all platform.
354	 */
355	const struct sparse sparse_file0[] = {
356		{ DATA,	 1024 }, { HOLE,   2048000 },
357		{ DATA,	 2048 }, { HOLE,   2048000 },
358		{ DATA,	 4096 }, { HOLE,  20480000 },
359		{ DATA,	 8192 }, { HOLE, 204800000 },
360		{ DATA,     1 }, { END,	0 }
361	};
362	const struct sparse sparse_file1[] = {
363		{ HOLE,	409600 }, { DATA, 1 },
364		{ HOLE,	409600 }, { DATA, 1 },
365		{ HOLE,	409600 }, { END,  0 }
366	};
367	const struct sparse sparse_file2[] = {
368		{ HOLE,	409600 * 1 }, { DATA, 1024 },
369		{ HOLE,	409600 * 2 }, { DATA, 1024 },
370		{ HOLE,	409600 * 3 }, { DATA, 1024 },
371		{ HOLE,	409600 * 4 }, { DATA, 1024 },
372		{ HOLE,	409600 * 5 }, { DATA, 1024 },
373		{ HOLE,	409600 * 6 }, { DATA, 1024 },
374		{ HOLE,	409600 * 7 }, { DATA, 1024 },
375		{ HOLE,	409600 * 8 }, { DATA, 1024 },
376		{ HOLE,	409600 * 9 }, { DATA, 1024 },
377		{ HOLE,	409600 * 10}, { DATA, 1024 },/* 10 */
378		{ HOLE,	409600 * 1 }, { DATA, 1024 * 1 },
379		{ HOLE,	409600 * 2 }, { DATA, 1024 * 2 },
380		{ HOLE,	409600 * 3 }, { DATA, 1024 * 3 },
381		{ HOLE,	409600 * 4 }, { DATA, 1024 * 4 },
382		{ HOLE,	409600 * 5 }, { DATA, 1024 * 5 },
383		{ HOLE,	409600 * 6 }, { DATA, 1024 * 6 },
384		{ HOLE,	409600 * 7 }, { DATA, 1024 * 7 },
385		{ HOLE,	409600 * 8 }, { DATA, 1024 * 8 },
386		{ HOLE,	409600 * 9 }, { DATA, 1024 * 9 },
387		{ HOLE,	409600 * 10}, { DATA, 1024 * 10},/* 20 */
388		{ END,	0 }
389	};
390	const struct sparse sparse_file3[] = {
391 		/* This hole size is too small to create a sparse
392		 * files for almost filesystem. */
393		{ HOLE,	 1024 }, { DATA, 10240 },
394		{ END,	0 }
395	};
396
397	/*
398	 * Test for the case that sparse data indicates just the whole file
399	 * data.
400	 */
401	test_sparse_whole_file_data();
402
403	/* Check if the filesystem where CWD on can
404	 * report the number of the holes of a sparse file. */
405#ifdef PATH_MAX
406	cwd = getcwd(NULL, PATH_MAX);/* Solaris getcwd needs the size. */
407#else
408	cwd = getcwd(NULL, 0);
409#endif
410	if (!assert(cwd != NULL))
411		return;
412	if (!is_sparse_supported(cwd)) {
413		free(cwd);
414		skipping("This filesystem or platform do not support "
415		    "the reporting of the holes of a sparse file through "
416		    "API such as lseek(HOLE)");
417		return;
418	}
419
420	/*
421	 * Get sparse data through directory traversals.
422	 */
423	assert((a = archive_read_disk_new()) != NULL);
424
425	verify_sparse_file(a, "file0", sparse_file0, 5);
426	verify_sparse_file(a, "file1", sparse_file1, 2);
427	verify_sparse_file(a, "file2", sparse_file2, 20);
428	verify_sparse_file(a, "file3", sparse_file3, 0);
429
430	assertEqualInt(ARCHIVE_OK, archive_read_free(a));
431
432	/*
433	 * Get sparse data through archive_read_disk_entry_from_file().
434	 */
435	assert((a = archive_read_disk_new()) != NULL);
436
437	verify_sparse_file2(a, "file0", sparse_file0, 5, 0);
438	verify_sparse_file2(a, "file0", sparse_file0, 5, 1);
439
440	assertEqualInt(ARCHIVE_OK, archive_read_free(a));
441	free(cwd);
442}
443