mirror of
https://github.com/dborth/vbagx.git
synced 2024-12-01 15:04:17 +01:00
446 lines
9.1 KiB
C++
446 lines
9.1 KiB
C++
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <zlib.h>
|
|
|
|
#include "Patch.h"
|
|
|
|
#ifndef _MSC_VER
|
|
#define _stricmp strcasecmp
|
|
#endif // ! _MSC_VER
|
|
|
|
static int readInt2(MFILE *f)
|
|
{
|
|
int res = 0;
|
|
int c = memfgetc(f);
|
|
if(c == MEOF)
|
|
return -1;
|
|
res = c;
|
|
c = memfgetc(f);
|
|
if(c == MEOF)
|
|
return -1;
|
|
return c + (res<<8);
|
|
}
|
|
|
|
static int readInt3(MFILE *f)
|
|
{
|
|
int res = 0;
|
|
int c = memfgetc(f);
|
|
if(c == MEOF)
|
|
return -1;
|
|
res = c;
|
|
c = memfgetc(f);
|
|
if(c == MEOF)
|
|
return -1;
|
|
res = c + (res<<8);
|
|
c = memfgetc(f);
|
|
if(c == MEOF)
|
|
return -1;
|
|
return c + (res<<8);
|
|
}
|
|
|
|
static s64 readInt4(MFILE *f)
|
|
{
|
|
s64 tmp, res = 0;
|
|
int c;
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
c = memfgetc(f);
|
|
if (c == MEOF)
|
|
return -1;
|
|
tmp = c;
|
|
res = res + (tmp << (i*8));
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static s64 readInt8(MFILE *f)
|
|
{
|
|
s64 tmp, res = 0;
|
|
int c;
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
c = memfgetc(f);
|
|
if (c == MEOF)
|
|
return -1;
|
|
tmp = c;
|
|
res = res + (tmp << (i*8));
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static s64 readVarPtr(MFILE *f)
|
|
{
|
|
s64 offset = 0, shift = 1;
|
|
for (;;) {
|
|
int c = memfgetc(f);
|
|
if (c == MEOF) return 0;
|
|
offset += (c & 0x7F) * shift;
|
|
if (c & 0x80) break;
|
|
shift <<= 7;
|
|
offset += shift;
|
|
}
|
|
return offset;
|
|
}
|
|
|
|
#ifndef MIN
|
|
#define MIN(a,b) (((a)<(b))?(a):(b))
|
|
#endif
|
|
|
|
static uLong computePatchCRC(MFILE *f, unsigned int size)
|
|
{
|
|
Bytef buf[4096];
|
|
long readed;
|
|
|
|
uLong crc = crc32(0L, Z_NULL, 0);
|
|
do {
|
|
readed = memfread(buf, 1, MIN(size, sizeof(buf)), f);
|
|
crc = crc32(crc, buf, readed);
|
|
size -= readed;
|
|
} while (readed > 0);
|
|
return crc;
|
|
}
|
|
|
|
bool patchApplyIPS(MFILE *f, u8 **r, int *s)
|
|
{
|
|
// from the IPS spec at http://zerosoft.zophar.net/ips.htm
|
|
|
|
bool result = false;
|
|
|
|
u8 *rom = *r;
|
|
int size = *s;
|
|
if(memfgetc(f) == 'P' &&
|
|
memfgetc(f) == 'A' &&
|
|
memfgetc(f) == 'T' &&
|
|
memfgetc(f) == 'C' &&
|
|
memfgetc(f) == 'H') {
|
|
int b;
|
|
int offset;
|
|
int len;
|
|
|
|
result = true;
|
|
|
|
for(;;) {
|
|
// read offset
|
|
offset = readInt3(f);
|
|
// if offset == MEOF, end of patch
|
|
if(offset == 0x454f46 || offset == -1)
|
|
break;
|
|
// read length
|
|
len = readInt2(f);
|
|
if(!len) {
|
|
// len == 0, RLE block
|
|
len = readInt2(f);
|
|
// byte to fill
|
|
int c = memfgetc(f);
|
|
if(c == -1)
|
|
break;
|
|
b = (u8)c;
|
|
} else
|
|
b= -1;
|
|
// check if we need to reallocate our ROM
|
|
if((offset + len) >= size) {
|
|
#ifdef GEKKO
|
|
size = offset + len;
|
|
#else
|
|
size *= 2;
|
|
rom = (u8 *)realloc(rom, size);
|
|
#endif
|
|
*r = rom;
|
|
*s = size;
|
|
}
|
|
if(b == -1) {
|
|
// normal block, just read the data
|
|
if(memfread(&rom[offset], 1, len, f) != (size_t)len)
|
|
break;
|
|
} else {
|
|
// fill the region with the given byte
|
|
while(len--) {
|
|
rom[offset++] = b;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool patchApplyUPS(MFILE *f, u8 **rom, int *size)
|
|
{
|
|
s64 srcCRC, dstCRC, patchCRC;
|
|
|
|
memfseek(f, 0, MSEEK_END);
|
|
long int patchSize = memftell(f);
|
|
if (patchSize < 20) {
|
|
return false;
|
|
}
|
|
|
|
memfseek(f, 0, MSEEK_SET);
|
|
if(memfgetc(f) != 'U' || memfgetc(f) != 'P' || memfgetc(f) != 'S' || memfgetc(f) != '1') {
|
|
return false;
|
|
}
|
|
|
|
memfseek(f, -12, MSEEK_END);
|
|
srcCRC = readInt4(f);
|
|
dstCRC = readInt4(f);
|
|
patchCRC = readInt4(f);
|
|
if (srcCRC == -1 || dstCRC == -1 || patchCRC == -1) {
|
|
return false;
|
|
}
|
|
|
|
memfseek(f, 0, MSEEK_SET);
|
|
u32 crc = computePatchCRC(f, patchSize-4);
|
|
|
|
if (crc != patchCRC) {
|
|
return false;
|
|
}
|
|
|
|
crc = crc32(0L, Z_NULL, 0);
|
|
crc = crc32(crc, *rom, *size);
|
|
|
|
memfseek(f, 4, MSEEK_SET);
|
|
s64 dataSize;
|
|
s64 srcSize = readVarPtr(f);
|
|
s64 dstSize = readVarPtr(f);
|
|
|
|
if (crc == srcCRC) {
|
|
if (srcSize != *size) {
|
|
return false;
|
|
}
|
|
dataSize = dstSize;
|
|
} else if (crc == dstCRC) {
|
|
if (dstSize != *size) {
|
|
return false;
|
|
}
|
|
dataSize = srcSize;
|
|
} else {
|
|
return false;
|
|
}
|
|
if (dataSize > *size) {
|
|
*rom = (u8*)realloc(*rom, dataSize);
|
|
memset(*rom + *size, 0, dataSize - *size);
|
|
*size = dataSize;
|
|
}
|
|
|
|
s64 relative = 0;
|
|
u8 *mem;
|
|
while(memftell(f) < patchSize - 12) {
|
|
relative += readVarPtr(f);
|
|
if (relative > dataSize) continue;
|
|
mem = *rom + relative;
|
|
for(s64 i = relative; i < dataSize; i++) {
|
|
int x = memfgetc(f);
|
|
relative++;
|
|
if (!x) break;
|
|
if (i < dataSize) {
|
|
*mem++ ^= x;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static int ppfVersion(MFILE *f)
|
|
{
|
|
memfseek(f, 0, MSEEK_SET);
|
|
if (memfgetc(f) != 'P' || memfgetc(f) != 'P' || memfgetc(f) != 'F') //-V501
|
|
return 0;
|
|
switch(memfgetc(f)){
|
|
case '1': return 1;
|
|
case '2': return 2;
|
|
case '3': return 3;
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
static int ppfFileIdLen(MFILE *f, int version)
|
|
{
|
|
if (version == 2) {
|
|
memfseek(f, -8, MSEEK_END);
|
|
} else {
|
|
memfseek(f, -6, MSEEK_END);
|
|
}
|
|
|
|
if (memfgetc(f) != '.' || memfgetc(f) != 'D' || memfgetc(f) != 'I' || memfgetc(f) != 'Z')
|
|
return 0;
|
|
|
|
return (version == 2) ? readInt4(f) : readInt2(f);
|
|
}
|
|
|
|
static bool patchApplyPPF1(MFILE *f, u8 **rom, int *size)
|
|
{
|
|
memfseek(f, 0, MSEEK_END);
|
|
int count = memftell(f);
|
|
if (count < 56)
|
|
return false;
|
|
count -= 56;
|
|
|
|
memfseek(f, 56, MSEEK_SET);
|
|
|
|
u8 *mem = *rom;
|
|
|
|
while (count > 0) {
|
|
int offset = readInt4(f);
|
|
if (offset == -1)
|
|
break;
|
|
int len = memfgetc(f);
|
|
if (len == MEOF)
|
|
break;
|
|
if (offset+len > *size)
|
|
break;
|
|
if (memfread(&mem[offset], 1, len, f) != (size_t)len)
|
|
break;
|
|
count -= 4 + 1 + len;
|
|
}
|
|
|
|
return (count == 0);
|
|
}
|
|
|
|
static bool patchApplyPPF2(MFILE *f, u8 **rom, int *size)
|
|
{
|
|
memfseek(f, 0, MSEEK_END);
|
|
int count = memftell(f);
|
|
if (count < 56+4+1024)
|
|
return false;
|
|
count -= 56+4+1024;
|
|
|
|
memfseek(f, 56, MSEEK_SET);
|
|
|
|
int datalen = readInt4(f);
|
|
if (datalen != *size)
|
|
return false;
|
|
|
|
u8 *mem = *rom;
|
|
|
|
u8 block[1024];
|
|
memfread(&block, 1, 1024, f);
|
|
if (memcmp(&mem[0x9320], &block, 1024) != 0)
|
|
return false;
|
|
|
|
int idlen = ppfFileIdLen(f, 2);
|
|
if (idlen > 0)
|
|
count -= 16 + 16 + idlen;
|
|
|
|
memfseek(f, 56+4+1024, MSEEK_SET);
|
|
|
|
while (count > 0) {
|
|
int offset = readInt4(f);
|
|
if (offset == -1)
|
|
break;
|
|
int len = memfgetc(f);
|
|
if (len == MEOF)
|
|
break;
|
|
if (offset+len > *size)
|
|
break;
|
|
if (memfread(&mem[offset], 1, len, f) != (size_t)len)
|
|
break;
|
|
count -= 4 + 1 + len;
|
|
}
|
|
|
|
return (count == 0);
|
|
}
|
|
|
|
static bool patchApplyPPF3(MFILE *f, u8 **rom, int *size)
|
|
{
|
|
memfseek(f, 0, MSEEK_END);
|
|
int count = memftell(f);
|
|
if (count < 56+4+1024)
|
|
return false;
|
|
count -= 56+4;
|
|
|
|
memfseek(f, 56, MSEEK_SET);
|
|
|
|
int imagetype = memfgetc(f);
|
|
int blockcheck = memfgetc(f);
|
|
int undo = memfgetc(f);
|
|
memfgetc(f);
|
|
|
|
u8 *mem = *rom;
|
|
|
|
if (blockcheck) {
|
|
u8 block[1024];
|
|
memfread(&block, 1, 1024, f);
|
|
if (memcmp(&mem[(imagetype == 0) ? 0x9320 : 0x80A0], &block, 1024) != 0)
|
|
return false;
|
|
count -= 1024;
|
|
}
|
|
|
|
int idlen = ppfFileIdLen(f, 2);
|
|
if (idlen > 0)
|
|
count -= 16 + 16 + idlen;
|
|
|
|
memfseek(f, 56+4+(blockcheck ? 1024 : 0), MSEEK_SET);
|
|
|
|
while (count > 0) {
|
|
s64 offset = readInt8(f);
|
|
if (offset == -1)
|
|
break;
|
|
int len = memfgetc(f);
|
|
if (len == MEOF)
|
|
break;
|
|
if (offset+len > *size)
|
|
break;
|
|
if (memfread(&mem[offset], 1, len, f) != (size_t)len)
|
|
break;
|
|
if (undo) memfseek(f, len, MSEEK_CUR);
|
|
count -= 8 + 1 + len;
|
|
if (undo) count -= len;
|
|
}
|
|
|
|
return (count == 0);
|
|
}
|
|
|
|
bool patchApplyPPF(MFILE *f, u8 **rom, int *size)
|
|
{
|
|
bool res = false;
|
|
|
|
int version = ppfVersion(f);
|
|
switch (version) {
|
|
case 1: res = patchApplyPPF1(f, rom, size); break;
|
|
case 2: res = patchApplyPPF2(f, rom, size); break;
|
|
case 3: res = patchApplyPPF3(f, rom, size); break;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
bool applyPatch(const char *patchname, u8 **rom, int *size)
|
|
{
|
|
bool result = false;
|
|
|
|
if (strlen(patchname) < 5)
|
|
return false;
|
|
const char * p = strrchr(patchname, '.');
|
|
if (p == NULL)
|
|
return false;
|
|
|
|
FILE *f = fopen(patchname, "rb");
|
|
if (!f)
|
|
return false;
|
|
|
|
// read in file
|
|
fseek(f, 0, SEEK_END); // go to end of file
|
|
int filesize = ftell(f); // get filesize
|
|
fseek(f, 0, SEEK_SET); // go to start of file
|
|
char * pbuffer = (char *) malloc(filesize);
|
|
fread (pbuffer, 1, filesize, f);
|
|
fclose(f);
|
|
|
|
MFILE * mf = memfopen(pbuffer, filesize); // create memory file
|
|
|
|
if (_stricmp(p, ".ips") == 0)
|
|
result = patchApplyIPS(mf, rom, size);
|
|
else if (_stricmp(p, ".ups") == 0)
|
|
result = patchApplyUPS(mf, rom, size);
|
|
else if (_stricmp(p, ".ppf") == 0)
|
|
result = patchApplyPPF(mf, rom, size);
|
|
|
|
memfclose(mf); // close memory file
|
|
free(pbuffer); // free buffer
|
|
|
|
return result;
|
|
}
|