2 * Copyright (c) 2003-2007 Tim Kientzle
3 * Copyright (c) 2011 Michihiro NAKAJIMA
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 __FBSDID("$FreeBSD$");
29 #define __LIBARCHIVE_BUILD
30 #include <archive_crc32.h>
33 int extract_one(struct archive* a, struct archive_entry* ae, uint32_t crc)
35 la_ssize_t fsize, bytes_read;
38 uint32_t computed_crc;
40 fsize = (la_ssize_t) archive_entry_size(ae);
45 bytes_read = archive_read_data(a, buf, fsize);
46 if(bytes_read != fsize) {
47 assertEqualInt(bytes_read, fsize);
51 computed_crc = crc32(0, buf, fsize);
52 assertEqualInt(computed_crc, crc);
61 int extract_one_using_blocks(struct archive* a, int block_size, uint32_t crc)
65 uint32_t computed_crc = 0;
66 la_ssize_t bytes_read;
68 buf = malloc(block_size);
73 bytes_read = archive_read_data(a, buf, block_size);
74 if(bytes_read == ARCHIVE_RETRY)
76 else if(bytes_read == 0)
78 else if(bytes_read < 0) {
79 /* If we're here, it means the decompressor has failed
80 * to properly decode test file. */
88 computed_crc = crc32(computed_crc, buf, bytes_read);
91 assertEqualInt(computed_crc, crc);
100 * The reference file for this has been manually tweaked so that:
101 * * file2 has length-at-end but file1 does not
102 * * file2 has an invalid CRC
105 verify_basic(struct archive *a, int seek_checks)
107 struct archive_entry *ae;
113 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
114 assertEqualString("ZIP 1.0 (uncompressed)", archive_format_name(a));
115 assertEqualString("dir/", archive_entry_pathname(ae));
116 assertEqualInt(1179604249, archive_entry_mtime(ae));
117 assertEqualInt(0, archive_entry_size(ae));
119 assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae));
120 assertEqualInt(archive_entry_is_encrypted(ae), 0);
121 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
122 assertEqualIntA(a, ARCHIVE_EOF,
123 archive_read_data_block(a, &pv, &s, &o));
124 assertEqualInt((int)s, 0);
126 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
127 assertEqualString("ZIP 2.0 (deflation)", archive_format_name(a));
128 assertEqualString("file1", archive_entry_pathname(ae));
129 assertEqualInt(1179604289, archive_entry_mtime(ae));
131 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
132 assertEqualInt(18, archive_entry_size(ae));
133 assertEqualInt(archive_entry_is_encrypted(ae), 0);
134 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
135 failure("archive_read_data() returns number of bytes read");
136 if (archive_zlib_version() != NULL) {
137 assertEqualInt(18, archive_read_data(a, buff, 19));
138 assertEqualMem(buff, "hello\nhello\nhello\n", 18);
140 assertEqualInt(ARCHIVE_FAILED, archive_read_data(a, buff, 19));
141 assertEqualString(archive_error_string(a),
142 "Unsupported ZIP compression method (deflation)");
143 assert(archive_errno(a) != 0);
146 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
147 assertEqualString("ZIP 2.0 (deflation)", archive_format_name(a));
148 assertEqualString("file2", archive_entry_pathname(ae));
149 assertEqualInt(1179605932, archive_entry_mtime(ae));
150 assertEqualInt(archive_entry_is_encrypted(ae), 0);
151 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
153 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
155 assert(archive_entry_size_is_set(ae));
156 assertEqualInt(18, archive_entry_size(ae));
157 if (archive_zlib_version() != NULL) {
158 failure("file2 has a bad CRC, so read should fail and not change buff");
159 memset(buff, 'a', 19);
160 assertEqualInt(ARCHIVE_WARN, archive_read_data(a, buff, 19));
161 assertEqualMem(buff, "aaaaaaaaaaaaaaaaaaa", 19);
163 assertEqualInt(ARCHIVE_FAILED, archive_read_data(a, buff, 19));
164 assertEqualString(archive_error_string(a),
165 "Unsupported ZIP compression method (deflation)");
166 assert(archive_errno(a) != 0);
168 assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &ae));
169 assertEqualString("ZIP 2.0 (deflation)", archive_format_name(a));
170 /* Verify the number of files read. */
171 failure("the archive file has three files");
172 assertEqualInt(3, archive_file_count(a));
173 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
174 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
175 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
176 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
182 const char *refname = "test_read_format_zip.zip";
187 extract_reference_file(refname);
189 /* Verify with seeking reader. */
190 assert((a = archive_read_new()) != NULL);
191 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
192 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
193 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 10240));
196 /* Verify with streaming reader. */
197 p = slurpfile(&s, refname);
198 assert((a = archive_read_new()) != NULL);
199 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
200 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
201 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, p, s, 31));
207 * Read Info-ZIP New Unix Extra Field 0x7875 "ux".
208 * Currently stores Unix UID/GID up to 32 bits.
211 verify_info_zip_ux(struct archive *a, int seek_checks)
213 struct archive_entry *ae;
216 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
217 assertEqualString("file1", archive_entry_pathname(ae));
218 assertEqualInt(1300668680, archive_entry_mtime(ae));
219 assertEqualInt(18, archive_entry_size(ae));
220 assertEqualInt(archive_entry_is_encrypted(ae), 0);
221 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
223 assertEqualInt(AE_IFREG | 0644, archive_entry_mode(ae));
224 failure("zip reader should read Info-ZIP New Unix Extra Field");
225 assertEqualInt(1001, archive_entry_uid(ae));
226 assertEqualInt(1001, archive_entry_gid(ae));
227 if (archive_zlib_version() != NULL) {
228 failure("archive_read_data() returns number of bytes read");
229 assertEqualInt(18, archive_read_data(a, buff, 19));
230 assertEqualMem(buff, "hello\nhello\nhello\n", 18);
232 assertEqualInt(ARCHIVE_FAILED, archive_read_data(a, buff, 19));
233 assertEqualString(archive_error_string(a),
234 "Unsupported ZIP compression method (deflation)");
235 assert(archive_errno(a) != 0);
237 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
239 /* Verify the number of files read. */
240 failure("the archive file has just one file");
241 assertEqualInt(1, archive_file_count(a));
243 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
244 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
245 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
246 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
250 test_info_zip_ux(void)
252 const char *refname = "test_read_format_zip_ux.zip";
257 extract_reference_file(refname);
259 /* Verify with seeking reader. */
260 assert((a = archive_read_new()) != NULL);
261 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
262 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
263 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 10240));
264 verify_info_zip_ux(a, 1);
266 /* Verify with streaming reader. */
267 p = slurpfile(&s, refname);
268 assert((a = archive_read_new()) != NULL);
269 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
270 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
271 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, p, s, 108));
272 verify_info_zip_ux(a, 0);
277 * Verify that test_read_extract correctly works with
278 * Zip entries that use length-at-end.
281 verify_extract_length_at_end(struct archive *a, int seek_checks)
283 struct archive_entry *ae;
285 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
287 assertEqualInt(archive_entry_is_encrypted(ae), 0);
288 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
289 assertEqualString("hello.txt", archive_entry_pathname(ae));
291 assertEqualInt(AE_IFREG | 0644, archive_entry_mode(ae));
292 assert(archive_entry_size_is_set(ae));
293 assertEqualInt(6, archive_entry_size(ae));
295 assert(!archive_entry_size_is_set(ae));
296 assertEqualInt(0, archive_entry_size(ae));
299 if (archive_zlib_version() != NULL) {
300 assertEqualIntA(a, ARCHIVE_OK, archive_read_extract(a, ae, 0));
301 assertFileContents("hello\x0A", 6, "hello.txt");
303 assertEqualIntA(a, ARCHIVE_FAILED, archive_read_extract(a, ae, 0));
304 assertEqualString(archive_error_string(a),
305 "Unsupported ZIP compression method (deflation)");
306 assert(archive_errno(a) != 0);
309 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
310 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
314 test_extract_length_at_end(void)
316 const char *refname = "test_read_format_zip_length_at_end.zip";
321 extract_reference_file(refname);
323 /* Verify extraction with seeking reader. */
324 assert((a = archive_read_new()) != NULL);
325 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
326 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
327 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 10240));
328 verify_extract_length_at_end(a, 1);
330 /* Verify extraction with streaming reader. */
331 p = slurpfile(&s, refname);
332 assert((a = archive_read_new()) != NULL);
333 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
334 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
335 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, p, s, 108));
336 verify_extract_length_at_end(a, 0);
343 const char *refname = "test_read_format_zip_symlink.zip";
347 struct archive_entry *ae;
349 extract_reference_file(refname);
350 p = slurpfile(&s, refname);
352 /* Symlinks can only be extracted with the seeking reader. */
353 assert((a = archive_read_new()) != NULL);
354 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
355 assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, p, s, 1));
357 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
358 assertEqualString("file", archive_entry_pathname(ae));
359 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
360 assertEqualInt(archive_entry_is_encrypted(ae), 0);
361 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
363 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
364 assertEqualString("symlink", archive_entry_pathname(ae));
365 assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
366 assertEqualInt(0, archive_entry_size(ae));
367 assertEqualString("file", archive_entry_symlink(ae));
368 assertEqualInt(archive_entry_is_encrypted(ae), 0);
369 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
371 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
372 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
373 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
378 DEFINE_TEST(test_read_format_zip)
382 test_extract_length_at_end();
386 DEFINE_TEST(test_read_format_zip_ppmd_one_file)
388 const char *refname = "test_read_format_zip_ppmd8.zipx";
390 struct archive_entry *ae;
392 extract_reference_file(refname);
394 assert((a = archive_read_new()) != NULL);
395 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
396 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
397 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
398 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
399 assertEqualString("vimrc", archive_entry_pathname(ae));
400 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
401 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
402 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
403 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
406 DEFINE_TEST(test_read_format_zip_ppmd_one_file_blockread)
408 const char *refname = "test_read_format_zip_ppmd8.zipx";
410 struct archive_entry *ae;
412 extract_reference_file(refname);
414 assert((a = archive_read_new()) != NULL);
415 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
416 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
417 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
418 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
419 assertEqualString("vimrc", archive_entry_pathname(ae));
420 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
421 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
422 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
423 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
426 DEFINE_TEST(test_read_format_zip_ppmd_multi)
428 const char *refname = "test_read_format_zip_ppmd8_multi.zipx";
430 struct archive_entry *ae;
432 extract_reference_file(refname);
434 assert((a = archive_read_new()) != NULL);
435 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
436 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
438 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
439 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
440 assertEqualString("smartd.conf", archive_entry_pathname(ae));
441 assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E));
443 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
444 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
445 assertEqualString("ts.conf", archive_entry_pathname(ae));
446 assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31));
448 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
449 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
450 assertEqualString("vimrc", archive_entry_pathname(ae));
451 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
453 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
454 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
455 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
458 DEFINE_TEST(test_read_format_zip_ppmd_multi_blockread)
460 const char *refname = "test_read_format_zip_ppmd8_multi.zipx";
462 struct archive_entry *ae;
464 extract_reference_file(refname);
466 assert((a = archive_read_new()) != NULL);
467 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
468 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
470 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
471 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
472 assertEqualString("smartd.conf", archive_entry_pathname(ae));
473 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E));
475 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
476 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
477 assertEqualString("ts.conf", archive_entry_pathname(ae));
478 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31));
480 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
481 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
482 assertEqualString("vimrc", archive_entry_pathname(ae));
483 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA));
485 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
486 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
487 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
490 DEFINE_TEST(test_read_format_zip_lzma_one_file)
492 const char *refname = "test_read_format_zip_lzma.zipx";
494 struct archive_entry *ae;
496 extract_reference_file(refname);
498 assert((a = archive_read_new()) != NULL);
499 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
500 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
501 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
502 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
503 assertEqualString("vimrc", archive_entry_pathname(ae));
504 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
505 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
506 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
507 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
510 DEFINE_TEST(test_read_format_zip_lzma_one_file_blockread)
512 const char *refname = "test_read_format_zip_lzma.zipx";
514 struct archive_entry *ae;
516 extract_reference_file(refname);
518 assert((a = archive_read_new()) != NULL);
519 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
520 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
521 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
522 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
523 assertEqualString("vimrc", archive_entry_pathname(ae));
524 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
525 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
526 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
527 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
530 DEFINE_TEST(test_read_format_zip_lzma_multi)
532 const char *refname = "test_read_format_zip_lzma_multi.zipx";
534 struct archive_entry *ae;
536 extract_reference_file(refname);
538 assert((a = archive_read_new()) != NULL);
539 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
540 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
542 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
543 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
544 assertEqualString("smartd.conf", archive_entry_pathname(ae));
545 assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E));
547 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
548 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
549 assertEqualString("ts.conf", archive_entry_pathname(ae));
550 assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31));
552 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
553 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
554 assertEqualString("vimrc", archive_entry_pathname(ae));
555 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
557 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
558 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
559 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
562 DEFINE_TEST(test_read_format_zip_lzma_multi_blockread)
564 const char *refname = "test_read_format_zip_lzma_multi.zipx";
566 struct archive_entry *ae;
568 extract_reference_file(refname);
570 assert((a = archive_read_new()) != NULL);
571 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
572 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
574 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
575 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
576 assertEqualString("smartd.conf", archive_entry_pathname(ae));
577 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E));
579 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
580 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
581 assertEqualString("ts.conf", archive_entry_pathname(ae));
582 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31));
584 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
585 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
586 assertEqualString("vimrc", archive_entry_pathname(ae));
587 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA));
589 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
590 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
591 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
595 DEFINE_TEST(test_read_format_zip_bzip2_one_file)
597 const char *refname = "test_read_format_zip_bzip2.zipx";
599 struct archive_entry *ae;
601 extract_reference_file(refname);
603 assert((a = archive_read_new()) != NULL);
604 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
605 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
606 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
607 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
608 assertEqualString("vimrc", archive_entry_pathname(ae));
609 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
610 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
611 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
612 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
615 DEFINE_TEST(test_read_format_zip_bzip2_one_file_blockread)
617 const char *refname = "test_read_format_zip_bzip2.zipx";
619 struct archive_entry *ae;
621 extract_reference_file(refname);
623 assert((a = archive_read_new()) != NULL);
624 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
625 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
626 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
627 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
628 assertEqualString("vimrc", archive_entry_pathname(ae));
629 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
630 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
631 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
632 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
635 DEFINE_TEST(test_read_format_zip_bzip2_multi)
637 const char *refname = "test_read_format_zip_bzip2_multi.zipx";
639 struct archive_entry *ae;
641 extract_reference_file(refname);
643 assert((a = archive_read_new()) != NULL);
644 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
645 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
647 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
648 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
649 assertEqualString("smartd.conf", archive_entry_pathname(ae));
650 assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E));
652 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
653 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
654 assertEqualString("ts.conf", archive_entry_pathname(ae));
655 assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31));
657 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
658 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
659 assertEqualString("vimrc", archive_entry_pathname(ae));
660 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
662 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
663 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
664 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
667 DEFINE_TEST(test_read_format_zip_bzip2_multi_blockread)
669 const char *refname = "test_read_format_zip_bzip2_multi.zipx";
671 struct archive_entry *ae;
673 extract_reference_file(refname);
675 assert((a = archive_read_new()) != NULL);
676 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
677 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
679 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
680 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
681 assertEqualString("smartd.conf", archive_entry_pathname(ae));
682 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E));
684 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
685 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
686 assertEqualString("ts.conf", archive_entry_pathname(ae));
687 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31));
689 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
690 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
691 assertEqualString("vimrc", archive_entry_pathname(ae));
692 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA));
694 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
695 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
696 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
699 DEFINE_TEST(test_read_format_zip_xz_multi)
701 const char *refname = "test_read_format_zip_xz_multi.zipx";
703 struct archive_entry *ae;
705 extract_reference_file(refname);
707 assert((a = archive_read_new()) != NULL);
708 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
709 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
711 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
712 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
713 assertEqualString("bash.bashrc", archive_entry_pathname(ae));
714 assertEqualIntA(a, 0, extract_one(a, ae, 0xF751B8C9));
716 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
717 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
718 assertEqualString("pacman.conf", archive_entry_pathname(ae));
719 assertEqualIntA(a, 0, extract_one(a, ae, 0xB20B7F88));
721 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
722 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
723 assertEqualString("profile", archive_entry_pathname(ae));
724 assertEqualIntA(a, 0, extract_one(a, ae, 0x2329F054));
726 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
727 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
728 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
731 DEFINE_TEST(test_read_format_zip_xz_multi_blockread)
733 const char *refname = "test_read_format_zip_xz_multi.zipx";
735 struct archive_entry *ae;
737 extract_reference_file(refname);
739 assert((a = archive_read_new()) != NULL);
740 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
741 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
743 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
744 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
745 assertEqualString("bash.bashrc", archive_entry_pathname(ae));
746 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0xF751B8C9));
748 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
749 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
750 assertEqualString("pacman.conf", archive_entry_pathname(ae));
751 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xB20B7F88));
753 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
754 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
755 assertEqualString("profile", archive_entry_pathname(ae));
756 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0x2329F054));
758 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
759 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
760 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
763 DEFINE_TEST(test_read_format_zip_ppmd8_crash_1)
765 const char *refname = "test_read_format_zip_ppmd8_crash_2.zipx";
767 struct archive_entry *ae;
770 extract_reference_file(refname);
772 assert((a = archive_read_new()) != NULL);
773 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
774 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 100));
775 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
777 /* This file shouldn't be properly decompressed, because it's invalid.
778 * However, unpacker should return an error during unpacking. Without the
779 * proper fix, the unpacker was entering an unlimited loop. */
780 assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buf, 1));
781 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
782 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
785 DEFINE_TEST(test_read_format_zip_bz2_hang_on_invalid)
787 const char *refname = "test_read_format_zip_bz2_hang.zip";
789 struct archive_entry *ae;
792 extract_reference_file(refname);
794 assert((a = archive_read_new()) != NULL);
795 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
796 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
797 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
799 /* The file `refname` is invalid in this case, so this call should fail.
800 * But it shouldn't crash. */
801 assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buf, 64));
802 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
803 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
806 DEFINE_TEST(test_read_format_zip_ppmd8_crash_2)
808 const char *refname = "test_read_format_zip_ppmd8_crash_2.zipx";
810 struct archive_entry *ae;
813 extract_reference_file(refname);
815 assert((a = archive_read_new()) != NULL);
816 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
817 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
818 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
820 /* The file `refname` is invalid in this case, so this call should fail.
821 * But it shouldn't crash. */
822 assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buf, 64));
823 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
824 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));