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