2 * Copyright (c) 2003-2008 Tim Kientzle
3 * Copyright (c) 2008 Anselm Strauss
4 * Copyright (c) 2014 Michihiro NAKAJIMA
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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.
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.
29 * Development supported by Google Summer of Code 2008.
33 __FBSDID("$FreeBSD$");
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
43 * Write a variety of different file types into the archive.
46 write_contents(struct archive *a)
48 struct archive_entry *ae;
51 * First write things with the "default" compression.
52 * The library will choose "deflate" for most things if it's
53 * available, else "store".
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));
70 * Write another file to it.
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));
82 * Write a file with an unknown size.
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));
94 * Write symbolic link.
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);
108 assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae));
109 archive_entry_free(ae);
112 * Write a directory to it.
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));
126 * Force "deflate" compression if the platform supports it.
129 assertEqualIntA(a, ARCHIVE_OK, archive_write_zip_set_compression_deflate(a));
132 * Write a file to it.
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));
145 * Write another file to it.
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));
157 * Write a file with an unknown size.
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));
169 * Write symbolic like file to it.
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);
181 * Write a directory to it.
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));
197 * Now write a bunch of entries with "store" compression.
199 assertEqualIntA(a, ARCHIVE_OK, archive_write_zip_set_compression_store(a));
202 * Write a file to it.
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));
215 * Write another file to it.
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));
227 * Write a file with an unknown size.
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));
239 * Write symbolic like file to it.
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);
251 * Write a directory to it.
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));
265 /* Close out the archive. */
266 assertEqualInt(ARCHIVE_OK, archive_write_close(a));
267 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
271 * Read back all of the entries and verify their values.
274 verify_contents(struct archive *a, int seeking, int content)
277 struct archive_entry *ae;
280 * Default compression options:
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));
292 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
294 assert(archive_entry_size_is_set(ae));
295 assertEqualInt(8, archive_entry_size(ae));
297 assertEqualIntA(a, 8,
298 archive_read_data(a, filedata, sizeof(filedata)));
299 assertEqualMem(filedata, "12345678", 8);
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));
310 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
312 assertEqualInt(4, archive_entry_size(ae));
313 assert(archive_entry_size_is_set(ae));
315 assertEqualIntA(a, 4,
316 archive_read_data(a, filedata, sizeof(filedata)));
317 assertEqualMem(filedata, "1234", 4);
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));
328 assertEqualInt(5, archive_entry_size(ae));
329 assertEqualInt(AE_IFREG | 0621, archive_entry_mode(ae));
331 assertEqualInt(0, archive_entry_size_is_set(ae));
334 assertEqualIntA(a, 5,
335 archive_read_data(a, filedata, sizeof(filedata)));
336 assertEqualMem(filedata, "mnopq", 5);
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));
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));
358 assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae));
359 assertEqualInt(0, archive_entry_size(ae));
361 assertEqualIntA(a, 0, archive_read_data(a, filedata, 10));
366 * Deflate compression option:
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));
378 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
379 assertEqualInt(8, archive_entry_size(ae));
380 assert(archive_entry_size_is_set(ae));
382 assertEqualIntA(a, 8,
383 archive_read_data(a, filedata, sizeof(filedata)));
384 assertEqualMem(filedata, "12345678", 8);
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));
396 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
397 assertEqualInt(4, archive_entry_size(ae));
398 assert(archive_entry_size_is_set(ae));
400 assertEqualIntA(a, 4,
401 archive_read_data(a, filedata, sizeof(filedata)));
402 assertEqualMem(filedata, "1234", 4);
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));
413 assertEqualInt(5, archive_entry_size(ae));
414 assertEqualInt(AE_IFREG | 0621, archive_entry_mode(ae));
416 assertEqualInt(0, archive_entry_size_is_set(ae));
419 assertEqualIntA(a, 5,
420 archive_read_data(a, filedata, sizeof(filedata)));
421 assertEqualMem(filedata, "ghijk", 4);
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));
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));
443 assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae));
445 assertEqualInt(0, archive_entry_size(ae));
447 assertEqualIntA(a, 0, archive_read_data(a, filedata, 10));
452 * Store compression option:
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));
464 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
465 assert(archive_entry_size_is_set(ae));
466 assertEqualInt(8, archive_entry_size(ae));
468 assertEqualIntA(a, 8,
469 archive_read_data(a, filedata, sizeof(filedata)));
470 assertEqualMem(filedata, "12345678", 8);
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));
482 assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
483 assertEqualInt(4, archive_entry_size(ae));
484 assert(archive_entry_size_is_set(ae));
486 assertEqualIntA(a, 4,
487 archive_read_data(a, filedata, sizeof(filedata)));
488 assertEqualMem(filedata, "ACEG", 4);
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));
499 assertEqualInt(5, archive_entry_size(ae));
500 assertEqualInt(AE_IFREG | 0621, archive_entry_mode(ae));
502 assertEqualInt(0, archive_entry_size_is_set(ae));
505 assertEqualIntA(a, 5,
506 archive_read_data(a, filedata, sizeof(filedata)));
507 assertEqualMem(filedata, "ijklm", 4);
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));
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));
529 assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae));
530 assertEqualInt(0, archive_entry_size(ae));
532 assertEqualIntA(a, 0, archive_read_data(a, filedata, 10));
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));
542 * Do a write-then-read roundtrip.
544 DEFINE_TEST(test_write_format_zip)
548 size_t buffsize = 1000000;
551 buff = malloc(buffsize);
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));
562 dumpfile("constructed.zip", buff, used);
565 * Now, read the data back.
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);
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);
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);
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);
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);
606 * Do a write-then-read roundtrip with Zip64 enabled.
608 DEFINE_TEST(test_write_format_zip64)
612 size_t buffsize = 1000000;
615 buff = malloc(buffsize);
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));
628 dumpfile("constructed64.zip", buff, used);
631 * Now, read the data back.
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);
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);
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);
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);
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);
671 DEFINE_TEST(test_write_format_zip_traditional_pkware_encryption)
675 size_t buffsize = 1000000;
678 buff = malloc(buffsize);
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);
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));
698 dumpfile("constructed.zip", buff, used);
701 * Now, read the data back.
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);
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);
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);
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);
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);
751 DEFINE_TEST(test_write_format_zip_winzip_aes128_encryption)
755 size_t buffsize = 1000000;
758 buff = malloc(buffsize);
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"))
766 skipping("This system does not have cryptographic liberary");
767 archive_write_free(a);
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));
778 dumpfile("constructed.zip", buff, used);
781 * Now, read the data back.
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);
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);
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);
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);
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);
831 DEFINE_TEST(test_write_format_zip_winzip_aes256_encryption)
835 size_t buffsize = 1000000;
838 buff = malloc(buffsize);
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"))
846 skipping("This system does not have cryptographic liberary");
847 archive_write_free(a);
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));
858 dumpfile("constructed.zip", buff, used);
861 * Now, read the data back.
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);
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);
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);
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);
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);