1 /*- 2 * Copyright (c) 2003-2008 Tim Kientzle 3 * Copyright (c) 2008 Anselm Strauss 4 * Copyright (c) 2014 Michihiro NAKAJIMA 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 /* 29 * Development supported by Google Summer of Code 2008. 30 */ 31 32 #include "test.h" 33 __FBSDID("$FreeBSD$"); 34 35 /* 36 * This test doesn't actually check that the zip writer is 37 * correct, just that our zip reader can read the output of 38 * our zip writer. We do more detailed checks of the bits 39 * elsewhere. 40 */ 41 42 /* 43 * Write a variety of different file types into the archive. 44 */ 45 static void 46 write_contents(struct archive *a) 47 { 48 struct archive_entry *ae; 49 50 /* 51 * First write things with the "default" compression. 52 * The library will choose "deflate" for most things if it's 53 * available, else "store". 54 */ 55 56 /* 57 * Write a file to it. 58 */ 59 assert((ae = archive_entry_new()) != NULL); 60 archive_entry_set_mtime(ae, 1, 10); 61 archive_entry_copy_pathname(ae, "file"); 62 archive_entry_set_mode(ae, AE_IFREG | 0755); 63 archive_entry_set_size(ae, 8); 64 assertEqualInt(0, archive_write_header(a, ae)); 65 archive_entry_free(ae); 66 assertEqualInt(8, archive_write_data(a, "12345678", 9)); 67 assertEqualInt(0, archive_write_data(a, "1", 1)); 68 69 /* 70 * Write another file to it. 71 */ 72 assert((ae = archive_entry_new()) != NULL); 73 archive_entry_set_mtime(ae, 1, 10); 74 archive_entry_copy_pathname(ae, "file2"); 75 archive_entry_set_mode(ae, AE_IFREG | 0755); 76 archive_entry_set_size(ae, 4); 77 assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae)); 78 archive_entry_free(ae); 79 assertEqualInt(4, archive_write_data(a, "1234", 4)); 80 81 /* 82 * Write a file with an unknown size. 83 */ 84 assert((ae = archive_entry_new()) != NULL); 85 archive_entry_set_mtime(ae, 2, 15); 86 archive_entry_copy_pathname(ae, "file3"); 87 archive_entry_set_mode(ae, AE_IFREG | 0621); 88 archive_entry_unset_size(ae); 89 assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae)); 90 archive_entry_free(ae); 91 assertEqualInt(5, archive_write_data(a, "mnopq", 5)); 92 93 /* 94 * Write symbolic link. 95 */ 96 assert((ae = archive_entry_new()) != NULL); 97 archive_entry_set_mtime(ae, 1, 10); 98 assertEqualInt(1, archive_entry_mtime(ae)); 99 assertEqualInt(10, archive_entry_mtime_nsec(ae)); 100 archive_entry_copy_pathname(ae, "symlink"); 101 assertEqualString("symlink", archive_entry_pathname(ae)); 102 archive_entry_copy_symlink(ae, "file1"); 103 assertEqualString("file1", archive_entry_symlink(ae)); 104 archive_entry_set_mode(ae, AE_IFLNK | 0755); 105 assertEqualInt((AE_IFLNK | 0755), archive_entry_mode(ae)); 106 archive_entry_set_size(ae, 4); 107 108 assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae)); 109 archive_entry_free(ae); 110 111 /* 112 * Write a directory to it. 113 */ 114 assert((ae = archive_entry_new()) != NULL); 115 archive_entry_set_mtime(ae, 11, 110); 116 archive_entry_copy_pathname(ae, "dir"); 117 archive_entry_set_mode(ae, S_IFDIR | 0755); 118 archive_entry_set_size(ae, 512); 119 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae)); 120 failure("size should be zero so that applications know not to write"); 121 assertEqualInt(0, archive_entry_size(ae)); 122 archive_entry_free(ae); 123 assertEqualIntA(a, 0, archive_write_data(a, "12345678", 9)); 124 125 /* 126 * Force "deflate" compression if the platform supports it. 127 */ 128 #ifdef HAVE_ZLIB_H 129 assertEqualIntA(a, ARCHIVE_OK, archive_write_zip_set_compression_deflate(a)); 130 131 /* 132 * Write a file to it. 133 */ 134 assert((ae = archive_entry_new()) != NULL); 135 archive_entry_set_mtime(ae, 1, 10); 136 archive_entry_copy_pathname(ae, "file_deflate"); 137 archive_entry_set_mode(ae, AE_IFREG | 0755); 138 archive_entry_set_size(ae, 8); 139 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae)); 140 archive_entry_free(ae); 141 assertEqualInt(8, archive_write_data(a, "12345678", 9)); 142 assertEqualInt(0, archive_write_data(a, "1", 1)); 143 144 /* 145 * Write another file to it. 146 */ 147 assert((ae = archive_entry_new()) != NULL); 148 archive_entry_set_mtime(ae, 1, 10); 149 archive_entry_copy_pathname(ae, "file2_deflate"); 150 archive_entry_set_mode(ae, AE_IFREG | 0755); 151 archive_entry_set_size(ae, 4); 152 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae)); 153 archive_entry_free(ae); 154 assertEqualInt(4, archive_write_data(a, "1234", 4)); 155 156 /* 157 * Write a file with an unknown size. 158 */ 159 assert((ae = archive_entry_new()) != NULL); 160 archive_entry_set_mtime(ae, 2, 15); 161 archive_entry_copy_pathname(ae, "file3_deflate"); 162 archive_entry_set_mode(ae, AE_IFREG | 0621); 163 archive_entry_unset_size(ae); 164 assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae)); 165 archive_entry_free(ae); 166 assertEqualInt(5, archive_write_data(a, "ghijk", 5)); 167 168 /* 169 * Write symbolic like file to it. 170 */ 171 assert((ae = archive_entry_new()) != NULL); 172 archive_entry_set_mtime(ae, 1, 10); 173 archive_entry_copy_pathname(ae, "symlink_deflate"); 174 archive_entry_copy_symlink(ae, "file1"); 175 archive_entry_set_mode(ae, AE_IFLNK | 0755); 176 archive_entry_set_size(ae, 4); 177 assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae)); 178 archive_entry_free(ae); 179 180 /* 181 * Write a directory to it. 182 */ 183 assert((ae = archive_entry_new()) != NULL); 184 archive_entry_set_mtime(ae, 11, 110); 185 archive_entry_copy_pathname(ae, "dir_deflate"); 186 archive_entry_set_mode(ae, S_IFDIR | 0755); 187 archive_entry_set_size(ae, 512); 188 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae)); 189 failure("size should be zero so that applications know not to write"); 190 assertEqualInt(0, archive_entry_size(ae)); 191 archive_entry_free(ae); 192 assertEqualIntA(a, 0, archive_write_data(a, "12345678", 9)); 193 assertEqualIntA(a, ARCHIVE_OK, archive_write_finish_entry(a)); 194 #endif 195 196 /* 197 * Now write a bunch of entries with "store" compression. 198 */ 199 assertEqualIntA(a, ARCHIVE_OK, archive_write_zip_set_compression_store(a)); 200 201 /* 202 * Write a file to it. 203 */ 204 assert((ae = archive_entry_new()) != NULL); 205 archive_entry_set_mtime(ae, 1, 10); 206 archive_entry_copy_pathname(ae, "file_stored"); 207 archive_entry_set_mode(ae, AE_IFREG | 0755); 208 archive_entry_set_size(ae, 8); 209 assertEqualInt(0, archive_write_header(a, ae)); 210 archive_entry_free(ae); 211 assertEqualInt(8, archive_write_data(a, "12345678", 9)); 212 assertEqualInt(0, archive_write_data(a, "1", 1)); 213 214 /* 215 * Write another file to it. 216 */ 217 assert((ae = archive_entry_new()) != NULL); 218 archive_entry_set_mtime(ae, 1, 10); 219 archive_entry_copy_pathname(ae, "file2_stored"); 220 archive_entry_set_mode(ae, AE_IFREG | 0755); 221 archive_entry_set_size(ae, 4); 222 assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae)); 223 archive_entry_free(ae); 224 assertEqualInt(4, archive_write_data(a, "ACEG", 4)); 225 226 /* 227 * Write a file with an unknown size. 228 */ 229 assert((ae = archive_entry_new()) != NULL); 230 archive_entry_set_mtime(ae, 2, 15); 231 archive_entry_copy_pathname(ae, "file3_stored"); 232 archive_entry_set_mode(ae, AE_IFREG | 0621); 233 archive_entry_unset_size(ae); 234 assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae)); 235 archive_entry_free(ae); 236 assertEqualInt(5, archive_write_data(a, "ijklm", 5)); 237 238 /* 239 * Write symbolic like file to it. 240 */ 241 assert((ae = archive_entry_new()) != NULL); 242 archive_entry_set_mtime(ae, 1, 10); 243 archive_entry_copy_pathname(ae, "symlink_stored"); 244 archive_entry_copy_symlink(ae, "file1"); 245 archive_entry_set_mode(ae, AE_IFLNK | 0755); 246 archive_entry_set_size(ae, 4); 247 assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae)); 248 archive_entry_free(ae); 249 250 /* 251 * Write a directory to it. 252 */ 253 assert((ae = archive_entry_new()) != NULL); 254 archive_entry_set_mtime(ae, 11, 110); 255 archive_entry_copy_pathname(ae, "dir_stored"); 256 archive_entry_set_mode(ae, S_IFDIR | 0755); 257 archive_entry_set_size(ae, 512); 258 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae)); 259 failure("size should be zero so that applications know not to write"); 260 assertEqualInt(0, archive_entry_size(ae)); 261 archive_entry_free(ae); 262 assertEqualIntA(a, 0, archive_write_data(a, "12345678", 9)); 263 264 265 /* Close out the archive. */ 266 assertEqualInt(ARCHIVE_OK, archive_write_close(a)); 267 assertEqualInt(ARCHIVE_OK, archive_write_free(a)); 268 } 269 270 /* 271 * Read back all of the entries and verify their values. 272 */ 273 static void 274 verify_contents(struct archive *a, int seeking, int content) 275 { 276 char filedata[64]; 277 struct archive_entry *ae; 278 279 /* 280 * Default compression options: 281 */ 282 283 /* Read and verify first file. */ 284 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 285 assertEqualInt(1, archive_entry_mtime(ae)); 286 /* Zip doesn't store high-resolution mtime. */ 287 assertEqualInt(0, archive_entry_mtime_nsec(ae)); 288 assertEqualInt(0, archive_entry_atime(ae)); 289 assertEqualInt(0, archive_entry_ctime(ae)); 290 assertEqualString("file", archive_entry_pathname(ae)); 291 if (seeking) { 292 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae)); 293 } 294 assert(archive_entry_size_is_set(ae)); 295 assertEqualInt(8, archive_entry_size(ae)); 296 if (content) { 297 assertEqualIntA(a, 8, 298 archive_read_data(a, filedata, sizeof(filedata))); 299 assertEqualMem(filedata, "12345678", 8); 300 } 301 302 /* Read the second file back. */ 303 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 304 assertEqualInt(1, archive_entry_mtime(ae)); 305 assertEqualInt(0, archive_entry_mtime_nsec(ae)); 306 assertEqualInt(0, archive_entry_atime(ae)); 307 assertEqualInt(0, archive_entry_ctime(ae)); 308 assertEqualString("file2", archive_entry_pathname(ae)); 309 if (seeking) { 310 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae)); 311 } 312 assertEqualInt(4, archive_entry_size(ae)); 313 assert(archive_entry_size_is_set(ae)); 314 if (content) { 315 assertEqualIntA(a, 4, 316 archive_read_data(a, filedata, sizeof(filedata))); 317 assertEqualMem(filedata, "1234", 4); 318 } 319 320 /* Read the third file back. */ 321 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 322 assertEqualInt(2, archive_entry_mtime(ae)); 323 assertEqualInt(0, archive_entry_mtime_nsec(ae)); 324 assertEqualInt(0, archive_entry_atime(ae)); 325 assertEqualInt(0, archive_entry_ctime(ae)); 326 assertEqualString("file3", archive_entry_pathname(ae)); 327 if (seeking) { 328 assertEqualInt(5, archive_entry_size(ae)); 329 assertEqualInt(AE_IFREG | 0621, archive_entry_mode(ae)); 330 } else { 331 assertEqualInt(0, archive_entry_size_is_set(ae)); 332 } 333 if (content) { 334 assertEqualIntA(a, 5, 335 archive_read_data(a, filedata, sizeof(filedata))); 336 assertEqualMem(filedata, "mnopq", 5); 337 } 338 339 /* Read symlink. */ 340 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 341 assertEqualInt(1, archive_entry_mtime(ae)); 342 assertEqualInt(0, archive_entry_mtime_nsec(ae)); 343 assertEqualInt(0, archive_entry_atime(ae)); 344 assertEqualInt(0, archive_entry_ctime(ae)); 345 assertEqualString("symlink", archive_entry_pathname(ae)); 346 assertEqualInt(AE_IFLNK | 0755, archive_entry_mode(ae)); 347 assertEqualInt(0, archive_entry_size(ae)); 348 assertEqualString("file1", archive_entry_symlink(ae)); 349 350 /* Read the dir entry back. */ 351 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 352 assertEqualInt(11, archive_entry_mtime(ae)); 353 assertEqualInt(0, archive_entry_mtime_nsec(ae)); 354 assertEqualInt(0, archive_entry_atime(ae)); 355 assertEqualInt(0, archive_entry_ctime(ae)); 356 assertEqualString("dir/", archive_entry_pathname(ae)); 357 if (seeking) 358 assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae)); 359 assertEqualInt(0, archive_entry_size(ae)); 360 if (content) { 361 assertEqualIntA(a, 0, archive_read_data(a, filedata, 10)); 362 } 363 364 #ifdef HAVE_ZLIB_H 365 /* 366 * Deflate compression option: 367 */ 368 369 /* Read and verify first file. */ 370 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 371 assertEqualInt(1, archive_entry_mtime(ae)); 372 /* Zip doesn't store high-resolution mtime. */ 373 assertEqualInt(0, archive_entry_mtime_nsec(ae)); 374 assertEqualInt(0, archive_entry_atime(ae)); 375 assertEqualInt(0, archive_entry_ctime(ae)); 376 assertEqualString("file_deflate", archive_entry_pathname(ae)); 377 if (seeking) 378 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae)); 379 assertEqualInt(8, archive_entry_size(ae)); 380 assert(archive_entry_size_is_set(ae)); 381 if (content) { 382 assertEqualIntA(a, 8, 383 archive_read_data(a, filedata, sizeof(filedata))); 384 assertEqualMem(filedata, "12345678", 8); 385 } 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) 396 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae)); 397 assertEqualInt(4, archive_entry_size(ae)); 398 assert(archive_entry_size_is_set(ae)); 399 if (content) { 400 assertEqualIntA(a, 4, 401 archive_read_data(a, filedata, sizeof(filedata))); 402 assertEqualMem(filedata, "1234", 4); 403 } 404 405 /* Read the third file back. */ 406 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 407 assertEqualInt(2, archive_entry_mtime(ae)); 408 assertEqualInt(0, archive_entry_mtime_nsec(ae)); 409 assertEqualInt(0, archive_entry_atime(ae)); 410 assertEqualInt(0, archive_entry_ctime(ae)); 411 assertEqualString("file3_deflate", archive_entry_pathname(ae)); 412 if (seeking) { 413 assertEqualInt(5, archive_entry_size(ae)); 414 assertEqualInt(AE_IFREG | 0621, archive_entry_mode(ae)); 415 } else { 416 assertEqualInt(0, archive_entry_size_is_set(ae)); 417 } 418 if (content) { 419 assertEqualIntA(a, 5, 420 archive_read_data(a, filedata, sizeof(filedata))); 421 assertEqualMem(filedata, "ghijk", 4); 422 } 423 424 /* Read symlink. */ 425 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 426 assertEqualInt(1, archive_entry_mtime(ae)); 427 assertEqualInt(0, archive_entry_mtime_nsec(ae)); 428 assertEqualInt(0, archive_entry_atime(ae)); 429 assertEqualInt(0, archive_entry_ctime(ae)); 430 assertEqualString("symlink_deflate", archive_entry_pathname(ae)); 431 assertEqualInt(AE_IFLNK | 0755, archive_entry_mode(ae)); 432 assertEqualInt(0, archive_entry_size(ae)); 433 assertEqualString("file1", archive_entry_symlink(ae)); 434 435 /* Read the dir entry back. */ 436 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 437 assertEqualInt(11, archive_entry_mtime(ae)); 438 assertEqualInt(0, archive_entry_mtime_nsec(ae)); 439 assertEqualInt(0, archive_entry_atime(ae)); 440 assertEqualInt(0, archive_entry_ctime(ae)); 441 assertEqualString("dir_deflate/", archive_entry_pathname(ae)); 442 if (seeking) { 443 assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae)); 444 } 445 assertEqualInt(0, archive_entry_size(ae)); 446 if (content) { 447 assertEqualIntA(a, 0, archive_read_data(a, filedata, 10)); 448 } 449 #endif 450 451 /* 452 * Store compression option: 453 */ 454 455 /* Read and verify first file. */ 456 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 457 assertEqualInt(1, archive_entry_mtime(ae)); 458 /* Zip doesn't store high-resolution mtime. */ 459 assertEqualInt(0, archive_entry_mtime_nsec(ae)); 460 assertEqualInt(0, archive_entry_atime(ae)); 461 assertEqualInt(0, archive_entry_ctime(ae)); 462 assertEqualString("file_stored", archive_entry_pathname(ae)); 463 if (seeking) 464 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae)); 465 assert(archive_entry_size_is_set(ae)); 466 assertEqualInt(8, archive_entry_size(ae)); 467 if (content) { 468 assertEqualIntA(a, 8, 469 archive_read_data(a, filedata, sizeof(filedata))); 470 assertEqualMem(filedata, "12345678", 8); 471 } 472 473 474 /* Read the second file back. */ 475 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 476 assertEqualInt(1, archive_entry_mtime(ae)); 477 assertEqualInt(0, archive_entry_mtime_nsec(ae)); 478 assertEqualInt(0, archive_entry_atime(ae)); 479 assertEqualInt(0, archive_entry_ctime(ae)); 480 assertEqualString("file2_stored", archive_entry_pathname(ae)); 481 if (seeking) 482 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae)); 483 assertEqualInt(4, archive_entry_size(ae)); 484 assert(archive_entry_size_is_set(ae)); 485 if (content) { 486 assertEqualIntA(a, 4, 487 archive_read_data(a, filedata, sizeof(filedata))); 488 assertEqualMem(filedata, "ACEG", 4); 489 } 490 491 /* Read the third file back. */ 492 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 493 assertEqualInt(2, archive_entry_mtime(ae)); 494 assertEqualInt(0, archive_entry_mtime_nsec(ae)); 495 assertEqualInt(0, archive_entry_atime(ae)); 496 assertEqualInt(0, archive_entry_ctime(ae)); 497 assertEqualString("file3_stored", archive_entry_pathname(ae)); 498 if (seeking) { 499 assertEqualInt(5, archive_entry_size(ae)); 500 assertEqualInt(AE_IFREG | 0621, archive_entry_mode(ae)); 501 } else { 502 assertEqualInt(0, archive_entry_size_is_set(ae)); 503 } 504 if (content) { 505 assertEqualIntA(a, 5, 506 archive_read_data(a, filedata, sizeof(filedata))); 507 assertEqualMem(filedata, "ijklm", 4); 508 } 509 510 /* Read symlink. */ 511 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 512 assertEqualInt(1, archive_entry_mtime(ae)); 513 assertEqualInt(0, archive_entry_mtime_nsec(ae)); 514 assertEqualInt(0, archive_entry_atime(ae)); 515 assertEqualInt(0, archive_entry_ctime(ae)); 516 assertEqualString("symlink_stored", archive_entry_pathname(ae)); 517 assertEqualInt(AE_IFLNK | 0755, archive_entry_mode(ae)); 518 assertEqualInt(0, archive_entry_size(ae)); 519 assertEqualString("file1", archive_entry_symlink(ae)); 520 521 /* Read the dir entry back. */ 522 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); 523 assertEqualInt(11, archive_entry_mtime(ae)); 524 assertEqualInt(0, archive_entry_mtime_nsec(ae)); 525 assertEqualInt(0, archive_entry_atime(ae)); 526 assertEqualInt(0, archive_entry_ctime(ae)); 527 assertEqualString("dir_stored/", archive_entry_pathname(ae)); 528 if (seeking) 529 assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae)); 530 assertEqualInt(0, archive_entry_size(ae)); 531 if (content) { 532 assertEqualIntA(a, 0, archive_read_data(a, filedata, 10)); 533 } 534 535 /* Verify the end of the archive. */ 536 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); 537 assertEqualInt(ARCHIVE_OK, archive_read_close(a)); 538 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 539 } 540 541 /* 542 * Do a write-then-read roundtrip. 543 */ 544 DEFINE_TEST(test_write_format_zip) 545 { 546 struct archive *a; 547 size_t used; 548 size_t buffsize = 1000000; 549 char *buff; 550 551 buff = malloc(buffsize); 552 553 /* Create a new archive in memory. */ 554 assert((a = archive_write_new()) != NULL); 555 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a)); 556 assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a)); 557 assertEqualIntA(a, ARCHIVE_OK, 558 archive_write_set_options(a, "zip:experimental")); 559 assertEqualIntA(a, ARCHIVE_OK, 560 archive_write_open_memory(a, buff, buffsize, &used)); 561 write_contents(a); 562 dumpfile("constructed.zip", buff, used); 563 564 /* 565 * Now, read the data back. 566 */ 567 /* With the standard memory reader. */ 568 assert((a = archive_read_new()) != NULL); 569 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 570 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 571 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used)); 572 verify_contents(a, 1, 1); 573 574 /* With the test memory reader -- streaming mode. */ 575 assert((a = archive_read_new()) != NULL); 576 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 577 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 578 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, buff, used, 7)); 579 /* Streaming reader doesn't see mode information from Central Directory. */ 580 verify_contents(a, 0, 1); 581 582 assert((a = archive_read_new()) != NULL); 583 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 584 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 585 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, buff, used, 7)); 586 /* Streaming reader doesn't see mode information from Central Directory. */ 587 verify_contents(a, 0, 0); 588 589 /* With the test memory reader -- seeking mode. */ 590 assert((a = archive_read_new()) != NULL); 591 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 592 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 593 assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7)); 594 verify_contents(a, 1, 1); 595 596 assert((a = archive_read_new()) != NULL); 597 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 598 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 599 assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7)); 600 verify_contents(a, 1, 0); 601 602 free(buff); 603 } 604 605 /* 606 * Do a write-then-read roundtrip with Zip64 enabled. 607 */ 608 DEFINE_TEST(test_write_format_zip64) 609 { 610 struct archive *a; 611 size_t used; 612 size_t buffsize = 1000000; 613 char *buff; 614 615 buff = malloc(buffsize); 616 617 /* Create a new archive in memory. */ 618 assert((a = archive_write_new()) != NULL); 619 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a)); 620 assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a)); 621 assertEqualIntA(a, ARCHIVE_OK, 622 archive_write_set_options(a, "zip:zip64")); 623 assertEqualIntA(a, ARCHIVE_OK, 624 archive_write_set_options(a, "zip:experimental")); 625 assertEqualIntA(a, ARCHIVE_OK, 626 archive_write_open_memory(a, buff, buffsize, &used)); 627 write_contents(a); 628 dumpfile("constructed64.zip", buff, used); 629 630 /* 631 * Now, read the data back. 632 */ 633 /* With the standard memory reader. */ 634 assert((a = archive_read_new()) != NULL); 635 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 636 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 637 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used)); 638 verify_contents(a, 1, 1); 639 640 /* With the test memory reader -- streaming mode. */ 641 assert((a = archive_read_new()) != NULL); 642 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 643 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 644 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, buff, used, 7)); 645 /* Streaming reader doesn't see mode information from Central Directory. */ 646 verify_contents(a, 0, 1); 647 648 assert((a = archive_read_new()) != NULL); 649 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 650 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 651 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, buff, used, 7)); 652 /* Streaming reader doesn't see mode information from Central Directory. */ 653 verify_contents(a, 0, 0); 654 655 /* With the test memory reader -- seeking mode. */ 656 assert((a = archive_read_new()) != NULL); 657 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 658 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 659 assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7)); 660 verify_contents(a, 1, 1); 661 662 assert((a = archive_read_new()) != NULL); 663 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 664 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 665 assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7)); 666 verify_contents(a, 1, 0); 667 668 free(buff); 669 } 670 671 DEFINE_TEST(test_write_format_zip_traditional_pkware_encryption) 672 { 673 struct archive *a; 674 size_t used; 675 size_t buffsize = 1000000; 676 char *buff; 677 678 buff = malloc(buffsize); 679 680 /* Create a new archive in memory. */ 681 assert((a = archive_write_new()) != NULL); 682 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a)); 683 assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a)); 684 if (ARCHIVE_OK != archive_write_set_options(a, 685 "zip:encryption=zipcrypt")) { 686 skipping("This system does not have cryptographic liberary"); 687 archive_write_free(a); 688 free(buff); 689 return; 690 } 691 assertEqualIntA(a, ARCHIVE_OK, 692 archive_write_set_passphrase(a, "password1234")); 693 assertEqualIntA(a, ARCHIVE_OK, 694 archive_write_set_options(a, "zip:experimental")); 695 assertEqualIntA(a, ARCHIVE_OK, 696 archive_write_open_memory(a, buff, buffsize, &used)); 697 write_contents(a); 698 dumpfile("constructed.zip", buff, used); 699 700 /* 701 * Now, read the data back. 702 */ 703 /* With the standard memory reader. */ 704 assert((a = archive_read_new()) != NULL); 705 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 706 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 707 assertEqualIntA(a, ARCHIVE_OK, 708 archive_read_add_passphrase(a, "password1234")); 709 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used)); 710 verify_contents(a, 1, 1); 711 712 /* With the test memory reader -- streaming mode. */ 713 assert((a = archive_read_new()) != NULL); 714 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 715 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 716 assertEqualIntA(a, ARCHIVE_OK, 717 archive_read_add_passphrase(a, "password1234")); 718 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, buff, used, 7)); 719 /* Streaming reader doesn't see mode information from Central Directory. */ 720 verify_contents(a, 0, 1); 721 722 assert((a = archive_read_new()) != NULL); 723 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 724 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 725 assertEqualIntA(a, ARCHIVE_OK, 726 archive_read_add_passphrase(a, "password1234")); 727 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, buff, used, 7)); 728 /* Streaming reader doesn't see mode information from Central Directory. */ 729 verify_contents(a, 0, 0); 730 731 /* With the test memory reader -- seeking mode. */ 732 assert((a = archive_read_new()) != NULL); 733 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 734 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 735 assertEqualIntA(a, ARCHIVE_OK, 736 archive_read_add_passphrase(a, "password1234")); 737 assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7)); 738 verify_contents(a, 1, 1); 739 740 assert((a = archive_read_new()) != NULL); 741 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 742 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 743 assertEqualIntA(a, ARCHIVE_OK, 744 archive_read_add_passphrase(a, "password1234")); 745 assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7)); 746 verify_contents(a, 1, 0); 747 748 free(buff); 749 } 750 751 DEFINE_TEST(test_write_format_zip_winzip_aes128_encryption) 752 { 753 struct archive *a; 754 size_t used; 755 size_t buffsize = 1000000; 756 char *buff; 757 758 buff = malloc(buffsize); 759 760 /* Create a new archive in memory. */ 761 assert((a = archive_write_new()) != NULL); 762 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a)); 763 assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a)); 764 if (ARCHIVE_OK != archive_write_set_options(a, "zip:encryption=aes128")) 765 { 766 skipping("This system does not have cryptographic liberary"); 767 archive_write_free(a); 768 free(buff); 769 return; 770 } 771 assertEqualIntA(a, ARCHIVE_OK, 772 archive_write_set_passphrase(a, "password1234")); 773 assertEqualIntA(a, ARCHIVE_OK, 774 archive_write_set_options(a, "zip:experimental")); 775 assertEqualIntA(a, ARCHIVE_OK, 776 archive_write_open_memory(a, buff, buffsize, &used)); 777 write_contents(a); 778 dumpfile("constructed.zip", buff, used); 779 780 /* 781 * Now, read the data back. 782 */ 783 /* With the standard memory reader. */ 784 assert((a = archive_read_new()) != NULL); 785 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 786 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 787 assertEqualIntA(a, ARCHIVE_OK, 788 archive_read_add_passphrase(a, "password1234")); 789 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used)); 790 verify_contents(a, 1, 1); 791 792 /* With the test memory reader -- streaming mode. */ 793 assert((a = archive_read_new()) != NULL); 794 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 795 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 796 assertEqualIntA(a, ARCHIVE_OK, 797 archive_read_add_passphrase(a, "password1234")); 798 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, buff, used, 7)); 799 /* Streaming reader doesn't see mode information from Central Directory. */ 800 verify_contents(a, 0, 1); 801 802 assert((a = archive_read_new()) != NULL); 803 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 804 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 805 assertEqualIntA(a, ARCHIVE_OK, 806 archive_read_add_passphrase(a, "password1234")); 807 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, buff, used, 7)); 808 /* Streaming reader doesn't see mode information from Central Directory. */ 809 verify_contents(a, 0, 0); 810 811 /* With the test memory reader -- seeking mode. */ 812 assert((a = archive_read_new()) != NULL); 813 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 814 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 815 assertEqualIntA(a, ARCHIVE_OK, 816 archive_read_add_passphrase(a, "password1234")); 817 assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7)); 818 verify_contents(a, 1, 1); 819 820 assert((a = archive_read_new()) != NULL); 821 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 822 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 823 assertEqualIntA(a, ARCHIVE_OK, 824 archive_read_add_passphrase(a, "password1234")); 825 assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7)); 826 verify_contents(a, 1, 0); 827 828 free(buff); 829 } 830 831 DEFINE_TEST(test_write_format_zip_winzip_aes256_encryption) 832 { 833 struct archive *a; 834 size_t used; 835 size_t buffsize = 1000000; 836 char *buff; 837 838 buff = malloc(buffsize); 839 840 /* Create a new archive in memory. */ 841 assert((a = archive_write_new()) != NULL); 842 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a)); 843 assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a)); 844 if (ARCHIVE_OK != archive_write_set_options(a, "zip:encryption=aes256")) 845 { 846 skipping("This system does not have cryptographic liberary"); 847 archive_write_free(a); 848 free(buff); 849 return; 850 } 851 assertEqualIntA(a, ARCHIVE_OK, 852 archive_write_set_passphrase(a, "password1234")); 853 assertEqualIntA(a, ARCHIVE_OK, 854 archive_write_set_options(a, "zip:experimental")); 855 assertEqualIntA(a, ARCHIVE_OK, 856 archive_write_open_memory(a, buff, buffsize, &used)); 857 write_contents(a); 858 dumpfile("constructed.zip", buff, used); 859 860 /* 861 * Now, read the data back. 862 */ 863 /* With the standard memory reader. */ 864 assert((a = archive_read_new()) != NULL); 865 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 866 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 867 assertEqualIntA(a, ARCHIVE_OK, 868 archive_read_add_passphrase(a, "password1234")); 869 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used)); 870 verify_contents(a, 1, 1); 871 872 /* With the test memory reader -- streaming mode. */ 873 assert((a = archive_read_new()) != NULL); 874 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 875 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 876 assertEqualIntA(a, ARCHIVE_OK, 877 archive_read_add_passphrase(a, "password1234")); 878 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, buff, used, 7)); 879 /* Streaming reader doesn't see mode information from Central Directory. */ 880 verify_contents(a, 0, 1); 881 882 assert((a = archive_read_new()) != NULL); 883 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 884 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 885 assertEqualIntA(a, ARCHIVE_OK, 886 archive_read_add_passphrase(a, "password1234")); 887 assertEqualIntA(a, ARCHIVE_OK, read_open_memory(a, buff, used, 7)); 888 /* Streaming reader doesn't see mode information from Central Directory. */ 889 verify_contents(a, 0, 0); 890 891 /* With the test memory reader -- seeking mode. */ 892 assert((a = archive_read_new()) != NULL); 893 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 894 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 895 assertEqualIntA(a, ARCHIVE_OK, 896 archive_read_add_passphrase(a, "password1234")); 897 assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7)); 898 verify_contents(a, 1, 1); 899 900 assert((a = archive_read_new()) != NULL); 901 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); 902 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); 903 assertEqualIntA(a, ARCHIVE_OK, 904 archive_read_add_passphrase(a, "password1234")); 905 assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7)); 906 verify_contents(a, 1, 0); 907 908 free(buff); 909 } 910