usbloadergx/source/patches/wip.cpp

#include <gccore.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "gecko.h"

#include "settings/CSettings.h"
#include "wip.h"

static WIP_Code * CodeList = NULL;
static u32 CodesCount = 0;
static u32 ProcessedLength = 0;
static u32 Counter = 0;

extern "C" void do_wip_code(u8 * dst, u32 len)
{
    if (!CodeList) return;

    if (Counter < 3)
    {
        Counter++;
        return;
    }

    u32 i = 0;
    int n = 0;
    int offset = 0;

    for (i = 0; i < CodesCount; i++)
    {
        for (n = 0; n < 4; n++)
        {
            offset = CodeList[i].offset + n - ProcessedLength;

            if (offset < 0 || offset >= (int) len) continue;

            if (dst[offset] == ((u8 *) &CodeList[i].srcaddress)[n])
            {
                dst[offset] = ((u8 *) &CodeList[i].dstaddress)[n];
                gprintf("WIP: %08X Address Patched.\n", CodeList[i].offset + n);
            }
            else
            {
                gprintf("WIP: %08X Address does not match with WIP entrie.\n", CodeList[i].offset + n);
                gprintf("Destination: %02X | Should be: %02X.\n", dst[offset], ((u8 *) &CodeList[i].srcaddress)[n]);
            }
        }
    }
    ProcessedLength += len;
    Counter++;
}

//! for internal patches only
//! .wip files override internal patches
//! the codelist has to be freed if the set fails
//! if set was successful the codelist will be freed when it's done
extern "C" bool set_wip_list(WIP_Code * list, int size)
{
    if (!CodeList && size > 0)
    {
        CodeList = list;
        CodesCount = size;
        return true;
    }

    return false;
}

extern "C" void wip_reset_counter()
{
    ProcessedLength = 0;
    //alternative dols don't need a skip. only main.dol.
    Counter = 3;
}

extern "C" void free_wip()
{
    if (CodeList) free(CodeList);
    CodeList = NULL;
    CodesCount = 0;
    Counter = 0;
    ProcessedLength = 0;
}

extern "C" int load_wip_code(u8 *gameid)
{
    char filepath[150];
    char GameID[8];
    memset(GameID, 0, sizeof(GameID));
    memcpy(GameID, gameid, 6);
    snprintf(filepath, sizeof(filepath), "%s%s.wip", Settings.WipCodepath, GameID);

    FILE * fp = fopen(filepath, "rb");
    if (!fp)
    {
        memset(GameID, 0, sizeof(GameID));
        memcpy(GameID, gameid, 4);
        snprintf(filepath, sizeof(filepath), "%s%s.wip", Settings.WipCodepath, GameID);
        fp = fopen(filepath, "rb");
    }
    if (!fp)
    {
        memset(GameID, 0, sizeof(GameID));
        memcpy(GameID, gameid, 3);
        snprintf(filepath, sizeof(filepath), "%s%s.wip", Settings.WipCodepath, GameID);
        fp = fopen(filepath, "rb");
    }

    if (!fp) return -1;

    char line[255];
    gprintf("\nLoading WIP code from %s.\n", filepath);

    while (fgets(line, sizeof(line), fp))
    {
        if (line[0] == '#') continue;
        if (line[0] == ';') continue;
        if (line[0] == ':') continue;

        if (strlen(line) < 26) continue;

        u32 offset = (u32) strtoul(line, NULL, 16);
        u32 srcaddress = (u32) strtoul(line + 9, NULL, 16);
        u32 dstaddress = (u32) strtoul(line + 18, NULL, 16);

        if (!CodeList) CodeList = (WIP_Code *) malloc(sizeof(WIP_Code));

        WIP_Code * tmp = (WIP_Code *) realloc(CodeList, (CodesCount + 1) * sizeof(WIP_Code));
        if (!tmp)
        {
            fclose(fp);
            free_wip();
            return -1;
        }

        CodeList = tmp;

        CodeList[CodesCount].offset = offset;
        CodeList[CodesCount].srcaddress = srcaddress;
        CodeList[CodesCount].dstaddress = dstaddress;
        CodesCount++;
    }
    fclose(fp);
    gprintf("\n");

    return 0;
}