contrib/libarchive/libarchive/test/test_write_read_format_zip.c

   1 /*-
   2  * Copyright (c) 2003-2008 Tim Kientzle
   3  * Copyright (c) 2008 Anselm Strauss
   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
  27 /*
  28  * Development supported by Google Summer of Code 2008.
  29  */
  30
  31 #include "test.h"
  32 __FBSDID("$FreeBSD$");
  33
  34 /*
  35  * These tests verify that our reader can read files
  36  * created by our writer.
  37  */
  38
  39 /*
  40  * Write a variety of different file types into the archive.
  41  */
  42 static void
  43 write_contents(struct archive *a)
  44 {
  45         struct archive_entry *ae;
  46
  47         /*
  48          * First write things with the "default" compression.
  49          * The library will choose "deflate" for most things if it's
  50          * available, else "store".
  51          */
  52
  53         /*
  54          * Write a file to it.
  55          */
  56         assert((ae = archive_entry_new()) != NULL);
  57         archive_entry_set_mtime(ae, 1, 10);
  58         archive_entry_copy_pathname(ae, "file");
  59         archive_entry_set_mode(ae, AE_IFREG | 0755);
  60         archive_entry_set_size(ae, 8);
  61         assertEqualInt(0, archive_write_header(a, ae));
  62         archive_entry_free(ae);
  63         assertEqualInt(8, archive_write_data(a, "12345678", 9));
  64         assertEqualInt(0, archive_write_data(a, "1", 1));
  65
  66         /*
  67          * Write another file to it.
  68          */
  69         assert((ae = archive_entry_new()) != NULL);
  70         archive_entry_set_mtime(ae, 1, 10);
  71         archive_entry_copy_pathname(ae, "file2");
  72         archive_entry_set_mode(ae, AE_IFREG | 0755);
  73         archive_entry_set_size(ae, 4);
  74         assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae));
  75         archive_entry_free(ae);
  76         assertEqualInt(4, archive_write_data(a, "1234", 4));
  77
  78         /*
  79          * Write a file with an unknown size.
  80          */
  81         assert((ae = archive_entry_new()) != NULL);
  82         archive_entry_set_mtime(ae, 2, 15);
  83         archive_entry_copy_pathname(ae, "file3");
  84         archive_entry_set_mode(ae, AE_IFREG | 0621);
  85         archive_entry_unset_size(ae);
  86         assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae));
  87         archive_entry_free(ae);
  88         assertEqualInt(5, archive_write_data(a, "mnopq", 5));
  89
  90         /*
  91          * Write symbolic link.
  92          */
  93         assert((ae = archive_entry_new()) != NULL);
  94         archive_entry_set_mtime(ae, 1, 10);
  95         assertEqualInt(1, archive_entry_mtime(ae));
  96         assertEqualInt(10, archive_entry_mtime_nsec(ae));
  97         archive_entry_copy_pathname(ae, "symlink");
  98         assertEqualString("symlink", archive_entry_pathname(ae));
  99         archive_entry_copy_symlink(ae, "file1");
 100         assertEqualString("file1", archive_entry_symlink(ae));
 101         archive_entry_set_mode(ae, AE_IFLNK | 0755);
 102         assertEqualInt((AE_IFLNK | 0755), archive_entry_mode(ae));
 103         archive_entry_set_size(ae, 4);
 104
 105         assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae));
 106         archive_entry_free(ae);
 107
 108         /*
 109          * Write a directory to it.
 110          */
 111         assert((ae = archive_entry_new()) != NULL);
 112         archive_entry_set_mtime(ae, 11, 110);
 113         archive_entry_copy_pathname(ae, "dir");
 114         archive_entry_set_mode(ae, S_IFDIR | 0755);
 115         archive_entry_set_size(ae, 512);
 116         assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
 117         failure("size should be zero so that applications know not to write");
 118         assertEqualInt(0, archive_entry_size(ae));
 119         archive_entry_free(ae);
 120         assertEqualIntA(a, 0, archive_write_data(a, "12345678", 9));
 121
 122         /*
 123          * Force "deflate" compression if the platform supports it.
 124          */
 125 #ifdef HAVE_ZLIB_H
 126         assertEqualIntA(a, ARCHIVE_OK, archive_write_zip_set_compression_deflate(a));
 127
 128         /*
 129          * Write a file to it.
 130          */
 131         assert((ae = archive_entry_new()) != NULL);
 132         archive_entry_set_mtime(ae, 1, 10);
 133         archive_entry_copy_pathname(ae, "file_deflate");
 134         archive_entry_set_mode(ae, AE_IFREG | 0755);
 135         archive_entry_set_size(ae, 8);
 136         assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
 137         archive_entry_free(ae);
 138         assertEqualInt(8, archive_write_data(a, "12345678", 9));
 139         assertEqualInt(0, archive_write_data(a, "1", 1));
 140
 141         /*
 142          * Write another file to it.
 143          */
 144         assert((ae = archive_entry_new()) != NULL);
 145         archive_entry_set_mtime(ae, 1, 10);
 146         archive_entry_copy_pathname(ae, "file2_deflate");
 147         archive_entry_set_mode(ae, AE_IFREG | 0755);
 148         archive_entry_set_size(ae, 4);
 149         assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
 150         archive_entry_free(ae);
 151         assertEqualInt(4, archive_write_data(a, "1234", 4));
 152
 153         /*
 154          * Write a file with an unknown size.
 155          */
 156         assert((ae = archive_entry_new()) != NULL);
 157         archive_entry_set_mtime(ae, 2, 15);
 158         archive_entry_copy_pathname(ae, "file3_deflate");
 159         archive_entry_set_mode(ae, AE_IFREG | 0621);
 160         archive_entry_unset_size(ae);
 161         assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae));
 162         archive_entry_free(ae);
 163         assertEqualInt(5, archive_write_data(a, "ghijk", 5));
 164
 165         /*
 166          * Write symbolic like file to it.
 167          */
 168         assert((ae = archive_entry_new()) != NULL);
 169         archive_entry_set_mtime(ae, 1, 10);
 170         archive_entry_copy_pathname(ae, "symlink_deflate");
 171         archive_entry_copy_symlink(ae, "file1");
 172         archive_entry_set_mode(ae, AE_IFLNK | 0755);
 173         archive_entry_set_size(ae, 4);
 174         assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae));
 175         archive_entry_free(ae);
 176
 177         /*
 178          * Write a directory to it.
 179          */
 180         assert((ae = archive_entry_new()) != NULL);
 181         archive_entry_set_mtime(ae, 11, 110);
 182         archive_entry_copy_pathname(ae, "dir_deflate");
 183         archive_entry_set_mode(ae, S_IFDIR | 0755);
 184         archive_entry_set_size(ae, 512);
 185         assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
 186         failure("size should be zero so that applications know not to write");
 187         assertEqualInt(0, archive_entry_size(ae));
 188         archive_entry_free(ae);
 189         assertEqualIntA(a, 0, archive_write_data(a, "12345678", 9));
 190         assertEqualIntA(a, ARCHIVE_OK, archive_write_finish_entry(a));
 191 #endif
 192
 193         /*
 194          * Now write a bunch of entries with "store" compression.
 195          */
 196         assertEqualIntA(a, ARCHIVE_OK, archive_write_zip_set_compression_store(a));
 197
 198         /*
 199          * Write a file to it.
 200          */
 201         assert((ae = archive_entry_new()) != NULL);
 202         archive_entry_set_mtime(ae, 1, 10);
 203         archive_entry_copy_pathname(ae, "file_stored");
 204         archive_entry_set_mode(ae, AE_IFREG | 0755);
 205         archive_entry_set_size(ae, 8);
 206         assertEqualInt(0, archive_write_header(a, ae));
 207         archive_entry_free(ae);
 208         assertEqualInt(8, archive_write_data(a, "12345678", 9));
 209         assertEqualInt(0, archive_write_data(a, "1", 1));
 210
 211         /*
 212          * Write another file to it.
 213          */
 214         assert((ae = archive_entry_new()) != NULL);
 215         archive_entry_set_mtime(ae, 1, 10);
 216         archive_entry_copy_pathname(ae, "file2_stored");
 217         archive_entry_set_mode(ae, AE_IFREG | 0755);
 218         archive_entry_set_size(ae, 4);
 219         assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae));
 220         archive_entry_free(ae);
 221         assertEqualInt(4, archive_write_data(a, "ACEG", 4));
 222
 223         /*
 224          * Write a file with an unknown size.
 225          */
 226         assert((ae = archive_entry_new()) != NULL);
 227         archive_entry_set_mtime(ae, 2, 15);
 228         archive_entry_copy_pathname(ae, "file3_stored");
 229         archive_entry_set_mode(ae, AE_IFREG | 0621);
 230         archive_entry_unset_size(ae);
 231         assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae));
 232         archive_entry_free(ae);
 233         assertEqualInt(5, archive_write_data(a, "ijklm", 5));
 234
 235         /*
 236          * Write symbolic like file to it.
 237          */
 238         assert((ae = archive_entry_new()) != NULL);
 239         archive_entry_set_mtime(ae, 1, 10);
 240         archive_entry_copy_pathname(ae, "symlink_stored");
 241         archive_entry_copy_symlink(ae, "file1");
 242         archive_entry_set_mode(ae, AE_IFLNK | 0755);
 243         archive_entry_set_size(ae, 4);
 244         assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae));
 245         archive_entry_free(ae);
 246
 247         /*
 248          * Write a directory to it.
 249          */
 250         assert((ae = archive_entry_new()) != NULL);
 251         archive_entry_set_mtime(ae, 11, 110);
 252         archive_entry_copy_pathname(ae, "dir_stored");
 253         archive_entry_set_mode(ae, S_IFDIR | 0755);
 254         archive_entry_set_size(ae, 512);
 255         assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
 256         failure("size should be zero so that applications know not to write");
 257         assertEqualInt(0, archive_entry_size(ae));
 258         archive_entry_free(ae);
 259         assertEqualIntA(a, 0, archive_write_data(a, "12345678", 9));
 260
 261
 262         /* Close out the archive. */
 263         assertEqualInt(ARCHIVE_OK, archive_write_close(a));
 264         assertEqualInt(ARCHIVE_OK, archive_write_free(a));
 265 }
 266
 267 /*
 268  * Read back all of the entries and verify their values.
 269  */
 270 static void
 271 verify_contents(struct archive *a, int seeking, int improved_streaming)
 272 {
 273         char filedata[64];
 274         struct archive_entry *ae;
 275
 276         /*
 277          * Default compression options:
 278          */
 279
 280         /* Read and verify first file. */
 281         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 282         assertEqualInt(1, archive_entry_mtime(ae));
 283         /* Zip doesn't store high-resolution mtime. */
 284         assertEqualInt(0, archive_entry_mtime_nsec(ae));
 285         assertEqualInt(0, archive_entry_atime(ae));
 286         assertEqualInt(0, archive_entry_ctime(ae));
 287         assertEqualString("file", archive_entry_pathname(ae));
 288         if (seeking || improved_streaming) {
 289                 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
 290         }
 291         assertEqualInt(8, archive_entry_size(ae));
 292         assert(archive_entry_size_is_set(ae));
 293         assertEqualIntA(a, 8,
 294             archive_read_data(a, filedata, sizeof(filedata)));
 295         assertEqualMem(filedata, "12345678", 8);
 296
 297
 298         /* Read the second file back. */
 299         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 300         assertEqualInt(1, archive_entry_mtime(ae));
 301         assertEqualInt(0, archive_entry_mtime_nsec(ae));
 302         assertEqualInt(0, archive_entry_atime(ae));
 303         assertEqualInt(0, archive_entry_ctime(ae));
 304         assertEqualString("file2", archive_entry_pathname(ae));
 305         if (seeking || improved_streaming) {
 306                 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
 307         }
 308         assertEqualInt(4, archive_entry_size(ae));
 309         assert(archive_entry_size_is_set(ae));
 310         assertEqualIntA(a, 4,
 311             archive_read_data(a, filedata, sizeof(filedata)));
 312         assertEqualMem(filedata, "1234", 4);
 313
 314         /* Read the third file back. */
 315         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 316         assertEqualInt(2, archive_entry_mtime(ae));
 317         assertEqualInt(0, archive_entry_mtime_nsec(ae));
 318         assertEqualInt(0, archive_entry_atime(ae));
 319         assertEqualInt(0, archive_entry_ctime(ae));
 320         assertEqualString("file3", archive_entry_pathname(ae));
 321         if (seeking || improved_streaming) {
 322                 assertEqualInt(AE_IFREG | 0621, archive_entry_mode(ae));
 323         }
 324         if (seeking) {
 325                 assertEqualInt(5, archive_entry_size(ae));
 326         } else {
 327                 assertEqualInt(0, archive_entry_size_is_set(ae));
 328         }
 329         assertEqualIntA(a, 5,
 330             archive_read_data(a, filedata, sizeof(filedata)));
 331         assertEqualMem(filedata, "mnopq", 5);
 332
 333         /* Read symlink. */
 334         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 335         assertEqualInt(1, archive_entry_mtime(ae));
 336         assertEqualInt(0, archive_entry_mtime_nsec(ae));
 337         assertEqualInt(0, archive_entry_atime(ae));
 338         assertEqualInt(0, archive_entry_ctime(ae));
 339         assertEqualString("symlink", archive_entry_pathname(ae));
 340         if (seeking || improved_streaming) {
 341                 assertEqualInt(AE_IFLNK | 0755, archive_entry_mode(ae));
 342                 assertEqualInt(0, archive_entry_size(ae));
 343                 assertEqualString("file1", archive_entry_symlink(ae));
 344         } else {
 345                 /* Streaming cannot read file type, so
 346                  * symlink body shows as regular file contents. */
 347                 assertEqualInt(AE_IFREG | 0664, archive_entry_mode(ae));
 348                 assertEqualInt(5, archive_entry_size(ae));
 349                 assert(archive_entry_size_is_set(ae));
 350         }
 351
 352         /* Read the dir entry back. */
 353         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 354         assertEqualInt(11, archive_entry_mtime(ae));
 355         assertEqualInt(0, archive_entry_mtime_nsec(ae));
 356         assertEqualInt(0, archive_entry_atime(ae));
 357         assertEqualInt(0, archive_entry_ctime(ae));
 358         assertEqualString("dir/", archive_entry_pathname(ae));
 359         if (seeking || improved_streaming)
 360                 assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae));
 361         assertEqualInt(0, archive_entry_size(ae));
 362         assert(archive_entry_size_is_set(ae));
 363         assertEqualIntA(a, 0, archive_read_data(a, filedata, 10));
 364
 365 #ifdef HAVE_ZLIB_H
 366         /*
 367          * Deflate compression option:
 368          */
 369
 370         /* Read and verify first file. */
 371         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 372         assertEqualInt(1, archive_entry_mtime(ae));
 373         /* Zip doesn't store high-resolution mtime. */
 374         assertEqualInt(0, archive_entry_mtime_nsec(ae));
 375         assertEqualInt(0, archive_entry_atime(ae));
 376         assertEqualInt(0, archive_entry_ctime(ae));
 377         assertEqualString("file_deflate", archive_entry_pathname(ae));
 378         if (seeking || improved_streaming) {
 379                 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
 380         }
 381         assertEqualInt(8, archive_entry_size(ae));
 382         assert(archive_entry_size_is_set(ae));
 383         assertEqualIntA(a, 8,
 384             archive_read_data(a, filedata, sizeof(filedata)));
 385         assertEqualMem(filedata, "12345678", 8);
 386
 387
 388         /* Read the second file back. */
 389         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 390         assertEqualInt(1, archive_entry_mtime(ae));
 391         assertEqualInt(0, archive_entry_mtime_nsec(ae));
 392         assertEqualInt(0, archive_entry_atime(ae));
 393         assertEqualInt(0, archive_entry_ctime(ae));
 394         assertEqualString("file2_deflate", archive_entry_pathname(ae));
 395         if (seeking || improved_streaming) {
 396                 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
 397         }
 398         assertEqualInt(4, archive_entry_size(ae));
 399         assert(archive_entry_size_is_set(ae));
 400         assertEqualIntA(a, 4,
 401             archive_read_data(a, filedata, sizeof(filedata)));
 402         assertEqualMem(filedata, "1234", 4);
 403
 404         /* Read the third file back. */
 405         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 406         assertEqualInt(2, archive_entry_mtime(ae));
 407         assertEqualInt(0, archive_entry_mtime_nsec(ae));
 408         assertEqualInt(0, archive_entry_atime(ae));
 409         assertEqualInt(0, archive_entry_ctime(ae));
 410         assertEqualString("file3_deflate", archive_entry_pathname(ae));
 411         if (seeking || improved_streaming) {
 412                 assertEqualInt(AE_IFREG | 0621, archive_entry_mode(ae));
 413         }
 414         if (seeking) {
 415                 assertEqualInt(5, archive_entry_size(ae));
 416         } else {
 417                 assertEqualInt(0, archive_entry_size_is_set(ae));
 418         }
 419         assertEqualIntA(a, 5,
 420             archive_read_data(a, filedata, sizeof(filedata)));
 421         assertEqualMem(filedata, "ghijk", 4);
 422
 423         /* Read symlink. */
 424         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 425         assertEqualInt(1, archive_entry_mtime(ae));
 426         assertEqualInt(0, archive_entry_mtime_nsec(ae));
 427         assertEqualInt(0, archive_entry_atime(ae));
 428         assertEqualInt(0, archive_entry_ctime(ae));
 429         assertEqualString("symlink_deflate", archive_entry_pathname(ae));
 430         if (seeking || improved_streaming) {
 431                 assertEqualInt(AE_IFLNK | 0755, archive_entry_mode(ae));
 432                 assertEqualInt(0, archive_entry_size(ae));
 433                 assertEqualString("file1", archive_entry_symlink(ae));
 434         } else {
 435                 assertEqualInt(AE_IFREG | 0664, archive_entry_mode(ae));
 436                 assertEqualInt(5, archive_entry_size(ae));
 437                 assertEqualIntA(a, 5, archive_read_data(a, filedata, 10));
 438                 assertEqualMem(filedata, "file1", 5);
 439         }
 440
 441         /* Read the dir entry back. */
 442         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 443         assertEqualInt(11, archive_entry_mtime(ae));
 444         assertEqualInt(0, archive_entry_mtime_nsec(ae));
 445         assertEqualInt(0, archive_entry_atime(ae));
 446         assertEqualInt(0, archive_entry_ctime(ae));
 447         assertEqualString("dir_deflate/", archive_entry_pathname(ae));
 448         if (seeking) {
 449                 assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae));
 450         }
 451         assertEqualInt(0, archive_entry_size(ae));
 452         assert(archive_entry_size_is_set(ae));
 453         assertEqualIntA(a, 0, archive_read_data(a, filedata, 10));
 454 #endif
 455
 456         /*
 457          * Store compression option:
 458          */
 459
 460         /* Read and verify first file. */
 461         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 462         assertEqualInt(1, archive_entry_mtime(ae));
 463         /* Zip doesn't store high-resolution mtime. */
 464         assertEqualInt(0, archive_entry_mtime_nsec(ae));
 465         assertEqualInt(0, archive_entry_atime(ae));
 466         assertEqualInt(0, archive_entry_ctime(ae));
 467         assertEqualString("file_stored", archive_entry_pathname(ae));
 468         if (seeking || improved_streaming) {
 469                 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
 470         }
 471         assert(archive_entry_size_is_set(ae));
 472         assert(archive_entry_size_is_set(ae));
 473         assertEqualInt(8, archive_entry_size(ae));
 474         assertEqualIntA(a, 8,
 475             archive_read_data(a, filedata, sizeof(filedata)));
 476         assertEqualMem(filedata, "12345678", 8);
 477
 478
 479         /* Read the second file back. */
 480         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 481         assertEqualInt(1, archive_entry_mtime(ae));
 482         assertEqualInt(0, archive_entry_mtime_nsec(ae));
 483         assertEqualInt(0, archive_entry_atime(ae));
 484         assertEqualInt(0, archive_entry_ctime(ae));
 485         assertEqualString("file2_stored", archive_entry_pathname(ae));
 486         if (seeking || improved_streaming) {
 487                 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
 488         }
 489         assertEqualInt(4, archive_entry_size(ae));
 490         assert(archive_entry_size_is_set(ae));
 491         assertEqualIntA(a, 4,
 492             archive_read_data(a, filedata, sizeof(filedata)));
 493         assertEqualMem(filedata, "ACEG", 4);
 494
 495         /* Read the third file back. */
 496         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 497         assertEqualInt(2, archive_entry_mtime(ae));
 498         assertEqualInt(0, archive_entry_mtime_nsec(ae));
 499         assertEqualInt(0, archive_entry_atime(ae));
 500         assertEqualInt(0, archive_entry_ctime(ae));
 501         assertEqualString("file3_stored", archive_entry_pathname(ae));
 502         if (seeking || improved_streaming)
 503                 assertEqualInt(AE_IFREG | 0621, archive_entry_mode(ae));
 504         if (seeking) {
 505                 assertEqualInt(5, archive_entry_size(ae));
 506         } else {
 507                 assertEqualInt(0, archive_entry_size_is_set(ae));
 508         }
 509         assertEqualIntA(a, 5,
 510             archive_read_data(a, filedata, sizeof(filedata)));
 511         assertEqualMem(filedata, "ijklm", 4);
 512
 513         /* Read symlink. */
 514         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 515         assertEqualInt(1, archive_entry_mtime(ae));
 516         assertEqualInt(0, archive_entry_mtime_nsec(ae));
 517         assertEqualInt(0, archive_entry_atime(ae));
 518         assertEqualInt(0, archive_entry_ctime(ae));
 519         assertEqualString("symlink_stored", archive_entry_pathname(ae));
 520         if (seeking || improved_streaming) {
 521                 assertEqualInt(AE_IFLNK | 0755, archive_entry_mode(ae));
 522                 assertEqualInt(0, archive_entry_size(ae));
 523                 assertEqualString("file1", archive_entry_symlink(ae));
 524         } else {
 525                 assertEqualInt(AE_IFREG | 0664, archive_entry_mode(ae));
 526                 assertEqualInt(5, archive_entry_size(ae));
 527                 assertEqualIntA(a, 5, archive_read_data(a, filedata, 10));
 528                 assertEqualMem(filedata, "file1", 5);
 529         }
 530
 531         /* Read the dir entry back. */
 532         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 533         assertEqualInt(11, archive_entry_mtime(ae));
 534         assertEqualInt(0, archive_entry_mtime_nsec(ae));
 535         assertEqualInt(0, archive_entry_atime(ae));
 536         assertEqualInt(0, archive_entry_ctime(ae));
 537         assertEqualString("dir_stored/", archive_entry_pathname(ae));
 538         if (seeking || improved_streaming)
 539                 assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae));
 540         assertEqualInt(0, archive_entry_size(ae));
 541         assertEqualIntA(a, 0, archive_read_data(a, filedata, 10));
 542
 543         /* Verify the end of the archive. */
 544         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 545         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 546         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 547 }
 548
 549 /*
 550  * Do a write-then-read roundtrip.
 551  */
 552 DEFINE_TEST(test_write_read_format_zip)
 553 {
 554         struct archive *a;
 555         size_t used;
 556         size_t buffsize = 1000000;
 557         char *buff;
 558
 559         buff = malloc(buffsize);
 560
 561         /* Create a new archive in memory. */
 562         assert((a = archive_write_new()) != NULL);
 563         assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a));
 564         assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
 565         assertEqualIntA(a, ARCHIVE_OK,
 566             archive_write_open_memory(a, buff, buffsize, &used));
 567         write_contents(a);
 568         dumpfile("constructed.zip", buff, used);
 569
 570         /*
 571          * Now, read the data back.
 572          */
 573         /* With the standard memory reader. */
 574         assert((a = archive_read_new()) != NULL);
 575         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 576         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 577         assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
 578         verify_contents(a, 1, 0);
 579
 580         /* With the test memory reader -- streaming mode. */
 581         assert((a = archive_read_new()) != NULL);
 582         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 583         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 584         assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, buff, used, 7));
 585         /* Streaming reader doesn't see mode information from Central Directory. */
 586         verify_contents(a, 0, 0);
 587
 588         /* With the test memory reader -- seeking mode. */
 589         assert((a = archive_read_new()) != NULL);
 590         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 591         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 592         assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7));
 593         verify_contents(a, 1, 0);
 594
 595         free(buff);
 596 }
 597
 598 /*
 599  * Do a write-then-read roundtrip with 'el' extension enabled.
 600  */
 601 DEFINE_TEST(test_write_read_format_zip_improved_streaming)
 602 {
 603         struct archive *a;
 604         size_t used;
 605         size_t buffsize = 1000000;
 606         char *buff;
 607
 608         buff = malloc(buffsize);
 609
 610         /* Create a new archive in memory. */
 611         assert((a = archive_write_new()) != NULL);
 612         assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a));
 613         assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
 614         assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "zip:experimental"));
 615         assertEqualIntA(a, ARCHIVE_OK,
 616             archive_write_open_memory(a, buff, buffsize, &used));
 617         write_contents(a);
 618         dumpfile("constructed.zip", buff, used);
 619
 620         /*
 621          * Now, read the data back.
 622          */
 623         /* With the standard memory reader. */
 624         assert((a = archive_read_new()) != NULL);
 625         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 626         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 627         assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
 628         verify_contents(a, 1, 1);
 629
 630         /* With the test memory reader -- streaming mode. */
 631         assert((a = archive_read_new()) != NULL);
 632         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 633         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 634         assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, buff, used, 7));
 635         /* Streaming reader doesn't see mode information from Central Directory. */
 636         verify_contents(a, 0, 1);
 637
 638         /* With the test memory reader -- seeking mode. */
 639         assert((a = archive_read_new()) != NULL);
 640         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 641         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 642         assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7));
 643         verify_contents(a, 1, 1);
 644
 645         free(buff);
 646 }
 647
 648 /*
 649  * Do a write-then-read roundtrip with Zip64 enabled.
 650  */
 651 DEFINE_TEST(test_write_read_format_zip64)
 652 {
 653         struct archive *a;
 654         size_t used;
 655         size_t buffsize = 1000000;
 656         char *buff;
 657
 658         buff = malloc(buffsize);
 659
 660         /* Create a new archive in memory. */
 661         assert((a = archive_write_new()) != NULL);
 662         assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a));
 663         assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
 664         assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "zip:zip64"));
 665 #if ZIP_IMPROVED_STREAMING
 666         assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "zip:experimental"));
 667 #endif
 668         assertEqualIntA(a, ARCHIVE_OK,
 669             archive_write_open_memory(a, buff, buffsize, &used));
 670         write_contents(a);
 671         dumpfile("constructed64.zip", buff, used);
 672
 673         /*
 674          * Now, read the data back.
 675          */
 676         /* With the standard memory reader. */
 677         assert((a = archive_read_new()) != NULL);
 678         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 679         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 680         assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
 681         verify_contents(a, 1, 0);
 682
 683         /* With the test memory reader -- streaming mode. */
 684         assert((a = archive_read_new()) != NULL);
 685         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 686         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 687         assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, buff, used, 7));
 688         /* Streaming reader doesn't see mode information from Central Directory. */
 689         verify_contents(a, 0, 0);
 690
 691         /* With the test memory reader -- seeking mode. */
 692         assert((a = archive_read_new()) != NULL);
 693         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 694         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 695         assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7));
 696         verify_contents(a, 1, 0);
 697
 698         free(buff);
 699 }
 700
 701
 702 /*
 703  * Do a write-then-read roundtrip with Zip64 enabled and 'el' extension enabled.
 704  */
 705 DEFINE_TEST(test_write_read_format_zip64_improved_streaming)
 706 {
 707         struct archive *a;
 708         size_t used;
 709         size_t buffsize = 1000000;
 710         char *buff;
 711
 712         buff = malloc(buffsize);
 713
 714         /* Create a new archive in memory. */
 715         assert((a = archive_write_new()) != NULL);
 716         assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a));
 717         assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
 718         assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "zip:zip64"));
 719         assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "zip:experimental"));
 720         assertEqualIntA(a, ARCHIVE_OK,
 721             archive_write_open_memory(a, buff, buffsize, &used));
 722         write_contents(a);
 723         dumpfile("constructed64.zip", buff, used);
 724
 725         /*
 726          * Now, read the data back.
 727          */
 728         /* With the standard memory reader. */
 729         assert((a = archive_read_new()) != NULL);
 730         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 731         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 732         assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
 733         verify_contents(a, 1, 1);
 734
 735         /* With the test memory reader -- streaming mode. */
 736         assert((a = archive_read_new()) != NULL);
 737         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 738         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 739         assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, buff, used, 7));
 740         /* Streaming reader doesn't see mode information from Central Directory. */
 741         verify_contents(a, 0, 1);
 742
 743         /* With the test memory reader -- seeking mode. */
 744         assert((a = archive_read_new()) != NULL);
 745         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 746         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 747         assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7));
 748         verify_contents(a, 1, 1);
 749
 750         free(buff);
 751 }