1 /*-
2 * Copyright (c) 2009-2011 Michihiro NAKAJIMA
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
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.
13 *
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.
24 */
25 #include "test.h"
26
27 /*
28 * Check that a "zisofs" ISO 9660 image is correctly created.
29 */
30
31 static const unsigned char primary_id[] = {
32 0x01, 0x43, 0x44, 0x30, 0x30, 0x31, 0x01, 0x00
33 };
34 static const unsigned char volumesize[] = {
35 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23
36 };
37 static const unsigned char volumesize2[] = {
38 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36
39 };
40 static const unsigned char volumesize3[] = {
41 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28
42 };
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
48 };
49 static const unsigned char supplementary_id[] = {
50 0x02, 0x43, 0x44, 0x30, 0x30, 0x31, 0x01, 0x00
51 };
52 static const unsigned char terminator_id[] = {
53 0xff, 0x43, 0x44, 0x30, 0x30, 0x31, 0x01, 0x00
54 };
55
56 static const unsigned char zisofs_magic[8] = {
57 0x37, 0xE4, 0x53, 0x96, 0xC9, 0xDB, 0xD6, 0x07
58 };
59
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
64 };
65
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,
72 };
73
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
83 };
84
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."
91 };
92
93 static void
test_write_format_iso9660_zisofs_1(void)94 test_write_format_iso9660_zisofs_1(void)
95 {
96 unsigned char buff2[1024];
97 unsigned char nullb[1024];
98 struct archive *a;
99 struct archive_entry *ae;
100 unsigned char *buff;
101 size_t buffsize = 36 * 2048;
102 size_t used;
103 unsigned int i;
104 int r;
105
106 memset(nullb, 0, sizeof(nullb));
107 buff = malloc(buffsize);
108 assert(buff != NULL);
109 if (buff == NULL)
110 return;
111
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));
120 free(buff);
121 return;
122 }
123 assertEqualIntA(a, 0, archive_write_set_option(a, NULL, "pad", NULL));
124 assertEqualIntA(a, 0, archive_write_open_memory(a, buff, buffsize, &used));
125
126 /*
127 * "file1" has a bunch of attributes and 256K bytes of null data.
128 */
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));
140
141 /*
142 * "file2" has a bunch of attributes and 2048 bytes of null data.
143 */
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));
155
156 /*
157 * "file3" has a bunch of attributes and 2049 bytes of null data.
158 */
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));
170
171 /*
172 * "file4" has a bunch of attributes and 24 bytes of zisofs data
173 * which is compressed from 32K bytes null data.
174 */
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));
186
187 /* Close out the archive. */
188 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
189 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
190
191 failure("The ISO image size should be 71680 bytes.");
192 assertEqualInt(used, 2048 * 35);
193
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);
198 }
199
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,
204 "CDROM ", 32);
205 assertEqualMem(buff+2048*16+0x50, volumesize, 8);
206
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);
217
218 /* Terminator. */
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);
226 }
227
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);
240
241 /*
242 * Read ISO image.
243 */
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));
248
249 /*
250 * Read Root Directory
251 * Root Directory entry must be in ISO image.
252 */
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));
259
260 /*
261 * Read "file1" which has 256K bytes null data.
262 */
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);
273
274 /*
275 * Read "file2" which has 2048 bytes null data.
276 */
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);
287
288 /*
289 * Read "file3" which has 2049 bytes null data.
290 */
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);
301
302 /*
303 * Read "file4" which has 32K bytes null data.
304 */
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);
315
316 /*
317 * Verify the end of the archive.
318 */
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));
322
323 free(buff);
324 }
325
326 static void
test_write_format_iso9660_zisofs_2(void)327 test_write_format_iso9660_zisofs_2(void)
328 {
329 unsigned char buff2[1024];
330 unsigned char data[1024];
331 struct archive *a;
332 struct archive_entry *ae;
333 unsigned char *buff;
334 size_t buffsize = 60 * 2048;
335 size_t used;
336 unsigned int i;
337 int r;
338
339 buff = malloc(buffsize);
340 assert(buff != NULL);
341 if (buff == NULL)
342 return;
343
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));
352 free(buff);
353 return;
354 }
355 assertEqualIntA(a, 0, archive_write_set_option(a, NULL, "pad", NULL));
356 assertEqualIntA(a, 0, archive_write_open_memory(a, buff, buffsize, &used));
357
358 /*
359 * "file1" has a bunch of attributes and 256K bytes of random data.
360 */
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++) {
372 int j;
373 if (i == 0) {
374 for (j = 0; j < (int)sizeof(data); j++)
375 data[j] = (i^j) & 0xff;
376 } else {
377 for (j = 0; j < (int)sizeof(data); j++)
378 data[j] ^= i+j;
379 }
380 assertEqualIntA(a, 1024, archive_write_data(a, data, 1024));
381 }
382
383 /*
384 * "file2" has a bunch of attributes and 2048 bytes data.
385 */
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));
400
401 /*
402 * "file3" has a bunch of attributes and 1024 bytes of 'Z'
403 * + 1025 bytes of null data.
404 */
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));
417
418 /*
419 * "file4" has a bunch of attributes and 24 bytes of zisofs data
420 * which is compressed from 32K bytes null data.
421 */
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));
433
434 /* Close out the archive. */
435 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
436 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
437
438 failure("The ISO image size should be 110592 bytes.");
439 assertEqualInt(used, 2048 * 54);
440
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);
445 }
446
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,
451 "CDROM ", 32);
452 assertEqualMem(buff+2048*16+0x50, volumesize2, 8);
453
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);
464
465 /* Terminator. */
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);
473 }
474
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);
491
492 /*
493 * Read ISO image.
494 */
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));
499
500 /*
501 * Read Root Directory
502 * Root Directory entry must be in ISO image.
503 */
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));
510
511 /*
512 * Read "file1" which has 256K bytes random data.
513 */
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));
522
523 /*
524 * Read "file2" which has 2048 bytes data.
525 */
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);
536
537 /*
538 * Read "file3" which has 2049 bytes data.
539 */
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);
550
551 /*
552 * Read "file4" which has 32K bytes null data.
553 */
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);
564
565 /*
566 * Verify the end of the archive.
567 */
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));
571
572 free(buff);
573 }
574
575 /*
576 * Make a bootable ISO image with "zisofs" option.
577 */
578 static void
test_write_format_iso9660_zisofs_3(void)579 test_write_format_iso9660_zisofs_3(void)
580 {
581 unsigned char buff2[1024];
582 unsigned char nullb[2048];
583 struct archive *a;
584 struct archive_entry *ae;
585 unsigned char *buff;
586 size_t buffsize = 50 * 2048;
587 size_t used;
588 unsigned int i;
589 int r;
590
591 memset(nullb, 0, sizeof(nullb));
592 buff = malloc(buffsize);
593 assert(buff != NULL);
594 if (buff == NULL)
595 return;
596
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));
605 free(buff);
606 return;
607 }
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));
611
612 /*
613 * "file1" has a bunch of attributes and 256K bytes of null data.
614 */
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));
626
627 /*
628 * "file2" has a bunch of attributes and 2048 bytes of null data.
629 */
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));
641
642 /*
643 * "file3" has a bunch of attributes and 2049 bytes of null data.
644 */
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));
656
657 /* Close out the archive. */
658 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
659 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
660
661 failure("The ISO image size should be 81920 bytes.");
662 assertEqualInt(used, 2048 * 40);
663
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);
668 }
669
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,
674 "CDROM ", 32);
675 assertEqualMem(buff+2048*16+0x50, volumesize3, 8);
676
677 /* Boot Volume. */
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);
683 }
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);
692 }
693
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);
704
705 /* Terminator. */
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);
713 }
714
715 /* Check signature of El-Torito. */
716 assertEqualMem(buff+2048*31, el_torito_signature, 237);
717 assertEqualMem(buff+2048*31+237, nullb, 2048-237);
718
719 /* Check contents of "boot.catalog". */
720 assertEqualMem(buff+2048*32, boot_catalog, 64);
721 assertEqualMem(buff+2048*32+64, nullb, 2048-64);
722
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);
728 }
729
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);
736
737 /*
738 * Read ISO image.
739 */
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));
744
745 /*
746 * Read Root Directory
747 * Root Directory entry must be in ISO image.
748 */
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));
755
756 /*
757 * Read "boot.catalog".
758 */
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));
763 #else
764 /* On Windows and CYGWIN, always set all exec bit ON by default. */
765 assert((S_IFREG | 0555) == archive_entry_mode(ae));
766 #endif
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);
771
772 /*
773 * Read "boot.img".
774 */
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);
786
787 /*
788 * Read "file2" which has 2048 bytes null data.
789 */
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);
799
800 /*
801 * Read "file3" which has 2049 bytes null data.
802 */
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);
812
813 /*
814 * Verify the end of the archive.
815 */
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));
819
820 free(buff);
821 }
822
DEFINE_TEST(test_write_format_iso9660_zisofs)823 DEFINE_TEST(test_write_format_iso9660_zisofs)
824 {
825 test_write_format_iso9660_zisofs_1();
826 test_write_format_iso9660_zisofs_2();
827 test_write_format_iso9660_zisofs_3();
828 }
829