1/* $NetBSD: cd9660_eltorito.c,v 1.17 2011/06/23 02:35:56 enami Exp $ */ 2 3/* 4 * Copyright (c) 2005 Daniel Watt, Walter Deignan, Ryan Gabrys, Alan 5 * Perez-Rathke and Ram Vedam. All rights reserved. 6 * 7 * This code was written by Daniel Watt, Walter Deignan, Ryan Gabrys, 8 * Alan Perez-Rathke and Ram Vedam. 9 * 10 * Redistribution and use in source and binary forms, with or 11 * without modification, are permitted provided that the following 12 * conditions are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above 16 * copyright notice, this list of conditions and the following 17 * disclaimer in the documentation and/or other materials provided 18 * with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY DANIEL WATT, WALTER DEIGNAN, RYAN 21 * GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 24 * DISCLAIMED. IN NO EVENT SHALL DANIEL WATT, WALTER DEIGNAN, RYAN 25 * GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF 28 * USE,DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 29 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 32 * OF SUCH DAMAGE. 33 */ 34 35#include "cd9660.h" 36#include "cd9660_eltorito.h" 37 38#include <sys/cdefs.h> 39__FBSDID("$FreeBSD$"); 40 41#ifdef DEBUG 42#define ELTORITO_DPRINTF(__x) printf __x 43#else 44#define ELTORITO_DPRINTF(__x) 45#endif 46 47static struct boot_catalog_entry *cd9660_init_boot_catalog_entry(void); 48static struct boot_catalog_entry *cd9660_boot_setup_validation_entry(char); 49static struct boot_catalog_entry *cd9660_boot_setup_default_entry( 50 struct cd9660_boot_image *); 51static struct boot_catalog_entry *cd9660_boot_setup_section_head(char); 52static struct boot_catalog_entry *cd9660_boot_setup_validation_entry(char); 53#if 0 54static u_char cd9660_boot_get_system_type(struct cd9660_boot_image *); 55#endif 56 57int 58cd9660_add_boot_disk(const char *boot_info) 59{ 60 struct stat stbuf; 61 const char *mode_msg; 62 char *temp; 63 char *sysname; 64 char *filename; 65 struct cd9660_boot_image *new_image, *tmp_image; 66 67 assert(boot_info != NULL); 68 69 if (*boot_info == '\0') { 70 warnx("Error: Boot disk information must be in the " 71 "format 'system;filename'"); 72 return 0; 73 } 74 75 /* First decode the boot information */ 76 if ((temp = strdup(boot_info)) == NULL) { 77 warn("%s: strdup", __func__); 78 return 0; 79 } 80 81 sysname = temp; 82 filename = strchr(sysname, ';'); 83 if (filename == NULL) { 84 warnx("supply boot disk information in the format " 85 "'system;filename'"); 86 free(temp); 87 return 0; 88 } 89 90 *filename++ = '\0'; 91 92 if (diskStructure.verbose_level > 0) { 93 printf("Found bootdisk with system %s, and filename %s\n", 94 sysname, filename); 95 } 96 if ((new_image = malloc(sizeof(*new_image))) == NULL) { 97 warn("%s: malloc", __func__); 98 free(temp); 99 return 0; 100 } 101 (void)memset(new_image, 0, sizeof(*new_image)); 102 new_image->loadSegment = 0; /* default for now */ 103 104 /* Decode System */ 105 if (strcmp(sysname, "i386") == 0) 106 new_image->system = ET_SYS_X86; 107 else if (strcmp(sysname, "powerpc") == 0) 108 new_image->system = ET_SYS_PPC; 109 else if (strcmp(sysname, "macppc") == 0 || 110 strcmp(sysname, "mac68k") == 0) 111 new_image->system = ET_SYS_MAC; 112 else { 113 warnx("boot disk system must be " 114 "i386, powerpc, macppc, or mac68k"); 115 free(temp); 116 free(new_image); 117 return 0; 118 } 119 120 121 if ((new_image->filename = strdup(filename)) == NULL) { 122 warn("%s: strdup", __func__); 123 free(temp); 124 free(new_image); 125 return 0; 126 } 127 128 free(temp); 129 130 /* Get information about the file */ 131 if (lstat(new_image->filename, &stbuf) == -1) 132 err(EXIT_FAILURE, "%s: lstat(\"%s\")", __func__, 133 new_image->filename); 134 135 switch (stbuf.st_size) { 136 case 1440 * 1024: 137 new_image->targetMode = ET_MEDIA_144FDD; 138 mode_msg = "Assigned boot image to 1.44 emulation mode"; 139 break; 140 case 1200 * 1024: 141 new_image->targetMode = ET_MEDIA_12FDD; 142 mode_msg = "Assigned boot image to 1.2 emulation mode"; 143 break; 144 case 2880 * 1024: 145 new_image->targetMode = ET_MEDIA_288FDD; 146 mode_msg = "Assigned boot image to 2.88 emulation mode"; 147 break; 148 default: 149 new_image->targetMode = ET_MEDIA_NOEM; 150 mode_msg = "Assigned boot image to no emulation mode"; 151 break; 152 } 153 154 if (diskStructure.verbose_level > 0) 155 printf("%s\n", mode_msg); 156 157 new_image->size = stbuf.st_size; 158 new_image->num_sectors = 159 howmany(new_image->size, diskStructure.sectorSize) * 160 howmany(diskStructure.sectorSize, 512); 161 if (diskStructure.verbose_level > 0) { 162 printf("New image has size %d, uses %d 512-byte sectors\n", 163 new_image->size, new_image->num_sectors); 164 } 165 new_image->sector = -1; 166 /* Bootable by default */ 167 new_image->bootable = ET_BOOTABLE; 168 /* Add boot disk */ 169 170 /* Group images for the same platform together. */ 171 TAILQ_FOREACH(tmp_image, &diskStructure.boot_images, image_list) { 172 if (tmp_image->system != new_image->system) 173 break; 174 } 175 176 if (tmp_image == NULL) { 177 TAILQ_INSERT_HEAD(&diskStructure.boot_images, new_image, 178 image_list); 179 } else 180 TAILQ_INSERT_BEFORE(tmp_image, new_image, image_list); 181 182 new_image->serialno = diskStructure.image_serialno++; 183 184 /* TODO : Need to do anything about the boot image in the tree? */ 185 diskStructure.is_bootable = 1; 186 187 return 1; 188} 189 190int 191cd9660_eltorito_add_boot_option(const char *option_string, const char *value) 192{ 193 char *eptr; 194 struct cd9660_boot_image *image; 195 196 assert(option_string != NULL); 197 198 /* Find the last image added */ 199 TAILQ_FOREACH(image, &diskStructure.boot_images, image_list) { 200 if (image->serialno + 1 == diskStructure.image_serialno) 201 break; 202 } 203 if (image == NULL) 204 errx(EXIT_FAILURE, "Attempted to add boot option, " 205 "but no boot images have been specified"); 206 207 if (strcmp(option_string, "no-emul-boot") == 0) { 208 image->targetMode = ET_MEDIA_NOEM; 209 } else if (strcmp(option_string, "no-boot") == 0) { 210 image->bootable = ET_NOT_BOOTABLE; 211 } else if (strcmp(option_string, "hard-disk-boot") == 0) { 212 image->targetMode = ET_MEDIA_HDD; 213 } else if (strcmp(option_string, "boot-load-segment") == 0) { 214 image->loadSegment = strtoul(value, &eptr, 16); 215 if (eptr == value || *eptr != '\0' || errno != ERANGE) { 216 warn("%s: strtoul", __func__); 217 return 0; 218 } 219 } else { 220 return 0; 221 } 222 return 1; 223} 224 225static struct boot_catalog_entry * 226cd9660_init_boot_catalog_entry(void) 227{ 228 struct boot_catalog_entry *temp; 229 230 if ((temp = malloc(sizeof(*temp))) == NULL) 231 return NULL; 232 233 return memset(temp, 0, sizeof(*temp)); 234} 235 236static struct boot_catalog_entry * 237cd9660_boot_setup_validation_entry(char sys) 238{ 239 struct boot_catalog_entry *entry; 240 boot_catalog_validation_entry *ve; 241 int16_t checksum; 242 unsigned char *csptr; 243 int i; 244 entry = cd9660_init_boot_catalog_entry(); 245 246 if (entry == NULL) { 247 warnx("Error: memory allocation failed in " 248 "cd9660_boot_setup_validation_entry"); 249 return 0; 250 } 251 ve = &entry->entry_data.VE; 252 253 ve->header_id[0] = 1; 254 ve->platform_id[0] = sys; 255 ve->key[0] = 0x55; 256 ve->key[1] = 0xAA; 257 258 /* Calculate checksum */ 259 checksum = 0; 260 cd9660_721(0, ve->checksum); 261 csptr = (unsigned char*)ve; 262 for (i = 0; i < sizeof(*ve); i += 2) { 263 checksum += (int16_t)csptr[i]; 264 checksum += 256 * (int16_t)csptr[i + 1]; 265 } 266 checksum = -checksum; 267 cd9660_721(checksum, ve->checksum); 268 269 ELTORITO_DPRINTF(("%s: header_id %d, platform_id %d, key[0] %d, key[1] %d, " 270 "checksum %04x\n", __func__, ve->header_id[0], ve->platform_id[0], 271 ve->key[0], ve->key[1], checksum)); 272 return entry; 273} 274 275static struct boot_catalog_entry * 276cd9660_boot_setup_default_entry(struct cd9660_boot_image *disk) 277{ 278 struct boot_catalog_entry *default_entry; 279 boot_catalog_initial_entry *ie; 280 281 default_entry = cd9660_init_boot_catalog_entry(); 282 if (default_entry == NULL) 283 return NULL; 284 285 ie = &default_entry->entry_data.IE; 286 287 ie->boot_indicator[0] = disk->bootable; 288 ie->media_type[0] = disk->targetMode; 289 cd9660_721(disk->loadSegment, ie->load_segment); 290 ie->system_type[0] = disk->system; 291 cd9660_721(disk->num_sectors, ie->sector_count); 292 cd9660_731(disk->sector, ie->load_rba); 293 294 ELTORITO_DPRINTF(("%s: boot indicator %d, media type %d, " 295 "load segment %04x, system type %d, sector count %d, " 296 "load rba %d\n", __func__, ie->boot_indicator[0], 297 ie->media_type[0], disk->loadSegment, ie->system_type[0], 298 disk->num_sectors, disk->sector)); 299 return default_entry; 300} 301 302static struct boot_catalog_entry * 303cd9660_boot_setup_section_head(char platform) 304{ 305 struct boot_catalog_entry *entry; 306 boot_catalog_section_header *sh; 307 308 entry = cd9660_init_boot_catalog_entry(); 309 if (entry == NULL) 310 return NULL; 311 312 sh = &entry->entry_data.SH; 313 /* More by default. The last one will manually be set to 0x91 */ 314 sh->header_indicator[0] = ET_SECTION_HEADER_MORE; 315 sh->platform_id[0] = platform; 316 sh->num_section_entries[0] = 0; 317 return entry; 318} 319 320static struct boot_catalog_entry * 321cd9660_boot_setup_section_entry(struct cd9660_boot_image *disk) 322{ 323 struct boot_catalog_entry *entry; 324 boot_catalog_section_entry *se; 325 if ((entry = cd9660_init_boot_catalog_entry()) == NULL) 326 return NULL; 327 328 se = &entry->entry_data.SE; 329 330 se->boot_indicator[0] = ET_BOOTABLE; 331 se->media_type[0] = disk->targetMode; 332 cd9660_721(disk->loadSegment, se->load_segment); 333 cd9660_721(disk->num_sectors, se->sector_count); 334 cd9660_731(disk->sector, se->load_rba); 335 return entry; 336} 337 338#if 0 339static u_char 340cd9660_boot_get_system_type(struct cd9660_boot_image *disk) 341{ 342 /* 343 For hard drive booting, we need to examine the MBR to figure 344 out what the partition type is 345 */ 346 return 0; 347} 348#endif 349 350/* 351 * Set up the BVD, Boot catalog, and the boot entries, but do no writing 352 */ 353int 354cd9660_setup_boot(int first_sector) 355{ 356 int sector; 357 int used_sectors; 358 int num_entries = 0; 359 int catalog_sectors; 360 struct boot_catalog_entry *x86_head, *mac_head, *ppc_head, 361 *valid_entry, *default_entry, *temp, *head, **headp, *next; 362 struct cd9660_boot_image *tmp_disk; 363 364 headp = NULL; 365 x86_head = mac_head = ppc_head = NULL; 366 367 /* If there are no boot disks, don't bother building boot information */ 368 if (TAILQ_EMPTY(&diskStructure.boot_images)) 369 return 0; 370 371 /* Point to catalog: For now assume it consumes one sector */ 372 ELTORITO_DPRINTF(("Boot catalog will go in sector %d\n", first_sector)); 373 diskStructure.boot_catalog_sector = first_sector; 374 cd9660_bothendian_dword(first_sector, 375 diskStructure.boot_descriptor->boot_catalog_pointer); 376 377 /* Step 1: Generate boot catalog */ 378 /* Step 1a: Validation entry */ 379 valid_entry = cd9660_boot_setup_validation_entry(ET_SYS_X86); 380 if (valid_entry == NULL) 381 return -1; 382 383 /* 384 * Count how many boot images there are, 385 * and how many sectors they consume. 386 */ 387 num_entries = 1; 388 used_sectors = 0; 389 390 TAILQ_FOREACH(tmp_disk, &diskStructure.boot_images, image_list) { 391 used_sectors += tmp_disk->num_sectors; 392 393 /* One default entry per image */ 394 num_entries++; 395 } 396 catalog_sectors = howmany(num_entries * 0x20, diskStructure.sectorSize); 397 used_sectors += catalog_sectors; 398 399 if (diskStructure.verbose_level > 0) { 400 printf("%s: there will be %i entries consuming %i sectors. " 401 "Catalog is %i sectors\n", __func__, num_entries, 402 used_sectors, catalog_sectors); 403 } 404 405 /* Populate sector numbers */ 406 sector = first_sector + catalog_sectors; 407 TAILQ_FOREACH(tmp_disk, &diskStructure.boot_images, image_list) { 408 tmp_disk->sector = sector; 409 sector += tmp_disk->num_sectors; 410 } 411 412 LIST_INSERT_HEAD(&diskStructure.boot_entries, valid_entry, ll_struct); 413 414 /* Step 1b: Initial/default entry */ 415 /* TODO : PARAM */ 416 tmp_disk = TAILQ_FIRST(&diskStructure.boot_images); 417 default_entry = cd9660_boot_setup_default_entry(tmp_disk); 418 if (default_entry == NULL) { 419 warnx("Error: memory allocation failed in cd9660_setup_boot"); 420 return -1; 421 } 422 423 LIST_INSERT_AFTER(valid_entry, default_entry, ll_struct); 424 425 /* Todo: multiple default entries? */ 426 427 tmp_disk = TAILQ_NEXT(tmp_disk, image_list); 428 429 temp = default_entry; 430 431 /* If multiple boot images are given : */ 432 while (tmp_disk != NULL) { 433 /* Step 2: Section header */ 434 switch (tmp_disk->system) { 435 case ET_SYS_X86: 436 headp = &x86_head; 437 break; 438 case ET_SYS_PPC: 439 headp = &ppc_head; 440 break; 441 case ET_SYS_MAC: 442 headp = &mac_head; 443 break; 444 default: 445 warnx("%s: internal error: unknown system type", 446 __func__); 447 return -1; 448 } 449 450 if (*headp == NULL) { 451 head = 452 cd9660_boot_setup_section_head(tmp_disk->system); 453 if (head == NULL) { 454 warnx("Error: memory allocation failed in " 455 "cd9660_setup_boot"); 456 return -1; 457 } 458 LIST_INSERT_AFTER(default_entry, head, ll_struct); 459 *headp = head; 460 } else 461 head = *headp; 462 463 head->entry_data.SH.num_section_entries[0]++; 464 465 /* Step 2a: Section entry and extensions */ 466 temp = cd9660_boot_setup_section_entry(tmp_disk); 467 if (temp == NULL) { 468 warn("%s: cd9660_boot_setup_section_entry", __func__); 469 return -1; 470 } 471 472 while ((next = LIST_NEXT(head, ll_struct)) != NULL && 473 next->entry_type == ET_ENTRY_SE) 474 head = next; 475 476 LIST_INSERT_AFTER(head, temp, ll_struct); 477 tmp_disk = TAILQ_NEXT(tmp_disk, image_list); 478 } 479 480 /* TODO: Remaining boot disks when implemented */ 481 482 return first_sector + used_sectors; 483} 484 485int 486cd9660_setup_boot_volume_descriptor(volume_descriptor *bvd) 487{ 488 boot_volume_descriptor *bvdData = 489 (boot_volume_descriptor*)bvd->volumeDescriptorData; 490 491 bvdData->boot_record_indicator[0] = ISO_VOLUME_DESCRIPTOR_BOOT; 492 memcpy(bvdData->identifier, ISO_VOLUME_DESCRIPTOR_STANDARD_ID, 5); 493 bvdData->version[0] = 1; 494 memcpy(bvdData->boot_system_identifier, ET_ID, 23); 495 memcpy(bvdData->identifier, ISO_VOLUME_DESCRIPTOR_STANDARD_ID, 5); 496 diskStructure.boot_descriptor = 497 (boot_volume_descriptor*) bvd->volumeDescriptorData; 498 return 1; 499} 500 501static int 502cd9660_write_mbr_partition_entry(FILE *fd, int idx, off_t sector_start, 503 off_t nsectors, int type) 504{ 505 uint8_t val; 506 uint32_t lba; 507 508 if (fseeko(fd, (off_t)(idx) * 16 + 0x1be, SEEK_SET) == -1) 509 err(1, "fseeko"); 510 511 val = 0x80; /* Bootable */ 512 fwrite(&val, sizeof(val), 1, fd); 513 514 val = 0xff; /* CHS begin */ 515 fwrite(&val, sizeof(val), 1, fd); 516 fwrite(&val, sizeof(val), 1, fd); 517 fwrite(&val, sizeof(val), 1, fd); 518 519 val = type; /* Part type */ 520 fwrite(&val, sizeof(val), 1, fd); 521 522 val = 0xff; /* CHS end */ 523 fwrite(&val, sizeof(val), 1, fd); 524 fwrite(&val, sizeof(val), 1, fd); 525 fwrite(&val, sizeof(val), 1, fd); 526 527 /* LBA extent */ 528 lba = htole32(sector_start); 529 fwrite(&lba, sizeof(lba), 1, fd); 530 lba = htole32(nsectors); 531 fwrite(&lba, sizeof(lba), 1, fd); 532 533 return 0; 534} 535 536static int 537cd9660_write_apm_partition_entry(FILE *fd, int idx, int total_partitions, 538 off_t sector_start, off_t nsectors, off_t sector_size, 539 const char *part_name, const char *part_type) 540{ 541 uint32_t apm32, part_status; 542 uint16_t apm16; 543 544 /* See Apple Tech Note 1189 for the details about the pmPartStatus 545 * flags. 546 * Below the flags which are default: 547 * - IsValid 0x01 548 * - IsAllocated 0x02 549 * - IsReadable 0x10 550 * - IsWritable 0x20 551 */ 552 part_status = 0x01 | 0x02 | 0x10 | 0x20; 553 554 if (fseeko(fd, (off_t)(idx + 1) * sector_size, SEEK_SET) == -1) 555 err(1, "fseeko"); 556 557 /* Signature */ 558 apm16 = htobe16(0x504d); 559 fwrite(&apm16, sizeof(apm16), 1, fd); 560 apm16 = 0; 561 fwrite(&apm16, sizeof(apm16), 1, fd); 562 563 /* Total number of partitions */ 564 apm32 = htobe32(total_partitions); 565 fwrite(&apm32, sizeof(apm32), 1, fd); 566 /* Bounds */ 567 apm32 = htobe32(sector_start); 568 fwrite(&apm32, sizeof(apm32), 1, fd); 569 apm32 = htobe32(nsectors); 570 fwrite(&apm32, sizeof(apm32), 1, fd); 571 572 fwrite(part_name, strlen(part_name) + 1, 1, fd); 573 fseek(fd, 32 - strlen(part_name) - 1, SEEK_CUR); 574 fwrite(part_type, strlen(part_type) + 1, 1, fd); 575 fseek(fd, 32 - strlen(part_type) - 1, SEEK_CUR); 576 577 apm32 = 0; 578 /* pmLgDataStart */ 579 fwrite(&apm32, sizeof(apm32), 1, fd); 580 /* pmDataCnt */ 581 apm32 = htobe32(nsectors); 582 fwrite(&apm32, sizeof(apm32), 1, fd); 583 /* pmPartStatus */ 584 apm32 = htobe32(part_status); 585 fwrite(&apm32, sizeof(apm32), 1, fd); 586 587 return 0; 588} 589 590int 591cd9660_write_boot(FILE *fd) 592{ 593 struct boot_catalog_entry *e; 594 struct cd9660_boot_image *t; 595 int apm_partitions = 0; 596 int mbr_partitions = 0; 597 598 /* write boot catalog */ 599 if (fseeko(fd, (off_t)diskStructure.boot_catalog_sector * 600 diskStructure.sectorSize, SEEK_SET) == -1) 601 err(1, "fseeko"); 602 603 if (diskStructure.verbose_level > 0) { 604 printf("Writing boot catalog to sector %" PRId64 "\n", 605 diskStructure.boot_catalog_sector); 606 } 607 LIST_FOREACH(e, &diskStructure.boot_entries, ll_struct) { 608 if (diskStructure.verbose_level > 0) { 609 printf("Writing catalog entry of type %d\n", 610 e->entry_type); 611 } 612 /* 613 * It doesn't matter which one gets written 614 * since they are the same size 615 */ 616 fwrite(&(e->entry_data.VE), 1, 32, fd); 617 } 618 if (diskStructure.verbose_level > 0) 619 printf("Finished writing boot catalog\n"); 620 621 /* copy boot images */ 622 TAILQ_FOREACH(t, &diskStructure.boot_images, image_list) { 623 if (diskStructure.verbose_level > 0) { 624 printf("Writing boot image from %s to sectors %d\n", 625 t->filename, t->sector); 626 } 627 cd9660_copy_file(fd, t->sector, t->filename); 628 629 if (t->system == ET_SYS_MAC) 630 apm_partitions++; 631 if (t->system == ET_SYS_PPC) 632 mbr_partitions++; 633 } 634 635 /* some systems need partition tables as well */ 636 if (mbr_partitions > 0 || diskStructure.chrp_boot) { 637 uint16_t sig; 638 639 fseek(fd, 0x1fe, SEEK_SET); 640 sig = htole16(0xaa55); 641 fwrite(&sig, sizeof(sig), 1, fd); 642 643 mbr_partitions = 0; 644 645 /* Write ISO9660 descriptor, enclosing the whole disk */ 646 if (diskStructure.chrp_boot) 647 cd9660_write_mbr_partition_entry(fd, mbr_partitions++, 648 0, diskStructure.totalSectors * 649 (diskStructure.sectorSize / 512), 0x96); 650 651 /* Write all partition entries */ 652 TAILQ_FOREACH(t, &diskStructure.boot_images, image_list) { 653 if (t->system != ET_SYS_PPC) 654 continue; 655 cd9660_write_mbr_partition_entry(fd, mbr_partitions++, 656 t->sector * (diskStructure.sectorSize / 512), 657 t->num_sectors * (diskStructure.sectorSize / 512), 658 0x41 /* PReP Boot */); 659 } 660 } 661 662 if (apm_partitions > 0) { 663 /* Write DDR and global APM info */ 664 uint32_t apm32; 665 uint16_t apm16; 666 int total_parts; 667 668 fseek(fd, 0, SEEK_SET); 669 apm16 = htobe16(0x4552); 670 fwrite(&apm16, sizeof(apm16), 1, fd); 671 /* Device block size */ 672 apm16 = htobe16(512); 673 fwrite(&apm16, sizeof(apm16), 1, fd); 674 /* Device block count */ 675 apm32 = htobe32(diskStructure.totalSectors * 676 (diskStructure.sectorSize / 512)); 677 fwrite(&apm32, sizeof(apm32), 1, fd); 678 /* Device type/id */ 679 apm16 = htobe16(1); 680 fwrite(&apm16, sizeof(apm16), 1, fd); 681 fwrite(&apm16, sizeof(apm16), 1, fd); 682 683 /* Count total needed entries */ 684 total_parts = 2 + apm_partitions; /* Self + ISO9660 */ 685 686 /* Write self-descriptor */ 687 cd9660_write_apm_partition_entry(fd, 0, total_parts, 1, 688 total_parts, 512, "Apple", "Apple_partition_map"); 689 690 /* Write all partition entries */ 691 apm_partitions = 0; 692 TAILQ_FOREACH(t, &diskStructure.boot_images, image_list) { 693 if (t->system != ET_SYS_MAC) 694 continue; 695 696 cd9660_write_apm_partition_entry(fd, 697 1 + apm_partitions++, total_parts, 698 t->sector * (diskStructure.sectorSize / 512), 699 t->num_sectors * (diskStructure.sectorSize / 512), 700 512, "CD Boot", "Apple_Bootstrap"); 701 } 702 /* Write ISO9660 descriptor, enclosing the whole disk */ 703 cd9660_write_apm_partition_entry(fd, 2 + apm_partitions, 704 total_parts, 0, diskStructure.totalSectors * 705 (diskStructure.sectorSize / 512), 512, "ISO9660", 706 "CD_ROM_Mode_1"); 707 } 708 709 return 0; 710} 711 712