1 /*- 2 * Copyright (c) 2011 Michihiro NAKAJIMA 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 */ 25 #include "test.h" 26 __FBSDID("$FreeBSD"); 27 28 #if defined(_WIN32) && !defined(__CYGWIN__) 29 #define close _close 30 #define open _open 31 #endif 32 33 #define __LIBARCHIVE_BUILD 34 #include <archive_crc32.h> 35 36 /* 37 * Extract a non-encoded file. 38 * The header of the 7z archive files is not encoded. 39 */ 40 static void 41 test_copy(int use_open_fd) 42 { 43 const char *refname = "test_read_format_7zip_copy.7z"; 44 struct archive_entry *ae; 45 struct archive *a; 46 char buff[128]; 47 int fd = -1; 48 49 extract_reference_file(refname); 50 assert((a = archive_read_new()) != NULL); 51 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 52 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 53 if (use_open_fd) { 54 fd = open(refname, O_RDONLY | O_BINARY); 55 assertEqualIntA(a, ARCHIVE_OK, 56 archive_read_open_fd(a, fd, 10240)); 57 } else { 58 assertEqualIntA(a, ARCHIVE_OK, 59 archive_read_open_filename(a, refname, 10240)); 60 } 61 62 /* Verify regular file1. */ 63 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 64 assertEqualInt((AE_IFREG | 0666), archive_entry_mode(ae)); 65 assertEqualString("file1", archive_entry_pathname(ae)); 66 assertEqualInt(86401, archive_entry_mtime(ae)); 67 assertEqualInt(60, archive_entry_size(ae)); 68 assertEqualInt(archive_entry_is_encrypted(ae), 0); 69 assert(archive_read_has_encrypted_entries(a) > ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED); 70 assertEqualInt(60, archive_read_data(a, buff, sizeof(buff))); 71 assertEqualMem(buff, " ", 4); 72 73 assertEqualInt(1, archive_file_count(a)); 74 75 /* End of archive. */ 76 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 77 78 /* Verify archive format. */ 79 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 80 assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a)); 81 82 /* Close the archive. */ 83 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 84 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 85 if (fd != -1) 86 close(fd); 87 } 88 89 /* 90 * An archive file has no entry. 91 */ 92 static void 93 test_empty_archive(void) 94 { 95 const char *refname = "test_read_format_7zip_empty_archive.7z"; 96 struct archive_entry *ae; 97 struct archive *a; 98 99 extract_reference_file(refname); 100 assert((a = archive_read_new()) != NULL); 101 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 102 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 103 assertEqualIntA(a, ARCHIVE_OK, 104 archive_read_open_filename(a, refname, 10240)); 105 106 /* End of archive. */ 107 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 108 109 assertEqualInt(0, archive_file_count(a)); 110 111 /* Verify archive format. */ 112 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 113 assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a)); 114 115 /* Close the archive. */ 116 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 117 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 118 } 119 120 /* 121 * An archive file has one empty file. It means there is no content 122 * in the archive file except for a header. 123 */ 124 static void 125 test_empty_file(void) 126 { 127 const char *refname = "test_read_format_7zip_empty_file.7z"; 128 struct archive_entry *ae; 129 struct archive *a; 130 131 extract_reference_file(refname); 132 assert((a = archive_read_new()) != NULL); 133 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 134 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 135 assertEqualIntA(a, ARCHIVE_OK, 136 archive_read_open_filename(a, refname, 10240)); 137 138 /* Verify regular empty. */ 139 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 140 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 141 assertEqualString("empty", archive_entry_pathname(ae)); 142 assertEqualInt(86401, archive_entry_mtime(ae)); 143 assertEqualInt(0, archive_entry_size(ae)); 144 assertEqualInt(archive_entry_is_encrypted(ae), 0); 145 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 146 147 assertEqualInt(1, archive_file_count(a)); 148 149 /* End of archive. */ 150 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 151 152 /* Verify archive format. */ 153 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 154 assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a)); 155 156 /* Close the archive. */ 157 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 158 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 159 } 160 161 /* 162 * Extract an encoded file. 163 * The header of the 7z archive files is not encoded. 164 */ 165 static void 166 test_plain_header(const char *refname) 167 { 168 struct archive_entry *ae; 169 struct archive *a; 170 char buff[128]; 171 172 extract_reference_file(refname); 173 assert((a = archive_read_new()) != NULL); 174 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 175 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 176 assertEqualIntA(a, ARCHIVE_OK, 177 archive_read_open_filename(a, refname, 10240)); 178 179 /* Verify regular file1. */ 180 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 181 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 182 assertEqualString("file1", archive_entry_pathname(ae)); 183 assertEqualInt(1322058763, archive_entry_mtime(ae)); 184 assertEqualInt(2844, archive_entry_size(ae)); 185 assertEqualInt(archive_entry_is_encrypted(ae), 0); 186 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 187 assertEqualInt(sizeof(buff), archive_read_data(a, buff, sizeof(buff))); 188 assertEqualMem(buff, "The libarchive distribution ", 28); 189 190 assertEqualInt(1, archive_file_count(a)); 191 192 /* End of archive. */ 193 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 194 195 /* Verify archive format. */ 196 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 197 assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a)); 198 199 /* Close the archive. */ 200 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 201 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 202 } 203 204 /* 205 * Extract multi files. 206 * The header of the 7z archive files is encoded with LZMA. 207 */ 208 static void 209 test_extract_all_files(const char *refname) 210 { 211 struct archive_entry *ae; 212 struct archive *a; 213 char buff[128]; 214 215 extract_reference_file(refname); 216 assert((a = archive_read_new()) != NULL); 217 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 218 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 219 assertEqualIntA(a, ARCHIVE_OK, 220 archive_read_open_filename(a, refname, 10240)); 221 222 /* Verify regular file1. */ 223 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 224 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 225 assertEqualString("dir1/file1", archive_entry_pathname(ae)); 226 assertEqualInt(86401, archive_entry_mtime(ae)); 227 assertEqualInt(13, archive_entry_size(ae)); 228 assertEqualInt(archive_entry_is_encrypted(ae), 0); 229 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 230 assertEqualInt(13, archive_read_data(a, buff, sizeof(buff))); 231 assertEqualMem(buff, "aaaaaaaaaaaa\n", 13); 232 233 /* Verify regular file2. */ 234 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 235 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 236 assertEqualString("file2", archive_entry_pathname(ae)); 237 assertEqualInt(86401, archive_entry_mtime(ae)); 238 assertEqualInt(26, archive_entry_size(ae)); 239 assertEqualInt(archive_entry_is_encrypted(ae), 0); 240 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 241 assertEqualInt(26, archive_read_data(a, buff, sizeof(buff))); 242 assertEqualMem(buff, "aaaaaaaaaaaa\nbbbbbbbbbbbb\n", 26); 243 244 /* Verify regular file3. */ 245 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 246 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 247 assertEqualString("file3", archive_entry_pathname(ae)); 248 assertEqualInt(86401, archive_entry_mtime(ae)); 249 assertEqualInt(39, archive_entry_size(ae)); 250 assertEqualInt(archive_entry_is_encrypted(ae), 0); 251 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 252 assertEqualInt(39, archive_read_data(a, buff, sizeof(buff))); 253 assertEqualMem(buff, "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\n", 39); 254 255 /* Verify regular file4. */ 256 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 257 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 258 assertEqualString("file4", archive_entry_pathname(ae)); 259 assertEqualInt(86401, archive_entry_mtime(ae)); 260 assertEqualInt(52, archive_entry_size(ae)); 261 assertEqualInt(archive_entry_is_encrypted(ae), 0); 262 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 263 assertEqualInt(52, archive_read_data(a, buff, sizeof(buff))); 264 assertEqualMem(buff, 265 "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\ndddddddddddd\n", 52); 266 267 /* Verify directory dir1. */ 268 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 269 assertEqualInt((AE_IFDIR | 0755), archive_entry_mode(ae)); 270 assertEqualString("dir1/", archive_entry_pathname(ae)); 271 assertEqualInt(2764801, archive_entry_mtime(ae)); 272 assertEqualInt(archive_entry_is_encrypted(ae), 0); 273 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 274 275 assertEqualInt(5, archive_file_count(a)); 276 277 /* End of archive. */ 278 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 279 280 /* Verify archive format. */ 281 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 282 assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a)); 283 284 /* Close the archive. */ 285 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 286 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 287 } 288 289 /* 290 * Extract multi files. 291 * Like test_extract_all_files, but with zstandard compression. 292 */ 293 static void 294 test_extract_all_files_zstd(const char *refname) 295 { 296 struct archive_entry *ae; 297 struct archive *a; 298 char buff[128]; 299 300 extract_reference_file(refname); 301 assert((a = archive_read_new()) != NULL); 302 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 303 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 304 assertEqualIntA(a, ARCHIVE_OK, 305 archive_read_open_filename(a, refname, 10240)); 306 307 /* Verify directory dir1. Note that this comes before the dir1/file1 entry in recent versions of 7-Zip. */ 308 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 309 assertEqualInt((AE_IFDIR | 0755), archive_entry_mode(ae)); 310 assertEqualString("dir1/", archive_entry_pathname(ae)); 311 assertEqualInt(2764801, archive_entry_mtime(ae)); 312 assertEqualInt(archive_entry_is_encrypted(ae), 0); 313 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 314 315 /* Verify regular file1. */ 316 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 317 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 318 assertEqualString("dir1/file1", archive_entry_pathname(ae)); 319 assertEqualInt(86401, archive_entry_mtime(ae)); 320 assertEqualInt(13, archive_entry_size(ae)); 321 assertEqualInt(archive_entry_is_encrypted(ae), 0); 322 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 323 assertEqualInt(13, archive_read_data(a, buff, sizeof(buff))); 324 assertEqualMem(buff, "aaaaaaaaaaaa\n", 13); 325 326 /* Verify regular file2. */ 327 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 328 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 329 assertEqualString("file2", archive_entry_pathname(ae)); 330 assertEqualInt(86401, archive_entry_mtime(ae)); 331 assertEqualInt(26, archive_entry_size(ae)); 332 assertEqualInt(archive_entry_is_encrypted(ae), 0); 333 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 334 assertEqualInt(26, archive_read_data(a, buff, sizeof(buff))); 335 assertEqualMem(buff, "aaaaaaaaaaaa\nbbbbbbbbbbbb\n", 26); 336 337 /* Verify regular file3. */ 338 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 339 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 340 assertEqualString("file3", archive_entry_pathname(ae)); 341 assertEqualInt(86401, archive_entry_mtime(ae)); 342 assertEqualInt(39, archive_entry_size(ae)); 343 assertEqualInt(archive_entry_is_encrypted(ae), 0); 344 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 345 assertEqualInt(39, archive_read_data(a, buff, sizeof(buff))); 346 assertEqualMem(buff, "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\n", 39); 347 348 /* Verify regular file4. */ 349 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 350 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 351 assertEqualString("file4", archive_entry_pathname(ae)); 352 assertEqualInt(86401, archive_entry_mtime(ae)); 353 assertEqualInt(52, archive_entry_size(ae)); 354 assertEqualInt(archive_entry_is_encrypted(ae), 0); 355 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 356 assertEqualInt(52, archive_read_data(a, buff, sizeof(buff))); 357 assertEqualMem(buff, 358 "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\ndddddddddddd\n", 52); 359 360 assertEqualInt(5, archive_file_count(a)); 361 362 /* End of archive. */ 363 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 364 365 /* Verify archive format. */ 366 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 367 assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a)); 368 369 /* Close the archive. */ 370 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 371 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 372 } 373 374 /* 375 * Extract file from an archives using ZSTD compression with and without BCJ. 376 */ 377 static void 378 test_extract_file_zstd_bcj_nobjc(const char *refname) 379 { 380 struct archive_entry *ae; 381 struct archive *a; 382 char buff[4096]; 383 uint32_t computed_crc = 0; 384 uint32_t expected_crc = 0xbd66eebc; 385 386 extract_reference_file(refname); 387 assert((a = archive_read_new()) != NULL); 388 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 389 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 390 assertEqualIntA(a, ARCHIVE_OK, 391 archive_read_open_filename(a, refname, 10240)); 392 393 /* Verify regular file: hw. */ 394 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 395 assertEqualInt((AE_IFREG | 0775), archive_entry_mode(ae)); 396 assertEqualString("hw", archive_entry_pathname(ae)); 397 assertEqualInt(1685913368, archive_entry_mtime(ae)); 398 assertEqualInt(15952, archive_entry_size(ae)); 399 assertEqualInt(archive_entry_is_encrypted(ae), 0); 400 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 401 402 for (;;) { 403 la_ssize_t bytes_read = archive_read_data(a, buff, sizeof(buff)); 404 assert(bytes_read >= 0); 405 if (bytes_read == 0) break; 406 computed_crc = crc32(computed_crc, buff, bytes_read); 407 } 408 assertEqualInt(computed_crc, expected_crc); 409 410 assertEqualInt(1, archive_file_count(a)); 411 412 /* End of archive. */ 413 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 414 415 /* Verify archive format. */ 416 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 417 assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a)); 418 419 /* Close the archive. */ 420 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 421 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 422 } 423 424 /* 425 * Extract last file. 426 * The header of the 7z archive files is encoded with LZMA. 427 */ 428 static void 429 test_extract_last_file(const char *refname) 430 { 431 struct archive_entry *ae; 432 struct archive *a; 433 char buff[128]; 434 435 extract_reference_file(refname); 436 assert((a = archive_read_new()) != NULL); 437 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 438 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 439 assertEqualIntA(a, ARCHIVE_OK, 440 archive_read_open_filename(a, refname, 10240)); 441 442 /* Verify regular file1. */ 443 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 444 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 445 assertEqualString("dir1/file1", archive_entry_pathname(ae)); 446 assertEqualInt(86401, archive_entry_mtime(ae)); 447 assertEqualInt(13, archive_entry_size(ae)); 448 assertEqualInt(archive_entry_is_encrypted(ae), 0); 449 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 450 451 /* Verify regular file2. */ 452 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 453 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 454 assertEqualString("file2", archive_entry_pathname(ae)); 455 assertEqualInt(86401, archive_entry_mtime(ae)); 456 assertEqualInt(26, archive_entry_size(ae)); 457 assertEqualInt(archive_entry_is_encrypted(ae), 0); 458 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 459 460 /* Verify regular file3. */ 461 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 462 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 463 assertEqualString("file3", archive_entry_pathname(ae)); 464 assertEqualInt(86401, archive_entry_mtime(ae)); 465 assertEqualInt(39, archive_entry_size(ae)); 466 assertEqualInt(archive_entry_is_encrypted(ae), 0); 467 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 468 469 /* Verify regular file4. */ 470 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 471 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 472 assertEqualString("file4", archive_entry_pathname(ae)); 473 assertEqualInt(86401, archive_entry_mtime(ae)); 474 assertEqualInt(52, archive_entry_size(ae)); 475 assertEqualInt(archive_entry_is_encrypted(ae), 0); 476 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 477 assertEqualInt(52, archive_read_data(a, buff, sizeof(buff))); 478 assertEqualMem(buff, 479 "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\ndddddddddddd\n", 52); 480 481 /* Verify directory dir1. */ 482 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 483 assertEqualInt((AE_IFDIR | 0755), archive_entry_mode(ae)); 484 assertEqualString("dir1/", archive_entry_pathname(ae)); 485 assertEqualInt(2764801, archive_entry_mtime(ae)); 486 assertEqualInt(archive_entry_is_encrypted(ae), 0); 487 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 488 489 assertEqualInt(5, archive_file_count(a)); 490 491 /* End of archive. */ 492 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 493 494 /* Verify archive format. */ 495 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 496 assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a)); 497 498 /* Close the archive. */ 499 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 500 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 501 } 502 503 /* 504 * Extract a mixed archive file which has both LZMA and LZMA2 encoded files. 505 * LZMA: file1, file2, file3, file4 506 * LZMA2: zfile1, zfile2, zfile3, zfile4 507 */ 508 static void 509 test_extract_all_files2(const char *refname) 510 { 511 struct archive_entry *ae; 512 struct archive *a; 513 char buff[128]; 514 515 extract_reference_file(refname); 516 assert((a = archive_read_new()) != NULL); 517 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 518 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 519 assertEqualIntA(a, ARCHIVE_OK, 520 archive_read_open_filename(a, refname, 10240)); 521 522 /* Verify regular file1. */ 523 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 524 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 525 assertEqualString("dir1/file1", archive_entry_pathname(ae)); 526 assertEqualInt(86401, archive_entry_mtime(ae)); 527 assertEqualInt(13, archive_entry_size(ae)); 528 assertEqualInt(archive_entry_is_encrypted(ae), 0); 529 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 530 assertEqualInt(13, archive_read_data(a, buff, sizeof(buff))); 531 assertEqualMem(buff, "aaaaaaaaaaaa\n", 13); 532 533 /* Verify regular file2. */ 534 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 535 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 536 assertEqualString("file2", archive_entry_pathname(ae)); 537 assertEqualInt(86401, archive_entry_mtime(ae)); 538 assertEqualInt(26, archive_entry_size(ae)); 539 assertEqualInt(archive_entry_is_encrypted(ae), 0); 540 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 541 assertEqualInt(26, archive_read_data(a, buff, sizeof(buff))); 542 assertEqualMem(buff, "aaaaaaaaaaaa\nbbbbbbbbbbbb\n", 26); 543 544 /* Verify regular file3. */ 545 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 546 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 547 assertEqualString("file3", archive_entry_pathname(ae)); 548 assertEqualInt(86401, archive_entry_mtime(ae)); 549 assertEqualInt(39, archive_entry_size(ae)); 550 assertEqualInt(archive_entry_is_encrypted(ae), 0); 551 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 552 assertEqualInt(39, archive_read_data(a, buff, sizeof(buff))); 553 assertEqualMem(buff, "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\n", 39); 554 555 /* Verify regular file4. */ 556 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 557 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 558 assertEqualString("file4", archive_entry_pathname(ae)); 559 assertEqualInt(86401, archive_entry_mtime(ae)); 560 assertEqualInt(52, archive_entry_size(ae)); 561 assertEqualInt(archive_entry_is_encrypted(ae), 0); 562 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 563 assertEqualInt(52, archive_read_data(a, buff, sizeof(buff))); 564 assertEqualMem(buff, 565 "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\ndddddddddddd\n", 52); 566 567 /* Verify regular zfile1. */ 568 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 569 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 570 assertEqualString("dir1/zfile1", archive_entry_pathname(ae)); 571 assertEqualInt(5184001, archive_entry_mtime(ae)); 572 assertEqualInt(13, archive_entry_size(ae)); 573 assertEqualInt(archive_entry_is_encrypted(ae), 0); 574 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 575 assertEqualInt(13, archive_read_data(a, buff, sizeof(buff))); 576 assertEqualMem(buff, "aaaaaaaaaaaa\n", 13); 577 578 /* Verify regular zfile2. */ 579 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 580 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 581 assertEqualString("zfile2", archive_entry_pathname(ae)); 582 assertEqualInt(5184001, archive_entry_mtime(ae)); 583 assertEqualInt(26, archive_entry_size(ae)); 584 assertEqualInt(archive_entry_is_encrypted(ae), 0); 585 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 586 assertEqualInt(26, archive_read_data(a, buff, sizeof(buff))); 587 assertEqualMem(buff, "aaaaaaaaaaaa\nbbbbbbbbbbbb\n", 26); 588 589 /* Verify regular zfile3. */ 590 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 591 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 592 assertEqualString("zfile3", archive_entry_pathname(ae)); 593 assertEqualInt(5184001, archive_entry_mtime(ae)); 594 assertEqualInt(39, archive_entry_size(ae)); 595 assertEqualInt(archive_entry_is_encrypted(ae), 0); 596 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 597 assertEqualInt(39, archive_read_data(a, buff, sizeof(buff))); 598 assertEqualMem(buff, "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\n", 39); 599 600 /* Verify regular zfile4. */ 601 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 602 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 603 assertEqualString("zfile4", archive_entry_pathname(ae)); 604 assertEqualInt(5184001, archive_entry_mtime(ae)); 605 assertEqualInt(52, archive_entry_size(ae)); 606 assertEqualInt(archive_entry_is_encrypted(ae), 0); 607 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 608 assertEqualInt(52, archive_read_data(a, buff, sizeof(buff))); 609 assertEqualMem(buff, 610 "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\ndddddddddddd\n", 52); 611 612 /* Verify directory dir1. */ 613 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 614 assertEqualInt((AE_IFDIR | 0755), archive_entry_mode(ae)); 615 assertEqualString("dir1/", archive_entry_pathname(ae)); 616 assertEqualInt(2764801, archive_entry_mtime(ae)); 617 assertEqualInt(archive_entry_is_encrypted(ae), 0); 618 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 619 620 assertEqualInt(9, archive_file_count(a)); 621 622 /* End of archive. */ 623 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 624 625 /* Verify archive format. */ 626 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 627 assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a)); 628 629 /* Close the archive. */ 630 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 631 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 632 } 633 634 /* 635 * Extract a file compressed with DELTA + LZMA[12]. 636 */ 637 static void 638 test_delta_lzma(const char *refname) 639 { 640 struct archive_entry *ae; 641 struct archive *a; 642 size_t remaining; 643 ssize_t bytes; 644 char buff[1024]; 645 646 extract_reference_file(refname); 647 assert((a = archive_read_new()) != NULL); 648 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 649 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 650 assertEqualIntA(a, ARCHIVE_OK, 651 archive_read_open_filename(a, refname, 10240)); 652 653 /* Verify regular file1. */ 654 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 655 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 656 assertEqualString("file1", archive_entry_pathname(ae)); 657 assertEqualInt(172802, archive_entry_mtime(ae)); 658 assertEqualInt(27627, archive_entry_size(ae)); 659 assertEqualInt(archive_entry_is_encrypted(ae), 0); 660 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 661 remaining = (size_t)archive_entry_size(ae); 662 while (remaining) { 663 if (remaining < sizeof(buff)) 664 assertEqualInt(remaining, 665 bytes = archive_read_data(a, buff, sizeof(buff))); 666 else 667 assertEqualInt(sizeof(buff), 668 bytes = archive_read_data(a, buff, sizeof(buff))); 669 if (bytes > 0) 670 remaining -= bytes; 671 else 672 break; 673 } 674 assertEqualInt(0, remaining); 675 676 assertEqualInt(1, archive_file_count(a)); 677 678 /* End of archive. */ 679 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 680 681 /* Verify archive format. */ 682 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 683 assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a)); 684 685 /* Close the archive. */ 686 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 687 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 688 } 689 690 /* 691 * Extract a file compressed with BCJ + LZMA2. 692 */ 693 static void 694 test_bcj(const char *refname) 695 { 696 struct archive_entry *ae; 697 struct archive *a; 698 size_t remaining; 699 ssize_t bytes; 700 char buff[1024]; 701 702 extract_reference_file(refname); 703 assert((a = archive_read_new()) != NULL); 704 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 705 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 706 assertEqualIntA(a, ARCHIVE_OK, 707 archive_read_open_filename(a, refname, 10240)); 708 709 /* Verify regular x86exe. */ 710 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 711 assertEqualInt((AE_IFREG | 0444), archive_entry_mode(ae) & ~0111); 712 assertEqualString("x86exe", archive_entry_pathname(ae)); 713 assertEqualInt(172802, archive_entry_mtime(ae)); 714 assertEqualInt(27328, archive_entry_size(ae)); 715 assertEqualInt(archive_entry_is_encrypted(ae), 0); 716 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 717 remaining = (size_t)archive_entry_size(ae); 718 while (remaining) { 719 if (remaining < sizeof(buff)) 720 assertEqualInt(remaining, 721 bytes = archive_read_data(a, buff, sizeof(buff))); 722 else 723 assertEqualInt(sizeof(buff), 724 bytes = archive_read_data(a, buff, sizeof(buff))); 725 if (bytes > 0) 726 remaining -= bytes; 727 else 728 break; 729 } 730 assertEqualInt(0, remaining); 731 732 assertEqualInt(1, archive_file_count(a)); 733 734 /* End of archive. */ 735 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 736 737 /* Verify archive format. */ 738 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 739 assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a)); 740 741 /* Close the archive. */ 742 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 743 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 744 } 745 746 /* 747 * Extract a file compressed with PPMd. 748 */ 749 static void 750 test_ppmd(void) 751 { 752 const char *refname = "test_read_format_7zip_ppmd.7z"; 753 struct archive_entry *ae; 754 struct archive *a; 755 size_t remaining; 756 ssize_t bytes; 757 char buff[1024]; 758 759 extract_reference_file(refname); 760 assert((a = archive_read_new()) != NULL); 761 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 762 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 763 assertEqualIntA(a, ARCHIVE_OK, 764 archive_read_open_filename(a, refname, 10240)); 765 766 /* Verify regular file1. */ 767 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 768 assertEqualInt((AE_IFREG | 0666), archive_entry_mode(ae)); 769 assertEqualString("ppmd_test.txt", archive_entry_pathname(ae)); 770 assertEqualInt(1322464589, archive_entry_mtime(ae)); 771 assertEqualInt(102400, archive_entry_size(ae)); 772 assertEqualInt(archive_entry_is_encrypted(ae), 0); 773 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 774 remaining = (size_t)archive_entry_size(ae); 775 while (remaining) { 776 if (remaining < sizeof(buff)) 777 assertEqualInt(remaining, 778 bytes = archive_read_data(a, buff, sizeof(buff))); 779 else 780 assertEqualInt(sizeof(buff), 781 bytes = archive_read_data(a, buff, sizeof(buff))); 782 if (bytes > 0) 783 remaining -= bytes; 784 else 785 break; 786 } 787 assertEqualInt(0, remaining); 788 789 assertEqualInt(1, archive_file_count(a)); 790 791 /* End of archive. */ 792 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 793 794 /* Verify archive format. */ 795 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 796 assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a)); 797 798 /* Close the archive. */ 799 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 800 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 801 } 802 803 static void 804 test_symname(void) 805 { 806 const char *refname = "test_read_format_7zip_symbolic_name.7z"; 807 struct archive_entry *ae; 808 struct archive *a; 809 char buff[128]; 810 811 extract_reference_file(refname); 812 assert((a = archive_read_new()) != NULL); 813 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 814 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 815 assertEqualIntA(a, ARCHIVE_OK, 816 archive_read_open_filename(a, refname, 10240)); 817 818 /* Verify regular file1. */ 819 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 820 assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae)); 821 assertEqualString("file1", archive_entry_pathname(ae)); 822 assertEqualInt(86401, archive_entry_mtime(ae)); 823 assertEqualInt(32, archive_entry_size(ae)); 824 assertEqualInt(archive_entry_is_encrypted(ae), 0); 825 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 826 assertEqualInt(32, archive_read_data(a, buff, sizeof(buff))); 827 assertEqualMem(buff, "hellohellohello\nhellohellohello\n", 32); 828 829 /* Verify symbolic-link symlinkfile. */ 830 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 831 assertEqualInt((AE_IFLNK | 0755), archive_entry_mode(ae)); 832 assertEqualString("symlinkfile", archive_entry_pathname(ae)); 833 assertEqualString("file1", archive_entry_symlink(ae)); 834 assertEqualInt(86401, archive_entry_mtime(ae)); 835 assertEqualInt(archive_entry_is_encrypted(ae), 0); 836 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 837 838 assertEqualInt(2, archive_file_count(a)); 839 840 /* End of archive. */ 841 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 842 843 /* Verify archive format. */ 844 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 845 assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a)); 846 847 /* Close the archive. */ 848 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 849 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 850 } 851 852 853 DEFINE_TEST(test_read_format_7zip) 854 { 855 struct archive *a; 856 857 assert((a = archive_read_new()) != NULL); 858 859 /* Extracting with liblzma */ 860 if (ARCHIVE_OK != archive_read_support_filter_xz(a)) { 861 skipping("7zip:lzma decoding is not supported on this " 862 "platform"); 863 } else { 864 test_symname(); 865 test_extract_all_files("test_read_format_7zip_copy_2.7z"); 866 test_extract_last_file("test_read_format_7zip_copy_2.7z"); 867 test_extract_all_files2("test_read_format_7zip_lzma1_lzma2.7z"); 868 test_bcj("test_read_format_7zip_bcj2_copy_lzma.7z"); 869 } 870 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 871 } 872 873 DEFINE_TEST(test_read_format_7zip_bzip2) 874 { 875 struct archive *a; 876 877 assert((a = archive_read_new()) != NULL); 878 879 /* Extracting with libbzip2 */ 880 if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) { 881 skipping("7zip:bzip2 decoding is not supported on this platform"); 882 } else { 883 test_plain_header("test_read_format_7zip_bzip2.7z"); 884 test_bcj("test_read_format_7zip_bcj_bzip2.7z"); 885 test_bcj("test_read_format_7zip_bcj2_bzip2.7z"); 886 } 887 888 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 889 } 890 891 DEFINE_TEST(test_read_format_7zip_from_fd) 892 { 893 test_copy(1);/* read a 7zip file from a file descriptor. */ 894 } 895 896 DEFINE_TEST(test_read_format_7zip_copy) 897 { 898 test_copy(0); 899 test_bcj("test_read_format_7zip_bcj_copy.7z"); 900 test_bcj("test_read_format_7zip_bcj2_copy_1.7z"); 901 test_bcj("test_read_format_7zip_bcj2_copy_2.7z"); 902 } 903 904 DEFINE_TEST(test_read_format_7zip_deflate) 905 { 906 struct archive *a; 907 908 assert((a = archive_read_new()) != NULL); 909 910 /* Extracting with libz */ 911 if (ARCHIVE_OK != archive_read_support_filter_gzip(a)) { 912 skipping( 913 "7zip:deflate decoding is not supported on this platform"); 914 } else { 915 test_plain_header("test_read_format_7zip_deflate.7z"); 916 test_bcj("test_read_format_7zip_bcj_deflate.7z"); 917 test_bcj("test_read_format_7zip_bcj2_deflate.7z"); 918 } 919 920 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 921 } 922 923 DEFINE_TEST(test_read_format_7zip_zstd) 924 { 925 struct archive *a; 926 927 assert((a = archive_read_new()) != NULL); 928 929 /* Extracting with libzstd */ 930 if (ARCHIVE_OK != archive_read_support_filter_zstd(a)) { 931 skipping( 932 "7zip:zstd decoding is not supported on this platform"); 933 } else { 934 test_extract_all_files_zstd("test_read_format_7zip_zstd.7z"); 935 } 936 937 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 938 } 939 940 DEFINE_TEST(test_read_format_7zip_zstd_solid) 941 { 942 struct archive *a; 943 944 assert((a = archive_read_new()) != NULL); 945 946 /* Extracting with libzstd */ 947 if (ARCHIVE_OK != archive_read_support_filter_zstd(a)) { 948 skipping( 949 "7zip:zstd decoding is not supported on this platform"); 950 } else { 951 test_extract_all_files_zstd("test_read_format_7zip_solid_zstd.7z"); 952 } 953 954 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 955 } 956 957 DEFINE_TEST(test_read_format_7zip_zstd_bcj) 958 { 959 struct archive *a; 960 961 assert((a = archive_read_new()) != NULL); 962 963 /* Extracting with libzstd */ 964 if (ARCHIVE_OK != archive_read_support_filter_zstd(a)) { 965 skipping( 966 "7zip:zstd decoding is not supported on this platform"); 967 } else { 968 test_extract_file_zstd_bcj_nobjc("test_read_format_7zip_zstd_bcj.7z"); 969 } 970 971 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 972 } 973 974 DEFINE_TEST(test_read_format_7zip_zstd_nobcj) 975 { 976 struct archive *a; 977 978 assert((a = archive_read_new()) != NULL); 979 980 /* Extracting with libzstd */ 981 if (ARCHIVE_OK != archive_read_support_filter_zstd(a)) { 982 skipping( 983 "7zip:zstd decoding is not supported on this platform"); 984 } else { 985 test_extract_file_zstd_bcj_nobjc("test_read_format_7zip_zstd_nobcj.7z"); 986 } 987 988 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 989 } 990 991 DEFINE_TEST(test_read_format_7zip_empty) 992 { 993 test_empty_archive(); 994 test_empty_file(); 995 } 996 997 DEFINE_TEST(test_read_format_7zip_lzma1) 998 { 999 struct archive *a; 1000 1001 assert((a = archive_read_new()) != NULL); 1002 1003 /* Extracting with liblzma */ 1004 if (ARCHIVE_OK != archive_read_support_filter_xz(a)) { 1005 skipping("7zip:lzma decoding is not supported on this " 1006 "platform"); 1007 } else { 1008 test_plain_header("test_read_format_7zip_lzma1.7z"); 1009 test_extract_all_files("test_read_format_7zip_lzma1_2.7z"); 1010 test_extract_last_file("test_read_format_7zip_lzma1_2.7z"); 1011 test_bcj("test_read_format_7zip_bcj_lzma1.7z"); 1012 test_bcj("test_read_format_7zip_bcj2_lzma1_1.7z"); 1013 test_bcj("test_read_format_7zip_bcj2_lzma1_2.7z"); 1014 test_delta_lzma("test_read_format_7zip_delta_lzma1.7z"); 1015 test_delta_lzma("test_read_format_7zip_delta4_lzma1.7z"); 1016 } 1017 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 1018 } 1019 1020 DEFINE_TEST(test_read_format_7zip_lzma2) 1021 { 1022 struct archive *a; 1023 1024 assert((a = archive_read_new()) != NULL); 1025 1026 /* Extracting with liblzma */ 1027 if (ARCHIVE_OK != archive_read_support_filter_xz(a)) { 1028 skipping("7zip:lzma decoding is not supported on this " 1029 "platform"); 1030 } else { 1031 test_plain_header("test_read_format_7zip_lzma2.7z"); 1032 test_bcj("test_read_format_7zip_bcj_lzma2.7z"); 1033 test_bcj("test_read_format_7zip_bcj2_lzma2_1.7z"); 1034 test_bcj("test_read_format_7zip_bcj2_lzma2_2.7z"); 1035 test_delta_lzma("test_read_format_7zip_delta_lzma2.7z"); 1036 test_delta_lzma("test_read_format_7zip_delta4_lzma2.7z"); 1037 } 1038 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 1039 } 1040 1041 static void 1042 test_arm_filter(const char *refname) 1043 { 1044 struct archive *a; 1045 struct archive_entry *ae; 1046 char buff[7804]; 1047 uint32_t computed_crc = 0; 1048 uint32_t expected_crc = 0x355ec4e1; 1049 1050 assert((a = archive_read_new()) != NULL); 1051 1052 extract_reference_file(refname); 1053 1054 assert((a = archive_read_new()) != NULL); 1055 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 1056 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 1057 1058 assertEqualIntA(a, ARCHIVE_OK, 1059 archive_read_open_filename(a, refname, 10240)); 1060 1061 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 1062 assertEqualInt((AE_IFREG | 0755), archive_entry_mode(ae)); 1063 assertEqualString("hw-gnueabihf", archive_entry_pathname(ae)); 1064 assertEqualInt(sizeof(buff), archive_entry_size(ae)); 1065 assertEqualInt(sizeof(buff), archive_read_data(a, buff, sizeof(buff))); 1066 computed_crc = crc32(computed_crc, buff, sizeof(buff)); 1067 assertEqualInt(computed_crc, expected_crc); 1068 1069 assertEqualInt(1, archive_file_count(a)); 1070 1071 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 1072 1073 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 1074 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 1075 } 1076 1077 DEFINE_TEST(test_read_format_7zip_zstd_arm) 1078 { 1079 struct archive *a; 1080 1081 assert((a = archive_read_new()) != NULL); 1082 1083 if (ARCHIVE_OK != archive_read_support_filter_zstd(a)) { 1084 skipping( 1085 "7zip:zstd decoding is not supported on this platform"); 1086 } else { 1087 test_arm_filter("test_read_format_7zip_zstd_arm.7z"); 1088 } 1089 1090 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 1091 } 1092 1093 DEFINE_TEST(test_read_format_7zip_lzma2_arm) 1094 { 1095 struct archive *a; 1096 1097 assert((a = archive_read_new()) != NULL); 1098 1099 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) { 1100 skipping( 1101 "7zip:lzma decoding is not supported on this platform"); 1102 } else { 1103 test_arm_filter("test_read_format_7zip_lzma2_arm.7z"); 1104 } 1105 1106 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 1107 } 1108 1109 DEFINE_TEST(test_read_format_7zip_ppmd) 1110 { 1111 test_ppmd(); 1112 } 1113 1114 static void 1115 test_arm64_filter(const char *refname) 1116 { 1117 struct archive *a; 1118 struct archive_entry *ae; 1119 char buff[70368]; 1120 uint32_t computed_crc = 0; 1121 uint32_t expected_crc = 0xde97d594; 1122 1123 assert((a = archive_read_new()) != NULL); 1124 1125 extract_reference_file(refname); 1126 1127 assert((a = archive_read_new()) != NULL); 1128 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 1129 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 1130 1131 assertEqualIntA(a, ARCHIVE_OK, 1132 archive_read_open_filename(a, refname, 10240)); 1133 1134 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 1135 assertEqualInt((AE_IFREG | 0775), archive_entry_mode(ae)); 1136 assertEqualString("hw-arm64", archive_entry_pathname(ae)); 1137 assertEqualInt(sizeof(buff), archive_entry_size(ae)); 1138 assertEqualInt(sizeof(buff), archive_read_data(a, buff, sizeof(buff))); 1139 computed_crc = crc32(computed_crc, buff, sizeof(buff)); 1140 assertEqualInt(computed_crc, expected_crc); 1141 1142 assertEqualInt(1, archive_file_count(a)); 1143 1144 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 1145 1146 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 1147 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 1148 } 1149 1150 DEFINE_TEST(test_read_format_7zip_lzma2_arm64) 1151 { 1152 #ifdef HAVE_LZMA_FILTER_ARM64 1153 struct archive *a; 1154 1155 assert((a = archive_read_new()) != NULL); 1156 1157 if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) { 1158 skipping( 1159 "7zip:lzma decoding is not supported on this platform"); 1160 } else { 1161 test_arm64_filter("test_read_format_7zip_lzma2_arm64.7z"); 1162 } 1163 1164 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 1165 #else 1166 skipping("This version of liblzma does not support LZMA_FILTER_ARM64"); 1167 #endif 1168 } 1169 1170 DEFINE_TEST(test_read_format_7zip_deflate_arm64) 1171 { 1172 struct archive *a; 1173 1174 assert((a = archive_read_new()) != NULL); 1175 1176 if (ARCHIVE_OK != archive_read_support_filter_gzip(a)) { 1177 skipping( 1178 "7zip:deflate decoding is not supported on this platform"); 1179 } else { 1180 test_arm64_filter("test_read_format_7zip_deflate_arm64.7z"); 1181 } 1182 1183 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 1184 } 1185