eltorito.c File Reference

#include <schily/mconfig.h>
#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>

Include dependency graph for eltorito.c:

Go to the source code of this file.

Macros
#define	MIN(a, b)   (((a) < (b))? (a): (b))

Functions
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 ex_boot_enoent	__PR ((char *msg, char *pname))
LOCAL int tvd_write	__PR ((FILE *outfile))
EXPORT void	init_boot_catalog (char *path) const
EXPORT void	insert_boot_cat ()
LOCAL void	get_torito_desc (struct eltorito_boot_descriptor *boot_desc)
LOCAL void	fill_boot_shdr (struct eltorito_sectionheader_entry *boot_shdr_entry, int arch)
LOCAL void	fill_boot_desc (struct eltorito_defaultboot_entry *boot_desc_entry, struct eltorito_boot_entry_info *boot_entry)
EXPORT void	get_boot_entry ()
EXPORT int	new_boot_entry ()
EXPORT void	ex_boot_enoent (char *msg, char *pname)
LOCAL int	tvd_write (FILE *outfile)

Variables
static UConst char	sccsid []
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
struct output_fragment	torito_desc = {NULL, oneblock_size, NULL, tvd_write, "Eltorito Volume Descriptor"}

Macro Definition Documentation

MIN

#define MIN	(		a,
			b
	)		(((a) < (b))? (a): (b))

Definition at line 42 of file eltorito.c.

Function Documentation

__PR() [1/7]

EXPORT void ex_boot_enoent __PR

(

(char *msg, char *pname)

)

__PR() [2/7]

EXPORT void init_boot_catalog __PR

(

(const char *path)

)

__PR() [3/7]

LOCAL int tvd_write __PR

(

(FILE *outfile)

)

__PR() [4/7]

LOCAL void get_torito_desc __PR

(

(struct eltorito_boot_descriptor *boot_desc)

)

__PR() [5/7]

LOCAL void fill_boot_desc __PR

(

(struct eltorito_defaultboot_entry *boot_desc_entry, struct eltorito_boot_entry_info *boot_entry)

)

__PR() [6/7]

LOCAL void fill_boot_shdr __PR

(

(struct eltorito_sectionheader_entry *boot_shdr_entry, int arch)

)

__PR() [7/7]

EXPORT void insert_boot_cat __PR

(

(void)

)

ex_boot_enoent()

EXPORT void ex_boot_enoent	(	char *	msg,
		char *	pname
	)

Definition at line 660 of file eltorito.c.

{
    comerrno(EX_BAD, _("Uh oh, I cant find the boot %s '%s' inside the target tree.\n"), msg, pname);
    /* NOTREACHED */
}

Referenced by fill_boot_desc(), get_torito_desc(), and insert_boot_cat().

fill_boot_desc()

LOCAL void fill_boot_desc	(	struct eltorito_defaultboot_entry *	boot_desc_entry,
		struct eltorito_boot_entry_info *	boot_entry
	)

Definition at line 400 of file eltorito.c.

{
    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(... */

Referenced by get_torito_desc().

fill_boot_shdr()

LOCAL void fill_boot_shdr	(	struct eltorito_sectionheader_entry *	boot_shdr_entry,
		int	arch
	)

Definition at line 390 of file eltorito.c.

{
    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;
}

Referenced by get_torito_desc().

get_boot_entry()

EXPORT void get_boot_entry

(

)

Definition at line 629 of file eltorito.c.

{
    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;
    }
}

Referenced by get_boot_addr(), get_boot_image(), get_boot_platid(), get_boot_size(), get_boot_table(), get_hd_boot(), get_ne_boot(), and get_no_boot().

get_torito_desc()

LOCAL void get_torito_desc

(

struct eltorito_boot_descriptor *

boot_desc

)

Definition at line 253 of file eltorito.c.

{
    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(... */

Referenced by tvd_write().

init_boot_catalog()

EXPORT void init_boot_catalog

(

char *

path

)

const

Definition at line 67 of file eltorito.c.

{
#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(... */

Referenced by main().

insert_boot_cat()

EXPORT void insert_boot_cat

(

)

Definition at line 124 of file eltorito.c.

{
    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;
    }
}

Referenced by main().

new_boot_entry()

EXPORT int new_boot_entry

(

)

Definition at line 650 of file eltorito.c.

{
    current_boot_entry = NULL;
    return (1);
}

Referenced by get_boot_platid().

tvd_write()

LOCAL int tvd_write

(

FILE *

outfile

)

Definition at line 672 of file eltorito.c.

{
    /* 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);
}

Variable Documentation

bcat_de_flags

LOCAL unsigned int bcat_de_flags

Definition at line 60 of file eltorito.c.

Referenced by init_boot_catalog(), and insert_boot_cat().

bootcat_path

LOCAL char* bootcat_path

Definition at line 61 of file eltorito.c.

Referenced by init_boot_catalog(), and insert_boot_cat().

disk_mbr

LOCAL struct disk_master_boot_record disk_mbr

Definition at line 59 of file eltorito.c.

Referenced by fill_boot_desc().

gboot_desc

LOCAL struct eltorito_boot_descriptor gboot_desc

Definition at line 58 of file eltorito.c.

Referenced by tvd_write().

sccsid

UConst char sccsid[]

static

Initial value:

=
    "@(#)eltorito.c 1.52 15/11/23 joerg"

Definition at line 4 of file eltorito.c.

torito_desc

struct output_fragment torito_desc = {NULL, oneblock_size, NULL, tvd_write, "Eltorito Volume Descriptor"}

Definition at line 686 of file eltorito.c.

Referenced by main().

valid_desc

LOCAL struct eltorito_validation_entry valid_desc

Definition at line 57 of file eltorito.c.

Referenced by get_torito_desc().