|
|
|
|
@ -3,6 +3,7 @@
|
|
|
|
|
#include "eltorito.h"
|
|
|
|
|
#include "volume.h"
|
|
|
|
|
#include "util.h"
|
|
|
|
|
#include "messages.h"
|
|
|
|
|
|
|
|
|
|
#include <assert.h>
|
|
|
|
|
#include <malloc.h>
|
|
|
|
|
@ -15,46 +16,6 @@
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct el_torito_validation_entry {
|
|
|
|
|
uint8_t header_id BP(1, 1);
|
|
|
|
|
uint8_t platform_id BP(2, 2);
|
|
|
|
|
uint8_t reserved BP(3, 4);
|
|
|
|
|
uint8_t id_string BP(5, 28);
|
|
|
|
|
uint8_t checksum BP(29, 30);
|
|
|
|
|
uint8_t key_byte1 BP(31, 31);
|
|
|
|
|
uint8_t key_byte2 BP(32, 32);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct el_torito_default_entry {
|
|
|
|
|
uint8_t boot_indicator BP(1, 1);
|
|
|
|
|
uint8_t boot_media_type BP(2, 2);
|
|
|
|
|
uint8_t load_seg BP(3, 4);
|
|
|
|
|
uint8_t system_type BP(5, 5);
|
|
|
|
|
uint8_t unused1 BP(6, 6);
|
|
|
|
|
uint8_t sec_count BP(7, 8);
|
|
|
|
|
uint8_t block BP(9, 12);
|
|
|
|
|
uint8_t unused2 BP(13, 32);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct el_torito_section_header_entry {
|
|
|
|
|
uint8_t header_indicator BP(1, 1);
|
|
|
|
|
uint8_t platform_id BP(2, 2);
|
|
|
|
|
uint8_t number BP(3, 4);
|
|
|
|
|
uint8_t character BP(5, 32);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct el_torito_section_entry {
|
|
|
|
|
uint8_t boot_indicator BP(1, 1);
|
|
|
|
|
uint8_t boot_media_type BP(2, 2);
|
|
|
|
|
uint8_t load_seg BP(3, 4);
|
|
|
|
|
uint8_t system_type BP(5, 5);
|
|
|
|
|
uint8_t unused1 BP(6, 6);
|
|
|
|
|
uint8_t sec_count BP(7, 8);
|
|
|
|
|
uint8_t block BP(9, 12);
|
|
|
|
|
uint8_t selec_criteria BP(13, 13);
|
|
|
|
|
uint8_t vendor_sc BP(14, 32);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* This table should be written with accuracy values at offset
|
|
|
|
|
* 8 of boot image, when used ISOLINUX boot loader
|
|
|
|
|
@ -85,18 +46,67 @@ struct hard_disc_mbr {
|
|
|
|
|
uint8_t sign2;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
el_torito_image_free(struct el_torito_boot_image *image)
|
|
|
|
|
{
|
|
|
|
|
assert(image);
|
|
|
|
|
|
|
|
|
|
/* unref image node */
|
|
|
|
|
iso_tree_free((struct iso_tree_node*)image->node);
|
|
|
|
|
free(image);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct iso_tree_node_boot*
|
|
|
|
|
create_boot_image_node(struct iso_tree_node_file *image)
|
|
|
|
|
{
|
|
|
|
|
struct iso_tree_node_boot *boot;
|
|
|
|
|
struct iso_tree_node_dir *parent;
|
|
|
|
|
|
|
|
|
|
assert(image);
|
|
|
|
|
|
|
|
|
|
boot = calloc(1, sizeof(struct iso_tree_node_boot));
|
|
|
|
|
boot->node.attrib = image->node.attrib;
|
|
|
|
|
boot->node.type = LIBISO_NODE_BOOT;
|
|
|
|
|
boot->node.name = strdup(image->node.name);
|
|
|
|
|
boot->node.hide_flags = image->node.hide_flags;
|
|
|
|
|
boot->node.refcount = 2; /* mine and tree */
|
|
|
|
|
boot->loc.path = strdup(image->loc.path);
|
|
|
|
|
boot->img = 1; /* it refers to image */
|
|
|
|
|
|
|
|
|
|
/* replace iso_tree_node_file with the image */
|
|
|
|
|
parent = image->node.parent;
|
|
|
|
|
iso_tree_node_remove(parent, (struct iso_tree_node*)image);
|
|
|
|
|
iso_tree_add_child(parent, (struct iso_tree_node*) boot);
|
|
|
|
|
|
|
|
|
|
return boot;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct el_torito_boot_image *
|
|
|
|
|
create_image(struct iso_tree_node *image,
|
|
|
|
|
create_image(const char *path,
|
|
|
|
|
enum eltorito_boot_media_type type)
|
|
|
|
|
{
|
|
|
|
|
struct stat attrib;
|
|
|
|
|
struct el_torito_boot_image *boot;
|
|
|
|
|
int boot_media_type = 0;
|
|
|
|
|
int load_sectors = 0; /* number of sector to load */
|
|
|
|
|
unsigned char partition_type = 0;
|
|
|
|
|
|
|
|
|
|
if (stat(path, &attrib)) {
|
|
|
|
|
iso_msg_sorry(LIBISO_EL_TORITO_WRONG_IMG, "Can't access file.");
|
|
|
|
|
libisofs_errno = NO_FILE;
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ( !S_ISREG(attrib.st_mode) ) {
|
|
|
|
|
iso_msg_sorry(LIBISO_EL_TORITO_WRONG_IMG,
|
|
|
|
|
"We can only create boot images from regular files");
|
|
|
|
|
libisofs_errno = ELTORITO_WRONG_IMAGE;
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
|
case ELTORITO_FLOPPY_EMUL:
|
|
|
|
|
switch (image->attrib.st_size) {
|
|
|
|
|
switch (attrib.st_size) {
|
|
|
|
|
case 1200 * 1024:
|
|
|
|
|
boot_media_type = 1; /* 1.2 meg diskette */
|
|
|
|
|
break;
|
|
|
|
|
@ -107,10 +117,14 @@ create_image(struct iso_tree_node *image,
|
|
|
|
|
boot_media_type = 3; /* 2.88 meg diskette */
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
fprintf(stderr, "Invalid image size %d Kb. Must be one of 1.2, 1.44"
|
|
|
|
|
"or 2.88 Mb", (int) image->attrib.st_size / 1024);
|
|
|
|
|
{
|
|
|
|
|
char msg[72];
|
|
|
|
|
sprintf(msg, "Invalid image size %d Kb. Must be one of 1.2, 1.44"
|
|
|
|
|
"or 2.88 Mb", (int) attrib.st_size / 1024);
|
|
|
|
|
iso_msg_sorry(LIBISO_EL_TORITO_WRONG_IMG, msg);
|
|
|
|
|
libisofs_errno = ELTORITO_WRONG_IMAGE_SIZE;
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
/* it seems that for floppy emulation we need to load
|
|
|
|
|
@ -125,13 +139,16 @@ create_image(struct iso_tree_node *image,
|
|
|
|
|
int used_partition;
|
|
|
|
|
|
|
|
|
|
/* read the MBR on disc and get the type of the partition */
|
|
|
|
|
fd = open(((struct iso_tree_node_file*)image)->loc.path, O_RDONLY);
|
|
|
|
|
fd = open(path, O_RDONLY);
|
|
|
|
|
if ( fd == -1 ) {
|
|
|
|
|
fprintf(stderr, "Can't open image file\n");
|
|
|
|
|
iso_msg_sorry(LIBISO_EL_TORITO_WRONG_IMG, "Can't open image file.");
|
|
|
|
|
libisofs_errno = NO_READ_ACCESS;
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
if ( read(fd, &mbr, sizeof(mbr)) ) {
|
|
|
|
|
fprintf(stderr, "Can't read MBR from image file\n");
|
|
|
|
|
iso_msg_sorry(LIBISO_EL_TORITO_WRONG_IMG,
|
|
|
|
|
"Can't read MBR from image file.");
|
|
|
|
|
libisofs_errno = ELTORITO_WRONG_IMAGE;
|
|
|
|
|
close(fd);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
@ -139,7 +156,9 @@ create_image(struct iso_tree_node *image,
|
|
|
|
|
|
|
|
|
|
/* check valid MBR signature */
|
|
|
|
|
if ( mbr.sign1 != 0x55 || mbr.sign2 != 0xAA ) {
|
|
|
|
|
fprintf(stderr, "Invalid MBR. Wrong signature.\n");
|
|
|
|
|
iso_msg_sorry(LIBISO_EL_TORITO_WRONG_IMG,
|
|
|
|
|
"Invalid MBR. Wrong signature.");
|
|
|
|
|
libisofs_errno = ELTORITO_WRONG_IMAGE;
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@ -149,8 +168,11 @@ create_image(struct iso_tree_node *image,
|
|
|
|
|
if (mbr.partition[i].type != 0) {
|
|
|
|
|
/* it's an used partition */
|
|
|
|
|
if (used_partition != -1) {
|
|
|
|
|
fprintf(stderr, "Invalid MBR. At least 2 partitions: %d and "
|
|
|
|
|
char msg[72];
|
|
|
|
|
sprintf(msg, "Invalid MBR. At least 2 partitions: %d and "
|
|
|
|
|
"%d, are being used\n", used_partition, i);
|
|
|
|
|
iso_msg_sorry(LIBISO_EL_TORITO_WRONG_IMG, msg);
|
|
|
|
|
libisofs_errno = ELTORITO_WRONG_IMAGE;
|
|
|
|
|
return NULL;
|
|
|
|
|
} else
|
|
|
|
|
used_partition = i;
|
|
|
|
|
@ -170,67 +192,180 @@ create_image(struct iso_tree_node *image,
|
|
|
|
|
|
|
|
|
|
boot = calloc(1, sizeof(struct el_torito_boot_image));
|
|
|
|
|
boot->bootable = 1;
|
|
|
|
|
boot->image = (struct iso_tree_node_file *) image;
|
|
|
|
|
boot->type = boot_media_type;
|
|
|
|
|
boot->load_size = load_sectors;
|
|
|
|
|
boot->partition_type = partition_type;
|
|
|
|
|
return boot;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct iso_tree_node_boot_catalog*
|
|
|
|
|
/* parent and name can be null */
|
|
|
|
|
static struct iso_tree_node_boot*
|
|
|
|
|
create_boot_catalog_node(struct iso_tree_node_dir *parent,
|
|
|
|
|
const char *name)
|
|
|
|
|
{
|
|
|
|
|
struct iso_tree_node_boot_catalog *boot;
|
|
|
|
|
struct iso_tree_node_boot *boot;
|
|
|
|
|
|
|
|
|
|
assert( parent && name );
|
|
|
|
|
assert( (parent && name) || (!parent && !name) );
|
|
|
|
|
|
|
|
|
|
boot = calloc(1, sizeof(struct iso_tree_node_boot_catalog));
|
|
|
|
|
boot = calloc(1, sizeof(struct iso_tree_node_boot));
|
|
|
|
|
boot->node.attrib.st_mode = S_IFREG | 0444;
|
|
|
|
|
boot->node.attrib.st_atime =
|
|
|
|
|
boot->node.attrib.st_mtime =
|
|
|
|
|
boot->node.attrib.st_ctime = time(NULL);
|
|
|
|
|
boot->node.type = LIBISO_NODE_BOOTCATALOG;
|
|
|
|
|
boot->node.name = strdup(name);
|
|
|
|
|
iso_tree_add_child(parent, (struct iso_tree_node*) boot);
|
|
|
|
|
boot->node.attrib.st_size = 2048;
|
|
|
|
|
boot->node.type = LIBISO_NODE_BOOT;
|
|
|
|
|
boot->node.name = name ? strdup(name) : NULL;
|
|
|
|
|
boot->node.refcount = 1; /* mine */
|
|
|
|
|
if (parent) {
|
|
|
|
|
boot->node.refcount++; /* add tree ref */
|
|
|
|
|
iso_tree_add_child(parent, (struct iso_tree_node*) boot);
|
|
|
|
|
}
|
|
|
|
|
return boot;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct el_torito_boot_image *
|
|
|
|
|
iso_volume_create_boot_catalog(struct iso_volume *volume,
|
|
|
|
|
struct iso_tree_node *image,
|
|
|
|
|
enum eltorito_boot_media_type type,
|
|
|
|
|
struct iso_tree_node_dir *dir,
|
|
|
|
|
char *name)
|
|
|
|
|
struct el_torito_boot_image*
|
|
|
|
|
iso_volume_set_boot_image(struct iso_volume *volume,
|
|
|
|
|
struct iso_tree_node *image,
|
|
|
|
|
enum eltorito_boot_media_type type,
|
|
|
|
|
struct iso_tree_node_dir *dir,
|
|
|
|
|
char *name)
|
|
|
|
|
{
|
|
|
|
|
struct el_torito_boot_image *boot_image;
|
|
|
|
|
struct iso_tree_node_boot *cat_node;
|
|
|
|
|
struct el_torito_boot_catalog *catalog;
|
|
|
|
|
struct iso_tree_node_file *imgfile;
|
|
|
|
|
|
|
|
|
|
assert(volume && !volume->bootcat);
|
|
|
|
|
assert(image && ISO_ISREG(image));
|
|
|
|
|
assert(dir && name);
|
|
|
|
|
|
|
|
|
|
imgfile = (struct iso_tree_node_file*)image;
|
|
|
|
|
|
|
|
|
|
if (image->procedence == LIBISO_PREVIMG) {
|
|
|
|
|
/* FIXME mmm, what to do here? */
|
|
|
|
|
iso_msg_sorry(LIBISO_EL_TORITO_WRONG_IMG, "Can't use prev. image files "
|
|
|
|
|
"as boot images");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
boot_image = create_image(imgfile->loc.path, type);
|
|
|
|
|
if ( !boot_image )
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
/* create image node */
|
|
|
|
|
boot_image->node = create_boot_image_node(imgfile);
|
|
|
|
|
|
|
|
|
|
/* creates the catalog with the given default image */
|
|
|
|
|
catalog = malloc(sizeof(struct el_torito_boot_catalog));
|
|
|
|
|
if (!catalog) {
|
|
|
|
|
el_torito_image_free(boot_image);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
catalog->image = boot_image;
|
|
|
|
|
|
|
|
|
|
/* add catalog file */
|
|
|
|
|
cat_node = create_boot_catalog_node(dir, name);
|
|
|
|
|
catalog->node = cat_node;
|
|
|
|
|
|
|
|
|
|
volume->bootcat = catalog;
|
|
|
|
|
|
|
|
|
|
return boot_image;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct el_torito_boot_image*
|
|
|
|
|
iso_volume_set_boot_image_hidden(struct iso_volume *volume, const char* path,
|
|
|
|
|
enum eltorito_boot_media_type type)
|
|
|
|
|
{
|
|
|
|
|
struct el_torito_boot_image *boot_image;
|
|
|
|
|
struct iso_tree_node_boot_catalog *boot_node;
|
|
|
|
|
struct iso_tree_node_boot *cat_node;
|
|
|
|
|
struct el_torito_boot_catalog *catalog;
|
|
|
|
|
|
|
|
|
|
assert( volume && !volume->bootcat);
|
|
|
|
|
assert( image && ISO_ISREG(image) && dir && name);
|
|
|
|
|
assert(volume && !volume->bootcat);
|
|
|
|
|
assert(path);
|
|
|
|
|
|
|
|
|
|
boot_image = create_image(image, type);
|
|
|
|
|
boot_image = create_image(path, type);
|
|
|
|
|
if ( !boot_image )
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
/* create image node */
|
|
|
|
|
{
|
|
|
|
|
struct iso_tree_node_boot *boot;
|
|
|
|
|
boot = calloc(1, sizeof(struct iso_tree_node_boot));
|
|
|
|
|
/* we assume the stat won't fail, as we already stat the same file above */
|
|
|
|
|
stat(path, &boot->node.attrib);
|
|
|
|
|
boot->node.type = LIBISO_NODE_BOOT;
|
|
|
|
|
boot->node.refcount = 1; /* mine */
|
|
|
|
|
boot->loc.path = strdup(path);
|
|
|
|
|
boot->img = 1; /* it refers to image */
|
|
|
|
|
boot_image->node = boot;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* creates the catalog with the given default image */
|
|
|
|
|
catalog = malloc(sizeof(struct el_torito_boot_catalog));
|
|
|
|
|
catalog->nentries = 1;
|
|
|
|
|
catalog->entries = malloc(sizeof(struct el_torito_boot_image *));
|
|
|
|
|
catalog->entries[0] = boot_image;
|
|
|
|
|
catalog->file = malloc(sizeof(struct iso_file));
|
|
|
|
|
catalog->file->size = 2048;
|
|
|
|
|
if (!catalog) {
|
|
|
|
|
el_torito_image_free(boot_image);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
catalog->image = boot_image;
|
|
|
|
|
|
|
|
|
|
/* add catalog file */
|
|
|
|
|
boot_node = create_boot_catalog_node(dir, name);
|
|
|
|
|
boot_node->catalog = catalog;
|
|
|
|
|
cat_node = create_boot_catalog_node(NULL, NULL);
|
|
|
|
|
catalog->node = cat_node;
|
|
|
|
|
|
|
|
|
|
volume->bootcat = catalog;
|
|
|
|
|
|
|
|
|
|
return boot_image;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct el_torito_boot_image*
|
|
|
|
|
iso_volume_get_boot_image(struct iso_volume *volume,
|
|
|
|
|
struct iso_tree_node **imgnode,
|
|
|
|
|
struct iso_tree_node **catnode)
|
|
|
|
|
{
|
|
|
|
|
struct el_torito_boot_catalog *catalog;
|
|
|
|
|
|
|
|
|
|
assert(volume);
|
|
|
|
|
|
|
|
|
|
catalog = volume->bootcat;
|
|
|
|
|
if (!catalog)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
if (imgnode)
|
|
|
|
|
*imgnode = (struct iso_tree_node*)catalog->image->node;
|
|
|
|
|
|
|
|
|
|
if (catnode)
|
|
|
|
|
*catnode = (struct iso_tree_node*)catalog->node;
|
|
|
|
|
|
|
|
|
|
return catalog->image;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
iso_volume_remove_boot_image(struct iso_volume *volume)
|
|
|
|
|
{
|
|
|
|
|
struct el_torito_boot_catalog *catalog;
|
|
|
|
|
struct iso_tree_node *catnode;
|
|
|
|
|
struct iso_tree_node *imgnode;
|
|
|
|
|
assert(volume);
|
|
|
|
|
|
|
|
|
|
catalog = volume->bootcat;
|
|
|
|
|
if (!catalog)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* remove node from tree */
|
|
|
|
|
catnode = (struct iso_tree_node*)catalog->node;
|
|
|
|
|
if (catnode->parent)
|
|
|
|
|
iso_tree_node_remove(catnode->parent, catnode);
|
|
|
|
|
|
|
|
|
|
/* remove image from tree */
|
|
|
|
|
imgnode = (struct iso_tree_node*)catalog->image->node;
|
|
|
|
|
if (imgnode->parent)
|
|
|
|
|
iso_tree_node_remove(imgnode->parent, imgnode);
|
|
|
|
|
|
|
|
|
|
/* remove catalog */
|
|
|
|
|
el_torito_boot_catalog_free(catalog);
|
|
|
|
|
volume->bootcat = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
el_torito_set_load_seg(struct el_torito_boot_image *bootimg, int segment)
|
|
|
|
|
{
|
|
|
|
|
@ -254,43 +389,20 @@ el_torito_set_no_bootable(struct el_torito_boot_image *bootimg)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
el_torito_set_write_boot_info(struct el_torito_boot_image *bootimg)
|
|
|
|
|
el_torito_patch_isolinux_image(struct el_torito_boot_image *bootimg)
|
|
|
|
|
{
|
|
|
|
|
bootimg->patch_isolinux = 1;
|
|
|
|
|
bootimg->isolinux = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void el_torito_boot_catalog_free(struct el_torito_boot_catalog *cat)
|
|
|
|
|
{
|
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
|
|
assert(cat);
|
|
|
|
|
|
|
|
|
|
for(i = 0; i < cat->nentries; ++i) {
|
|
|
|
|
free(cat->entries[i]);
|
|
|
|
|
}
|
|
|
|
|
free(cat->entries);
|
|
|
|
|
free(cat->file);
|
|
|
|
|
el_torito_image_free(cat->image);
|
|
|
|
|
iso_tree_free((struct iso_tree_node*)cat->node);
|
|
|
|
|
free(cat);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void el_torito_get_image_files(struct ecma119_write_target *t)
|
|
|
|
|
{
|
|
|
|
|
size_t i;
|
|
|
|
|
struct el_torito_boot_catalog *cat = t->catalog;
|
|
|
|
|
assert(cat);
|
|
|
|
|
|
|
|
|
|
for(i = 0; i < cat->nentries; ++i) {
|
|
|
|
|
|
|
|
|
|
struct iso_tree_node_file *image = cat->entries[i]->image;
|
|
|
|
|
struct iso_file *file = iso_file_table_lookup(t->file_table, image);
|
|
|
|
|
if ( file == NULL ) {
|
|
|
|
|
file = iso_file_new(image);
|
|
|
|
|
iso_file_table_add_file(t->file_table, file);
|
|
|
|
|
}
|
|
|
|
|
cat->entries[i]->file = file;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Write the Boot Record Volume Descriptor
|
|
|
|
|
*/
|
|
|
|
|
@ -307,7 +419,7 @@ el_torito_write_boot_vol_desc(struct ecma119_write_target *t, uint8_t *buf)
|
|
|
|
|
memcpy(vol->std_identifier, "CD001", 5);
|
|
|
|
|
vol->vol_desc_version[0] = 1;
|
|
|
|
|
memcpy(vol->boot_sys_id, "EL TORITO SPECIFICATION", 23);
|
|
|
|
|
iso_lsb(vol->boot_catalog, cat->file->block, 4);
|
|
|
|
|
iso_lsb(vol->boot_catalog, t->catblock, 4);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
@ -333,104 +445,139 @@ write_validation_entry(struct ecma119_write_target *t, uint8_t *buf)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
patch_boot_file(struct el_torito_boot_image *img)
|
|
|
|
|
patch_boot_image(uint8_t *buf, struct ecma119_write_target *t, ssize_t imgsize)
|
|
|
|
|
{
|
|
|
|
|
struct boot_info_table info;
|
|
|
|
|
int fd;
|
|
|
|
|
struct boot_info_table *info;
|
|
|
|
|
uint32_t checksum;
|
|
|
|
|
ssize_t len;
|
|
|
|
|
uint8_t buf[4];
|
|
|
|
|
ssize_t offset;
|
|
|
|
|
|
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
|
|
|
|
|
|
|
|
/* open image */
|
|
|
|
|
fd = open(img->image->loc.path, O_RDWR);
|
|
|
|
|
if ( fd == -1 ) {
|
|
|
|
|
//TODO what do do? exit or just continue?
|
|
|
|
|
fprintf(stderr, "Can't patch boot image %s\n", img->image->loc.path);
|
|
|
|
|
close(fd);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* compute checksum, as the the sum of all 32 bit words in boot image
|
|
|
|
|
* from offset 64 */
|
|
|
|
|
checksum = 0;
|
|
|
|
|
lseek(fd, (off_t) 64, SEEK_SET);
|
|
|
|
|
offset = (ssize_t) 64;
|
|
|
|
|
|
|
|
|
|
//TODO this can (must) be optimizied by reading to a longer buffer
|
|
|
|
|
while ( (len = read(fd, buf, 4) ) == 4 ) {
|
|
|
|
|
checksum += iso_read_lsb(buf, 4);
|
|
|
|
|
while (offset < imgsize) {
|
|
|
|
|
checksum += iso_read_lsb(buf + offset, 4);
|
|
|
|
|
offset += 4;
|
|
|
|
|
}
|
|
|
|
|
if ( len != 0 ) {
|
|
|
|
|
/* error reading file, or file length not multiple of 4 */
|
|
|
|
|
//TODO what do do? exit or just continue?
|
|
|
|
|
fprintf(stderr, "Can't patch boot image %s\n", img->image->loc.path);
|
|
|
|
|
close(fd);
|
|
|
|
|
return;
|
|
|
|
|
if (offset != imgsize) {
|
|
|
|
|
/* file length not multiple of 4 */
|
|
|
|
|
iso_msg_warn(LIBISO_ISOLINUX_CANT_PATCH,
|
|
|
|
|
"Unexpected isolinux image length. Patch might not work.");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* fill boot info table */
|
|
|
|
|
iso_lsb(info.bi_pvd, 16, 4); //FIXME this should be changed when we implement ms
|
|
|
|
|
iso_lsb(info.bi_file, img->file->block, 4);
|
|
|
|
|
iso_lsb(info.bi_length, img->image->node.attrib.st_size, 4);
|
|
|
|
|
iso_lsb(info.bi_csum, checksum, 4);
|
|
|
|
|
|
|
|
|
|
/* patch file */
|
|
|
|
|
lseek(fd, (off_t) 8, SEEK_SET);
|
|
|
|
|
write(fd, &info, sizeof(info));
|
|
|
|
|
|
|
|
|
|
close(fd);
|
|
|
|
|
}
|
|
|
|
|
/* patch boot info table */
|
|
|
|
|
info = (struct boot_info_table*)(buf + 8);
|
|
|
|
|
memset(info, 0, sizeof(struct boot_info_table));
|
|
|
|
|
iso_lsb(info->bi_pvd, t->ms_block + 16, 4);
|
|
|
|
|
iso_lsb(info->bi_file, t->imgblock, 4);
|
|
|
|
|
iso_lsb(info->bi_length, imgsize, 4);
|
|
|
|
|
iso_lsb(info->bi_csum, checksum, 4);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
el_torito_patch_image_files(struct ecma119_write_target *t)
|
|
|
|
|
static void
|
|
|
|
|
write_boot_image(uint8_t *buf, struct ecma119_write_target *t)
|
|
|
|
|
{
|
|
|
|
|
size_t i;
|
|
|
|
|
struct el_torito_boot_catalog *cat = t->catalog;
|
|
|
|
|
assert(cat);
|
|
|
|
|
ssize_t imgsize;
|
|
|
|
|
struct el_torito_boot_image *image;
|
|
|
|
|
|
|
|
|
|
image = t->catalog->image;
|
|
|
|
|
imgsize= image->node->node.attrib.st_size;
|
|
|
|
|
|
|
|
|
|
/* copy image contents to memory buffer */
|
|
|
|
|
if (image->node->node.procedence == LIBISO_PREVIMG) {
|
|
|
|
|
int block, nblocks;
|
|
|
|
|
uint8_t *memloc;
|
|
|
|
|
assert(t->src);
|
|
|
|
|
|
|
|
|
|
block = 0;
|
|
|
|
|
memloc = buf;
|
|
|
|
|
nblocks = imgsize ? div_up(imgsize, 2048) : 1;
|
|
|
|
|
while (block < nblocks) {
|
|
|
|
|
if (t->src->read_block(t->src,
|
|
|
|
|
image->node->loc.block + block, memloc)) {
|
|
|
|
|
iso_msg_sorry(LIBISO_CANT_READ_IMG,
|
|
|
|
|
"Unable to read boot image from previous image.");
|
|
|
|
|
break; /* exit loop */
|
|
|
|
|
}
|
|
|
|
|
memloc += 2048;
|
|
|
|
|
++block;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
int fd;
|
|
|
|
|
ssize_t nread, tread;
|
|
|
|
|
uint8_t *memloc;
|
|
|
|
|
const char *path = image->node->loc.path;
|
|
|
|
|
memloc = buf;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < cat->nentries; ++i) {
|
|
|
|
|
struct el_torito_boot_image *img = cat->entries[i];
|
|
|
|
|
if ( img->patch_isolinux )
|
|
|
|
|
patch_boot_file(img);
|
|
|
|
|
fd = open(path, O_RDONLY);
|
|
|
|
|
if (fd == -1) {
|
|
|
|
|
iso_msg_sorry(LIBISO_CANT_READ_FILE,
|
|
|
|
|
"Can't open boot image file for reading. Skipping");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tread = 0;
|
|
|
|
|
while (tread < imgsize) {
|
|
|
|
|
nread = read(fd, memloc, t->block_size);
|
|
|
|
|
if (nread <= 0) {
|
|
|
|
|
iso_msg_sorry(LIBISO_CANT_READ_FILE,
|
|
|
|
|
"Problem reading boot image file. Skipping");
|
|
|
|
|
break; /* exit loop */
|
|
|
|
|
}
|
|
|
|
|
tread += nread;
|
|
|
|
|
memloc += nread;
|
|
|
|
|
}
|
|
|
|
|
close(fd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (image->isolinux) {
|
|
|
|
|
/* we need to patch the image */
|
|
|
|
|
patch_boot_image(buf, t, imgsize);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Write one section entry.
|
|
|
|
|
* Currently this is used for both default and other entries since we
|
|
|
|
|
* put selection criteria no 0 (no sel. criteria)
|
|
|
|
|
* Currently this is used only for default image (the only supported just now)
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
write_section_entry(uint8_t *buf, struct el_torito_boot_image *img)
|
|
|
|
|
write_section_entry(uint8_t *buf, struct ecma119_write_target *t)
|
|
|
|
|
{
|
|
|
|
|
struct el_torito_boot_image *img;
|
|
|
|
|
struct el_torito_section_entry *se =
|
|
|
|
|
(struct el_torito_section_entry*)buf;
|
|
|
|
|
|
|
|
|
|
img = t->catalog->image;
|
|
|
|
|
|
|
|
|
|
assert(img);
|
|
|
|
|
|
|
|
|
|
se->boot_indicator[0] = img->bootable ? 0x88 : 0x00;
|
|
|
|
|
se->boot_media_type[0] = img->type;
|
|
|
|
|
iso_lsb(se->load_seg, img->load_seg, 2);
|
|
|
|
|
se->system_type[0] = 0; //TODO need to get the partition type
|
|
|
|
|
se->system_type[0] = img->partition_type;
|
|
|
|
|
iso_lsb(se->sec_count, img->load_size, 2);
|
|
|
|
|
iso_lsb(se->block, img->file->block, 4);
|
|
|
|
|
iso_lsb(se->block, t->imgblock, 4);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Write El-Torito Boot Catalog
|
|
|
|
|
* Write El-Torito Boot Catalog plus image
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
write_catalog(struct ecma119_write_target *t, uint8_t *buf)
|
|
|
|
|
{
|
|
|
|
|
struct el_torito_boot_catalog *cat = t->catalog;
|
|
|
|
|
assert(cat);
|
|
|
|
|
assert(cat->nentries >= 1 && cat->nentries < 63);
|
|
|
|
|
assert(cat->image);
|
|
|
|
|
|
|
|
|
|
write_validation_entry(t, buf);
|
|
|
|
|
|
|
|
|
|
/* write default entry */
|
|
|
|
|
write_section_entry(buf + 32, cat->entries[0]);
|
|
|
|
|
write_section_entry(buf + 32, t);
|
|
|
|
|
|
|
|
|
|
//TODO write all images
|
|
|
|
|
write_boot_image(buf + 2048, t);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
@ -446,9 +593,27 @@ el_torito_wr_boot_vol_desc(struct ecma119_write_target *t, uint8_t *buf)
|
|
|
|
|
void
|
|
|
|
|
el_torito_wr_catalog(struct ecma119_write_target *t, uint8_t *buf)
|
|
|
|
|
{
|
|
|
|
|
off_t size;
|
|
|
|
|
off_t imgsize;
|
|
|
|
|
assert(t->catalog);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Note that when this is called, we need to write el-torito info to
|
|
|
|
|
* image. Note, however, that the image could come from a previous session
|
|
|
|
|
* and maybe we don't know its size
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
imgsize = t->catalog->image->node->node.attrib.st_size;
|
|
|
|
|
if (imgsize == 0) {
|
|
|
|
|
iso_msg_warn(LIBISO_EL_TORITO_BLIND_COPY,
|
|
|
|
|
"Can get boot image size, only one block will be copied");
|
|
|
|
|
imgsize = 2048;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
size = 2048 + div_up(imgsize, t->block_size);
|
|
|
|
|
|
|
|
|
|
ecma119_start_chunking(t,
|
|
|
|
|
write_catalog,
|
|
|
|
|
2048,
|
|
|
|
|
size,
|
|
|
|
|
buf);
|
|
|
|
|
}
|
|
|
|
|
|
Mario Danic
16 years ago