static void vc20_prg_open(mess_image *img, mame_file *fp) { const char *name; int i; prg.length = mame_fsize (fp); if ((prg.prg = (UINT8 *) malloc (prg.length)) == NULL) { logerror("tape %s could not be loaded\n", image_filename(img)); return; } mame_fread (fp, prg.prg, prg.length); logerror("tape %s loaded\n", image_filename(img)); name = image_filename(img); for (i = 0; name[i] != 0; i++) prg.name[i] = toupper (name[i]); for (; i < 16; i++) prg.name[i] = ' '; prg.img = img; prg.stateblock = 0; prg.stateheader = 0; prg.statebyte = 0; prg.statebit = 0; tape.type = TAPE_PRG; tape.on = 1; prg.state = 2; prg.pos = 0; prg.timer = prg.prg_timer; }
static int run_hash(mame_file *file, void (*partialhash)(char *, const unsigned char *, unsigned long, unsigned int), char *dest, unsigned int hash_functions) { UINT32 size; UINT8 *buf = NULL; *dest = '\0'; size = (UINT32) mame_fsize(file); buf = (UINT8 *) malloc(size); if (!buf) return FALSE; /* read the file */ mame_fseek(file, 0, SEEK_SET); mame_fread(file, buf, size); if (partialhash) partialhash(dest, buf, size, hash_functions); else hash_compute(dest, buf, size, hash_functions); /* cleanup */ if (buf) free(buf); mame_fseek(file, 0, SEEK_SET); return TRUE; }
/* load image */ static int kc_load(mame_file *file, unsigned char **ptr) { if (file) { int datasize; unsigned char *data; /* get file size */ datasize = mame_fsize(file); if (datasize!=0) { /* malloc memory for this data */ data = malloc(datasize); if (data!=NULL) { /* read whole file */ mame_fread(file, data, datasize); *ptr = data; logerror("File loaded!\r\n"); /* ok! */ return 1; } } } return 0; }
static void verify_length_and_hash(struct rom_load_data *romdata, const char *name, UINT32 explength, const char* hash) { UINT32 actlength; const char* acthash; /* we've already complained if there is no file */ if (!romdata->file) return; /* get the length and CRC from the file */ actlength = mame_fsize(romdata->file); acthash = mame_fhash(romdata->file); /* verify length */ if (explength != actlength) { sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%-12s WRONG LENGTH (expected: %08x found: %08x)\n", name, explength, actlength); romdata->warnings++; } /* If there is no good dump known, write it */ if (hash_data_has_info(hash, HASH_INFO_NO_DUMP)) { sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%-12s NO GOOD DUMP KNOWN\n", name); romdata->warnings++; } /* verify checksums */ else if (!hash_data_is_equal(hash, acthash, 0)) { /* otherwise, it's just bad */ sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%-12s WRONG CHECKSUMS:\n", name); dump_wrong_and_correct_checksums(romdata, hash, acthash); romdata->warnings++; } /* If it matches, but it is actually a bad dump, write it */ else if (hash_data_has_info(hash, HASH_INFO_BAD_DUMP)) { sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%-12s ROM NEEDS REDUMP\n",name); romdata->warnings++; } }
/* open an d64 image */ static DEVICE_LOAD(cbm_drive) { int size; int id = image_index_in_device(image); cbm_drive[id].drive = 0; cbm_drive[id].image = NULL; size = mame_fsize(file); cbm_drive[id].image = (UINT8*) image_malloc(image, size); if (!cbm_drive[id].image) return INIT_FAIL; if (size != mame_fread (file, cbm_drive[id].image, size)) return INIT_FAIL; cbm_drive[id].drive = D64_IMAGE; return 0; }
int state_save_load_begin(mame_file *file) { TRACE(logerror("Beginning load\n")); /* read the file into memory */ ss_dump_size = mame_fsize(file); ss_dump_array = malloc(ss_dump_size); ss_dump_file = file; mame_fread(ss_dump_file, ss_dump_array, ss_dump_size); /* verify the header and report an error if it doesn't match */ if (validate_header(ss_dump_array, NULL, get_signature(), popmessage, "Error: ")) { free(ss_dump_array); return 1; } /* compute the total size and offset of all the entries */ compute_size_and_offsets(); return 0; }
static UINT64 mame_fsize_thunk(void *file) { return mame_fsize((mame_file *) file); }
static void audit_one_rom(core_options *options, const rom_entry *rom, const char *regiontag, const game_driver *gamedrv, UINT32 validation, audit_record *record) { const game_driver *drv; 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); record->length = 0; record->explength = rom_file_size(rom); /* 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)) { file_error filerr; mame_file *file; /* open the file if we can */ astring fname(drv->name, PATH_SEPARATOR, ROM_GETNAME(rom)); if (has_crc) filerr = mame_fopen_crc_options(options, libretro_content_directory, fname, crc, OPEN_FLAG_READ | OPEN_FLAG_NO_PRELOAD, &file); else filerr = mame_fopen_options(options, libretro_content_directory, fname, OPEN_FLAG_READ | OPEN_FLAG_NO_PRELOAD, &file); /* 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 not found, check the region as a backup */ if (record->length == 0 && regiontag != NULL) { file_error filerr; mame_file *file; /* open the file if we can */ astring fname(regiontag, PATH_SEPARATOR, ROM_GETNAME(rom)); if (has_crc) filerr = mame_fopen_crc_options(options, libretro_content_directory, fname, crc, OPEN_FLAG_READ | OPEN_FLAG_NO_PRELOAD, &file); else filerr = mame_fopen_options(options, libretro_content_directory, fname, OPEN_FLAG_READ | OPEN_FLAG_NO_PRELOAD, &file); /* 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); } } /* if we failed to find the file, set the appropriate status */ if (record->length == 0) { 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 & GAME_IS_BIOS_ROOT) ? 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); } }
static UINT64 mess_chd_length(chd_interface_file *file) { return mame_fsize((mame_file *)file); }
UINT64 audit_chd_length(chd_interface_file *file) { return mame_fsize((mame_file *)file); }
/* check a mfm_disk image is valid */ int mfm_disk_id(int id) { mame_file *file; int result = 0; /* open file and determine image geometry */ file = image_fopen(IO_FLOPPY, id, FILETYPE_IMAGE, OSD_FOPEN_READ); if (file) { unsigned char header[mfm_disk_header_size]; unsigned long FileLength; /* get length of file */ FileLength = mame_fsize(file); if (FileLength!=0) { /* load header */ if (mame_fread(file, header, mfm_disk_header_size)) { /* check for text ident */ if (memcmp(header, MFM_ID, 8)==0) { unsigned long NumTracks; unsigned long TrackSize; unsigned long NumSides; unsigned long Density; NumTracks = mfm_get_long(&header[12]); NumSides = mfm_get_long(&header[16]); Density = mfm_get_long(&header[8]); switch (Density) { default: case MFM_DISK_DENSITY_MFM_LO: { TrackSize = TrackSizeMFMLo; } break; } /* size must be long enough to contain the data */ if (FileLength>=((NumTracks*NumSides*TrackSize)+mfm_disk_header_size)) { logerror("mfm disk id succeeded!\n"); result = 1; } } } } mame_fclose(file); } return result; }
ROM_END static int device_load_arcadia_cart(mess_image *image, mame_file *file) { UINT8 *rom = memory_region(REGION_CPU1); int size; memset(rom, 0, 0x8000); size = mame_fsize(file); if (size > memory_region_length(REGION_CPU1)) size = memory_region_length(REGION_CPU1); if (mame_fread(file, rom, size) != size) return INIT_FAIL; if (size > 0x1000) memmove(rom + 0x2000, rom + 0x1000, size - 0x1000); if (size > 0x2000) memmove(rom + 0x4000, rom + 0x3000, size - 0x2000); #if 1 /* golf cartridge support */ /* 4kbyte at 0x0000 */ /* 2kbyte at 0x4000 */ if (size<=0x2000) memcpy (rom+0x4000, rom+0x2000, 0x1000); #else /* this is a testpatch for the golf cartridge so it could be burned in a arcadia 2001 cartridge activate it and use debugger to save patched version */ /* not enough yet (some pointers stored as data?) */ struct { UINT16 address; UINT8 old; UINT8 neu; } patch[]= { { 0x0077,0x40,0x20 }, { 0x011e,0x40,0x20 }, { 0x0348,0x40,0x20 }, { 0x03be,0x40,0x20 }, { 0x04ce,0x40,0x20 }, { 0x04da,0x40,0x20 }, { 0x0562,0x42,0x22 }, { 0x0617,0x40,0x20 }, { 0x0822,0x40,0x20 }, { 0x095e,0x42,0x22 }, { 0x09d3,0x42,0x22 }, { 0x0bb0,0x42,0x22 }, { 0x0efb,0x40,0x20 }, { 0x0ec1,0x43,0x23 }, { 0x0f00,0x40,0x20 }, { 0x0f12,0x40,0x20 }, { 0x0ff5,0x43,0x23 }, { 0x0ff7,0x41,0x21 }, { 0x0ff9,0x40,0x20 }, { 0x0ffb,0x41,0x21 }, { 0x20ec,0x42,0x22 } }; for (int i=0; i<ARRAY_LENGTH(patch); i++) { assert(rom[patch[i].address]==patch[i].old); rom[patch[i].address]=patch[i].neu; } #endif return INIT_PASS; }
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); }
static int image_load_internal(mess_image *img, const char *name, int is_create, int create_format, option_resolution *create_args) { const struct IODevice *dev; const char *s; char *newname; int err = INIT_PASS; mame_file *file = NULL; UINT8 *buffer = NULL; UINT64 size; unsigned int readable, writeable, creatable; /* unload if we are loaded */ if (img->status & IMAGE_STATUS_ISLOADED) image_unload(img); /* clear out the error */ image_clear_error(img); /* if we are attempting to "load" NULL, then exit at this point */ if (!name) return INIT_PASS; dev = image_device(img); assert(dev); img->status |= IMAGE_STATUS_ISLOADING; if (name && *name) { newname = image_strdup(img, name); if (!newname) { err = IMAGE_ERROR_OUTOFMEMORY; goto error; } } else newname = NULL; img->name = newname; img->dir = NULL; osd_image_load_status_changed(img, 0); /* do we need to reset the CPU? */ if ((timer_get_time() > 0) && dev->reset_on_load) machine_reset(); /* prepare to open the file */ img->created = 0; img->writeable = 0; file = NULL; if (dev->getdispositions) { dev->getdispositions(dev, image_index_in_device(img), &readable, &writeable, &creatable); } else { readable = dev->readable; writeable = dev->writeable; creatable = dev->creatable; } /* is this a ZIP file? */ s = strrchr(img->name, '.'); if (s && !mame_stricmp(s, ".ZIP")) { /* ZIP files are writeable */ writeable = 0; creatable = 0; } if (readable && !writeable) { file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_READ); } else if (!readable && writeable) { file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_WRITE); img->writeable = file ? 1 : 0; } else if (readable && writeable) { file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_RW); img->writeable = file ? 1 : 0; if (!file) { file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_READ); if (!file && creatable) { file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_RW_CREATE); img->writeable = file ? 1 : 0; img->created = file ? 1 : 0; } } } /* did this attempt succeed? */ if (!file) { img->err = IMAGE_ERROR_FILENOTFOUND; goto error; } /* if applicable, call device verify */ if (dev->imgverify && !image_has_been_created(img)) { size = mame_fsize(file); buffer = malloc(size); if (!buffer) { img->err = IMAGE_ERROR_OUTOFMEMORY; goto error; } if (mame_fread(file, buffer, (UINT32) size) != size) { img->err = IMAGE_ERROR_INVALIDIMAGE; goto error; } err = dev->imgverify(buffer, size); if (err) { img->err = IMAGE_ERROR_INVALIDIMAGE; goto error; } mame_fseek(file, 0, SEEK_SET); free(buffer); buffer = NULL; } /* call device load or create */ if (image_has_been_created(img) && dev->create) { err = dev->create(img, file, create_format, create_args); if (err) { if (!img->err) img->err = IMAGE_ERROR_UNSPECIFIED; goto error; } } else if (dev->load) { /* using device load */ err = dev->load(img, file); if (err) { if (!img->err) img->err = IMAGE_ERROR_UNSPECIFIED; goto error; } } img->status &= ~IMAGE_STATUS_ISLOADING; img->status |= IMAGE_STATUS_ISLOADED; return INIT_PASS; error: if (file) mame_fclose(file); if (buffer) free(buffer); if (img) { img->fp = NULL; img->name = NULL; img->status &= ~IMAGE_STATUS_ISLOADING|IMAGE_STATUS_ISLOADED; } osd_image_load_status_changed(img, 0); return INIT_FAIL; }
static mame_file *image_fopen_custom(mess_image *img, int filetype, int read_or_write) { const char *sysname; char *lpExt; const game_driver *gamedrv = Machine->gamedrv; assert(img); if (!img->name) return NULL; if (img->fp) { /* If already open, we won't open the file again until it is closed. */ return NULL; } do { sysname = gamedrv->name; logerror("image_fopen: trying %s for system %s\n", img->name, sysname); img->fp = mame_fopen(sysname, img->name, filetype, read_or_write); if (img->fp && (read_or_write == OSD_FOPEN_READ)) { lpExt = strrchr( img->name, '.' ); if (lpExt && (mame_stricmp( lpExt, ".ZIP" ) == 0)) { int pathindex; int pathcount = osd_get_path_count(filetype); zip_file *zipfile; zip_entry *zipentry; char *newname; char *name; char *zipname; const char *ext; const struct IODevice *dev; mame_fclose( img->fp ); img->fp = NULL; dev = image_device(img); assert(dev); newname = NULL; zipname = image_malloc( img, strlen( sysname ) + 1 + strlen( img->name ) + 1 ); if( osd_is_absolute_path( img->name ) ) { strcpy( zipname, img->name ); } else { strcpy( zipname, sysname ); strcat( zipname, osd_path_separator() ); strcat( zipname, img->name ); } for (pathindex = 0; pathindex < pathcount; pathindex++) { zipfile = openzip(filetype, pathindex, zipname); if (zipfile) { zipentry = readzip(zipfile); while( zipentry ) { /* mess doesn't support paths in zip files */ name = osd_basename( zipentry->name ); lpExt = strrchr(name, '.'); if (lpExt) { lpExt++; ext = dev->file_extensions; while(*ext) { if( mame_stricmp( lpExt, ext ) == 0 ) { if( newname ) { image_freeptr( img, newname ); } newname = image_malloc(img, strlen(img->name) + 1 + strlen(name) + 1); if (!newname) return NULL; strcpy(newname, img->name); strcat(newname, osd_path_separator()); strcat(newname, name); } ext += strlen(ext) + 1; } } zipentry = readzip(zipfile); } closezip(zipfile); } if( !newname ) { return NULL; } img->fp = mame_fopen(sysname, newname, filetype, read_or_write); if (img->fp) { image_freeptr(img, img->name); img->name = newname; break; } } image_freeptr( img, zipname ); } } gamedrv = mess_next_compatible_driver(gamedrv); } while(!img->fp && gamedrv); if (img->fp) { logerror("image_fopen: found image %s for system %s\n", img->name, sysname); img->length = mame_fsize(img->fp); img->hash = NULL; } return img->fp; }
static int load_cartridge(const rom_entry *romrgn, const rom_entry *roment, mame_file *file) { UINT32 region, flags; offs_t offset, length, read_length, pos = 0, len; UINT8 *ptr; UINT8 clear_val; int type, datawidth, littleendian, i, j; region = ROMREGION_GETTYPE(romrgn); offset = ROM_GETOFFSET(roment); length = ROM_GETLENGTH(roment); flags = ROM_GETFLAGS(roment); ptr = ((UINT8 *) memory_region(region)) + offset; if (file) { /* must this be full size */ if (flags & ROM_FULLSIZE) { if (mame_fsize(file) != length) return INIT_FAIL; } /* read the ROM */ pos = read_length = mame_fread(file, ptr, length); /* do we need to mirror the ROM? */ if (flags & ROM_MIRROR) { while(pos < length) { len = MIN(read_length, length - pos); memcpy(ptr + pos, ptr, len); pos += len; } } /* postprocess this region */ type = ROMREGION_GETTYPE(romrgn); littleendian = ROMREGION_ISLITTLEENDIAN(romrgn); datawidth = ROMREGION_GETWIDTH(romrgn) / 8; /* if the region is inverted, do that now */ if (type >= REGION_CPU1 && type < REGION_CPU1 + MAX_CPU) { int cputype = Machine->drv->cpu[type - REGION_CPU1].cpu_type; if (cputype != 0) { datawidth = cputype_databus_width(cputype, ADDRESS_SPACE_PROGRAM) / 8; littleendian = (cputype_endianness(cputype) == CPU_IS_LE); } } /* swap the endianness if we need to */ #ifdef LSB_FIRST if (datawidth > 1 && !littleendian) #else if (datawidth > 1 && littleendian) #endif { for (i = 0; i < length; i += datawidth) { UINT8 temp[8]; memcpy(temp, &ptr[i], datawidth); for (j = datawidth - 1; j >= 0; j--) ptr[i + j] = temp[datawidth - 1 - j]; } } } /* clear out anything that remains */ if (!(flags & ROM_NOCLEAR)) { clear_val = (flags & ROM_FILL_FF) ? 0xFF : 0x00; memset(ptr + pos, clear_val, length - pos); } return INIT_PASS; }