Added mod hashing/caching to prevent re-downloading the same mods

src/pc/mods/mod.c

@@ -1,8 +1,10 @@
 #include "mod.h"
 #include "mods.h"
 #include "mods_utils.h"
+#include "mod_cache.h"
 #include "data/dynos.c.h"
 #include "pc/utils/misc.h"
+#include "pc/utils/md5.h"
 #include "pc/debuglog.h"
 
 static void mod_activate_bin(struct Mod* mod, struct ModFile* file) {
@@ -107,6 +109,7 @@ void mod_activate(struct Mod* mod) {
             mod_activate_lvl(mod, file);
         }
     }
+    mod_md5_hash(mod);
 }
 
 void mod_clear(struct Mod* mod) {
@@ -518,5 +521,108 @@ bool mod_load(struct Mods* mods, char* basePath, char* modName) {
         }
     }
 
+    // hash and cache if we haven't before
+    struct ModCacheEntry* cache = mod_cache_get_from_path(fullPath);
+    if (cache == NULL) {
+        mod_md5_hash(mod);
+        mod_cache_add(mod->dataHash, strdup(fullPath));
+    }
+
     return true;
 }
+
+#define MD5_BUFFER_SIZE 1024
+
+void mod_md5_hash(struct Mod* mod) {
+    char path[SYS_MAX_PATH] = { 0 };
+    u8 buffer[MD5_BUFFER_SIZE] = { 0 };
+
+    mod->hashProcessed = false;
+
+    MD5_CTX ctx = { 0 };
+    MD5_Init(&ctx);
+
+    for (u32 i = 0; i < mod->fileCount; i++) {
+        struct ModFile* file = &mod->files[i];
+        if (!concat_path(path, mod->basePath, file->relativePath)) {
+            LOG_ERROR("Failed to combine path for mod hashing.");
+            return;
+        }
+
+        // open file pointer
+        FILE* fp = fopen(path, "rb");
+        if (fp == NULL) {
+            LOG_ERROR("Failed to open filepointer for mod hashing: '%s'.", path);
+            continue;
+        }
+
+        // read bytes and md5 them
+        size_t readBytes = 0;
+        do {
+            readBytes = fread(buffer, sizeof(u8), MD5_BUFFER_SIZE, fp);
+            MD5_Update(&ctx, buffer, readBytes);
+        } while (readBytes >= MD5_BUFFER_SIZE);
+
+        // close file pointer
+        fclose(fp);
+    }
+
+    // finish computing
+    MD5_Final(mod->dataHash, &ctx);
+    mod->hashProcessed = true;
+
+    if (mod->isDirectory) {
+        mod_cache_add(mod->dataHash, strdup(mod->basePath));
+    } else {
+        if (!concat_path(path, mod->basePath, mod->files[0].relativePath)) {
+            LOG_ERROR("Failed to combine path for mod hashing.");
+            return;
+        }
+        mod_cache_add(mod->dataHash, strdup(path));
+    }
+}
+
+void mod_load_from_cache(struct Mod* mod) {
+    mod->loadedFromCache = false;
+    struct ModCacheEntry* cache = mod_cache_get_from_hash(mod->dataHash);
+    if (cache == NULL) { return; }
+
+    // remember previous base path and hash
+    char oldBasePath[SYS_MAX_PATH] = { 0 };
+    snprintf(oldBasePath, SYS_MAX_PATH, "%s", mod->basePath);
+    u8 oldDataHash[16] = { 0 };
+    memcpy(oldDataHash, mod->dataHash, sizeof(u8) * 16);
+
+    // override base path
+    if (mod->isDirectory) {
+        snprintf(mod->basePath, SYS_MAX_PATH-1, "%s", cache->path);
+    } else {
+        path_get_folder(cache->path, mod->basePath);
+    }
+
+    // hash our local version of the mod
+    mod_md5_hash(mod);
+
+    // check if hashes match
+    if (mod->hashProcessed && !memcmp(mod->dataHash, oldDataHash, sizeof(u8) * 16)) {
+        // close file pointers
+        for (s32 i = 0; i < mod->fileCount; i++) {
+            struct ModFile* file = &mod->files[i];
+            if (file->fp != NULL) {
+                fclose(file->fp);
+                file->fp = NULL;
+            }
+        }
+
+        // mod is loaded and enabled
+        mod->loadedFromCache = true;
+        mod->enabled = true;
+        LOG_INFO("Loaded from cache: %s", mod->name);
+        return;
+    }
+
+    // error condition, load old base path and hash
+    snprintf(mod->basePath, SYS_MAX_PATH, "%s", oldBasePath);
+    memcpy(mod->dataHash, oldDataHash, sizeof(u8) * 16);
+    LOG_INFO("Could not load from cache: %s", mod->name);
+}

src/pc/mods/mod.h

@@ -29,10 +29,15 @@ struct Mod {
     bool enabled;
     bool selectable;
     size_t size;
+    u8 dataHash[16];
+    bool hashProcessed;
+    bool loadedFromCache;
 };
 
 void mod_activate(struct Mod* mod);
 void mod_clear(struct Mod* mod);
 bool mod_load(struct Mods* mods, char* basePath, char* modName);
+void mod_md5_hash(struct Mod* mod);
+void mod_load_from_cache(struct Mod* mod);
 
 #endif

src/pc/mods/mod_cache.c

@@ -0,0 +1,148 @@
+#include <stdio.h>
+#include "mod_cache.h"
+#include "mods.h"
+#include "mod.h"
+#include "pc/debuglog.h"
+
+#define MOD_CACHE_FILENAME "mod.cache"
+#define MOD_CACHE_VERSION 1
+
+struct ModCacheEntry* sModCacheHead = NULL;
+
+static void mod_cache_remove_node(struct ModCacheEntry* node, struct ModCacheEntry* parent) {
+    if (node == NULL) { return; }
+    if (node == sModCacheHead) { sModCacheHead = node->next; }
+    if (parent != NULL) { parent->next = node->next; }
+    LOG_INFO("Removing node: %s", node->path);
+    if (node->path) {
+        free(node->path);
+    }
+    free(node);
+}
+
+void mod_cache_shutdown(void) {
+    LOG_INFO("Shutting down mod cache.");
+    while (sModCacheHead) {
+        mod_cache_remove_node(sModCacheHead, NULL);
+    }    
+}
+
+struct ModCacheEntry* mod_cache_get_from_hash(u8* dataHash) {
+    struct ModCacheEntry* node = sModCacheHead;
+    while (node != NULL) {
+        if (!memcmp(node->dataHash, dataHash, 16)) {
+            return node;
+        }
+        node = node->next;
+    }
+    return NULL;
+}
+
+struct ModCacheEntry* mod_cache_get_from_path(const char* path) {
+    struct ModCacheEntry* node = sModCacheHead;
+    while (node != NULL) {
+        if (!strcmp(node->path, path)) {
+            return node;
+        }
+        node = node->next;
+    }
+    return NULL;
+}
+
+void mod_cache_add(u8* dataHash, const char* path) {
+    if (mod_cache_get_from_hash(dataHash)) {
+        return;
+    }
+
+    struct ModCacheEntry* node = calloc(1, sizeof(struct ModCacheEntry));
+    memcpy(node->dataHash, dataHash, 16);
+    node->path = (char*)path;
+    node->next = NULL;
+
+    if (sModCacheHead == NULL) {
+        sModCacheHead = node;
+    }
+
+    struct ModCacheEntry* n = sModCacheHead;
+    struct ModCacheEntry* prev = NULL;
+    while (n != NULL) {
+        struct ModCacheEntry* next = n->next;
+
+        // found end of list, add it
+        if (next == NULL) {
+            LOG_INFO("Added node: %s", node->path);
+            if (n != node) { n->next = node; }
+            return;
+        }
+
+        // found old hash, remove it
+        if (!strcmp(n->path, path)) {
+            LOG_INFO("Removing old node: %s", node->path);
+            mod_cache_remove_node(n, prev);
+        }
+
+        prev = n;
+        n = next;
+    }
+}
+
+void mod_cache_load(void) {
+    mod_cache_shutdown();
+    LOG_INFO("Loading mod cache");
+
+    const char* filename = fs_get_write_path(MOD_CACHE_FILENAME);
+    FILE* fp = fopen(filename, "rb");
+    if (fp == NULL) {
+        LOG_INFO("Could not open mod cache load fp: %s", filename);
+        return;
+    }
+
+    u16 version;
+    fread(&version, sizeof(u16), 1, fp);
+    if (version != MOD_CACHE_VERSION) {
+        fclose(fp);
+        LOG_INFO("Mod cache version mismatch");
+        return;
+    }
+
+    while (true) {
+        u8 dataHash[16] = { 0 };
+        u16 pathLen;
+
+        if (fread(dataHash, sizeof(u8), 16, fp) == 0) {
+            break;
+        }
+        fread(&pathLen, sizeof(u16), 1, fp);
+
+        const char* path = calloc(pathLen + 1, sizeof(u8));
+        fread((char*)path, sizeof(u8), pathLen + 1, fp);
+
+        mod_cache_add(dataHash, path);
+    }
+    LOG_INFO("Loading mod cache complete");
+
+    fclose(fp);
+}
+
+void mod_cache_save(void) {
+    LOG_INFO("Saving mod cache");
+    const char* filename = fs_get_write_path(MOD_CACHE_FILENAME);
+    FILE* fp = fopen(filename, "wb");
+    if (fp == NULL) {
+        LOG_ERROR("Failed to open mod cache save fp: %s", filename);
+    }
+
+    u16 version = MOD_CACHE_VERSION;
+    fwrite(&version, sizeof(u16), 1, fp);
+
+    struct ModCacheEntry* node = sModCacheHead;
+    while (node != NULL) {
+        fwrite(node->dataHash, sizeof(u8), 16, fp);
+        u16 pathLen = strlen(node->path);
+        fwrite(&pathLen, sizeof(u16), 1, fp);
+        fwrite(node->path, sizeof(u8), pathLen + 1, fp);
+        node = node->next;
+    }
+
+    fclose(fp);
+}

src/pc/mods/mod_cache.h

@@ -0,0 +1,18 @@
+#ifndef MOD_CACHE_H
+
+#include "types.h"
+
+struct ModCacheEntry {
+    u8 dataHash[16];
+    char* path;
+    struct ModCacheEntry* next;
+};
+
+void mod_cache_shutdown(void);
+struct ModCacheEntry* mod_cache_get_from_hash(u8* dataHash);
+struct ModCacheEntry* mod_cache_get_from_path(const char* path);
+void mod_cache_add(u8* dataHash, const char* path);
+void mod_cache_load(void);
+void mod_cache_save(void);
+
+#endif

src/pc/mods/mods.c

@@ -1,6 +1,7 @@
 #include <unistd.h>
 #include "mods.h"
 #include "mods_utils.h"
+#include "mod_cache.h"
 #include "data/dynos.c.h"
 #include "pc/debuglog.h"
 
@@ -94,6 +95,7 @@ void mods_activate(struct Mods* mods) {
             }
         }
     }
+    mod_cache_save();
 }
 
 static void mods_load(struct Mods* mods, char* modsBasePath) {
@@ -141,6 +143,9 @@ static void mods_load(struct Mods* mods, char* modsBasePath) {
 }
 
 void mods_init(void) {
+    // load mod cache
+    mod_cache_load();
+
     // figure out user path
     bool hasUserPath = true;
     char userModPath[SYS_MAX_PATH] = { 0 };
@@ -203,6 +208,8 @@ void mods_clear(struct Mods* mods) {
 }
 
 void mods_shutdown(void) {
+    mod_cache_save();
+    mod_cache_shutdown();
     mods_clear(&gRemoteMods);
     mods_clear(&gActiveMods);
     mods_clear(&gLocalMods);

src/pc/mods/mods_utils.c

@@ -240,6 +240,18 @@ char* path_basename(char* path) {
     return base;
 }
 
+void path_get_folder(char* path, char* outpath) {
+    char* baseNamePath = path_basename(path);
+    char* p = path;
+    char* o = outpath;
+    while (*p != '\0' && p != baseNamePath) {
+        *o = *p;
+        o++;
+        p++;
+    }
+    *o = '\0';
+}
+
 bool directory_sanity_check(struct dirent* dir, char* dirPath, char* outPath) {
     // skip non-portable filenames
     if (!path_is_portable_filename(dir->d_name)) { return false; }

src/pc/mods/mods_utils.h

@@ -22,6 +22,7 @@ bool is_directory(char* path);
 void normalize_path(char* path);
 bool concat_path(char* destination, char* path, char* fname);
 char* path_basename(char* path);
+void path_get_folder(char* path, char* outpath);
 bool directory_sanity_check(struct dirent* dir, char* dirPath, char* outPath);
 
 #endif

src/pc/network/packets/packet_download.c

@@ -3,7 +3,7 @@
 #include "pc/djui/djui.h"
 #include "pc/mods/mods.h"
 #include "pc/mods/mods_utils.h"
-#define DISABLE_MODULE_LOG 1
+//#define DISABLE_MODULE_LOG 1
 #include "pc/debuglog.h"
 
 #define CHUNK_SIZE 800
@@ -23,8 +23,9 @@ static u64 sOffsetGroupCount = 0;
 u64 sTotalDownloadBytes = 0;
 extern float gDownloadProgress;
 
-static void network_start_offset_group(struct OffsetGroup* og);
+static bool network_start_offset_group(struct OffsetGroup* og);
 static void network_update_offset_groups(void);
+static void mark_groups_loaded_from_hash(void);
 
 void network_start_download_requests(void) {
     sTotalDownloadBytes = 0;
@@ -41,10 +42,52 @@ void network_start_download_requests(void) {
     memset(&sOffsetGroup[0], 0, sizeof(struct OffsetGroup));
     memset(&sOffsetGroup[1], 0, sizeof(struct OffsetGroup));
 
+    mark_groups_loaded_from_hash();
     network_update_offset_groups();
 }
 
-static void network_start_offset_group(struct OffsetGroup* og) {
+static void mark_groups_loaded_from_hash(void) {
+    u8* offsetGroupRequired = calloc(sOffsetGroupCount, sizeof(u8));
+    if (offsetGroupRequired == NULL) {
+        LOG_ERROR("Failed to allocate offsetGroupRequired");
+        return;
+    }
+
+    sTotalDownloadBytes = 0;
+    u64 fileStartOffset = 0;
+    for (u64 modIndex = 0; modIndex < gRemoteMods.entryCount; modIndex++) {
+        struct Mod* mod = gRemoteMods.entries[modIndex];
+
+        if (mod->loadedFromCache) {
+            // if we loaded from cache, mark bytes as downloaded
+            sTotalDownloadBytes += mod->size;
+            LOG_INFO("Loaded from cache: %s, %lu", mod->name, mod->size);
+        } else {
+            // if we haven't loaded from cache, we need this offset group
+            u64 ogIndexStart = fileStartOffset / GROUP_SIZE;
+            u64 ogIndexEnd = (fileStartOffset + mod->size) / GROUP_SIZE;
+            do {
+                LOG_INFO("Marking group as required: %llu (%s)", ogIndexStart, mod->name);
+                offsetGroupRequired[ogIndexStart] = 1;
+                ogIndexStart++;
+            } while (ogIndexStart <= ogIndexEnd);
+        }
+
+        fileStartOffset += mod->size;
+    }
+
+    for (u64 ogIndex = 0; ogIndex < sOffsetGroupCount; ogIndex++) {
+        if (!offsetGroupRequired[ogIndex]) {
+            sOffsetGroupsCompleted[ogIndex] = 1;
+        } else {
+            sOffsetGroupsCompleted[ogIndex] = 0;
+        }
+    }
+
+    free(offsetGroupRequired);
+}
+
+static bool network_start_offset_group(struct OffsetGroup* og) {
 
     // sanity check
     if (og->active) {
@@ -75,7 +118,7 @@ static void network_start_offset_group(struct OffsetGroup* og) {
     // sanity check
     if (!foundIndex) {
         LOG_INFO("Could not find offset group, may be near the end of the download");
-        return;
+        return false;
     }
 
     // set up offset group
@@ -87,6 +130,7 @@ static void network_start_offset_group(struct OffsetGroup* og) {
 
     // send download request
     network_send_download_request(og->offset[0]);
+    return true;
 }
 
 static void network_update_offset_groups(void) {
@@ -94,8 +138,9 @@ static void network_update_offset_groups(void) {
 
     // if no groups are active, start one
     if (!sOffsetGroup[0].active && !sOffsetGroup[1].active) {
-        network_start_offset_group(&sOffsetGroup[0]);
+        if (network_start_offset_group(&sOffsetGroup[0])) {
-        return;
+            return;
+        }
     }
 
     // figure out group progress
@@ -122,13 +167,13 @@ static void network_update_offset_groups(void) {
     bool completedDownload = true;
     for (u64 i = 0; i < sOffsetGroupCount; i++) {
         if (!sOffsetGroupsCompleted[i]) {
+            LOG_INFO("Not completed: %llu", i);
             completedDownload = false;
             break;
         }
     }
 
     if (completedDownload) {
-
         // close and flush all file pointers
         for (u64 modIndex = 0; modIndex < gRemoteMods.entryCount; modIndex++) {
             struct Mod* mod = gRemoteMods.entries[modIndex];
@@ -136,6 +181,8 @@ static void network_update_offset_groups(void) {
                 struct ModFile* modFile = &mod->files[fileIndex];
                 if (modFile->fp == NULL) { continue; }
                 fflush(modFile->fp);
+                fclose(modFile->fp);
+                modFile->fp = NULL;
             }
         }
         LOG_INFO("Download complete!");
@@ -305,6 +352,7 @@ after_group:;
     }
 
     // write the chunk
+    u64 wroteBytes = 0;
     u64 chunkPour = 0;
     u64 fileStartOffset = 0;
     for (u64 modIndex = 0; modIndex < gRemoteMods.entryCount; modIndex++) {
@@ -330,9 +378,12 @@ after_group:;
             u64 fileWriteLength = MIN((modFile->size - fileWriteOffset), (chunkLength - chunkPour));
 
             // read from file, filling chunk
-            open_mod_file(mod, modFile);
+            if (!mod->loadedFromCache) {
-            fseek(modFile->fp, fileWriteOffset, SEEK_SET);
+                open_mod_file(mod, modFile);
-            fwrite(&chunk[chunkPour], sizeof(u8), fileWriteLength, modFile->fp);
+                fseek(modFile->fp, fileWriteOffset, SEEK_SET);
+                fwrite(&chunk[chunkPour], sizeof(u8), fileWriteLength, modFile->fp);
+                wroteBytes += fileWriteLength;
+            }
 
             // increment counters
             chunkPour       += fileWriteLength;
@@ -349,7 +400,7 @@ after_poured:;
     LOG_INFO("Received chunk: offset %llu, size %llu", receiveOffset, chunkLength);
 
     // update progress
-    sTotalDownloadBytes += chunkLength;
+    sTotalDownloadBytes += wroteBytes;
     gDownloadProgress = (float)sTotalDownloadBytes / (float)gRemoteMods.size;
 
     network_update_offset_groups();

src/pc/network/packets/packet_mod_list.c

@@ -39,8 +39,8 @@ void network_send_mod_list(void) {
     snprintf(version, MAX_VERSION_LENGTH, "%s", get_version());
     LOG_INFO("sending version: %s", version);
     packet_write(&p, &version, sizeof(u8) * MAX_VERSION_LENGTH);
-
     packet_write(&p, &gActiveMods.entryCount, sizeof(u16));
+
     LOG_INFO("sent mod list (%u):", gActiveMods.entryCount);
     for (u16 i = 0; i < gActiveMods.entryCount; i++) {
         struct Mod* mod = gActiveMods.entries[i];
@@ -57,6 +57,7 @@ void network_send_mod_list(void) {
         packet_write(&p, mod->relativePath, sizeof(u8) * relativePathLength);
         packet_write(&p, &modSize, sizeof(u64));
         packet_write(&p, &mod->isDirectory, sizeof(u8));
+        packet_write(&p, &mod->dataHash[0], sizeof(u8) * 16);
         LOG_INFO("    '%s': %llu", mod->name, (u64)mod->size);
 
         packet_write(&p, &mod->fileCount, sizeof(u16));
@@ -142,6 +143,7 @@ void network_receive_mod_list(struct Packet* p) {
         packet_read(p, mod->relativePath, relativePathLength * sizeof(u8));
         packet_read(p, &mod->size, sizeof(u64));
         packet_read(p, &mod->isDirectory, sizeof(u8));
+        packet_read(p, &mod->dataHash, sizeof(u8) * 16);
         normalize_path(mod->relativePath);
         totalSize += mod->size;
         LOG_INFO("    '%s': %llu", mod->name, (u64)mod->size);
@@ -181,6 +183,8 @@ void network_receive_mod_list(struct Packet* p) {
             file->fp = NULL;
             LOG_INFO("      '%s': %llu", file->relativePath, (u64)file->size);
         }
+
+        mod_load_from_cache(mod);
     }
     gRemoteMods.size = totalSize;
 

src/pc/utils/md5.c

@@ -0,0 +1,303 @@
+/*
+ * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
+ * MD5 Message-Digest Algorithm (RFC 1321).
+ *
+ * Homepage:
+ * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
+ *
+ * Author:
+ * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
+ *
+ * This software was written by Alexander Peslyak in 2001.  No copyright is
+ * claimed, and the software is hereby placed in the public domain.
+ * In case this attempt to disclaim copyright and place the software in the
+ * public domain is deemed null and void, then the software is
+ * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
+ * general public under the following terms:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted.
+ *
+ * There's ABSOLUTELY NO WARRANTY, express or implied.
+ *
+ * (This is a heavily cut-down "BSD license".)
+ *
+ * This differs from Colin Plumb's older public domain implementation in that
+ * no exactly 32-bit integer data type is required (any 32-bit or wider
+ * unsigned integer data type will do), there's no compile-time endianness
+ * configuration, and the function prototypes match OpenSSL's.  No code from
+ * Colin Plumb's implementation has been reused; this comment merely compares
+ * the properties of the two independent implementations.
+ *
+ * The primary goals of this implementation are portability and ease of use.
+ * It is meant to be fast, but not as fast as possible.  Some known
+ * optimizations are not included to reduce source code size and avoid
+ * compile-time configuration.
+ */
+
+#ifndef HAVE_OPENSSL
+
+#include <string.h>
+
+#include "md5.h"
+
+/*
+ * The basic MD5 functions.
+ *
+ * F and G are optimized compared to their RFC 1321 definitions for
+ * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
+ * implementation.
+ */
+#define F(x, y, z)			((z) ^ ((x) & ((y) ^ (z))))
+#define G(x, y, z)			((y) ^ ((z) & ((x) ^ (y))))
+#define H(x, y, z)			(((x) ^ (y)) ^ (z))
+#define H2(x, y, z)			((x) ^ ((y) ^ (z)))
+#define I(x, y, z)			((y) ^ ((x) | ~(z)))
+
+/*
+ * The MD5 transformation for all four rounds.
+ */
+#define STEP(f, a, b, c, d, x, t, s) \
+	(a) += f((b), (c), (d)) + (x) + (t); \
+	(a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
+	(a) += (b);
+
+/*
+ * SET reads 4 input bytes in little-endian byte order and stores them in a
+ * properly aligned word in host byte order.
+ *
+ * The check for little-endian architectures that tolerate unaligned memory
+ * accesses is just an optimization.  Nothing will break if it fails to detect
+ * a suitable architecture.
+ *
+ * Unfortunately, this optimization may be a C strict aliasing rules violation
+ * if the caller's data buffer has effective type that cannot be aliased by
+ * MD5_u32plus.  In practice, this problem may occur if these MD5 routines are
+ * inlined into a calling function, or with future and dangerously advanced
+ * link-time optimizations.  For the time being, keeping these MD5 routines in
+ * their own translation unit avoids the problem.
+ */
+#if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
+#define SET(n) \
+	(*(MD5_u32plus *)&ptr[(n) * 4])
+#define GET(n) \
+	SET(n)
+#else
+#define SET(n) \
+	(ctx->block[(n)] = \
+	(MD5_u32plus)ptr[(n) * 4] | \
+	((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
+	((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
+	((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
+#define GET(n) \
+	(ctx->block[(n)])
+#endif
+
+/*
+ * This processes one or more 64-byte data blocks, but does NOT update the bit
+ * counters.  There are no alignment requirements.
+ */
+static const void *body(MD5_CTX *ctx, const void *data, unsigned long size)
+{
+	const unsigned char *ptr;
+	MD5_u32plus a, b, c, d;
+	MD5_u32plus saved_a, saved_b, saved_c, saved_d;
+
+	ptr = (const unsigned char *)data;
+
+	a = ctx->a;
+	b = ctx->b;
+	c = ctx->c;
+	d = ctx->d;
+
+	do {
+		saved_a = a;
+		saved_b = b;
+		saved_c = c;
+		saved_d = d;
+
+/* Round 1 */
+		STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
+		STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
+		STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
+		STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
+		STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
+		STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
+		STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
+		STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
+		STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
+		STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
+		STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
+		STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
+		STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
+		STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
+		STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
+		STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
+
+/* Round 2 */
+		STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
+		STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
+		STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
+		STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
+		STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
+		STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
+		STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
+		STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
+		STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
+		STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
+		STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
+		STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
+		STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
+		STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
+		STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
+		STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
+
+/* Round 3 */
+		STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
+		STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11)
+		STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
+		STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23)
+		STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
+		STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11)
+		STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
+		STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23)
+		STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
+		STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11)
+		STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
+		STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23)
+		STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
+		STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11)
+		STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
+		STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23)
+
+/* Round 4 */
+		STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
+		STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
+		STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
+		STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
+		STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
+		STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
+		STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
+		STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
+		STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
+		STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
+		STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
+		STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
+		STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
+		STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
+		STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
+		STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
+
+		a += saved_a;
+		b += saved_b;
+		c += saved_c;
+		d += saved_d;
+
+		ptr += 64;
+	} while (size -= 64);
+
+	ctx->a = a;
+	ctx->b = b;
+	ctx->c = c;
+	ctx->d = d;
+
+	return ptr;
+}
+
+void MD5_Init(MD5_CTX *ctx)
+{
+	ctx->a = 0x67452301;
+	ctx->b = 0xefcdab89;
+	ctx->c = 0x98badcfe;
+	ctx->d = 0x10325476;
+
+	ctx->lo = 0;
+	ctx->hi = 0;
+}
+
+void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size)
+{
+	MD5_u32plus saved_lo;
+	unsigned long used, available;
+
+	saved_lo = ctx->lo;
+	if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
+		ctx->hi++;
+	ctx->hi += size >> 29;
+
+	used = saved_lo & 0x3f;
+
+	if (used) {
+		available = 64 - used;
+
+		if (size < available) {
+			memcpy(&ctx->buffer[used], data, size);
+			return;
+		}
+
+		memcpy(&ctx->buffer[used], data, available);
+		data = (const unsigned char *)data + available;
+		size -= available;
+		body(ctx, ctx->buffer, 64);
+	}
+
+	if (size >= 64) {
+		data = body(ctx, data, size & ~(unsigned long)0x3f);
+		size &= 0x3f;
+	}
+
+	memcpy(ctx->buffer, data, size);
+}
+
+#define OUT(dst, src) \
+	(dst)[0] = (unsigned char)(src); \
+	(dst)[1] = (unsigned char)((src) >> 8); \
+	(dst)[2] = (unsigned char)((src) >> 16); \
+	(dst)[3] = (unsigned char)((src) >> 24);
+
+void MD5_Final(unsigned char *result, MD5_CTX *ctx)
+{
+	unsigned long used, available;
+
+	used = ctx->lo & 0x3f;
+
+	ctx->buffer[used++] = 0x80;
+
+	available = 64 - used;
+
+	if (available < 8) {
+		memset(&ctx->buffer[used], 0, available);
+		body(ctx, ctx->buffer, 64);
+		used = 0;
+		available = 64;
+	}
+
+	memset(&ctx->buffer[used], 0, available - 8);
+
+	ctx->lo <<= 3;
+	OUT(&ctx->buffer[56], ctx->lo)
+	OUT(&ctx->buffer[60], ctx->hi)
+
+	body(ctx, ctx->buffer, 64);
+
+	OUT(&result[0], ctx->a)
+	OUT(&result[4], ctx->b)
+	OUT(&result[8], ctx->c)
+	OUT(&result[12], ctx->d)
+
+	memset(ctx, 0, sizeof(*ctx));
+}
+
+#endif
+
+// my additions below
+#include <stdio.h>
+
+void MD5_ToString(unsigned char* dataHash, char* outString) {
+	for (int i = 0; i < 16; i++) {
+		if (snprintf(&outString[i*2], 3, "%02x", dataHash[i]) < 0) {
+			return;
+		}
+	}
+	outString[33] = '\0';
+}

src/pc/utils/md5.h

@@ -0,0 +1,47 @@
+/*
+ * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
+ * MD5 Message-Digest Algorithm (RFC 1321).
+ *
+ * Homepage:
+ * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
+ *
+ * Author:
+ * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
+ *
+ * This software was written by Alexander Peslyak in 2001.  No copyright is
+ * claimed, and the software is hereby placed in the public domain.
+ * In case this attempt to disclaim copyright and place the software in the
+ * public domain is deemed null and void, then the software is
+ * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
+ * general public under the following terms:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted.
+ *
+ * There's ABSOLUTELY NO WARRANTY, express or implied.
+ *
+ * See md5.c for more information.
+ */
+
+#ifdef HAVE_OPENSSL
+#include <openssl/md5.h>
+#elif !defined(_MD5_H)
+#define _MD5_H
+
+/* Any 32-bit or wider unsigned integer data type will do */
+typedef unsigned int MD5_u32plus;
+
+typedef struct {
+	MD5_u32plus lo, hi;
+	MD5_u32plus a, b, c, d;
+	unsigned char buffer[64];
+	MD5_u32plus block[16];
+} MD5_CTX;
+
+extern void MD5_Init(MD5_CTX *ctx);
+extern void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size);
+extern void MD5_Final(unsigned char *result, MD5_CTX *ctx);
+
+#endif
+
+void MD5_ToString(unsigned char* dataHash, char* outString);