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 * Read PKWARE Unix Extra Field 0x000d.
276 */
277 static void
verify_pkware_unix(struct archive * a,int seek_checks)278 verify_pkware_unix(struct archive *a, int seek_checks)
279 {
280 struct archive_entry *ae;
281 char buff[8];
282
283 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
284 assertEqualString("file1", archive_entry_pathname(ae));
285 assertEqualInt(1300668680, archive_entry_mtime(ae));
286 assertEqualInt(1300668670, archive_entry_atime(ae));
287 assertEqualInt(6, archive_entry_size(ae));
288 assertEqualInt(archive_entry_is_encrypted(ae), 0);
289 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
290 if (seek_checks)
291 assertEqualInt(AE_IFREG | 0644, archive_entry_mode(ae));
292 failure("zip reader should read PKWARE Unix Extra Field");
293 assertEqualInt(1001, archive_entry_uid(ae));
294 assertEqualInt(1002, archive_entry_gid(ae));
295 assertEqualInt(6, archive_read_data(a, buff, sizeof(buff)));
296 assertEqualMem(buff, "hello\n", 6);
297 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
298
299 /* Verify the number of files read. */
300 failure("the archive file has just one file");
301 assertEqualInt(1, archive_file_count(a));
302
303 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
304 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
305 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
306 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
307 }
308
309 static void
test_pkware_unix(void)310 test_pkware_unix(void)
311 {
312 const char *refname = "test_read_format_zip_pkware_unix.zip";
313 struct archive *a;
314 char *p;
315 size_t s;
316
317 extract_reference_file(refname);
318
319 /* Verify with seeking reader. */
320 assert((a = archive_read_new()) != NULL);
321 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
322 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
323 assertEqualIntA(a, ARCHIVE_OK,
324 archive_read_open_filename(a, refname, 10240));
325 verify_pkware_unix(a, 1);
326
327 /* Verify with streaming reader. */
328 p = slurpfile(&s, "%s", refname);
329 assert((a = archive_read_new()) != NULL);
330 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
331 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
332 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, p, s, 31));
333 verify_pkware_unix(a, 0);
334 free(p);
335 }
336
337 /*
338 * Verify that test_read_extract correctly works with
339 * Zip entries that use length-at-end.
340 */
341 static void
verify_extract_length_at_end(struct archive * a,int seek_checks)342 verify_extract_length_at_end(struct archive *a, int seek_checks)
343 {
344 struct archive_entry *ae;
345
346 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
347
348 assertEqualInt(archive_entry_is_encrypted(ae), 0);
349 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
350 assertEqualString("hello.txt", archive_entry_pathname(ae));
351 if (seek_checks) {
352 assertEqualInt(AE_IFREG | 0644, archive_entry_mode(ae));
353 assert(archive_entry_size_is_set(ae));
354 assertEqualInt(6, archive_entry_size(ae));
355 } else {
356 assert(!archive_entry_size_is_set(ae));
357 assertEqualInt(0, archive_entry_size(ae));
358 }
359
360 if (archive_zlib_version() != NULL) {
361 assertEqualIntA(a, ARCHIVE_OK, archive_read_extract(a, ae, 0));
362 assertFileContents("hello\x0A", 6, "hello.txt");
363 } else {
364 assertEqualIntA(a, ARCHIVE_FAILED, archive_read_extract(a, ae, 0));
365 assertEqualString(archive_error_string(a),
366 "Unsupported ZIP compression method (8: deflation)");
367 assert(archive_errno(a) != 0);
368 }
369
370 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
371 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
372 }
373
374 static void
test_extract_length_at_end(void)375 test_extract_length_at_end(void)
376 {
377 const char *refname = "test_read_format_zip_length_at_end.zip";
378 char *p;
379 size_t s;
380 struct archive *a;
381
382 extract_reference_file(refname);
383
384 /* Verify extraction with seeking reader. */
385 assert((a = archive_read_new()) != NULL);
386 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
387 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
388 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 10240));
389 verify_extract_length_at_end(a, 1);
390
391 /* Verify extraction with streaming reader. */
392 p = slurpfile(&s, "%s", refname);
393 assert((a = archive_read_new()) != NULL);
394 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
395 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
396 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, p, s, 108));
397 verify_extract_length_at_end(a, 0);
398 free(p);
399 }
400
401 static void
test_symlink(void)402 test_symlink(void)
403 {
404 const char *refname = "test_read_format_zip_symlink.zip";
405 char *p;
406 size_t s;
407 struct archive *a;
408 struct archive_entry *ae;
409
410 extract_reference_file(refname);
411 p = slurpfile(&s, "%s", refname);
412
413 /* Symlinks can only be extracted with the seeking reader. */
414 assert((a = archive_read_new()) != NULL);
415 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
416 assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, p, s, 1));
417
418 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
419 assertEqualString("file", archive_entry_pathname(ae));
420 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
421 assertEqualInt(archive_entry_is_encrypted(ae), 0);
422 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
423
424 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
425 assertEqualString("symlink", archive_entry_pathname(ae));
426 assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
427 assertEqualInt(0, archive_entry_size(ae));
428 assertEqualString("file", archive_entry_symlink(ae));
429 assertEqualInt(archive_entry_is_encrypted(ae), 0);
430 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
431
432 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
433 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
434 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
435
436 free(p);
437 }
438
DEFINE_TEST(test_read_format_zip)439 DEFINE_TEST(test_read_format_zip)
440 {
441 test_basic();
442 test_info_zip_ux();
443 test_pkware_unix();
444 test_extract_length_at_end();
445 test_symlink();
446 }
447
DEFINE_TEST(test_read_format_zip_ppmd_one_file)448 DEFINE_TEST(test_read_format_zip_ppmd_one_file)
449 {
450 const char *refname = "test_read_format_zip_ppmd8.zipx";
451 struct archive *a;
452 struct archive_entry *ae;
453
454 extract_reference_file(refname);
455
456 assert((a = archive_read_new()) != NULL);
457 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
458 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
459 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
460 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
461 assertEqualString("vimrc", archive_entry_pathname(ae));
462 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
463 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
464 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
465 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
466 }
467
DEFINE_TEST(test_read_format_zip_ppmd_one_file_blockread)468 DEFINE_TEST(test_read_format_zip_ppmd_one_file_blockread)
469 {
470 const char *refname = "test_read_format_zip_ppmd8.zipx";
471 struct archive *a;
472 struct archive_entry *ae;
473
474 extract_reference_file(refname);
475
476 assert((a = archive_read_new()) != NULL);
477 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
478 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
479 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
480 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
481 assertEqualString("vimrc", archive_entry_pathname(ae));
482 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
483 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
484 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
485 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
486 }
487
DEFINE_TEST(test_read_format_zip_ppmd_multi)488 DEFINE_TEST(test_read_format_zip_ppmd_multi)
489 {
490 const char *refname = "test_read_format_zip_ppmd8_multi.zipx";
491 struct archive *a;
492 struct archive_entry *ae;
493
494 extract_reference_file(refname);
495
496 assert((a = archive_read_new()) != NULL);
497 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
498 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
499
500 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
501 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
502 assertEqualString("smartd.conf", archive_entry_pathname(ae));
503 assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E));
504
505 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
506 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
507 assertEqualString("ts.conf", archive_entry_pathname(ae));
508 assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31));
509
510 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
511 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
512 assertEqualString("vimrc", archive_entry_pathname(ae));
513 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
514
515 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
516 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
517 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
518 }
519
DEFINE_TEST(test_read_format_zip_ppmd_multi_blockread)520 DEFINE_TEST(test_read_format_zip_ppmd_multi_blockread)
521 {
522 const char *refname = "test_read_format_zip_ppmd8_multi.zipx";
523 struct archive *a;
524 struct archive_entry *ae;
525
526 extract_reference_file(refname);
527
528 assert((a = archive_read_new()) != NULL);
529 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
530 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
531
532 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
533 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
534 assertEqualString("smartd.conf", archive_entry_pathname(ae));
535 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E));
536
537 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
538 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
539 assertEqualString("ts.conf", archive_entry_pathname(ae));
540 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31));
541
542 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
543 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
544 assertEqualString("vimrc", archive_entry_pathname(ae));
545 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA));
546
547 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
548 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
549 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
550 }
551
DEFINE_TEST(test_read_format_zip_lzma_one_file)552 DEFINE_TEST(test_read_format_zip_lzma_one_file)
553 {
554 const char *refname = "test_read_format_zip_lzma.zipx";
555 struct archive *a;
556 struct archive_entry *ae;
557
558 assert((a = archive_read_new()) != NULL);
559 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
560 skipping("lzma reading not fully supported on this platform");
561 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
562 return;
563 }
564 extract_reference_file(refname);
565
566 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
567 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
568 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
569 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
570 assertEqualString("vimrc", archive_entry_pathname(ae));
571 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
572 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
573 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
574 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
575 }
576
DEFINE_TEST(test_read_format_zip_lzma_one_file_blockread)577 DEFINE_TEST(test_read_format_zip_lzma_one_file_blockread)
578 {
579 const char *refname = "test_read_format_zip_lzma.zipx";
580 struct archive *a;
581 struct archive_entry *ae;
582
583 assert((a = archive_read_new()) != NULL);
584 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
585 skipping("lzma reading not fully supported on this platform");
586 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
587 return;
588 }
589 extract_reference_file(refname);
590
591 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
592 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
593 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
594 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
595 assertEqualString("vimrc", archive_entry_pathname(ae));
596 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
597 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
598 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
599 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
600 }
601
DEFINE_TEST(test_read_format_zip_lzma_multi)602 DEFINE_TEST(test_read_format_zip_lzma_multi)
603 {
604 const char *refname = "test_read_format_zip_lzma_multi.zipx";
605 struct archive *a;
606 struct archive_entry *ae;
607
608 assert((a = archive_read_new()) != NULL);
609 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
610 skipping("lzma reading not fully supported on this platform");
611 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
612 return;
613 }
614 extract_reference_file(refname);
615
616 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
617 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
618
619 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
620 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
621 assertEqualString("smartd.conf", archive_entry_pathname(ae));
622 assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E));
623
624 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
625 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
626 assertEqualString("ts.conf", archive_entry_pathname(ae));
627 assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31));
628
629 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
630 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
631 assertEqualString("vimrc", archive_entry_pathname(ae));
632 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
633
634 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
635 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
636 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
637 }
638
DEFINE_TEST(test_read_format_zip_lzma_multi_blockread)639 DEFINE_TEST(test_read_format_zip_lzma_multi_blockread)
640 {
641 const char *refname = "test_read_format_zip_lzma_multi.zipx";
642 struct archive *a;
643 struct archive_entry *ae;
644
645 assert((a = archive_read_new()) != NULL);
646 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
647 skipping("lzma reading not fully supported on this platform");
648 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
649 return;
650 }
651 extract_reference_file(refname);
652
653 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
654 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
655
656 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
657 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
658 assertEqualString("smartd.conf", archive_entry_pathname(ae));
659 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E));
660
661 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
662 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
663 assertEqualString("ts.conf", archive_entry_pathname(ae));
664 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31));
665
666 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
667 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
668 assertEqualString("vimrc", archive_entry_pathname(ae));
669 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA));
670
671 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
672 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
673 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
674 }
675
676
DEFINE_TEST(test_read_format_zip_bzip2_one_file)677 DEFINE_TEST(test_read_format_zip_bzip2_one_file)
678 {
679 const char *refname = "test_read_format_zip_bzip2.zipx";
680 struct archive *a;
681 struct archive_entry *ae;
682
683 assert((a = archive_read_new()) != NULL);
684 if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) {
685 skipping("bzip2 is not fully supported on this platform");
686 archive_read_free(a);
687 return;
688 }
689 extract_reference_file(refname);
690
691 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
692 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
693 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
694 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
695 assertEqualString("vimrc", archive_entry_pathname(ae));
696 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
697 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
698 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
699 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
700 }
701
DEFINE_TEST(test_read_format_zip_bzip2_one_file_blockread)702 DEFINE_TEST(test_read_format_zip_bzip2_one_file_blockread)
703 {
704 const char *refname = "test_read_format_zip_bzip2.zipx";
705 struct archive *a;
706 struct archive_entry *ae;
707
708 assert((a = archive_read_new()) != NULL);
709 if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) {
710 skipping("bzip2 is not fully supported on this platform");
711 archive_read_free(a);
712 return;
713 }
714 extract_reference_file(refname);
715
716 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
717 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
718 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
719 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
720 assertEqualString("vimrc", archive_entry_pathname(ae));
721 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
722 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
723 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
724 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
725 }
726
DEFINE_TEST(test_read_format_zip_bzip2_multi)727 DEFINE_TEST(test_read_format_zip_bzip2_multi)
728 {
729 const char *refname = "test_read_format_zip_bzip2_multi.zipx";
730 struct archive *a;
731 struct archive_entry *ae;
732
733 assert((a = archive_read_new()) != NULL);
734 if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) {
735 skipping("bzip2 is not fully supported on this platform");
736 archive_read_free(a);
737 return;
738 }
739 extract_reference_file(refname);
740
741 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
742 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
743
744 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
745 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
746 assertEqualString("smartd.conf", archive_entry_pathname(ae));
747 assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E));
748
749 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
750 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
751 assertEqualString("ts.conf", archive_entry_pathname(ae));
752 assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31));
753
754 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
755 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
756 assertEqualString("vimrc", archive_entry_pathname(ae));
757 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
758
759 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
760 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
761 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
762 }
763
DEFINE_TEST(test_read_format_zip_bzip2_multi_blockread)764 DEFINE_TEST(test_read_format_zip_bzip2_multi_blockread)
765 {
766 const char *refname = "test_read_format_zip_bzip2_multi.zipx";
767 struct archive *a;
768 struct archive_entry *ae;
769
770 assert((a = archive_read_new()) != NULL);
771 if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) {
772 skipping("bzip2 is not fully supported on this platform");
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
781 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
782 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
783 assertEqualString("smartd.conf", archive_entry_pathname(ae));
784 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E));
785
786 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
787 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
788 assertEqualString("ts.conf", archive_entry_pathname(ae));
789 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31));
790
791 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
792 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
793 assertEqualString("vimrc", archive_entry_pathname(ae));
794 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA));
795
796 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
797 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
798 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
799 }
800
DEFINE_TEST(test_read_format_zip_zstd_one_file)801 DEFINE_TEST(test_read_format_zip_zstd_one_file)
802 {
803 const char *refname = "test_read_format_zip_zstd.zipx";
804 struct archive *a;
805 struct archive_entry *ae;
806
807 assert((a = archive_read_new()) != NULL);
808 if (ARCHIVE_OK != archive_read_support_filter_zstd(a)) {
809 skipping("zstd is not fully supported on this platform");
810 archive_read_close(a);
811 archive_read_free(a);
812 return;
813 }
814 extract_reference_file(refname);
815
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));
819 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
820 assertEqualString("vimrc", archive_entry_pathname(ae));
821 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
822 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
823 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
824 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
825 }
826
DEFINE_TEST(test_read_format_zip_zstd_one_file_blockread)827 DEFINE_TEST(test_read_format_zip_zstd_one_file_blockread)
828 {
829 const char *refname = "test_read_format_zip_zstd.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 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
845 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
846 assertEqualString("vimrc", archive_entry_pathname(ae));
847 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
848 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
849 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
850 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
851 }
852
DEFINE_TEST(test_read_format_zip_zstd_multi)853 DEFINE_TEST(test_read_format_zip_zstd_multi)
854 {
855 const char *refname = "test_read_format_zip_zstd_multi.zipx";
856 struct archive *a;
857 struct archive_entry *ae;
858
859 assert((a = archive_read_new()) != NULL);
860 if (ARCHIVE_OK != archive_read_support_filter_zstd(a)) {
861 skipping("zstd is not fully supported on this platform");
862 archive_read_close(a);
863 archive_read_free(a);
864 return;
865 }
866 extract_reference_file(refname);
867
868 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
869 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
870
871 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
872 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
873 assertEqualString("smartd.conf", archive_entry_pathname(ae));
874 assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E));
875
876 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
877 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
878 assertEqualString("ts.conf", archive_entry_pathname(ae));
879 assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31));
880
881 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
882 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
883 assertEqualString("vimrc", archive_entry_pathname(ae));
884 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
885
886 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
887 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
888 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
889 }
890
DEFINE_TEST(test_read_format_zip_zstd_multi_blockread)891 DEFINE_TEST(test_read_format_zip_zstd_multi_blockread)
892 {
893 const char *refname = "test_read_format_zip_zstd_multi.zipx";
894 struct archive *a;
895 struct archive_entry *ae;
896
897 assert((a = archive_read_new()) != NULL);
898 if (ARCHIVE_OK != archive_read_support_filter_zstd(a)) {
899 skipping("zstd is not fully supported on this platform");
900 archive_read_close(a);
901 archive_read_free(a);
902 return;
903 }
904 extract_reference_file(refname);
905
906 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
907 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
908
909 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
910 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
911 assertEqualString("smartd.conf", archive_entry_pathname(ae));
912 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E));
913
914 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
915 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
916 assertEqualString("ts.conf", archive_entry_pathname(ae));
917 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31));
918
919 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
920 assertEqualString("ZIP 2.0 (zstd)", archive_format_name(a));
921 assertEqualString("vimrc", archive_entry_pathname(ae));
922 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA));
923
924 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
925 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
926 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
927 }
928
DEFINE_TEST(test_read_format_zip_xz_multi)929 DEFINE_TEST(test_read_format_zip_xz_multi)
930 {
931 const char *refname = "test_read_format_zip_xz_multi.zipx";
932 struct archive *a;
933 struct archive_entry *ae;
934
935 assert((a = archive_read_new()) != NULL);
936 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
937 skipping("lzma reading not fully supported on this platform");
938 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
939 return;
940 }
941 extract_reference_file(refname);
942
943 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
944 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
945
946 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
947 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
948 assertEqualString("bash.bashrc", archive_entry_pathname(ae));
949 assertEqualIntA(a, 0, extract_one(a, ae, 0xF751B8C9));
950
951 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
952 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
953 assertEqualString("pacman.conf", archive_entry_pathname(ae));
954 assertEqualIntA(a, 0, extract_one(a, ae, 0xB20B7F88));
955
956 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
957 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
958 assertEqualString("profile", archive_entry_pathname(ae));
959 assertEqualIntA(a, 0, extract_one(a, ae, 0x2329F054));
960
961 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
962 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
963 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
964 }
965
DEFINE_TEST(test_read_format_zip_xz_multi_blockread)966 DEFINE_TEST(test_read_format_zip_xz_multi_blockread)
967 {
968 const char *refname = "test_read_format_zip_xz_multi.zipx";
969 struct archive *a;
970 struct archive_entry *ae;
971
972 assert((a = archive_read_new()) != NULL);
973 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
974 skipping("lzma reading not fully supported on this platform");
975 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
976 return;
977 }
978 extract_reference_file(refname);
979
980 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
981 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
982
983 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
984 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
985 assertEqualString("bash.bashrc", archive_entry_pathname(ae));
986 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0xF751B8C9));
987
988 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
989 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
990 assertEqualString("pacman.conf", archive_entry_pathname(ae));
991 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xB20B7F88));
992
993 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
994 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
995 assertEqualString("profile", archive_entry_pathname(ae));
996 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0x2329F054));
997
998 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
999 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1000 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1001 }
1002
DEFINE_TEST(test_read_format_zip_ppmd8_crash_1)1003 DEFINE_TEST(test_read_format_zip_ppmd8_crash_1)
1004 {
1005 const char *refname = "test_read_format_zip_ppmd8_crash_2.zipx";
1006 struct archive *a;
1007 struct archive_entry *ae;
1008 char buf[64];
1009
1010 extract_reference_file(refname);
1011
1012 assert((a = archive_read_new()) != NULL);
1013 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
1014 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 100));
1015 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1016
1017 /* This file shouldn't be properly decompressed, because it's invalid.
1018 * However, unpacker should return an error during unpacking. Without the
1019 * proper fix, the unpacker was entering an unlimited loop. */
1020 assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buf, 1));
1021 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1022 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1023 }
1024
DEFINE_TEST(test_read_format_zip_bz2_hang_on_invalid)1025 DEFINE_TEST(test_read_format_zip_bz2_hang_on_invalid)
1026 {
1027 const char *refname = "test_read_format_zip_bz2_hang.zip";
1028 struct archive *a;
1029 struct archive_entry *ae;
1030 char buf[8];
1031
1032 assert((a = archive_read_new()) != NULL);
1033 if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) {
1034 skipping("bzip2 is not fully supported on this platform");
1035 archive_read_free(a);
1036 return;
1037 }
1038 extract_reference_file(refname);
1039
1040 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
1041 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
1042 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1043
1044 /* The file `refname` is invalid in this case, so this call should fail.
1045 * But it shouldn't crash. */
1046 assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buf, 64));
1047 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1048 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1049 }
1050
DEFINE_TEST(test_read_format_zip_ppmd8_crash_2)1051 DEFINE_TEST(test_read_format_zip_ppmd8_crash_2)
1052 {
1053 const char *refname = "test_read_format_zip_ppmd8_crash_2.zipx";
1054 struct archive *a;
1055 struct archive_entry *ae;
1056 char buf[64];
1057
1058 extract_reference_file(refname);
1059
1060 assert((a = archive_read_new()) != NULL);
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
1065 /* The file `refname` is invalid in this case, so this call should fail.
1066 * But it shouldn't crash. */
1067 assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buf, 64));
1068 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1069 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1070 }
1071
DEFINE_TEST(test_read_format_zip_lzma_alone_leak)1072 DEFINE_TEST(test_read_format_zip_lzma_alone_leak)
1073 {
1074 const char *refname = "test_read_format_zip_lzma_alone_leak.zipx";
1075 struct archive *a;
1076 struct archive_entry *ae;
1077 char buf[64];
1078
1079 /* OSSFuzz #14470 sample file. */
1080 extract_reference_file(refname);
1081
1082 assert((a = archive_read_new()) != NULL);
1083 if(ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
1084 skipping("lzma reading is not fully supported on this platform");
1085 archive_read_close(a);
1086 archive_read_free(a);
1087 return;
1088 }
1089
1090 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
1091 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
1092 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1093
1094 /* Extraction of this file should fail, because the sample file is invalid.
1095 * But it shouldn't crash. */
1096 assertEqualIntA(a, ARCHIVE_FAILED, archive_read_data(a, buf, sizeof(buf)));
1097 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1098
1099 /* Extraction of this file should fail, because the sample file is invalid.
1100 * But it shouldn't crash. */
1101 assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buf, sizeof(buf)));
1102
1103 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1104 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1105
1106 /* This testcase shouldn't produce any memory leaks. When running test
1107 * suite under Valgrind or ASan, the test runner won't return with
1108 * exit code 0 in case if a memory leak. */
1109 }
1110
DEFINE_TEST(test_read_format_zip_lzma_stream_end)1111 DEFINE_TEST(test_read_format_zip_lzma_stream_end)
1112 {
1113 const char *refname = "test_read_format_zip_lzma_stream_end.zipx";
1114 struct archive *a;
1115 struct archive_entry *ae;
1116
1117 assert((a = archive_read_new()) != NULL);
1118 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
1119 skipping("lzma reading not fully supported on this platform");
1120 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1121 return;
1122 }
1123 extract_reference_file(refname);
1124
1125 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
1126 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
1127 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1128 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
1129 assertEqualString("vimrc", archive_entry_pathname(ae));
1130 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
1131 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
1132 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1133 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1134 }
1135
DEFINE_TEST(test_read_format_zip_lzma_stream_end_blockread)1136 DEFINE_TEST(test_read_format_zip_lzma_stream_end_blockread)
1137 {
1138 const char *refname = "test_read_format_zip_lzma_stream_end.zipx";
1139 struct archive *a;
1140 struct archive_entry *ae;
1141
1142 assert((a = archive_read_new()) != NULL);
1143 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
1144 skipping("lzma reading not fully supported on this platform");
1145 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1146 return;
1147 }
1148 extract_reference_file(refname);
1149
1150 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
1151 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
1152 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1153 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
1154 assertEqualString("vimrc", archive_entry_pathname(ae));
1155 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
1156 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
1157 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1158 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1159 }
1160
DEFINE_TEST(test_read_format_zip_7z_lzma)1161 DEFINE_TEST(test_read_format_zip_7z_lzma)
1162 {
1163 const char *refname = "test_read_format_zip_7z_lzma.zip";
1164 struct archive_entry *ae;
1165 struct archive *a;
1166
1167 assert((a = archive_read_new()) != NULL);
1168 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) {
1169 skipping("lzma reading not fully supported on this platform");
1170 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1171 return;
1172 }
1173 extract_reference_file(refname);
1174
1175 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
1176 assertEqualIntA(a, ARCHIVE_OK,
1177 archive_read_open_filename(a, refname, 10240));
1178 //read directories
1179 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1180 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1181 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1182 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1183 //read symlink
1184 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1185 assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
1186 assertEqualString("../samples/abc_measurement_analysis_sample"
1187 "/src/abc_measurement_analysis_sample.py",
1188 archive_entry_symlink(ae));
1189 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1190 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1191 }
1192
DEFINE_TEST(test_read_format_zip_7z_deflate)1193 DEFINE_TEST(test_read_format_zip_7z_deflate)
1194 {
1195 const char *refname = "test_read_format_zip_7z_deflate.zip";
1196 struct archive_entry *ae;
1197 struct archive *a;
1198 int r;
1199
1200 assert((a = archive_read_new()) != NULL);
1201 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1202 extract_reference_file(refname);
1203
1204 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
1205 assertEqualIntA(a, ARCHIVE_OK,
1206 archive_read_open_filename(a, refname, 10240));
1207 //read first symlink
1208 r = archive_read_next_header(a, &ae);
1209 if (archive_zlib_version() == NULL) {
1210 assertEqualInt(ARCHIVE_FAILED, r);
1211 assertEqualString(archive_error_string(a),
1212 "Unsupported ZIP compression method during decompression "
1213 "of link entry (8: deflation)");
1214 assert(archive_errno(a) != 0);
1215 } else {
1216 assertEqualIntA(a, ARCHIVE_OK, r);
1217 assertEqualString("libxkbcommon-x11.so.0.0.0",
1218 archive_entry_symlink(ae));
1219 }
1220 assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
1221 //read second symlink
1222 r = archive_read_next_header(a, &ae);
1223 if (archive_zlib_version() == NULL) {
1224 assertEqualInt(ARCHIVE_FAILED, r);
1225 assertEqualString(archive_error_string(a),
1226 "Unsupported ZIP compression method during decompression "
1227 "of link entry (8: deflation)");
1228 assert(archive_errno(a) != 0);
1229 } else {
1230 assertEqualIntA(a, ARCHIVE_OK, r);
1231 assertEqualString("libxkbcommon-x11.so.0.0.0",
1232 archive_entry_symlink(ae));
1233 }
1234 assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
1235 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1236 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1237 }
1238