/*
imghd_open()
Open stream as a MAME HD image
*/
imgtoolerr_t imghd_open(imgtool_stream *stream, struct mess_hard_disk_file *hard_disk)
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
char encoded_image_ref[encoded_image_ref_max_len];
chd_interface interface_save;
hard_disk->hard_disk = NULL;
hard_disk->chd = NULL;
encode_image_ref(stream, encoded_image_ref);
/* use our CHD interface */
chd_save_interface(&interface_save);
chd_set_interface(&imgtool_chd_interface);
hard_disk->chd = chd_open(encoded_image_ref, !stream_isreadonly(stream), NULL);
if (!hard_disk->chd)
{
err = imghd_chd_getlasterror();
goto done;
}
hard_disk->hard_disk = hard_disk_open(hard_disk->chd);
if (!hard_disk->hard_disk)
{
err = IMGTOOLERR_UNEXPECTED;
goto done;
}
hard_disk->stream = stream;
done:
if (err)
imghd_close(hard_disk);
chd_set_interface(&interface_save);
return err;
}
/*
imghd_get_header()
Return pointer to the header of MAME HD image
*/
const hard_disk_info *imghd_get_header(struct mess_hard_disk_file *disk)
{
chd_interface interface_save;
const hard_disk_info *reply;
chd_save_interface(&interface_save);
chd_set_interface(&imgtool_chd_interface);
reply = hard_disk_get_info(disk->hard_disk);
chd_set_interface(&interface_save);
return reply;
}
/*
imghd_write()
Write sector(s) from MAME HD image
*/
imgtoolerr_t imghd_write(struct mess_hard_disk_file *disk, UINT32 lbasector, const void *buffer)
{
chd_interface interface_save;
UINT32 reply;
chd_save_interface(&interface_save);
chd_set_interface(&imgtool_chd_interface);
reply = hard_disk_write(disk->hard_disk, lbasector, buffer);
chd_set_interface(&interface_save);
return reply ? IMGTOOLERR_SUCCESS : map_chd_error(reply);
}
/*
imghd_read()
Read sector(s) from MAME HD image
*/
imgtoolerr_t imghd_read(struct mess_hard_disk_file *disk, UINT32 lbasector, UINT32 numsectors, void *buffer)
{
chd_interface interface_save;
UINT32 reply;
chd_save_interface(&interface_save);
chd_set_interface(&imgtool_chd_interface);
reply = hard_disk_read(disk->hard_disk, lbasector, numsectors, buffer);
chd_set_interface(&interface_save);
return reply ? IMGTOOLERR_SUCCESS : imghd_chd_getlasterror();
}
/*
imghd_close()
Close MAME HD image
*/
void imghd_close(struct mess_hard_disk_file *disk)
{
chd_interface interface_save;
chd_save_interface(&interface_save);
chd_set_interface(&imgtool_chd_interface);
if (disk->hard_disk)
{
hard_disk_close(disk->hard_disk);
disk->hard_disk = NULL;
}
if (disk->chd)
{
chd_close(disk->chd);
disk->chd = NULL;
}
chd_set_interface(&interface_save);
}
int device_init_mess_hd(mess_image *image)
{
struct mess_hd *hd;
hd = image_alloctag(image, MESSHDTAG, sizeof(struct mess_hd));
if (!hd)
return INIT_FAIL;
hd->hard_disk_handle = NULL;
chd_set_interface(&mess_hard_disk_interface);
return INIT_PASS;
}
int device_init_mess_cd(mess_image *image)
{
struct mess_cd *cd;
cd = image_alloctag(image, MESSCDTAG, sizeof(struct mess_cd));
if (!cd)
return INIT_FAIL;
cd->cdrom_handle = NULL;
chd_set_interface(&mess_cdrom_interface);
return INIT_PASS;
}
/*
imghd_open()
Open stream as a MAME HD image
*/
imgtoolerr_t imghd_open(imgtool_stream *stream, struct mess_hard_disk_file *hard_disk)
{
chd_error chderr;
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
char encoded_image_ref[encoded_image_ref_max_len];
chd_interface interface_save;
hard_disk->hard_disk = NULL;
hard_disk->chd = NULL;
encode_image_ref(stream, encoded_image_ref);
/* use our CHD interface */
chd_save_interface(&interface_save);
chd_set_interface(&imgtool_chd_interface);
chderr = chd_open(encoded_image_ref, stream_isreadonly(stream) ? CHD_OPEN_READ : CHD_OPEN_READWRITE, NULL, &hard_disk->chd);
if (chderr)
{
err = map_chd_error(chderr);
goto done;
}
hard_disk->hard_disk = hard_disk_open(hard_disk->chd);
if (!hard_disk->hard_disk)
{
err = IMGTOOLERR_UNEXPECTED;
goto done;
}
hard_disk->stream = stream;
done:
if (err)
imghd_close(hard_disk);
chd_set_interface(&interface_save);
return err;
}
/* Fills in an audit record for each rom in the romset. Sets 'audit' to
point to the list of audit records. Returns total number of roms
in the romset (same as number of audit records), 0 if romset missing. */
int audit_roms (int game, audit_record **audit)
{
const rom_entry *region, *rom, *chunk;
const char *name;
const game_driver *gamedrv;
const game_driver *clone_of;
int count = 0;
audit_record *aud;
int err;
if (!audit_records)
{
audit_records = (audit_record *)malloc (AUD_MAX_ROMS * sizeof (audit_record));
// Make sure the memory is cleared - it's needed by the hashing
// engine
memset(audit_records, 0, AUD_MAX_ROMS * sizeof(audit_record));
}
if (audit_records)
*audit = aud = audit_records;
else
return 0;
gamedrv = drivers[game];
clone_of = driver_get_clone(gamedrv);
if (!gamedrv->rom) return -1;
/* check for existence of romset */
if (!mame_faccess (gamedrv->name, FILETYPE_ROM))
{
/* if the game is a clone, check for parent */
if (clone_of == NULL || (clone_of->flags & NOT_A_DRIVER) ||
!mame_faccess(clone_of->name,FILETYPE_ROM))
return 0;
}
for (region = rom_first_region(gamedrv); region; region = rom_next_region(region))
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
if (ROMREGION_ISROMDATA(region))
{
const game_driver *drv;
name = ROM_GETNAME(rom);
strcpy (aud->rom, name);
aud->explength = 0;
aud->length = 0;
aud->exphash = ROM_GETHASHDATA(rom);
/* Copy into the variable we pass to the functions
to support load-by-checksum */
hash_data_copy(aud->hash, aud->exphash);
count++;
/* obtain hash checksums and length of ROM file */
drv = gamedrv;
do
{
err = mame_fchecksum(drv->name, name, &aud->length, aud->hash);
drv = driver_get_clone(drv);
} while (err && drv);
/* spin through ROM_CONTINUEs, totaling length */
for (chunk = rom_first_chunk(rom); chunk; chunk = rom_next_chunk(chunk))
aud->explength += ROM_GETLENGTH(chunk);
if (err)
{
if (hash_data_has_info(aud->exphash, HASH_INFO_NO_DUMP))
{
/* not found but it's not good anyway */
aud->status = AUD_NOT_AVAILABLE;
}
else if (ROM_ISOPTIONAL(rom))
{
/* optional ROM not found */
aud->status = AUD_OPTIONAL_ROM_NOT_FOUND;
}
else
{
/* not found */
aud->status = AUD_ROM_NOT_FOUND;
drv = clone_of;
/* If missing ROM is also present in a parent set, indicate that */
while (drv)
{
if (audit_is_rom_used (drv, aud->exphash))
{
if (drv->flags & NOT_A_DRIVER)
{
aud->status = AUD_ROM_NOT_FOUND_BIOS;
break;
}
else
aud->status = AUD_ROM_NOT_FOUND_PARENT;
}
// Walk up the inheritance list. If this ROM is a clone of a set which
// contains a BIOS that is missing, we can correctly mark it as
// such.
drv = driver_get_clone(drv);
}
}
}
/* all cases below assume the ROM was at least found */
else if (aud->explength != aud->length)
aud->status = AUD_LENGTH_MISMATCH;
else if (hash_data_has_info(aud->exphash, HASH_INFO_NO_DUMP))
aud->status = AUD_ROM_NEED_DUMP; /* new case - found but not known to be dumped */
else if (!hash_data_is_equal(aud->exphash, aud->hash, 0))
{
/* non-matching hash */
aud->status = AUD_BAD_CHECKSUM;
}
else
{
/* matching hash */
if (hash_data_has_info(aud->exphash, HASH_INFO_BAD_DUMP))
aud->status = AUD_ROM_NEED_REDUMP;
else
aud->status = AUD_ROM_GOOD;
}
aud++;
}
else if (ROMREGION_ISDISKDATA(region))
{
const UINT8 nullhash[HASH_BUF_SIZE] = { 0 };
void *source;
chd_header header;
name = ROM_GETNAME(rom);
strcpy (aud->rom, name);
aud->explength = 0;
aud->length = 0;
aud->exphash = ROM_GETHASHDATA(rom);
hash_data_clear(aud->hash);
count++;
chd_gamedrv = gamedrv;
chd_set_interface(&audit_chd_interface);
source = chd_open( name, 0, NULL );
if( source == NULL )
{
err = chd_get_last_error();
if( err == CHDERR_OUT_OF_MEMORY )
{
aud->status = AUD_MEM_ERROR;
}
else if (hash_data_has_info(aud->exphash, HASH_INFO_NO_DUMP))
{
/* not found but it's not good anyway */
aud->status = AUD_DISK_NOT_AVAILABLE;
}
else
{
/* not found */
aud->status = AUD_DISK_NOT_FOUND;
}
}
else
{
header = *chd_get_header(source);
if (memcmp(nullhash, header.md5, sizeof(header.md5)))
hash_data_insert_binary_checksum(aud->hash, HASH_MD5, header.md5);
if (memcmp(nullhash, header.sha1, sizeof(header.sha1)))
hash_data_insert_binary_checksum(aud->hash, HASH_SHA1, header.sha1);
if (hash_data_has_info(aud->exphash, HASH_INFO_NO_DUMP))
{
aud->status = AUD_DISK_NEED_DUMP;
}
else if (!hash_data_is_equal(aud->exphash, aud->hash, 0))
{
aud->status = AUD_DISK_BAD_MD5;
}
else
{
aud->status = AUD_DISK_GOOD;
}
chd_close( source );
}
aud++;
}
}
#ifdef MESS
if (!count)
return -1;
else
#endif
return count;
}
/*
imghd_create()
Create a MAME HD image
*/
imgtoolerr_t imghd_create(imgtool_stream *stream, UINT32 hunksize, UINT32 cylinders, UINT32 heads, UINT32 sectors, UINT32 seclen)
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
char encoded_image_ref[encoded_image_ref_max_len];
chd_interface interface_save;
UINT8 *cache = NULL;
chd_file *chd = NULL;
int rc;
UINT64 logicalbytes;
int hunknum, totalhunks;
char metadata[256];
/* jump through the hoops as required by the CHD system */
encode_image_ref(stream, encoded_image_ref);
chd_save_interface(&interface_save);
chd_set_interface(&imgtool_chd_interface);
/* sanity check args */
if (hunksize >= 2048)
{
err = IMGTOOLERR_PARAMCORRUPT;
goto done;
}
if (hunksize <= 0)
hunksize = 1024; /* default value */
/* bail if we are read only */
if (stream_isreadonly(stream))
{
err = IMGTOOLERR_READONLY;
goto done;
}
/* calculations */
logicalbytes = (UINT64)cylinders * heads * sectors * seclen;
/* create the new hard drive */
rc = chd_create(encoded_image_ref, logicalbytes, hunksize, CHDCOMPRESSION_NONE, NULL);
if (rc != CHDERR_NONE)
{
err = map_chd_error(rc);
goto done;
}
/* open the new hard drive */
rc = chd_open(encoded_image_ref, CHD_OPEN_READWRITE, NULL, &chd);
if (rc != CHDERR_NONE)
{
err = map_chd_error(rc);
goto done;
}
/* write the metadata */
sprintf(metadata, HARD_DISK_METADATA_FORMAT, cylinders, heads, sectors, seclen);
err = chd_set_metadata(chd, HARD_DISK_METADATA_TAG, 0, metadata, strlen(metadata) + 1);
if (rc != CHDERR_NONE)
{
err = map_chd_error(rc);
goto done;
}
/* alloc and zero buffer */
cache = malloc(hunksize);
if (!cache)
{
err = IMGTOOLERR_OUTOFMEMORY;
goto done;
}
memset(cache, '\0', hunksize);
/* zero out every hunk */
totalhunks = (logicalbytes + hunksize - 1) / hunksize;
for (hunknum = 0; hunknum < totalhunks; hunknum++)
{
rc = chd_write(chd, hunknum, cache);
if (rc)
{
err = IMGTOOLERR_WRITEERROR;
goto done;
}
}
done:
if (cache)
free(cache);
if (chd)
chd_close(chd);
chd_set_interface(&interface_save);
return err;
}
static int audit_one_disk(const rom_entry *rom, const game_driver *gamedrv, UINT32 validation, audit_record *record)
{
chd_file *source;
chd_error err;
/* fill in the record basics */
record->type = AUDIT_FILE_DISK;
record->name = ROM_GETNAME(rom);
record->exphash = ROM_GETHASHDATA(rom);
/* open the disk */
chd_gamedrv = gamedrv;
chd_set_interface(&audit_chd_interface);
err = open_disk_image(gamedrv, rom, &source);
/* if we failed, report the error */
if (err != CHDERR_NONE)
{
/* out of memory */
if (err == CHDERR_OUT_OF_MEMORY)
set_status(record, AUDIT_STATUS_ERROR, SUBSTATUS_ERROR);
/* not found but it's not good anyway */
else if (hash_data_has_info(record->exphash, HASH_INFO_NO_DUMP))
set_status(record, AUDIT_STATUS_NOT_FOUND, SUBSTATUS_NOT_FOUND_NODUMP);
/* not found at all */
else
set_status(record, AUDIT_STATUS_NOT_FOUND, SUBSTATUS_NOT_FOUND);
}
/* if we succeeded, validate it */
else
{
static const UINT8 nullhash[HASH_BUF_SIZE] = { 0 };
chd_header header = *chd_get_header(source);
/* if there's an MD5 or SHA1 hash, add them to the output hash */
if (memcmp(nullhash, header.md5, sizeof(header.md5)) != 0)
hash_data_insert_binary_checksum(record->hash, HASH_MD5, header.md5);
if (memcmp(nullhash, header.sha1, sizeof(header.sha1)) != 0)
hash_data_insert_binary_checksum(record->hash, HASH_SHA1, header.sha1);
/* found but needs a dump */
if (hash_data_has_info(record->exphash, HASH_INFO_NO_DUMP))
set_status(record, AUDIT_STATUS_GOOD, SUBSTATUS_GOOD_NEEDS_REDUMP);
/* incorrect hash */
else if (!hash_data_is_equal(record->exphash, record->hash, 0))
set_status(record, AUDIT_STATUS_FOUND_INVALID, SUBSTATUS_FOUND_BAD_CHECKSUM);
/* just plain good */
else
set_status(record, AUDIT_STATUS_GOOD, SUBSTATUS_GOOD);
chd_close(source);
}
/* return TRUE if we found anything at all */
return (source != NULL);
}
