simplify api, add ips patch truncation

Author: ITotalJustice

README.md

@@ -28,31 +28,35 @@ an example of how it would look in your code.
 ```c
 uint8_t* apply_patch(
     const uint8_t* src_data, size_t src_size,
-    const uint8_t* patch_data, size_t patch_size, enum PatchType type,
+    const uint8_t* patch_data, size_t patch_size,
     size_t* out_size
 ) {
+    enum PatchType type;
+    if (PatchError_OK != patch_get_type(&type, patch_data, patch_size))
+    {
+        return NULL;
+    }
 
-    uint8_t* out = NULL;
-
-    const enum PatchError result = patch(
-        type,
-        &out, out_size,
-        src_data, src_size,
-        patch_data, patch_size
-    );
-
-    // if patch failed, no data is allocated, so out==NULL
-    if (result != PatchError_OK)
+    if (PatchError_OK != patch_get_size(type, out_size, src_size, patch_data, patch_size))
     {
-        // handle error here
         return NULL;
     }
-    else
+
+    uint8_t* out = malloc(out_size);
+    if (!out)
     {
-        // patch worked, out is now pointing to allocated data.
-        // remember to call free when done!
-        return out;
+        return NULL
     }
+
+    if (PatchError_OK != patch_apply(type, out, out_size, src_data, src_size, patch_data, patch_size))
+    {
+        free(out);
+        return NULL;
+    }
+
+    // patch worked, out is now pointing to allocated data.
+    // remember to call free when done!
+    return out;
 }
 ```
 

examples/patcher/main.c

@@ -15,45 +15,47 @@
 #include <stdlib.h>
 #include <string.h>
 
-static uint8_t* ROM_DATA = {0};
 static uint8_t* PATCH_DATA = {0};
+static uint8_t* ROM_DATA = {0};
 static uint8_t* OUT_DATA = {0};
 
-static size_t ROM_SIZE = {0};
 static size_t PATCH_SIZE = {0};
+static size_t ROM_SIZE = {0};
 static size_t OUT_SIZE = {0};
 
-static int get_patch_type(const char* file_name)
+struct SizePair
 {
-    static const char* extentions[] =
-    {
-        [PatchType_IPS] = ".ips",
-        [PatchType_UPS] = ".ups",
-        [PatchType_BPS] = ".bps",
-    };
+    const char* str;
+    double size;
+};
 
-    const char* ext = strrchr(file_name, '.');
-    if (!ext)
-    {
-        return -1;
-    }
+static const char* PATCH_TYPE_STR[] =
+{
+    [PatchType_IPS] = "ips",
+    [PatchType_UPS] = "ups",
+    [PatchType_BPS] = "bps",
+};
 
-    if (!strcmp(ext, extentions[PatchType_IPS]))
+// not perfect but it'll do
+static struct SizePair get_size_pair(size_t size)
+{
+    struct SizePair pair;
+    if (size > 1024 * 1024 * 100)
     {
-        return PatchType_IPS;
+        pair.str = "GiB";
+        pair.size = (double)size / 1024.0 / 1024.0 / 1024.0;
     }
-
-    if (!strcmp(ext, extentions[PatchType_UPS]))
+    else if (size > 1024 * 100)
     {
-        return PatchType_UPS;
+        pair.str = "MiB";
+        pair.size = (double)size / 1024.0 / 1024.0;
     }
-
-    if (!strcmp(ext, extentions[PatchType_BPS]))
+    else
     {
-        return PatchType_BPS;
+        pair.str = "KiB";
+        pair.size = (double)size / 1024.0;
     }
-
-    return -1;
+    return pair;
 }
 
 static uint8_t* readfile(const char* filepath, size_t* size)
@@ -133,51 +135,59 @@ static int cleanup(const char* error_message)
         printf("ERROR: %s\n", error_message);
     }
 
-    if (ROM_DATA)
-    {
-        free(ROM_DATA);
-        ROM_DATA = NULL;
-    }
     if (PATCH_DATA)
     {
         free(PATCH_DATA);
-        PATCH_DATA = NULL;
+    }
+    if (ROM_DATA)
+    {
+        free(ROM_DATA);
     }
     if (OUT_DATA)
     {
         free(OUT_DATA);
-        OUT_DATA = NULL;
     }
 
-    return 1;
+    return error_message ? EXIT_FAILURE : EXIT_SUCCESS;
 }
 
 int main(int argc, char** argv)
 {
     if (argc < 4)
     {
-        return cleanup("missing args: ./exe rom.bin patch.ips out.bin");
+        return cleanup("missing args: ./exe patch.ips rom.bin out.bin");
     }
 
-    const char* rom_filename = argv[1];
-    const char* patch_filename = argv[2];
+    const char* patch_filename = argv[1];
+    const char* rom_filename = argv[2];
     const char* out_filename = argv[3];
 
-    ROM_DATA = readfile(rom_filename, &ROM_SIZE);
     PATCH_DATA = readfile(patch_filename, &PATCH_SIZE);
+    ROM_DATA = readfile(rom_filename, &ROM_SIZE);
 
-    if (!ROM_DATA || !ROM_SIZE || !PATCH_DATA || !PATCH_SIZE)
+    if (!PATCH_DATA || !PATCH_SIZE || !ROM_DATA || !ROM_SIZE)
     {
         return cleanup("failed to read files");
     }
 
-    const int patch_type = get_patch_type(patch_filename);
-    if (patch_type == -1)
+    enum PatchType type;
+    if (PatchError_OK != patch_get_type(&type, PATCH_DATA, PATCH_SIZE))
     {
         return cleanup("unknown patch type");
     }
 
-    if (PatchError_OK != patch(patch_type, &OUT_DATA, &OUT_SIZE, ROM_DATA, ROM_SIZE, PATCH_DATA, PATCH_SIZE))
+    if (PatchError_OK != patch_get_size(type, &OUT_SIZE, ROM_SIZE, PATCH_DATA, PATCH_SIZE))
+    {
+        return cleanup("unknown patch size");
+    }
+
+    OUT_DATA = malloc(OUT_SIZE);
+    if (!OUT_DATA)
+    {
+        return cleanup("failed to allocate output");
+    }
+
+    if (PatchError_OK != patch_apply(type, OUT_DATA, OUT_SIZE, ROM_DATA, ROM_SIZE, PATCH_DATA, PATCH_SIZE))
     {
         return cleanup("failed to patch file");
     }
@@ -187,8 +197,14 @@ int main(int argc, char** argv)
         return cleanup("failed to write patched file");
     }
 
-    printf("patched: %s\n", out_filename);
-    cleanup(NULL);
+    printf("patched!\n");
+    printf("\tpatch_file: %s\n", patch_filename);
+    printf("\tinput_file: %s\n", rom_filename);
+    printf("\toutput_file: %s\n", out_filename);
+    printf("\tpatch_type: %s\n", PATCH_TYPE_STR[type]);
+    printf("\tpatch_size: %.2f %s\n", get_size_pair(PATCH_SIZE).size, get_size_pair(PATCH_SIZE).str);
+    printf("\tsrc_size: %.2f %s\n", get_size_pair(ROM_SIZE).size, get_size_pair(ROM_SIZE).str);
+    printf("\tdst_size: %.2f %s\n", get_size_pair(OUT_SIZE).size, get_size_pair(OUT_SIZE).str);
 
-    return 0;
+    return cleanup(NULL);
 }

src/CMakeLists.txt

@@ -1,13 +1,19 @@
 cmake_minimum_required(VERSION 3.0.2)
 
 project(patch LANGUAGES C)
-add_library(patch patch.c)
+add_library(patch
+    patch.c
+    bps/bps.c
+    ips/ips.c
+    ups/ups.c
+    common/common.c
+)
 
-add_subdirectory(ips)
-add_subdirectory(ups)
-add_subdirectory(bps)
+# add_subdirectory(ips)
+# add_subdirectory(ups)
+# add_subdirectory(bps)
 
-target_link_libraries(patch PRIVATE ips ups bps)
+# target_link_libraries(patch PRIVATE ips ups bps)
 target_include_directories(patch PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 
 target_compile_options(patch PRIVATE

src/bps/CMakeLists.txt

@@ -5,60 +5,11 @@
 
 /* SOURCE: https://www.romhacking.net/documents/764/ */
 #include "bps.h"
-#include <string.h>
+#include "common/common.h"
 
-
-#define PATCH_HEADER_SIZE 0x4
+#define PATCH_HEADER_SIZE 0x4U
 /* header + src / dst / meta sizes + command + crc32 */
-#define PATCH_MIN_SIZE (PATCH_HEADER_SIZE + 3 + 1 + 12)
-
-
-/* SOURCE: https://web.archive.org/web/20190108202303/http://www.hackersdelight.org/hdcodetxt/crc.c.txt */
-static uint32_t crc32(const uint8_t* data, const size_t size)
-{
-    int crc;
-    unsigned int byte, c;
-    const unsigned int g0 = 0xEDB88320,    g1 = g0>>1,
-        g2 = g0>>2, g3 = g0>>3, g4 = g0>>4, g5 = g0>>5,
-        g6 = (g0>>6)^g0, g7 = ((g0>>6)^g0)>>1;
-
-    crc = 0xFFFFFFFF;
-    for (size_t i = 0; i < size; i++) {
-        byte = data[i];
-        crc = crc ^ byte;
-        c = ((crc<<31>>31) & g7) ^ ((crc<<30>>31) & g6) ^
-            ((crc<<29>>31) & g5) ^ ((crc<<28>>31) & g4) ^
-            ((crc<<27>>31) & g3) ^ ((crc<<26>>31) & g2) ^
-            ((crc<<25>>31) & g1) ^ ((crc<<24>>31) & g0);
-        crc = ((unsigned)crc >> 8) ^ c;
-    }
-    return ~crc;
-}
-
-/* this can fail if the int is bigger than 8 bytes */
-static size_t vln_read(const uint8_t* data, size_t* offset)
-{
-    size_t result = 0;
-    size_t shift = 0;
-
-    /* just in case its a bad patch, only run until max size */
-    for (uint8_t i = 0; i < sizeof(size_t); ++i)
-    {
-        const uint8_t value = data[*offset];
-        ++*offset;
-
-        if (value & 0x80)
-        {
-            result += (value & 0x7F) << shift;
-            break;
-        }
-
-        result += (value | 0x80) << shift;
-        shift += 7;
-    }
-
-    return result;
-}
+#define PATCH_MIN_SIZE (PATCH_HEADER_SIZE + 3U + 1U + 12U)
 
 bool bps_verify_header(const uint8_t* patch, size_t patch_size)
 {
@@ -75,7 +26,7 @@ bool bps_verify_header(const uint8_t* patch, size_t patch_size)
     return true;
 }
 
-bool bps_get_sizes(
+bool bps_get_size(
     const uint8_t* patch, size_t patch_size,
     size_t* dst_size, size_t* src_size, size_t* meta_size, size_t* offset
 ) {
@@ -109,7 +60,7 @@ bool bps_get_sizes(
 }
 
 /* dst_size: large enough to fit entire output */
-bool bps_patch(
+bool bps_patch_apply(
     uint8_t* dst, size_t dst_size,
     const uint8_t* src, size_t src_size,
     const uint8_t* patch, size_t patch_size
@@ -128,7 +79,7 @@ bool bps_patch(
     size_t target_size = 0;
     size_t metadata_size = 0;
 
-    if (!bps_get_sizes(patch, patch_size, &target_size, &source_size, &metadata_size, &patch_offset))
+    if (!bps_get_size(patch, patch_size, &target_size, &source_size, &metadata_size, &patch_offset))
     {
         return false;
     }
@@ -147,23 +98,19 @@ bool bps_patch(
     patch_offset += metadata_size;
 
     /* crc's are at the last 12 bytes, each 4 bytes each. */
-    uint32_t src_crc = 0;
-    uint32_t dst_crc = 0;
-    uint32_t patch_crc = 0;
-
-    memcpy(&src_crc, patch + (patch_size - 12), sizeof(src_crc));
-    memcpy(&dst_crc, patch + (patch_size - 8), sizeof(dst_crc));
-    memcpy(&patch_crc, patch + (patch_size - 4), sizeof(patch_crc));
+    const uint32_t src_crc = read32(patch, patch_size - 12);
+    const uint32_t dst_crc = read32(patch, patch_size - 8);
+    const uint32_t patch_crc = read32(patch, patch_size - 4);
 
     /* check that the src and patch is valid. */
     /* dst is checked at the end. */
-    if (src_crc != crc32(src, src_size))
+    if (src_crc != patch_crc32(src, src_size))
     {
         return false;
     }
 
     /* we don't check it's own crc32 (obviously) */
-    if (patch_crc != crc32(patch, patch_size - 4))
+    if (patch_crc != patch_crc32(patch, patch_size - 4))
     {
         return false;
     }
@@ -188,8 +135,7 @@ bool bps_patch(
         switch (action)
         {
             case SourceRead: {
-                while (len--)
-                {
+                while (len--) {
                     dst[dst_offset] = src[dst_offset];
                     dst_offset++;
                 }
@@ -223,7 +169,7 @@ bool bps_patch(
         }
     }
 
-    if (dst_crc != crc32(dst, dst_size))
+    if (dst_crc != patch_crc32(dst, dst_size))
     {
         return false;
     }