--- /dev/null
+/* @(#)eltorito.c 1.52 15/11/23 joerg */
+#include <schily/mconfig.h>
+#ifndef lint
+static UConst char sccsid[] =
+ "@(#)eltorito.c 1.52 15/11/23 joerg";
+
+#endif
+/*
+ * Program eltorito.c - Handle El Torito specific extensions to iso9660.
+ *
+ *
+ * Written by Michael Fulbright <msf@redhat.com> (1996).
+ *
+ * Copyright 1996 RedHat Software, Incorporated
+ * Copyright (c) 1999-2015 J. Schilling
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "mkisofs.h"
+#include <schily/fcntl.h>
+#include <schily/utypes.h>
+#include <schily/intcvt.h>
+#include "match.h"
+#include "diskmbr.h"
+#include "bootinfo.h"
+#include <schily/schily.h>
+
+#undef MIN
+#define MIN(a, b) (((a) < (b))? (a): (b))
+
+EXPORT void init_boot_catalog __PR((const char *path));
+EXPORT void insert_boot_cat __PR((void));
+LOCAL void get_torito_desc __PR((struct eltorito_boot_descriptor *boot_desc));
+LOCAL void fill_boot_shdr __PR((struct eltorito_sectionheader_entry *boot_shdr_entry,
+ int arch));
+LOCAL void fill_boot_desc __PR((struct eltorito_defaultboot_entry *boot_desc_entry,
+ struct eltorito_boot_entry_info *boot_entry));
+EXPORT void get_boot_entry __PR((void));
+EXPORT int new_boot_entry __PR((void));
+EXPORT void ex_boot_enoent __PR((char *msg, char *pname));
+LOCAL int tvd_write __PR((FILE *outfile));
+
+
+LOCAL struct eltorito_validation_entry valid_desc;
+LOCAL struct eltorito_boot_descriptor gboot_desc;
+LOCAL struct disk_master_boot_record disk_mbr;
+LOCAL unsigned int bcat_de_flags;
+LOCAL char *bootcat_path; /* name of bootcatalog */
+
+/*
+ * Make sure any existing boot catalog is excluded
+ */
+EXPORT void
+init_boot_catalog(path)
+ const char *path;
+{
+#ifdef SORTING
+ struct eltorito_boot_entry_info *cbe;
+
+ for (cbe = first_boot_entry;
+ cbe != NULL;
+ cbe = cbe->next) {
+ char *p;
+
+ if (cbe->boot_image == NULL)
+ comerrno(EX_BAD, _("Missing boot image name, use -eltorito-boot option.\n"));
+ p = (char *)e_malloc(strlen(cbe->boot_image) + strlen(path) + 2);
+ strcpy(p, path);
+ if (p[strlen(p) - 1] != '/') {
+ strcat(p, "/");
+ }
+ strcat(p, cbe->boot_image);
+ add_sort_match(p, sort_matches(p, 1));
+ free(p);
+ }
+#endif
+ bootcat_path = (char *)e_malloc(strlen(boot_catalog) + strlen(path) + 2);
+ strcpy(bootcat_path, path);
+ if (bootcat_path[strlen(bootcat_path) - 1] != '/') {
+ strcat(bootcat_path, "/");
+ }
+ strcat(bootcat_path, boot_catalog);
+
+ /*
+ * we are going to create a virtual catalog file
+ * - so make sure any existing is excluded
+ */
+ add_match(bootcat_path);
+
+ /* flag the file as a memory file */
+ bcat_de_flags = MEMORY_FILE;
+
+ /* find out if we want to "hide" this file */
+ if (i_matches(boot_catalog) || i_matches(bootcat_path))
+ bcat_de_flags |= INHIBIT_ISO9660_ENTRY;
+
+ if (j_matches(boot_catalog) || j_matches(bootcat_path))
+ bcat_de_flags |= INHIBIT_JOLIET_ENTRY;
+
+ if (u_matches(boot_catalog) || u_matches(bootcat_path))
+ bcat_de_flags |= INHIBIT_UDF_ENTRY;
+
+} /* init_boot_catalog(... */
+
+/*
+ * Create a boot catalog file in memory - mkisofs already uses this type of
+ * file for the TRANS.TBL files. Therefore the boot catalog is set up in
+ * similar way
+ */
+EXPORT void
+insert_boot_cat()
+{
+ struct directory_entry *de;
+ struct directory_entry *s_entry;
+ char *p1;
+ char *p2;
+ char *p3;
+ struct directory *this_dir;
+ struct directory *dir;
+ char *buffer;
+
+ init_fstatbuf();
+
+ buffer = (char *)e_malloc(SECTOR_SIZE);
+ memset(buffer, 0, SECTOR_SIZE);
+
+ /*
+ * try to find the directory that will contain the boot.cat file
+ * - not very neat, but I can't think of a better way
+ */
+ p1 = e_strdup(boot_catalog);
+
+ /* get dirname (p1) and basename (p2) of boot.cat */
+ if ((p2 = strrchr(p1, '/')) != NULL) {
+ *p2 = '\0';
+ p2++;
+
+ /* find the dirname directory entry */
+ de = search_tree_file(root, p1);
+ if (!de) {
+ ex_boot_enoent(_("catalog directory"), p1);
+ /* NOTREACHED */
+ }
+ this_dir = 0;
+
+ /* get the basename (p3) of the directory */
+ if ((p3 = strrchr(p1, '/')) != NULL)
+ p3++;
+ else
+ p3 = p1;
+
+ /* find the correct sub-directory entry */
+ for (dir = de->filedir->subdir; dir; dir = dir->next)
+ if (strcmp(dir->de_name, p3) == 0)
+ this_dir = dir;
+
+ if (this_dir == 0) {
+ ex_boot_enoent(_("catalog directory"), p3);
+ /* NOTREACHED */
+ }
+ } else {
+ /* boot.cat is in the root directory */
+ this_dir = root;
+ p2 = p1;
+ }
+
+ /*
+ * make a directory entry in memory (using the same set up as for table
+ * entries
+ */
+ s_entry = (struct directory_entry *)
+ e_malloc(sizeof (struct directory_entry));
+ memset(s_entry, 0, sizeof (struct directory_entry));
+ s_entry->next = this_dir->contents;
+ this_dir->contents = s_entry;
+
+#ifdef SORTING
+ /* inherit any sort weight from parent directory */
+ s_entry->sort = this_dir->sort;
+ s_entry->sort += 2;
+
+ /* see if this entry should have a new weighting */
+ if (do_sort) {
+ s_entry->sort = sort_matches(bootcat_path, s_entry->sort);
+ }
+#endif /* SORTING */
+
+ s_entry->isorec.flags[0] = ISO_FILE;
+ s_entry->priority = 32768;
+ iso9660_date(s_entry->isorec.date, fstatbuf.st_mtime);
+ s_entry->inode = TABLE_INODE;
+ s_entry->dev = (dev_t)UNCACHED_DEVICE;
+ set_723(s_entry->isorec.volume_sequence_number,
+ volume_sequence_number);
+ set_733((char *)s_entry->isorec.size, SECTOR_SIZE);
+ s_entry->size = SECTOR_SIZE;
+ s_entry->filedir = this_dir;
+ s_entry->name = e_strdup(p2);
+ iso9660_file_length(p2, s_entry, 0);
+
+ /* flag file as necessary */
+ s_entry->de_flags = bcat_de_flags;
+
+ if ((use_XA || use_RockRidge) &&
+ !(bcat_de_flags & INHIBIT_ISO9660_ENTRY)) {
+ fstatbuf.st_mode = 0444 | S_IFREG;
+ fstatbuf.st_nlink = 1;
+ generate_xa_rr_attributes("",
+ p2, s_entry,
+ &fstatbuf, &fstatbuf, 0);
+ }
+ /*
+ * memory files are stored at s_entry->table
+ * - but this is also used for each s_entry to generate
+ * TRANS.TBL entries. So if we are generating tables,
+ * store the TRANS.TBL data here for the moment
+ */
+ if (generate_tables && !(bcat_de_flags & INHIBIT_ISO9660_ENTRY)) {
+ sprintf(buffer, "F\t%s\n", s_entry->name);
+
+ /* copy the TRANS.TBL entry info and clear the buffer */
+ s_entry->table = e_strdup(buffer);
+ memset(buffer, 0, SECTOR_SIZE);
+
+ /*
+ * store the (empty) file data in the
+ * unused s_entry->whole_name element for the time being
+ * - this will be transferred to s_entry->table after any
+ * TRANS.TBL processing later
+ */
+ s_entry->whole_name = buffer;
+ } else {
+ /* store the (empty) file data in the s_entry->table element */
+ s_entry->table = buffer;
+ s_entry->whole_name = NULL;
+ }
+}
+
+LOCAL void
+get_torito_desc(boot_desc)
+ struct eltorito_boot_descriptor *boot_desc;
+{
+ int checksum;
+ unsigned char *checksum_ptr;
+ struct directory_entry *de2; /* Boot catalog */
+ int i;
+ int offset;
+ int arch = 0;
+ int nentries = 0;
+ struct eltorito_defaultboot_entry boot_desc_record;
+ struct eltorito_sectionheader_entry boot_shdr_record;
+#ifdef __needed__
+ struct eltorito_section_entry boot_section_record;
+#endif
+ struct eltorito_sectionheader_entry *last_section_header = 0;
+
+ memset(boot_desc, 0, sizeof (*boot_desc));
+ boot_desc->type[0] = 0;
+ strncpy(boot_desc->id, ISO_STANDARD_ID, sizeof (boot_desc->id));
+ boot_desc->version[0] = 1;
+
+ memcpy(boot_desc->system_id, EL_TORITO_ID, sizeof (EL_TORITO_ID));
+
+ /*
+ * search from root of iso fs to find boot catalog
+ * - we already know where the boot catalog is
+ * - we created it above - but lets search for it anyway
+ * - good sanity check!
+ */
+ de2 = search_tree_file(root, boot_catalog);
+ if (!de2 || !(de2->de_flags & MEMORY_FILE)) {
+ ex_boot_enoent(_("catalog"), boot_catalog);
+ /* NOTREACHED */
+ }
+ set_731(boot_desc->bootcat_ptr,
+ (unsigned int) get_733(de2->isorec.extent));
+
+ /*
+ * If the platform id for the first (default) boot entry has not been
+ * explicitly set, we default to EL_TORITO_ARCH_x86
+ */
+ if ((first_boot_entry->type & ELTORITO_BOOT_ID) == 0) {
+ first_boot_entry->boot_platform = EL_TORITO_ARCH_x86;
+ }
+ arch = first_boot_entry->boot_platform;
+
+ /*
+ * we have the boot image, so write boot catalog information
+ * Next we write out the primary descriptor for the disc
+ */
+ memset(&valid_desc, 0, sizeof (valid_desc));
+ valid_desc.headerid[0] = 1;
+ valid_desc.arch[0] = arch; /* Platform id for the default boot */
+
+ /*
+ * we'll shove start of publisher id into id field,
+ * may get truncated but who really reads this stuff!
+ */
+ if (publisher)
+ memcpy_max(valid_desc.id, publisher,
+ MIN(23, strlen(publisher)));
+
+ valid_desc.key1[0] = (char)0x55;
+ valid_desc.key2[0] = (char)0xAA;
+
+ /* compute the checksum */
+ checksum = 0;
+ checksum_ptr = (unsigned char *) &valid_desc;
+ /* Set checksum to 0 before computing checksum */
+ set_721(valid_desc.cksum, 0);
+ for (i = 0; i < (int)sizeof (valid_desc); i += 2) {
+ checksum += (unsigned int) checksum_ptr[i];
+ checksum += ((unsigned int) checksum_ptr[i + 1]) * 256;
+ }
+
+ /* now find out the real checksum */
+ checksum = -checksum;
+ set_721(valid_desc.cksum, (unsigned int) checksum);
+
+ /* now write it to the virtual boot catalog */
+ memcpy(de2->table, &valid_desc, 32);
+
+ for (current_boot_entry = first_boot_entry, offset = sizeof (valid_desc);
+ current_boot_entry != NULL;
+ current_boot_entry = current_boot_entry->next,
+ offset += sizeof (boot_desc_record)) {
+ int newarch = arch;
+
+ if (current_boot_entry->type & ELTORITO_BOOT_ID)
+ newarch = current_boot_entry->boot_platform;
+ else
+ current_boot_entry->boot_platform = arch;
+
+ /*
+ * El Torito has no such limitation but we currently have...
+ */
+ if (offset >= (SECTOR_SIZE - sizeof (boot_desc_record))) {
+ comerrno(EX_BAD,
+ _("Too many El Torito boot entries\n"));
+ }
+ if (current_boot_entry == first_boot_entry) {
+ ;
+ /* EMPTY */
+ } else if ((current_boot_entry == first_boot_entry->next) ||
+ (arch != newarch) ||
+ (current_boot_entry->type & ELTORITO_SECTION_HEADER)) {
+ if (last_section_header)
+ set_721(&last_section_header->entry_count, nentries);
+ nentries = 1;
+ last_section_header = (struct eltorito_sectionheader_entry *)
+ (de2->table + offset);
+ fill_boot_shdr(&boot_shdr_record, newarch);
+ memcpy(de2->table + offset, &boot_shdr_record,
+ sizeof (boot_shdr_record));
+ offset += sizeof (boot_desc_record);
+ } else {
+ nentries++; /* Add entry to this section header */
+ }
+ /*
+ * This works because a section entry has the same essential
+ * layout as a default entry (and we do not populate the
+ * selection criteria fields).
+ */
+ fill_boot_desc(&boot_desc_record, current_boot_entry);
+ memcpy(de2->table + offset, &boot_desc_record,
+ sizeof (boot_desc_record));
+ }
+
+ if (last_section_header) {
+ set_721(&last_section_header->entry_count, nentries);
+ last_section_header->header_id[0] = EL_TORITO_SHDR_ID_LAST_SHDR;
+ }
+
+} /* get_torito_desc(... */
+
+LOCAL void
+fill_boot_shdr(boot_shdr_entry, arch)
+ struct eltorito_sectionheader_entry *boot_shdr_entry;
+ int arch;
+{
+ memset(boot_shdr_entry, 0, sizeof (struct eltorito_sectionheader_entry));
+ boot_shdr_entry->header_id[0] = EL_TORITO_SHDR_ID_SHDR;
+ boot_shdr_entry->platform_id[0] = arch;
+}
+
+LOCAL void
+fill_boot_desc(boot_desc_entry, boot_entry)
+ struct eltorito_defaultboot_entry *boot_desc_entry;
+ struct eltorito_boot_entry_info *boot_entry;
+{
+ struct directory_entry *de; /* Boot file */
+ int bootmbr;
+ int i;
+ int nsectors;
+ int geosec;
+
+ if (!boot_desc_entry || !boot_entry)
+ return;
+
+ /* now adjust boot catalog lets find boot image first */
+ de = search_tree_file(root, boot_entry->boot_image);
+ if (!de) {
+ ex_boot_enoent(_("image"), boot_entry->boot_image);
+ /* NOTREACHED */
+ }
+ /* now make the initial/default entry for boot catalog */
+ memset(boot_desc_entry, 0, sizeof (*boot_desc_entry));
+ boot_desc_entry->boot_id[0] = (char)boot_entry->not_bootable ?
+ EL_TORITO_NOT_BOOTABLE : EL_TORITO_BOOTABLE;
+
+ /* use default BIOS loadpnt */
+ set_721(boot_desc_entry->loadseg, boot_entry->load_addr);
+
+ /*
+ * figure out size of boot image in 512-byte sectors.
+ * However, round up to the nearest integral CD (2048-byte) sector.
+ * This is only used for no-emulation booting.
+ */
+ nsectors = boot_entry->load_size ? boot_entry->load_size :
+ ISO_BLOCKS(de->size) * (SECTOR_SIZE/512);
+
+ if (verbose > 0) {
+ fprintf(stderr,
+ _("Size of boot image is %d sectors -> "), nsectors);
+ }
+
+ if (boot_entry->hard_disk_boot) {
+ /* sanity test hard disk boot image */
+ boot_desc_entry->boot_media[0] = EL_TORITO_MEDIA_HD;
+ if (verbose > 0)
+ fprintf(stderr, _("Emulating a hard disk\n"));
+
+ /* read MBR */
+ bootmbr = open(de->whole_name, O_RDONLY | O_BINARY);
+ if (bootmbr == -1) {
+ comerr(_("Error opening boot image '%s' for read.\n"),
+ de->whole_name);
+ }
+ if (read(bootmbr, &disk_mbr, sizeof (disk_mbr)) !=
+ sizeof (disk_mbr)) {
+ comerr(_("Error reading MBR from boot image '%s'.\n"),
+ de->whole_name);
+ }
+ close(bootmbr);
+ if (la_to_u_2_byte(disk_mbr.magic) != MBR_MAGIC) {
+ errmsgno(EX_BAD,
+ _("Warning: boot image '%s' MBR is not a boot sector.\n"),
+ de->whole_name);
+ }
+ /* find partition type */
+ boot_desc_entry->sys_type[0] = PARTITION_UNUSED;
+ for (i = 0; i < PARTITION_COUNT; ++i) {
+ int s_cyl_sec;
+ int e_cyl_sec;
+
+ s_cyl_sec =
+ la_to_u_2_byte(disk_mbr.partition[i].s_cyl_sec);
+ e_cyl_sec =
+ la_to_u_2_byte(disk_mbr.partition[i].e_cyl_sec);
+
+ if (disk_mbr.partition[i].type != PARTITION_UNUSED) {
+ if (boot_desc_entry->sys_type[0] !=
+ PARTITION_UNUSED) {
+ comerrno(EX_BAD,
+ _("Boot image '%s' has multiple partitions.\n"),
+ de->whole_name);
+ }
+ boot_desc_entry->sys_type[0] =
+ disk_mbr.partition[i].type;
+
+ /* a few simple sanity warnings */
+ if (!boot_entry->not_bootable &&
+ disk_mbr.partition[i].status !=
+ PARTITION_ACTIVE) {
+ fprintf(stderr,
+ _("Warning: partition not marked active.\n"));
+ }
+ if (MBR_CYLINDER(s_cyl_sec) != 0 ||
+ disk_mbr.partition[i].s_head != 1 ||
+ MBR_SECTOR(s_cyl_sec != 1)) {
+ fprintf(stderr,
+ _("Warning: partition does not start at 0/1/1.\n"));
+ }
+ geosec = (MBR_CYLINDER(e_cyl_sec) + 1) *
+ (disk_mbr.partition[i].e_head + 1) *
+ MBR_SECTOR(e_cyl_sec);
+ if (geosec != nsectors) {
+ fprintf(stderr,
+ _("Warning: image size does not match geometry (%d)\n"),
+ geosec);
+ }
+#ifdef DEBUG_TORITO
+ fprintf(stderr, "Partition start %u/%u/%u\n",
+ MBR_CYLINDER(s_cyl_sec),
+ disk_mbr.partition[i].s_head,
+ MBR_SECTOR(s_cyl_sec));
+ fprintf(stderr, "Partition end %u/%u/%u\n",
+ MBR_CYLINDER(e_cyl_sec),
+ disk_mbr.partition[i].e_head,
+ MBR_SECTOR(e_cyl_sec));
+#endif
+ }
+ }
+ if (boot_desc_entry->sys_type[0] == PARTITION_UNUSED) {
+ comerrno(EX_BAD,
+ _("Boot image '%s' has no partitions.\n"),
+ de->whole_name);
+ }
+#ifdef DEBUG_TORITO
+ fprintf(stderr, "Partition type %u\n",
+ boot_desc_entry->sys_type[0]);
+#endif
+ /* load single boot sector, in this case the MBR */
+ nsectors = 1;
+
+ } else if (boot_entry->no_emul_boot) {
+ /*
+ * no emulation is a simple image boot of all the sectors
+ * in the boot image
+ */
+ boot_desc_entry->boot_media[0] = EL_TORITO_MEDIA_NOEMUL;
+ if (verbose > 0)
+ fprintf(stderr, _("No emulation\n"));
+
+ } else {
+ /* choose size of emulated floppy based on boot image size */
+ if (nsectors == 2880) {
+ boot_desc_entry->boot_media[0] = EL_TORITO_MEDIA_144FLOP;
+ if (verbose > 0)
+ fprintf(stderr, _("Emulating a 1440 kB floppy\n"));
+
+ } else if (nsectors == 5760) {
+ boot_desc_entry->boot_media[0] = EL_TORITO_MEDIA_288FLOP;
+ if (verbose > 0)
+ fprintf(stderr, _("Emulating a 2880 kB floppy\n"));
+
+ } else if (nsectors == 2400) {
+ boot_desc_entry->boot_media[0] = EL_TORITO_MEDIA_12FLOP;
+ if (verbose > 0)
+ fprintf(stderr, _("Emulating a 1200 kB floppy\n"));
+
+ } else {
+ comerrno(EX_BAD,
+ _("Error - boot image '%s' has not an allowable size.\n"),
+ de->whole_name);
+ }
+
+ /* load single boot sector for floppies */
+ nsectors = 1;
+ }
+
+ /* fill in boot image details */
+#ifdef DEBUG_TORITO
+ fprintf(stderr, "Boot %u sectors\n", nsectors);
+ fprintf(stderr, "Extent of boot images is %d\n",
+ get_733(de->isorec.extent));
+#endif
+ set_721(boot_desc_entry->nsect, (unsigned int) nsectors);
+ set_731(boot_desc_entry->bootoff,
+ (unsigned int) get_733(de->isorec.extent));
+
+
+ /* If the user has asked for it, patch the boot image */
+ if (boot_entry->boot_info_table) {
+ int bootimage;
+ unsigned int bi_checksum;
+ unsigned int total_len;
+ static char csum_buffer[SECTOR_SIZE];
+ int len;
+ struct mkisofs_boot_info bi_table;
+
+ bootimage = open(de->whole_name, O_RDWR | O_BINARY);
+ if (bootimage == -1) {
+ comerr(
+ _("Error opening boot image file '%s' for update.\n"),
+ de->whole_name);
+ }
+ /* Compute checksum of boot image, sans 64 bytes */
+ total_len = 0;
+ bi_checksum = 0;
+ while ((len = read(bootimage, csum_buffer, SECTOR_SIZE)) > 0) {
+ if (total_len & 3) {
+ comerrno(EX_BAD,
+ _("Odd alignment at non-end-of-file in boot image '%s'.\n"),
+ de->whole_name);
+ }
+ if (total_len < 64)
+ memset(csum_buffer, 0, 64 - total_len);
+ if (len < SECTOR_SIZE)
+ memset(csum_buffer + len, 0, SECTOR_SIZE-len);
+ for (i = 0; i < SECTOR_SIZE; i += 4)
+ bi_checksum += get_731(&csum_buffer[i]);
+ total_len += len;
+ }
+
+ if (total_len != de->size) {
+ comerrno(EX_BAD,
+ _("Boot image file '%s' changed underneath us!\n"),
+ de->whole_name);
+ }
+ /* End of file, set position to byte 8 */
+ lseek(bootimage, (off_t)8, SEEK_SET);
+ memset(&bi_table, 0, sizeof (bi_table));
+ /* Is it always safe to assume PVD is at session_start+16? */
+ set_731(bi_table.bi_pvd, session_start + 16);
+ set_731(bi_table.bi_file, de->starting_block);
+ set_731(bi_table.bi_length, de->size);
+ set_731(bi_table.bi_csum, bi_checksum);
+
+ write(bootimage, &bi_table, sizeof (bi_table));
+ close(bootimage);
+ }
+} /* fill_boot_desc(... */
+
+EXPORT void
+get_boot_entry()
+{
+ if (current_boot_entry)
+ return;
+
+ current_boot_entry = (struct eltorito_boot_entry_info *)
+ e_malloc(sizeof (struct eltorito_boot_entry_info));
+ memset(current_boot_entry, 0, sizeof (*current_boot_entry));
+
+ if (!first_boot_entry) {
+ first_boot_entry = current_boot_entry;
+ last_boot_entry = current_boot_entry;
+ current_boot_entry->boot_platform = EL_TORITO_ARCH_x86;
+ } else {
+ current_boot_entry->boot_platform = last_boot_entry->boot_platform;
+ last_boot_entry->next = current_boot_entry;
+ last_boot_entry = current_boot_entry;
+ }
+}
+
+EXPORT int
+new_boot_entry()
+{
+ current_boot_entry = NULL;
+ return (1);
+}
+
+/*
+ * Exit with a boot no entry message.
+ */
+EXPORT void
+ex_boot_enoent(msg, pname)
+ char *msg;
+ char *pname;
+{
+ comerrno(EX_BAD, _("Uh oh, I cant find the boot %s '%s' inside the target tree.\n"), msg, pname);
+ /* NOTREACHED */
+}
+
+/*
+ * Function to write the EVD for the disc.
+ */
+LOCAL int
+tvd_write(outfile)
+ FILE *outfile;
+{
+ /* check the boot image is not NULL */
+ if (!boot_image) {
+ comerrno(EX_BAD, _("No boot image specified.\n"));
+ }
+ /* Next we write out the boot volume descriptor for the disc */
+ get_torito_desc(&gboot_desc);
+ xfwrite(&gboot_desc, SECTOR_SIZE, 1, outfile, 0, FALSE);
+ last_extent_written++;
+ return (0);
+}
+
+struct output_fragment torito_desc = {NULL, oneblock_size, NULL, tvd_write, "Eltorito Volume Descriptor"};
projects / reactos.git / blobdiff