libarchive/test/test_read_format_rar5.c

   1 /*-
   2  * Copyright (c) 2018 Grzegorz Antoniak
   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
  27 /* Some tests will want to calculate some CRC32's, and this header can
  28  * help. */
  29 #define __LIBARCHIVE_BUILD
  30 #include <archive_crc32.h>
  31 #include <archive_endian.h>
  32
  33 #define PROLOGUE(reffile) \
  34         struct archive_entry *ae; \
  35         struct archive *a; \
  36         \
  37         (void) a;  /* Make the compiler happy if we won't use this variables */ \
  38         (void) ae; /* in the test cases. */ \
  39         \
  40         extract_reference_file(reffile); \
  41         assert((a = archive_read_new()) != NULL); \
  42         assertA(0 == archive_read_support_filter_all(a)); \
  43         assertA(0 == archive_read_support_format_all(a)); \
  44         assertA(0 == archive_read_open_filename(a, reffile, 10240))
  45
  46 #define PROLOGUE_MULTI(reffile) \
  47         struct archive_entry *ae; \
  48         struct archive *a; \
  49         \
  50         (void) a; \
  51         (void) ae; \
  52         \
  53         extract_reference_files(reffile); \
  54         assert((a = archive_read_new()) != NULL); \
  55         assertA(0 == archive_read_support_filter_all(a)); \
  56         assertA(0 == archive_read_support_format_all(a)); \
  57         assertA(0 == archive_read_open_filenames(a, reffile, 10240))
  58
  59
  60 #define EPILOGUE() \
  61         assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); \
  62         assertEqualInt(ARCHIVE_OK, archive_read_free(a))
  63
  64 static
  65 int verify_data(const uint8_t* data_ptr, int magic, int size) {
  66         int i = 0;
  67
  68         /* This is how the test data inside test files was generated;
  69          * we are re-generating it here and we check if our re-generated
  70          * test data is the same as in the test file. If this test is
  71          * failing it's either because there's a bug in the test case,
  72          * or the unpacked data is corrupted. */
  73
  74         for(i = 0; i < size / 4; ++i) {
  75                 const int k = i + 1;
  76                 const signed int* lptr = (const signed int*) &data_ptr[i * 4];
  77                 signed int val = k * k - 3 * k + (1 + magic);
  78
  79                 if(val < 0)
  80                         val = 0;
  81
  82                 /* *lptr is a value inside unpacked test file, val is the
  83                  * value that should be in the unpacked test file. */
  84
  85                 if(archive_le32dec(lptr) != (uint32_t) val)
  86                         return 0;
  87         }
  88
  89         return 1;
  90 }
  91
  92 static
  93 int extract_one(struct archive* a, struct archive_entry* ae, uint32_t crc) {
  94         la_ssize_t fsize, bytes_read;
  95         uint8_t* buf;
  96         int ret = 1;
  97         uint32_t computed_crc;
  98
  99         fsize = (la_ssize_t) archive_entry_size(ae);
 100         buf = malloc(fsize);
 101         if(buf == NULL)
 102                 return 1;
 103
 104         bytes_read = archive_read_data(a, buf, fsize);
 105         if(bytes_read != fsize) {
 106                 assertEqualInt(bytes_read, fsize);
 107                 goto fn_exit;
 108         }
 109
 110         computed_crc = crc32(0, buf, fsize);
 111         assertEqualInt(computed_crc, crc);
 112         ret = 0;
 113
 114 fn_exit:
 115         free(buf);
 116         return ret;
 117 }
 118
 119 DEFINE_TEST(test_read_format_rar5_set_format)
 120 {
 121         struct archive *a;
 122         struct archive_entry *ae;
 123         const char reffile[] = "test_read_format_rar5_stored.rar";
 124
 125         extract_reference_file(reffile);
 126         assert((a = archive_read_new()) != NULL);
 127         assertA(0 == archive_read_support_filter_all(a));
 128         assertA(0 == archive_read_set_format(a, ARCHIVE_FORMAT_RAR_V5));
 129         assertA(0 == archive_read_open_filename(a, reffile, 10240));
 130         assertA(0 == archive_read_next_header(a, &ae));
 131         EPILOGUE();
 132 }
 133
 134 DEFINE_TEST(test_read_format_rar5_stored)
 135 {
 136         const char helloworld_txt[] = "hello libarchive test suite!\n";
 137         la_ssize_t file_size = sizeof(helloworld_txt) - 1;
 138         char buff[64];
 139
 140         PROLOGUE("test_read_format_rar5_stored.rar");
 141
 142         assertA(0 == archive_read_next_header(a, &ae));
 143         assertEqualString("helloworld.txt", archive_entry_pathname(ae));
 144         assertA((int) archive_entry_mtime(ae) > 0);
 145         assertA((int) archive_entry_ctime(ae) == 0);
 146         assertA((int) archive_entry_atime(ae) == 0);
 147         assertEqualInt(file_size, archive_entry_size(ae));
 148         assertEqualInt(33188, archive_entry_mode(ae));
 149         assertA(file_size == archive_read_data(a, buff, file_size));
 150         assertEqualMem(buff, helloworld_txt, file_size);
 151         assertEqualInt(archive_entry_is_encrypted(ae), 0);
 152
 153         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 154
 155         EPILOGUE();
 156 }
 157
 158 DEFINE_TEST(test_read_format_rar5_compressed)
 159 {
 160         const int DATA_SIZE = 1200;
 161         uint8_t buff[1200];
 162
 163         PROLOGUE("test_read_format_rar5_compressed.rar");
 164
 165         assertA(0 == archive_read_next_header(a, &ae));
 166         assertEqualString("test.bin", archive_entry_pathname(ae));
 167         assertA((int) archive_entry_mtime(ae) > 0);
 168         assertEqualInt(DATA_SIZE, archive_entry_size(ae));
 169         assertA(DATA_SIZE == archive_read_data(a, buff, DATA_SIZE));
 170         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 171         assertA(1 == verify_data(buff, 0, DATA_SIZE));
 172
 173         EPILOGUE();
 174 }
 175
 176 DEFINE_TEST(test_read_format_rar5_multiple_files)
 177 {
 178         const int DATA_SIZE = 4096;
 179         uint8_t buff[4096];
 180
 181         PROLOGUE("test_read_format_rar5_multiple_files.rar");
 182
 183         /* There should be 4 files inside this test file. Check for their
 184          * existence, and also check the contents of those test files. */
 185
 186         assertA(0 == archive_read_next_header(a, &ae));
 187         assertEqualString("test1.bin", archive_entry_pathname(ae));
 188         assertEqualInt(DATA_SIZE, archive_entry_size(ae));
 189         assertA(DATA_SIZE == archive_read_data(a, buff, DATA_SIZE));
 190         assertA(1 == verify_data(buff, 1, DATA_SIZE));
 191
 192         assertA(0 == archive_read_next_header(a, &ae));
 193         assertEqualString("test2.bin", archive_entry_pathname(ae));
 194         assertEqualInt(DATA_SIZE, archive_entry_size(ae));
 195         assertA(DATA_SIZE == archive_read_data(a, buff, DATA_SIZE));
 196         assertA(1 == verify_data(buff, 2, DATA_SIZE));
 197
 198         assertA(0 == archive_read_next_header(a, &ae));
 199         assertEqualString("test3.bin", archive_entry_pathname(ae));
 200         assertEqualInt(DATA_SIZE, archive_entry_size(ae));
 201         assertA(DATA_SIZE == archive_read_data(a, buff, DATA_SIZE));
 202         assertA(1 == verify_data(buff, 3, DATA_SIZE));
 203
 204         assertA(0 == archive_read_next_header(a, &ae));
 205         assertEqualString("test4.bin", archive_entry_pathname(ae));
 206         assertEqualInt(DATA_SIZE, archive_entry_size(ae));
 207         assertA(DATA_SIZE == archive_read_data(a, buff, DATA_SIZE));
 208         assertA(1 == verify_data(buff, 4, DATA_SIZE));
 209
 210         /* There should be no more files in this archive. */
 211
 212         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 213         EPILOGUE();
 214 }
 215
 216 /* This test is really the same as the test above, but it deals with a solid
 217  * archive instead of a regular archive. The test solid archive contains the
 218  * same set of files as regular test archive, but it's size is 2x smaller,
 219  * because solid archives reuse the window buffer from previous compressed
 220  * files, so it's able to compress lots of small files more effectively. */
 221
 222 DEFINE_TEST(test_read_format_rar5_multiple_files_solid)
 223 {
 224         const int DATA_SIZE = 4096;
 225         uint8_t buff[4096];
 226
 227         PROLOGUE("test_read_format_rar5_multiple_files_solid.rar");
 228
 229         assertA(0 == archive_read_next_header(a, &ae));
 230         assertEqualString("test1.bin", archive_entry_pathname(ae));
 231         assertEqualInt(DATA_SIZE, archive_entry_size(ae));
 232         assertA(DATA_SIZE == archive_read_data(a, buff, DATA_SIZE));
 233         assertA(1 == verify_data(buff, 1, DATA_SIZE));
 234
 235         assertA(0 == archive_read_next_header(a, &ae));
 236         assertEqualString("test2.bin", archive_entry_pathname(ae));
 237         assertEqualInt(DATA_SIZE, archive_entry_size(ae));
 238         assertA(DATA_SIZE == archive_read_data(a, buff, DATA_SIZE));
 239         assertA(1 == verify_data(buff, 2, DATA_SIZE));
 240
 241         assertA(0 == archive_read_next_header(a, &ae));
 242         assertEqualString("test3.bin", archive_entry_pathname(ae));
 243         assertEqualInt(DATA_SIZE, archive_entry_size(ae));
 244         assertA(DATA_SIZE == archive_read_data(a, buff, DATA_SIZE));
 245         assertA(1 == verify_data(buff, 3, DATA_SIZE));
 246
 247         assertA(0 == archive_read_next_header(a, &ae));
 248         assertEqualString("test4.bin", archive_entry_pathname(ae));
 249         assertEqualInt(DATA_SIZE, archive_entry_size(ae));
 250         assertA(DATA_SIZE == archive_read_data(a, buff, DATA_SIZE));
 251         assertA(1 == verify_data(buff, 4, DATA_SIZE));
 252
 253         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 254         EPILOGUE();
 255 }
 256
 257 DEFINE_TEST(test_read_format_rar5_multiarchive_skip_all)
 258 {
 259         const char* reffiles[] = {
 260                 "test_read_format_rar5_multiarchive.part01.rar",
 261                 "test_read_format_rar5_multiarchive.part02.rar",
 262                 "test_read_format_rar5_multiarchive.part03.rar",
 263                 "test_read_format_rar5_multiarchive.part04.rar",
 264                 "test_read_format_rar5_multiarchive.part05.rar",
 265                 "test_read_format_rar5_multiarchive.part06.rar",
 266                 "test_read_format_rar5_multiarchive.part07.rar",
 267                 "test_read_format_rar5_multiarchive.part08.rar",
 268                 NULL
 269         };
 270
 271         PROLOGUE_MULTI(reffiles);
 272         assertA(0 == archive_read_next_header(a, &ae));
 273         assertEqualString("home/antek/temp/build/unrar5/libarchive/bin/bsdcat_test", archive_entry_pathname(ae));
 274         assertA(0 == archive_read_next_header(a, &ae));
 275         assertEqualString("home/antek/temp/build/unrar5/libarchive/bin/bsdtar_test", archive_entry_pathname(ae));
 276         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 277         EPILOGUE();
 278 }
 279
 280 DEFINE_TEST(test_read_format_rar5_multiarchive_skip_all_but_first)
 281 {
 282         const char* reffiles[] = {
 283                 "test_read_format_rar5_multiarchive.part01.rar",
 284                 "test_read_format_rar5_multiarchive.part02.rar",
 285                 "test_read_format_rar5_multiarchive.part03.rar",
 286                 "test_read_format_rar5_multiarchive.part04.rar",
 287                 "test_read_format_rar5_multiarchive.part05.rar",
 288                 "test_read_format_rar5_multiarchive.part06.rar",
 289                 "test_read_format_rar5_multiarchive.part07.rar",
 290                 "test_read_format_rar5_multiarchive.part08.rar",
 291                 NULL
 292         };
 293
 294         PROLOGUE_MULTI(reffiles);
 295         assertA(0 == archive_read_next_header(a, &ae));
 296         assertA(0 == extract_one(a, ae, 0x35277473));
 297         assertA(0 == archive_read_next_header(a, &ae));
 298         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 299         EPILOGUE();
 300 }
 301
 302 DEFINE_TEST(test_read_format_rar5_multiarchive_skip_all_but_second)
 303 {
 304         const char* reffiles[] = {
 305                 "test_read_format_rar5_multiarchive.part01.rar",
 306                 "test_read_format_rar5_multiarchive.part02.rar",
 307                 "test_read_format_rar5_multiarchive.part03.rar",
 308                 "test_read_format_rar5_multiarchive.part04.rar",
 309                 "test_read_format_rar5_multiarchive.part05.rar",
 310                 "test_read_format_rar5_multiarchive.part06.rar",
 311                 "test_read_format_rar5_multiarchive.part07.rar",
 312                 "test_read_format_rar5_multiarchive.part08.rar",
 313                 NULL
 314         };
 315
 316         PROLOGUE_MULTI(reffiles);
 317         assertA(0 == archive_read_next_header(a, &ae));
 318         assertA(0 == archive_read_next_header(a, &ae));
 319         assertA(0 == extract_one(a, ae, 0xE59665F8));
 320         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 321         EPILOGUE();
 322 }
 323
 324 DEFINE_TEST(test_read_format_rar5_blake2)
 325 {
 326         const la_ssize_t proper_size = 814;
 327         uint8_t buf[814];
 328
 329         PROLOGUE("test_read_format_rar5_blake2.rar");
 330         assertA(0 == archive_read_next_header(a, &ae));
 331         assertEqualInt(proper_size, archive_entry_size(ae));
 332
 333         /* Should blake2 calculation fail, we'll get a failure return
 334          * value from archive_read_data(). */
 335
 336         assertA(proper_size == archive_read_data(a, buf, proper_size));
 337
 338         /* To be extra pedantic, let's also check crc32 of the poem. */
 339         assertEqualInt(crc32(0, buf, proper_size), 0x7E5EC49E);
 340
 341         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 342         EPILOGUE();
 343 }
 344
 345 DEFINE_TEST(test_read_format_rar5_arm_filter)
 346 {
 347         /* This test unpacks a file that uses an ARM filter. The DELTA
 348          * and X86 filters are tested implicitly in the "multiarchive_skip"
 349          * test. */
 350
 351         const la_ssize_t proper_size = 90808;
 352         uint8_t buf[90808];
 353
 354         PROLOGUE("test_read_format_rar5_arm.rar");
 355         assertA(0 == archive_read_next_header(a, &ae));
 356         assertEqualInt(proper_size, archive_entry_size(ae));
 357         assertA(proper_size == archive_read_data(a, buf, proper_size));
 358
 359         /* Yes, RARv5 unpacker itself should calculate the CRC, but in case
 360          * the DONT_FAIL_ON_CRC_ERROR define option is enabled during compilation,
 361          * let's still fail the test if the unpacked data is wrong. */
 362         assertEqualInt(crc32(0, buf, proper_size), 0x886F91EB);
 363
 364         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 365         EPILOGUE();
 366 }
 367
 368 DEFINE_TEST(test_read_format_rar5_stored_skip_all)
 369 {
 370         const char* fname = "test_read_format_rar5_stored_manyfiles.rar";
 371
 372         PROLOGUE(fname);
 373         assertA(0 == archive_read_next_header(a, &ae));
 374         assertEqualString("make_uue.tcl", archive_entry_pathname(ae));
 375         assertA(0 == archive_read_next_header(a, &ae));
 376         assertEqualString("cebula.txt", archive_entry_pathname(ae));
 377         assertA(0 == archive_read_next_header(a, &ae));
 378         assertEqualString("test.bin", archive_entry_pathname(ae));
 379         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 380         EPILOGUE();
 381 }
 382
 383 DEFINE_TEST(test_read_format_rar5_stored_skip_in_part)
 384 {
 385         const char* fname = "test_read_format_rar5_stored_manyfiles.rar";
 386         char buf[6];
 387
 388         /* Skip first, extract in part rest. */
 389
 390         PROLOGUE(fname);
 391         assertA(0 == archive_read_next_header(a, &ae));
 392         assertEqualString("make_uue.tcl", archive_entry_pathname(ae));
 393         assertA(0 == archive_read_next_header(a, &ae));
 394         assertEqualString("cebula.txt", archive_entry_pathname(ae));
 395         assertA(6 == archive_read_data(a, buf, 6));
 396         assertEqualInt(0, memcmp(buf, "Cebula", 6));
 397         assertA(0 == archive_read_next_header(a, &ae));
 398         assertEqualString("test.bin", archive_entry_pathname(ae));
 399         assertA(4 == archive_read_data(a, buf, 4));
 400         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 401         EPILOGUE();
 402 }
 403
 404 DEFINE_TEST(test_read_format_rar5_stored_skip_all_but_first)
 405 {
 406         const char* fname = "test_read_format_rar5_stored_manyfiles.rar";
 407         char buf[405];
 408
 409         /* Extract first, skip rest. */
 410
 411         PROLOGUE(fname);
 412         assertA(0 == archive_read_next_header(a, &ae));
 413         assertEqualString("make_uue.tcl", archive_entry_pathname(ae));
 414         assertA(405 == archive_read_data(a, buf, sizeof(buf)));
 415         assertA(0 == archive_read_next_header(a, &ae));
 416         assertEqualString("cebula.txt", archive_entry_pathname(ae));
 417         assertA(0 == archive_read_next_header(a, &ae));
 418         assertEqualString("test.bin", archive_entry_pathname(ae));
 419         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 420         EPILOGUE();
 421 }
 422
 423 DEFINE_TEST(test_read_format_rar5_stored_skip_all_in_part)
 424 {
 425         const char* fname = "test_read_format_rar5_stored_manyfiles.rar";
 426         char buf[4];
 427
 428         /* Extract in part all */
 429
 430         PROLOGUE(fname);
 431         assertA(0 == archive_read_next_header(a, &ae));
 432         assertEqualString("make_uue.tcl", archive_entry_pathname(ae));
 433         assertA(4 == archive_read_data(a, buf, 4));
 434         assertA(0 == archive_read_next_header(a, &ae));
 435         assertEqualString("cebula.txt", archive_entry_pathname(ae));
 436         assertA(4 == archive_read_data(a, buf, 4));
 437         assertA(0 == archive_read_next_header(a, &ae));
 438         assertEqualString("test.bin", archive_entry_pathname(ae));
 439         assertA(4 == archive_read_data(a, buf, 4));
 440         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 441         EPILOGUE();
 442 }
 443
 444 DEFINE_TEST(test_read_format_rar5_multiarchive_solid_extr_all)
 445 {
 446         const char* reffiles[] = {
 447                 "test_read_format_rar5_multiarchive_solid.part01.rar",
 448                 "test_read_format_rar5_multiarchive_solid.part02.rar",
 449                 "test_read_format_rar5_multiarchive_solid.part03.rar",
 450                 "test_read_format_rar5_multiarchive_solid.part04.rar",
 451                 NULL
 452         };
 453
 454         PROLOGUE_MULTI(reffiles);
 455         assertA(0 == archive_read_next_header(a, &ae));
 456         assertEqualString("cebula.txt", archive_entry_pathname(ae));
 457         assertA(0 == extract_one(a, ae, 0x7E5EC49E));
 458
 459         assertA(0 == archive_read_next_header(a, &ae));
 460         assertEqualString("test.bin", archive_entry_pathname(ae));
 461         assertA(0 == extract_one(a, ae, 0x7cca70cd));
 462
 463         assertA(0 == archive_read_next_header(a, &ae));
 464         assertEqualString("test1.bin", archive_entry_pathname(ae));
 465         assertA(0 == extract_one(a, ae, 0x7e13b2c6));
 466
 467         assertA(0 == archive_read_next_header(a, &ae));
 468         assertEqualString("test2.bin", archive_entry_pathname(ae));
 469         assertA(0 == extract_one(a, ae, 0xf166afcb));
 470
 471         assertA(0 == archive_read_next_header(a, &ae));
 472         assertEqualString("test3.bin", archive_entry_pathname(ae));
 473         assertA(0 == extract_one(a, ae, 0x9fb123d9));
 474
 475         assertA(0 == archive_read_next_header(a, &ae));
 476         assertEqualString("test4.bin", archive_entry_pathname(ae));
 477         assertA(0 == extract_one(a, ae, 0x10c43ed4));
 478
 479         assertA(0 == archive_read_next_header(a, &ae));
 480         assertEqualString("test5.bin", archive_entry_pathname(ae));
 481         assertA(0 == extract_one(a, ae, 0xb9d155f2));
 482
 483         assertA(0 == archive_read_next_header(a, &ae));
 484         assertEqualString("test6.bin", archive_entry_pathname(ae));
 485         assertA(0 == extract_one(a, ae, 0x36a448ff));
 486
 487         assertA(0 == archive_read_next_header(a, &ae));
 488         assertEqualString("elf-Linux-ARMv7-ls", archive_entry_pathname(ae));
 489         assertA(0 == extract_one(a, ae, 0x886F91EB));
 490
 491         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 492         EPILOGUE();
 493 }
 494
 495 DEFINE_TEST(test_read_format_rar5_multiarchive_solid_skip_all)
 496 {
 497         const char* reffiles[] = {
 498                 "test_read_format_rar5_multiarchive_solid.part01.rar",
 499                 "test_read_format_rar5_multiarchive_solid.part02.rar",
 500                 "test_read_format_rar5_multiarchive_solid.part03.rar",
 501                 "test_read_format_rar5_multiarchive_solid.part04.rar",
 502                 NULL
 503         };
 504
 505         PROLOGUE_MULTI(reffiles);
 506         assertA(0 == archive_read_next_header(a, &ae));
 507         assertEqualString("cebula.txt", archive_entry_pathname(ae));
 508         assertA(0 == archive_read_next_header(a, &ae));
 509         assertEqualString("test.bin", archive_entry_pathname(ae));
 510         assertA(0 == archive_read_next_header(a, &ae));
 511         assertEqualString("test1.bin", archive_entry_pathname(ae));
 512         assertA(0 == archive_read_next_header(a, &ae));
 513         assertEqualString("test2.bin", archive_entry_pathname(ae));
 514         assertA(0 == archive_read_next_header(a, &ae));
 515         assertEqualString("test3.bin", archive_entry_pathname(ae));
 516         assertA(0 == archive_read_next_header(a, &ae));
 517         assertEqualString("test4.bin", archive_entry_pathname(ae));
 518         assertA(0 == archive_read_next_header(a, &ae));
 519         assertEqualString("test5.bin", archive_entry_pathname(ae));
 520         assertA(0 == archive_read_next_header(a, &ae));
 521         assertEqualString("test6.bin", archive_entry_pathname(ae));
 522         assertA(0 == archive_read_next_header(a, &ae));
 523         assertEqualString("elf-Linux-ARMv7-ls", archive_entry_pathname(ae));
 524         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 525         EPILOGUE();
 526 }
 527
 528 DEFINE_TEST(test_read_format_rar5_multiarchive_solid_skip_all_but_first)
 529 {
 530         const char* reffiles[] = {
 531                 "test_read_format_rar5_multiarchive_solid.part01.rar",
 532                 "test_read_format_rar5_multiarchive_solid.part02.rar",
 533                 "test_read_format_rar5_multiarchive_solid.part03.rar",
 534                 "test_read_format_rar5_multiarchive_solid.part04.rar",
 535                 NULL
 536         };
 537
 538         PROLOGUE_MULTI(reffiles);
 539         assertA(0 == archive_read_next_header(a, &ae));
 540         assertEqualString("cebula.txt", archive_entry_pathname(ae));
 541         assertA(0 == extract_one(a, ae, 0x7E5EC49E));
 542         assertA(0 == archive_read_next_header(a, &ae));
 543         assertEqualString("test.bin", archive_entry_pathname(ae));
 544         assertA(0 == archive_read_next_header(a, &ae));
 545         assertEqualString("test1.bin", archive_entry_pathname(ae));
 546         assertA(0 == archive_read_next_header(a, &ae));
 547         assertEqualString("test2.bin", archive_entry_pathname(ae));
 548         assertA(0 == archive_read_next_header(a, &ae));
 549         assertEqualString("test3.bin", archive_entry_pathname(ae));
 550         assertA(0 == archive_read_next_header(a, &ae));
 551         assertEqualString("test4.bin", archive_entry_pathname(ae));
 552         assertA(0 == archive_read_next_header(a, &ae));
 553         assertEqualString("test5.bin", archive_entry_pathname(ae));
 554         assertA(0 == archive_read_next_header(a, &ae));
 555         assertEqualString("test6.bin", archive_entry_pathname(ae));
 556         assertA(0 == archive_read_next_header(a, &ae));
 557         assertEqualString("elf-Linux-ARMv7-ls", archive_entry_pathname(ae));
 558         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 559         EPILOGUE();
 560 }
 561
 562 /* "skip_all_but_scnd" -> am I hitting the test name limit here after
 563  * expansion of "scnd" to "second"? */
 564
 565 DEFINE_TEST(test_read_format_rar5_multiarchive_solid_skip_all_but_scnd)
 566 {
 567         const char* reffiles[] = {
 568                 "test_read_format_rar5_multiarchive_solid.part01.rar",
 569                 "test_read_format_rar5_multiarchive_solid.part02.rar",
 570                 "test_read_format_rar5_multiarchive_solid.part03.rar",
 571                 "test_read_format_rar5_multiarchive_solid.part04.rar",
 572                 NULL
 573         };
 574
 575         PROLOGUE_MULTI(reffiles);
 576         assertA(0 == archive_read_next_header(a, &ae));
 577         assertEqualString("cebula.txt", archive_entry_pathname(ae));
 578         assertA(0 == archive_read_next_header(a, &ae));
 579         assertEqualString("test.bin", archive_entry_pathname(ae));
 580         assertA(0 == extract_one(a, ae, 0x7CCA70CD));
 581         assertA(0 == archive_read_next_header(a, &ae));
 582         assertEqualString("test1.bin", archive_entry_pathname(ae));
 583         assertA(0 == archive_read_next_header(a, &ae));
 584         assertEqualString("test2.bin", archive_entry_pathname(ae));
 585         assertA(0 == archive_read_next_header(a, &ae));
 586         assertEqualString("test3.bin", archive_entry_pathname(ae));
 587         assertA(0 == archive_read_next_header(a, &ae));
 588         assertEqualString("test4.bin", archive_entry_pathname(ae));
 589         assertA(0 == archive_read_next_header(a, &ae));
 590         assertEqualString("test5.bin", archive_entry_pathname(ae));
 591         assertA(0 == archive_read_next_header(a, &ae));
 592         assertEqualString("test6.bin", archive_entry_pathname(ae));
 593         assertA(0 == archive_read_next_header(a, &ae));
 594         assertEqualString("elf-Linux-ARMv7-ls", archive_entry_pathname(ae));
 595         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 596         EPILOGUE();
 597 }
 598
 599 DEFINE_TEST(test_read_format_rar5_multiarchive_solid_skip_all_but_third)
 600 {
 601         const char* reffiles[] = {
 602                 "test_read_format_rar5_multiarchive_solid.part01.rar",
 603                 "test_read_format_rar5_multiarchive_solid.part02.rar",
 604                 "test_read_format_rar5_multiarchive_solid.part03.rar",
 605                 "test_read_format_rar5_multiarchive_solid.part04.rar",
 606                 NULL
 607         };
 608
 609         PROLOGUE_MULTI(reffiles);
 610         assertA(0 == archive_read_next_header(a, &ae));
 611         assertEqualString("cebula.txt", archive_entry_pathname(ae));
 612         assertA(0 == archive_read_next_header(a, &ae));
 613         assertEqualString("test.bin", archive_entry_pathname(ae));
 614         assertA(0 == archive_read_next_header(a, &ae));
 615         assertEqualString("test1.bin", archive_entry_pathname(ae));
 616         assertA(0 == extract_one(a, ae, 0x7E13B2C6));
 617         assertA(0 == archive_read_next_header(a, &ae));
 618         assertEqualString("test2.bin", archive_entry_pathname(ae));
 619         assertA(0 == archive_read_next_header(a, &ae));
 620         assertEqualString("test3.bin", archive_entry_pathname(ae));
 621         assertA(0 == archive_read_next_header(a, &ae));
 622         assertEqualString("test4.bin", archive_entry_pathname(ae));
 623         assertA(0 == archive_read_next_header(a, &ae));
 624         assertEqualString("test5.bin", archive_entry_pathname(ae));
 625         assertA(0 == archive_read_next_header(a, &ae));
 626         assertEqualString("test6.bin", archive_entry_pathname(ae));
 627         assertA(0 == archive_read_next_header(a, &ae));
 628         assertEqualString("elf-Linux-ARMv7-ls", archive_entry_pathname(ae));
 629         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 630         EPILOGUE();
 631 }
 632
 633 DEFINE_TEST(test_read_format_rar5_multiarchive_solid_skip_all_but_last)
 634 {
 635         const char* reffiles[] = {
 636                 "test_read_format_rar5_multiarchive_solid.part01.rar",
 637                 "test_read_format_rar5_multiarchive_solid.part02.rar",
 638                 "test_read_format_rar5_multiarchive_solid.part03.rar",
 639                 "test_read_format_rar5_multiarchive_solid.part04.rar",
 640                 NULL
 641         };
 642
 643         PROLOGUE_MULTI(reffiles);
 644         assertA(0 == archive_read_next_header(a, &ae));
 645         assertEqualString("cebula.txt", archive_entry_pathname(ae));
 646         assertA(0 == archive_read_next_header(a, &ae));
 647         assertEqualString("test.bin", archive_entry_pathname(ae));
 648         assertA(0 == archive_read_next_header(a, &ae));
 649         assertEqualString("test1.bin", archive_entry_pathname(ae));
 650         assertA(0 == archive_read_next_header(a, &ae));
 651         assertEqualString("test2.bin", archive_entry_pathname(ae));
 652         assertA(0 == archive_read_next_header(a, &ae));
 653         assertEqualString("test3.bin", archive_entry_pathname(ae));
 654         assertA(0 == archive_read_next_header(a, &ae));
 655         assertEqualString("test4.bin", archive_entry_pathname(ae));
 656         assertA(0 == archive_read_next_header(a, &ae));
 657         assertEqualString("test5.bin", archive_entry_pathname(ae));
 658         assertA(0 == archive_read_next_header(a, &ae));
 659         assertEqualString("test6.bin", archive_entry_pathname(ae));
 660         assertA(0 == archive_read_next_header(a, &ae));
 661         assertEqualString("elf-Linux-ARMv7-ls", archive_entry_pathname(ae));
 662         assertA(0 == extract_one(a, ae, 0x886F91EB));
 663         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 664         EPILOGUE();
 665 }
 666
 667 DEFINE_TEST(test_read_format_rar5_solid_skip_all)
 668 {
 669         const char* reffile = "test_read_format_rar5_solid.rar";
 670
 671         /* Skip all */
 672
 673         PROLOGUE(reffile);
 674         assertA(0 == archive_read_next_header(a, &ae));
 675         assertEqualString("test.bin", archive_entry_pathname(ae));
 676         assertA(0 == archive_read_next_header(a, &ae));
 677         assertEqualString("test1.bin", archive_entry_pathname(ae));
 678         assertA(0 == archive_read_next_header(a, &ae));
 679         assertEqualString("test2.bin", archive_entry_pathname(ae));
 680         assertA(0 == archive_read_next_header(a, &ae));
 681         assertEqualString("test3.bin", archive_entry_pathname(ae));
 682         assertA(0 == archive_read_next_header(a, &ae));
 683         assertEqualString("test4.bin", archive_entry_pathname(ae));
 684         assertA(0 == archive_read_next_header(a, &ae));
 685         assertEqualString("test5.bin", archive_entry_pathname(ae));
 686         assertA(0 == archive_read_next_header(a, &ae));
 687         assertEqualString("test6.bin", archive_entry_pathname(ae));
 688         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 689         EPILOGUE();
 690 }
 691
 692 DEFINE_TEST(test_read_format_rar5_solid_skip_all_but_first)
 693 {
 694         const char* reffile = "test_read_format_rar5_solid.rar";
 695
 696         /* Extract first, skip rest */
 697
 698         PROLOGUE(reffile);
 699         assertA(0 == archive_read_next_header(a, &ae));
 700         assertEqualString("test.bin", archive_entry_pathname(ae));
 701         assertA(0 == extract_one(a, ae, 0x7CCA70CD));
 702         assertA(0 == archive_read_next_header(a, &ae));
 703         assertEqualString("test1.bin", archive_entry_pathname(ae));
 704         assertA(0 == archive_read_next_header(a, &ae));
 705         assertEqualString("test2.bin", archive_entry_pathname(ae));
 706         assertA(0 == archive_read_next_header(a, &ae));
 707         assertEqualString("test3.bin", archive_entry_pathname(ae));
 708         assertA(0 == archive_read_next_header(a, &ae));
 709         assertEqualString("test4.bin", archive_entry_pathname(ae));
 710         assertA(0 == archive_read_next_header(a, &ae));
 711         assertEqualString("test5.bin", archive_entry_pathname(ae));
 712         assertA(0 == archive_read_next_header(a, &ae));
 713         assertEqualString("test6.bin", archive_entry_pathname(ae));
 714         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 715         EPILOGUE();
 716 }
 717
 718 DEFINE_TEST(test_read_format_rar5_solid_skip_all_but_second)
 719 {
 720         const char* reffile = "test_read_format_rar5_solid.rar";
 721
 722         /* Skip first, extract second, skip rest */
 723
 724         PROLOGUE(reffile);
 725         assertA(0 == archive_read_next_header(a, &ae));
 726         assertEqualString("test.bin", archive_entry_pathname(ae));
 727         assertA(0 == archive_read_next_header(a, &ae));
 728         assertEqualString("test1.bin", archive_entry_pathname(ae));
 729         assertA(0 == extract_one(a, ae, 0x7E13B2C6));
 730         assertA(0 == archive_read_next_header(a, &ae));
 731         assertEqualString("test2.bin", archive_entry_pathname(ae));
 732         assertA(0 == archive_read_next_header(a, &ae));
 733         assertEqualString("test3.bin", archive_entry_pathname(ae));
 734         assertA(0 == archive_read_next_header(a, &ae));
 735         assertEqualString("test4.bin", archive_entry_pathname(ae));
 736         assertA(0 == archive_read_next_header(a, &ae));
 737         assertEqualString("test5.bin", archive_entry_pathname(ae));
 738         assertA(0 == archive_read_next_header(a, &ae));
 739         assertEqualString("test6.bin", archive_entry_pathname(ae));
 740         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 741         EPILOGUE();
 742 }
 743
 744 DEFINE_TEST(test_read_format_rar5_solid_skip_all_but_last)
 745 {
 746         const char* reffile = "test_read_format_rar5_solid.rar";
 747
 748         /* Skip all but last, extract last */
 749
 750         PROLOGUE(reffile);
 751         assertA(0 == archive_read_next_header(a, &ae));
 752         assertEqualString("test.bin", archive_entry_pathname(ae));
 753         assertA(0 == archive_read_next_header(a, &ae));
 754         assertEqualString("test1.bin", archive_entry_pathname(ae));
 755         assertA(0 == archive_read_next_header(a, &ae));
 756         assertEqualString("test2.bin", archive_entry_pathname(ae));
 757         assertA(0 == archive_read_next_header(a, &ae));
 758         assertEqualString("test3.bin", archive_entry_pathname(ae));
 759         assertA(0 == archive_read_next_header(a, &ae));
 760         assertEqualString("test4.bin", archive_entry_pathname(ae));
 761         assertA(0 == archive_read_next_header(a, &ae));
 762         assertEqualString("test5.bin", archive_entry_pathname(ae));
 763         assertA(0 == archive_read_next_header(a, &ae));
 764         assertEqualString("test6.bin", archive_entry_pathname(ae));
 765         assertA(0 == extract_one(a, ae, 0x36A448FF));
 766         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 767         EPILOGUE();
 768 }
 769
 770 DEFINE_TEST(test_read_format_rar5_extract_win32)
 771 {
 772         PROLOGUE("test_read_format_rar5_win32.rar");
 773         assertA(0 == archive_read_next_header(a, &ae));
 774         assertEqualString("testdir", archive_entry_pathname(ae));
 775         assertEqualInt(archive_entry_mode(ae), AE_IFDIR | 0755);
 776         assertA(0 == extract_one(a, ae, 0));
 777         assertA(0 == archive_read_next_header(a, &ae));
 778         assertEqualString("test.bin", archive_entry_pathname(ae));
 779         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 780         assertA(0 == extract_one(a, ae, 0x7CCA70CD));
 781         assertA(0 == archive_read_next_header(a, &ae));
 782         assertEqualString("test1.bin", archive_entry_pathname(ae));
 783         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 784         assertA(0 == extract_one(a, ae, 0x7E13B2C6));
 785         assertA(0 == archive_read_next_header(a, &ae));
 786         /* Read only file */
 787         assertEqualString("test2.bin", archive_entry_pathname(ae));
 788         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0444);
 789         assertA(0 == extract_one(a, ae, 0xF166AFCB));
 790         assertA(0 == archive_read_next_header(a, &ae));
 791         assertEqualString("test3.bin", archive_entry_pathname(ae));
 792         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 793         assertA(0 == extract_one(a, ae, 0x9FB123D9));
 794         assertA(0 == archive_read_next_header(a, &ae));
 795         assertEqualString("test4.bin", archive_entry_pathname(ae));
 796         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 797         assertA(0 == extract_one(a, ae, 0x10C43ED4));
 798         assertA(0 == archive_read_next_header(a, &ae));
 799         assertEqualString("test5.bin", archive_entry_pathname(ae));
 800         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 801         assertA(0 == extract_one(a, ae, 0xB9D155F2));
 802         assertA(0 == archive_read_next_header(a, &ae));
 803         assertEqualString("test6.bin", archive_entry_pathname(ae));
 804         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 805         assertA(0 == extract_one(a, ae, 0x36A448FF));
 806         EPILOGUE();
 807 }
 808
 809 DEFINE_TEST(test_read_format_rar5_unicode)
 810 {
 811 #if !defined(WIN32) || defined(__CYGWIN__)
 812         skipping("Skipping test on non-Windows");
 813         return;
 814 #else
 815         /* Corresponds to the names:
 816          * 👋🌎.txt
 817          * 𝒮𝓎𝓂𝒷𝑜𝓁𝒾𝒸 𝐿𝒾𝓃𝓀.txt
 818          * Ⓗⓐⓡⓓ Ⓛⓘⓝⓚ.txt */
 819         const wchar_t* emoji_name = L"\U0001f44b\U0001f30e.txt";
 820         const wchar_t* italic_name = L"\U0001d4ae\U0001d4ce\U0001d4c2\U0001d4b7\U0001d45c\U0001d4c1\U0001d4be\U0001d4b8 \U0001d43f\U0001d4be\U0001d4c3\U0001d4c0.txt";
 821         const wchar_t* circle_name = L"\u24bd\u24d0\u24e1\u24d3 \u24c1\u24d8\u24dd\u24da.txt";
 822
 823         PROLOGUE("test_read_format_rar5_unicode.rar");
 824         assertA(0 == archive_read_next_header(a, &ae));
 825         assertEqualWString(emoji_name, archive_entry_pathname_w(ae));
 826         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 827         assertA(0 == archive_read_next_header(a, &ae));
 828         assertEqualWString(circle_name, archive_entry_pathname_w(ae));
 829         assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0644);
 830         assertEqualWString(emoji_name, archive_entry_hardlink_w(ae));
 831         assertA(0 == archive_read_next_header(a, &ae));
 832         assertEqualWString(italic_name, archive_entry_pathname_w(ae));
 833         assertEqualInt(archive_entry_mode(ae), AE_IFLNK | 0644);
 834         assertEqualWString(emoji_name, archive_entry_symlink_w(ae));
 835         EPILOGUE();
 836 #endif
 837 }
 838
 839 DEFINE_TEST(test_read_format_rar5_block_by_block)
 840 {
 841         /* This test uses strange buffer sizes intentionally. */
 842
 843         struct archive_entry *ae;
 844         struct archive *a;
 845         uint8_t buf[173];
 846         int bytes_read;
 847         uint32_t computed_crc = 0;
 848
 849         extract_reference_file("test_read_format_rar5_compressed.rar");
 850         assert((a = archive_read_new()) != NULL);
 851         assertA(0 == archive_read_support_filter_all(a));
 852         assertA(0 == archive_read_support_format_all(a));
 853         assertA(0 == archive_read_open_filename(a, "test_read_format_rar5_compressed.rar", 130));
 854         assertA(0 == archive_read_next_header(a, &ae));
 855         assertEqualString("test.bin", archive_entry_pathname(ae));
 856         assertEqualInt(1200, archive_entry_size(ae));
 857
 858         /* File size is 1200 bytes, we're reading it using a buffer of 173 bytes.
 859          * Libarchive is configured to use a buffer of 130 bytes. */
 860
 861         while(1) {
 862                 /* archive_read_data should return one of:
 863                  * a) 0, if there is no more data to be read,
 864                  * b) negative value, if there was an error,
 865                  * c) positive value, meaning how many bytes were read.
 866                  */
 867
 868                 bytes_read = archive_read_data(a, buf, sizeof(buf));
 869                 assertA(bytes_read >= 0);
 870                 if(bytes_read <= 0)
 871                         break;
 872
 873                 computed_crc = crc32(computed_crc, buf, bytes_read);
 874         }
 875
 876         assertEqualInt(computed_crc, 0x7CCA70CD);
 877         EPILOGUE();
 878 }
 879
 880 DEFINE_TEST(test_read_format_rar5_owner)
 881 {
 882         const int DATA_SIZE = 5;
 883         uint8_t buff[5];
 884
 885         PROLOGUE("test_read_format_rar5_owner.rar");
 886
 887         assertA(0 == archive_read_next_header(a, &ae));
 888         assertEqualString("root.txt", archive_entry_pathname(ae));
 889         assertEqualString("root", archive_entry_uname(ae));
 890         assertEqualString("wheel", archive_entry_gname(ae));
 891         assertA((int) archive_entry_mtime(ae) > 0);
 892         assertEqualInt(DATA_SIZE, archive_entry_size(ae));
 893         assertA(DATA_SIZE == archive_read_data(a, buff, DATA_SIZE));
 894
 895         assertA(0 == archive_read_next_header(a, &ae));
 896         assertEqualString("nobody.txt", archive_entry_pathname(ae));
 897         assertEqualString("nobody", archive_entry_uname(ae));
 898         assertEqualString("nogroup", archive_entry_gname(ae));
 899         assertA((int) archive_entry_mtime(ae) > 0);
 900         assertEqualInt(DATA_SIZE, archive_entry_size(ae));
 901         assertA(DATA_SIZE == archive_read_data(a, buff, DATA_SIZE));
 902
 903         assertA(0 == archive_read_next_header(a, &ae));
 904         assertEqualString("numeric.txt", archive_entry_pathname(ae));
 905         assertEqualInt(9999, archive_entry_uid(ae));
 906         assertEqualInt(8888, archive_entry_gid(ae));
 907         assertA((int) archive_entry_mtime(ae) > 0);
 908         assertEqualInt(DATA_SIZE, archive_entry_size(ae));
 909         assertA(DATA_SIZE == archive_read_data(a, buff, DATA_SIZE));
 910
 911         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 912
 913         EPILOGUE();
 914 }
 915
 916 DEFINE_TEST(test_read_format_rar5_symlink)
 917 {
 918         const int DATA_SIZE = 5;
 919         uint8_t buff[5];
 920
 921         PROLOGUE("test_read_format_rar5_symlink.rar");
 922
 923         assertA(0 == archive_read_next_header(a, &ae));
 924         assertEqualString("file.txt", archive_entry_pathname(ae));
 925         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 926         assertA((int) archive_entry_mtime(ae) > 0);
 927         assertEqualInt(DATA_SIZE, archive_entry_size(ae));
 928         assertA(DATA_SIZE == archive_read_data(a, buff, DATA_SIZE));
 929
 930         assertA(0 == archive_read_next_header(a, &ae));
 931         assertEqualString("symlink.txt", archive_entry_pathname(ae));
 932         assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
 933         assertEqualString("file.txt", archive_entry_symlink(ae));
 934         assertEqualInt(AE_SYMLINK_TYPE_FILE, archive_entry_symlink_type(ae));
 935         assertA(0 == archive_read_data(a, NULL, archive_entry_size(ae)));
 936
 937         assertA(0 == archive_read_next_header(a, &ae));
 938         assertEqualString("dirlink", archive_entry_pathname(ae));
 939         assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
 940         assertEqualString("dir", archive_entry_symlink(ae));
 941         assertEqualInt(AE_SYMLINK_TYPE_DIRECTORY, archive_entry_symlink_type(ae));
 942         assertA(0 == archive_read_data(a, NULL, archive_entry_size(ae)));
 943
 944         assertA(0 == archive_read_next_header(a, &ae));
 945         assertEqualString("dir", archive_entry_pathname(ae));
 946         assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
 947         assertA(0 == archive_read_data(a, NULL, archive_entry_size(ae)));
 948
 949         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 950
 951         EPILOGUE();
 952 }
 953
 954 DEFINE_TEST(test_read_format_rar5_hardlink)
 955 {
 956         const int DATA_SIZE = 5;
 957         uint8_t buff[5];
 958
 959         PROLOGUE("test_read_format_rar5_hardlink.rar");
 960
 961         assertA(0 == archive_read_next_header(a, &ae));
 962         assertEqualString("file.txt", archive_entry_pathname(ae));
 963         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 964         assertA((int) archive_entry_mtime(ae) > 0);
 965         assertEqualInt(DATA_SIZE, archive_entry_size(ae));
 966         assertA(DATA_SIZE == archive_read_data(a, buff, DATA_SIZE));
 967
 968         assertA(0 == archive_read_next_header(a, &ae));
 969         assertEqualString("hardlink.txt", archive_entry_pathname(ae));
 970         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 971         assertEqualString("file.txt", archive_entry_hardlink(ae));
 972         assertA(0 == archive_read_data(a, NULL, archive_entry_size(ae)));
 973
 974         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 975
 976         EPILOGUE();
 977 }
 978
 979 DEFINE_TEST(test_read_format_rar5_extra_field_version)
 980 {
 981         PROLOGUE("test_read_format_rar5_extra_field_version.rar");
 982
 983         assertA(0 == archive_read_next_header(a, &ae));
 984         assertEqualString("bin/2to3;1", archive_entry_pathname(ae));
 985         assertA(0 == extract_one(a, ae, 0xF24181B7));
 986
 987         assertA(0 == archive_read_next_header(a, &ae));
 988         assertEqualString("bin/2to3", archive_entry_pathname(ae));
 989         assertA(0 == extract_one(a, ae, 0xF24181B7));
 990
 991         assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
 992
 993         EPILOGUE();
 994 }
 995
 996 DEFINE_TEST(test_read_format_rar5_readtables_overflow)
 997 {
 998         uint8_t buf[16];
 999
1000         PROLOGUE("test_read_format_rar5_readtables_overflow.rar");
1001
1002         /* This archive is invalid. However, processing it shouldn't cause any
1003          * buffer overflow errors during reading rar5 tables. */
1004
1005         (void) archive_read_next_header(a, &ae);
1006         (void) archive_read_data(a, buf, sizeof(buf));
1007         (void) archive_read_next_header(a, &ae);
1008
1009         EPILOGUE();
1010 }
1011
1012 DEFINE_TEST(test_read_format_rar5_leftshift1)
1013 {
1014         uint8_t buf[16];
1015
1016         PROLOGUE("test_read_format_rar5_leftshift1.rar");
1017
1018         /* This archive is invalid. However, processing it shouldn't cause any
1019          * errors related to undefined operations when using -fsanitize. */
1020
1021         (void) archive_read_next_header(a, &ae);
1022         (void) archive_read_data(a, buf, sizeof(buf));
1023         (void) archive_read_next_header(a, &ae);
1024
1025         EPILOGUE();
1026 }
1027
1028 DEFINE_TEST(test_read_format_rar5_leftshift2)
1029 {
1030         uint8_t buf[16];
1031
1032         PROLOGUE("test_read_format_rar5_leftshift2.rar");
1033
1034         /* This archive is invalid. However, processing it shouldn't cause any
1035          * errors related to undefined operations when using -fsanitize. */
1036
1037         (void) archive_read_next_header(a, &ae);
1038         (void) archive_read_data(a, buf, sizeof(buf));
1039         (void) archive_read_next_header(a, &ae);
1040
1041         EPILOGUE();
1042 }
1043
1044 DEFINE_TEST(test_read_format_rar5_truncated_huff)
1045 {
1046         uint8_t buf[16];
1047
1048         PROLOGUE("test_read_format_rar5_truncated_huff.rar");
1049
1050         /* This archive is invalid. However, processing it shouldn't cause any
1051          * errors related to undefined operations when using -fsanitize. */
1052
1053         (void) archive_read_next_header(a, &ae);
1054         (void) archive_read_data(a, buf, sizeof(buf));
1055         (void) archive_read_next_header(a, &ae);
1056
1057         EPILOGUE();
1058 }
1059
1060 DEFINE_TEST(test_read_format_rar5_invalid_dict_reference)
1061 {
1062         uint8_t buf[16];
1063
1064         PROLOGUE("test_read_format_rar5_invalid_dict_reference.rar");
1065
1066         /* This test should fail on parsing the header. */
1067         assertA(archive_read_next_header(a, &ae) != ARCHIVE_OK);
1068
1069         /* This archive is invalid. However, processing it shouldn't cause any
1070          * errors related to buffer underflow when using -fsanitize. */
1071         assertA(archive_read_data(a, buf, sizeof(buf)) <= 0);
1072
1073         /* This test only cares about not returning success here. */
1074         assertA(ARCHIVE_OK != archive_read_next_header(a, &ae));
1075
1076         EPILOGUE();
1077 }
1078
1079 DEFINE_TEST(test_read_format_rar5_distance_overflow)
1080 {
1081         uint8_t buf[16];
1082
1083         PROLOGUE("test_read_format_rar5_distance_overflow.rar");
1084
1085         /* This archive is invalid. However, processing it shouldn't cause any
1086          * errors related to variable overflows when using -fsanitize. */
1087
1088         (void) archive_read_next_header(a, &ae);
1089         (void) archive_read_data(a, buf, sizeof(buf));
1090         (void) archive_read_next_header(a, &ae);
1091
1092         EPILOGUE();
1093 }
1094
1095 DEFINE_TEST(test_read_format_rar5_nonempty_dir_stream)
1096 {
1097         uint8_t buf[16];
1098
1099         PROLOGUE("test_read_format_rar5_nonempty_dir_stream.rar");
1100
1101         /* This archive is invalid. However, processing it shouldn't cause any
1102          * errors related to buffer overflows when using -fsanitize. */
1103
1104         (void) archive_read_next_header(a, &ae);
1105         (void) archive_read_data(a, buf, sizeof(buf));
1106         (void) archive_read_next_header(a, &ae);
1107
1108         EPILOGUE();
1109 }
1110
1111 DEFINE_TEST(test_read_format_rar5_fileattr)
1112 {
1113         unsigned long set, clear, flag;
1114
1115         flag = 0;
1116
1117         PROLOGUE("test_read_format_rar5_fileattr.rar");
1118
1119         assertA(0 == archive_read_next_header(a, &ae));
1120         assertEqualInt(archive_entry_mode(ae), 0444 | AE_IFREG);
1121         assertEqualString("readonly.txt", archive_entry_pathname(ae));
1122         assertEqualString("rdonly", archive_entry_fflags_text(ae));
1123         archive_entry_fflags(ae, &set, &clear);
1124 #if defined(__FreeBSD__)
1125         flag = UF_READONLY;
1126 #elif defined(_WIN32) && !defined(CYGWIN)
1127         flag = FILE_ATTRIBUTE_READONLY;
1128 #endif
1129         assertEqualInt(flag, set & flag);
1130
1131         assertA(0 == archive_read_next_header(a, &ae));
1132         assertEqualInt(archive_entry_mode(ae), 0644 | AE_IFREG);
1133         assertEqualString("hidden.txt", archive_entry_pathname(ae));
1134         assertEqualString("hidden", archive_entry_fflags_text(ae));
1135         archive_entry_fflags(ae, &set, &clear);
1136 #if defined(__FreeBSD__)
1137         flag = UF_HIDDEN;
1138 #elif defined(_WIN32) && !defined(CYGWIN)
1139         flag = FILE_ATTRIBUTE_HIDDEN;
1140 #endif
1141         assertEqualInt(flag, set & flag);
1142
1143         assertA(0 == archive_read_next_header(a, &ae));
1144         assertEqualInt(archive_entry_mode(ae), 0644 | AE_IFREG);
1145         assertEqualString("system.txt", archive_entry_pathname(ae));
1146         assertEqualString("system", archive_entry_fflags_text(ae));
1147         archive_entry_fflags(ae, &set, &clear);
1148 #if defined(__FreeBSD__)
1149         flag = UF_SYSTEM;;
1150 #elif defined(_WIN32) && !defined(CYGWIN)
1151         flag = FILE_ATTRIBUTE_SYSTEM;
1152 #endif
1153         assertEqualInt(flag, set & flag);
1154
1155         assertA(0 == archive_read_next_header(a, &ae));
1156         assertEqualInt(archive_entry_mode(ae), 0444 | AE_IFREG);
1157         assertEqualString("ro_hidden.txt", archive_entry_pathname(ae));
1158         assertEqualString("rdonly,hidden", archive_entry_fflags_text(ae));
1159         archive_entry_fflags(ae, &set, &clear);
1160 #if defined(__FreeBSD__)
1161         flag = UF_READONLY | UF_HIDDEN;
1162 #elif defined(_WIN32) && !defined(CYGWIN)
1163         flag = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN;
1164 #endif
1165         assertEqualInt(flag, set & flag);
1166
1167         assertA(0 == archive_read_next_header(a, &ae));
1168         assertEqualInt(archive_entry_mode(ae), 0555 | AE_IFDIR);
1169         assertEqualString("dir_readonly", archive_entry_pathname(ae));
1170         assertEqualString("rdonly", archive_entry_fflags_text(ae));
1171         archive_entry_fflags(ae, &set, &clear);
1172 #if defined(__FreeBSD__)
1173         flag = UF_READONLY;
1174 #elif defined(_WIN32) && !defined(CYGWIN)
1175         flag = FILE_ATTRIBUTE_READONLY;
1176 #endif
1177         assertEqualInt(flag, set & flag);
1178
1179         assertA(0 == archive_read_next_header(a, &ae));
1180         assertEqualInt(archive_entry_mode(ae), 0755 | AE_IFDIR);
1181         assertEqualString("dir_hidden", archive_entry_pathname(ae));
1182         assertEqualString("hidden", archive_entry_fflags_text(ae));
1183         archive_entry_fflags(ae, &set, &clear);
1184 #if defined(__FreeBSD__)
1185         flag = UF_HIDDEN;
1186 #elif defined(_WIN32) && !defined(CYGWIN)
1187         flag = FILE_ATTRIBUTE_HIDDEN;
1188 #endif
1189         assertEqualInt(flag, set & flag);
1190
1191         assertA(0 == archive_read_next_header(a, &ae));
1192         assertEqualInt(archive_entry_mode(ae), 0755 | AE_IFDIR);
1193         assertEqualString("dir_system", archive_entry_pathname(ae));
1194         assertEqualString("system", archive_entry_fflags_text(ae));
1195         archive_entry_fflags(ae, &set, &clear);
1196 #if defined(__FreeBSD__)
1197         flag = UF_SYSTEM;
1198 #elif defined(_WIN32) && !defined(CYGWIN)
1199         flag = FILE_ATTRIBUTE_SYSTEM;
1200 #endif
1201         assertEqualInt(flag, set & flag);
1202
1203         assertA(0 == archive_read_next_header(a, &ae));
1204         assertEqualInt(archive_entry_mode(ae), 0555 | AE_IFDIR);
1205         assertEqualString("dir_rohidden", archive_entry_pathname(ae));
1206         assertEqualString("rdonly,hidden", archive_entry_fflags_text(ae));
1207         archive_entry_fflags(ae, &set, &clear);
1208 #if defined(__FreeBSD__)
1209         flag = UF_READONLY | UF_HIDDEN;
1210 #elif defined(_WIN32) && !defined(CYGWIN)
1211         flag = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN;
1212 #endif
1213         assertEqualInt(flag, set & flag);
1214
1215         EPILOGUE();
1216 }
1217
1218 DEFINE_TEST(test_read_format_rar5_different_window_size)
1219 {
1220         char buf[4096];
1221         PROLOGUE("test_read_format_rar5_different_window_size.rar");
1222
1223         /* Return codes of those calls are ignored, because this sample file
1224          * is invalid. However, the unpacker shouldn't produce any SIGSEGV
1225          * errors during processing. */
1226
1227         (void) archive_read_next_header(a, &ae);
1228         while(0 < archive_read_data(a, buf, sizeof(buf))) {}
1229
1230         (void) archive_read_next_header(a, &ae);
1231         while(0 < archive_read_data(a, buf, sizeof(buf))) {}
1232
1233         (void) archive_read_next_header(a, &ae);
1234         while(0 < archive_read_data(a, buf, sizeof(buf))) {}
1235
1236         EPILOGUE();
1237 }
1238
1239 DEFINE_TEST(test_read_format_rar5_window_buf_and_size_desync)
1240 {
1241         /* oss fuzz 30442 */
1242
1243         char buf[4096];
1244         PROLOGUE("test_read_format_rar5_window_buf_and_size_desync.rar");
1245
1246         /* Return codes of those calls are ignored, because this sample file
1247          * is invalid. However, the unpacker shouldn't produce any SIGSEGV
1248          * errors during processing. */
1249
1250         (void) archive_read_next_header(a, &ae);
1251         while(0 < archive_read_data(a, buf, 46)) {}
1252
1253         EPILOGUE();
1254 }
1255
1256 DEFINE_TEST(test_read_format_rar5_arm_filter_on_window_boundary)
1257 {
1258         char buf[4096];
1259         PROLOGUE("test_read_format_rar5_arm_filter_on_window_boundary.rar");
1260
1261         /* Return codes of those calls are ignored, because this sample file
1262          * is invalid. However, the unpacker shouldn't produce any SIGSEGV
1263          * errors during processing. */
1264
1265         (void) archive_read_next_header(a, &ae);
1266         while(0 < archive_read_data(a, buf, sizeof(buf))) {}
1267
1268         EPILOGUE();
1269 }
1270
1271 DEFINE_TEST(test_read_format_rar5_different_solid_window_size)
1272 {
1273         char buf[4096];
1274         PROLOGUE("test_read_format_rar5_different_solid_window_size.rar");
1275
1276         /* Return codes of those calls are ignored, because this sample file
1277          * is invalid. However, the unpacker shouldn't produce any SIGSEGV
1278          * errors during processing. */
1279
1280         (void) archive_read_next_header(a, &ae);
1281         while(0 < archive_read_data(a, buf, sizeof(buf))) {}
1282
1283         (void) archive_read_next_header(a, &ae);
1284         while(0 < archive_read_data(a, buf, sizeof(buf))) {}
1285
1286         (void) archive_read_next_header(a, &ae);
1287         while(0 < archive_read_data(a, buf, sizeof(buf))) {}
1288
1289         EPILOGUE();
1290 }
1291
1292 DEFINE_TEST(test_read_format_rar5_different_winsize_on_merge)
1293 {
1294         char buf[4096];
1295         PROLOGUE("test_read_format_rar5_different_winsize_on_merge.rar");
1296
1297         /* Return codes of those calls are ignored, because this sample file
1298          * is invalid. However, the unpacker shouldn't produce any SIGSEGV
1299          * errors during processing. */
1300
1301         (void) archive_read_next_header(a, &ae);
1302         while(0 < archive_read_data(a, buf, sizeof(buf))) {}
1303
1304         EPILOGUE();
1305 }
1306
1307 DEFINE_TEST(test_read_format_rar5_block_size_is_too_small)
1308 {
1309         char buf[4096];
1310         PROLOGUE("test_read_format_rar5_block_size_is_too_small.rar");
1311
1312         /* This file is damaged, so those functions should return failure.
1313          * Additionally, SIGSEGV shouldn't be raised during execution
1314          * of those functions. */
1315
1316         assertA(archive_read_next_header(a, &ae) != ARCHIVE_OK);
1317         assertA(archive_read_data(a, buf, sizeof(buf)) <= 0);
1318
1319         EPILOGUE();
1320 }
1321
1322 DEFINE_TEST(test_read_format_rar5_sfx)
1323 {
1324         struct archive *a;
1325         struct archive_entry *ae;
1326         int bs = 10240;
1327         char buff[32];
1328         const char reffile[] = "test_read_format_rar5_sfx.exe";
1329         const char test_txt[] = "123";
1330         int size = sizeof(test_txt) - 1;
1331
1332         extract_reference_file(reffile);
1333         assert((a = archive_read_new()) != NULL);
1334         assertA(0 == archive_read_support_filter_all(a));
1335         assertA(0 == archive_read_support_format_all(a));
1336         assertA(0 == archive_read_open_filename(a, reffile, bs));
1337
1338         assertA(0 == archive_read_next_header(a, &ae));
1339         assertEqualString("test.txt.txt", archive_entry_pathname(ae));
1340
1341         assertA(size == archive_read_data(a, buff, size));
1342         assertEqualMem(buff, test_txt, size);
1343
1344         EPILOGUE();
1345 }
1346
1347 DEFINE_TEST(test_read_format_rar5_decode_number_out_of_bounds_read)
1348 {
1349         /* oss fuzz 30448 */
1350
1351         char buf[4096];
1352         PROLOGUE("test_read_format_rar5_decode_number_out_of_bounds_read.rar");
1353
1354         /* Return codes of those calls are ignored, because this sample file
1355          * is invalid. However, the unpacker shouldn't produce any SIGSEGV
1356          * errors during processing. */
1357
1358         (void) archive_read_next_header(a, &ae);
1359         while(0 < archive_read_data(a, buf, sizeof(buf))) {}
1360
1361         EPILOGUE();
1362 }
1363
1364 DEFINE_TEST(test_read_format_rar5_bad_window_size_in_multiarchive_file)
1365 {
1366         /* oss fuzz 30459 */
1367
1368         char buf[4096];
1369         PROLOGUE("test_read_format_rar5_bad_window_sz_in_mltarc_file.rar");
1370
1371         /* This file is damaged, so those functions should return failure.
1372          * Additionally, SIGSEGV shouldn't be raised during execution
1373          * of those functions. */
1374
1375         (void) archive_read_next_header(a, &ae);
1376         while(0 < archive_read_data(a, buf, sizeof(buf))) {}
1377         (void) archive_read_next_header(a, &ae);
1378         while(0 < archive_read_data(a, buf, sizeof(buf))) {}
1379
1380         EPILOGUE();
1381 }
1382
1383 DEFINE_TEST(test_read_format_rar5_read_data_block_uninitialized_offset)
1384 {
1385         const void *buf;
1386         size_t size;
1387         la_int64_t offset;
1388
1389         PROLOGUE("test_read_format_rar5_compressed.rar");
1390         assertA(0 == archive_read_next_header(a, &ae));
1391
1392         /* A real code may pass a pointer to an uninitialized variable as an offset
1393          * output argument. Here we want to check this situation. But because
1394          * relying on a value of an uninitialized variable in a test is not a good
1395          * idea, let's pretend that 0xdeadbeef is a random value of the
1396          * uninitialized variable. */
1397         offset = 0xdeadbeef;
1398         assertEqualInt(ARCHIVE_OK, archive_read_data_block(a, &buf, &size, &offset));
1399         /* The test archive doesn't contain a sparse file. And because of that, here
1400          * we assume that the first returned offset should be 0. */
1401         assertEqualInt(0, offset);
1402
1403         EPILOGUE();
1404 }