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 __FBSDID("$FreeBSD$"); 28 29 #define __LIBARCHIVE_BUILD 30 #include <archive_crc32.h> 31 32 static 33 int extract_one(struct archive* a, struct archive_entry* ae, uint32_t crc) 34 { 35 la_ssize_t fsize, bytes_read; 36 uint8_t* buf; 37 int ret = 1; 38 uint32_t computed_crc; 39 40 fsize = archive_entry_size(ae); 41 buf = malloc(fsize); 42 if(buf == NULL) 43 return 1; 44 45 bytes_read = archive_read_data(a, buf, fsize); 46 if(bytes_read != fsize) { 47 assertEqualInt(bytes_read, fsize); 48 goto fn_exit; 49 } 50 51 computed_crc = crc32(0, buf, fsize); 52 assertEqualInt(computed_crc, crc); 53 ret = 0; 54 55 fn_exit: 56 free(buf); 57 return ret; 58 } 59 60 static 61 int extract_one_using_blocks(struct archive* a, int block_size, uint32_t crc) 62 { 63 uint8_t* buf; 64 int ret = 1; 65 uint32_t computed_crc = 0; 66 la_ssize_t bytes_read; 67 68 buf = malloc(block_size); 69 if(buf == NULL) 70 return 1; 71 72 while(1) { 73 bytes_read = archive_read_data(a, buf, block_size); 74 if(bytes_read == ARCHIVE_RETRY) 75 continue; 76 else if(bytes_read == 0) 77 break; 78 else if(bytes_read < 0) { 79 /* If we're here, it means the decompressor has failed 80 * to properly decode test file. */ 81 assertA(0); 82 ret = 1; 83 goto fn_exit; 84 } else { 85 /* ok */ 86 } 87 88 computed_crc = crc32(computed_crc, buf, bytes_read); 89 } 90 91 assertEqualInt(computed_crc, crc); 92 ret = 0; 93 94 fn_exit: 95 free(buf); 96 return ret; 97 } 98 99 /* 100 * The reference file for this has been manually tweaked so that: 101 * * file2 has length-at-end but file1 does not 102 * * file2 has an invalid CRC 103 */ 104 static void 105 verify_basic(struct archive *a, int seek_checks) 106 { 107 struct archive_entry *ae; 108 char *buff[128]; 109 const void *pv; 110 size_t s; 111 int64_t o; 112 113 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 114 assertEqualString("ZIP 1.0 (uncompressed)", archive_format_name(a)); 115 assertEqualString("dir/", archive_entry_pathname(ae)); 116 assertEqualInt(1179604249, archive_entry_mtime(ae)); 117 assertEqualInt(0, archive_entry_size(ae)); 118 if (seek_checks) 119 assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae)); 120 assertEqualInt(archive_entry_is_encrypted(ae), 0); 121 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 122 assertEqualIntA(a, ARCHIVE_EOF, 123 archive_read_data_block(a, &pv, &s, &o)); 124 assertEqualInt((int)s, 0); 125 126 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 127 assertEqualString("ZIP 2.0 (deflation)", archive_format_name(a)); 128 assertEqualString("file1", archive_entry_pathname(ae)); 129 assertEqualInt(1179604289, archive_entry_mtime(ae)); 130 if (seek_checks) 131 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae)); 132 assertEqualInt(18, archive_entry_size(ae)); 133 assertEqualInt(archive_entry_is_encrypted(ae), 0); 134 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 135 failure("archive_read_data() returns number of bytes read"); 136 if (archive_zlib_version() != NULL) { 137 assertEqualInt(18, archive_read_data(a, buff, 19)); 138 assertEqualMem(buff, "hello\nhello\nhello\n", 18); 139 } else { 140 assertEqualInt(ARCHIVE_FAILED, archive_read_data(a, buff, 19)); 141 assertEqualString(archive_error_string(a), 142 "Unsupported ZIP compression method (deflation)"); 143 assert(archive_errno(a) != 0); 144 } 145 146 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 147 assertEqualString("ZIP 2.0 (deflation)", archive_format_name(a)); 148 assertEqualString("file2", archive_entry_pathname(ae)); 149 assertEqualInt(1179605932, archive_entry_mtime(ae)); 150 assertEqualInt(archive_entry_is_encrypted(ae), 0); 151 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 152 if (seek_checks) { 153 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae)); 154 } 155 assert(archive_entry_size_is_set(ae)); 156 assertEqualInt(18, archive_entry_size(ae)); 157 if (archive_zlib_version() != NULL) { 158 failure("file2 has a bad CRC, so read should fail and not change buff"); 159 memset(buff, 'a', 19); 160 assertEqualInt(ARCHIVE_WARN, archive_read_data(a, buff, 19)); 161 assertEqualMem(buff, "aaaaaaaaaaaaaaaaaaa", 19); 162 } else { 163 assertEqualInt(ARCHIVE_FAILED, archive_read_data(a, buff, 19)); 164 assertEqualString(archive_error_string(a), 165 "Unsupported ZIP compression method (deflation)"); 166 assert(archive_errno(a) != 0); 167 } 168 assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &ae)); 169 assertEqualString("ZIP 2.0 (deflation)", archive_format_name(a)); 170 /* Verify the number of files read. */ 171 failure("the archive file has three files"); 172 assertEqualInt(3, archive_file_count(a)); 173 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 174 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 175 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 176 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 177 } 178 179 static void 180 test_basic(void) 181 { 182 const char *refname = "test_read_format_zip.zip"; 183 struct archive *a; 184 char *p; 185 size_t s; 186 187 extract_reference_file(refname); 188 189 /* Verify with seeking reader. */ 190 assert((a = archive_read_new()) != NULL); 191 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 192 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 193 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 10240)); 194 verify_basic(a, 1); 195 196 /* Verify with streaming reader. */ 197 p = slurpfile(&s, refname); 198 assert((a = archive_read_new()) != NULL); 199 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 200 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 201 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, p, s, 31)); 202 verify_basic(a, 0); 203 free(p); 204 } 205 206 /* 207 * Read Info-ZIP New Unix Extra Field 0x7875 "ux". 208 * Currently stores Unix UID/GID up to 32 bits. 209 */ 210 static void 211 verify_info_zip_ux(struct archive *a, int seek_checks) 212 { 213 struct archive_entry *ae; 214 char *buff[128]; 215 216 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 217 assertEqualString("file1", archive_entry_pathname(ae)); 218 assertEqualInt(1300668680, archive_entry_mtime(ae)); 219 assertEqualInt(18, archive_entry_size(ae)); 220 assertEqualInt(archive_entry_is_encrypted(ae), 0); 221 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 222 if (seek_checks) 223 assertEqualInt(AE_IFREG | 0644, archive_entry_mode(ae)); 224 failure("zip reader should read Info-ZIP New Unix Extra Field"); 225 assertEqualInt(1001, archive_entry_uid(ae)); 226 assertEqualInt(1001, archive_entry_gid(ae)); 227 if (archive_zlib_version() != NULL) { 228 failure("archive_read_data() returns number of bytes read"); 229 assertEqualInt(18, archive_read_data(a, buff, 19)); 230 assertEqualMem(buff, "hello\nhello\nhello\n", 18); 231 } else { 232 assertEqualInt(ARCHIVE_FAILED, archive_read_data(a, buff, 19)); 233 assertEqualString(archive_error_string(a), 234 "Unsupported ZIP compression method (deflation)"); 235 assert(archive_errno(a) != 0); 236 } 237 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 238 239 /* Verify the number of files read. */ 240 failure("the archive file has just one file"); 241 assertEqualInt(1, archive_file_count(a)); 242 243 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 244 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 245 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 246 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 247 } 248 249 static void 250 test_info_zip_ux(void) 251 { 252 const char *refname = "test_read_format_zip_ux.zip"; 253 struct archive *a; 254 char *p; 255 size_t s; 256 257 extract_reference_file(refname); 258 259 /* Verify with seeking reader. */ 260 assert((a = archive_read_new()) != NULL); 261 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 262 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 263 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 10240)); 264 verify_info_zip_ux(a, 1); 265 266 /* Verify with streaming reader. */ 267 p = slurpfile(&s, refname); 268 assert((a = archive_read_new()) != NULL); 269 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 270 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 271 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, p, s, 108)); 272 verify_info_zip_ux(a, 0); 273 free(p); 274 } 275 276 /* 277 * Verify that test_read_extract correctly works with 278 * Zip entries that use length-at-end. 279 */ 280 static void 281 verify_extract_length_at_end(struct archive *a, int seek_checks) 282 { 283 struct archive_entry *ae; 284 285 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 286 287 assertEqualInt(archive_entry_is_encrypted(ae), 0); 288 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 289 assertEqualString("hello.txt", archive_entry_pathname(ae)); 290 if (seek_checks) { 291 assertEqualInt(AE_IFREG | 0644, archive_entry_mode(ae)); 292 assert(archive_entry_size_is_set(ae)); 293 assertEqualInt(6, archive_entry_size(ae)); 294 } else { 295 assert(!archive_entry_size_is_set(ae)); 296 assertEqualInt(0, archive_entry_size(ae)); 297 } 298 299 if (archive_zlib_version() != NULL) { 300 assertEqualIntA(a, ARCHIVE_OK, archive_read_extract(a, ae, 0)); 301 assertFileContents("hello\x0A", 6, "hello.txt"); 302 } else { 303 assertEqualIntA(a, ARCHIVE_FAILED, archive_read_extract(a, ae, 0)); 304 assertEqualString(archive_error_string(a), 305 "Unsupported ZIP compression method (deflation)"); 306 assert(archive_errno(a) != 0); 307 } 308 309 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 310 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 311 } 312 313 static void 314 test_extract_length_at_end(void) 315 { 316 const char *refname = "test_read_format_zip_length_at_end.zip"; 317 char *p; 318 size_t s; 319 struct archive *a; 320 321 extract_reference_file(refname); 322 323 /* Verify extraction with seeking reader. */ 324 assert((a = archive_read_new()) != NULL); 325 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 326 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 327 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 10240)); 328 verify_extract_length_at_end(a, 1); 329 330 /* Verify extraction with streaming reader. */ 331 p = slurpfile(&s, refname); 332 assert((a = archive_read_new()) != NULL); 333 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 334 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 335 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, p, s, 108)); 336 verify_extract_length_at_end(a, 0); 337 free(p); 338 } 339 340 static void 341 test_symlink(void) 342 { 343 const char *refname = "test_read_format_zip_symlink.zip"; 344 char *p; 345 size_t s; 346 struct archive *a; 347 struct archive_entry *ae; 348 349 extract_reference_file(refname); 350 p = slurpfile(&s, refname); 351 352 /* Symlinks can only be extracted with the seeking reader. */ 353 assert((a = archive_read_new()) != NULL); 354 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 355 assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, p, s, 1)); 356 357 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 358 assertEqualString("file", archive_entry_pathname(ae)); 359 assertEqualInt(AE_IFREG, archive_entry_filetype(ae)); 360 assertEqualInt(archive_entry_is_encrypted(ae), 0); 361 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 362 363 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 364 assertEqualString("symlink", archive_entry_pathname(ae)); 365 assertEqualInt(AE_IFLNK, archive_entry_filetype(ae)); 366 assertEqualInt(0, archive_entry_size(ae)); 367 assertEqualString("file", archive_entry_symlink(ae)); 368 assertEqualInt(archive_entry_is_encrypted(ae), 0); 369 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 370 371 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 372 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 373 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 374 375 free(p); 376 } 377 378 DEFINE_TEST(test_read_format_zip) 379 { 380 test_basic(); 381 test_info_zip_ux(); 382 test_extract_length_at_end(); 383 test_symlink(); 384 } 385 386 DEFINE_TEST(test_read_format_zip_ppmd_one_file) 387 { 388 const char *refname = "test_read_format_zip_ppmd8.zipx"; 389 struct archive *a; 390 struct archive_entry *ae; 391 392 extract_reference_file(refname); 393 394 assert((a = archive_read_new()) != NULL); 395 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 396 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 397 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 398 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 399 assertEqualString("vimrc", archive_entry_pathname(ae)); 400 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA)); 401 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 402 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 403 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 404 } 405 406 DEFINE_TEST(test_read_format_zip_ppmd_one_file_blockread) 407 { 408 const char *refname = "test_read_format_zip_ppmd8.zipx"; 409 struct archive *a; 410 struct archive_entry *ae; 411 412 extract_reference_file(refname); 413 414 assert((a = archive_read_new()) != NULL); 415 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 416 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 417 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 418 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 419 assertEqualString("vimrc", archive_entry_pathname(ae)); 420 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA)); 421 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 422 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 423 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 424 } 425 426 DEFINE_TEST(test_read_format_zip_ppmd_multi) 427 { 428 const char *refname = "test_read_format_zip_ppmd8_multi.zipx"; 429 struct archive *a; 430 struct archive_entry *ae; 431 432 extract_reference_file(refname); 433 434 assert((a = archive_read_new()) != NULL); 435 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 436 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 437 438 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 439 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 440 assertEqualString("smartd.conf", archive_entry_pathname(ae)); 441 assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E)); 442 443 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 444 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 445 assertEqualString("ts.conf", archive_entry_pathname(ae)); 446 assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31)); 447 448 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 449 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 450 assertEqualString("vimrc", archive_entry_pathname(ae)); 451 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA)); 452 453 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 454 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 455 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 456 } 457 458 DEFINE_TEST(test_read_format_zip_ppmd_multi_blockread) 459 { 460 const char *refname = "test_read_format_zip_ppmd8_multi.zipx"; 461 struct archive *a; 462 struct archive_entry *ae; 463 464 extract_reference_file(refname); 465 466 assert((a = archive_read_new()) != NULL); 467 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 468 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 469 470 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 471 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 472 assertEqualString("smartd.conf", archive_entry_pathname(ae)); 473 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E)); 474 475 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 476 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 477 assertEqualString("ts.conf", archive_entry_pathname(ae)); 478 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31)); 479 480 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 481 assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 482 assertEqualString("vimrc", archive_entry_pathname(ae)); 483 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA)); 484 485 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 486 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 487 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 488 } 489 490 DEFINE_TEST(test_read_format_zip_lzma_one_file) 491 { 492 const char *refname = "test_read_format_zip_lzma.zipx"; 493 struct archive *a; 494 struct archive_entry *ae; 495 496 extract_reference_file(refname); 497 498 assert((a = archive_read_new()) != NULL); 499 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 500 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 501 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 502 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 503 assertEqualString("vimrc", archive_entry_pathname(ae)); 504 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA)); 505 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 506 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 507 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 508 } 509 510 DEFINE_TEST(test_read_format_zip_lzma_one_file_blockread) 511 { 512 const char *refname = "test_read_format_zip_lzma.zipx"; 513 struct archive *a; 514 struct archive_entry *ae; 515 516 extract_reference_file(refname); 517 518 assert((a = archive_read_new()) != NULL); 519 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 520 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 521 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 522 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 523 assertEqualString("vimrc", archive_entry_pathname(ae)); 524 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA)); 525 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 526 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 527 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 528 } 529 530 DEFINE_TEST(test_read_format_zip_lzma_multi) 531 { 532 const char *refname = "test_read_format_zip_lzma_multi.zipx"; 533 struct archive *a; 534 struct archive_entry *ae; 535 536 extract_reference_file(refname); 537 538 assert((a = archive_read_new()) != NULL); 539 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 540 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 541 542 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 543 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 544 assertEqualString("smartd.conf", archive_entry_pathname(ae)); 545 assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E)); 546 547 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 548 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 549 assertEqualString("ts.conf", archive_entry_pathname(ae)); 550 assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31)); 551 552 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 553 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 554 assertEqualString("vimrc", archive_entry_pathname(ae)); 555 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA)); 556 557 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 558 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 559 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 560 } 561 562 DEFINE_TEST(test_read_format_zip_lzma_multi_blockread) 563 { 564 const char *refname = "test_read_format_zip_lzma_multi.zipx"; 565 struct archive *a; 566 struct archive_entry *ae; 567 568 extract_reference_file(refname); 569 570 assert((a = archive_read_new()) != NULL); 571 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 572 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 573 574 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 575 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 576 assertEqualString("smartd.conf", archive_entry_pathname(ae)); 577 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E)); 578 579 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 580 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 581 assertEqualString("ts.conf", archive_entry_pathname(ae)); 582 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31)); 583 584 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 585 assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 586 assertEqualString("vimrc", archive_entry_pathname(ae)); 587 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA)); 588 589 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 590 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 591 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 592 } 593 594 595 DEFINE_TEST(test_read_format_zip_bzip2_one_file) 596 { 597 const char *refname = "test_read_format_zip_bzip2.zipx"; 598 struct archive *a; 599 struct archive_entry *ae; 600 601 extract_reference_file(refname); 602 603 assert((a = archive_read_new()) != NULL); 604 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 605 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 606 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 607 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 608 assertEqualString("vimrc", archive_entry_pathname(ae)); 609 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA)); 610 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 611 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 612 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 613 } 614 615 DEFINE_TEST(test_read_format_zip_bzip2_one_file_blockread) 616 { 617 const char *refname = "test_read_format_zip_bzip2.zipx"; 618 struct archive *a; 619 struct archive_entry *ae; 620 621 extract_reference_file(refname); 622 623 assert((a = archive_read_new()) != NULL); 624 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 625 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 626 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 627 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 628 assertEqualString("vimrc", archive_entry_pathname(ae)); 629 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA)); 630 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 631 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 632 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 633 } 634 635 DEFINE_TEST(test_read_format_zip_bzip2_multi) 636 { 637 const char *refname = "test_read_format_zip_bzip2_multi.zipx"; 638 struct archive *a; 639 struct archive_entry *ae; 640 641 extract_reference_file(refname); 642 643 assert((a = archive_read_new()) != NULL); 644 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 645 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 646 647 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 648 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 649 assertEqualString("smartd.conf", archive_entry_pathname(ae)); 650 assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E)); 651 652 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 653 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 654 assertEqualString("ts.conf", archive_entry_pathname(ae)); 655 assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31)); 656 657 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 658 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 659 assertEqualString("vimrc", archive_entry_pathname(ae)); 660 assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA)); 661 662 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 663 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 664 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 665 } 666 667 DEFINE_TEST(test_read_format_zip_bzip2_multi_blockread) 668 { 669 const char *refname = "test_read_format_zip_bzip2_multi.zipx"; 670 struct archive *a; 671 struct archive_entry *ae; 672 673 extract_reference_file(refname); 674 675 assert((a = archive_read_new()) != NULL); 676 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 677 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 678 679 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 680 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 681 assertEqualString("smartd.conf", archive_entry_pathname(ae)); 682 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E)); 683 684 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 685 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 686 assertEqualString("ts.conf", archive_entry_pathname(ae)); 687 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31)); 688 689 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 690 assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 691 assertEqualString("vimrc", archive_entry_pathname(ae)); 692 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA)); 693 694 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 695 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 696 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 697 } 698 699 DEFINE_TEST(test_read_format_zip_xz_multi) 700 { 701 const char *refname = "test_read_format_zip_xz_multi.zipx"; 702 struct archive *a; 703 struct archive_entry *ae; 704 705 extract_reference_file(refname); 706 707 assert((a = archive_read_new()) != NULL); 708 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 709 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 710 711 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 712 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a)); 713 assertEqualString("bash.bashrc", archive_entry_pathname(ae)); 714 assertEqualIntA(a, 0, extract_one(a, ae, 0xF751B8C9)); 715 716 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 717 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a)); 718 assertEqualString("pacman.conf", archive_entry_pathname(ae)); 719 assertEqualIntA(a, 0, extract_one(a, ae, 0xB20B7F88)); 720 721 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 722 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a)); 723 assertEqualString("profile", archive_entry_pathname(ae)); 724 assertEqualIntA(a, 0, extract_one(a, ae, 0x2329F054)); 725 726 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 727 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 728 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 729 } 730 731 DEFINE_TEST(test_read_format_zip_xz_multi_blockread) 732 { 733 const char *refname = "test_read_format_zip_xz_multi.zipx"; 734 struct archive *a; 735 struct archive_entry *ae; 736 737 extract_reference_file(refname); 738 739 assert((a = archive_read_new()) != NULL); 740 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 741 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 742 743 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 744 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a)); 745 assertEqualString("bash.bashrc", archive_entry_pathname(ae)); 746 assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0xF751B8C9)); 747 748 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 749 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a)); 750 assertEqualString("pacman.conf", archive_entry_pathname(ae)); 751 assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xB20B7F88)); 752 753 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 754 assertEqualString("ZIP 2.0 (xz)", archive_format_name(a)); 755 assertEqualString("profile", archive_entry_pathname(ae)); 756 assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0x2329F054)); 757 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