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;
} else if (is_vhd[0]) {
fclose(hdd_images[id].file);
MVHDGeom geometry;
MVHDGeom geometry = { 0 };
geometry.cyl = hdd[id].tracks;
geometry.heads = hdd[id].hpc;
geometry.spt = hdd[id].spt;
@@ -335,7 +335,7 @@ hdd_image_load(int id)
hdd_images[id].last_sector = (full_size >> 9LL) - 1;
if (hdd[id].vhd_blocksize || hdd[id].vhd_parent[0]) {
MVHDCreationOptions options;
MVHDCreationOptions options = { 0 };
retry_vhd:
options.block_size_in_sectors = hdd[id].vhd_blocksize;
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 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};
memset(bat_sect, 0xffffffff, sizeof bat_sect);
MVHDMeta* vhdm = NULL;

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

@@ -92,7 +92,7 @@ read_footer(MVHDMeta* vhdm)
static void
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);
(void) !fread(buffer, sizeof buffer, 1, vhdm->f);
@@ -438,17 +438,15 @@ mvhd_version_id(void)
MVHDAPI int
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;
}
mvhd_fseeko64(f, -MVHD_FOOTER_SIZE, SEEK_END);
(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 0;
}
@@ -457,13 +455,12 @@ mvhd_file_is_vhd(FILE* f)
MVHDAPI MVHDGeom
mvhd_calculate_geometry(uint64_t size)
{
MVHDGeom chs;
MVHDGeom chs = { 0 };
uint32_t ts = (uint32_t)(size / MVHD_SECTOR_SIZE);
uint32_t spt, heads, cyl, cth;
if (ts > 65535 * 16 * 255) {
if (ts > 65535 * 16 * 255)
ts = 65535 * 16 * 255;
}
if (ts >= 65535 * 16 * 63) {
spt = 255;
@@ -473,9 +470,8 @@ mvhd_calculate_geometry(uint64_t size)
spt = 17;
cth = ts / spt;
heads = (cth + 1023) / 1024;
if (heads < 4) {
if (heads < 4)
heads = 4;
}
if (cth >= (heads * 1024) || heads > 16) {
spt = 31;
heads = 16;
@@ -500,7 +496,7 @@ mvhd_calculate_geometry(uint64_t size)
MVHDAPI MVHDMeta*
mvhd_open(const char* path, int readonly, int* err)
{
MVHDError open_err;
MVHDError open_err = { 0 };
MVHDMeta *vhdm = calloc(sizeof *vhdm, 1);
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
strcpy(vhdm->filename, path);
if (readonly) {
if (readonly)
vhdm->f = mvhd_fopen((const char*)vhdm->filename, "rb", err);
} else {
else
vhdm->f = mvhd_fopen((const char*)vhdm->filename, "rb+", err);
}
if (vhdm->f == NULL) {
/* note, mvhd_fopen sets err for us */
goto cleanup_vhdm;
@@ -567,14 +562,12 @@ mvhd_open(const char* path, int readonly, int* err)
vhdm->format_buffer.sector_count = 64;
if (vhdm->footer.disk_type == MVHD_TYPE_DIFF) {
char* par_path = get_diff_parent_path(vhdm, err);
if (par_path == NULL) {
if (par_path == NULL)
goto cleanup_format_buff;
}
uint32_t par_mod_ts = mvhd_file_mod_timestamp(par_path, err);
if (*err != 0) {
if (*err != 0)
goto cleanup_format_buff;
}
if (vhdm->sparse.par_timestamp != par_mod_ts) {
/* 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;
}
vhdm->parent = mvhd_open(par_path, true, err);
if (vhdm->parent == NULL) {
if (vhdm->parent == NULL)
goto cleanup_format_buff;
}
if (memcmp(vhdm->sparse.par_uuid, vhdm->parent->footer.uuid, sizeof vhdm->sparse.par_uuid) != 0) {
*err = MVHD_ERR_INVALID_PAR_UUID;
@@ -629,9 +621,8 @@ mvhd_close(MVHDMeta* vhdm)
if (vhdm == NULL)
return;
if (vhdm->parent != NULL) {
if (vhdm->parent != NULL)
mvhd_close(vhdm->parent);
}
fclose(vhdm->f);
@@ -655,7 +646,7 @@ mvhd_close(MVHDMeta* vhdm)
MVHDAPI int
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) {
*err = MVHD_ERR_INVALID_PARAMS;

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

@@ -46,7 +46,6 @@
#include "minivhd.h"
#include "internal.h"
/*
* The following bit array macros adapted from:
*
@@ -56,7 +55,6 @@
#define VHD_CLEARBIT(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
*
@@ -68,29 +66,26 @@
* \param [out] trunc_sectors The number of sectors truncated if transfer_sectors < num_sectors
*/
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;
*trunc_sect = 0;
if ((total_sectors - offset) < (uint32_t)*transfer_sect) {
if ((total_sectors - offset) < ((uint32_t) *transfer_sect)) {
*transfer_sect = total_sectors - offset;
*trunc_sect = num_sectors - *transfer_sect;
}
}
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};
for (int i = 0; i < sector_count; i++) {
for (int i = 0; i < sector_count; i++)
fwrite(zero_bytes, sizeof zero_bytes, 1, f);
}
}
/**
* \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
*/
static void
read_sect_bitmap(MVHDMeta* vhdm, int blk)
read_sect_bitmap(MVHDMeta *vhdm, int blk)
{
if (vhdm->block_offset[blk] != MVHD_SPARSE_BLK) {
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);
} else {
} else
memset(vhdm->bitmap.curr_bitmap, 0, vhdm->bitmap.sector_count * MVHD_SECTOR_SIZE);
}
vhdm->bitmap.curr_block = blk;
}
/**
* \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
*
@@ -137,7 +129,7 @@ write_curr_sect_bitmap(MVHDMeta* vhdm)
* \param [in] blk The block for which to write the offset for
*/
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);
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);
}
/**
* \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
*/
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 */
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);
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 */
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;
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);
}
abs_offset += padding_amount;
}
@@ -204,37 +194,39 @@ create_block(MVHDMeta* vhdm, int blk)
write_bat_entry(vhdm, blk);
}
int
mvhd_fixed_read(MVHDMeta* vhdm, uint32_t offset, int num_sectors, void* out_buff) {
int64_t addr;
int transfer_sectors, truncated_sectors;
mvhd_fixed_read(MVHDMeta *vhdm, uint32_t offset, int num_sectors, void *out_buff) {
int64_t addr = 0ULL;
int transfer_sectors = 0;
int truncated_sectors = 0;
uint32_t total_sectors = (uint32_t)(vhdm->footer.curr_sz / MVHD_SECTOR_SIZE);
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);
(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;
}
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);
check_sectors(offset, num_sectors, total_sectors, &transfer_sectors, &truncated_sectors);
uint8_t* buff = (uint8_t*)out_buff;
int64_t addr;
uint32_t s, ls;
int blk, prev_blk, sib;
int64_t addr = 0ULL;
uint32_t s = 0;
uint32_t ls = 0;
int blk = 0;
int prev_blk = -1;
int sib = 0;
ls = offset + transfer_sectors;
prev_blk = -1;
for (s = offset; s < ls; s++) {
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);
mvhd_fseeko64(vhdm->f, (uint64_t)sib * MVHD_SECTOR_SIZE, SEEK_CUR);
} 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);
}
}
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);
} else {
else {
memset(buff, 0, MVHD_SECTOR_SIZE);
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;
}
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);
check_sectors(offset, num_sectors, total_sectors, &transfer_sectors, &truncated_sectors);
uint8_t* buff = (uint8_t*)out_buff;
MVHDMeta* curr_vhdm = vhdm;
uint32_t s, ls;
int blk, sib;
uint8_t *buff = (uint8_t*)out_buff;
MVHDMeta *curr_vhdm = vhdm;
uint32_t s = 0;
uint32_t ls = 0;
int blk = 0;
int sib = 0;
ls = offset + transfer_sectors;
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,
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);
} else {
else
mvhd_fixed_read(curr_vhdm, s, 1, buff);
}
curr_vhdm = vhdm;
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;
}
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;
int transfer_sectors, truncated_sectors;
int64_t addr = 0ULL;
int transfer_sectors = 0;
int truncated_sectors = 0;
uint32_t total_sectors = (uint32_t)(vhdm->footer.curr_sz / MVHD_SECTOR_SIZE);
check_sectors(offset, num_sectors, total_sectors, &transfer_sectors, &truncated_sectors);
addr = (int64_t)offset * MVHD_SECTOR_SIZE;
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;
}
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);
check_sectors(offset, num_sectors, total_sectors, &transfer_sectors, &truncated_sectors);
uint8_t* buff = (uint8_t*)in_buff;
int64_t addr;
uint32_t s, ls;
int blk, prev_blk, sib;
uint8_t* buff = (uint8_t *) in_buff;
int64_t addr = 0ULL;
uint32_t s = 0;
uint32_t ls = 0;
int blk = 0;
int prev_blk = -1;
int sib = 0;
ls = offset + transfer_sectors;
prev_blk = -1;
for (s = offset; s < ls; s++) {
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);
mvhd_fseeko64(vhdm->f, (uint64_t)sib * MVHD_SECTOR_SIZE, SEEK_CUR);
} 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);
}
prev_blk = blk;
@@ -374,14 +372,13 @@ mvhd_sparse_diff_write(MVHDMeta* vhdm, uint32_t offset, int num_sectors, void* i
return truncated_sectors;
}
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)offset;
(void)num_sectors;
(void)in_buff;
(void) vhdm;
(void) offset;
(void) num_sectors;
(void) in_buff;
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;
#ifdef _WIN32
struct _stat file_stat;
struct _stat file_stat = { 0 };
size_t path_len = strlen(path);
mvhd_utf16 new_path[260] = {0};
int new_path_len = (sizeof new_path) - 2;
@@ -485,7 +485,7 @@ mvhd_file_mod_timestamp(const char* path, int *err)
return 0;
}
#else
struct stat file_stat;
struct stat file_stat = { 0 };
int stat_res = stat(path, &file_stat);
if (stat_res != 0) {