2 * Copyright (c) 2009-2011 Michihiro NAKAJIMA
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 * Check that a "zisofs" ISO 9660 image is correctly created.
31 static const unsigned char primary_id[] = {
32 0x01, 0x43, 0x44, 0x30, 0x30, 0x31, 0x01, 0x00
34 static const unsigned char volumesize[] = {
35 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23
37 static const unsigned char volumesize2[] = {
38 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36
40 static const unsigned char volumesize3[] = {
41 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28
43 static const unsigned char volumeidu16[] = {
44 0x00, 0x43, 0x00, 0x44, 0x00, 0x52, 0x00, 0x4f,
45 0x00, 0x4d, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20,
46 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20,
47 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20
49 static const unsigned char supplementary_id[] = {
50 0x02, 0x43, 0x44, 0x30, 0x30, 0x31, 0x01, 0x00
52 static const unsigned char terminator_id[] = {
53 0xff, 0x43, 0x44, 0x30, 0x30, 0x31, 0x01, 0x00
56 static const unsigned char zisofs_magic[8] = {
57 0x37, 0xE4, 0x53, 0x96, 0xC9, 0xDB, 0xD6, 0x07
60 static const unsigned char zisofs_data[24] = {
61 0x37, 0xe4, 0x53, 0x96, 0xc9, 0xdb, 0xd6, 0x07,
62 0x00, 0x80, 0x00, 0x00, 0x04, 0x0f, 0x00, 0x00,
63 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00
66 static const unsigned char boot_id[] = {
67 0x00, 0x43, 0x44, 0x30, 0x30, 0x31, 0x01, 0x45,
68 0x4c, 0x20, 0x54, 0x4f, 0x52, 0x49, 0x54, 0x4f,
69 0x20, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49,
70 0x43, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00,
71 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
74 static const unsigned char boot_catalog[] = {
75 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
76 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
77 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
78 0x00, 0x00, 0x00, 0x00, 0xaa, 0x55, 0x55, 0xaa,
79 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
80 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
81 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
82 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
85 static const unsigned char el_torito_signature[] = {
86 "ER\355\001\012T\207\001RRIP_1991ATHE ROCK RIDGE "
87 "INTERCHANGE PROTOCOL PROVIDES SUPPORT FOR POSIX "
88 "FILE SYSTEM SEMANTICSPLEASE CONTACT DISC PUBLISHER "
89 "FOR SPECIFICATION SOURCE. SEE PUBLISHER IDENTIFIER "
90 "IN PRIMARY VOLUME DESCRIPTOR FOR CONTACT INFORMATION."
94 test_write_format_iso9660_zisofs_1(void)
96 unsigned char buff2[1024];
97 unsigned char nullb[1024];
99 struct archive_entry *ae;
101 size_t buffsize = 36 * 2048;
106 memset(nullb, 0, sizeof(nullb));
107 buff = malloc(buffsize);
108 assert(buff != NULL);
112 /* ISO9660 format: Create a new archive in memory. */
113 assert((a = archive_write_new()) != NULL);
114 assertEqualIntA(a, 0, archive_write_set_format_iso9660(a));
115 assertEqualIntA(a, 0, archive_write_add_filter_none(a));
116 r = archive_write_set_option(a, NULL, "zisofs", "1");
117 if (r == ARCHIVE_FATAL) {
118 skipping("zisofs option not supported on this platform");
119 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
123 assertEqualIntA(a, 0, archive_write_set_option(a, NULL, "pad", NULL));
124 assertEqualIntA(a, 0, archive_write_open_memory(a, buff, buffsize, &used));
127 * "file1" has a bunch of attributes and 256K bytes of null data.
129 assert((ae = archive_entry_new()) != NULL);
130 archive_entry_set_atime(ae, 2, 20);
131 archive_entry_set_birthtime(ae, 3, 30);
132 archive_entry_set_ctime(ae, 4, 40);
133 archive_entry_set_mtime(ae, 5, 50);
134 archive_entry_copy_pathname(ae, "file1");
135 archive_entry_set_mode(ae, S_IFREG | 0755);
136 archive_entry_set_size(ae, 256*1024);
137 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
138 archive_entry_free(ae);
139 assertEqualIntA(a, 1024, archive_write_data(a, nullb, 1024));
142 * "file2" has a bunch of attributes and 2048 bytes of null data.
144 assert((ae = archive_entry_new()) != NULL);
145 archive_entry_set_atime(ae, 2, 20);
146 archive_entry_set_birthtime(ae, 3, 30);
147 archive_entry_set_ctime(ae, 4, 40);
148 archive_entry_set_mtime(ae, 5, 50);
149 archive_entry_copy_pathname(ae, "file2");
150 archive_entry_set_mode(ae, S_IFREG | 0755);
151 archive_entry_set_size(ae, 2048);
152 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
153 archive_entry_free(ae);
154 assertEqualIntA(a, 1024, archive_write_data(a, nullb, 1024));
157 * "file3" has a bunch of attributes and 2049 bytes of null data.
159 assert((ae = archive_entry_new()) != NULL);
160 archive_entry_set_atime(ae, 2, 20);
161 archive_entry_set_birthtime(ae, 3, 30);
162 archive_entry_set_ctime(ae, 4, 40);
163 archive_entry_set_mtime(ae, 5, 50);
164 archive_entry_copy_pathname(ae, "file3");
165 archive_entry_set_mode(ae, S_IFREG | 0755);
166 archive_entry_set_size(ae, 2049);
167 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
168 archive_entry_free(ae);
169 assertEqualIntA(a, 1024, archive_write_data(a, nullb, 1024));
172 * "file4" has a bunch of attributes and 24 bytes of zisofs data
173 * which is compressed from 32K bytes null data.
175 assert((ae = archive_entry_new()) != NULL);
176 archive_entry_set_atime(ae, 2, 20);
177 archive_entry_set_birthtime(ae, 3, 30);
178 archive_entry_set_ctime(ae, 4, 40);
179 archive_entry_set_mtime(ae, 5, 50);
180 archive_entry_copy_pathname(ae, "file4");
181 archive_entry_set_mode(ae, S_IFREG | 0755);
182 archive_entry_set_size(ae, 24);
183 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
184 archive_entry_free(ae);
185 assertEqualIntA(a, 24, archive_write_data(a, zisofs_data, 24));
187 /* Close out the archive. */
188 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
189 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
191 failure("The ISO image size should be 71680 bytes.");
192 assertEqualInt(used, 2048 * 35);
194 /* Check System Area. */
195 for (i = 0; i < 2048 * 16; i++) {
196 failure("System Area should be all nulls.");
197 assertEqualInt(buff[i], 0);
200 /* Primary Volume. */
201 failure("Primary Volume Descriptor should be in 16 Logical Sector.");
202 assertEqualMem(buff+2048*16, primary_id, 8);
203 assertEqualMem(buff+2048*16+0x28,
205 assertEqualMem(buff+2048*16+0x50, volumesize, 8);
207 /* Supplementary Volume. */
208 failure("Supplementary Volume(Joliet) Descriptor "
209 "should be in 17 Logical Sector.");
210 assertEqualMem(buff+2048*17, supplementary_id, 8);
211 assertEqualMem(buff+2048*17+0x28, volumeidu16, 32);
212 assertEqualMem(buff+2048*17+0x50, volumesize, 8);
213 failure("Date and Time of Primary Volume and "
214 "Date and Time of Supplementary Volume "
215 "must be the same.");
216 assertEqualMem(buff+2048*16+0x32d, buff+2048*17+0x32d, 0x44);
219 failure("Volume Descriptor Set Terminator "
220 "should be in 18 Logical Sector.");
221 assertEqualMem(buff+2048*18, terminator_id, 8);
222 for (i = 8; i < 2048; i++) {
223 failure("Body of Volume Descriptor Set Terminator "
224 "should be all nulls.");
225 assertEqualInt(buff[2048*18+i], 0);
228 /* "file1" Contents is zisofs data. */
229 failure("file1 image should be zisofs'ed.");
230 assertEqualMem(buff+2048*31, zisofs_magic, 8);
231 /* "file2" Contents is not zisofs data. */
232 failure("file2 image should not be zisofs'ed.");
233 assertEqualMem(buff+2048*32, nullb, 8);
234 /* "file3" Contents is zisofs data. */
235 failure("file3 image should be zisofs'ed.");
236 assertEqualMem(buff+2048*33, zisofs_magic, 8);
237 /* "file4" Contents is zisofs data. */
238 failure("file4 image should be zisofs'ed.");
239 assertEqualMem(buff+2048*34, zisofs_magic, 8);
244 assert((a = archive_read_new()) != NULL);
245 assertEqualIntA(a, 0, archive_read_support_format_all(a));
246 assertEqualIntA(a, 0, archive_read_support_filter_all(a));
247 assertEqualIntA(a, 0, archive_read_open_memory(a, buff, used));
250 * Read Root Directory
251 * Root Directory entry must be in ISO image.
253 assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
254 assertEqualInt(archive_entry_atime(ae), archive_entry_ctime(ae));
255 assertEqualInt(archive_entry_atime(ae), archive_entry_mtime(ae));
256 assertEqualString(".", archive_entry_pathname(ae));
257 assert((S_IFDIR | 0555) == archive_entry_mode(ae));
258 assertEqualInt(2048, archive_entry_size(ae));
261 * Read "file1" which has 256K bytes null data.
263 assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
264 assertEqualInt(2, archive_entry_atime(ae));
265 /* assertEqualInt(3, archive_entry_birthtime(ae)); */
266 assertEqualInt(4, archive_entry_ctime(ae));
267 assertEqualInt(5, archive_entry_mtime(ae));
268 assertEqualString("file1", archive_entry_pathname(ae));
269 assert((S_IFREG | 0555) == archive_entry_mode(ae));
270 assertEqualInt(256*1024, archive_entry_size(ae));
271 assertEqualIntA(a, 1024, archive_read_data(a, buff2, 1024));
272 assertEqualMem(buff2, nullb, 1024);
275 * Read "file2" which has 2048 bytes null data.
277 assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
278 assertEqualInt(2, archive_entry_atime(ae));
279 /* assertEqualInt(3, archive_entry_birthtime(ae)); */
280 assertEqualInt(4, archive_entry_ctime(ae));
281 assertEqualInt(5, archive_entry_mtime(ae));
282 assertEqualString("file2", archive_entry_pathname(ae));
283 assert((S_IFREG | 0555) == archive_entry_mode(ae));
284 assertEqualInt(2048, archive_entry_size(ae));
285 assertEqualIntA(a, 1024, archive_read_data(a, buff2, 1024));
286 assertEqualMem(buff2, nullb, 1024);
289 * Read "file3" which has 2049 bytes null data.
291 assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
292 assertEqualInt(2, archive_entry_atime(ae));
293 /* assertEqualInt(3, archive_entry_birthtime(ae)); */
294 assertEqualInt(4, archive_entry_ctime(ae));
295 assertEqualInt(5, archive_entry_mtime(ae));
296 assertEqualString("file3", archive_entry_pathname(ae));
297 assert((S_IFREG | 0555) == archive_entry_mode(ae));
298 assertEqualInt(2049, archive_entry_size(ae));
299 assertEqualIntA(a, 1024, archive_read_data(a, buff2, 1024));
300 assertEqualMem(buff2, nullb, 1024);
303 * Read "file4" which has 32K bytes null data.
305 assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
306 assertEqualInt(2, archive_entry_atime(ae));
307 /* assertEqualInt(3, archive_entry_birthtime(ae)); */
308 assertEqualInt(4, archive_entry_ctime(ae));
309 assertEqualInt(5, archive_entry_mtime(ae));
310 assertEqualString("file4", archive_entry_pathname(ae));
311 assert((S_IFREG | 0555) == archive_entry_mode(ae));
312 assertEqualInt(32768, archive_entry_size(ae));
313 assertEqualIntA(a, 1024, archive_read_data(a, buff2, 1024));
314 assertEqualMem(buff2, nullb, 1024);
317 * Verify the end of the archive.
319 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
320 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
321 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
327 test_write_format_iso9660_zisofs_2(void)
329 unsigned char buff2[1024];
330 unsigned char data[1024];
332 struct archive_entry *ae;
334 size_t buffsize = 60 * 2048;
339 buff = malloc(buffsize);
340 assert(buff != NULL);
344 /* ISO9660 format: Create a new archive in memory. */
345 assert((a = archive_write_new()) != NULL);
346 assertEqualIntA(a, 0, archive_write_set_format_iso9660(a));
347 assertEqualIntA(a, 0, archive_write_add_filter_none(a));
348 r = archive_write_set_option(a, NULL, "zisofs", "1");
349 if (r == ARCHIVE_FATAL) {
350 skipping("zisofs option not supported on this platform");
351 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
355 assertEqualIntA(a, 0, archive_write_set_option(a, NULL, "pad", NULL));
356 assertEqualIntA(a, 0, archive_write_open_memory(a, buff, buffsize, &used));
359 * "file1" has a bunch of attributes and 256K bytes of random data.
361 assert((ae = archive_entry_new()) != NULL);
362 archive_entry_set_atime(ae, 2, 20);
363 archive_entry_set_birthtime(ae, 3, 30);
364 archive_entry_set_ctime(ae, 4, 40);
365 archive_entry_set_mtime(ae, 5, 50);
366 archive_entry_copy_pathname(ae, "file1");
367 archive_entry_set_mode(ae, S_IFREG | 0755);
368 archive_entry_set_size(ae, 256*1024);
369 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
370 archive_entry_free(ae);
371 for (i = 0; i < 256; i++) {
374 for (j = 0; j < (int)sizeof(data); j++)
375 data[j] = (i^j) & 0xff;
377 for (j = 0; j < (int)sizeof(data); j++)
380 assertEqualIntA(a, 1024, archive_write_data(a, data, 1024));
384 * "file2" has a bunch of attributes and 2048 bytes data.
386 assert((ae = archive_entry_new()) != NULL);
387 archive_entry_set_atime(ae, 2, 20);
388 archive_entry_set_birthtime(ae, 3, 30);
389 archive_entry_set_ctime(ae, 4, 40);
390 archive_entry_set_mtime(ae, 5, 50);
391 archive_entry_copy_pathname(ae, "file2");
392 archive_entry_set_mode(ae, S_IFREG | 0755);
393 archive_entry_set_size(ae, 2048);
394 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
395 archive_entry_free(ae);
396 memset(data, 'a', sizeof(data));
397 assertEqualIntA(a, 1024, archive_write_data(a, data, 1024));
398 memset(data, 'b', sizeof(data));
399 assertEqualIntA(a, 1024, archive_write_data(a, data, 1024));
402 * "file3" has a bunch of attributes and 1024 bytes of 'Z'
403 * + 1025 bytes of null data.
405 assert((ae = archive_entry_new()) != NULL);
406 archive_entry_set_atime(ae, 2, 20);
407 archive_entry_set_birthtime(ae, 3, 30);
408 archive_entry_set_ctime(ae, 4, 40);
409 archive_entry_set_mtime(ae, 5, 50);
410 archive_entry_copy_pathname(ae, "file3");
411 archive_entry_set_mode(ae, S_IFREG | 0755);
412 archive_entry_set_size(ae, 2049);
413 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
414 archive_entry_free(ae);
415 memset(data, 'Z', sizeof(data));
416 assertEqualIntA(a, 1024, archive_write_data(a, data, 1024));
419 * "file4" has a bunch of attributes and 24 bytes of zisofs data
420 * which is compressed from 32K bytes null data.
422 assert((ae = archive_entry_new()) != NULL);
423 archive_entry_set_atime(ae, 2, 20);
424 archive_entry_set_birthtime(ae, 3, 30);
425 archive_entry_set_ctime(ae, 4, 40);
426 archive_entry_set_mtime(ae, 5, 50);
427 archive_entry_copy_pathname(ae, "file4");
428 archive_entry_set_mode(ae, S_IFREG | 0755);
429 archive_entry_set_size(ae, 24);
430 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
431 archive_entry_free(ae);
432 assertEqualIntA(a, 24, archive_write_data(a, zisofs_data, 24));
434 /* Close out the archive. */
435 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
436 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
438 failure("The ISO image size should be 110592 bytes.");
439 assertEqualInt(used, 2048 * 54);
441 /* Check System Area. */
442 for (i = 0; i < 2048 * 16; i++) {
443 failure("System Area should be all nulls.");
444 assertEqualInt(buff[i], 0);
447 /* Primary Volume. */
448 failure("Primary Volume Descriptor should be in 16 Logical Sector.");
449 assertEqualMem(buff+2048*16, primary_id, 8);
450 assertEqualMem(buff+2048*16+0x28,
452 assertEqualMem(buff+2048*16+0x50, volumesize2, 8);
454 /* Supplementary Volume. */
455 failure("Supplementary Volume(Joliet) Descriptor "
456 "should be in 17 Logical Sector.");
457 assertEqualMem(buff+2048*17, supplementary_id, 8);
458 assertEqualMem(buff+2048*17+0x28, volumeidu16, 32);
459 assertEqualMem(buff+2048*17+0x50, volumesize2, 8);
460 failure("Date and Time of Primary Volume and "
461 "Date and Time of Supplementary Volume "
462 "must be the same.");
463 assertEqualMem(buff+2048*16+0x32d, buff+2048*17+0x32d, 0x44);
466 failure("Volume Descriptor Set Terminator "
467 "should be in 18 Logical Sector.");
468 assertEqualMem(buff+2048*18, terminator_id, 8);
469 for (i = 8; i < 2048; i++) {
470 failure("Body of Volume Descriptor Set Terminator "
471 "should be all nulls.");
472 assertEqualInt(buff[2048*18+i], 0);
475 /* "file1" Contents is zisofs data. */
476 failure("file1 image should be zisofs'ed.");
477 assertEqualMem(buff+2048*31, zisofs_magic, 8);
478 /* "file2" Contents is not zisofs data. */
479 memset(data, 'a', sizeof(data));
480 failure("file2 image should not be zisofs'ed.");
481 assertEqualMem(buff+2048*51, data, 1024);
482 memset(data, 'b', sizeof(data));
483 failure("file2 image should not be zisofs'ed.");
484 assertEqualMem(buff+2048*51+1024, data, 1024);
485 /* "file3" Contents is zisofs data. */
486 failure("file3 image should be zisofs'ed.");
487 assertEqualMem(buff+2048*52, zisofs_magic, 8);
488 /* "file4" Contents is zisofs data. */
489 failure("file4 image should be zisofs'ed.");
490 assertEqualMem(buff+2048*53, zisofs_magic, 8);
495 assert((a = archive_read_new()) != NULL);
496 assertEqualIntA(a, 0, archive_read_support_format_all(a));
497 assertEqualIntA(a, 0, archive_read_support_filter_all(a));
498 assertEqualIntA(a, 0, archive_read_open_memory(a, buff, used));
501 * Read Root Directory
502 * Root Directory entry must be in ISO image.
504 assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
505 assertEqualInt(archive_entry_atime(ae), archive_entry_ctime(ae));
506 assertEqualInt(archive_entry_atime(ae), archive_entry_mtime(ae));
507 assertEqualString(".", archive_entry_pathname(ae));
508 assert((S_IFDIR | 0555) == archive_entry_mode(ae));
509 assertEqualInt(2048, archive_entry_size(ae));
512 * Read "file1" which has 256K bytes random data.
514 assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
515 assertEqualInt(2, archive_entry_atime(ae));
516 assertEqualInt(4, archive_entry_ctime(ae));
517 assertEqualInt(5, archive_entry_mtime(ae));
518 assertEqualString("file1", archive_entry_pathname(ae));
519 assert((S_IFREG | 0555) == archive_entry_mode(ae));
520 assertEqualInt(256*1024, archive_entry_size(ae));
521 assertEqualIntA(a, 1024, archive_read_data(a, buff2, 1024));
524 * Read "file2" which has 2048 bytes data.
526 assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
527 assertEqualInt(2, archive_entry_atime(ae));
528 assertEqualInt(4, archive_entry_ctime(ae));
529 assertEqualInt(5, archive_entry_mtime(ae));
530 assertEqualString("file2", archive_entry_pathname(ae));
531 assert((S_IFREG | 0555) == archive_entry_mode(ae));
532 assertEqualInt(2048, archive_entry_size(ae));
533 assertEqualIntA(a, 1024, archive_read_data(a, buff2, 1024));
534 memset(data, 'a', sizeof(data));
535 assertEqualMem(buff2, data, 1024);
538 * Read "file3" which has 2049 bytes data.
540 assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
541 assertEqualInt(2, archive_entry_atime(ae));
542 assertEqualInt(4, archive_entry_ctime(ae));
543 assertEqualInt(5, archive_entry_mtime(ae));
544 assertEqualString("file3", archive_entry_pathname(ae));
545 assert((S_IFREG | 0555) == archive_entry_mode(ae));
546 assertEqualInt(2049, archive_entry_size(ae));
547 assertEqualIntA(a, 1024, archive_read_data(a, buff2, 1024));
548 memset(data, 'Z', sizeof(data));
549 assertEqualMem(buff2, data, 1024);
552 * Read "file4" which has 32K bytes null data.
554 assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
555 assertEqualInt(2, archive_entry_atime(ae));
556 assertEqualInt(4, archive_entry_ctime(ae));
557 assertEqualInt(5, archive_entry_mtime(ae));
558 assertEqualString("file4", archive_entry_pathname(ae));
559 assert((S_IFREG | 0555) == archive_entry_mode(ae));
560 assertEqualInt(32768, archive_entry_size(ae));
561 assertEqualIntA(a, 1024, archive_read_data(a, buff2, 1024));
562 memset(data, 0, sizeof(data));
563 assertEqualMem(buff2, data, 1024);
566 * Verify the end of the archive.
568 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
569 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
570 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
576 * Make a bootable ISO image with "zisofs" option.
579 test_write_format_iso9660_zisofs_3(void)
581 unsigned char buff2[1024];
582 unsigned char nullb[2048];
584 struct archive_entry *ae;
586 size_t buffsize = 50 * 2048;
591 memset(nullb, 0, sizeof(nullb));
592 buff = malloc(buffsize);
593 assert(buff != NULL);
597 /* ISO9660 format: Create a new archive in memory. */
598 assert((a = archive_write_new()) != NULL);
599 assertEqualIntA(a, 0, archive_write_set_format_iso9660(a));
600 assertEqualIntA(a, 0, archive_write_add_filter_none(a));
601 r = archive_write_set_option(a, NULL, "zisofs", "1");
602 if (r == ARCHIVE_FATAL) {
603 skipping("zisofs option not supported on this platform");
604 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
608 assertEqualIntA(a, 0, archive_write_set_option(a, NULL, "boot", "boot.img"));
609 assertEqualIntA(a, 0, archive_write_set_option(a, NULL, "pad", NULL));
610 assertEqualIntA(a, 0, archive_write_open_memory(a, buff, buffsize, &used));
613 * "file1" has a bunch of attributes and 256K bytes of null data.
615 assert((ae = archive_entry_new()) != NULL);
616 archive_entry_set_atime(ae, 2, 20);
617 archive_entry_set_birthtime(ae, 3, 30);
618 archive_entry_set_ctime(ae, 4, 40);
619 archive_entry_set_mtime(ae, 5, 50);
620 archive_entry_copy_pathname(ae, "boot.img");
621 archive_entry_set_mode(ae, S_IFREG | 0755);
622 archive_entry_set_size(ae, 10*1024);
623 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
624 archive_entry_free(ae);
625 assertEqualIntA(a, 1024, archive_write_data(a, nullb, 1024));
628 * "file2" has a bunch of attributes and 2048 bytes of null data.
630 assert((ae = archive_entry_new()) != NULL);
631 archive_entry_set_atime(ae, 2, 20);
632 archive_entry_set_birthtime(ae, 3, 30);
633 archive_entry_set_ctime(ae, 4, 40);
634 archive_entry_set_mtime(ae, 5, 50);
635 archive_entry_copy_pathname(ae, "file2");
636 archive_entry_set_mode(ae, S_IFREG | 0755);
637 archive_entry_set_size(ae, 2048);
638 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
639 archive_entry_free(ae);
640 assertEqualIntA(a, 1024, archive_write_data(a, nullb, 1024));
643 * "file3" has a bunch of attributes and 2049 bytes of null data.
645 assert((ae = archive_entry_new()) != NULL);
646 archive_entry_set_atime(ae, 2, 20);
647 archive_entry_set_birthtime(ae, 3, 30);
648 archive_entry_set_ctime(ae, 4, 40);
649 archive_entry_set_mtime(ae, 5, 50);
650 archive_entry_copy_pathname(ae, "file3");
651 archive_entry_set_mode(ae, S_IFREG | 0755);
652 archive_entry_set_size(ae, 2049);
653 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
654 archive_entry_free(ae);
655 assertEqualIntA(a, 1024, archive_write_data(a, nullb, 1024));
657 /* Close out the archive. */
658 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
659 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
661 failure("The ISO image size should be 81920 bytes.");
662 assertEqualInt(used, 2048 * 40);
664 /* Check System Area. */
665 for (i = 0; i < 2048 * 16; i++) {
666 failure("System Area should be all nulls.");
667 assertEqualInt(buff[i], 0);
670 /* Primary Volume. */
671 failure("Primary Volume Descriptor should be in 16 Logical Sector.");
672 assertEqualMem(buff+2048*16, primary_id, 8);
673 assertEqualMem(buff+2048*16+0x28,
675 assertEqualMem(buff+2048*16+0x50, volumesize3, 8);
678 failure("Boot Volume Descriptor should be in 17 Logical Sector.");
679 assertEqualMem(buff+2048*17, boot_id, sizeof(boot_id));
680 for (i = 0x27; i <= 0x46; i++) {
681 failure("Unused area must be all nulls.");
682 assert(buff[2048*17+i] == 0);
684 /* First sector of Boot Catalog. */
685 assert(buff[2048*17+0x47] == 0x20);
686 assert(buff[2048*17+0x48] == 0x00);
687 assert(buff[2048*17+0x49] == 0x00);
688 assert(buff[2048*17+0x4a] == 0x00);
689 for (i = 0x4a; i <= 0x7ff; i++) {
690 failure("Unused area must be all nulls.");
691 assert(buff[2048*17+i] == 0);
694 /* Supplementary Volume. */
695 failure("Supplementary Volume(Joliet) Descriptor "
696 "should be in 18 Logical Sector.");
697 assertEqualMem(buff+2048*18, supplementary_id, 8);
698 assertEqualMem(buff+2048*18+0x28, volumeidu16, 32);
699 assertEqualMem(buff+2048*18+0x50, volumesize3, 8);
700 failure("Date and Time of Primary Volume and "
701 "Date and Time of Supplementary Volume "
702 "must be the same.");
703 assertEqualMem(buff+2048*16+0x32d, buff+2048*18+0x32d, 0x44);
706 failure("Volume Descriptor Set Terminator "
707 "should be in 19 Logical Sector.");
708 assertEqualMem(buff+2048*19, terminator_id, 8);
709 for (i = 8; i < 2048; i++) {
710 failure("Body of Volume Descriptor Set Terminator "
711 "should be all nulls.");
712 assertEqualInt(buff[2048*19+i], 0);
715 /* Check signature of El-Torito. */
716 assertEqualMem(buff+2048*31, el_torito_signature, 237);
717 assertEqualMem(buff+2048*31+237, nullb, 2048-237);
719 /* Check contents of "boot.catalog". */
720 assertEqualMem(buff+2048*32, boot_catalog, 64);
721 assertEqualMem(buff+2048*32+64, nullb, 2048-64);
723 /* Check contents of "boot.img". */
724 failure("boot.img image should not be zisofs'ed.");
725 assertEqualMem(buff+2048*33, nullb, 2048);
726 for (i = 2048*34; i < 2048*38; i += 2048) {
727 assertEqualMem(buff+i, nullb, 2048);
730 /* "file2" Contents is not zisofs data. */
731 failure("file2 image should not be zisofs'ed.");
732 assertEqualMem(buff+2048*38, nullb, 8);
733 /* "file3" Contents is zisofs data. */
734 failure("file3 image should be zisofs'ed.");
735 assertEqualMem(buff+2048*39, zisofs_magic, 8);
740 assert((a = archive_read_new()) != NULL);
741 assertEqualIntA(a, 0, archive_read_support_format_all(a));
742 assertEqualIntA(a, 0, archive_read_support_filter_all(a));
743 assertEqualIntA(a, 0, archive_read_open_memory(a, buff, used));
746 * Read Root Directory
747 * Root Directory entry must be in ISO image.
749 assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
750 assertEqualInt(archive_entry_atime(ae), archive_entry_ctime(ae));
751 assertEqualInt(archive_entry_atime(ae), archive_entry_mtime(ae));
752 assertEqualString(".", archive_entry_pathname(ae));
753 assert((S_IFDIR | 0555) == archive_entry_mode(ae));
754 assertEqualInt(2048, archive_entry_size(ae));
757 * Read "boot.catalog".
759 assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
760 assertEqualString("boot.catalog", archive_entry_pathname(ae));
761 #if !defined(_WIN32) && !defined(__CYGWIN__)
762 assert((S_IFREG | 0444) == archive_entry_mode(ae));
764 /* On Windows and CYGWIN, always set all exec bit ON by default. */
765 assert((S_IFREG | 0555) == archive_entry_mode(ae));
767 assertEqualInt(1, archive_entry_nlink(ae));
768 assertEqualInt(2*1024, archive_entry_size(ae));
769 assertEqualIntA(a, 1024, archive_read_data(a, buff2, 1024));
770 assertEqualMem(buff2, boot_catalog, 64);
775 assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
776 assertEqualInt(2, archive_entry_atime(ae));
777 assertEqualInt(3, archive_entry_birthtime(ae));
778 assertEqualInt(4, archive_entry_ctime(ae));
779 assertEqualInt(5, archive_entry_mtime(ae));
780 assertEqualString("boot.img", archive_entry_pathname(ae));
781 assert((S_IFREG | 0555) == archive_entry_mode(ae));
782 assertEqualInt(1, archive_entry_nlink(ae));
783 assertEqualInt(10*1024, archive_entry_size(ae));
784 assertEqualIntA(a, 1024, archive_read_data(a, buff2, 1024));
785 assertEqualMem(buff2, nullb, 1024);
788 * Read "file2" which has 2048 bytes null data.
790 assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
791 assertEqualInt(2, archive_entry_atime(ae));
792 assertEqualInt(4, archive_entry_ctime(ae));
793 assertEqualInt(5, archive_entry_mtime(ae));
794 assertEqualString("file2", archive_entry_pathname(ae));
795 assert((S_IFREG | 0555) == archive_entry_mode(ae));
796 assertEqualInt(2048, archive_entry_size(ae));
797 assertEqualIntA(a, 1024, archive_read_data(a, buff2, 1024));
798 assertEqualMem(buff2, nullb, 1024);
801 * Read "file3" which has 2049 bytes null data.
803 assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
804 assertEqualInt(2, archive_entry_atime(ae));
805 assertEqualInt(4, archive_entry_ctime(ae));
806 assertEqualInt(5, archive_entry_mtime(ae));
807 assertEqualString("file3", archive_entry_pathname(ae));
808 assert((S_IFREG | 0555) == archive_entry_mode(ae));
809 assertEqualInt(2049, archive_entry_size(ae));
810 assertEqualIntA(a, 1024, archive_read_data(a, buff2, 1024));
811 assertEqualMem(buff2, nullb, 1024);
814 * Verify the end of the archive.
816 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
817 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
818 assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
823 DEFINE_TEST(test_write_format_iso9660_zisofs)
825 test_write_format_iso9660_zisofs_1();
826 test_write_format_iso9660_zisofs_2();
827 test_write_format_iso9660_zisofs_3();