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