contrib/libarchive/libarchive/test/test_read_format_zip.c

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