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