6 // (C) 2010 Underground Software
8 // JLH = James Hammons <jlhamm@acm.org>
11 // --- ---------- -------------------------------------------------------------
12 // JLH 01/16/2010 Created this log ;-)
13 // JLH 02/28/2010 Added functions to look inside .ZIP files and handle contents
25 #include "universalhdr.h"
29 // Private function prototypes
31 static int gzfilelength(gzFile gd);
32 static bool CheckExtension(const char * filename, const char * ext);
33 //static int ParseFileType(uint8 header1, uint8 header2, uint32 size);
35 // Private variables/enums
39 // Generic ROM loading
41 uint32 JaguarLoadROM(uint8 * &rom, char * path)
43 // We really should have some kind of sanity checking for the ROM size here to prevent
44 // a buffer overflow... !!! FIX !!!
45 #warning "!!! FIX !!! Should have sanity checking for ROM size to prevent buffer overflow!"
48 WriteLog("JaguarLoadROM: Attempting to load file '%s'...", path);
49 char * ext = strrchr(path, '.');
51 // No filename extension == YUO FAIL IT (it is loading the file).
52 // This is naive, but it works. But should probably come up with something a little
53 // more robust, to prevent problems with dopes trying to exploit this.
56 WriteLog("FAILED!\n");
60 WriteLog("Succeeded in finding extension (%s)!\n", ext);
61 WriteLog("VJ: Loading \"%s\"...", path);
63 if (strcasecmp(ext, ".zip") == 0)
65 // Handle ZIP file loading here...
66 WriteLog("(ZIPped)...");
68 // uint8_t * buffer = NULL;
69 // romSize = GetFileFromZIP(path, FT_SOFTWARE, buffer);
70 romSize = GetFileFromZIP(path, FT_SOFTWARE, rom);
74 WriteLog("Failed!\n");
78 // memcpy(rom, buffer, romSize);
83 // Handle gzipped files transparently [Adam Green]...
85 gzFile fp = gzopen(path, "rb");
89 WriteLog("Failed!\n");
93 romSize = gzfilelength(fp);
94 rom = new uint8[romSize];
95 gzseek(fp, 0, SEEK_SET);
96 gzread(fp, rom, romSize);
100 WriteLog("OK (%i bytes)\n", romSize);
106 // Jaguar file loading
107 // We do a more intelligent file analysis here instead of relying on (possible false)
108 // file extensions which people don't seem to give two shits about anyway. :-(
110 bool JaguarLoadFile(char * path)
112 uint8 * buffer = NULL;
113 jaguarROMSize = JaguarLoadROM(buffer, path);
115 if (jaguarROMSize == 0)
117 // It's up to the GUI to report errors, not us. :-)
118 WriteLog("FILE: Could not load ROM from file \"%s\"...\nAborting load!\n", path);
122 jaguarMainROMCRC32 = crc32_calcCheckSum(buffer, jaguarROMSize);
123 WriteLog("CRC: %08X\n", (unsigned int)jaguarMainROMCRC32);
124 // TODO: Check for EEPROM file in ZIP file. If there is no EEPROM in the user's EEPROM
125 // directory, copy the one from the ZIP file, if it exists.
127 jaguarRunAddress = 0x802000; // For non-BIOS runs, this is true
128 int fileType = ParseFileType(buffer, jaguarROMSize);
129 jaguarCartInserted = false;
131 if (fileType == JST_ROM)
133 jaguarCartInserted = true;
134 memcpy(jagMemSpace + 0x800000, buffer, jaguarROMSize);
138 else if (fileType == JST_ALPINE)
140 // File extension ".ROM": Alpine image that loads/runs at $802000
141 WriteLog("FILE: Setting up Alpine ROM... Run address: 00802000, length: %08X\n", jaguarROMSize);
142 memset(jagMemSpace + 0x800000, 0xFF, 0x2000);
143 memcpy(jagMemSpace + 0x802000, buffer, jaguarROMSize);
146 // Maybe instead of this, we could try requiring the STUBULATOR ROM? Just a thought...
147 // Try setting the vector to say, $1000 and putting an instruction there that loops forever:
148 // This kludge works! Yeah!
149 SET32(jaguarMainRAM, 0x10, 0x00001000);
150 SET16(jaguarMainRAM, 0x1000, 0x60FE); // Here: bra Here
153 else if (fileType == JST_ABS_TYPE1)
155 // For ABS type 1, run address == load address
156 uint32 loadAddress = GET32(buffer, 0x16),
157 codeSize = GET32(buffer, 0x02) + GET32(buffer, 0x06);
158 WriteLog("FILE: Setting up homebrew (ABS-1)... Run address: %08X, length: %08X\n", loadAddress, codeSize);
159 memcpy(jagMemSpace + loadAddress, buffer + 0x24, codeSize);
161 jaguarRunAddress = loadAddress;
164 else if (fileType == JST_ABS_TYPE2)
166 uint32 loadAddress = GET32(buffer, 0x28), runAddress = GET32(buffer, 0x24),
167 codeSize = GET32(buffer, 0x18) + GET32(buffer, 0x1C);
168 WriteLog("FILE: Setting up homebrew (ABS-2)... Run address: %08X, length: %08X\n", runAddress, codeSize);
169 memcpy(jagMemSpace + loadAddress, buffer + 0xA8, codeSize);
171 jaguarRunAddress = runAddress;
174 // NB: This is *wrong*
176 Basically, if there is no "JAG" at position $1C, then the long there is the load/start
177 address in LITTLE ENDIAN.
178 If "JAG" is present, the the next character ("R" or "L") determines the size of the
179 JagServer command (2 bytes vs. 4). Following that are the commands themselves;
180 typically it will either be 2 (load) or 3 (load & run). Command headers go like so:
199 10: (Poll for commands)
201 12: (Load & run user program)
202 filname, terminated with NULL
207 else if (fileType == JST_JAGSERVER)
209 // This kind of shiaut should be in the detection code below...
210 // (and now it is! :-)
211 // if (buffer[0x1C] == 'J' && buffer[0x1D] == 'A' && buffer[0x1E] == 'G')
213 // Still need to do some checking here for type 2 vs. type 3. This assumes 3
214 // Also, JAGR vs. JAGL (word command size vs. long command size)
215 uint32 loadAddress = GET32(buffer, 0x22), runAddress = GET32(buffer, 0x2A);
216 WriteLog("FILE: Setting up homebrew (Jag Server)... Run address: $%X, length: $%X\n", runAddress, jaguarROMSize - 0x2E);
217 memcpy(jagMemSpace + loadAddress, buffer + 0x2E, jaguarROMSize - 0x2E);
219 jaguarRunAddress = runAddress;
222 // else // Special WTFOMGBBQ type here...
224 // uint32_t loadAddress = (buffer[0x1F] << 24) | (buffer[0x1E] << 16) | (buffer[0x1D] << 8) | buffer[0x1C];
225 // WriteLog("FILE: Setting up homebrew (GEMDOS WTFOMGBBQ type)... Run address: $%X, length: $%X\n", loadAddress, jaguarROMSize - 0x20);
226 // memcpy(jagMemSpace + loadAddress, buffer + 0x20, jaguarROMSize - 0x20);
228 // jaguarRunAddress = loadAddress;
232 else if (fileType == JST_WTFOMGBBQ)
234 uint32_t loadAddress = (buffer[0x1F] << 24) | (buffer[0x1E] << 16) | (buffer[0x1D] << 8) | buffer[0x1C];
235 WriteLog("FILE: Setting up homebrew (GEMDOS WTFOMGBBQ type)... Run address: $%X, length: $%X\n", loadAddress, jaguarROMSize - 0x20);
236 memcpy(jagMemSpace + loadAddress, buffer + 0x20, jaguarROMSize - 0x20);
238 jaguarRunAddress = loadAddress;
242 // We can assume we have JST_NONE at this point. :-P
247 // "Alpine" file loading
248 // Since the developers were coming after us with torches and pitchforks, we decided to
249 // allow this kind of thing. ;-) But ONLY FOR THE DEVS, DAMMIT! >:-U O_O
251 bool AlpineLoadFile(char * path)
253 uint8 * buffer = NULL;
254 jaguarROMSize = JaguarLoadROM(buffer, path);
256 if (jaguarROMSize == 0)
258 // It's up to the GUI to deal with failure, not us. ;-)
259 WriteLog("FILE: Could not load Alpine from file \"%s\"...\nAborting load!\n", path);
263 jaguarMainROMCRC32 = crc32_calcCheckSum(buffer, jaguarROMSize);
264 WriteLog("CRC: %08X\n", (unsigned int)jaguarMainROMCRC32);
267 jaguarRunAddress = 0x802000;
269 WriteLog("FILE: Setting up Alpine ROM with non-standard length... Run address: 00802000, length: %08X\n", jaguarROMSize);
271 memset(jagMemSpace + 0x800000, 0xFF, 0x2000);
272 memcpy(jagMemSpace + 0x802000, buffer, jaguarROMSize);
275 // Maybe instead of this, we could try requiring the STUBULATOR ROM? Just a thought...
276 // Try setting the vector to say, $1000 and putting an instruction there that loops forever:
277 // This kludge works! Yeah!
278 SET32(jaguarMainRAM, 0x10, 0x00001000); // Set Exception #4 (Illegal Instruction)
279 SET16(jaguarMainRAM, 0x1000, 0x60FE); // Here: bra Here
285 // Get the length of a (possibly) gzipped file
287 static int gzfilelength(gzFile gd)
289 int size = 0, length = 0;
290 unsigned char buffer[0x10000];
296 // Read in chunks until EOF
297 size = gzread(gd, buffer, 0x10000);
311 // Compare extension to passed in filename. If equal, return true; otherwise false.
313 static bool CheckExtension(const char * filename, const char * ext)
315 // Sanity checking...
316 if ((filename == NULL) || (ext == NULL))
319 const char * filenameExt = strrchr(filename, '.'); // Get the file's extension (if any)
321 if (filenameExt == NULL)
324 return (strcasecmp(filenameExt, ext) == 0 ? true : false);
328 // Get file from .ZIP
329 // Returns the size of the file inside the .ZIP file that we're looking at
330 // NOTE: If the thing we're looking for is found, it allocates it in the passed in buffer.
331 // Which means we have to deallocate it later.
333 uint32 GetFileFromZIP(const char * zipFile, FileType type, uint8 * &buffer)
335 // NOTE: We could easily check for this by discarding anything that's larger than the RAM/ROM
336 // size of the Jaguar console.
337 #warning "!!! FIX !!! Should have sanity checking for ROM size to prevent buffer overflow!"
338 const char ftStrings[5][32] = { "Software", "EEPROM", "Label", "Box Art", "Controller Overlay" };
339 ZIP * zip = openzip(0, 0, zipFile);
343 WriteLog("FILE: Could not open file '%s'!\n", zipFile);
350 // The order is here is important: If the file is found, we need to short-circuit the
351 // readzip() call because otherwise, 'ze' will be pointing to the wrong file!
352 while (!found && readzip(zip))
356 // Here we simply rely on the file extension to tell the truth, but we know
357 // that extensions lie like sons-a-bitches. So this is naive, we need to do
358 // something a little more robust to keep bad things from happening here.
359 #warning "!!! Checking for image by extension can be fooled !!!"
360 if ((type == FT_LABEL) && (CheckExtension(ze->name, ".png") || CheckExtension(ze->name, ".jpg") || CheckExtension(ze->name, ".gif")))
363 WriteLog("FILE: Found image file '%s'.\n", ze->name);
366 if ((type == FT_SOFTWARE) && (CheckExtension(ze->name, ".j64")
367 || CheckExtension(ze->name, ".rom") || CheckExtension(ze->name, ".abs")
368 || CheckExtension(ze->name, ".cof") || CheckExtension(ze->name, ".coff")
369 || CheckExtension(ze->name, ".jag")))
372 WriteLog("FILE: Found software file '%s'.\n", ze->name);
375 if ((type == FT_EEPROM) && (CheckExtension(ze->name, ".eep") || CheckExtension(ze->name, ".eeprom")))
378 WriteLog("FILE: Found EEPROM file '%s'.\n", ze->name);
386 WriteLog("FILE: Uncompressing...");
387 // Insert file size sanity check here...
388 buffer = new uint8[ze->uncompressed_size];
390 if (readuncompresszip(zip, ze, (char *)buffer) == 0)
392 fileSize = ze->uncompressed_size;
393 WriteLog("success! (%u bytes)\n", fileSize);
399 WriteLog("FAILED!\n");
403 // Didn't find what we're looking for...
404 WriteLog("FILE: Failed to find file of type %s...\n", ftStrings[type]);
411 // Parse the file type based upon file size and/or headers.
413 uint32 ParseFileType(uint8_t * buffer, uint32 size)
415 // Check headers first...
418 if (buffer[0] == 0x60 && buffer[1] == 0x1B)
419 return JST_ABS_TYPE1;
422 if (buffer[0] == 0x01 && buffer[1] == 0x50)
423 return JST_ABS_TYPE2;
425 // Jag Server & other old shite
426 if (buffer[0] == 0x60 && buffer[1] == 0x1A)
428 if (buffer[0x1C] == 'J' && buffer[0x1D] == 'A' && buffer[0x1E] == 'G')
429 return JST_JAGSERVER;
431 return JST_WTFOMGBBQ;
434 // And if that fails, try file sizes...
436 // If the file size is divisible by 1M, we probably have an regular ROM.
437 // We can also check our CRC32 against the internal ROM database to be sure.
438 // (We also check for the Memory Track cartridge size here as well...)
439 if ((size % 1048576) == 0 || size == 131072)
442 // If the file size + 8192 bytes is divisible by 1M, we probably have an
443 // Alpine format ROM.
444 if (((size + 8192) % 1048576) == 0)
452 // Check for universal header
454 bool HasUniversalHeader(uint8 * rom, uint32 romSize)
460 for(int i=0; i<8192; i++)
461 if (rom[i] != universalCartHeader[i])
471 Stubulator ROM vectors...
472 handler 001 at $00E00008
473 handler 002 at $00E008DE
474 handler 003 at $00E008E2
475 handler 004 at $00E008E6
476 handler 005 at $00E008EA
477 handler 006 at $00E008EE
478 handler 007 at $00E008F2
479 handler 008 at $00E0054A
480 handler 009 at $00E008FA
481 handler 010 at $00000000
482 handler 011 at $00000000
483 handler 012 at $00E008FE
484 handler 013 at $00E00902
485 handler 014 at $00E00906
486 handler 015 at $00E0090A
487 handler 016 at $00E0090E
488 handler 017 at $00E00912
489 handler 018 at $00E00916
490 handler 019 at $00E0091A
491 handler 020 at $00E0091E
492 handler 021 at $00E00922
493 handler 022 at $00E00926
494 handler 023 at $00E0092A
495 handler 024 at $00E0092E
496 handler 025 at $00E0107A
497 handler 026 at $00E0107A
498 handler 027 at $00E0107A
499 handler 028 at $00E008DA
500 handler 029 at $00E0107A
501 handler 030 at $00E0107A
502 handler 031 at $00E0107A
503 handler 032 at $00000000
505 Let's try setting up the illegal instruction vector for a stubulated jaguar...
507 SET32(jaguar_mainRam, 0x08, 0x00E008DE);
508 SET32(jaguar_mainRam, 0x0C, 0x00E008E2);
509 SET32(jaguar_mainRam, 0x10, 0x00E008E6); // <-- Should be here (it is)...
510 SET32(jaguar_mainRam, 0x14, 0x00E008EA);//*/
513 ABS Format sleuthing (LBUGDEMO.ABS):
515 000000 60 1B 00 00 05 0C 00 04 62 C0 00 00 04 28 00 00
516 000010 12 A6 00 00 00 00 00 80 20 00 FF FF 00 80 25 0C
519 DRI-format file detected...
520 Text segment size = 0x0000050c bytes
521 Data segment size = 0x000462c0 bytes
522 BSS Segment size = 0x00000428 bytes
523 Symbol Table size = 0x000012a6 bytes
524 Absolute Address for text segment = 0x00802000
525 Absolute Address for data segment = 0x0080250c
526 Absolute Address for BSS segment = 0x00004000
529 000000 01 50 00 03 00 00 00 00 00 03 83 10 00 00 05 3b
530 000010 00 1c 00 03 00 00 01 07 00 00 1d d0 00 03 64 98
531 000020 00 06 8b 80 00 80 20 00 00 80 20 00 00 80 3d d0
533 000030 2e 74 78 74 00 00 00 00 00 80 20 00 00 80 20 00 .txt (+36 bytes)
534 000040 00 00 1d d0 00 00 00 a8 00 00 00 00 00 00 00 00
535 000050 00 00 00 00 00 00 00 20
536 000058 2e 64 74 61 00 00 00 00 00 80 3d d0 00 80 3d d0 .dta (+36 bytes)
537 000068 00 03 64 98 00 00 1e 78 00 00 00 00 00 00 00 00
538 000078 00 00 00 00 00 00 00 40
539 000080 2e 62 73 73 00 00 00 00 00 00 50 00 00 00 50 00 .bss (+36 bytes)
540 000090 00 06 8b 80 00 03 83 10 00 00 00 00 00 00 00 00
541 0000a0 00 00 00 00 00 00 00 80
543 Header size is $A8 bytes...
545 BSD/COFF format file detected...
547 Symbol Table offset = 230160 ($00038310)
548 Symbol Table contains 1339 symbol entries ($0000053B)
549 The additional header size is 28 bytes ($001C)
550 Magic Number for RUN_HDR = 0x00000107
551 Text Segment Size = 7632 ($00001DD0)
552 Data Segment Size = 222360 ($00036498)
553 BSS Segment Size = 428928 ($00068B80)
554 Starting Address for executable = 0x00802000
555 Start of Text Segment = 0x00802000
556 Start of Data Segment = 0x00803dd0