// FILE.CPP
//
// File support
-// by James L. Hammons
+// by James Hammons
// (C) 2010 Underground Software
//
-// JLH = James L. Hammons <jlhamm@acm.org>
+// JLH = James Hammons <jlhamm@acm.org>
//
// Who When What
-// --- ---------- -------------------------------------------------------------
+// --- ---------- ------------------------------------------------------------
// JLH 01/16/2010 Created this log ;-)
-// JLH 02/28/2010 Added functions to look inside .ZIP files and handle contents
+// JLH 02/28/2010 Added functions to look inside .ZIP files and handle
+// contents
+// JLH 06/01/2012 Added function to check ZIP file CRCs against file DB
//
#include "file.h"
#include <stdarg.h>
#include <string.h>
#include "crc32.h"
+#include "filedb.h"
#include "eeprom.h"
#include "jaguar.h"
#include "log.h"
static int gzfilelength(gzFile gd);
static bool CheckExtension(const char * filename, const char * ext);
-//static int ParseFileType(uint8 header1, uint8 header2, uint32 size);
+//static int ParseFileType(uint8_t header1, uint8_t header2, uint32_t size);
// Private variables/enums
//
// Generic ROM loading
//
-uint32 JaguarLoadROM(uint8 * &rom, char * path)
+uint32_t JaguarLoadROM(uint8_t * &rom, char * path)
{
// We really should have some kind of sanity checking for the ROM size here to prevent
// a buffer overflow... !!! FIX !!!
#warning "!!! FIX !!! Should have sanity checking for ROM size to prevent buffer overflow!"
- uint32 romSize = 0;
+ uint32_t romSize = 0;
WriteLog("JaguarLoadROM: Attempting to load file '%s'...", path);
char * ext = strrchr(path, '.');
}
romSize = gzfilelength(fp);
- rom = new uint8[romSize];
+ rom = new uint8_t[romSize];
gzseek(fp, 0, SEEK_SET);
gzread(fp, rom, romSize);
gzclose(fp);
return romSize;
}
+
//
// Jaguar file loading
-// We do a more intelligent file analysis here instead of relying on (possible false)
-// file extensions which people don't seem to give two shits about anyway. :-(
+// We do a more intelligent file analysis here instead of relying on (possible
+// false) file extensions which people don't seem to give two shits about
+// anyway. :-(
//
bool JaguarLoadFile(char * path)
{
- uint8 * buffer = NULL;
+ uint8_t * buffer = NULL;
jaguarROMSize = JaguarLoadROM(buffer, path);
if (jaguarROMSize == 0)
// directory, copy the one from the ZIP file, if it exists.
EepromInit();
jaguarRunAddress = 0x802000; // For non-BIOS runs, this is true
- int fileType = ParseFileType(buffer[0], buffer[1], jaguarROMSize);
+ int fileType = ParseFileType(buffer, jaguarROMSize);
+ jaguarCartInserted = false;
if (fileType == JST_ROM)
{
+ jaguarCartInserted = true;
memcpy(jagMemSpace + 0x800000, buffer, jaguarROMSize);
+// Checking something...
+jaguarRunAddress = GET32(jagMemSpace, 0x800404);
+WriteLog("FILE: Cartridge run address is reported as $%X...\n", jaguarRunAddress);
delete[] buffer;
return true;
}
else if (fileType == JST_ABS_TYPE1)
{
// For ABS type 1, run address == load address
- uint32 loadAddress = GET32(buffer, 0x16),
+ uint32_t loadAddress = GET32(buffer, 0x16),
codeSize = GET32(buffer, 0x02) + GET32(buffer, 0x06);
WriteLog("FILE: Setting up homebrew (ABS-1)... Run address: %08X, length: %08X\n", loadAddress, codeSize);
memcpy(jagMemSpace + loadAddress, buffer + 0x24, codeSize);
}
else if (fileType == JST_ABS_TYPE2)
{
- uint32 loadAddress = GET32(buffer, 0x28), runAddress = GET32(buffer, 0x24),
+ uint32_t loadAddress = GET32(buffer, 0x28), runAddress = GET32(buffer, 0x24),
codeSize = GET32(buffer, 0x18) + GET32(buffer, 0x1C);
WriteLog("FILE: Setting up homebrew (ABS-2)... Run address: %08X, length: %08X\n", runAddress, codeSize);
memcpy(jagMemSpace + loadAddress, buffer + 0xA8, codeSize);
jaguarRunAddress = runAddress;
return true;
}
+ // NB: This is *wrong*
+ /*
+ Basically, if there is no "JAG" at position $1C, then the long there is the load/start
+ address in LITTLE ENDIAN.
+ If "JAG" is present, the the next character ("R" or "L") determines the size of the
+ JagServer command (2 bytes vs. 4). Following that are the commands themselves;
+ typically it will either be 2 (load) or 3 (load & run). Command headers go like so:
+ 2:
+ Load address (long)
+ Length (long)
+ payload
+ 3:
+ Load address (long)
+ Length (long)
+ Run address (long)
+ payload
+ 5: (Reset)
+ [command only]
+ 7: (Run at address)
+ Run address (long)
+ [no payload]
+ 9: (Clear memory)
+ Start address (long)
+ End address (long)
+ [no payload]
+ 10: (Poll for commands)
+ [command only]
+ 12: (Load & run user program)
+ filname, terminated with NULL
+ [no payload]
+ $FFFF: (Halt)
+ [no payload]
+ */
else if (fileType == JST_JAGSERVER)
{
- uint32 loadAddress = GET32(buffer, 0x22), runAddress = GET32(buffer, 0x2A);
- WriteLog("FILE: Setting up homebrew (Jag Server)... Run address: %08X, length: %08X\n", runAddress, jaguarROMSize - 0x2E);
- memcpy(jagMemSpace + loadAddress, buffer + 0x2E, jaguarROMSize - 0x2E);
+ // This kind of shiaut should be in the detection code below...
+ // (and now it is! :-)
+// if (buffer[0x1C] == 'J' && buffer[0x1D] == 'A' && buffer[0x1E] == 'G')
+// {
+ // Still need to do some checking here for type 2 vs. type 3. This assumes 3
+ // Also, JAGR vs. JAGL (word command size vs. long command size)
+ uint32_t loadAddress = GET32(buffer, 0x22), runAddress = GET32(buffer, 0x2A);
+ WriteLog("FILE: Setting up homebrew (Jag Server)... Run address: $%X, length: $%X\n", runAddress, jaguarROMSize - 0x2E);
+ memcpy(jagMemSpace + loadAddress, buffer + 0x2E, jaguarROMSize - 0x2E);
+ delete[] buffer;
+ jaguarRunAddress = runAddress;
+
+// Hmm. Is this kludge necessary?
+SET32(jaguarMainRAM, 0x10, 0x00001000); // Set Exception #4 (Illegal Instruction)
+SET16(jaguarMainRAM, 0x1000, 0x60FE); // Here: bra Here
+
+ return true;
+// }
+// else // Special WTFOMGBBQ type here...
+// {
+// uint32_t loadAddress = (buffer[0x1F] << 24) | (buffer[0x1E] << 16) | (buffer[0x1D] << 8) | buffer[0x1C];
+// WriteLog("FILE: Setting up homebrew (GEMDOS WTFOMGBBQ type)... Run address: $%X, length: $%X\n", loadAddress, jaguarROMSize - 0x20);
+// memcpy(jagMemSpace + loadAddress, buffer + 0x20, jaguarROMSize - 0x20);
+// delete[] buffer;
+// jaguarRunAddress = loadAddress;
+// return true;
+// }
+ }
+ else if (fileType == JST_WTFOMGBBQ)
+ {
+ uint32_t loadAddress = (buffer[0x1F] << 24) | (buffer[0x1E] << 16) | (buffer[0x1D] << 8) | buffer[0x1C];
+ WriteLog("FILE: Setting up homebrew (GEMDOS WTFOMGBBQ type)... Run address: $%X, length: $%X\n", loadAddress, jaguarROMSize - 0x20);
+ memcpy(jagMemSpace + loadAddress, buffer + 0x20, jaguarROMSize - 0x20);
delete[] buffer;
- jaguarRunAddress = runAddress;
+ jaguarRunAddress = loadAddress;
return true;
}
// We can assume we have JST_NONE at this point. :-P
+ WriteLog("FILE: Failed to load headerless file.\n");
return false;
}
+
//
// "Alpine" file loading
-// Since the developers were coming after us with torches and pitchforks, we decided to
-// allow this kind of thing. ;-) But ONLY FOR THE DEVS, DAMMIT! O_O
+// Since the developers were coming after us with torches and pitchforks, we
+// decided to allow this kind of thing. ;-) But ONLY FOR THE DEVS, DAMMIT! >:-U
+// O_O
//
bool AlpineLoadFile(char * path)
{
- uint8 * buffer = NULL;
+ uint8_t * buffer = NULL;
jaguarROMSize = JaguarLoadROM(buffer, path);
if (jaguarROMSize == 0)
delete[] buffer;
// Maybe instead of this, we could try requiring the STUBULATOR ROM? Just a thought...
- // Try setting the vector to say, $1000 and putting an instruction there that loops forever:
+ // Try setting the vector to say, $1000 and putting an instruction there
+ // that loops forever:
// This kludge works! Yeah!
- SET32(jaguarMainRAM, 0x10, 0x00001000);
+ SET32(jaguarMainRAM, 0x10, 0x00001000); // Set Exception #4 (Illegal Instruction)
SET16(jaguarMainRAM, 0x1000, 0x60FE); // Here: bra Here
return true;
}
+
//
// Get the length of a (possibly) gzipped file
//
return length;
}
+
//
// Compare extension to passed in filename. If equal, return true; otherwise false.
//
-static bool CheckExtension(const char * filename, const char * ext)
+static bool CheckExtension(const uint8_t * filename, const char * ext)
{
- const char * filenameExt = strrchr(filename, '.'); // Get the file's extension (if any)
+ // Sanity checking...
+ if ((filename == NULL) || (ext == NULL))
+ return false;
+
+ const char * filenameExt = strrchr((const char *)filename, '.'); // Get the file's extension (if any)
+
+ if (filenameExt == NULL)
+ return false;
+
return (strcasecmp(filenameExt, ext) == 0 ? true : false);
}
+
//
// Get file from .ZIP
// Returns the size of the file inside the .ZIP file that we're looking at
// NOTE: If the thing we're looking for is found, it allocates it in the passed in buffer.
// Which means we have to deallocate it later.
//
-uint32 GetFileFromZIP(const char * zipFile, FileType type, uint8 * &buffer)
+uint32_t GetFileFromZIP(const char * zipFile, FileType type, uint8_t * &buffer)
{
// NOTE: We could easily check for this by discarding anything that's larger than the RAM/ROM
// size of the Jaguar console.
#warning "!!! FIX !!! Should have sanity checking for ROM size to prevent buffer overflow!"
const char ftStrings[5][32] = { "Software", "EEPROM", "Label", "Box Art", "Controller Overlay" };
- ZIP * zip = openzip(0, 0, zipFile);
+// ZIP * zip = openzip(0, 0, zipFile);
+ FILE * zip = fopen(zipFile, "rb");
if (zip == NULL)
{
return 0;
}
- zipent * ze;
+// zipent * ze;
+ ZipFileEntry ze;
bool found = false;
// The order is here is important: If the file is found, we need to short-circuit the
// readzip() call because otherwise, 'ze' will be pointing to the wrong file!
- while (!found && readzip(zip))
+// while (!found && readzip(zip))
+ while (!found && GetZIPHeader(zip, ze))
{
- ze = &zip->ent;
+// ze = &zip->ent;
// Here we simply rely on the file extension to tell the truth, but we know
// that extensions lie like sons-a-bitches. So this is naive, we need to do
// something a little more robust to keep bad things from happening here.
#warning "!!! Checking for image by extension can be fooled !!!"
- if ((type == FT_LABEL) && (CheckExtension(ze->name, ".png") || CheckExtension(ze->name, ".jpg") || CheckExtension(ze->name, ".gif")))
+ if ((type == FT_LABEL) && (CheckExtension(ze.filename, ".png") || CheckExtension(ze.filename, ".jpg") || CheckExtension(ze.filename, ".gif")))
{
found = true;
- WriteLog("FILE: Found image file '%s'.\n", ze->name);
+ WriteLog("FILE: Found image file '%s'.\n", ze.filename);
}
- if ((type == FT_SOFTWARE) && (CheckExtension(ze->name, ".j64")
- || CheckExtension(ze->name, ".rom") || CheckExtension(ze->name, ".abs")
- || CheckExtension(ze->name, ".cof") || CheckExtension(ze->name, ".jag")))
+ if ((type == FT_SOFTWARE) && (CheckExtension(ze.filename, ".j64")
+ || CheckExtension(ze.filename, ".rom") || CheckExtension(ze.filename, ".abs")
+ || CheckExtension(ze.filename, ".cof") || CheckExtension(ze.filename, ".coff")
+ || CheckExtension(ze.filename, ".jag")))
{
found = true;
- WriteLog("FILE: Found software file '%s'.\n", ze->name);
+ WriteLog("FILE: Found software file '%s'.\n", ze.filename);
}
- if ((type == FT_EEPROM) && (CheckExtension(ze->name, ".eep") || CheckExtension(ze->name, ".eeprom")))
+ if ((type == FT_EEPROM) && (CheckExtension(ze.filename, ".eep") || CheckExtension(ze.filename, ".eeprom")))
{
found = true;
- WriteLog("FILE: Found EEPROM file '%s'.\n", ze->name);
+ WriteLog("FILE: Found EEPROM file '%s'.\n", ze.filename);
}
+
+ if (!found)
+ fseek(zip, ze.compressedSize, SEEK_CUR);
}
- uint32 fileSize = 0;
+ uint32_t fileSize = 0;
if (found)
{
WriteLog("FILE: Uncompressing...");
// Insert file size sanity check here...
- buffer = new uint8[ze->uncompressed_size];
+ buffer = new uint8_t[ze.uncompressedSize];
- if (readuncompresszip(zip, ze, (char *)buffer) == 0)
+// if (readuncompresszip(zip, ze.compressedSize, buffer) == 0)
+// if (UncompressFileFromZIP(zip, ze.compressedSize, buffer) == 0)
+ if (UncompressFileFromZIP(zip, ze, buffer) == 0)
{
- fileSize = ze->uncompressed_size;
+ fileSize = ze.uncompressedSize;
WriteLog("success! (%u bytes)\n", fileSize);
}
else
// Didn't find what we're looking for...
WriteLog("FILE: Failed to find file of type %s...\n", ftStrings[type]);
- closezip(zip);
+// closezip(zip);
+ fclose(zip);
return fileSize;
}
+
+uint32_t GetFileDBIdentityFromZIP(const char * zipFile)
+{
+ FILE * zip = fopen(zipFile, "rb");
+
+ if (zip == NULL)
+ {
+ WriteLog("FILE: Could not open file '%s'!\n", zipFile);
+ return 0;
+ }
+
+ ZipFileEntry ze;
+
+ // Loop through all files in the zip file under consideration
+ while (GetZIPHeader(zip, ze))
+ {
+ // & loop through all known CRC32s in our file DB to see if it's there!
+ uint32_t index = 0;
+
+ while (romList[index].crc32 != 0xFFFFFF)
+ {
+ if (romList[index].crc32 == ze.crc32)
+ {
+ fclose(zip);
+ return index;
+ }
+
+ index++;
+ }
+
+ // We didn't find it, so skip the compressed data...
+ fseek(zip, ze.compressedSize, SEEK_CUR);
+ }
+
+ fclose(zip);
+ return -1;
+}
+
+
+bool FindFileInZIPWithCRC32(const char * zipFile, uint32_t crc)
+{
+ FILE * zip = fopen(zipFile, "rb");
+
+ if (zip == NULL)
+ {
+ WriteLog("FILE: Could not open file '%s'!\n", zipFile);
+ return 0;
+ }
+
+ ZipFileEntry ze;
+
+ // Loop through all files in the zip file under consideration
+ while (GetZIPHeader(zip, ze))
+ {
+ if (ze.crc32 == crc)
+ {
+ fclose(zip);
+ return true;
+ }
+
+ fseek(zip, ze.compressedSize, SEEK_CUR);
+ }
+
+ fclose(zip);
+ return false;
+}
+
+
//
// Parse the file type based upon file size and/or headers.
//
-uint32 ParseFileType(uint8 header1, uint8 header2, uint32 size)
+uint32_t ParseFileType(uint8_t * buffer, uint32_t size)
{
// Check headers first...
// ABS/COFF type 1
- if (header1 == 0x60 && header2 == 0x1B)
+ if (buffer[0] == 0x60 && buffer[1] == 0x1B)
return JST_ABS_TYPE1;
// ABS/COFF type 2
- if (header1 == 0x01 && header2 == 0x50)
+ if (buffer[0] == 0x01 && buffer[1] == 0x50)
return JST_ABS_TYPE2;
- // Jag Server
- if (header1 == 0x60 && header2 == 0x1A)
- return JST_JAGSERVER;
+ // Jag Server & other old shite
+ if (buffer[0] == 0x60 && buffer[1] == 0x1A)
+ {
+ if (buffer[0x1C] == 'J' && buffer[0x1D] == 'A' && buffer[0x1E] == 'G')
+ return JST_JAGSERVER;
+ else
+ return JST_WTFOMGBBQ;
+ }
// And if that fails, try file sizes...
// If the file size is divisible by 1M, we probably have an regular ROM.
// We can also check our CRC32 against the internal ROM database to be sure.
- if ((size % 1048576) == 0)
+ // (We also check for the Memory Track cartridge size here as well...)
+ if ((size % 1048576) == 0 || size == 131072)
return JST_ROM;
// If the file size + 8192 bytes is divisible by 1M, we probably have an
//
// Check for universal header
//
-bool HasUniversalHeader(uint8 * rom, uint32 romSize)
+bool HasUniversalHeader(uint8_t * rom, uint32_t romSize)
{
// Sanity check
if (romSize < 8192)
projects / virtualjaguar / blobdiff