1228753Smm/*- 2228753Smm * Copyright (c) 2003-2007 Tim Kientzle 3232153Smm * Copyright (c) 2011 Michihiro NAKAJIMA 4228753Smm * All rights reserved. 5228753Smm * 6228753Smm * Redistribution and use in source and binary forms, with or without 7228753Smm * modification, are permitted provided that the following conditions 8228753Smm * are met: 9228753Smm * 1. Redistributions of source code must retain the above copyright 10228753Smm * notice, this list of conditions and the following disclaimer. 11228753Smm * 2. Redistributions in binary form must reproduce the above copyright 12228753Smm * notice, this list of conditions and the following disclaimer in the 13228753Smm * documentation and/or other materials provided with the distribution. 14228753Smm * 15228753Smm * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 16228753Smm * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17228753Smm * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18228753Smm * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 19228753Smm * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20228753Smm * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21228753Smm * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22228753Smm * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23228753Smm * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24228753Smm * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25228753Smm */ 26228753Smm#include "test.h" 27228763Smm__FBSDID("$FreeBSD: stable/10/contrib/libarchive/libarchive/test/test_read_format_zip.c 368708 2020-12-16 22:25:40Z mm $"); 28228753Smm 29344674Smm#define __LIBARCHIVE_BUILD 30344674Smm#include <archive_crc32.h> 31344674Smm 32344674Smmstatic 33344674Smmint extract_one(struct archive* a, struct archive_entry* ae, uint32_t crc) 34344674Smm{ 35348608Smm la_ssize_t fsize, bytes_read; 36348608Smm uint8_t* buf; 37348608Smm int ret = 1; 38348608Smm uint32_t computed_crc; 39344674Smm 40348608Smm fsize = (la_ssize_t) archive_entry_size(ae); 41348608Smm buf = malloc(fsize); 42348608Smm if(buf == NULL) 43348608Smm return 1; 44344674Smm 45348608Smm bytes_read = archive_read_data(a, buf, fsize); 46348608Smm if(bytes_read != fsize) { 47348608Smm assertEqualInt(bytes_read, fsize); 48348608Smm goto fn_exit; 49348608Smm } 50344674Smm 51348608Smm computed_crc = crc32(0, buf, fsize); 52348608Smm assertEqualInt(computed_crc, crc); 53348608Smm ret = 0; 54344674Smm 55344674Smmfn_exit: 56348608Smm free(buf); 57348608Smm return ret; 58344674Smm} 59344674Smm 60344674Smmstatic 61344674Smmint extract_one_using_blocks(struct archive* a, int block_size, uint32_t crc) 62344674Smm{ 63344674Smm uint8_t* buf; 64344674Smm int ret = 1; 65344674Smm uint32_t computed_crc = 0; 66344674Smm la_ssize_t bytes_read; 67344674Smm 68344674Smm buf = malloc(block_size); 69344674Smm if(buf == NULL) 70344674Smm return 1; 71344674Smm 72344674Smm while(1) { 73344674Smm bytes_read = archive_read_data(a, buf, block_size); 74344674Smm if(bytes_read == ARCHIVE_RETRY) 75344674Smm continue; 76344674Smm else if(bytes_read == 0) 77344674Smm break; 78344674Smm else if(bytes_read < 0) { 79344674Smm /* If we're here, it means the decompressor has failed 80344674Smm * to properly decode test file. */ 81344674Smm assertA(0); 82344674Smm ret = 1; 83344674Smm goto fn_exit; 84344674Smm } else { 85344674Smm /* ok */ 86344674Smm } 87344674Smm 88344674Smm computed_crc = crc32(computed_crc, buf, bytes_read); 89344674Smm } 90344674Smm 91344674Smm assertEqualInt(computed_crc, crc); 92344674Smm ret = 0; 93344674Smm 94344674Smmfn_exit: 95344674Smm free(buf); 96344674Smm return ret; 97344674Smm} 98344674Smm 99228753Smm/* 100228753Smm * The reference file for this has been manually tweaked so that: 101228753Smm * * file2 has length-at-end but file1 does not 102228753Smm * * file2 has an invalid CRC 103228753Smm */ 104232153Smmstatic void 105232153Smmverify_basic(struct archive *a, int seek_checks) 106228753Smm{ 107228753Smm struct archive_entry *ae; 108228753Smm char *buff[128]; 109228753Smm const void *pv; 110228753Smm size_t s; 111232153Smm int64_t o; 112228753Smm 113232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 114348608Smm assertEqualString("ZIP 1.0 (uncompressed)", archive_format_name(a)); 115228753Smm assertEqualString("dir/", archive_entry_pathname(ae)); 116228753Smm assertEqualInt(1179604249, archive_entry_mtime(ae)); 117228753Smm assertEqualInt(0, archive_entry_size(ae)); 118232153Smm if (seek_checks) 119232153Smm assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae)); 120302001Smm assertEqualInt(archive_entry_is_encrypted(ae), 0); 121302001Smm assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 122228753Smm assertEqualIntA(a, ARCHIVE_EOF, 123228753Smm archive_read_data_block(a, &pv, &s, &o)); 124228753Smm assertEqualInt((int)s, 0); 125232153Smm 126232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 127348608Smm assertEqualString("ZIP 2.0 (deflation)", archive_format_name(a)); 128228753Smm assertEqualString("file1", archive_entry_pathname(ae)); 129228753Smm assertEqualInt(1179604289, archive_entry_mtime(ae)); 130232153Smm if (seek_checks) 131232153Smm assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae)); 132228753Smm assertEqualInt(18, archive_entry_size(ae)); 133302001Smm assertEqualInt(archive_entry_is_encrypted(ae), 0); 134302001Smm assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 135228753Smm failure("archive_read_data() returns number of bytes read"); 136302001Smm if (archive_zlib_version() != NULL) { 137232153Smm assertEqualInt(18, archive_read_data(a, buff, 19)); 138232153Smm assertEqualMem(buff, "hello\nhello\nhello\n", 18); 139232153Smm } else { 140232153Smm assertEqualInt(ARCHIVE_FAILED, archive_read_data(a, buff, 19)); 141232153Smm assertEqualString(archive_error_string(a), 142353377Smm "Unsupported ZIP compression method (8: deflation)"); 143232153Smm assert(archive_errno(a) != 0); 144228753Smm } 145232153Smm 146232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 147348608Smm assertEqualString("ZIP 2.0 (deflation)", archive_format_name(a)); 148228753Smm assertEqualString("file2", archive_entry_pathname(ae)); 149228753Smm assertEqualInt(1179605932, archive_entry_mtime(ae)); 150302001Smm assertEqualInt(archive_entry_is_encrypted(ae), 0); 151302001Smm assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 152232153Smm if (seek_checks) { 153232153Smm assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae)); 154232153Smm } 155302001Smm assert(archive_entry_size_is_set(ae)); 156302001Smm assertEqualInt(18, archive_entry_size(ae)); 157302001Smm if (archive_zlib_version() != NULL) { 158232153Smm failure("file2 has a bad CRC, so read should fail and not change buff"); 159232153Smm memset(buff, 'a', 19); 160232153Smm assertEqualInt(ARCHIVE_WARN, archive_read_data(a, buff, 19)); 161232153Smm assertEqualMem(buff, "aaaaaaaaaaaaaaaaaaa", 19); 162232153Smm } else { 163232153Smm assertEqualInt(ARCHIVE_FAILED, archive_read_data(a, buff, 19)); 164232153Smm assertEqualString(archive_error_string(a), 165353377Smm "Unsupported ZIP compression method (8: deflation)"); 166232153Smm assert(archive_errno(a) != 0); 167232153Smm } 168232153Smm assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &ae)); 169348608Smm assertEqualString("ZIP 2.0 (deflation)", archive_format_name(a)); 170232153Smm /* Verify the number of files read. */ 171232153Smm failure("the archive file has three files"); 172232153Smm assertEqualInt(3, archive_file_count(a)); 173248616Smm assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 174232153Smm assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 175232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 176232153Smm assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 177228753Smm} 178228753Smm 179232153Smmstatic void 180232153Smmtest_basic(void) 181232153Smm{ 182232153Smm const char *refname = "test_read_format_zip.zip"; 183232153Smm struct archive *a; 184232153Smm char *p; 185232153Smm size_t s; 186228753Smm 187232153Smm extract_reference_file(refname); 188232153Smm 189232153Smm /* Verify with seeking reader. */ 190232153Smm assert((a = archive_read_new()) != NULL); 191232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 192232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 193232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 10240)); 194232153Smm verify_basic(a, 1); 195232153Smm 196232153Smm /* Verify with streaming reader. */ 197358090Smm p = slurpfile(&s, "%s", refname); 198232153Smm assert((a = archive_read_new()) != NULL); 199232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 200232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 201232153Smm assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, p, s, 31)); 202232153Smm verify_basic(a, 0); 203313571Smm free(p); 204232153Smm} 205232153Smm 206232153Smm/* 207232153Smm * Read Info-ZIP New Unix Extra Field 0x7875 "ux". 208232153Smm * Currently stores Unix UID/GID up to 32 bits. 209232153Smm */ 210232153Smmstatic void 211232153Smmverify_info_zip_ux(struct archive *a, int seek_checks) 212232153Smm{ 213232153Smm struct archive_entry *ae; 214232153Smm char *buff[128]; 215232153Smm 216232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 217232153Smm assertEqualString("file1", archive_entry_pathname(ae)); 218232153Smm assertEqualInt(1300668680, archive_entry_mtime(ae)); 219232153Smm assertEqualInt(18, archive_entry_size(ae)); 220302001Smm assertEqualInt(archive_entry_is_encrypted(ae), 0); 221302001Smm assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 222232153Smm if (seek_checks) 223232153Smm assertEqualInt(AE_IFREG | 0644, archive_entry_mode(ae)); 224232153Smm failure("zip reader should read Info-ZIP New Unix Extra Field"); 225232153Smm assertEqualInt(1001, archive_entry_uid(ae)); 226232153Smm assertEqualInt(1001, archive_entry_gid(ae)); 227302001Smm if (archive_zlib_version() != NULL) { 228232153Smm failure("archive_read_data() returns number of bytes read"); 229232153Smm assertEqualInt(18, archive_read_data(a, buff, 19)); 230232153Smm assertEqualMem(buff, "hello\nhello\nhello\n", 18); 231232153Smm } else { 232232153Smm assertEqualInt(ARCHIVE_FAILED, archive_read_data(a, buff, 19)); 233232153Smm assertEqualString(archive_error_string(a), 234353377Smm "Unsupported ZIP compression method (8: deflation)"); 235232153Smm assert(archive_errno(a) != 0); 236232153Smm } 237232153Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 238232153Smm 239232153Smm /* Verify the number of files read. */ 240232153Smm failure("the archive file has just one file"); 241232153Smm assertEqualInt(1, archive_file_count(a)); 242232153Smm 243248616Smm assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0)); 244232153Smm assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a)); 245232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 246232153Smm assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 247232153Smm} 248232153Smm 249232153Smmstatic void 250232153Smmtest_info_zip_ux(void) 251232153Smm{ 252232153Smm const char *refname = "test_read_format_zip_ux.zip"; 253232153Smm struct archive *a; 254232153Smm char *p; 255232153Smm size_t s; 256232153Smm 257232153Smm extract_reference_file(refname); 258232153Smm 259232153Smm /* Verify with seeking reader. */ 260232153Smm assert((a = archive_read_new()) != NULL); 261232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 262232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 263232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 10240)); 264232153Smm verify_info_zip_ux(a, 1); 265232153Smm 266232153Smm /* Verify with streaming reader. */ 267358090Smm p = slurpfile(&s, "%s", refname); 268232153Smm assert((a = archive_read_new()) != NULL); 269232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 270232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 271232153Smm assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, p, s, 108)); 272232153Smm verify_info_zip_ux(a, 0); 273313571Smm free(p); 274232153Smm} 275232153Smm 276232153Smm/* 277232153Smm * Verify that test_read_extract correctly works with 278232153Smm * Zip entries that use length-at-end. 279232153Smm */ 280232153Smmstatic void 281232153Smmverify_extract_length_at_end(struct archive *a, int seek_checks) 282232153Smm{ 283232153Smm struct archive_entry *ae; 284232153Smm 285232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 286232153Smm 287302001Smm assertEqualInt(archive_entry_is_encrypted(ae), 0); 288302001Smm assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 289232153Smm assertEqualString("hello.txt", archive_entry_pathname(ae)); 290232153Smm if (seek_checks) { 291232153Smm assertEqualInt(AE_IFREG | 0644, archive_entry_mode(ae)); 292232153Smm assert(archive_entry_size_is_set(ae)); 293232153Smm assertEqualInt(6, archive_entry_size(ae)); 294232153Smm } else { 295232153Smm assert(!archive_entry_size_is_set(ae)); 296232153Smm assertEqualInt(0, archive_entry_size(ae)); 297232153Smm } 298232153Smm 299302001Smm if (archive_zlib_version() != NULL) { 300232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_extract(a, ae, 0)); 301232153Smm assertFileContents("hello\x0A", 6, "hello.txt"); 302232153Smm } else { 303232153Smm assertEqualIntA(a, ARCHIVE_FAILED, archive_read_extract(a, ae, 0)); 304232153Smm assertEqualString(archive_error_string(a), 305353377Smm "Unsupported ZIP compression method (8: deflation)"); 306232153Smm assert(archive_errno(a) != 0); 307232153Smm } 308232153Smm 309232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 310232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 311232153Smm} 312232153Smm 313232153Smmstatic void 314232153Smmtest_extract_length_at_end(void) 315232153Smm{ 316232153Smm const char *refname = "test_read_format_zip_length_at_end.zip"; 317232153Smm char *p; 318232153Smm size_t s; 319232153Smm struct archive *a; 320232153Smm 321232153Smm extract_reference_file(refname); 322232153Smm 323232153Smm /* Verify extraction with seeking reader. */ 324232153Smm assert((a = archive_read_new()) != NULL); 325232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 326232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 327232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 10240)); 328232153Smm verify_extract_length_at_end(a, 1); 329232153Smm 330232153Smm /* Verify extraction with streaming reader. */ 331358090Smm p = slurpfile(&s, "%s", refname); 332232153Smm assert((a = archive_read_new()) != NULL); 333232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 334232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 335232153Smm assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, p, s, 108)); 336232153Smm verify_extract_length_at_end(a, 0); 337313571Smm free(p); 338232153Smm} 339232153Smm 340232153Smmstatic void 341232153Smmtest_symlink(void) 342232153Smm{ 343232153Smm const char *refname = "test_read_format_zip_symlink.zip"; 344232153Smm char *p; 345232153Smm size_t s; 346232153Smm struct archive *a; 347232153Smm struct archive_entry *ae; 348232153Smm 349232153Smm extract_reference_file(refname); 350358090Smm p = slurpfile(&s, "%s", refname); 351232153Smm 352232153Smm /* Symlinks can only be extracted with the seeking reader. */ 353232153Smm assert((a = archive_read_new()) != NULL); 354232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 355232153Smm assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, p, s, 1)); 356232153Smm 357232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 358232153Smm assertEqualString("file", archive_entry_pathname(ae)); 359232153Smm assertEqualInt(AE_IFREG, archive_entry_filetype(ae)); 360302001Smm assertEqualInt(archive_entry_is_encrypted(ae), 0); 361302001Smm assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 362232153Smm 363232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 364232153Smm assertEqualString("symlink", archive_entry_pathname(ae)); 365232153Smm assertEqualInt(AE_IFLNK, archive_entry_filetype(ae)); 366232153Smm assertEqualInt(0, archive_entry_size(ae)); 367232153Smm assertEqualString("file", archive_entry_symlink(ae)); 368302001Smm assertEqualInt(archive_entry_is_encrypted(ae), 0); 369302001Smm assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0); 370232153Smm 371232153Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 372232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 373232153Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 374313571Smm 375313571Smm free(p); 376232153Smm} 377232153Smm 378232153SmmDEFINE_TEST(test_read_format_zip) 379232153Smm{ 380232153Smm test_basic(); 381232153Smm test_info_zip_ux(); 382232153Smm test_extract_length_at_end(); 383232153Smm test_symlink(); 384232153Smm} 385344674Smm 386344674SmmDEFINE_TEST(test_read_format_zip_ppmd_one_file) 387344674Smm{ 388344674Smm const char *refname = "test_read_format_zip_ppmd8.zipx"; 389344674Smm struct archive *a; 390344674Smm struct archive_entry *ae; 391344674Smm 392344674Smm extract_reference_file(refname); 393344674Smm 394344674Smm assert((a = archive_read_new()) != NULL); 395344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 396344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 397344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 398344674Smm assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 399344674Smm assertEqualString("vimrc", archive_entry_pathname(ae)); 400344674Smm assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA)); 401344674Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 402344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 403344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 404344674Smm} 405344674Smm 406344674SmmDEFINE_TEST(test_read_format_zip_ppmd_one_file_blockread) 407344674Smm{ 408344674Smm const char *refname = "test_read_format_zip_ppmd8.zipx"; 409344674Smm struct archive *a; 410344674Smm struct archive_entry *ae; 411344674Smm 412344674Smm extract_reference_file(refname); 413344674Smm 414344674Smm assert((a = archive_read_new()) != NULL); 415344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 416344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 417344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 418344674Smm assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 419344674Smm assertEqualString("vimrc", archive_entry_pathname(ae)); 420344674Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA)); 421344674Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 422344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 423344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 424344674Smm} 425344674Smm 426344674SmmDEFINE_TEST(test_read_format_zip_ppmd_multi) 427344674Smm{ 428344674Smm const char *refname = "test_read_format_zip_ppmd8_multi.zipx"; 429344674Smm struct archive *a; 430344674Smm struct archive_entry *ae; 431344674Smm 432344674Smm extract_reference_file(refname); 433344674Smm 434344674Smm assert((a = archive_read_new()) != NULL); 435344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 436344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 437344674Smm 438344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 439344674Smm assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 440344674Smm assertEqualString("smartd.conf", archive_entry_pathname(ae)); 441344674Smm assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E)); 442344674Smm 443344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 444344674Smm assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 445344674Smm assertEqualString("ts.conf", archive_entry_pathname(ae)); 446344674Smm assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31)); 447344674Smm 448344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 449344674Smm assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 450344674Smm assertEqualString("vimrc", archive_entry_pathname(ae)); 451344674Smm assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA)); 452344674Smm 453344674Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 454344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 455344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 456344674Smm} 457344674Smm 458344674SmmDEFINE_TEST(test_read_format_zip_ppmd_multi_blockread) 459344674Smm{ 460344674Smm const char *refname = "test_read_format_zip_ppmd8_multi.zipx"; 461344674Smm struct archive *a; 462344674Smm struct archive_entry *ae; 463344674Smm 464344674Smm extract_reference_file(refname); 465344674Smm 466344674Smm assert((a = archive_read_new()) != NULL); 467344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 468344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 469344674Smm 470344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 471344674Smm assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 472344674Smm assertEqualString("smartd.conf", archive_entry_pathname(ae)); 473344674Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E)); 474344674Smm 475344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 476344674Smm assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 477344674Smm assertEqualString("ts.conf", archive_entry_pathname(ae)); 478344674Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31)); 479344674Smm 480344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 481344674Smm assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a)); 482344674Smm assertEqualString("vimrc", archive_entry_pathname(ae)); 483344674Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA)); 484344674Smm 485344674Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 486344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 487344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 488344674Smm} 489344674Smm 490344674SmmDEFINE_TEST(test_read_format_zip_lzma_one_file) 491344674Smm{ 492344674Smm const char *refname = "test_read_format_zip_lzma.zipx"; 493344674Smm struct archive *a; 494344674Smm struct archive_entry *ae; 495344674Smm 496348608Smm assert((a = archive_read_new()) != NULL); 497348608Smm if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) { 498348608Smm skipping("lzma reading not fully supported on this platform"); 499348608Smm assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 500348608Smm return; 501348608Smm } 502344674Smm extract_reference_file(refname); 503344674Smm 504344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 505344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 506344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 507344674Smm assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 508344674Smm assertEqualString("vimrc", archive_entry_pathname(ae)); 509344674Smm assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA)); 510344674Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 511344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 512344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 513344674Smm} 514344674Smm 515344674SmmDEFINE_TEST(test_read_format_zip_lzma_one_file_blockread) 516344674Smm{ 517344674Smm const char *refname = "test_read_format_zip_lzma.zipx"; 518344674Smm struct archive *a; 519344674Smm struct archive_entry *ae; 520344674Smm 521348608Smm assert((a = archive_read_new()) != NULL); 522348608Smm if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) { 523348608Smm skipping("lzma reading not fully supported on this platform"); 524348608Smm assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 525348608Smm return; 526348608Smm } 527344674Smm extract_reference_file(refname); 528344674Smm 529344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 530344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 531344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 532344674Smm assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 533344674Smm assertEqualString("vimrc", archive_entry_pathname(ae)); 534344674Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA)); 535344674Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 536344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 537344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 538344674Smm} 539344674Smm 540344674SmmDEFINE_TEST(test_read_format_zip_lzma_multi) 541344674Smm{ 542344674Smm const char *refname = "test_read_format_zip_lzma_multi.zipx"; 543344674Smm struct archive *a; 544344674Smm struct archive_entry *ae; 545344674Smm 546348608Smm assert((a = archive_read_new()) != NULL); 547348608Smm if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) { 548348608Smm skipping("lzma reading not fully supported on this platform"); 549348608Smm assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 550348608Smm return; 551348608Smm } 552344674Smm extract_reference_file(refname); 553344674Smm 554344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 555344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 556344674Smm 557344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 558344674Smm assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 559344674Smm assertEqualString("smartd.conf", archive_entry_pathname(ae)); 560344674Smm assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E)); 561344674Smm 562344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 563344674Smm assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 564344674Smm assertEqualString("ts.conf", archive_entry_pathname(ae)); 565344674Smm assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31)); 566344674Smm 567344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 568344674Smm assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 569344674Smm assertEqualString("vimrc", archive_entry_pathname(ae)); 570344674Smm assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA)); 571344674Smm 572344674Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 573344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 574344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 575344674Smm} 576344674Smm 577344674SmmDEFINE_TEST(test_read_format_zip_lzma_multi_blockread) 578344674Smm{ 579344674Smm const char *refname = "test_read_format_zip_lzma_multi.zipx"; 580344674Smm struct archive *a; 581344674Smm struct archive_entry *ae; 582344674Smm 583348608Smm assert((a = archive_read_new()) != NULL); 584348608Smm if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) { 585348608Smm skipping("lzma reading not fully supported on this platform"); 586348608Smm assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 587348608Smm return; 588348608Smm } 589344674Smm extract_reference_file(refname); 590344674Smm 591344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 592344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 593344674Smm 594344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 595344674Smm assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 596344674Smm assertEqualString("smartd.conf", archive_entry_pathname(ae)); 597344674Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E)); 598344674Smm 599344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 600344674Smm assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 601344674Smm assertEqualString("ts.conf", archive_entry_pathname(ae)); 602344674Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31)); 603344674Smm 604344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 605344674Smm assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 606344674Smm assertEqualString("vimrc", archive_entry_pathname(ae)); 607344674Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA)); 608344674Smm 609344674Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 610344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 611344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 612344674Smm} 613344674Smm 614344674Smm 615344674SmmDEFINE_TEST(test_read_format_zip_bzip2_one_file) 616344674Smm{ 617344674Smm const char *refname = "test_read_format_zip_bzip2.zipx"; 618344674Smm struct archive *a; 619344674Smm struct archive_entry *ae; 620344674Smm 621348608Smm assert((a = archive_read_new()) != NULL); 622348608Smm if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) { 623348608Smm skipping("bzip2 is not fully supported on this platform"); 624348608Smm archive_read_close(a); 625348608Smm return; 626348608Smm } 627344674Smm extract_reference_file(refname); 628344674Smm 629344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 630344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 631344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 632344674Smm assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 633344674Smm assertEqualString("vimrc", archive_entry_pathname(ae)); 634344674Smm assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA)); 635344674Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 636344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 637344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 638344674Smm} 639344674Smm 640344674SmmDEFINE_TEST(test_read_format_zip_bzip2_one_file_blockread) 641344674Smm{ 642344674Smm const char *refname = "test_read_format_zip_bzip2.zipx"; 643344674Smm struct archive *a; 644344674Smm struct archive_entry *ae; 645344674Smm 646348608Smm assert((a = archive_read_new()) != NULL); 647348608Smm if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) { 648348608Smm skipping("bzip2 is not fully supported on this platform"); 649348608Smm archive_read_close(a); 650348608Smm return; 651348608Smm } 652344674Smm extract_reference_file(refname); 653344674Smm 654344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 655344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 656344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 657344674Smm assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 658344674Smm assertEqualString("vimrc", archive_entry_pathname(ae)); 659344674Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA)); 660344674Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 661344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 662344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 663344674Smm} 664344674Smm 665344674SmmDEFINE_TEST(test_read_format_zip_bzip2_multi) 666344674Smm{ 667344674Smm const char *refname = "test_read_format_zip_bzip2_multi.zipx"; 668344674Smm struct archive *a; 669344674Smm struct archive_entry *ae; 670344674Smm 671348608Smm assert((a = archive_read_new()) != NULL); 672348608Smm if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) { 673348608Smm skipping("bzip2 is not fully supported on this platform"); 674348608Smm archive_read_close(a); 675348608Smm return; 676348608Smm } 677344674Smm extract_reference_file(refname); 678344674Smm 679344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 680344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 681344674Smm 682344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 683344674Smm assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 684344674Smm assertEqualString("smartd.conf", archive_entry_pathname(ae)); 685344674Smm assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E)); 686344674Smm 687344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 688344674Smm assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 689344674Smm assertEqualString("ts.conf", archive_entry_pathname(ae)); 690344674Smm assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31)); 691344674Smm 692344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 693344674Smm assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 694344674Smm assertEqualString("vimrc", archive_entry_pathname(ae)); 695344674Smm assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA)); 696344674Smm 697344674Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 698344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 699344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 700344674Smm} 701344674Smm 702344674SmmDEFINE_TEST(test_read_format_zip_bzip2_multi_blockread) 703344674Smm{ 704344674Smm const char *refname = "test_read_format_zip_bzip2_multi.zipx"; 705344674Smm struct archive *a; 706344674Smm struct archive_entry *ae; 707344674Smm 708348608Smm assert((a = archive_read_new()) != NULL); 709348608Smm if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) { 710348608Smm skipping("bzip2 is not fully supported on this platform"); 711348608Smm archive_read_close(a); 712348608Smm return; 713348608Smm } 714344674Smm extract_reference_file(refname); 715344674Smm 716344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 717344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 718344674Smm 719344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 720344674Smm assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 721344674Smm assertEqualString("smartd.conf", archive_entry_pathname(ae)); 722344674Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E)); 723344674Smm 724344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 725344674Smm assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 726344674Smm assertEqualString("ts.conf", archive_entry_pathname(ae)); 727344674Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31)); 728344674Smm 729344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 730344674Smm assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a)); 731344674Smm assertEqualString("vimrc", archive_entry_pathname(ae)); 732344674Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA)); 733344674Smm 734344674Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 735344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 736344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 737344674Smm} 738344674Smm 739344674SmmDEFINE_TEST(test_read_format_zip_xz_multi) 740344674Smm{ 741344674Smm const char *refname = "test_read_format_zip_xz_multi.zipx"; 742344674Smm struct archive *a; 743344674Smm struct archive_entry *ae; 744344674Smm 745348608Smm assert((a = archive_read_new()) != NULL); 746348608Smm if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) { 747348608Smm skipping("lzma reading not fully supported on this platform"); 748348608Smm assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 749348608Smm return; 750348608Smm } 751344674Smm extract_reference_file(refname); 752344674Smm 753344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 754344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 755344674Smm 756344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 757344674Smm assertEqualString("ZIP 2.0 (xz)", archive_format_name(a)); 758344674Smm assertEqualString("bash.bashrc", archive_entry_pathname(ae)); 759344674Smm assertEqualIntA(a, 0, extract_one(a, ae, 0xF751B8C9)); 760344674Smm 761344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 762344674Smm assertEqualString("ZIP 2.0 (xz)", archive_format_name(a)); 763344674Smm assertEqualString("pacman.conf", archive_entry_pathname(ae)); 764344674Smm assertEqualIntA(a, 0, extract_one(a, ae, 0xB20B7F88)); 765344674Smm 766344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 767344674Smm assertEqualString("ZIP 2.0 (xz)", archive_format_name(a)); 768344674Smm assertEqualString("profile", archive_entry_pathname(ae)); 769344674Smm assertEqualIntA(a, 0, extract_one(a, ae, 0x2329F054)); 770344674Smm 771344674Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 772344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 773344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 774344674Smm} 775344674Smm 776344674SmmDEFINE_TEST(test_read_format_zip_xz_multi_blockread) 777344674Smm{ 778344674Smm const char *refname = "test_read_format_zip_xz_multi.zipx"; 779344674Smm struct archive *a; 780344674Smm struct archive_entry *ae; 781344674Smm 782348608Smm assert((a = archive_read_new()) != NULL); 783348608Smm if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) { 784348608Smm skipping("lzma reading not fully supported on this platform"); 785348608Smm assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 786348608Smm return; 787348608Smm } 788344674Smm extract_reference_file(refname); 789344674Smm 790344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 791344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 792344674Smm 793344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 794344674Smm assertEqualString("ZIP 2.0 (xz)", archive_format_name(a)); 795344674Smm assertEqualString("bash.bashrc", archive_entry_pathname(ae)); 796344674Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0xF751B8C9)); 797344674Smm 798344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 799344674Smm assertEqualString("ZIP 2.0 (xz)", archive_format_name(a)); 800344674Smm assertEqualString("pacman.conf", archive_entry_pathname(ae)); 801344674Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xB20B7F88)); 802344674Smm 803344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 804344674Smm assertEqualString("ZIP 2.0 (xz)", archive_format_name(a)); 805344674Smm assertEqualString("profile", archive_entry_pathname(ae)); 806344674Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0x2329F054)); 807344674Smm 808344674Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 809344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 810344674Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 811344674Smm} 812346105Smm 813346105SmmDEFINE_TEST(test_read_format_zip_ppmd8_crash_1) 814346105Smm{ 815346105Smm const char *refname = "test_read_format_zip_ppmd8_crash_2.zipx"; 816346105Smm struct archive *a; 817346105Smm struct archive_entry *ae; 818346105Smm char buf[64]; 819346105Smm 820346105Smm extract_reference_file(refname); 821346105Smm 822346105Smm assert((a = archive_read_new()) != NULL); 823346105Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 824346105Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 100)); 825346105Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 826346105Smm 827346105Smm /* This file shouldn't be properly decompressed, because it's invalid. 828346105Smm * However, unpacker should return an error during unpacking. Without the 829346105Smm * proper fix, the unpacker was entering an unlimited loop. */ 830346105Smm assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buf, 1)); 831346105Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 832346105Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 833346105Smm} 834346105Smm 835346105SmmDEFINE_TEST(test_read_format_zip_bz2_hang_on_invalid) 836346105Smm{ 837346105Smm const char *refname = "test_read_format_zip_bz2_hang.zip"; 838346105Smm struct archive *a; 839346105Smm struct archive_entry *ae; 840346105Smm char buf[8]; 841346105Smm 842348608Smm assert((a = archive_read_new()) != NULL); 843348608Smm if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) { 844348608Smm skipping("bzip2 is not fully supported on this platform"); 845348608Smm archive_read_close(a); 846348608Smm return; 847348608Smm } 848346105Smm extract_reference_file(refname); 849346105Smm 850346105Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 851346105Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 852346105Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 853346105Smm 854346105Smm /* The file `refname` is invalid in this case, so this call should fail. 855346105Smm * But it shouldn't crash. */ 856346105Smm assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buf, 64)); 857346105Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 858346105Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 859346105Smm} 860346105Smm 861346105SmmDEFINE_TEST(test_read_format_zip_ppmd8_crash_2) 862346105Smm{ 863346105Smm const char *refname = "test_read_format_zip_ppmd8_crash_2.zipx"; 864346105Smm struct archive *a; 865346105Smm struct archive_entry *ae; 866346105Smm char buf[64]; 867346105Smm 868346105Smm extract_reference_file(refname); 869346105Smm 870346105Smm assert((a = archive_read_new()) != NULL); 871346105Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 872346105Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 873346105Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 874346105Smm 875346105Smm /* The file `refname` is invalid in this case, so this call should fail. 876346105Smm * But it shouldn't crash. */ 877346105Smm assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buf, 64)); 878346105Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 879346105Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 880346105Smm} 881348608Smm 882348608SmmDEFINE_TEST(test_read_format_zip_lzma_alone_leak) 883348608Smm{ 884348608Smm const char *refname = "test_read_format_zip_lzma_alone_leak.zipx"; 885348608Smm struct archive *a; 886348608Smm struct archive_entry *ae; 887348608Smm char buf[64]; 888348608Smm 889348608Smm /* OSSFuzz #14470 sample file. */ 890348608Smm extract_reference_file(refname); 891348608Smm 892348608Smm assert((a = archive_read_new()) != NULL); 893348608Smm if(ARCHIVE_OK != archive_read_support_filter_lzma(a)) { 894348608Smm skipping("lzma reading is not fully supported on this platform"); 895348608Smm archive_read_close(a); 896348608Smm return; 897348608Smm } 898348608Smm 899348608Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 900348608Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 901348608Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 902348608Smm 903348608Smm /* Extraction of this file should fail, because the sample file is invalid. 904348608Smm * But it shouldn't crash. */ 905348608Smm assertEqualIntA(a, ARCHIVE_FAILED, archive_read_data(a, buf, sizeof(buf))); 906348608Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 907348608Smm 908348608Smm /* Extraction of this file should fail, because the sample file is invalid. 909348608Smm * But it shouldn't crash. */ 910348608Smm assertEqualIntA(a, ARCHIVE_FATAL, archive_read_data(a, buf, sizeof(buf))); 911348608Smm 912348608Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 913348608Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 914348608Smm 915348608Smm /* This testcase shouldn't produce any memory leaks. When running test 916348608Smm * suite under Valgrind or ASan, the test runner won't return with 917348608Smm * exit code 0 in case if a memory leak. */ 918348608Smm} 919358927Smm 920358927SmmDEFINE_TEST(test_read_format_zip_lzma_stream_end) 921358927Smm{ 922358927Smm const char *refname = "test_read_format_zip_lzma_stream_end.zipx"; 923358927Smm struct archive *a; 924358927Smm struct archive_entry *ae; 925358927Smm 926358927Smm assert((a = archive_read_new()) != NULL); 927358927Smm if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) { 928358927Smm skipping("lzma reading not fully supported on this platform"); 929358927Smm assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 930358927Smm return; 931358927Smm } 932358927Smm extract_reference_file(refname); 933358927Smm 934358927Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 935358927Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 936358927Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 937358927Smm assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 938358927Smm assertEqualString("vimrc", archive_entry_pathname(ae)); 939358927Smm assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA)); 940358927Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 941358927Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 942358927Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 943358927Smm} 944358927Smm 945358927SmmDEFINE_TEST(test_read_format_zip_lzma_stream_end_blockread) 946358927Smm{ 947358927Smm const char *refname = "test_read_format_zip_lzma_stream_end.zipx"; 948358927Smm struct archive *a; 949358927Smm struct archive_entry *ae; 950358927Smm 951358927Smm assert((a = archive_read_new()) != NULL); 952358927Smm if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) { 953358927Smm skipping("lzma reading not fully supported on this platform"); 954358927Smm assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 955358927Smm return; 956358927Smm } 957358927Smm extract_reference_file(refname); 958358927Smm 959358927Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 960358927Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37)); 961358927Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 962358927Smm assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a)); 963358927Smm assertEqualString("vimrc", archive_entry_pathname(ae)); 964358927Smm assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA)); 965358927Smm assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 966358927Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 967358927Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 968358927Smm} 969368708Smm 970368708SmmDEFINE_TEST(test_read_format_zip_7z_lzma) 971368708Smm{ 972368708Smm const char *refname = "test_read_format_zip_7z_lzma.zip"; 973368708Smm struct archive_entry *ae; 974368708Smm struct archive *a; 975368708Smm 976368708Smm assert((a = archive_read_new()) != NULL); 977368708Smm if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) { 978368708Smm skipping("lzma reading not fully supported on this platform"); 979368708Smm assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 980368708Smm return; 981368708Smm } 982368708Smm extract_reference_file(refname); 983368708Smm 984368708Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); 985368708Smm assertEqualIntA(a, ARCHIVE_OK, 986368708Smm archive_read_open_filename(a, refname, 10240)); 987368708Smm //read directories 988368708Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 989368708Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 990368708Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 991368708Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 992368708Smm //read symlink 993368708Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 994368708Smm assertEqualInt(AE_IFLNK, archive_entry_filetype(ae)); 995368708Smm assertEqualString("../samples/abc_measurement_analysis_sample" 996368708Smm "/src/abc_measurement_analysis_sample.py", 997368708Smm archive_entry_symlink(ae)); 998368708Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 999368708Smm assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); 1000368708Smm} 1001