To add file.cpp by hand

[clinton/Virtual-Jaguar-Rx.git] / src / file.cpp

//\r
// FILE.CPP\r
//\r
// File support\r
// by James Hammons\r
// (C) 2010 Underground Software\r
//\r
// JLH = James Hammons <jlhamm@acm.org>\r
// JPM = Jean-Paul Mari <djipi.mari@gmail.com>\r
//\r
// Who  When        What\r
// ---  ----------  ------------------------------------------------------------\r
// JLH  01/16/2010  Created this log ;-)\r
// JLH  02/28/2010  Added functions to look inside .ZIP files and handle\r
//                  contents\r
// JLH  06/01/2012  Added function to check ZIP file CRCs against file DB\r
// JPM  06/06/2016  Visual Studio support\r
// JPM  06/15/2016  ELF format support\r
// JPM  06/19/2016  Soft debugger support\r
// JPM  07/15/2016  DWARF format support\r
//\r
\r
#include "file.h"\r
#if defined(_MSC_VER)\r
#include "_MSC_VER/config.h"\r
#endif // _MSC_VER\r
#include <stdarg.h>\r
#include <string.h>\r
#include "crc32.h"\r
#include "filedb.h"\r
#include "eeprom.h"\r
#include "jaguar.h"\r
#include "log.h"\r
#include "memory.h"\r
#include "universalhdr.h"\r
#include "unzip.h"\r
#include "zlib.h"\r
#include "libelf/libelf.h"\r
#include "libelf/gelf.h"\r
#include "libdwarf.h"\r
<<<<<<< HEAD\r
#include "debugger/ELFManager.h"\r
#include "debugger/DBGManager.h"\r
=======\r
#include "debugger\ELFManager.h"\r
#include "debugger\DBGManager.h"\r
>>>>>>> origin/master\r
\r
\r
// Private function prototypes\r
\r
static int gzfilelength(gzFile gd);\r
//#if defined(_MSC_VER) || defined(__MINGW64__)|| defined(__MINGW32__) || defined(__CYGWIN__)\r
static bool CheckExtension(const uint8_t *filename, const char *ext);\r
//#else\r
//static bool CheckExtension(const char * filename, const char * ext);\r
//#endif // _MSC_VER\r
//static int ParseFileType(uint8_t header1, uint8_t header2, uint32_t size);\r
\r
// Private variables/enums\r
\r
\r
//\r
// Generic ROM loading\r
//\r
uint32_t JaguarLoadROM(uint8_t * &rom, char * path)\r
{\r
// We really should have some kind of sanity checking for the ROM size here to prevent\r
// a buffer overflow... !!! FIX !!!\r
#if defined(_MSC_VER)\r
#pragma message("Warning: !!! FIX !!! Should have sanity checking for ROM size to prevent buffer overflow!")\r
#else\r
#warning "!!! FIX !!! Should have sanity checking for ROM size to prevent buffer overflow!"\r
#endif // _MSC_VER\r
	uint32_t romSize = 0;\r
\r
	WriteLog("FILE: JaguarLoadROM attempting to load file '%s'...", path);\r
	char * ext = strrchr(path, '.');\r
\r
	// No filename extension == YUO FAIL IT (it is loading the file).\r
	// This is naive, but it works. But should probably come up with something a little\r
	// more robust, to prevent problems with dopes trying to exploit this.\r
	if (ext == NULL)\r
	{\r
		WriteLog("FAILED!\n");\r
		return 0;\r
	}\r
\r
	WriteLog("\nFILE: Succeeded in finding extension (%s)!\n", ext);\r
	WriteLog("FILE: Loading \"%s\"...", path);\r
\r
	if (strcasecmp(ext, ".zip") == 0)\r
	{\r
		// Handle ZIP file loading here...\r
		WriteLog("(ZIPped)...");\r
\r
//		uint8_t * buffer = NULL;\r
//		romSize = GetFileFromZIP(path, FT_SOFTWARE, buffer);\r
		romSize = GetFileFromZIP(path, FT_SOFTWARE, rom);\r
\r
		if (romSize == 0)\r
		{\r
			WriteLog("Failed!\n");\r
			return 0;\r
		}\r
\r
//		memcpy(rom, buffer, romSize);\r
//		delete[] buffer;\r
	}\r
	else\r
	{\r
		// Handle gzipped files transparently [Adam Green]...\r
\r
		gzFile fp = gzopen(path, "rb");\r
\r
		if (fp == NULL)\r
		{\r
			WriteLog("Failed!\n");\r
			return 0;\r
		}\r
\r
		romSize = gzfilelength(fp);\r
		rom = new uint8_t[romSize];\r
		gzseek(fp, 0, SEEK_SET);\r
		gzread(fp, rom, romSize);\r
		gzclose(fp);\r
	}\r
\r
	WriteLog("OK (%i bytes)\n", romSize);\r
\r
	return romSize;\r
}\r
\r
\r
//\r
// Jaguar file loading\r
// We do a more intelligent file analysis here instead of relying on (possible\r
// false) file extensions which people don't seem to give two shits about\r
// anyway. :-(\r
//\r
bool JaguarLoadFile(char * path)\r
{\r
	Elf *ElfMem;\r
	GElf_Ehdr ElfEhdr, *PtrGElfEhdr;\r
	Elf_Scn	*PtrElfScn;\r
	Elf_Data	*PtrElfData;\r
	GElf_Shdr GElfShdr, *PtrGElfShdr;\r
	size_t NbrSect;\r
	uint8_t *buffer = NULL;\r
	char *NameSection;\r
	size_t ElfSectionNameType;\r
	int	DBGType = DBG_NO_TYPE;\r
	bool error;\r
	int err;\r
\r
	jaguarROMSize = JaguarLoadROM(buffer, path);\r
\r
	if (jaguarROMSize == 0)\r
	{\r
		// It's up to the GUI to report errors, not us. :-)\r
		WriteLog("FILE: Could not load ROM from file \"%s\"...\nAborting load!\n", path);\r
		return false;\r
	}\r
\r
	jaguarMainROMCRC32 = crc32_calcCheckSum(buffer, jaguarROMSize);\r
	WriteLog("CRC: %08X\n", (unsigned int)jaguarMainROMCRC32);\r
// TODO: Check for EEPROM file in ZIP file. If there is no EEPROM in the user's EEPROM\r
//       directory, copy the one from the ZIP file, if it exists.\r
	EepromInit();\r
	jaguarRunAddress = 0x802000;					// For non-BIOS runs, this is true\r
	int fileType = ParseFileType(buffer, jaguarROMSize);\r
	jaguarCartInserted = false;\r
	DBGManager_Reset();\r
\r
	if (fileType == JST_ROM)\r
	{\r
		jaguarCartInserted = true;\r
		memcpy(jagMemSpace + 0x800000, buffer, jaguarROMSize);\r
// Checking something...\r
jaguarRunAddress = GET32(jagMemSpace, 0x800404);\r
WriteLog("FILE: Cartridge run address is reported as $%X...\n", jaguarRunAddress);\r
		delete[] buffer;\r
		return true;\r
	}\r
	else if (fileType == JST_ALPINE)\r
	{\r
		// File extension ".ROM": Alpine image that loads/runs at $802000\r
		WriteLog("FILE: Setting up Alpine ROM... Run address: 00802000, length: %08X\n", jaguarROMSize);\r
		memset(jagMemSpace + 0x800000, 0xFF, 0x2000);\r
		memcpy(jagMemSpace + 0x802000, buffer, jaguarROMSize);\r
		delete[] buffer;\r
\r
// Maybe instead of this, we could try requiring the STUBULATOR ROM? Just a thought...\r
		// Try setting the vector to say, $1000 and putting an instruction there that loops forever:\r
		// This kludge works! Yeah!\r
		SET32(jaguarMainRAM, 0x10, 0x00001000);\r
		SET16(jaguarMainRAM, 0x1000, 0x60FE);		// Here: bra Here\r
		return true;\r
	}\r
	else if (fileType == JST_ELF32)\r
	{\r
		DBGType = DBG_ELF;\r
\r
		char *PtrELFExe = (char *)ELFManager_ExeCopy(buffer, jaguarROMSize);\r
\r
		if (PtrELFExe != NULL)\r
		{\r
			if ((elf_version(EV_CURRENT) != EV_NONE) && (ElfMem = ELFManager_MemOpen(PtrELFExe, jaguarROMSize)))\r
			{\r
				if (ELFManager_DwarfInit(ElfMem))\r
				{\r
					DBGType |= DBG_ELFDWARF;\r
				}\r
\r
				if (!elf_getshdrnum(ElfMem, &NbrSect))\r
				{\r
					if (((PtrGElfEhdr = gelf_getehdr(ElfMem, &ElfEhdr)) != NULL) && ((PtrElfScn = elf_getscn(ElfMem, 0)) != NULL))\r
					{\r
						for (error = false; (PtrElfScn != NULL) && (error == false); PtrElfScn = elf_nextscn(ElfMem, PtrElfScn))\r
						{\r
							PtrElfData = NULL;\r
\r
							if ((PtrGElfShdr = gelf_getshdr(PtrElfScn, &GElfShdr)) == NULL)\r
							{\r
								error = true;\r
							}\r
							else\r
							{\r
								NameSection = elf_strptr(ElfMem, PtrGElfEhdr->e_shstrndx, (size_t)PtrGElfShdr->sh_name);\r
								WriteLog("FILE: ELF Section name: %s\n", NameSection);\r
\r
								if ((ElfSectionNameType = ELFManager_GetSectionType(NameSection)) == ELF_NO_TYPE)\r
								{\r
									WriteLog("FILE: ELF Section not listed\n");\r
									error = true;\r
								}\r
								else\r
								{\r
									switch (PtrGElfShdr->sh_type)\r
									{\r
									case	SHT_NULL:\r
										break;\r
\r
									case	SHT_PROGBITS:\r
										if ((PtrGElfShdr->sh_flags & (SHF_ALLOC | SHF_WRITE | SHF_EXECINSTR)))\r
										{\r
											if (PtrGElfShdr->sh_addr >= 0x800000)\r
											{\r
												memcpy(jagMemSpace + PtrGElfShdr->sh_addr, buffer + PtrGElfShdr->sh_offset, PtrGElfShdr->sh_size);\r
												//error = false;\r
											}\r
											else\r
											{\r
												memcpy(jaguarMainRAM + PtrGElfShdr->sh_addr, buffer + PtrGElfShdr->sh_offset, PtrGElfShdr->sh_size);\r
											}\r
										}\r
										else\r
										{\r
											switch (ElfSectionNameType)\r
											{\r
											case ELF_debug_aranges_TYPE:\r
											case ELF_debug_info_TYPE:\r
											case ELF_debug_abbrev_TYPE:\r
											case ELF_debug_line_TYPE:\r
											case ELF_debug_frame_TYPE:\r
											case ELF_debug_ranges_TYPE:\r
											case ELF_debug_str_TYPE:\r
											case ELF_debug_loc_TYPE:\r
												break;\r
\r
											case ELF_comment_TYPE:\r
												break;\r
\r
											default:\r
												error = true;\r
												break;\r
											}\r
										}\r
										break;\r
\r
									case	SHT_NOBITS:\r
										break;\r
\r
									case	SHT_STRTAB:\r
									case	SHT_SYMTAB:\r
										while ((error == false) && ((PtrElfData = elf_getdata(PtrElfScn, PtrElfData)) != NULL))\r
										{\r
											if (!ELFManager_AddTab(PtrElfData, ElfSectionNameType))\r
											{\r
												error = true;\r
											}\r
										}\r
										break;\r
\r
									default:\r
										error = true;\r
										break;\r
									}\r
								}\r
							}\r
						}\r
\r
						jaguarRunAddress = (uint32_t)PtrGElfEhdr->e_entry;\r
						WriteLog("FILE: Setting up ELF 32bits... Run address: %08X\n", jaguarRunAddress);\r
					}\r
					else\r
					{\r
						error = true;\r
					}\r
				}\r
				else\r
				{\r
					error = true;\r
				}\r
			}\r
			else\r
			{\r
				error = true;\r
				WriteLog("FILE: libelf version is not recognized or libelf memory cannot be opened\n");\r
			}\r
		}\r
		else\r
		{\r
			error = true;\r
			WriteLog("FILE: ELFManager cannot allocate memory\n");\r
		}\r
\r
		delete[] buffer;\r
\r
		if (error)\r
		{\r
			WriteLog("FILE: ELF parsing error\n");\r
\r
			if ((err = elf_errno()))\r
			{\r
				WriteLog("FILE: ELF error: %s\n", elf_errmsg(err));\r
			}\r
\r
			return false;\r
		}\r
		else\r
		{\r
			DBGManager_SetType(DBGType);\r
			return true;\r
		}\r
	}\r
	else if (fileType == JST_ABS_TYPE1)\r
	{\r
		// For ABS type 1, run address == load address\r
		uint32_t loadAddress = GET32(buffer, 0x16),\r
			codeSize = GET32(buffer, 0x02) + GET32(buffer, 0x06);\r
		WriteLog("FILE: Setting up homebrew (ABS-1)... Run address: %08X, length: %08X\n", loadAddress, codeSize);\r
		memcpy(jagMemSpace + loadAddress, buffer + 0x24, codeSize);\r
		delete[] buffer;\r
		jaguarRunAddress = loadAddress;\r
		return true;\r
	}\r
	else if (fileType == JST_ABS_TYPE2)\r
	{\r
		uint32_t loadAddress = GET32(buffer, 0x28), runAddress = GET32(buffer, 0x24),\r
			codeSize = GET32(buffer, 0x18) + GET32(buffer, 0x1C);\r
		WriteLog("FILE: Setting up homebrew (ABS-2)... Run address: %08X, length: %08X\n", runAddress, codeSize);\r
		memcpy(jagMemSpace + loadAddress, buffer + 0xA8, codeSize);\r
		delete[] buffer;\r
		jaguarRunAddress = runAddress;\r
		return true;\r
	}\r
	// NB: This is *wrong*\r
	/*\r
	Basically, if there is no "JAG" at position $1C, then the long there is the load/start\r
	address in LITTLE ENDIAN.\r
	If "JAG" is present, the the next character ("R" or "L") determines the size of the\r
	JagServer command (2 bytes vs. 4). Following that are the commands themselves;\r
	typically it will either be 2 (load) or 3 (load & run). Command headers go like so:\r
	2:\r
	Load address (long)\r
	Length (long)\r
	payload\r
	3:\r
	Load address (long)\r
	Length (long)\r
	Run address (long)\r
	payload\r
	5: (Reset)\r
	[command only]\r
	7: (Run at address)\r
	Run address (long)\r
	[no payload]\r
	9: (Clear memory)\r
	Start address (long)\r
	End address (long)\r
	[no payload]\r
	10: (Poll for commands)\r
	[command only]\r
	12: (Load & run user program)\r
	filname, terminated with NULL\r
	[no payload]\r
	$FFFF: (Halt)\r
	[no payload]\r
	*/\r
	else if (fileType == JST_JAGSERVER)\r
	{\r
		// This kind of shiaut should be in the detection code below...\r
		// (and now it is! :-)\r
//		if (buffer[0x1C] == 'J' && buffer[0x1D] == 'A' && buffer[0x1E] == 'G')\r
//		{\r
			// Still need to do some checking here for type 2 vs. type 3. This assumes 3\r
			// Also, JAGR vs. JAGL (word command size vs. long command size)\r
			uint32_t loadAddress = GET32(buffer, 0x22), runAddress = GET32(buffer, 0x2A);\r
			WriteLog("FILE: Setting up homebrew (Jag Server)... Run address: $%X, length: $%X\n", runAddress, jaguarROMSize - 0x2E);\r
			memcpy(jagMemSpace + loadAddress, buffer + 0x2E, jaguarROMSize - 0x2E);\r
			delete[] buffer;\r
			jaguarRunAddress = runAddress;\r
\r
// Hmm. Is this kludge necessary?\r
SET32(jaguarMainRAM, 0x10, 0x00001000);		// Set Exception #4 (Illegal Instruction)\r
SET16(jaguarMainRAM, 0x1000, 0x60FE);		// Here: bra Here\r
\r
			return true;\r
//		}\r
//		else // Special WTFOMGBBQ type here...\r
//		{\r
//			uint32_t loadAddress = (buffer[0x1F] << 24) | (buffer[0x1E] << 16) | (buffer[0x1D] << 8) | buffer[0x1C];\r
//			WriteLog("FILE: Setting up homebrew (GEMDOS WTFOMGBBQ type)... Run address: $%X, length: $%X\n", loadAddress, jaguarROMSize - 0x20);\r
//			memcpy(jagMemSpace + loadAddress, buffer + 0x20, jaguarROMSize - 0x20);\r
//			delete[] buffer;\r
//			jaguarRunAddress = loadAddress;\r
//			return true;\r
//		}\r
	}\r
	else if (fileType == JST_WTFOMGBBQ)\r
	{\r
		uint32_t loadAddress = (buffer[0x1F] << 24) | (buffer[0x1E] << 16) | (buffer[0x1D] << 8) | buffer[0x1C];\r
		WriteLog("FILE: Setting up homebrew (GEMDOS WTFOMGBBQ type)... Run address: $%X, length: $%X\n", loadAddress, jaguarROMSize - 0x20);\r
		memcpy(jagMemSpace + loadAddress, buffer + 0x20, jaguarROMSize - 0x20);\r
		delete[] buffer;\r
		jaguarRunAddress = loadAddress;\r
		return true;\r
	}\r
\r
	// We can assume we have JST_NONE at this point. :-P\r
	WriteLog("FILE: Failed to load headerless file.\n");\r
	return false;\r
}\r
\r
\r
//\r
// "Debugger" file loading\r
// To keep the things separate between "Debugger" and "Alpine" loading until usage clarification has been done\r
//\r
bool DebuggerLoadFile(char * path)\r
{\r
	return (AlpineLoadFile(path));\r
}\r
\r
\r
//\r
// "Alpine" file loading\r
// Since the developers were coming after us with torches and pitchforks, we\r
// decided to allow this kind of thing. ;-) But ONLY FOR THE DEVS, DAMMIT! >:-U\r
// O_O\r
//\r
bool AlpineLoadFile(char * path)\r
{\r
	uint8_t * buffer = NULL;\r
	jaguarROMSize = JaguarLoadROM(buffer, path);\r
\r
	if (jaguarROMSize == 0)\r
	{\r
		// It's up to the GUI to deal with failure, not us. ;-)\r
		WriteLog("FILE: Could not load Alpine from file \"%s\"...\nAborting load!\n", path);\r
		return false;\r
	}\r
\r
	jaguarMainROMCRC32 = crc32_calcCheckSum(buffer, jaguarROMSize);\r
	WriteLog("FILE: CRC is %08X\n", (unsigned int)jaguarMainROMCRC32);\r
	EepromInit();\r
\r
	jaguarRunAddress = 0x802000;\r
\r
	WriteLog("FILE: Setting up Alpine ROM with non-standard length... Run address: 00802000, length: %08X\n", jaguarROMSize);\r
\r
	memset(jagMemSpace + 0x800000, 0xFF, 0x2000);\r
	memcpy(jagMemSpace + 0x802000, buffer, jaguarROMSize);\r
	delete[] buffer;\r
\r
// Maybe instead of this, we could try requiring the STUBULATOR ROM? Just a thought...\r
	// Try setting the vector to say, $1000 and putting an instruction there\r
	// that loops forever:\r
	// This kludge works! Yeah!\r
	SET32(jaguarMainRAM, 0x10, 0x00001000);		// Set Exception #4 (Illegal Instruction)\r
	SET16(jaguarMainRAM, 0x1000, 0x60FE);		// Here: bra Here\r
\r
	return true;\r
}\r
\r
\r
//\r
// Get the length of a (possibly) gzipped file\r
//\r
static int gzfilelength(gzFile gd)\r
{\r
   int size = 0, length = 0;\r
   unsigned char buffer[0x10000];\r
\r
   gzrewind(gd);\r
\r
   do\r
   {\r
      // Read in chunks until EOF\r
      size = gzread(gd, buffer, 0x10000);\r
\r
      if (size <= 0)\r
      	break;\r
\r
      length += size;\r
   }\r
   while (!gzeof(gd));\r
\r
   gzrewind(gd);\r
   return length;\r
}\r
\r
\r
//\r
// Compare extension to passed in filename. If equal, return true; otherwise false.\r
//\r
//#if defined(_MSC_VER) || defined(__MINGW64__)|| defined(__MINGW32__) || defined(__CYGWIN__)\r
static bool CheckExtension(const uint8_t *filename, const char *ext)\r
//#else\r
//static bool CheckExtension(const char * filename, const char * ext)\r
//#endif // _MSC_VER\r
{\r
	// Sanity checking...\r
	if ((filename == NULL) || (ext == NULL))\r
		return false;\r
\r
	const char * filenameExt = strrchr((const char *)filename, '.');	// Get the file's extension (if any)\r
\r
	if (filenameExt == NULL)\r
		return false;\r
\r
	return (strcasecmp(filenameExt, ext) == 0 ? true : false);\r
}\r
\r
\r
//\r
// Get file from .ZIP\r
// Returns the size of the file inside the .ZIP file that we're looking at\r
// NOTE: If the thing we're looking for is found, it allocates it in the passed in buffer.\r
//       Which means we have to deallocate it later.\r
//\r
uint32_t GetFileFromZIP(const char * zipFile, FileType type, uint8_t * &buffer)\r
{\r
// NOTE: We could easily check for this by discarding anything that's larger than the RAM/ROM\r
//       size of the Jaguar console.\r
#if defined(_MSC_VER)\r
#pragma message("Warning: !!! FIX !!! Should have sanity checking for ROM size to prevent buffer overflow!")\r
#else\r
#warning "!!! FIX !!! Should have sanity checking for ROM size to prevent buffer overflow!"\r
#endif // _MSC_VER\r
	const char ftStrings[5][32] = { "Software", "EEPROM", "Label", "Box Art", "Controller Overlay" };\r
//	ZIP * zip = openzip(0, 0, zipFile);\r
	FILE * zip = fopen(zipFile, "rb");\r
\r
	if (zip == NULL)\r
	{\r
		WriteLog("FILE: Could not open file '%s'!\n", zipFile);\r
		return 0;\r
	}\r
\r
//	zipent * ze;\r
	ZipFileEntry ze;\r
	bool found = false;\r
\r
	// The order is here is important: If the file is found, we need to short-circuit the\r
	// readzip() call because otherwise, 'ze' will be pointing to the wrong file!\r
//	while (!found && readzip(zip))\r
	while (!found && GetZIPHeader(zip, ze))\r
	{\r
//		ze = &zip->ent;\r
\r
		// Here we simply rely on the file extension to tell the truth, but we know\r
		// that extensions lie like sons-a-bitches. So this is naive, we need to do\r
		// something a little more robust to keep bad things from happening here.\r
#if defined(_MSC_VER)\r
#pragma message("Warning: !!! Checking for image by extension can be fooled !!!")\r
#else\r
#warning "!!! Checking for image by extension can be fooled !!!"\r
#endif // _MSC_VER\r
		if ((type == FT_LABEL) && (CheckExtension(ze.filename, ".png") || CheckExtension(ze.filename, ".jpg") || CheckExtension(ze.filename, ".gif")))\r
		{\r
			found = true;\r
			WriteLog("FILE: Found image file '%s'.\n", ze.filename);\r
		}\r
\r
		if ((type == FT_SOFTWARE) && (CheckExtension(ze.filename, ".j64")\r
			|| CheckExtension(ze.filename, ".rom") || CheckExtension(ze.filename, ".abs")\r
			|| CheckExtension(ze.filename, ".cof") || CheckExtension(ze.filename, ".coff")\r
			|| CheckExtension(ze.filename, ".jag") || CheckExtension(ze.filename, ".elf")))\r
		{\r
			found = true;\r
			WriteLog("FILE: Found software file '%s'.\n", ze.filename);\r
		}\r
\r
		if ((type == FT_EEPROM) && (CheckExtension(ze.filename, ".eep") || CheckExtension(ze.filename, ".eeprom")))\r
		{\r
			found = true;\r
			WriteLog("FILE: Found EEPROM file '%s'.\n", ze.filename);\r
		}\r
\r
		if (!found)\r
			fseek(zip, ze.compressedSize, SEEK_CUR);\r
	}\r
\r
	uint32_t fileSize = 0;\r
\r
	if (found)\r
	{\r
		WriteLog("FILE: Uncompressing...");\r
// Insert file size sanity check here...\r
		buffer = new uint8_t[ze.uncompressedSize];\r
\r
//		if (readuncompresszip(zip, ze.compressedSize, buffer) == 0)\r
//		if (UncompressFileFromZIP(zip, ze.compressedSize, buffer) == 0)\r
		if (UncompressFileFromZIP(zip, ze, buffer) == 0)\r
		{\r
			fileSize = ze.uncompressedSize;\r
			WriteLog("success! (%u bytes)\n", fileSize);\r
		}\r
		else\r
		{\r
			delete[] buffer;\r
			buffer = NULL;\r
			WriteLog("FAILED!\n");\r
		}\r
	}\r
	else\r
		// Didn't find what we're looking for...\r
		WriteLog("FILE: Failed to find file of type %s...\n", ftStrings[type]);\r
\r
//	closezip(zip);\r
	fclose(zip);\r
	return fileSize;\r
}\r
\r
\r
uint32_t GetFileDBIdentityFromZIP(const char * zipFile)\r
{\r
	FILE * zip = fopen(zipFile, "rb");\r
\r
	if (zip == NULL)\r
	{\r
		WriteLog("FILE: Could not open file '%s'!\n", zipFile);\r
		return 0;\r
	}\r
\r
	ZipFileEntry ze;\r
\r
	// Loop through all files in the zip file under consideration\r
	while (GetZIPHeader(zip, ze))\r
	{\r
		// & loop through all known CRC32s in our file DB to see if it's there!\r
		uint32_t index = 0;\r
\r
		while (romList[index].crc32 != 0xFFFFFF)\r
		{\r
			if (romList[index].crc32 == ze.crc32)\r
			{\r
				fclose(zip);\r
				return index;\r
			}\r
\r
			index++;\r
		}\r
\r
		// We didn't find it, so skip the compressed data...\r
		fseek(zip, ze.compressedSize, SEEK_CUR);\r
	}\r
\r
	fclose(zip);\r
	return (uint32_t )-1;\r
}\r
\r
\r
bool FindFileInZIPWithCRC32(const char * zipFile, uint32_t crc)\r
{\r
	FILE * zip = fopen(zipFile, "rb");\r
\r
	if (zip == NULL)\r
	{\r
		WriteLog("FILE: Could not open file '%s'!\n", zipFile);\r
		return 0;\r
	}\r
\r
	ZipFileEntry ze;\r
\r
	// Loop through all files in the zip file under consideration\r
	while (GetZIPHeader(zip, ze))\r
	{\r
		if (ze.crc32 == crc)\r
		{\r
			fclose(zip);\r
			return true;\r
		}\r
\r
		fseek(zip, ze.compressedSize, SEEK_CUR);\r
	}\r
\r
	fclose(zip);\r
	return false;\r
}\r
\r
\r
//\r
// Parse the file type based upon file size and/or headers.\r
//\r
uint32_t ParseFileType(uint8_t * buffer, uint32_t size)\r
{\r
	// Check headers first...\r
\r
	// ELF 32bits\r
	if (buffer[EI_CLASS] == ELFCLASS32)\r
	{\r
		if (((BigToLittleEndian16(((Elf32_Ehdr *)buffer)->e_machine) & 0xFF) == EM_68K) && (BigToLittleEndian16(((Elf32_Ehdr *)buffer)->e_type) == ET_EXEC) && (buffer[0] == ELFMAG0) && (buffer[1] == ELFMAG1) && (buffer[2] == ELFMAG2) && (buffer[3] == ELFMAG3))\r
			return JST_ELF32;\r
	}\r
\r
	// ABS/COFF type 1\r
	if (buffer[0] == 0x60 && buffer[1] == 0x1B)\r
		return JST_ABS_TYPE1;\r
\r
	// ABS/COFF type 2\r
	if (buffer[0] == 0x01 && buffer[1] == 0x50)\r
		return JST_ABS_TYPE2;\r
\r
	// Jag Server & other old shite\r
	if (buffer[0] == 0x60 && buffer[1] == 0x1A)\r
	{\r
		if (buffer[0x1C] == 'J' && buffer[0x1D] == 'A' && buffer[0x1E] == 'G')\r
			return JST_JAGSERVER;\r
		else\r
			return JST_WTFOMGBBQ;\r
	}\r
\r
	// And if that fails, try file sizes...\r
\r
	// If the file size is divisible by 1M, we probably have an regular ROM.\r
	// We can also check our CRC32 against the internal ROM database to be sure.\r
	// (We also check for the Memory Track cartridge size here as well...)\r
	if ((size % 1048576) == 0 || size == 131072)\r
		return JST_ROM;\r
\r
	// If the file size + 8192 bytes is divisible by 1M, we probably have an\r
	// Alpine format ROM.\r
	if (((size + 8192) % 1048576) == 0)\r
		return JST_ALPINE;\r
\r
	// Headerless crap\r
	return JST_NONE;\r
}\r
\r
//\r
// Check for universal header\r
//\r
bool HasUniversalHeader(uint8_t * rom, uint32_t romSize)\r
{\r
	// Sanity check\r
	if (romSize < 8192)\r
		return false;\r
\r
	for(int i=0; i<8192; i++)\r
		if (rom[i] != universalCartHeader[i])\r
			return false;\r
\r
	return true;\r
}\r
\r
#if 0\r
// Misc. doco\r
\r
/*\r
Stubulator ROM vectors...\r
handler 001 at $00E00008\r
handler 002 at $00E008DE\r
handler 003 at $00E008E2\r
handler 004 at $00E008E6\r
handler 005 at $00E008EA\r
handler 006 at $00E008EE\r
handler 007 at $00E008F2\r
handler 008 at $00E0054A\r
handler 009 at $00E008FA\r
handler 010 at $00000000\r
handler 011 at $00000000\r
handler 012 at $00E008FE\r
handler 013 at $00E00902\r
handler 014 at $00E00906\r
handler 015 at $00E0090A\r
handler 016 at $00E0090E\r
handler 017 at $00E00912\r
handler 018 at $00E00916\r
handler 019 at $00E0091A\r
handler 020 at $00E0091E\r
handler 021 at $00E00922\r
handler 022 at $00E00926\r
handler 023 at $00E0092A\r
handler 024 at $00E0092E\r
handler 025 at $00E0107A\r
handler 026 at $00E0107A\r
handler 027 at $00E0107A\r
handler 028 at $00E008DA\r
handler 029 at $00E0107A\r
handler 030 at $00E0107A\r
handler 031 at $00E0107A\r
handler 032 at $00000000\r
\r
Let's try setting up the illegal instruction vector for a stubulated jaguar...\r
\r
		SET32(jaguar_mainRam, 0x08, 0x00E008DE);\r
		SET32(jaguar_mainRam, 0x0C, 0x00E008E2);\r
		SET32(jaguar_mainRam, 0x10, 0x00E008E6);	// <-- Should be here (it is)...\r
		SET32(jaguar_mainRam, 0x14, 0x00E008EA);//*/\r
\r
/*\r
ABS Format sleuthing (LBUGDEMO.ABS):\r
\r
000000  60 1B 00 00 05 0C 00 04 62 C0 00 00 04 28 00 00\r
000010  12 A6 00 00 00 00 00 80 20 00 FF FF 00 80 25 0C\r
000020  00 00 40 00\r
\r
DRI-format file detected...\r
Text segment size = 0x0000050c bytes\r
Data segment size = 0x000462c0 bytes\r
BSS Segment size = 0x00000428 bytes\r
Symbol Table size = 0x000012a6 bytes\r
Absolute Address for text segment = 0x00802000\r
Absolute Address for data segment = 0x0080250c\r
Absolute Address for BSS segment = 0x00004000\r
\r
(CRZDEMO.ABS):\r
000000  01 50 00 03 00 00 00 00 00 03 83 10 00 00 05 3b\r
000010  00 1c 00 03 00 00 01 07 00 00 1d d0 00 03 64 98\r
000020  00 06 8b 80 00 80 20 00 00 80 20 00 00 80 3d d0\r
\r
000030  2e 74 78 74 00 00 00 00 00 80 20 00 00 80 20 00 .txt (+36 bytes)\r
000040  00 00 1d d0 00 00 00 a8 00 00 00 00 00 00 00 00\r
000050  00 00 00 00 00 00 00 20\r
000058  2e 64 74 61 00 00 00 00 00 80 3d d0 00 80 3d d0 .dta (+36 bytes)\r
000068  00 03 64 98 00 00 1e 78 00 00 00 00 00 00 00 00\r
000078  00 00 00 00 00 00 00 40\r
000080  2e 62 73 73 00 00 00 00 00 00 50 00 00 00 50 00 .bss (+36 bytes)\r
000090  00 06 8b 80 00 03 83 10 00 00 00 00 00 00 00 00\r
0000a0  00 00 00 00 00 00 00 80\r
\r
Header size is $A8 bytes...\r
\r
BSD/COFF format file detected...\r
3 sections specified\r
Symbol Table offset = 230160				($00038310)\r
Symbol Table contains 1339 symbol entries	($0000053B)\r
The additional header size is 28 bytes		($001C)\r
Magic Number for RUN_HDR = 0x00000107\r
Text Segment Size = 7632					($00001DD0)\r
Data Segment Size = 222360					($00036498)\r
BSS Segment Size = 428928					($00068B80)\r
Starting Address for executable = 0x00802000\r
Start of Text Segment = 0x00802000\r
Start of Data Segment = 0x00803dd0\r
*/\r
#endif\r