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