1 /*-
2 * Copyright (c) 2003-2007 Tim Kientzle
3 * Copyright (c) 2011 Michihiro NAKAJIMA
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
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.
14 *
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.
25 */
26 #include "test.h"
27
28 #define __LIBARCHIVE_BUILD
29
30 static
extract_one(struct archive * a,struct archive_entry * ae,uint32_t crc)31 int extract_one(struct archive* a, struct archive_entry* ae, uint32_t crc)
32 {
33 la_ssize_t fsize, bytes_read;
34 uint8_t* buf;
35 int ret = 1;
36 uint32_t computed_crc;
37
38 fsize = (la_ssize_t) archive_entry_size(ae);
39 buf = malloc(fsize);
40 if(buf == NULL)
41 return 1;
42
43 bytes_read = archive_read_data(a, buf, fsize);
44 if(bytes_read != fsize) {
45 assertEqualInt(bytes_read, fsize);
46 goto fn_exit;
47 }
48
49 computed_crc = bitcrc32(0, buf, fsize);
50 assertEqualInt(computed_crc, crc);
51 ret = 0;
52
53 fn_exit:
54 free(buf);
55 return ret;
56 }
57
58 static
extract_one_using_blocks(struct archive * a,int block_size,uint32_t crc)59 int extract_one_using_blocks(struct archive* a, int block_size, uint32_t crc)
60 {
61 uint8_t* buf;
62 int ret = 1;
63 uint32_t computed_crc = 0;
64 la_ssize_t bytes_read;
65
66 buf = malloc(block_size);
67 if(buf == NULL)
68 return 1;
69
70 while(1) {
71 bytes_read = archive_read_data(a, buf, block_size);
72 if(bytes_read == ARCHIVE_RETRY)
73 continue;
74 else if(bytes_read == 0)
75 break;
76 else if(bytes_read < 0) {
77 /* If we're here, it means the decompressor has failed
78 * to properly decode test file. */
79 assertA(0);
80 ret = 1;
81 goto fn_exit;
82 } else {
83 /* ok */
84 }
85
86 computed_crc = bitcrc32(computed_crc, buf, bytes_read);
87 }
88
89 assertEqualInt(computed_crc, crc);
90 ret = 0;
91
92 fn_exit:
93 free(buf);
94 return ret;
95 }
96
97 /*
98 * The reference file for this has been manually tweaked so that:
99 * * file2 has length-at-end but file1 does not
100 * * file2 has an invalid CRC
101 */
102 static void
verify_basic(struct archive * a,int seek_checks)103 verify_basic(struct archive *a, int seek_checks)
104 {
105 struct archive_entry *ae;
106 char *buff[128];
107 const void *pv;
108 size_t s;
109 int64_t o;
110
111 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
112 assertEqualString("ZIP 1.0 (uncompressed)", archive_format_name(a));
113 assertEqualString("dir/", archive_entry_pathname(ae));
114 assertEqualInt(1179604249, archive_entry_mtime(ae));
115 assertEqualInt(0, archive_entry_size(ae));
116 if (seek_checks)
117 assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae));
118 assertEqualInt(archive_entry_is_encrypted(ae), 0);
119 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
120 assertEqualIntA(a, ARCHIVE_EOF,
121 archive_read_data_block(a, &pv, &s, &o));
122 assertEqualInt((int)s, 0);
123
124 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
125 assertEqualString("ZIP 2.0 (deflation)", archive_format_name(a));
126 assertEqualString("file1", archive_entry_pathname(ae));
127 assertEqualInt(1179604289, archive_entry_mtime(ae));
128 if (seek_checks)
129 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
130 assertEqualInt(18, archive_entry_size(ae));
131 assertEqualInt(archive_entry_is_encrypted(ae), 0);
132 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
133 failure("archive_read_data() returns number of bytes read");
134 if (archive_zlib_version() != NULL) {
135 assertEqualInt(18, archive_read_data(a, buff, 19));
136 assertEqualMem(buff, "hello\nhello\nhello\n", 18);
137 } else {
138 assertEqualInt(ARCHIVE_FAILED, archive_read_data(a, buff, 19));
139 assertEqualString(archive_error_string(a),
140 "Unsupported ZIP compression method (8: deflation)");
141 assert(archive_errno(a) != 0);
142 }
143
144 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
145 assertEqualString("ZIP 2.0 (deflation)", archive_format_name(a));
146 assertEqualString("file2", archive_entry_pathname(ae));
147 assertEqualInt(1179605932, archive_entry_mtime(ae));
148 assertEqualInt(archive_entry_is_encrypted(ae), 0);
149 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
150 if (seek_checks) {
151 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
152 }
153 assert(archive_entry_size_is_set(ae));
154 assertEqualInt(18, archive_entry_size(ae));
155 if (archive_zlib_version() != NULL) {
156 failure("file2 has a bad CRC, so read should fail and not change buff");
157 memset(buff, 'a', 19);
158 assertEqualInt(ARCHIVE_FAILED, archive_read_data(a, buff, 19));
159 assertEqualMem(buff, "aaaaaaaaaaaaaaaaaaa", 19);
160 } else {
161 assertEqualInt(ARCHIVE_FAILED, archive_read_data(a, buff, 19));
162 assertEqualString(archive_error_string(a),
163 "Unsupported ZIP compression method (8: deflation)");
164 assert(archive_errno(a) != 0);
165 }
166 assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &ae));
167 assertEqualString("ZIP 2.0 (deflation)", archive_format_name(a));
168 /* Verify the number of files read. */
169 failure("the archive file has three files");
170 assertEqualInt(3, archive_file_count(a));
171 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
172 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
173 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
174 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
175 }
176
177 static void
test_basic(void)178 test_basic(void)
179 {
180 const char *refname = "test_read_format_zip.zip";
181 struct archive *a;
182 char *p;
183 size_t s;
184
185 extract_reference_file(refname);
186
187 /* Verify with seeking reader. */
188 assert((a = archive_read_new()) != NULL);
189 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
190 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
191 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 10240));
192 verify_basic(a, 1);
193
194 /* Verify with streaming reader. */
195 p = slurpfile(&s, "%s", refname);
196 assert((a = archive_read_new()) != NULL);
197 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
198 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
199 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, p, s, 31));
200 verify_basic(a, 0);
201 free(p);
202 }
203
204 /*
205 * Read Info-ZIP New Unix Extra Field 0x7875 "ux".
206 * Currently stores Unix UID/GID up to 32 bits.
207 */
208 static void
verify_info_zip_ux(struct archive * a,int seek_checks)209 verify_info_zip_ux(struct archive *a, int seek_checks)
210 {
211 struct archive_entry *ae;
212 char *buff[128];
213
214 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
215 assertEqualString("file1", archive_entry_pathname(ae));
216 assertEqualInt(1300668680, archive_entry_mtime(ae));
217 assertEqualInt(18, archive_entry_size(ae));
218 assertEqualInt(archive_entry_is_encrypted(ae), 0);
219 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
220 if (seek_checks)
221 assertEqualInt(AE_IFREG | 0644, archive_entry_mode(ae));
222 failure("zip reader should read Info-ZIP New Unix Extra Field");
223 assertEqualInt(1001, archive_entry_uid(ae));
224 assertEqualInt(1001, archive_entry_gid(ae));
225 if (archive_zlib_version() != NULL) {
226 failure("archive_read_data() returns number of bytes read");
227 assertEqualInt(18, archive_read_data(a, buff, 19));
228 assertEqualMem(buff, "hello\nhello\nhello\n", 18);
229 } else {
230 assertEqualInt(ARCHIVE_FAILED, archive_read_data(a, buff, 19));
231 assertEqualString(archive_error_string(a),
232 "Unsupported ZIP compression method (8: deflation)");
233 assert(archive_errno(a) != 0);
234 }
235 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
236
237 /* Verify the number of files read. */
238 failure("the archive file has just one file");
239 assertEqualInt(1, archive_file_count(a));
240
241 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
242 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
243 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
244 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
245 }
246
247 static void
test_info_zip_ux(void)248 test_info_zip_ux(void)
249 {
250 const char *refname = "test_read_format_zip_ux.zip";
251 struct archive *a;
252 char *p;
253 size_t s;
254
255 extract_reference_file(refname);
256
257 /* Verify with seeking reader. */
258 assert((a = archive_read_new()) != NULL);
259 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
260 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
261 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 10240));
262 verify_info_zip_ux(a, 1);
263
264 /* Verify with streaming reader. */
265 p = slurpfile(&s, "%s", refname);
266 assert((a = archive_read_new()) != NULL);
267 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
268 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
269 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, p, s, 108));
270 verify_info_zip_ux(a, 0);
271 free(p);
272 }
273
274 /*
275 * Verify that test_read_extract correctly works with
276 * Zip entries that use length-at-end.
277 */
278 static void
verify_extract_length_at_end(struct archive * a,int seek_checks)279 verify_extract_length_at_end(struct archive *a, int seek_checks)
280 {
281 struct archive_entry *ae;
282
283 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
284
285 assertEqualInt(archive_entry_is_encrypted(ae), 0);
286 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
287 assertEqualString("hello.txt", archive_entry_pathname(ae));
288 if (seek_checks) {
289 assertEqualInt(AE_IFREG | 0644, archive_entry_mode(ae));
290 assert(archive_entry_size_is_set(ae));
291 assertEqualInt(6, archive_entry_size(ae));
292 } else {
293 assert(!archive_entry_size_is_set(ae));
294 assertEqualInt(0, archive_entry_size(ae));
295 }
296
297 if (archive_zlib_version() != NULL) {
298 assertEqualIntA(a, ARCHIVE_OK, archive_read_extract(a, ae, 0));
299 assertFileContents("hello\x0A", 6, "hello.txt");
300 } else {
301 assertEqualIntA(a, ARCHIVE_FAILED, archive_read_extract(a, ae, 0));
302 assertEqualString(archive_error_string(a),
303 "Unsupported ZIP compression method (8: deflation)");
304 assert(archive_errno(a) != 0);
305 }
306
307 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
308 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
309 }
310
311 static void
test_extract_length_at_end(void)312 test_extract_length_at_end(void)
313 {
314 const char *refname = "test_read_format_zip_length_at_end.zip";
315 char *p;
316 size_t s;
317 struct archive *a;
318
319 extract_reference_file(refname);
320
321 /* Verify extraction with seeking reader. */
322 assert((a = archive_read_new()) != NULL);
323 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
324 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
325 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 10240));
326 verify_extract_length_at_end(a, 1);
327
328 /* Verify extraction with streaming reader. */
329 p = slurpfile(&s, "%s", refname);
330 assert((a = archive_read_new()) != NULL);
331 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
332 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
333 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, p, s, 108));
334 verify_extract_length_at_end(a, 0);
335 free(p);
336 }
337
338 static void
test_symlink(void)339 test_symlink(void)
340 {
341 const char *refname = "test_read_format_zip_symlink.zip";
342 char *p;
343 size_t s;
344 struct archive *a;
345 struct archive_entry *ae;
346
347 extract_reference_file(refname);
348 p = slurpfile(&s, "%s", refname);
349
350 /* Symlinks can only be extracted with the seeking reader. */
351 assert((a = archive_read_new()) != NULL);
352 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
353 assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, p, s, 1));
354
355 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
356 assertEqualString("file", archive_entry_pathname(ae));
357 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
358 assertEqualInt(archive_entry_is_encrypted(ae), 0);
359 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
360
361 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
362 assertEqualString("symlink", archive_entry_pathname(ae));
363 assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
364 assertEqualInt(0, archive_entry_size(ae));
365 assertEqualString("file", archive_entry_symlink(ae));
366 assertEqualInt(archive_entry_is_encrypted(ae), 0);
367 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
368
369 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
370 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
371 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
372
373 free(p);
374 }
375
DEFINE_TEST(test_read_format_zip)376 DEFINE_TEST(test_read_format_zip)
377 {
378 test_basic();
379 test_info_zip_ux();
380 test_extract_length_at_end();
381 test_symlink();
382 }
383
DEFINE_TEST(test_read_format_zip_ppmd_one_file)384 DEFINE_TEST(test_read_format_zip_ppmd_one_file)
385 {
386 const char *refname = "test_read_format_zip_ppmd8.zipx";
387 struct archive *a;
388 struct archive_entry *ae;
389
390 extract_reference_file(refname);
391
392 assert((a = archive_read_new()) != NULL);
393 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
394 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
395 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
396 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
397 assertEqualString("vimrc", archive_entry_pathname(ae));
398 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
399 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
400 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
401 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
402 }
403
DEFINE_TEST(test_read_format_zip_ppmd_one_file_blockread)404 DEFINE_TEST(test_read_format_zip_ppmd_one_file_blockread)
405 {
406 const char *refname = "test_read_format_zip_ppmd8.zipx";
407 struct archive *a;
408 struct archive_entry *ae;
409
410 extract_reference_file(refname);
411
412 assert((a = archive_read_new()) != NULL);
413 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
414 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
415 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
416 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
417 assertEqualString("vimrc", archive_entry_pathname(ae));
418 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
419 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
420 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
421 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
422 }
423
DEFINE_TEST(test_read_format_zip_ppmd_multi)424 DEFINE_TEST(test_read_format_zip_ppmd_multi)
425 {
426 const char *refname = "test_read_format_zip_ppmd8_multi.zipx";
427 struct archive *a;
428 struct archive_entry *ae;
429
430 extract_reference_file(refname);
431
432 assert((a = archive_read_new()) != NULL);
433 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
434 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
435
436 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
437 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
438 assertEqualString("smartd.conf", archive_entry_pathname(ae));
439 assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E));
440
441 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
442 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
443 assertEqualString("ts.conf", archive_entry_pathname(ae));
444 assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31));
445
446 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
447 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
448 assertEqualString("vimrc", archive_entry_pathname(ae));
449 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
450
451 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
452 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
453 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
454 }
455
DEFINE_TEST(test_read_format_zip_ppmd_multi_blockread)456 DEFINE_TEST(test_read_format_zip_ppmd_multi_blockread)
457 {
458 const char *refname = "test_read_format_zip_ppmd8_multi.zipx";
459 struct archive *a;
460 struct archive_entry *ae;
461
462 extract_reference_file(refname);
463
464 assert((a = archive_read_new()) != NULL);
465 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
466 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
467
468 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
469 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
470 assertEqualString("smartd.conf", archive_entry_pathname(ae));
471 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E));
472
473 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
474 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
475 assertEqualString("ts.conf", archive_entry_pathname(ae));
476 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31));
477
478 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
479 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
480 assertEqualString("vimrc", archive_entry_pathname(ae));
481 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA));
482
483 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
484 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
485 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
486 }
487
DEFINE_TEST(test_read_format_zip_lzma_one_file)488 DEFINE_TEST(test_read_format_zip_lzma_one_file)
489 {
490 const char *refname = "test_read_format_zip_lzma.zipx";
491 struct archive *a;
492 struct archive_entry *ae;
493
494 assert((a = archive_read_new()) != NULL);
495 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
496 skipping("lzma reading not fully supported on this platform");
497 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
498 return;
499 }
500 extract_reference_file(refname);
501
502 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
503 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
504 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
505 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
506 assertEqualString("vimrc", archive_entry_pathname(ae));
507 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
508 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
509 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
510 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
511 }
512
DEFINE_TEST(test_read_format_zip_lzma_one_file_blockread)513 DEFINE_TEST(test_read_format_zip_lzma_one_file_blockread)
514 {
515 const char *refname = "test_read_format_zip_lzma.zipx";
516 struct archive *a;
517 struct archive_entry *ae;
518
519 assert((a = archive_read_new()) != NULL);
520 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
521 skipping("lzma reading not fully supported on this platform");
522 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
523 return;
524 }
525 extract_reference_file(refname);
526
527 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
528 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
529 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
530 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
531 assertEqualString("vimrc", archive_entry_pathname(ae));
532 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
533 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
534 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
535 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
536 }
537
DEFINE_TEST(test_read_format_zip_lzma_multi)538 DEFINE_TEST(test_read_format_zip_lzma_multi)
539 {
540 const char *refname = "test_read_format_zip_lzma_multi.zipx";
541 struct archive *a;
542 struct archive_entry *ae;
543
544 assert((a = archive_read_new()) != NULL);
545 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
546 skipping("lzma reading not fully supported on this platform");
547 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
548 return;
549 }
550 extract_reference_file(refname);
551
552 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
553 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
554
555 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
556 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
557 assertEqualString("smartd.conf", archive_entry_pathname(ae));
558 assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E));
559
560 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
561 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
562 assertEqualString("ts.conf", archive_entry_pathname(ae));
563 assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31));
564
565 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
566 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
567 assertEqualString("vimrc", archive_entry_pathname(ae));
568 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
569
570 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
571 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
572 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
573 }
574
DEFINE_TEST(test_read_format_zip_lzma_multi_blockread)575 DEFINE_TEST(test_read_format_zip_lzma_multi_blockread)
576 {
577 const char *refname = "test_read_format_zip_lzma_multi.zipx";
578 struct archive *a;
579 struct archive_entry *ae;
580
581 assert((a = archive_read_new()) != NULL);
582 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
583 skipping("lzma reading not fully supported on this platform");
584 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
585 return;
586 }
587 extract_reference_file(refname);
588
589 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
590 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
591
592 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
593 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
594 assertEqualString("smartd.conf", archive_entry_pathname(ae));
595 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E));
596
597 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
598 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
599 assertEqualString("ts.conf", archive_entry_pathname(ae));
600 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31));
601
602 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
603 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
604 assertEqualString("vimrc", archive_entry_pathname(ae));
605 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA));
606
607 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
608 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
609 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
610 }
611
612
DEFINE_TEST(test_read_format_zip_bzip2_one_file)613 DEFINE_TEST(test_read_format_zip_bzip2_one_file)
614 {
615 const char *refname = "test_read_format_zip_bzip2.zipx";
616 struct archive *a;
617 struct archive_entry *ae;
618
619 assert((a = archive_read_new()) != NULL);
620 if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) {
621 skipping("bzip2 is not fully supported on this platform");
622 archive_read_close(a);
623 return;
624 }
625 extract_reference_file(refname);
626
627 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
628 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
629 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
630 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
631 assertEqualString("vimrc", archive_entry_pathname(ae));
632 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
633 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
634 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
635 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
636 }
637
DEFINE_TEST(test_read_format_zip_bzip2_one_file_blockread)638 DEFINE_TEST(test_read_format_zip_bzip2_one_file_blockread)
639 {
640 const char *refname = "test_read_format_zip_bzip2.zipx";
641 struct archive *a;
642 struct archive_entry *ae;
643
644 assert((a = archive_read_new()) != NULL);
645 if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) {
646 skipping("bzip2 is not fully supported on this platform");
647 archive_read_close(a);
648 return;
649 }
650 extract_reference_file(refname);
651
652 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
653 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
654 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
655 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
656 assertEqualString("vimrc", archive_entry_pathname(ae));
657 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
658 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
659 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
660 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
661 }
662
DEFINE_TEST(test_read_format_zip_bzip2_multi)663 DEFINE_TEST(test_read_format_zip_bzip2_multi)
664 {
665 const char *refname = "test_read_format_zip_bzip2_multi.zipx";
666 struct archive *a;
667 struct archive_entry *ae;
668
669 assert((a = archive_read_new()) != NULL);
670 if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) {
671 skipping("bzip2 is not fully supported on this platform");
672 archive_read_close(a);
673 return;
674 }
675 extract_reference_file(refname);
676
677 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
678 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
679
680 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
681 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
682 assertEqualString("smartd.conf", archive_entry_pathname(ae));
683 assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E));
684
685 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
686 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
687 assertEqualString("ts.conf", archive_entry_pathname(ae));
688 assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31));
689
690 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
691 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
692 assertEqualString("vimrc", archive_entry_pathname(ae));
693 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
694
695 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
696 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
697 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
698 }
699
DEFINE_TEST(test_read_format_zip_bzip2_multi_blockread)700 DEFINE_TEST(test_read_format_zip_bzip2_multi_blockread)
701 {
702 const char *refname = "test_read_format_zip_bzip2_multi.zipx";
703 struct archive *a;
704 struct archive_entry *ae;
705
706 assert((a = archive_read_new()) != NULL);
707 if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) {
708 skipping("bzip2 is not fully supported on this platform");
709 archive_read_close(a);
710 return;
711 }
712 extract_reference_file(refname);
713
714 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
715 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
716
717 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
718 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
719 assertEqualString("smartd.conf", archive_entry_pathname(ae));
720 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E));
721
722 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
723 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
724 assertEqualString("ts.conf", archive_entry_pathname(ae));
725 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31));
726
727 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
728 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
729 assertEqualString("vimrc", archive_entry_pathname(ae));
730 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA));
731
732 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
733 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
734 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
735 }
736
DEFINE_TEST(test_read_format_zip_zstd_one_file)737 DEFINE_TEST(test_read_format_zip_zstd_one_file)
738 {
739 const char *refname = "test_read_format_zip_zstd.zipx";
740 struct archive *a;
741 struct archive_entry *ae;
742
743 assert((a = archive_read_new()) != NULL);
744 if (ARCHIVE_OK != archive_read_support_filter_zstd(a)) {
745 skipping("zstd is not fully supported on this platform");
746 archive_read_close(a);
747 archive_read_free(a);
748 return;
749 }
750 extract_reference_file(refname);
751
752 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
753 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
754 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
755 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
756 assertEqualString("vimrc", archive_entry_pathname(ae));
757 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
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));
761 }
762
DEFINE_TEST(test_read_format_zip_zstd_one_file_blockread)763 DEFINE_TEST(test_read_format_zip_zstd_one_file_blockread)
764 {
765 const char *refname = "test_read_format_zip_zstd.zipx";
766 struct archive *a;
767 struct archive_entry *ae;
768
769 assert((a = archive_read_new()) != NULL);
770 if (ARCHIVE_OK != archive_read_support_filter_zstd(a)) {
771 skipping("zstd is not fully supported on this platform");
772 archive_read_close(a);
773 archive_read_free(a);
774 return;
775 }
776 extract_reference_file(refname);
777
778 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
779 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
780 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
781 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
782 assertEqualString("vimrc", archive_entry_pathname(ae));
783 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
784 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
785 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
786 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
787 }
788
DEFINE_TEST(test_read_format_zip_zstd_multi)789 DEFINE_TEST(test_read_format_zip_zstd_multi)
790 {
791 const char *refname = "test_read_format_zip_zstd_multi.zipx";
792 struct archive *a;
793 struct archive_entry *ae;
794
795 assert((a = archive_read_new()) != NULL);
796 if (ARCHIVE_OK != archive_read_support_filter_zstd(a)) {
797 skipping("zstd is not fully supported on this platform");
798 archive_read_close(a);
799 archive_read_free(a);
800 return;
801 }
802 extract_reference_file(refname);
803
804 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
805 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
806
807 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
808 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
809 assertEqualString("smartd.conf", archive_entry_pathname(ae));
810 assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E));
811
812 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
813 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
814 assertEqualString("ts.conf", archive_entry_pathname(ae));
815 assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31));
816
817 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
818 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
819 assertEqualString("vimrc", archive_entry_pathname(ae));
820 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
821
822 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
823 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
824 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
825 }
826
DEFINE_TEST(test_read_format_zip_zstd_multi_blockread)827 DEFINE_TEST(test_read_format_zip_zstd_multi_blockread)
828 {
829 const char *refname = "test_read_format_zip_zstd_multi.zipx";
830 struct archive *a;
831 struct archive_entry *ae;
832
833 assert((a = archive_read_new()) != NULL);
834 if (ARCHIVE_OK != archive_read_support_filter_zstd(a)) {
835 skipping("zstd is not fully supported on this platform");
836 archive_read_close(a);
837 archive_read_free(a);
838 return;
839 }
840 extract_reference_file(refname);
841
842 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
843 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
844
845 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
846 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
847 assertEqualString("smartd.conf", archive_entry_pathname(ae));
848 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E));
849
850 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
851 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
852 assertEqualString("ts.conf", archive_entry_pathname(ae));
853 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31));
854
855 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
856 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
857 assertEqualString("vimrc", archive_entry_pathname(ae));
858 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA));
859
860 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
861 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
862 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
863 }
864
DEFINE_TEST(test_read_format_zip_xz_multi)865 DEFINE_TEST(test_read_format_zip_xz_multi)
866 {
867 const char *refname = "test_read_format_zip_xz_multi.zipx";
868 struct archive *a;
869 struct archive_entry *ae;
870
871 assert((a = archive_read_new()) != NULL);
872 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
873 skipping("lzma reading not fully supported on this platform");
874 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
875 return;
876 }
877 extract_reference_file(refname);
878
879 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
880 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
881
882 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
883 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
884 assertEqualString("bash.bashrc", archive_entry_pathname(ae));
885 assertEqualIntA(a, 0, extract_one(a, ae, 0xF751B8C9));
886
887 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
888 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
889 assertEqualString("pacman.conf", archive_entry_pathname(ae));
890 assertEqualIntA(a, 0, extract_one(a, ae, 0xB20B7F88));
891
892 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
893 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
894 assertEqualString("profile", archive_entry_pathname(ae));
895 assertEqualIntA(a, 0, extract_one(a, ae, 0x2329F054));
896
897 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
898 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
899 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
900 }
901
DEFINE_TEST(test_read_format_zip_xz_multi_blockread)902 DEFINE_TEST(test_read_format_zip_xz_multi_blockread)
903 {
904 const char *refname = "test_read_format_zip_xz_multi.zipx";
905 struct archive *a;
906 struct archive_entry *ae;
907
908 assert((a = archive_read_new()) != NULL);
909 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
910 skipping("lzma reading not fully supported on this platform");
911 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
912 return;
913 }
914 extract_reference_file(refname);
915
916 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
917 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
918
919 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
920 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
921 assertEqualString("bash.bashrc", archive_entry_pathname(ae));
922 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0xF751B8C9));
923
924 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
925 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
926 assertEqualString("pacman.conf", archive_entry_pathname(ae));
927 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xB20B7F88));
928
929 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
930 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
931 assertEqualString("profile", archive_entry_pathname(ae));
932 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0x2329F054));
933
934 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
935 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
936 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
937 }
938
DEFINE_TEST(test_read_format_zip_ppmd8_crash_1)939 DEFINE_TEST(test_read_format_zip_ppmd8_crash_1)
940 {
941 const char *refname = "test_read_format_zip_ppmd8_crash_2.zipx";
942 struct archive *a;
943 struct archive_entry *ae;
944 char buf[64];
945
946 extract_reference_file(refname);
947
948 assert((a = archive_read_new()) != NULL);
949 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
950 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 100));
951 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
952
953 /* This file shouldn't be properly decompressed, because it's invalid.
954 * However, unpacker should return an error during unpacking. Without the
955 * proper fix, the unpacker was entering an unlimited loop. */
956 assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buf, 1));
957 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
958 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
959 }
960
DEFINE_TEST(test_read_format_zip_bz2_hang_on_invalid)961 DEFINE_TEST(test_read_format_zip_bz2_hang_on_invalid)
962 {
963 const char *refname = "test_read_format_zip_bz2_hang.zip";
964 struct archive *a;
965 struct archive_entry *ae;
966 char buf[8];
967
968 assert((a = archive_read_new()) != NULL);
969 if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) {
970 skipping("bzip2 is not fully supported on this platform");
971 archive_read_close(a);
972 return;
973 }
974 extract_reference_file(refname);
975
976 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
977 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
978 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
979
980 /* The file `refname` is invalid in this case, so this call should fail.
981 * But it shouldn't crash. */
982 assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buf, 64));
983 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
984 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
985 }
986
DEFINE_TEST(test_read_format_zip_ppmd8_crash_2)987 DEFINE_TEST(test_read_format_zip_ppmd8_crash_2)
988 {
989 const char *refname = "test_read_format_zip_ppmd8_crash_2.zipx";
990 struct archive *a;
991 struct archive_entry *ae;
992 char buf[64];
993
994 extract_reference_file(refname);
995
996 assert((a = archive_read_new()) != NULL);
997 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
998 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
999 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1000
1001 /* The file `refname` is invalid in this case, so this call should fail.
1002 * But it shouldn't crash. */
1003 assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buf, 64));
1004 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1005 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
1006 }
1007
DEFINE_TEST(test_read_format_zip_lzma_alone_leak)1008 DEFINE_TEST(test_read_format_zip_lzma_alone_leak)
1009 {
1010 const char *refname = "test_read_format_zip_lzma_alone_leak.zipx";
1011 struct archive *a;
1012 struct archive_entry *ae;
1013 char buf[64];
1014
1015 /* OSSFuzz #14470 sample file. */
1016 extract_reference_file(refname);
1017
1018 assert((a = archive_read_new()) != NULL);
1019 if(ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
1020 skipping("lzma reading is not fully supported on this platform");
1021 archive_read_close(a);
1022 archive_read_free(a);
1023 return;
1024 }
1025
1026 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
1027 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
1028 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1029
1030 /* Extraction of this file should fail, because the sample file is invalid.
1031 * But it shouldn't crash. */
1032 assertEqualIntA(a, ARCHIVE_FAILED, archive_read_data(a, buf, sizeof(buf)));
1033 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1034
1035 /* Extraction of this file should fail, because the sample file is invalid.
1036 * But it shouldn't crash. */
1037 assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buf, sizeof(buf)));
1038
1039 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1040 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
1041
1042 /* This testcase shouldn't produce any memory leaks. When running test
1043 * suite under Valgrind or ASan, the test runner won't return with
1044 * exit code 0 in case if a memory leak. */
1045 }
1046
DEFINE_TEST(test_read_format_zip_lzma_stream_end)1047 DEFINE_TEST(test_read_format_zip_lzma_stream_end)
1048 {
1049 const char *refname = "test_read_format_zip_lzma_stream_end.zipx";
1050 struct archive *a;
1051 struct archive_entry *ae;
1052
1053 assert((a = archive_read_new()) != NULL);
1054 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
1055 skipping("lzma reading not fully supported on this platform");
1056 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1057 return;
1058 }
1059 extract_reference_file(refname);
1060
1061 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
1062 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
1063 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1064 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
1065 assertEqualString("vimrc", archive_entry_pathname(ae));
1066 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
1067 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
1068 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1069 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
1070 }
1071
DEFINE_TEST(test_read_format_zip_lzma_stream_end_blockread)1072 DEFINE_TEST(test_read_format_zip_lzma_stream_end_blockread)
1073 {
1074 const char *refname = "test_read_format_zip_lzma_stream_end.zipx";
1075 struct archive *a;
1076 struct archive_entry *ae;
1077
1078 assert((a = archive_read_new()) != NULL);
1079 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
1080 skipping("lzma reading not fully supported on this platform");
1081 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1082 return;
1083 }
1084 extract_reference_file(refname);
1085
1086 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
1087 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
1088 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1089 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
1090 assertEqualString("vimrc", archive_entry_pathname(ae));
1091 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
1092 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
1093 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1094 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
1095 }
1096
DEFINE_TEST(test_read_format_zip_7z_lzma)1097 DEFINE_TEST(test_read_format_zip_7z_lzma)
1098 {
1099 const char *refname = "test_read_format_zip_7z_lzma.zip";
1100 struct archive_entry *ae;
1101 struct archive *a;
1102
1103 assert((a = archive_read_new()) != NULL);
1104 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
1105 skipping("lzma reading not fully supported on this platform");
1106 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1107 return;
1108 }
1109 extract_reference_file(refname);
1110
1111 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
1112 assertEqualIntA(a, ARCHIVE_OK,
1113 archive_read_open_filename(a, refname, 10240));
1114 //read directories
1115 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1116 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1117 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1118 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1119 //read symlink
1120 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1121 assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
1122 assertEqualString("../samples/abc_measurement_analysis_sample"
1123 "/src/abc_measurement_analysis_sample.py",
1124 archive_entry_symlink(ae));
1125 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1126 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
1127 }
1128
DEFINE_TEST(test_read_format_zip_7z_deflate)1129 DEFINE_TEST(test_read_format_zip_7z_deflate)
1130 {
1131 const char *refname = "test_read_format_zip_7z_deflate.zip";
1132 struct archive_entry *ae;
1133 struct archive *a;
1134 int r;
1135
1136 assert((a = archive_read_new()) != NULL);
1137 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1138 extract_reference_file(refname);
1139
1140 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
1141 assertEqualIntA(a, ARCHIVE_OK,
1142 archive_read_open_filename(a, refname, 10240));
1143 //read first symlink
1144 r = archive_read_next_header(a, &ae);
1145 if (archive_zlib_version() == NULL) {
1146 assertEqualInt(ARCHIVE_FAILED, r);
1147 assertEqualString(archive_error_string(a),
1148 "Unsupported ZIP compression method during decompression "
1149 "of link entry (8: deflation)");
1150 assert(archive_errno(a) != 0);
1151 } else {
1152 assertEqualIntA(a, ARCHIVE_OK, r);
1153 assertEqualString("libxkbcommon-x11.so.0.0.0",
1154 archive_entry_symlink(ae));
1155 }
1156 assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
1157 //read second symlink
1158 r = archive_read_next_header(a, &ae);
1159 if (archive_zlib_version() == NULL) {
1160 assertEqualInt(ARCHIVE_FAILED, r);
1161 assertEqualString(archive_error_string(a),
1162 "Unsupported ZIP compression method during decompression "
1163 "of link entry (8: deflation)");
1164 assert(archive_errno(a) != 0);
1165 } else {
1166 assertEqualIntA(a, ARCHIVE_OK, r);
1167 assertEqualString("libxkbcommon-x11.so.0.0.0",
1168 archive_entry_symlink(ae));
1169 }
1170 assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
1171 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1172 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
1173 }
1174