usr.sbin/makefs/cd9660/cd9660_eltorito.c

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