80486DX2-66/86Box-fork
1
0
Fork 0
Code Issues Pull Requests Activity

MiniVHD: Some initialization sanitizations.

Browse Source
This commit is contained in:
OBattler
2024-03-08 22:37:18 +01:00
parent cdd24b2ee8
commit 01d066ce4c
5 changed files with 85 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/disk/hdd_image.c
View File

@@ -327,7 +327,7 @@ hdd_image_load(int id)
hdd_images[id].type = HDD_IMAGE_HDX; hdd_images[id].type = HDD_IMAGE_HDX;
} else if (is_vhd[0]) { } else if (is_vhd[0]) {
fclose(hdd_images[id].file); fclose(hdd_images[id].file);
MVHDGeom geometry; MVHDGeom geometry = { 0 };
geometry.cyl = hdd[id].tracks; geometry.cyl = hdd[id].tracks;
geometry.heads = hdd[id].hpc; geometry.heads = hdd[id].hpc;
geometry.spt = hdd[id].spt; geometry.spt = hdd[id].spt;
@@ -335,7 +335,7 @@ hdd_image_load(int id)
hdd_images[id].last_sector = (full_size >> 9LL) - 1; hdd_images[id].last_sector = (full_size >> 9LL) - 1;
if (hdd[id].vhd_blocksize || hdd[id].vhd_parent[0]) { if (hdd[id].vhd_blocksize || hdd[id].vhd_parent[0]) {
MVHDCreationOptions options; MVHDCreationOptions options = { 0 };
retry_vhd: retry_vhd:
options.block_size_in_sectors = hdd[id].vhd_blocksize; options.block_size_in_sectors = hdd[id].vhd_blocksize;
options.path = fn; options.path = fn;

2
src/disk/minivhd/create.c
View File

@@ -315,7 +315,7 @@ create_sparse_diff(const char* path, const char* par_path, uint64_t size_in_byte
{ {
uint8_t footer_buff[MVHD_FOOTER_SIZE] = {0}; uint8_t footer_buff[MVHD_FOOTER_SIZE] = {0};
uint8_t sparse_buff[MVHD_SPARSE_SIZE] = {0}; uint8_t sparse_buff[MVHD_SPARSE_SIZE] = {0};
uint8_t bat_sect[MVHD_SECTOR_SIZE]; uint8_t bat_sect[MVHD_SECTOR_SIZE] = {0};
MVHDGeom par_geom = {0}; MVHDGeom par_geom = {0};
memset(bat_sect, 0xffffffff, sizeof bat_sect); memset(bat_sect, 0xffffffff, sizeof bat_sect);
MVHDMeta* vhdm = NULL; MVHDMeta* vhdm = NULL;

39
src/disk/minivhd/manage.c
View File

@@ -92,7 +92,7 @@ read_footer(MVHDMeta* vhdm)
static void static void
read_sparse_header(MVHDMeta* vhdm) read_sparse_header(MVHDMeta* vhdm)
{ {
uint8_t buffer[MVHD_SPARSE_SIZE]; uint8_t buffer[MVHD_SPARSE_SIZE] = { 0 };
mvhd_fseeko64(vhdm->f, vhdm->footer.data_offset, SEEK_SET); mvhd_fseeko64(vhdm->f, vhdm->footer.data_offset, SEEK_SET);
(void) !fread(buffer, sizeof buffer, 1, vhdm->f); (void) !fread(buffer, sizeof buffer, 1, vhdm->f);
@@ -438,17 +438,15 @@ mvhd_version_id(void)
MVHDAPI int MVHDAPI int
mvhd_file_is_vhd(FILE* f) mvhd_file_is_vhd(FILE* f)
{ {
uint8_t con_str[8]; uint8_t con_str[8] = { 0 };
if (f == NULL) { if (f == NULL)
return 0; return 0;
}
mvhd_fseeko64(f, -MVHD_FOOTER_SIZE, SEEK_END); mvhd_fseeko64(f, -MVHD_FOOTER_SIZE, SEEK_END);
(void) !fread(con_str, sizeof con_str, 1, f); (void) !fread(con_str, sizeof con_str, 1, f);
if (mvhd_is_conectix_str(con_str)) { if (mvhd_is_conectix_str(con_str))
return 1; return 1;
}
return 0; return 0;
} }
@@ -457,13 +455,12 @@ mvhd_file_is_vhd(FILE* f)
MVHDAPI MVHDGeom MVHDAPI MVHDGeom
mvhd_calculate_geometry(uint64_t size) mvhd_calculate_geometry(uint64_t size)
{ {
MVHDGeom chs; MVHDGeom chs = { 0 };
uint32_t ts = (uint32_t)(size / MVHD_SECTOR_SIZE); uint32_t ts = (uint32_t)(size / MVHD_SECTOR_SIZE);
uint32_t spt, heads, cyl, cth; uint32_t spt, heads, cyl, cth;
if (ts > 65535 * 16 * 255) { if (ts > 65535 * 16 * 255)
ts = 65535 * 16 * 255; ts = 65535 * 16 * 255;
}
if (ts >= 65535 * 16 * 63) { if (ts >= 65535 * 16 * 63) {
spt = 255; spt = 255;
@@ -473,9 +470,8 @@ mvhd_calculate_geometry(uint64_t size)
spt = 17; spt = 17;
cth = ts / spt; cth = ts / spt;
heads = (cth + 1023) / 1024; heads = (cth + 1023) / 1024;
if (heads < 4) { if (heads < 4)
heads = 4; heads = 4;
}
if (cth >= (heads * 1024) || heads > 16) { if (cth >= (heads * 1024) || heads > 16) {
spt = 31; spt = 31;
heads = 16; heads = 16;
@@ -500,7 +496,7 @@ mvhd_calculate_geometry(uint64_t size)
MVHDAPI MVHDMeta* MVHDAPI MVHDMeta*
mvhd_open(const char* path, int readonly, int* err) mvhd_open(const char* path, int readonly, int* err)
{ {
MVHDError open_err; MVHDError open_err = { 0 };
MVHDMeta *vhdm = calloc(sizeof *vhdm, 1); MVHDMeta *vhdm = calloc(sizeof *vhdm, 1);
if (vhdm == NULL) { if (vhdm == NULL) {
@@ -516,11 +512,10 @@ mvhd_open(const char* path, int readonly, int* err)
//This is safe, as we've just checked for potential overflow above //This is safe, as we've just checked for potential overflow above
strcpy(vhdm->filename, path); strcpy(vhdm->filename, path);
if (readonly) { if (readonly)
vhdm->f = mvhd_fopen((const char*)vhdm->filename, "rb", err); vhdm->f = mvhd_fopen((const char*)vhdm->filename, "rb", err);
} else { else
vhdm->f = mvhd_fopen((const char*)vhdm->filename, "rb+", err); vhdm->f = mvhd_fopen((const char*)vhdm->filename, "rb+", err);
}
if (vhdm->f == NULL) { if (vhdm->f == NULL) {
/* note, mvhd_fopen sets err for us */ /* note, mvhd_fopen sets err for us */
goto cleanup_vhdm; goto cleanup_vhdm;
@@ -567,14 +562,12 @@ mvhd_open(const char* path, int readonly, int* err)
vhdm->format_buffer.sector_count = 64; vhdm->format_buffer.sector_count = 64;
if (vhdm->footer.disk_type == MVHD_TYPE_DIFF) { if (vhdm->footer.disk_type == MVHD_TYPE_DIFF) {
char* par_path = get_diff_parent_path(vhdm, err); char* par_path = get_diff_parent_path(vhdm, err);
if (par_path == NULL) { if (par_path == NULL)
goto cleanup_format_buff; goto cleanup_format_buff;
}
uint32_t par_mod_ts = mvhd_file_mod_timestamp(par_path, err); uint32_t par_mod_ts = mvhd_file_mod_timestamp(par_path, err);
if (*err != 0) { if (*err != 0)
goto cleanup_format_buff; goto cleanup_format_buff;
}
if (vhdm->sparse.par_timestamp != par_mod_ts) { if (vhdm->sparse.par_timestamp != par_mod_ts) {
/* The last-modified timestamp is to fragile to make this a fatal error. /* The last-modified timestamp is to fragile to make this a fatal error.
@@ -582,9 +575,8 @@ mvhd_open(const char* path, int readonly, int* err)
*err = MVHD_ERR_TIMESTAMP; *err = MVHD_ERR_TIMESTAMP;
} }
vhdm->parent = mvhd_open(par_path, true, err); vhdm->parent = mvhd_open(par_path, true, err);
if (vhdm->parent == NULL) { if (vhdm->parent == NULL)
goto cleanup_format_buff; goto cleanup_format_buff;
}
if (memcmp(vhdm->sparse.par_uuid, vhdm->parent->footer.uuid, sizeof vhdm->sparse.par_uuid) != 0) { if (memcmp(vhdm->sparse.par_uuid, vhdm->parent->footer.uuid, sizeof vhdm->sparse.par_uuid) != 0) {
*err = MVHD_ERR_INVALID_PAR_UUID; *err = MVHD_ERR_INVALID_PAR_UUID;
@@ -629,9 +621,8 @@ mvhd_close(MVHDMeta* vhdm)
if (vhdm == NULL) if (vhdm == NULL)
return; return;
if (vhdm->parent != NULL) { if (vhdm->parent != NULL)
mvhd_close(vhdm->parent); mvhd_close(vhdm->parent);
}
fclose(vhdm->f); fclose(vhdm->f);
@@ -655,7 +646,7 @@ mvhd_close(MVHDMeta* vhdm)
MVHDAPI int MVHDAPI int
mvhd_diff_update_par_timestamp(MVHDMeta* vhdm, int* err) mvhd_diff_update_par_timestamp(MVHDMeta* vhdm, int* err)
{ {
uint8_t sparse_buff[1024]; uint8_t sparse_buff[1024] = { 0 };
if (vhdm == NULL || err == NULL) { if (vhdm == NULL || err == NULL) {
*err = MVHD_ERR_INVALID_PARAMS; *err = MVHD_ERR_INVALID_PARAMS;

133
src/disk/minivhd/minivhd_io.c
View File

@@ -46,7 +46,6 @@
#include "minivhd.h" #include "minivhd.h"
#include "internal.h" #include "internal.h"
/* /*
* The following bit array macros adapted from: * The following bit array macros adapted from:
* *
@@ -56,7 +55,6 @@
#define VHD_CLEARBIT(A,k) ( A[(k>>3)] &= ~(0x80 >> (k&7)) ) #define VHD_CLEARBIT(A,k) ( A[(k>>3)] &= ~(0x80 >> (k&7)) )
#define VHD_TESTBIT(A,k) ( A[(k>>3)] & (0x80 >> (k&7)) ) #define VHD_TESTBIT(A,k) ( A[(k>>3)] & (0x80 >> (k&7)) )
/** /**
* \brief Check that we will not be overflowing buffers * \brief Check that we will not be overflowing buffers
* *
@@ -68,29 +66,26 @@
* \param [out] trunc_sectors The number of sectors truncated if transfer_sectors < num_sectors * \param [out] trunc_sectors The number of sectors truncated if transfer_sectors < num_sectors
*/ */
static inline void static inline void
check_sectors(uint32_t offset, int num_sectors, uint32_t total_sectors, int* transfer_sect, int* trunc_sect) check_sectors(uint32_t offset, int num_sectors, uint32_t total_sectors, int *transfer_sect, int *trunc_sect)
{ {
*transfer_sect = num_sectors; *transfer_sect = num_sectors;
*trunc_sect = 0; *trunc_sect = 0;
if ((total_sectors - offset) < (uint32_t)*transfer_sect) { if ((total_sectors - offset) < ((uint32_t) *transfer_sect)) {
*transfer_sect = total_sectors - offset; *transfer_sect = total_sectors - offset;
*trunc_sect = num_sectors - *transfer_sect; *trunc_sect = num_sectors - *transfer_sect;
} }
} }
void void
mvhd_write_empty_sectors(FILE* f, int sector_count) mvhd_write_empty_sectors(FILE *f, int sector_count)
{ {
uint8_t zero_bytes[MVHD_SECTOR_SIZE] = {0}; uint8_t zero_bytes[MVHD_SECTOR_SIZE] = {0};
for (int i = 0; i < sector_count; i++) { for (int i = 0; i < sector_count; i++)
fwrite(zero_bytes, sizeof zero_bytes, 1, f); fwrite(zero_bytes, sizeof zero_bytes, 1, f);
}
} }
/** /**
* \brief Read the sector bitmap for a block. * \brief Read the sector bitmap for a block.
* *
@@ -101,19 +96,17 @@ mvhd_write_empty_sectors(FILE* f, int sector_count)
* \param [in] blk The block for which to read the sector bitmap from * \param [in] blk The block for which to read the sector bitmap from
*/ */
static void static void
read_sect_bitmap(MVHDMeta* vhdm, int blk) read_sect_bitmap(MVHDMeta *vhdm, int blk)
{ {
if (vhdm->block_offset[blk] != MVHD_SPARSE_BLK) { if (vhdm->block_offset[blk] != MVHD_SPARSE_BLK) {
mvhd_fseeko64(vhdm->f, (uint64_t)vhdm->block_offset[blk] * MVHD_SECTOR_SIZE, SEEK_SET); mvhd_fseeko64(vhdm->f, (uint64_t)vhdm->block_offset[blk] * MVHD_SECTOR_SIZE, SEEK_SET);
(void) !fread(vhdm->bitmap.curr_bitmap, vhdm->bitmap.sector_count * MVHD_SECTOR_SIZE, 1, vhdm->f); (void) !fread(vhdm->bitmap.curr_bitmap, vhdm->bitmap.sector_count * MVHD_SECTOR_SIZE, 1, vhdm->f);
} else { } else
memset(vhdm->bitmap.curr_bitmap, 0, vhdm->bitmap.sector_count * MVHD_SECTOR_SIZE); memset(vhdm->bitmap.curr_bitmap, 0, vhdm->bitmap.sector_count * MVHD_SECTOR_SIZE);
}
vhdm->bitmap.curr_block = blk; vhdm->bitmap.curr_block = blk;
} }
/** /**
* \brief Write the current sector bitmap in memory to file * \brief Write the current sector bitmap in memory to file
* *
@@ -129,7 +122,6 @@ write_curr_sect_bitmap(MVHDMeta* vhdm)
} }
} }
/** /**
* \brief Write block offset from memory into file * \brief Write block offset from memory into file
* *
@@ -137,7 +129,7 @@ write_curr_sect_bitmap(MVHDMeta* vhdm)
* \param [in] blk The block for which to write the offset for * \param [in] blk The block for which to write the offset for
*/ */
static void static void
write_bat_entry(MVHDMeta* vhdm, int blk) write_bat_entry(MVHDMeta *vhdm, int blk)
{ {
uint64_t table_offset = vhdm->sparse.bat_offset + ((uint64_t)blk * sizeof *vhdm->block_offset); uint64_t table_offset = vhdm->sparse.bat_offset + ((uint64_t)blk * sizeof *vhdm->block_offset);
uint32_t offset = mvhd_to_be32(vhdm->block_offset[blk]); uint32_t offset = mvhd_to_be32(vhdm->block_offset[blk]);
@@ -146,7 +138,6 @@ write_bat_entry(MVHDMeta* vhdm, int blk)
fwrite(&offset, sizeof offset, 1, vhdm->f); fwrite(&offset, sizeof offset, 1, vhdm->f);
} }
/** /**
* \brief Create an empty block in a sparse or differencing VHD image * \brief Create an empty block in a sparse or differencing VHD image
* *
@@ -162,9 +153,9 @@ write_bat_entry(MVHDMeta* vhdm, int blk)
* \param [in] blk The block number to create * \param [in] blk The block number to create
*/ */
static void static void
create_block(MVHDMeta* vhdm, int blk) create_block(MVHDMeta *vhdm, int blk)
{ {
uint8_t footer[MVHD_FOOTER_SIZE]; uint8_t footer[MVHD_FOOTER_SIZE] = { 0 };
/* Seek to where the footer SHOULD be */ /* Seek to where the footer SHOULD be */
mvhd_fseeko64(vhdm->f, -MVHD_FOOTER_SIZE, SEEK_END); mvhd_fseeko64(vhdm->f, -MVHD_FOOTER_SIZE, SEEK_END);
@@ -179,13 +170,12 @@ create_block(MVHDMeta* vhdm, int blk)
} }
int64_t abs_offset = mvhd_ftello64(vhdm->f); int64_t abs_offset = mvhd_ftello64(vhdm->f);
if (abs_offset % MVHD_SECTOR_SIZE != 0) { if ((abs_offset % MVHD_SECTOR_SIZE) != 0) {
/* Yikes! We're supposed to be on a sector boundary. Add some padding */ /* Yikes! We're supposed to be on a sector boundary. Add some padding */
int64_t padding_amount = (int64_t)MVHD_SECTOR_SIZE - (abs_offset % MVHD_SECTOR_SIZE); int64_t padding_amount = ((int64_t) MVHD_SECTOR_SIZE) - (abs_offset % MVHD_SECTOR_SIZE);
uint8_t zero_byte = 0; uint8_t zero_byte = 0;
for (int i = 0; i < padding_amount; i++) { for (int i = 0; i < padding_amount; i++)
fwrite(&zero_byte, sizeof zero_byte, 1, vhdm->f); fwrite(&zero_byte, sizeof zero_byte, 1, vhdm->f);
}
abs_offset += padding_amount; abs_offset += padding_amount;
} }
@@ -204,37 +194,39 @@ create_block(MVHDMeta* vhdm, int blk)
write_bat_entry(vhdm, blk); write_bat_entry(vhdm, blk);
} }
int int
mvhd_fixed_read(MVHDMeta* vhdm, uint32_t offset, int num_sectors, void* out_buff) { mvhd_fixed_read(MVHDMeta *vhdm, uint32_t offset, int num_sectors, void *out_buff) {
int64_t addr; int64_t addr = 0ULL;
int transfer_sectors, truncated_sectors; int transfer_sectors = 0;
int truncated_sectors = 0;
uint32_t total_sectors = (uint32_t)(vhdm->footer.curr_sz / MVHD_SECTOR_SIZE); uint32_t total_sectors = (uint32_t)(vhdm->footer.curr_sz / MVHD_SECTOR_SIZE);
check_sectors(offset, num_sectors, total_sectors, &transfer_sectors, &truncated_sectors); check_sectors(offset, num_sectors, total_sectors, &transfer_sectors, &truncated_sectors);
addr = (int64_t)offset * MVHD_SECTOR_SIZE; addr = ((int64_t) offset) * MVHD_SECTOR_SIZE;
mvhd_fseeko64(vhdm->f, addr, SEEK_SET); mvhd_fseeko64(vhdm->f, addr, SEEK_SET);
(void) !fread(out_buff, transfer_sectors*MVHD_SECTOR_SIZE, 1, vhdm->f); (void) !fread(out_buff, transfer_sectors * MVHD_SECTOR_SIZE, 1, vhdm->f);
return truncated_sectors; return truncated_sectors;
} }
int int
mvhd_sparse_read(MVHDMeta* vhdm, uint32_t offset, int num_sectors, void* out_buff) mvhd_sparse_read(MVHDMeta *vhdm, uint32_t offset, int num_sectors, void *out_buff)
{ {
int transfer_sectors, truncated_sectors; int transfer_sectors = 0;
int truncated_sectors;
uint32_t total_sectors = (uint32_t)(vhdm->footer.curr_sz / MVHD_SECTOR_SIZE); uint32_t total_sectors = (uint32_t)(vhdm->footer.curr_sz / MVHD_SECTOR_SIZE);
check_sectors(offset, num_sectors, total_sectors, &transfer_sectors, &truncated_sectors); check_sectors(offset, num_sectors, total_sectors, &transfer_sectors, &truncated_sectors);
uint8_t* buff = (uint8_t*)out_buff; uint8_t* buff = (uint8_t*)out_buff;
int64_t addr; int64_t addr = 0ULL;
uint32_t s, ls; uint32_t s = 0;
int blk, prev_blk, sib; uint32_t ls = 0;
int blk = 0;
int prev_blk = -1;
int sib = 0;
ls = offset + transfer_sectors; ls = offset + transfer_sectors;
prev_blk = -1;
for (s = offset; s < ls; s++) { for (s = offset; s < ls; s++) {
blk = s / vhdm->sect_per_block; blk = s / vhdm->sect_per_block;
@@ -245,14 +237,15 @@ mvhd_sparse_read(MVHDMeta* vhdm, uint32_t offset, int num_sectors, void* out_buf
read_sect_bitmap(vhdm, blk); read_sect_bitmap(vhdm, blk);
mvhd_fseeko64(vhdm->f, (uint64_t)sib * MVHD_SECTOR_SIZE, SEEK_CUR); mvhd_fseeko64(vhdm->f, (uint64_t)sib * MVHD_SECTOR_SIZE, SEEK_CUR);
} else { } else {
addr = ((int64_t)vhdm->block_offset[blk] + vhdm->bitmap.sector_count + sib) * MVHD_SECTOR_SIZE; addr = (((int64_t) vhdm->block_offset[blk]) + vhdm->bitmap.sector_count + sib) *
MVHD_SECTOR_SIZE;
mvhd_fseeko64(vhdm->f, addr, SEEK_SET); mvhd_fseeko64(vhdm->f, addr, SEEK_SET);
} }
} }
if (VHD_TESTBIT(vhdm->bitmap.curr_bitmap, sib)) { if (VHD_TESTBIT(vhdm->bitmap.curr_bitmap, sib))
(void) !fread(buff, MVHD_SECTOR_SIZE, 1, vhdm->f); (void) !fread(buff, MVHD_SECTOR_SIZE, 1, vhdm->f);
} else { else {
memset(buff, 0, MVHD_SECTOR_SIZE); memset(buff, 0, MVHD_SECTOR_SIZE);
mvhd_fseeko64(vhdm->f, MVHD_SECTOR_SIZE, SEEK_CUR); mvhd_fseeko64(vhdm->f, MVHD_SECTOR_SIZE, SEEK_CUR);
} }
@@ -262,19 +255,21 @@ mvhd_sparse_read(MVHDMeta* vhdm, uint32_t offset, int num_sectors, void* out_buf
return truncated_sectors; return truncated_sectors;
} }
int int
mvhd_diff_read(MVHDMeta* vhdm, uint32_t offset, int num_sectors, void* out_buff) mvhd_diff_read(MVHDMeta *vhdm, uint32_t offset, int num_sectors, void *out_buff)
{ {
int transfer_sectors, truncated_sectors; int transfer_sectors = 0;
int truncated_sectors = 0;
uint32_t total_sectors = (uint32_t)(vhdm->footer.curr_sz / MVHD_SECTOR_SIZE); uint32_t total_sectors = (uint32_t)(vhdm->footer.curr_sz / MVHD_SECTOR_SIZE);
check_sectors(offset, num_sectors, total_sectors, &transfer_sectors, &truncated_sectors); check_sectors(offset, num_sectors, total_sectors, &transfer_sectors, &truncated_sectors);
uint8_t* buff = (uint8_t*)out_buff; uint8_t *buff = (uint8_t*)out_buff;
MVHDMeta* curr_vhdm = vhdm; MVHDMeta *curr_vhdm = vhdm;
uint32_t s, ls; uint32_t s = 0;
int blk, sib; uint32_t ls = 0;
int blk = 0;
int sib = 0;
ls = offset + transfer_sectors; ls = offset + transfer_sectors;
for (s = offset; s < ls; s++) { for (s = offset; s < ls; s++) {
@@ -291,11 +286,11 @@ mvhd_diff_read(MVHDMeta* vhdm, uint32_t offset, int num_sectors, void* out_buff)
/* We handle actual sector reading using the fixed or sparse functions, /* We handle actual sector reading using the fixed or sparse functions,
as a differencing VHD is also a sparse VHD */ as a differencing VHD is also a sparse VHD */
if (curr_vhdm->footer.disk_type == MVHD_TYPE_DIFF || curr_vhdm->footer.disk_type == MVHD_TYPE_DYNAMIC) { if ((curr_vhdm->footer.disk_type == MVHD_TYPE_DIFF) ||
(curr_vhdm->footer.disk_type == MVHD_TYPE_DYNAMIC))
mvhd_sparse_read(curr_vhdm, s, 1, buff); mvhd_sparse_read(curr_vhdm, s, 1, buff);
} else { else
mvhd_fixed_read(curr_vhdm, s, 1, buff); mvhd_fixed_read(curr_vhdm, s, 1, buff);
}
curr_vhdm = vhdm; curr_vhdm = vhdm;
buff += MVHD_SECTOR_SIZE; buff += MVHD_SECTOR_SIZE;
@@ -304,38 +299,40 @@ mvhd_diff_read(MVHDMeta* vhdm, uint32_t offset, int num_sectors, void* out_buff)
return truncated_sectors; return truncated_sectors;
} }
int int
mvhd_fixed_write(MVHDMeta* vhdm, uint32_t offset, int num_sectors, void* in_buff) mvhd_fixed_write(MVHDMeta *vhdm, uint32_t offset, int num_sectors, void *in_buff)
{ {
int64_t addr; int64_t addr = 0ULL;
int transfer_sectors, truncated_sectors; int transfer_sectors = 0;
int truncated_sectors = 0;
uint32_t total_sectors = (uint32_t)(vhdm->footer.curr_sz / MVHD_SECTOR_SIZE); uint32_t total_sectors = (uint32_t)(vhdm->footer.curr_sz / MVHD_SECTOR_SIZE);
check_sectors(offset, num_sectors, total_sectors, &transfer_sectors, &truncated_sectors); check_sectors(offset, num_sectors, total_sectors, &transfer_sectors, &truncated_sectors);
addr = (int64_t)offset * MVHD_SECTOR_SIZE; addr = (int64_t)offset * MVHD_SECTOR_SIZE;
mvhd_fseeko64(vhdm->f, addr, SEEK_SET); mvhd_fseeko64(vhdm->f, addr, SEEK_SET);
fwrite(in_buff, transfer_sectors*MVHD_SECTOR_SIZE, 1, vhdm->f); fwrite(in_buff, transfer_sectors * MVHD_SECTOR_SIZE, 1, vhdm->f);
return truncated_sectors; return truncated_sectors;
} }
int int
mvhd_sparse_diff_write(MVHDMeta* vhdm, uint32_t offset, int num_sectors, void* in_buff) mvhd_sparse_diff_write(MVHDMeta *vhdm, uint32_t offset, int num_sectors, void *in_buff)
{ {
int transfer_sectors, truncated_sectors; int transfer_sectors = 0;
int truncated_sectors = 0;
uint32_t total_sectors = (uint32_t)(vhdm->footer.curr_sz / MVHD_SECTOR_SIZE); uint32_t total_sectors = (uint32_t)(vhdm->footer.curr_sz / MVHD_SECTOR_SIZE);
check_sectors(offset, num_sectors, total_sectors, &transfer_sectors, &truncated_sectors); check_sectors(offset, num_sectors, total_sectors, &transfer_sectors, &truncated_sectors);
uint8_t* buff = (uint8_t*)in_buff; uint8_t* buff = (uint8_t *) in_buff;
int64_t addr; int64_t addr = 0ULL;
uint32_t s, ls; uint32_t s = 0;
int blk, prev_blk, sib; uint32_t ls = 0;
int blk = 0;
int prev_blk = -1;
int sib = 0;
ls = offset + transfer_sectors; ls = offset + transfer_sectors;
prev_blk = -1;
for (s = offset; s < ls; s++) { for (s = offset; s < ls; s++) {
blk = s / vhdm->sect_per_block; blk = s / vhdm->sect_per_block;
@@ -357,7 +354,8 @@ mvhd_sparse_diff_write(MVHDMeta* vhdm, uint32_t offset, int num_sectors, void* i
read_sect_bitmap(vhdm, blk); read_sect_bitmap(vhdm, blk);
mvhd_fseeko64(vhdm->f, (uint64_t)sib * MVHD_SECTOR_SIZE, SEEK_CUR); mvhd_fseeko64(vhdm->f, (uint64_t)sib * MVHD_SECTOR_SIZE, SEEK_CUR);
} else { } else {
addr = ((int64_t)vhdm->block_offset[blk] + vhdm->bitmap.sector_count + sib) * MVHD_SECTOR_SIZE; addr = (((int64_t) vhdm->block_offset[blk]) + vhdm->bitmap.sector_count + sib) *
MVHD_SECTOR_SIZE;
mvhd_fseeko64(vhdm->f, addr, SEEK_SET); mvhd_fseeko64(vhdm->f, addr, SEEK_SET);
} }
prev_blk = blk; prev_blk = blk;
@@ -374,14 +372,13 @@ mvhd_sparse_diff_write(MVHDMeta* vhdm, uint32_t offset, int num_sectors, void* i
return truncated_sectors; return truncated_sectors;
} }
int int
mvhd_noop_write(MVHDMeta* vhdm, uint32_t offset, int num_sectors, void* in_buff) mvhd_noop_write(MVHDMeta *vhdm, uint32_t offset, int num_sectors, void *in_buff)
{ {
(void)vhdm; (void) vhdm;
(void)offset; (void) offset;
(void)num_sectors; (void) num_sectors;
(void)in_buff; (void) in_buff;
return 0; return 0;
} }

4
src/disk/minivhd/minivhd_util.c
View File

@@ -462,7 +462,7 @@ mvhd_file_mod_timestamp(const char* path, int *err)
{ {
*err = 0; *err = 0;
#ifdef _WIN32 #ifdef _WIN32
struct _stat file_stat; struct _stat file_stat = { 0 };
size_t path_len = strlen(path); size_t path_len = strlen(path);
mvhd_utf16 new_path[260] = {0}; mvhd_utf16 new_path[260] = {0};
int new_path_len = (sizeof new_path) - 2; int new_path_len = (sizeof new_path) - 2;
@@ -485,7 +485,7 @@ mvhd_file_mod_timestamp(const char* path, int *err)
return 0; return 0;
} }
#else #else
struct stat file_stat; struct stat file_stat = { 0 };
int stat_res = stat(path, &file_stat); int stat_res = stat(path, &file_stat);
if (stat_res != 0) { if (stat_res != 0) {