/* * Copyright (c) 2008 - 2015 Thomas Schmitt * with special credits to H. Peter Anvin for isohybrid * and to Matthew Garrett for isohybrid with GPT and APM * * This file is part of the libisofs project; you can redistribute it and/or * modify it under the terms of the GNU General Public License version 2 * or later as published by the Free Software Foundation. * See COPYING file for details. */ #ifdef HAVE_CONFIG_H #include "../config.h" #endif #include #ifdef HAVE_STDINT_H #include #else #ifdef HAVE_INTTYPES_H #include #endif #endif #include #include #include #include #include #include /* for gettimeofday() */ #include #include "filesrc.h" #include "ecma119.h" #include "eltorito.h" #include "system_area.h" #include "image.h" #include "messages.h" /* This code stems from syslinux-3.72/utils/isohybrid, a perl script under GPL which is Copyright 2002-2008 H. Peter Anvin. Line numbers in comments refer to the lines of that script. It has been analyzed and re-written in C language 2008 by Thomas Schmitt, and is now under the licenses to which H.Peter Anvin agreed: http://syslinux.zytor.com/archives/2008-November/011105.html Date: Mon, 10 Nov 2008 08:36:46 -0800 From: H. Peter Anvin I hereby give permission for this code, translated to the C language, to be released under either the LGPL or the MIT/ISC/2-clause BSD licenses or both, at your option. Sincerely, H. Peter Anvin In the context of GNU xorriso, this code is under GPLv3+ derived from LGPL. In the context of libisofs this code derives its matching free software license from above stem licenses, typically from LGPL. In case its generosity is needed, here is the 2-clause BSD license: make_isohybrid_mbr.c is copyright 2002-2008 H. Peter Anvin and 2008-2015 Thomas Schmitt 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED `AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE PROVIDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* A helper function. One could replace it by one or two macros. */ static int lsb_to_buf(char **wpt, uint32_t value, int bits, int flag) { int b; for (b = 0; b < bits; b += 8) *((unsigned char *) ((*wpt)++)) = (value >> b) & 0xff; return (1); } /* ====================================================================== */ /* Deprecated Function */ /* ====================================================================== */ /* * Create a MBR for an isohybrid enabled ISOLINUX boot image. * * It is assumed that the caller has verified the readiness of the boot image * by checking for 0xfb 0xc0 0x78 0x70 at bytes 0x40 to 0x43 of isolinux.bin. * * @param bin_lba The predicted LBA of isolinux.bin within the emerging ISO. * @param img_blocks The predicted number of 2048 byte blocks in the ISO. * It will get rounded up to full MBs and that many blocks * must really be written as ISO 9660 image. * @param mbr A buffer of at least 512 bytes to take the result which is * to be written as the very beginning of the ISO. * @param flag unused yet, submit 0 * @return <0 = fatal, 0 = failed , 1 = ok , 2 = ok with size warning */ int make_isohybrid_mbr(int bin_lba, int *img_blocks, char *mbr, int flag) { /* According to H. Peter Anvin this binary code stems from syslinux-3.72/mbr/isohdpfx.S */ static int mbr_code_size = 271; static unsigned char mbr_code[271] = { 0xfa, 0x31, 0xc0, 0x8e, 0xd8, 0x8e, 0xd0, 0xbc, 0x00, 0x7c, 0x89, 0xe6, 0x06, 0x57, 0x52, 0x8e, 0xc0, 0xfb, 0xfc, 0xbf, 0x00, 0x06, 0xb9, 0x00, 0x01, 0xf3, 0xa5, 0xea, 0x20, 0x06, 0x00, 0x00, 0x52, 0xb4, 0x41, 0xbb, 0xaa, 0x55, 0x31, 0xc9, 0x30, 0xf6, 0xf9, 0xcd, 0x13, 0x72, 0x14, 0x81, 0xfb, 0x55, 0xaa, 0x75, 0x0e, 0x83, 0xe1, 0x01, 0x74, 0x09, 0x66, 0xc7, 0x06, 0xb4, 0x06, 0xb4, 0x42, 0xeb, 0x15, 0x5a, 0x51, 0xb4, 0x08, 0xcd, 0x13, 0x83, 0xe1, 0x3f, 0x51, 0x0f, 0xb6, 0xc6, 0x40, 0x50, 0xf7, 0xe1, 0x52, 0x50, 0xbb, 0x00, 0x7c, 0xb9, 0x04, 0x00, 0x66, 0xa1, 0xb0, 0x07, 0xe8, 0x40, 0x00, 0x72, 0x74, 0x66, 0x40, 0x80, 0xc7, 0x02, 0xe2, 0xf4, 0x66, 0x81, 0x3e, 0x40, 0x7c, 0xfb, 0xc0, 0x78, 0x70, 0x75, 0x07, 0xfa, 0xbc, 0xf4, 0x7b, 0xe9, 0xc6, 0x75, 0xe8, 0x79, 0x00, 0x69, 0x73, 0x6f, 0x6c, 0x69, 0x6e, 0x75, 0x78, 0x2e, 0x62, 0x69, 0x6e, 0x20, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x72, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x75, 0x70, 0x74, 0x2e, 0x0d, 0x0a, 0x66, 0x60, 0x66, 0x31, 0xd2, 0x66, 0x52, 0x66, 0x50, 0x06, 0x53, 0x6a, 0x01, 0x6a, 0x10, 0x89, 0xe6, 0x66, 0xf7, 0x36, 0xf0, 0x7b, 0xc0, 0xe4, 0x06, 0x88, 0xe1, 0x88, 0xc5, 0x92, 0xf6, 0x36, 0xf6, 0x7b, 0x88, 0xc6, 0x08, 0xe1, 0x41, 0xb8, 0x01, 0x02, 0x8a, 0x16, 0xfa, 0x7b, 0xcd, 0x13, 0x8d, 0x64, 0x10, 0x66, 0x61, 0xc3, 0xe8, 0x1e, 0x00, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x2e, 0x0d, 0x0a, 0x5e, 0xac, 0xb4, 0x0e, 0x8a, 0x3e, 0x62, 0x04, 0xb3, 0x07, 0xcd, 0x10, 0x3c, 0x0a, 0x75, 0xf1, 0xcd, 0x18, 0xf4, 0xeb, 0xfd }; static int h = 64, s = 32; int i, id; char *wpt; off_t imgsize, cylsize, frac, padding, c, cc; /* For generating a weak random number */ struct timeval tv; if (bin_lba < 0 || bin_lba >= (1 << 29)) return (0); /* 1 TB limit of signed 32 bit addressing of 512 byte blocks */ /* 84: Gets size of image in bytes. 89: */ imgsize = ((off_t) *img_blocks) * (off_t) 2048; /* 90: Computes $padding, size of padded image and number $c of pseudo-cylinders ($h and $s are constants set in line 24). 102: $cc is $c curbed to 1024. */ cylsize = h * s * 512; frac = imgsize % cylsize; padding = (frac > 0 ? cylsize - frac : 0); imgsize += padding; *img_blocks = imgsize / (off_t) 2048; c = imgsize / cylsize; if (c > 1024) { cc = 1024; } else cc = c; /* 107: Brings the hex-encoded bytes from the file __END__ into 113: the MBR buffer. (This function holds them in mbr_code[].) */ for (i = 0; i < mbr_code_size; i++) mbr[i] = mbr_code[i]; /* 118: Pads up to 432 */ for (i = mbr_code_size; i < 432; i++) mbr[i] = 0; /* From here on use write cursor wpt */ wpt = mbr + 432; /* 120: Converts LBA of isolinux.bin to blocksize 512 and writes to buffer. Appends 4 zero bytes. */ lsb_to_buf(&wpt, bin_lba * 4, 32, 0); lsb_to_buf(&wpt, 0, 32, 0); /* 121: I do not understand where $id should eventually come from. An environment variable ? 125: Whatever, i use some 32-bit random value with no crypto strength. */ gettimeofday(&tv, NULL); id = 0xffffffff & (tv.tv_sec ^ (tv.tv_usec * 2000)); /* 126: Adds 4 id bytes and 2 zero bytes. */ lsb_to_buf(&wpt, id, 32, 0); lsb_to_buf(&wpt, 0, 16, 0); /* 129: Composes 16 byte record from the parameters determined 147: so far. Appends it to buffer and add 48 zero bytes. */ /* There are 4 "partition slots". Only the first is non-zero here. In the perl script, the fields are set in variables and then written to buffer. I omit the variables. */ /* 0x80 */ lsb_to_buf(&wpt, 0x80, 8, 0); /* bhead */ lsb_to_buf(&wpt, 0, 8, 0); /* bsect */ lsb_to_buf(&wpt, 1, 8, 0); /* bcyl */ lsb_to_buf(&wpt, 0, 8, 0); /* fstype */ lsb_to_buf(&wpt, 0x83, 8, 0); /* ehead */ lsb_to_buf(&wpt, h - 1, 8, 0); /* esect */ lsb_to_buf(&wpt, s + (((cc - 1) & 0x300) >> 2), 8, 0); /* ecyl */ lsb_to_buf(&wpt, (cc - 1) & 0xff, 8, 0); /* 0 */ lsb_to_buf(&wpt, 0, 32, 0); /* psize */ lsb_to_buf(&wpt, c * h * s, 32, 0); /* Fill the other three slots with zeros */ for (i = 0; i < 3 * 4; i++) lsb_to_buf(&wpt, 0, 32, 0); /* 148: Appends bytes 0x55 , 0xAA. */ lsb_to_buf(&wpt, 0x55, 8, 0); lsb_to_buf(&wpt, 0xaa, 8, 0); return (1); } /* ====================================================================== */ /* The New MBR Producer */ /* ====================================================================== */ /* The new MBR producer for isohybrid is a slightly generalized version of the deprecated function make_isohybrid_mbr(). It complies to the urge of H.Peter Anvin not to hardcode MBR templates but rather to read a file from the Syslinux tree, and to patch it as was done with the old MBR producer. The old algorithm was clarified publicly by the following mail. Changes towards the old algorithm: - 512-byte LBA of boot image is extended to 64 bit (we stay with 32) - check for a magic number is now gone The new implementation tries to use similar terms as the mail in order to facilitate its future discussion with Syslinux developers. From hpa@zytor.com Thu Apr 1 08:32:52 2010 Date: Wed, 31 Mar 2010 14:53:51 -0700 From: H. Peter Anvin To: For discussion of Syslinux and tftp-hpa Cc: Thomas Schmitt Subject: Re: [syslinux] port syslinux isohybrid perl script to C [...] [me:] > Currently i lack of blob and prescriptions. The blobs are available in the Syslinux build tree under the names: mbr/isohdp[fp]x*.bin The default probably should be mbr/isohdppx.bin, but it's ultimately up to the user. User definable parameters: -> MBR ID (default random 32-bit number, or preserved from previous instance) -> Sector count (default 32, range 1-63) -> Head count (default 64, range 1-256) -> Partition offset (default 0, range 0-64) -> Partition number (default 1, range 1-4) -> Filesystem type (default 0x17, range 1-255) Note: the filesystem type is largely arbitrary, in theory it can be any value other than 0x00, 0x05, 0x0f, 0x85, 0xee, or 0xef. 0x17 ("Windows IFS Hidden") seems safeish, some people believe 0x83 (Linux) is better. Here is the prescriptions for how to install it: All numbers are littleendian. "word" means 16 bits, "dword" means 32 bits, "qword" means 64 bits. Common subroutine LBA_to_CHS(): s = (lba % sector_count) + 1 t = (lba / sector_count) h = (t % head_count) c = (t / head_count) if (c >= 1024): c = 1023 h = head_count s = sector_count s = s | ((c & 0x300) >> 2) c = c & 0xff write byte h write byte s write byte c Main: Pad image_size to a multiple of sector_count*head_count Use the input file unmodified for bytes 0..431 write qword boot_lba # Offset 432 write dword mbr_id # Offset 440 write word 0 # Offset 444 # Offset 446 For each partition entry 1..4: if this_partition != partition_number: write 16 zero bytes else: write byte 0x80 write LBA_to_CHS(partition_offset) write byte filesystem_type write LBA_to_CHS(image_size-1) write dword partition_offset write dword image_size # Offset 510 write word 0xaa55 Use the input file unmodified for bytes 512..32767 (pad with zero as necessary) [...] -hpa */ /* The new stuff about GPT and APM which was learned from Matthew Garret and isohybrid.c is described in doc/boot_sectord.txt chapter "SYSLINUX isohybrid for MBR, UEFI and x86-Mac" */ static int lba512chs_to_buf(char **wpt, off_t lba, int head_count, int sector_count) { int s, t, h, c; s = (lba % sector_count) + 1; t = (lba / sector_count); h = (t % head_count); c = (t / head_count); if (c >= 1024) { c = 1023; h = head_count; /* >>> not -1 ? Limits head_count to 255 */ s = sector_count; } s = s | ((c & 0x300) >> 2); c = c & 0xff; (*((unsigned char **) wpt))[0] = h; (*((unsigned char **) wpt))[1] = s; (*((unsigned char **) wpt))[2] = c; (*wpt)+= 3; return(1); } /* Find out whether GPT and APM are desired flag bit0 = register APM and GPT requests in Ecma119Image bit1 = do not asses and register APM bit2 = do not register overall GPT partition */ int assess_isohybrid_gpt_apm(Ecma119Image *t, int *gpt_count, int gpt_idx[128], int *apm_count, int flag) { int i, ilx_opts, j, ret, num_img; uint32_t block_count; uint64_t start_block; uint8_t gpt_name[72]; static uint8_t zero_uuid[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; static uint8_t basic_data_uuid[16] = { 0xa2, 0xa0, 0xd0, 0xeb, 0xe5, 0xb9, 0x33, 0x44, 0x87, 0xc0, 0x68, 0xb6, 0xb7, 0x26, 0x99, 0xc7 }; static uint8_t hfs_uuid[16] = { 0x00, 0x53, 0x46, 0x48, 0x00, 0x00, 0xaa, 0x11, 0xaa, 0x11, 0x00, 0x30, 0x65, 0x43, 0xec, 0xac }; uint8_t *uuid; static uint64_t gpt_flags = (((uint64_t) 1) << 60) | 1; *gpt_count = 0; *apm_count = 0; if (t->catalog != NULL) num_img = t->catalog->num_bootimages; else num_img = 0; for (i = 0; i < num_img; i++) { ilx_opts = t->catalog->bootimages[i]->isolinux_options; if ((((ilx_opts >> 2) & 63) == 1 || ((ilx_opts >> 2) & 63) == 2) && !(t->boot_appended_idx[i] >= 0 && t->opts->appended_as_gpt)) { if (*gpt_count < 128) gpt_idx[*gpt_count] = i; (*gpt_count)++; if ((flag & 1) && (t->bootsrc[i] != NULL || t->boot_appended_idx[i] >= 0)) { /* Register GPT entry */ memset(gpt_name, 0, 72); sprintf((char *) gpt_name, "ISOHybrid%d", *gpt_count); iso_ascii_utf_16le(gpt_name); if (((ilx_opts >> 2) & 63) == 2) uuid = hfs_uuid; else uuid = basic_data_uuid; if (t->boot_appended_idx[i] >= 0) { block_count = t->appended_part_size[ t->boot_appended_idx[i]]; start_block = ((uint64_t) t->appended_part_start[ t->boot_appended_idx[i]]) * 4; } else { block_count = 0; for (j = 0; j < t->bootsrc[i]->nsections; j++) block_count += t->bootsrc[i]->sections[j].size / 2048; start_block = ((uint64_t) t->bootsrc[i]->sections[0].block) * 4; } ret = iso_quick_gpt_entry( t->gpt_req, &(t->gpt_req_count), start_block, ((uint64_t) block_count) * 4, uuid, zero_uuid, gpt_flags, (uint8_t *) gpt_name); if (ret < 0) return ret; } } if ((ilx_opts & 256) && !(flag & 2)) { (*apm_count)++; if ((flag & 1) && (t->bootsrc[i] != NULL || t->boot_appended_idx[i] >= 0)) { /* Register APM entry */ if (t->boot_appended_idx[i] >= 0) { block_count = t->appended_part_size[ t->boot_appended_idx[i]]; start_block = t->appended_part_start[ t->boot_appended_idx[i]]; } else { block_count = 0; for (j = 0; j < t->bootsrc[i]->nsections; j++) block_count += t->bootsrc[i]->sections[j].size / 2048; start_block = t->bootsrc[i]->sections[0].block; } ret = iso_quick_apm_entry(t->apm_req, &(t->apm_req_count), (uint32_t) start_block, block_count, "EFI", "Apple_HFS"); if (ret < 0) return ret; /* Prevent gap filling */ t->apm_req_flags |= 2; t->opts->apm_block_size = 2048; } } } if (*gpt_count > 0 && !(flag & 4)) { (*gpt_count)++; if (*gpt_count < 128) gpt_idx[*gpt_count] = -1; } if ((flag & 1) && *gpt_count > 0 && !(flag & 4)) { /* Register overall GPT partition */ memset(gpt_name, 0, 72); sprintf((char *) gpt_name, "ISOHybrid"); iso_ascii_utf_16le(gpt_name); /* Let it be open ended. iso_write_gpt() will truncate it as needed. */ block_count = 0xffffffff; ret = iso_quick_gpt_entry(t->gpt_req, &(t->gpt_req_count), (uint64_t) t->opts->partition_offset * 4, ((uint64_t) block_count) * 4, basic_data_uuid, zero_uuid, gpt_flags, (uint8_t *) gpt_name); if (ret < 0) return ret; /* Remove ban on GPT overlapping */ t->gpt_req_flags |= 1; } return ISO_SUCCESS; } /* Insert APM head into MBR */ static int insert_apm_head(uint8_t *buf, int apm_count) { int i; static uint8_t apm_mbr_start[32] = { 0x33, 0xed, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90 }; static uint8_t apm_head[32] = { 0x45, 0x52, 0x08, 0x00, 0x00, 0x00, 0x90, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; if (apm_count) { for (i = 0; i < 32; i++) if(buf[i] != apm_mbr_start[i]) break; if (i < 32) { /* Maybe it is already patched by apm_head ? */ for (i = 0; i < 32; i++) if(buf[i] != apm_head[i]) break; } if (i < 32) { iso_msgs_submit(0, "MBR template file seems not prepared for Apple Partition Map.", 0, "FAILURE", 0); return ISO_ISOLINUX_CANT_PATCH; } for (i = 0; i < 32; i++) buf[i] = apm_head[i]; } return ISO_SUCCESS; } /* Describe GPT boot images as MBR partitions */ static int gpt_images_as_mbr_partitions(Ecma119Image *t, char *wpt, int gpt_idx[128], int *gpt_cursor) { int ilx_opts, skip = 0; off_t hd_blocks; static uint8_t dummy_chs[3] = { 0xfe, 0xff, 0xff, }; if (gpt_idx[*gpt_cursor] < 0) skip = 1; else if (t->bootsrc[gpt_idx[*gpt_cursor]] == NULL) skip = 1; if (skip) { (*gpt_cursor)++; return 2; } wpt[0] = 0; memcpy(wpt + 1, dummy_chs, 3); ilx_opts = t->catalog->bootimages[gpt_idx[*gpt_cursor]]->isolinux_options; if (((ilx_opts >> 2) & 63) == 2) wpt[4] = 0x00; /* HFS gets marked as "Empty" */ else ((unsigned char *) wpt)[4] = 0xef; /* "EFI (FAT-12/16)" */ memcpy(wpt + 5, dummy_chs, 3); /* Start LBA (in 512 blocks) */ wpt += 8; lsb_to_buf(&wpt, t->bootsrc[gpt_idx[*gpt_cursor]]->sections[0].block * 4, 32, 0); /* Number of blocks */ hd_blocks = t->bootsrc[gpt_idx[*gpt_cursor]]->sections[0].size; hd_blocks = hd_blocks / 512 + !!(hd_blocks % 512); lsb_to_buf(&wpt, (int) hd_blocks, 32, 0); (*gpt_cursor)++; return ISO_SUCCESS; } /* For generating a weak random number */ static uint32_t iso_make_mbr_id(Ecma119Image *t, int flag) { uint32_t id; struct timeval tv; if(t->opts->vol_uuid[0]) { id = iso_crc32_gpt((unsigned char *) t->opts->vol_uuid, 16, 0); } else if(t->opts->vol_modification_time > 0) { id = iso_crc32_gpt((unsigned char *) &(t->opts->vol_modification_time), sizeof(time_t), 0); } else { gettimeofday(&tv, NULL); id = 0xffffffff & (tv.tv_sec ^ (tv.tv_usec * 2000)); } return id; } /* * @param flag bit0= make own random MBR Id from current time * >>> or from overridden modification time * bit1= create protective MBR as of UEFI/GPT specs */ int make_isolinux_mbr(uint32_t *img_blocks, Ecma119Image *t, int part_offset, int part_number, int fs_type, uint8_t *buf, int flag) { uint32_t id, part, nominal_part_size; off_t hd_img_blocks, hd_boot_lba; char *wpt; uint32_t boot_lba; int head_count, sector_count, ret; int gpt_count = 0, gpt_idx[128], apm_count = 0, gpt_cursor, i; if (t->bootsrc[0] == NULL) return iso_msg_submit(t->image->id, ISO_BOOT_IMAGE_NOT_VALID, 0, "Cannot refer by isohybrid MBR to data outside of ISO 9660 filesystem."); for (i = 0; i < 128; i++) gpt_idx[i] = -1; if (flag & 2) { part_number = 1; part_offset = 1; } hd_img_blocks = ((off_t) *img_blocks) * (off_t) 4 - t->post_iso_part_pad / 512; boot_lba = t->bootsrc[0]->sections[0].block; head_count = t->partition_heads_per_cyl; sector_count = t->partition_secs_per_head; ret = assess_isohybrid_gpt_apm(t, &gpt_count, gpt_idx, &apm_count, 0); if (ret < 0) return ret; /* The rest of APM has already been written by iso_write_apm(). But the isohybrid APM head differs from the hfsplus_writer APM head. */ ret = insert_apm_head(buf, apm_count); if (ret < 0) return ret; /* Padding of image_size to a multiple of sector_count*head_count happens already at compute time and is implemented by an appropriate increase of Ecma119Image->tail_blocks. */ wpt = (char *) buf + 432; /* write qword boot_lba # Offset 432 */ hd_boot_lba = ((off_t) boot_lba) * (off_t) 4; lsb_to_buf(&wpt, hd_boot_lba & 0xffffffff, 32, 0); lsb_to_buf(&wpt, hd_boot_lba >> 32, 32, 0); /* write dword mbr_id # Offset 440 (here some 32-bit random value with no crypto strength) */ if (flag & 1) { id = iso_make_mbr_id(t, 0); lsb_to_buf(&wpt, id, 32, 0); } else { wpt+= 4; } /* write word 0 # Offset 444 */ lsb_to_buf(&wpt, 0, 16, 0); /* # Offset 446 */ gpt_cursor= 0; for (part = 1 ; part <= 4; part++) { if ((int) part != part_number) { /* if this_partition != partition_number: write 16 zero bytes (this is now overriden by the eventual desire to announce EFI and HFS boot images.) */ memset(wpt, 0, 16); if (gpt_cursor < gpt_count) { ret = gpt_images_as_mbr_partitions(t, wpt, gpt_idx, &gpt_cursor); if (ret < 0) return ret; } wpt+= 16; continue; } /* write byte 0x80 if bootable write LBA_to_CHS(partition_offset) write byte filesystem_type write LBA_to_CHS(image_size-1) write dword partition_offset write dword image_size */ if (flag & 2) lsb_to_buf(&wpt, 0x00, 8, 0); else lsb_to_buf(&wpt, 0x80, 8, 0); lba512chs_to_buf(&wpt, part_offset, head_count, sector_count); lsb_to_buf(&wpt, fs_type, 8, 0); lba512chs_to_buf(&wpt, hd_img_blocks - 1, head_count, sector_count); lsb_to_buf(&wpt, part_offset, 32, 0); if (hd_img_blocks - (off_t) part_offset > (off_t) 0xffffffff) nominal_part_size = 0xffffffff; else nominal_part_size = hd_img_blocks - (off_t) part_offset; lsb_to_buf(&wpt, nominal_part_size, 32, 0); } /* write word 0xaa55 # Offset 510 */ lsb_to_buf(&wpt, 0xaa55, 16, 0); return(1); }