HRESULT CRom::Init(const struct GameDriver *gamedrv, const struct RomModule *region, const struct RomModule *rom)
{
if ( !gamedrv || !region ||!rom )
return S_FALSE;
m_gamedrv = gamedrv;
m_region = region;
m_rom = rom;
m_pszName = ROM_GETNAME(m_rom);
m_dwState = 0;
m_dwLength = 0;
m_dwExpLength = 0;
const struct RomModule *chunk;
for (chunk = rom_first_chunk(m_rom); chunk; chunk = rom_next_chunk(chunk))
m_dwExpLength += ROM_GETLENGTH(chunk);
m_dwChecksum = 0;
char szExpChecksum[256];
lstrcpy(szExpChecksum, ROM_GETHASHDATA(m_rom));
m_dwExpChecksum = GetChecksumFromHash(szExpChecksum);
m_dwRegionFlags = ROMREGION_GETFLAGS(m_region);
return S_OK;
}
void printromlist(const struct RomModule *romp,const char *basename)
{
const struct RomModule *region, *rom, *chunk;
char buf[512];
if (!romp) return;
#ifdef MESS
if (!strcmp(basename,"nes")) return;
#endif
printf("This is the list of the ROMs required for driver \"%s\".\n"
"Name Size Checksum\n",basename);
for (region = romp; region; region = rom_next_region(region))
{
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
const char *name = ROM_GETNAME(rom);
const char* hash = ROM_GETHASHDATA(rom);
int length = -1; /* default is for disks! */
if (ROMREGION_ISROMDATA(region))
{
length = 0;
for (chunk = rom_first_chunk(rom); chunk; chunk = rom_next_chunk(chunk))
length += ROM_GETLENGTH(chunk);
}
printf("%-12s ", name);
if (length >= 0)
printf("%7d",length);
else
printf(" ");
if (!hash_data_has_info(hash, HASH_INFO_NO_DUMP))
{
if (hash_data_has_info(hash, HASH_INFO_BAD_DUMP))
printf(" BAD");
hash_data_print(hash, 0, buf);
printf(" %s", buf);
}
else
printf(" NO GOOD DUMP KNOWN");
printf("\n");
}
}
}
int cli_info_listroms(core_options *options, const char *gamename)
{
int drvindex, count = 0;
/* iterate over drivers */
for (drvindex = 0; drivers[drvindex]; drvindex++)
if (mame_strwildcmp(gamename, drivers[drvindex]->name) == 0)
{
const rom_entry *region, *rom, *chunk;
/* print the header */
if (count > 0)
mame_printf_info("\n");
mame_printf_info("This is the list of the ROMs required for driver \"%s\".\n"
"Name Size Checksum\n", drivers[drvindex]->name);
/* iterate over regions and then ROMs within the region */
for (region = drivers[drvindex]->rom; region; region = rom_next_region(region))
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
const char *name = ROM_GETNAME(rom);
const char* hash = ROM_GETHASHDATA(rom);
char hashbuf[HASH_BUF_SIZE];
int length = -1;
/* accumulate the total length of all chunks */
if (ROMREGION_ISROMDATA(region))
{
length = 0;
for (chunk = rom_first_chunk(rom); chunk; chunk = rom_next_chunk(chunk))
length += ROM_GETLENGTH(chunk);
}
/* start with the name */
mame_printf_info("%-12s ", name);
/* output the length next */
if (length >= 0)
mame_printf_info("%7d", length);
else
mame_printf_info(" ");
/* output the hash data */
if (!hash_data_has_info(hash, HASH_INFO_NO_DUMP))
{
if (hash_data_has_info(hash, HASH_INFO_BAD_DUMP))
mame_printf_info(" BAD");
hash_data_print(hash, 0, hashbuf);
mame_printf_info(" %s", hashbuf);
}
else
mame_printf_info(" NO GOOD DUMP KNOWN");
/* end with a CR */
mame_printf_info("\n");
}
count++;
}
return (count > 0) ? MAMERR_NONE : MAMERR_NO_SUCH_GAME;
}
/* 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;
}
static void print_game_rom(FILE* out, const game_driver* game)
{
const rom_entry *region, *rom, *chunk;
const rom_entry *pregion, *prom, *fprom=NULL;
const game_driver *clone_of;
if (!game->rom)
return;
clone_of = driver_get_clone(game);
for (region = rom_first_region(game); region; region = rom_next_region(region))
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
int offset, length, in_parent, is_disk, is_bios, found_bios, i;
char name[100], bios_name[100];
strcpy(name,ROM_GETNAME(rom));
offset = ROM_GETOFFSET(rom);
is_disk = ROMREGION_ISDISKDATA(region);
is_bios = ROM_GETBIOSFLAGS(rom);
in_parent = 0;
length = 0;
for (chunk = rom_first_chunk(rom); chunk; chunk = rom_next_chunk(chunk))
length += ROM_GETLENGTH(chunk);
if (!ROM_NOGOODDUMP(rom) && clone_of)
{
fprom=NULL;
for (pregion = rom_first_region(clone_of); pregion; pregion = rom_next_region(pregion))
for (prom = rom_first_file(pregion); prom; prom = rom_next_file(prom))
if (hash_data_is_equal(ROM_GETHASHDATA(rom), ROM_GETHASHDATA(prom), 0))
{
if (!fprom || !strcmp(ROM_GETNAME(prom), name))
fprom=prom;
in_parent = 1;
}
}
found_bios = 0;
if(!is_disk && is_bios && game->bios)
{
const bios_entry *thisbios = game->bios;
/* Match against bios short names */
while(!found_bios && !BIOSENTRY_ISEND(thisbios) )
{
if((is_bios-1) == thisbios->value) /* Note '-1' */
{
strcpy(bios_name,thisbios->_name);
found_bios = 1;
}
thisbios++;
}
}
if (!is_disk)
fprintf(out, "\t\t<rom");
else
fprintf(out, "\t\t<disk");
if (*name)
fprintf(out, " name=\"%s\"", normalize_string(name));
if (in_parent)
fprintf(out, " merge=\"%s\"", normalize_string(ROM_GETNAME(fprom)));
if (!is_disk && found_bios)
fprintf(out, " bios=\"%s\"", normalize_string(bios_name));
if (!is_disk)
fprintf(out, " size=\"%d\"", length);
/* dump checksum information only if there is a known dump */
if (!hash_data_has_info(ROM_GETHASHDATA(rom), HASH_INFO_NO_DUMP))
{
for (i=0;i<HASH_NUM_FUNCTIONS;i++)
{
int func = 1<<i;
const char* func_name = hash_function_name(func);
char checksum[1000];
if (hash_data_extract_printable_checksum(ROM_GETHASHDATA(rom), func, checksum))
{
fprintf(out, " %s=\"%s\"", func_name, checksum);
}
}
}
switch (ROMREGION_GETTYPE(region))
{
case REGION_CPU1: fprintf(out, " region=\"cpu1\""); break;
case REGION_CPU2: fprintf(out, " region=\"cpu2\""); break;
case REGION_CPU3: fprintf(out, " region=\"cpu3\""); break;
case REGION_CPU4: fprintf(out, " region=\"cpu4\""); break;
case REGION_CPU5: fprintf(out, " region=\"cpu5\""); break;
case REGION_CPU6: fprintf(out, " region=\"cpu6\""); break;
case REGION_CPU7: fprintf(out, " region=\"cpu7\""); break;
case REGION_CPU8: fprintf(out, " region=\"cpu8\""); break;
case REGION_GFX1: fprintf(out, " region=\"gfx1\""); break;
case REGION_GFX2: fprintf(out, " region=\"gfx2\""); break;
case REGION_GFX3: fprintf(out, " region=\"gfx3\""); break;
case REGION_GFX4: fprintf(out, " region=\"gfx4\""); break;
case REGION_GFX5: fprintf(out, " region=\"gfx5\""); break;
case REGION_GFX6: fprintf(out, " region=\"gfx6\""); break;
case REGION_GFX7: fprintf(out, " region=\"gfx7\""); break;
case REGION_GFX8: fprintf(out, " region=\"gfx8\""); break;
case REGION_PROMS: fprintf(out, " region=\"proms\""); break;
case REGION_SOUND1: fprintf(out, " region=\"sound1\""); break;
case REGION_SOUND2: fprintf(out, " region=\"sound2\""); break;
case REGION_SOUND3: fprintf(out, " region=\"sound3\""); break;
case REGION_SOUND4: fprintf(out, " region=\"sound4\""); break;
case REGION_SOUND5: fprintf(out, " region=\"sound5\""); break;
case REGION_SOUND6: fprintf(out, " region=\"sound6\""); break;
case REGION_SOUND7: fprintf(out, " region=\"sound7\""); break;
case REGION_SOUND8: fprintf(out, " region=\"sound8\""); break;
case REGION_USER1: fprintf(out, " region=\"user1\""); break;
case REGION_USER2: fprintf(out, " region=\"user2\""); break;
case REGION_USER3: fprintf(out, " region=\"user3\""); break;
case REGION_USER4: fprintf(out, " region=\"user4\""); break;
case REGION_USER5: fprintf(out, " region=\"user5\""); break;
case REGION_USER6: fprintf(out, " region=\"user6\""); break;
case REGION_USER7: fprintf(out, " region=\"user7\""); break;
case REGION_USER8: fprintf(out, " region=\"user8\""); break;
case REGION_DISKS: fprintf(out, " region=\"disks\""); break;
default: fprintf(out, " region=\"0x%x\"", ROMREGION_GETTYPE(region));
}
if (hash_data_has_info(ROM_GETHASHDATA(rom), HASH_INFO_NO_DUMP))
fprintf(out, " status=\"nodump\"");
if (hash_data_has_info(ROM_GETHASHDATA(rom), HASH_INFO_BAD_DUMP))
fprintf(out, " status=\"baddump\"");
if (!is_disk)
{
if (ROMREGION_GETFLAGS(region) & ROMREGION_DISPOSE)
fprintf(out, " dispose=\"yes\"");
fprintf(out, " offset=\"%x\"", offset);
fprintf(out, "/>\n");
}
else
{
fprintf(out, " index=\"%x\"", DISK_GETINDEX(rom));
fprintf(out, "/>\n");
}
}
}
static int audit_one_rom(const rom_entry *rom, const game_driver *gamedrv, UINT32 validation, audit_record *record)
{
const game_driver *drv;
const rom_entry *chunk;
UINT32 crc = 0;
UINT8 crcs[4];
int has_crc;
/* fill in the record basics */
record->type = AUDIT_FILE_ROM;
record->name = ROM_GETNAME(rom);
record->exphash = ROM_GETHASHDATA(rom);
/* compute the expected length by summing the chunks */
for (chunk = rom_first_chunk(rom); chunk; chunk = rom_next_chunk(chunk))
record->explength += ROM_GETLENGTH(chunk);
/* see if we have a CRC and extract it if so */
has_crc = hash_data_extract_binary_checksum(record->exphash, HASH_CRC, crcs);
if (has_crc)
crc = (crcs[0] << 24) | (crcs[1] << 16) | (crcs[2] << 8) | crcs[3];
/* find the file and checksum it, getting the file length along the way */
for (drv = gamedrv; drv != NULL; drv = driver_get_clone(drv))
{
mame_file_error filerr;
mame_file *file;
char *fname;
/* open the file if we can */
fname = assemble_3_strings(drv->name, PATH_SEPARATOR, ROM_GETNAME(rom));
if (has_crc)
filerr = mame_fopen_crc(SEARCHPATH_ROM, fname, crc, OPEN_FLAG_READ, &file);
else
filerr = mame_fopen(SEARCHPATH_ROM, fname, OPEN_FLAG_READ, &file);
free(fname);
/* if we got it, extract the hash and length */
if (filerr == FILERR_NONE)
{
hash_data_copy(record->hash, mame_fhash(file, validation));
record->length = (UINT32)mame_fsize(file);
mame_fclose(file);
break;
}
}
/* if we failed to find the file, set the appropriate status */
if (drv == NULL)
{
const game_driver *parent;
/* no good dump */
if (hash_data_has_info(record->exphash, HASH_INFO_NO_DUMP))
set_status(record, AUDIT_STATUS_NOT_FOUND, SUBSTATUS_NOT_FOUND_NODUMP);
/* optional ROM */
else if (ROM_ISOPTIONAL(rom))
set_status(record, AUDIT_STATUS_NOT_FOUND, SUBSTATUS_NOT_FOUND_OPTIONAL);
/* not found and used by parent */
else if (rom_used_by_parent(gamedrv, rom, &parent))
set_status(record, AUDIT_STATUS_NOT_FOUND, (parent->flags & NOT_A_DRIVER) ? SUBSTATUS_NOT_FOUND_BIOS : SUBSTATUS_NOT_FOUND_PARENT);
/* just plain old not found */
else
set_status(record, AUDIT_STATUS_NOT_FOUND, SUBSTATUS_NOT_FOUND);
}
/* if we did find the file, do additional verification */
else
{
/* length mismatch */
if (record->explength != record->length)
set_status(record, AUDIT_STATUS_FOUND_INVALID, SUBSTATUS_FOUND_WRONG_LENGTH);
/* found but needs a dump */
else if (hash_data_has_info(record->exphash, HASH_INFO_NO_DUMP))
set_status(record, AUDIT_STATUS_GOOD, SUBSTATUS_FOUND_NODUMP);
/* incorrect hash */
else if (!hash_data_is_equal(record->exphash, record->hash, 0))
set_status(record, AUDIT_STATUS_FOUND_INVALID, SUBSTATUS_FOUND_BAD_CHECKSUM);
/* correct hash but needs a redump */
else if (hash_data_has_info(record->exphash, HASH_INFO_BAD_DUMP))
set_status(record, AUDIT_STATUS_GOOD, SUBSTATUS_GOOD_NEEDS_REDUMP);
/* just plain old good */
else
set_status(record, AUDIT_STATUS_GOOD, SUBSTATUS_GOOD);
}
/* return TRUE if we found anything at all */
return (drv != NULL);
}
