Resolve all compiled warnings

Makefile

@@ -19,8 +19,8 @@ mice:
 	-@subst $(BUILD_DRIVE) .
 	@cd /D $(BUILD_DRIVE) \
 	& $(VCVARS) \
-	& meson setup --cross cross-32.ini $(BUILD_DRIVE)\$(BUILD_DIR) \
+	& meson.py setup --cross cross-32.ini $(BUILD_DRIVE)\$(BUILD_DIR) \
-	& meson compile -C $(BUILD_DRIVE)\$(BUILD_DIR)
+	& meson.py compile -C $(BUILD_DRIVE)\$(BUILD_DIR)
 	@subst $(BUILD_DRIVE) /D
 
 .PHONY: clean
@@ -50,18 +50,10 @@ dist:
 
 	@copy /Y "$(BUILD_DIR)/src/micetools/miceboot\miceprestartup.exe" "$(DIST_DIR)/Execute/miceprestartup.exe"
 	@copy /Y "$(BUILD_DIR)/src/micetools/miceboot\micestartup.exe" "$(DIST_DIR)/Execute/micestartup.exe"
-	@copy /Y "$(BUILD_DIR)/src/micetools/miceboot\TrueCrypt.exe" "$(DIST_DIR)/Execute/TrueCrypt.exe"
 	@copy /Y "$(BUILD_DIR)/src/micetools/miceboot\mxmaster.exe" "$(DIST_DIR)/Execute/S/mxmaster.exe"
 
 	@copy /Y "$(BUILD_DIR)/src/micetools/util\*.exe" "$(DIST_DIR)/util/"
 	@copy /Y "$(BUILD_DIR)/src/micetools/util\*.pdb" "$(DIST_DIR)/util/"
 
-	@copy /Y "$(BUILD_DIR)/src/micetools/system_dummy\dummymaster\dummymaster.exe" "$(DIST_DIR)/system_dummy/dummymaster.exe"
-	@copy /Y "$(BUILD_DIR)/src/micetools/system_dummy\dummyinstaller\dummyinstaller.exe" "$(DIST_DIR)/system_dummy/dummyinstaller.exe"
-	@copy /Y "$(BUILD_DIR)/src/micetools/system_dummy\dummykeychip\dummykeychip.exe" "$(DIST_DIR)/system_dummy/dummykeychip.exe"
-
-	@copy /Y "src/micetools/miceboot\TrueCrypt.cmd" "$(DIST_DIR)/Execute/TrueCrypt.cmd"
-
 	@xcopy /E /H /C /R /Q /Y src\system "$(DIST_DIR)\system/*"
-	@xcopy /E /H /C /R /Q /Y src\tools "$(DIST_DIR)\tools/*"
 	@xcopy /E /H /C /R /Q /Y src\patches "$(DIST_DIR)\patches/*"

cross-32.ini

@@ -2,6 +2,7 @@
 c = 'cl'
 cpp = 'cl'
 strip = 'cl'
+ar = ['lib', '/LTCG']
 
 [host_machine]
 system = 'windows'

meson.py

@@ -1,6 +1,7 @@
 import sys
 import os
 from mesonbuild import mesonmain
+from mesonbuild.linkers.linkers import StaticLinker, VisualStudioLikeLinker, VisualStudioLinker
 
 # https://bugs.python.org/issue36112
 os.path.realpath = lambda path: path

src/micetools/dll/amvStub/amv.c

@@ -16,7 +16,7 @@ __declspec(dllexport) int amvGetConnectedDisplaysEx_Nvidia(LPVOID pGpuHandle, DW
     return 0;
 }
 __declspec(dllexport) int amvGetConnectedDisplays_Nvidia(LPBYTE displayType) {
-    return amvGetConnectedDisplays_Nvidia(NULL, 4, displayType);
+    return amvGetConnectedDisplaysEx_Nvidia(NULL, 4, displayType);
 }
 __declspec(dllexport) int amvGetCurrentPstateEx_Nvidia(LPVOID pGpuHandle, DWORD dwGpuHandleSize,
                                                        DWORD* pPstate) {

src/micetools/dll/devices/smb_at24c64an.c

@@ -48,8 +48,7 @@ void set_eeprom_static_config() {
     memcpy(&EEPROM_DATA[AM_SYSDATAwH_STATIC_DUP], &Static, sizeof Static);
 }
 
-void build_eeprom() {
+void build_eeprom() {    // return;
-    return;
     log_info(plfEeprom, "Building default EEPROM file");
 
     memset(EEPROM_DATA, 0xff, EEPROM_SIZE);

src/micetools/dll/drivers/mxsram.c

@@ -23,8 +23,9 @@ void build_sram() {
     log_info(plfMxSram, "Building default SRAM file");
 
     memset(SRAM_DATA, 0xff, SRAM_SIZE);
-    return;
 
+    // TODO: Do we want to re-enable this with actual values
+#if false
     AM_SYSDATAwH_BACKUP Backup = { 0 };
     fix_crc(Backup);
     memcpy(SRAM_DATA + ADDR_BACKUP, (unsigned char*)&Backup, sizeof Backup);
@@ -44,6 +45,7 @@ void build_sram() {
     fix_crc(ErrorLog);
     memcpy(SRAM_DATA + ADDR_ERROR_LOG, (unsigned char*)&ErrorLog, sizeof ErrorLog);
     memcpy(SRAM_DATA + ADDR_ERROR_LOG + ADDR_DUP, (unsigned char*)&ErrorLog, sizeof ErrorLog);
+#endif
 
     return;
 }

src/micetools/dll/hooks/files.c

@@ -345,9 +345,11 @@ HANDLE WINAPI FakeFindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATA lpFindFile
 
 DWORD WINAPI FakeGetCurrentDirectoryA(DWORD nBufferLength, LPSTR lpBuffer) {
     strcpy_s(lpBuffer, nBufferLength, MiceFSGetCwd());
+    return strnlen_s(lpBuffer, nBufferLength);
 }
 DWORD WINAPI FakeGetCurrentDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer) {
     MultiByteToWideChar(CP_ACP, 0, MiceFSGetCwd(), -1, lpBuffer, nBufferLength);
+    return wcsnlen_s(lpBuffer, nBufferLength);
 }
 
 void hook_io() {

src/micetools/dll/hooks/network.c

@@ -153,22 +153,22 @@ int __stdcall Fake_socket(int domain, int type, int protocol) {
     return sock;
 }
 
-static struct sockaddr pingSentTo;
+static SOCKADDR pingSentTo;
 static unsigned char pingInfo[4];
 
-static struct sockaddr_in toLocalhost = {
+static SOCKADDR_IN toLocalhost = {
-    .sin_addr = 0x0100007f,
+    .sin_addr.S_un.S_addr = 0x0100007f,
     .sin_family = AF_INET,
     .sin_port = 24,
     .sin_zero = 0,
 };
 
-int __stdcall Fake_sendto(SOCKET s, const char* buf, int len, int flags, const struct sockaddr* to,
+int __stdcall Fake_sendto(SOCKET s, const char* buf, int len, int flags, const PSOCKADDR to,
                           int tolen) {
     // Hardcoded ICMP4 ping "detection"
     // TODO: Only do this if the socket is using the ICMP protocol
     if (len == 8 && buf[0] == 0x08 && buf[1] == 0x00) {
-        uint32_t addr = ((struct sockaddr_in*)to)->sin_addr.S_un.S_addr;
+        uint32_t addr = ((PSOCKADDR_IN)to)->sin_addr.S_un.S_addr;
 
         memcpy(&pingSentTo, to, sizeof pingSentTo);
 
@@ -178,11 +178,12 @@ int __stdcall Fake_sendto(SOCKET s, const char* buf, int len, int flags, const s
 
         memcpy(&toLocalhost, to, sizeof toLocalhost);
         toLocalhost.sin_addr.S_un.S_addr = 0x0100007f;  // 127.0.0.1
-        to = &toLocalhost;
 
         log_warning(plfNetwork, "(probable) Ping to: %d.%d.%d.%d (%d). Redirecting to localhost",
                     addr & 0xff, (addr >> 8) & 0xff, (addr >> 16) & 0xff, addr >> 24,
-                    ((struct sockaddr_in*)to)->sin_port, seq);
+                    ((PSOCKADDR_IN)to)->sin_port, seq);
+
+        return True_sendto(s, buf, len, flags, (PSOCKADDR)&toLocalhost, tolen);
     }
 
     return True_sendto(s, buf, len, flags, to, tolen);

src/micetools/dll/hooks/registry.c

@@ -29,7 +29,7 @@ LSTATUS WINAPI FakeRegEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpName, LPDWORD
                                  PFILETIME lpftLastWriteTime) {
     log_misc(plfRegistry, "RegEnumKeyExA %08x[%d]", hKey, dwIndex);
     if (dwIndex == 0 && !bHALDeleted) {
-        strcpy(lpName, "Direct3D HAL");
+        strcpy_s(lpName, RSIZE_MAX, "Direct3D HAL");
         return ERROR_SUCCESS;
     }
     return ERROR_NO_MORE_ITEMS;

src/micetools/dll/hooks/system.c

@@ -71,7 +71,7 @@ HMODULE WINAPI FakeLoadLibraryA(LPCSTR lpLibFileName) {
     }
     return TrueLoadLibraryA(lpLibFileName);
 }
-#define WIDEN2(x) L ## x
+#define WIDEN2(x) L##x
 #define WIDEN(x) WIDEN2(x)
 HMODULE WINAPI FakeLoadLibraryW(LPCWSTR lpLibFileName) {
     if (wcscmp(lpLibFileName, L"libamv_nvidia.dll") == 0) {
@@ -107,10 +107,13 @@ void hook_system() {
          "UeI3d2jT+Fw1dgRn7wIDAQAB\r\n"
          "-----END PUBLIC KEY-----\r\n");
 
-    hook_file_with_buffer(L"C:\\System\\SystemVersion.txt", SystemVersion,
+    // We're going to violate the non-const data requirements for these files,
+    // because we're only allowing GENERIC_READ. In the future this may be made
+    // more generic.
+    hook_file_with_buffer(L"C:\\System\\SystemVersion.txt", (LPBYTE)SystemVersion,
                           strlen(SystemVersion) + 1, GENERIC_READ);
-    hook_file_with_buffer(L"C:\\System\\UpdateVersion.txt", UpdateVersion,
+    hook_file_with_buffer(L"C:\\System\\UpdateVersion.txt", (LPBYTE)UpdateVersion,
                           strlen(UpdateVersion) + 1, GENERIC_READ);
-    hook_file_with_buffer(L"c:\\System\\Execute\\ringmaster_pub.pem", RingmasterPub,
+    hook_file_with_buffer(L"c:\\System\\Execute\\ringmaster_pub.pem", (LPBYTE)RingmasterPub,
                           strlen(RingmasterPub) + 1, GENERIC_READ);
 }

src/micetools/dll/util/_util.h

@@ -12,6 +12,10 @@ void SetDataForHandle(HANDLE hObject, DWORD type, PVOID pData, BOOL isHeap);
 BOOL RemoveDataForHandle(HANDLE hObject, DWORD type);
 HANDLE GetDummyHandle();
 void BytesToHex(char* hex_buffer, BYTE* bytes, DWORD nbytes);
+
+/**
+ * WARNING: This function will not work on XP machines!!
+ */
 void PrintStack(void);
 
 BOOL PathEqual(LPCSTR path1, LPCSTR path2);

src/micetools/dll/util/misc.c

@@ -1,3 +1,6 @@
+// Windows XP does not have RtlCaptureStackBackTrace. This is an awful workaround.
+// TODO: Reimplement this ourselves so we can print stacks on XP
+#undef _WIN32_WINNT
 #define _WIN32_WINNT 0x0600
 #include <Windows.h>
 #include <dbghelp.h>
@@ -22,7 +25,7 @@ void PrintStack(void) {
 
     for (i = 0; i < frames; i++) {
         SymFromAddr(process, (DWORD64)(stack[i]), 0, symbol);
-        printf("%i: %s - 0x%0X\n", frames - i - 1, symbol->Name, symbol->Address);
+        printf("%i: %s - 0x%0X\n", frames - i - 1, symbol->Name, (unsigned int)symbol->Address);
     }
 
     free(symbol);
@@ -118,7 +121,7 @@ HANDLE GetDummyHandle() {
 
 void BytesToHex(char* hex_buffer, BYTE* bytes, DWORD nbytes) {
     for (size_t i = 0; i < nbytes; i++) {
-        sprintf(hex_buffer + i * 3, "%02x ", bytes[i]);
+        sprintf_s(hex_buffer + i * 3, RSIZE_MAX, "%02x ", bytes[i]);
     }
     hex_buffer[nbytes * 3] = '\0';
 }
@@ -153,13 +156,17 @@ void make_dirs(const char* path) {
     free(temp);
 }
 
-void* open_mapped_file(LPCWSTR path, DWORD size, HANDLE* file, HANDLE* file_mapping) {
+void* open_mapped_file(LPCWSTR lpFilename, DWORD size, HANDLE* file, HANDLE* file_mapping) {
-    make_dirs(path);
+    char szFileName[MAX_PATH] = { 0 };
-    *file = _CreateFileW(path, GENERIC_READ | GENERIC_WRITE,
+    WideCharToMultiByte(CP_ACP, 0, lpFilename, wcslen(lpFilename), szFileName, sizeof szFileName,
+                        NULL, NULL);
+    make_dirs(szFileName);
+
+    *file = _CreateFileW(lpFilename, GENERIC_READ | GENERIC_WRITE,
                          FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_ALWAYS,
                          FILE_ATTRIBUTE_NORMAL, NULL);
     if (*file == INVALID_HANDLE_VALUE) {
-        log_error(plfMisc, "Failed to CreateFileW(%ls): %d", path, GetLastError());
+        log_error(plfMisc, "Failed to CreateFileW(%ls): %d", lpFilename, GetLastError());
         return NULL;
     }
 

src/micetools/lib/am/amDongle.c

@@ -44,8 +44,7 @@ AM_DONGLE_STATUS amDongleInit(void) {
     }
     if (pcpa_err != e_pcpa_ok) {
         if (amDongleDebugLevel > 0) {
-            amiDebugLog("Error: System error happened in pcp stream. ErrorCode = %d.",
+            amiDebugLog("Error: System error happened in pcp stream. ErrorCode = %d.", pcpa_err);
-                            pcpa_err);
         }
         return AM_DONGLE_STATUS_ERR_SYS;
     }
@@ -160,8 +159,7 @@ AM_DONGLE_STATUS amDongleSetupKeychip(void) {
             pcpa_err = pcpaOpenClient(&amDongle.pcpa, "127.0.0.1", amDongle.ctrl_port, 90000, 0);
             if (pcpa_err != e_pcpa_ok) {
                 if (pcpa_err != e_pcpa_to) {
-                    if (amDongleDebugLevel > 0)
+                    if (amDongleDebugLevel > 0) amiDebugLog("Error : pcpaOpenClient(%d)", pcpa_err);
-                        amiDebugLog("Error : pcpaOpenClient(%d)", pcpa_err);
 
                     amDongle.setupSeq = AM_DONGLE_SETUP_SEQ_ERR;
                     return AM_DONGLE_STATUS_PENDING;
@@ -387,10 +385,12 @@ AM_DONGLE_STATUS amDongleResponseCheck(void) {
             return AM_DONGLE_STATUS_OK;
         case AM_DONGLE_REQUEST_GET_PLATFORM_ID:
             if (strcmp(keyword, "keychip.appboot.platformid") || command == NULL) break;
-            strcpy_s(amDongle.valueBuffer, 4, command);
+            strcpy_s((char *)amDongle.valueBuffer, 4, command);
             return AM_DONGLE_STATUS_OK;
         case AM_DONGLE_REQUEST_GET_NETWORK_ADDRESS:
             if (strcmp(keyword, "keychip.appboot.networkaddr") || command == NULL) break;
+                // We can't use inet_pton because we target XP
+#pragma warning(suppress : 4996)
             if (amDongle.valueBuffer != NULL) *(uint *)amDongle.valueBuffer = inet_addr(command);
             return AM_DONGLE_STATUS_OK;
         case AM_DONGLE_REQUEST_GET_VERSION:
@@ -401,27 +401,27 @@ AM_DONGLE_STATUS amDongleResponseCheck(void) {
             return AM_DONGLE_STATUS_OK;
         case AM_DONGLE_REQUEST_BILLING_GET_KEYCHIP_ID:
             if (strcmp(keyword, "keychip.billing.keyid") || command == NULL) break;
-            strcpy_s(amDongle.valueBuffer, 0x11, command);
+            strcpy_s((char *)amDongle.valueBuffer, 17, command);
             return AM_DONGLE_STATUS_OK;
         case AM_DONGLE_REQUEST_BILLING_GET_MAIN_ID:
             if (strcmp(keyword, "keychip.billing.mainid") || command == NULL) break;
-            strcpy_s(amDongle.valueBuffer, 0xc, command);
+            strcpy_s((char *)amDongle.valueBuffer, 12, command);
             return AM_DONGLE_STATUS_OK;
         case AM_DONGLE_REQUEST_BILLING_GET_PLAYCOUNT:
             if (strcmp(keyword, "keychip.billing.playcount") || command == NULL) break;
-            hex_to_int(amDongle.valueBuffer, command);
+            hex_to_int((unsigned int *)amDongle.valueBuffer, command);
             return AM_DONGLE_STATUS_OK;
         case AM_DONGLE_REQUEST_BILLING_ADD_PLAYCOUNT:
             if (strcmp(keyword, "keychip.billing.playcount") || command == NULL) break;
-            hex_to_int(amDongle.valueBuffer, command);
+            hex_to_int((unsigned int *)amDongle.valueBuffer, command);
             return AM_DONGLE_STATUS_OK;
         case AM_DONGLE_REQUEST_BILLING_GET_PLAYLIMIT:
             if (strcmp(keyword, "keychip.billing.playlimit") || command == NULL) break;
-            hex_to_int(amDongle.valueBuffer, command);
+            hex_to_int((unsigned int *)amDongle.valueBuffer, command);
             return AM_DONGLE_STATUS_OK;
         case AM_DONGLE_REQUEST_BILLING_GET_NEARFULL:
             if (strcmp(keyword, "keychip.billing.nearfull") || command == NULL) break;
-            hex_to_int(amDongle.valueBuffer, command);
+            hex_to_int((unsigned int *)amDongle.valueBuffer, command);
             return AM_DONGLE_STATUS_OK;
         case AM_DONGLE_REQUEST_BILLING_TD_RESTORE:
             if (strcmp(keyword, "keychip.tracedata.restore") || command == NULL) break;
@@ -1133,8 +1133,7 @@ AM_DONGLE_STATUS amDongleSetIv(AM_DONGLE_BLOCKING blocking) {
     if (!amDongle.done_init || !amDongle.available) return AM_DONGLE_STATUS_NG;
     if (amDongle.seq != AM_DONGLE_SEQ_NONE) return AM_DONGLE_STATUS_BUSY;
 
-    pcp_send_data_t *send_data =
+    pcp_send_data_t *send_data = pcpaSetSendPacket(&amDongle.pcpa, "keychip.setiv", "?");
-        pcpaSetSendPacket(&amDongle.pcpa, "keychip.setiv", "?");
     if (send_data == NULL && amDongleDebugLevel > 0) {
         amiDebugLog("Error: pcpaSetSendPacket return NULL");
     }
@@ -1146,15 +1145,14 @@ AM_DONGLE_STATUS amDongleSetIv(AM_DONGLE_BLOCKING blocking) {
     return amDongleOpen();
 }
 
-AM_DONGLE_STATUS amDongleGetSeed(unsigned char* seed, AM_DONGLE_BLOCKING blocking) {
+AM_DONGLE_STATUS amDongleGetSeed(unsigned char *seed, AM_DONGLE_BLOCKING blocking) {
     if (!amDongle.m_init) return AM_DONGLE_STATUS_ERR_NO_INIT;
     if (!amDongle.auth_ready) return AM_DONGLE_STATUS_ERR_AUTH_READY;
     if (!amDongle.done_init || !amDongle.available) return AM_DONGLE_STATUS_NG;
     if (amDongle.seq != AM_DONGLE_SEQ_NONE) return AM_DONGLE_STATUS_BUSY;
     if (seed == NULL) return AM_DONGLE_STATUS_ERR_INVALID_PARAM;
 
-    pcp_send_data_t *send_data =
+    pcp_send_data_t *send_data = pcpaSetSendPacket(&amDongle.pcpa, "keychip.appboot.seed", "?");
-        pcpaSetSendPacket(&amDongle.pcpa, "keychip.appboot.seed", "?");
     if (send_data == NULL && amDongleDebugLevel > 0) {
         amiDebugLog("Error: pcpaSetSendPacket return NULL");
     }

src/micetools/lib/ami/amiCrc.c

@@ -20,10 +20,11 @@ void amiCrc32RCreateTable(uint32_t *table) {
 
 uint32_t amiCrc32RGet(uint32_t *table, int length, void *data, uint32_t initial) {
     uint32_t value = ~initial;
+    unsigned char* lpcData = (unsigned char*)data;
     while (length > 0) {
-        value = value >> 8 ^ table[(((unsigned char *)data)[0] ^ value) & 0xff];
+        value = value >> 8 ^ table[(lpcData[0] ^ value) & 0xff];
         length += -1;
-        ((unsigned char *)data)++;
+        lpcData++;
     }
     return ~value;
 }

src/micetools/lib/ami/amiTimer.h

@@ -19,7 +19,7 @@ amtime_t* amiTimerGet(amtime_t* time);
 
 #define _amTimeMs(time) (((time).microseconds / 1000 + (time).seconds * 1000))
 #define _amTimeDelta(now, start) \
-    (((now).microseconds - (start).microseconds) / 1000 + ((now).seconds - (start).seconds) * 1000)
+    (int)(((now).microseconds - (start).microseconds) / 1000 + ((now).seconds - (start).seconds) * 1000)
 
 int amiTimerDiffSec(amtime_t* start, amtime_t* now);
 int amiTimerDiffMsec(amtime_t* start, amtime_t* now);

src/micetools/lib/libpcp/pcp.h

@@ -4,10 +4,10 @@
 #define ZERO_BUF(x) memset((x), 0, sizeof(*x))
 
 #include <Winsock2.h>
-#include <ws2ipdef.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <ws2ipdef.h>
 
 #include "../ami/ami.h"
 
@@ -29,7 +29,7 @@ typedef unsigned char byte;
 typedef unsigned short ushort;
 typedef unsigned int uint;
 
-typedef unsigned int timeout_t;
+typedef int timeout_t;
 
 #define PCP_BUF_MAX 256
 #define PCP_CMDS_MAX 64
@@ -58,11 +58,6 @@ typedef enum binary_mode {
     binary_mode_recv = 2,
 } binary_mode_t;
 
-#define PCPT_CONFIG_0 0
-#define PCPT_CONFIG_1 1
-#define PCPT_SO_LINGER 2
-#define PCPT_TCP_NODELAY 3
-
 #define SOCKET_INVAL ((SOCKET)-1)
 #define HANDLE_INVAL -1
 #define TIMEOUT_NONE ((timeout_t)-1)

src/micetools/lib/libpcp/pcpa.c

@@ -137,7 +137,7 @@ e_pcpa_t pcpaOpenClient(pcpa_t *stream, char *ipAddr, ushort port, uint param_4,
 }
 
 e_pcpa_t pcpaOpenServerWithBinary(pcpa_t *stream, int open_mode, u_short port, u_short binary_port,
-                                  undefined4 param_5) {
+                                  timeout_t param_5) {
     e_pcpa_t err;
 
     if (stream == NULL) {
@@ -524,7 +524,7 @@ LAB_00454d84:
     return stream->err;
 }
 
-e_pcpa_t pcpaRecvBinary(pcpa_t *stream, uint something) {
+e_pcpa_t pcpaRecvBinary(pcpa_t *stream, timeout_t something) {
     if (stream == NULL) {
         amiDebugLog("error PCPA stream isn't set");
         return e_pcpa_stream_unset;
@@ -545,7 +545,7 @@ e_pcpa_t pcpaRecvBinary(pcpa_t *stream, uint something) {
     return err;
 }
 
-e_pcpa_t pcpaSendBinary(pcpa_t *stream, uint param_2) {
+e_pcpa_t pcpaSendBinary(pcpa_t *stream, timeout_t param_2) {
     if (stream == NULL) {
         amiDebugLog("error PCPA stream isn't set");
         return e_pcpa_stream_unset;
@@ -678,7 +678,7 @@ e_pcpa_t pcpaIsBusy(pcpa_t *pcpa, timeout_t timeout) {
         pcpa->state = 12;
         if (timeout != TIMEOUT_NONE) {
             amiTimerGet(&now);
-            uint dt = _amTimeDelta(now, start);
+            timeout_t dt = _amTimeDelta(now, start);
             if (dt < timeout) {
                 timeout -= dt;
             } else {
@@ -692,7 +692,7 @@ e_pcpa_t pcpaIsBusy(pcpa_t *pcpa, timeout_t timeout) {
         pcpa->state = 14;
         if (timeout != TIMEOUT_NONE) {
             amiTimerGet(&now);
-            uint dt = _amTimeDelta(now, start);
+            timeout_t dt = _amTimeDelta(now, start);
             if (dt < timeout) {
                 timeout -= dt;
             } else {
@@ -764,6 +764,8 @@ e_pcpa_t pcpaOpenBinaryClient(pcpa_t *stream, ushort port, timeout_t timeout) {
 
     SOCKADDR_IN *addr = (SOCKADDR_IN *)pcppGetSockAddr(&stream->pcpp, false);
     stream->state = pcpa_state_open_binary;
+    // We can't use inet_ntop because we target XP
+#pragma warning(suppress : 4996)
     char *ipAddr = inet_ntoa(addr->sin_addr);
 
     e_pcpa_t pcpa_err =
@@ -799,7 +801,7 @@ e_pcpa_t pcpaAccessClient(pcpa_t *stream, timeout_t timeout) {
 
         if (timeout != TIMEOUT_NONE) {
             amiTimerGet(&now);
-            uint delta = amiTimerDiffMsec(&start, &now);
+            timeout_t delta = amiTimerDiffMsec(&start, &now);
             if (delta < timeout) {
                 timeout -= delta;
             } else {

src/micetools/lib/libpcp/pcpa.h

@@ -61,7 +61,7 @@ typedef struct pcpa {
     uint callback_count;
     unsigned char* recv_buffer;
     size_t recv_buffer_len;
-    unsigned char* send_buffer;
+    const unsigned char* send_buffer;
     size_t send_buffer_len;
     binary_mode_t binary_mode;
     pcpa_callback* binary_mode_before_cb;
@@ -81,9 +81,9 @@ void pcpaCloseBinary(pcpa_t* stream);
 char* pcpaGetKeyword(pcpa_t* stream, uint keyword_num);
 e_pcpa_t pcpaInitStream(pcpa_t* stream);
 e_pcpa_t pcpaOpenClient(pcpa_t* stream, char* ipAddr, ushort port, uint param_4, timeout_t timeout);
-e_pcpa_t pcpaOpenServerWithBinary(pcpa_t* stream, int open_mode, ushort port, ushort binary_port, undefined4 param_5);
+e_pcpa_t pcpaOpenServerWithBinary(pcpa_t* stream, int open_mode, ushort port, ushort binary_port, timeout_t param_5);
-e_pcpa_t pcpaRecvBinary(pcpa_t* stream, undefined4 something);
+e_pcpa_t pcpaRecvBinary(pcpa_t* stream, timeout_t something);
-e_pcpa_t pcpaSendBinary(pcpa_t* stream, undefined4 something);
+e_pcpa_t pcpaSendBinary(pcpa_t* stream, timeout_t something);
 e_pcpa_t pcpaServer(pcpa_t* stream, timeout_t timeout_ms);
 e_pcpa_t pcpaSetAfterBinaryModeCallBackFunc(pcpa_t* stream, pcpa_callback* callback, void* data);
 e_pcpa_t pcpaSetBeforeBinaryModeCallBackFunc(pcpa_t* stream, pcpa_callback* callback, void* data);

src/micetools/lib/libpcp/pcpp.c

@@ -53,6 +53,14 @@ e_pcpp_t _pcppGetErrorFromPcpt(int err) {
     }
 }
 
+/**
+ * @brief Locate a PCP prompt string. The last prompt located in the
+ * buffer will be used, and all data following it moved to the
+ * beginning of the buffer.
+ *
+ * @return true
+ * @return false
+ */
 bool pcppCheckPrompt(pcpp_t* stream) {
     if (stream == NULL) {
         amiDebugLog("error PCPP stream isn't set");
@@ -64,18 +72,19 @@ bool pcppCheckPrompt(pcpp_t* stream) {
 
     for (uint cursor = 0; cursor < max; cursor++) {
         char* pos = stream->read_bytes_buf + cursor;
-        if (stream->read_bytes_buf[cursor] == '>') {
+        // Scan for the prompt character
-            if (cursor < stream->read_bytes_num) {
+        if (stream->read_bytes_buf[cursor] != PCP_CHAR_PROMPT) continue;
-                do {
+
-                    *pos = pos[1];
+        found = true;
-                    pos++;
+
-                } while (pos + (-204 - (int)stream) < (char*)stream->read_bytes_num);
+        // Shift everything one character left (clobber the prompt)
+        for (uint i = cursor; i < stream->read_bytes_num - 1; i++) {
+            pos[i] = pos[i + 1];
         }
 
+        // Adjust counts accordingly
         stream->read_bytes_num--;
         stream->read_bytes_size++;
-            found = true;
-        }
     }
 
     return found;
@@ -218,7 +227,7 @@ void pcppCloseBinary(pcpp_t* stream) {
 }
 
 e_pcpp_t pcppGetBlockingTime(uint param_1, timeout_t timeout, pcpp_t* stream, int param_4,
-                             uint* blocking_time) {
+                             timeout_t* blocking_time) {
     byte bVar1;
     uint uVar2;
     uint uVar3;
@@ -348,7 +357,7 @@ e_pcpp_t pcppInitStream(pcpp_t* stream) {
 e_pcpp_t pcppOpenClient(pcpp_t* stream, char* ipAddr, ushort port, uint param_4,
                         timeout_t timeout) {
     e_pcpp_t iVar1;
-    uint uVar3;
+    timeout_t uVar3;
     amtime_t start;
     amtime_t now;
 
@@ -739,14 +748,17 @@ e_pcpp_t pcppRecvRequestMain(pcpp_t* stream, bool* bReRecv, undefined4 timeout)
     recv_data = stream->read_bytes_buf;
     if (pcppCheckRecvMsg(recv_data, stream->read_bytes_num, 1) != e_pcpp_ok) {
         pcppResetRead(stream);
-        return -9;
+        return e_pcpp_data_format_error;
     }
 
     uint local_4 = 0;
     pcppChangeRequest(stream, &local_4);
 
-    if (local_4 < stream->read_bytes_num)
+    if (local_4 < stream->read_bytes_num) {
-        memcpy(recv_data + local_4, recv_data, stream->read_bytes_num);
+        for (uint i = 0; i < stream->read_bytes_num; i++) {
+            recv_data[local_4 + i] = recv_data[i];
+        }
+    }
 
     stream->read_bytes_num -= local_4;
     stream->read_bytes_size += local_4;
@@ -795,10 +807,9 @@ LAB_00456133:
 e_pcpp_t pcppRecvAllMsg(pcpp_t* stream, uint param_1, bool* bReRecv) {
     uint* recv_buf_len;
     int iVar1;
-    e_pcpt_t err;
     e_pcpp_t eVar2;
     undefined4 uVar3;
-    uint local_14;
+    timeout_t local_14;
     amtime_t local_10;
     amtime_t local_8;
 
@@ -947,11 +958,11 @@ pcp_parse_data_t* pcppChangeRequest(pcpp_t* stream, uint* lenout) {
     return stream->recv_data_buffer;
 }
 
-int pcppRecvPrompt(pcpp_t* stream, undefined4 param_2, int param_3) {
+int pcppRecvPrompt(pcpp_t* stream, undefined4 param_2, timeout_t param_3) {
     uint* recv_buf_len;
     int iVar1;
 
-    uint local_c = param_3;
+    timeout_t local_c = param_3;
     if (stream == NULL) {
         amiDebugLog("error PCPP stream isn't set");
         return e_pcpp_param_invalid;
@@ -1023,19 +1034,20 @@ e_pcpp_t pcppSendRequestMain(pcpp_t* stream, undefined4 param_2, timeout_t timeo
 
 // TODO: MINIMAL CLEANUP DONE HERE
 
-e_pcpp_t pcppRecvBinary(pcpp_t* stream, unsigned char* recv_buf, size_t buf_len, uint param_4) {
+e_pcpp_t pcppRecvBinary(pcpp_t* stream, unsigned char* recv_buf, size_t buf_len,
+                        timeout_t timeout) {
     size_t* psVar1;
     int iVar2;
     e_pcpt_t eVar3;
     e_pcpp_t eVar4;
     undefined4 uVar5;
     bool bVar6;
-    uint recvb_local;
+    timeout_t timeout_local;
     amtime_t now;
     amtime_t local_10;
     amtime_t local_8;
 
-    recvb_local = param_4;
+    timeout_local = timeout;
     if (stream == NULL) {
         amiDebugLog("error PCPP stream isn't set");
         return e_pcpp_param_invalid;
@@ -1063,10 +1075,10 @@ e_pcpp_t pcppRecvBinary(pcpp_t* stream, unsigned char* recv_buf, size_t buf_len,
             stream->last_active = _amTimeMs(local_8);
             ;
         }
-        iVar2 = pcppGetBlockingTime(uVar5, param_4, stream, _amTimeMs(now), &recvb_local);
+        iVar2 = pcppGetBlockingTime(uVar5, timeout, stream, _amTimeMs(now), &timeout_local);
         stream->field_0x214 = 1;
         eVar3 = pcptRecv(&stream->data_sock, stream->recv_binary_buf + stream->field_0x1fc, psVar1,
-                         recvb_local);
+                         timeout_local);
         eVar4 = _errT2P(eVar3);
         stream->err = eVar4;
         if ((eVar4 == e_pcpp_to) && (iVar2 != 0)) {
@@ -1101,10 +1113,9 @@ e_pcpp_t pcppRecvBinary(pcpp_t* stream, unsigned char* recv_buf, size_t buf_len,
             stream->state = pcpp_state_send_binary_ack;
             send_buf[0] = PCP_CHAR_BINACK;
             *psVar1 = 1;
-            iVar2 = pcppGetBlockingTime(stream->field_0x20c, param_4, stream, _amTimeMs(now),
+            iVar2 = pcppGetBlockingTime(stream->field_0x20c, timeout, stream, _amTimeMs(now),
-                                        &recvb_local);
+                                        &timeout_local);
-            eVar3 = pcptSend(&stream->sock, send_buf, psVar1, stream->field_0x208,
+            eVar3 = pcptSend(&stream->sock, send_buf, psVar1, stream->field_0x208, timeout_local);
-                             recvb_local);
             eVar4 = _errT2P(eVar3);
             stream->err = eVar4;
             if ((eVar4 == e_pcpp_to) && (iVar2 != 0)) {
@@ -1120,12 +1131,11 @@ e_pcpp_t pcppRecvBinary(pcpp_t* stream, unsigned char* recv_buf, size_t buf_len,
                 amiTimerGet(&local_10);
                 stream->last_active = _amTimeMs(local_10);
                 stream->state = pcpp_state_send_binary_ack_wait;
-                iVar2 = pcppGetBlockingTime(stream->field_0x208, param_4, stream, _amTimeMs(now),
+                iVar2 = pcppGetBlockingTime(stream->field_0x208, timeout, stream, _amTimeMs(now),
-                                            &recvb_local);
+                                            &timeout_local);
                 *psVar1 = PCP_SEND_BUF_MAX;
                 ZERO(stream->send_buf);
-                eVar3 =
+                eVar3 = pcptRecv(&stream->data_sock, send_buf, psVar1, timeout_local);
-                    pcptRecv(&stream->data_sock, send_buf, psVar1, recvb_local);
                 eVar4 = _errT2P(eVar3);
                 stream->err = eVar4;
                 if ((iVar2 != 0) && (eVar4 == e_pcpp_to)) {
@@ -1144,7 +1154,7 @@ e_pcpp_t pcppRecvBinary(pcpp_t* stream, unsigned char* recv_buf, size_t buf_len,
     } while (true);
 }
 
-e_pcpp_t pcppSendBinary(pcpp_t* stream, unsigned char* send_binary_buffer, size_t param_3,
+e_pcpp_t pcppSendBinary(pcpp_t* stream, const unsigned char* send_binary_buffer, size_t param_3,
                         uint param_4)
 
 {
@@ -1154,7 +1164,7 @@ e_pcpp_t pcppSendBinary(pcpp_t* stream, unsigned char* send_binary_buffer, size_
     int iVar4;
     e_pcpt_t eVar5;
     uint uVar6;
-    uint local_14;
+    timeout_t local_14;
     amtime_t local_10;
     amtime_t local_8;
 
@@ -1222,17 +1232,13 @@ e_pcpp_t pcppSendBinary(pcpp_t* stream, unsigned char* send_binary_buffer, size_
             uVar6 = 0;
             *psVar1 = 8 - stream->field_0x1e8;
             stream->state = pcpp_state_none;
-            stream->err = -9;
+
-            if (stream->field_0x1e8 != 0) {
+            for (uint i = 0; i < stream->field_0x1e8; i++) {
-                while (*(char*)((int)&stream->send_buf + uVar6) != PCP_CHAR_BINACK) {
+                if (stream->send_buf[i] == PCP_CHAR_BINACK) {
-                    uVar6 = uVar6 + 1;
+                    return (stream->err = e_pcpp_ok);
-                    if (stream->field_0x1e8 <= uVar6) {
-                        return stream->err;
                 }
             }
-                stream->err = e_pcpp_ok;
+            return (stream->err = e_pcpp_data_format_error);
-            }
-            eVar3 = stream->err;
         }
     }
     return eVar3;
@@ -1245,12 +1251,11 @@ e_pcpp_t pcppIsBusy(pcpp_t* stream, timeout_t timeout) {
     int iVar3;
     e_pcpt_t eVar4;
     int iVar5;
-    uint uVar6;
+    timeout_t uVar6;
     e_pcpp_t eVar7;
     char* pcVar8;
-    char* pcVar9;
+    timeout_t uVar10;
-    uint uVar10;
+    timeout_t uVar11;
-    uint uVar11;
     bool bVar12;
     bool local_24;
     int local_20;
@@ -1306,7 +1311,10 @@ e_pcpp_t pcppIsBusy(pcpp_t* stream, timeout_t timeout) {
                                 stream->read_bytes_num + stream->read_bytes_size;
                             stream->read_bytes_size = PCP_BUF_MAX - stream->read_bytes_num;
                             iVar3 = pcppCheckPrompt(stream);
-                            if (iVar3 != 0) goto LAB_00457676;
+                            if (iVar3 != 0) {
+                                stream->err = e_pcpp_ok;
+                                return e_pcpp_ok;
+                            }
                             stream->err = ~e_pcpp_no_client;
                             goto LAB_00457660;
                         }
@@ -1418,10 +1426,7 @@ e_pcpp_t pcppIsBusy(pcpp_t* stream, timeout_t timeout) {
                     uVar6 = uVar11;
                     if (uVar11 != TIMEOUT_NONE) {
                         amiTimerGet(&local_8);
-                        uVar6 =
+                        uVar6 = amiTimerDiffMsec(&local_18, &local_8) < uVar11 ? uVar11 : 0;
-                            -(uint)((uint)((local_8.microseconds - local_18.microseconds) / 1000 +
-                                           (local_8.seconds - local_18.seconds) * 1000) < uVar11) &
-                            uVar11;
                     }
                     eVar7 = pcppRecvPrompt(stream, stream->field_0xb8, uVar6);
                     stream->err = eVar7;
@@ -1431,11 +1436,7 @@ e_pcpp_t pcppIsBusy(pcpp_t* stream, timeout_t timeout) {
                             if (uVar11 != TIMEOUT_NONE) {
                                 amiTimerGet(&local_8);
                                 uVar11 =
-                                    -(uint)((uint)((local_8.microseconds - local_18.microseconds) /
+                                    amiTimerDiffMsec(&local_18, &local_8) < uVar11 ? uVar11 : 0;
-                                                       1000 +
-                                                   (local_8.seconds - local_18.seconds) * 1000) <
-                                            uVar11) &
-                                    uVar11;
                             }
                             stream->state = pcpp_state_send_request;
                             eVar7 = pcppSendRequestMain(stream, stream->field_0xb8, uVar11);
@@ -1491,19 +1492,15 @@ e_pcpp_t pcppIsBusy(pcpp_t* stream, timeout_t timeout) {
                     pcppCheckRecvMsg(pcVar8, stream->read_bytes_num, (uint)(stream->state == 5));
                 stream->err = eVar7;
                 if (eVar7 == e_pcpp_ok) {
-                    pcppChangeRequest(stream, &timeout);
+                    uint lenout;
-                    uVar11 = timeout;
+                    pcppChangeRequest(stream, &lenout);
-                    pcVar9 = pcVar8;
+                    if (lenout < stream->read_bytes_num) {
-                    if (timeout < stream->read_bytes_num) {
+                        for (uint i = 0; i < stream->read_bytes_num - lenout; i++) {
-                        do {
+                            pcVar8[i] = pcVar8[i + lenout];
-                            *pcVar9 = pcVar8[uVar11];
-                            uVar11 = uVar11 + 1;
-                            pcVar9 = pcVar9 + 1;
-                        } while (uVar11 < stream->read_bytes_num);
                         }
-                LAB_00458226:
+                    }
-                    stream->read_bytes_num = stream->read_bytes_num - timeout;
+                    stream->read_bytes_num = stream->read_bytes_num - lenout;
-                    stream->read_bytes_size = stream->read_bytes_size + timeout;
+                    stream->read_bytes_size = stream->read_bytes_size + lenout;
                     stream->state = pcpp_state_none;
                     amiTimerGet(&local_18);
                     stream->last_active = _amTimeMs(local_18);
@@ -1574,18 +1571,16 @@ e_pcpp_t pcppIsBusy(pcpp_t* stream, timeout_t timeout) {
                 }
                 if (stream->err == e_pcpp_ok) {
                     stream->field_0x1e8 = stream->field_0x1e8 + *psVar1;
-                    uVar11 = 0;
                     *psVar1 = PCP_SEND_BUF_MAX - stream->field_0x1e8;
                     stream->state = pcpp_state_none;
-                    stream->err = -9;
+                    stream->err = e_pcpp_data_format_error;
                     if (stream->field_0x1e8 != 0) {
-                        do {
+                        for (uint i = 0; i < stream->field_0x1e8; i++) {
-                            if (*(char*)((int)&stream->send_buf + uVar11) == PCP_CHAR_BINACK) {
+                            if (stream->send_buf[i] == PCP_CHAR_BINACK) {
                                 stream->err = e_pcpp_ok;
                                 break;
                             }
-                            uVar11 = uVar11 + 1;
+                        }
-                        } while (uVar11 < stream->field_0x1e8);
                     }
                     amiTimerGet(&local_10);
                     stream->last_active = _amTimeMs(local_10);
@@ -1614,20 +1609,14 @@ e_pcpp_t pcppIsBusy(pcpp_t* stream, timeout_t timeout) {
                 ;
                 uVar11 = 0;
                 stream->send_buf_len = PCP_SEND_BUF_MAX - stream->field_0x1e8;
-                stream->err = -9;
+                for (uint i = 0; i < stream->field_0x1e8; i++) {
-                if (stream->field_0x1e8 != 0) {
+                    if (stream->send_buf[i] == PCP_CHAR_BINACK) {
-                    while (*(char*)((int)&stream->send_buf + uVar11) != PCP_CHAR_BINACK) {
+                        return (stream->err = e_pcpp_ok);
-                        uVar11 = uVar11 + 1;
+                    }
-                        if (stream->field_0x1e8 <= uVar11) {
+                }
+                return (stream->err = e_pcpp_data_format_error);
+            }
             return stream->err;
-                        }
-                    }
-                LAB_00457676:
-                    stream->err = e_pcpp_ok;
-                    return e_pcpp_ok;
-                }
-            }
-            break;
         case pcpp_state_recv_binary:
             if (stream->field_0x214 != 0) {
                 bVar12 = (stream->data_sock).open != PCPT_LISTENING;
@@ -1827,17 +1816,20 @@ e_pcpp_t pcppIsBusy(pcpp_t* stream, timeout_t timeout) {
                     amiDebugLog("error Response format error");
                     return stream->err;
                 }
-                pcppChangeRequest(stream, &timeout);
+                uint lenout;
-                uVar11 = timeout;
+                pcppChangeRequest(stream, &lenout);
-                pcVar9 = pcVar8;
+                if (lenout < stream->read_bytes_num) {
-                if (timeout < stream->read_bytes_num) {
+                    for (uint i = 0; i < stream->read_bytes_num - lenout; i++) {
-                    do {
+                        pcVar8[i] = pcVar8[i + lenout];
-                        *pcVar9 = pcVar8[uVar11];
-                        uVar11 = uVar11 + 1;
-                        pcVar9 = pcVar9 + 1;
-                    } while (uVar11 < stream->read_bytes_num);
                     }
-                goto LAB_00458226;
+                }
+
+                stream->read_bytes_num = stream->read_bytes_num - lenout;
+                stream->read_bytes_size = stream->read_bytes_size + lenout;
+                stream->state = pcpp_state_none;
+                amiTimerGet(&local_18);
+                stream->last_active = _amTimeMs(local_18);
+                return stream->err;
             }
             if (eVar7 == e_pcpp_to) {
                 if (local_24 == 0) {
@@ -1854,10 +1846,10 @@ switchD_004572ff_caseD_10:
 }
 
 int pcpp_something(amtime_t* time, timeout_t timeout, pcpp_t* stream, pcpt_t* sock,
-                   unsigned char* send_buf, size_t* send_len, undefined4 param_7,
+                   const unsigned char* send_buf, size_t* send_len, undefined4 param_7,
                    undefined4 param_8, int fallback_err) {
-    uint iVar1;
+    timeout_t iVar1;
-    uint blocking_time;
+    timeout_t blocking_time;
     amtime_t now;
     e_pcpp_t err;
 
@@ -2020,15 +2012,12 @@ e_pcpp_t pcppRecvResponse(pcpp_t* stream, pcp_parse_data_t* buffer, timeout_t ti
     if (iVar1 == 0) {
         uint lenout;
         pcppChangeRequest(stream, &lenout);
-        uint ppVar2 = lenout;
-        char* pcVar3 = pcVar5;
         if (lenout < stream->read_bytes_num) {
-            do {
+            for (uint i = 0; i < stream->read_bytes_num - lenout; i++) {
-                *pcVar3 = pcVar5[ppVar2];
+                pcVar5[i] = pcVar5[i + lenout];
-                ppVar2++;
-                pcVar3++;
-            } while (ppVar2 < stream->read_bytes_num);
             }
+        }
+
         stream->read_bytes_num = stream->read_bytes_num - (int)lenout;
         stream->read_bytes_size = (stream->read_bytes_size - 0x46) + lenout;
         stream->state = pcpp_state_none;
@@ -2045,7 +2034,7 @@ e_pcpp_t pcppRecvResponse(pcpp_t* stream, pcp_parse_data_t* buffer, timeout_t ti
     return stream->err;
 }
 
-SOCKADDR* pcppGetSockAddr(pcpp_t* stream, bool is_data) {
+SOCKADDR_IN* pcppGetSockAddr(pcpp_t* stream, bool is_data) {
     if (stream == NULL) {
         amiDebugLog("error PCPP stream isn't set");
         return NULL;

src/micetools/lib/libpcp/pcpp.h

@@ -16,6 +16,7 @@ typedef enum e_pcpp {
     e_pcpp_already_open = -3,
     e_pcpp_param_invalid = -5,
     e_pcpp_timeout_closed = -6,
+    e_pcpp_data_format_error = -9,
     e_pcpp_recv_unset = -10,
     e_pcpp_no_server = -11,
     e_pcpp_timeout_open = -12,
@@ -25,7 +26,6 @@ typedef enum e_pcpp {
 
     e_pcpp_uk1 = -14,
     e_pcpp_uk2 = -13,
-    e_pcpp_uk4 = -9,
     e_pcpp_uk5 = -8,
     e_pcpp_uk6 = -7,
     e_pcpp_uk7 = -4,
@@ -76,7 +76,7 @@ typedef struct pcpp {
     char send_buf[PCP_SEND_BUF_MAX];
     size_t send_buf_len;
     uint field_0x1e8;
-    unsigned char* send_binary_buf;
+    const unsigned char* send_binary_buf;
     uint field_0x1f0;
     unsigned char* recv_binary_buf;
     size_t field_0x1f8;
@@ -86,7 +86,7 @@ typedef struct pcpp {
     uint field_0x204;
     uint field_0x208;
     uint field_0x20c;
-    uint field_0x210;
+    timeout_t field_0x210;
     int field_0x214;
     int open;
 } pcpp_t;
@@ -99,7 +99,7 @@ uint pcppCheckStr(char* param_1, uint* pcp_len, int* pcp_overflow);
 void pcppClose(pcpp_t* stream);
 void pcppCloseBinary(pcpp_t* stream);
 e_pcpp_t pcppGetBlockingTime(uint param_1, timeout_t param_2, pcpp_t* stream, int param_4,
-                             uint* blocking_time);
+                             timeout_t* blocking_time);
 char* pcppGetCommand(pcp_parse_data_t* pcpa, char* command);
 char* pcppGetKeyword(pcp_parse_data_t* recvData, uint keyword_num);
 SOCKET pcppGetServerSocket(pcpp_t* stream, int which);
@@ -109,12 +109,12 @@ e_pcpp_t pcppOpenClient(pcpp_t* stream, char* ipAddr, ushort port, uint param_4,
 e_pcpp_t pcppOpenBinaryServer(pcpp_t* stream, int open_mode, ushort port);
 e_pcpp_t pcppOpenServer(pcpp_t* stream, int open_mode, ushort port, undefined4 param_4);
 e_pcpp_t pcppRecvAllMsg(pcpp_t* stream, uint param_1, bool* bReRecv);
-e_pcpp_t pcppRecvBinary(pcpp_t* stream, unsigned char* recv_buf, size_t buf_len, uint param_4);
+e_pcpp_t pcppRecvBinary(pcpp_t* stream, unsigned char* recv_buf, size_t buf_len, timeout_t param_4);
 uint pcppRecvCheck(char* buf, int* found_at);
-e_pcpp_t pcppRecvPrompt(pcpp_t* stream, undefined4 param_2, int param_3);
+e_pcpp_t pcppRecvPrompt(pcpp_t* stream, undefined4 param_2, timeout_t param_3);
 e_pcpp_t pcppRecvRequest(pcpp_t* stream, pcp_parse_data_t* recv_data, timeout_t timeout);
 e_pcpp_t pcppRecvRequestMain(pcpp_t* stream, bool* bReRecv, undefined4 param_3);
-e_pcpp_t pcppSendBinary(pcpp_t* stream, unsigned char* send_binary_buffer, size_t param_3,
+e_pcpp_t pcppSendBinary(pcpp_t* stream, const unsigned char* send_binary_buffer, size_t param_3,
                         uint param_4);
 e_pcpp_t pcppSendPrompt(pcpp_t* stream, uint param_2, timeout_t timeout_ms);
 e_pcpp_t pcppSendRequestMain(pcpp_t* stream, undefined4 param_2, timeout_t timeout_ms);
@@ -123,7 +123,7 @@ e_pcpp_t pcppSendResponse(pcpp_t* stream, pcp_send_data_t* resp_buffer, size_t b
 e_pcpp_t pcppSendResponseTable(pcpp_t* stream, pcp_send_data_t* data, timeout_t timeout_ms);
 pcp_send_data_t* pcppSetSendPacket(pcp_send_data_t* send_data, char* keyword, char* value);
 e_pcpp_t pcpp_something(amtime_t* now, timeout_t timeout, pcpp_t* stream, pcpt_t* sock,
-                        unsigned char* send_buf, size_t* send_len, undefined4 param_7,
+                        const unsigned char* send_buf, size_t* send_len, undefined4 param_7,
                         undefined4 param_8, e_pcpp_t fallback_err);
 void pcppResetRead(pcpp_t* param_1);
 e_pcpp_t pcppSendRequestTable(pcpp_t* stream, pcp_send_data_t* request_buffer, timeout_t timeout);
@@ -131,4 +131,4 @@ e_pcpp_t pcppSendRequest(pcpp_t* stream, pcp_send_data_t* request_buffer, uint n
                          timeout_t timeout);
 e_pcpp_t pcppRecvResponse(pcpp_t* stream, pcp_parse_data_t* buffer, timeout_t timeout);
 e_pcpp_t pcppOpenBinaryClient(pcpp_t* stream, char* ipAddr, ushort port, timeout_t timeout);
-SOCKADDR* pcppGetSockAddr(pcpp_t* stream, bool is_data);
+SOCKADDR_IN* pcppGetSockAddr(pcpp_t* stream, bool is_data);

src/micetools/lib/libpcp/pcpt.c

@@ -125,8 +125,8 @@ e_pcpt_t pcptAcceptServer(pcpt_t *stream, timeout_t timeout_ms) {
     e_pcpt_t err = pcptCheckEvent(stream->server_event, timeout_ms, stream->server_sock, FD_ACCEPT);
     if (err != e_pcpt_ok) return err;
 
-    int addrlen = 16;
+    int addrlen = sizeof stream->client_addr;
-    SOCKET client = accept(stream->server_sock, &stream->client_addr, &addrlen);
+    SOCKET client = accept(stream->server_sock, (PSOCKADDR)&stream->client_addr, &addrlen);
     stream->client_sock = client;
     if (client == SOCKET_INVAL) return _errW2T(GetLastError());
 
@@ -148,8 +148,8 @@ e_pcpt_t pcptAcceptServer(pcpt_t *stream, timeout_t timeout_ms) {
 }
 
 e_pcpt_t pcptCheckConnectAble(pcpt_t *stream, timeout_t timeout_ms) {
-    DWORD DVar1;
+    timeout_t DVar1;
-    uint uVar3;
+    timeout_t uVar3;
     HANDLE event;
     bool bVar5;
     e_pcpt_t local_44;
@@ -224,7 +224,7 @@ e_pcpt_t pcptCheckEvent(HANDLE event, timeout_t timeout_ms, SOCKET socket, uint
     amiTimerGet(&start);
     now.seconds = start.seconds;
     now.microseconds = start.microseconds;
-    DWORD wait_timeout = timeout_ms;
+    timeout_t wait_timeout = timeout_ms;
     if (timeout_ms == TIMEOUT_NONE) wait_timeout = TIMEOUT_NONE;
 
     if (event == NULL) {
@@ -235,7 +235,7 @@ e_pcpt_t pcptCheckEvent(HANDLE event, timeout_t timeout_ms, SOCKET socket, uint
     event_mask &= 0xffffffdf;
 
     while (1) {
-        DWORD err = WaitForSingleObject(event, wait_timeout);
+        DWORD err = WaitForSingleObject(event, (DWORD)wait_timeout);
         if ((err != WAIT_TIMEOUT && err != 0) || FAILED(err)) {
             return e_pcpt_wsa2_generic;
         }
@@ -345,7 +345,7 @@ e_pcpt_t pcptOpenServer(pcpt_t *stream, int open_mode, ushort port) {
 
 e_pcpt_t pcptOpenClient(pcpt_t *stream, char *ipAddr, ushort port, timeout_t timeout) {
     pcpt_t *pcpt;
-    uint uVar6;
+    timeout_t uVar6;
     amtime_t start;
     amtime_t now;
 
@@ -366,6 +366,8 @@ e_pcpt_t pcptOpenClient(pcpt_t *stream, char *ipAddr, ushort port, timeout_t tim
     SOCKADDR_IN *pAddr = &stream->client_addr;
     pAddr->sin_port = ntohs(port);
     pAddr->sin_family = AF_INET;
+// We can't use inet_pton because we target XP
+#pragma warning(suppress : 4996)
     pAddr->sin_addr.s_addr = inet_addr(ipAddr);
 
     SOCKET s = socket(AF_INET, SOCK_STREAM, 0);
@@ -393,7 +395,8 @@ e_pcpt_t pcptOpenClient(pcpt_t *stream, char *ipAddr, ushort port, timeout_t tim
         }
         WSAEventSelect(pcpt->client_sock, client_event, 0x30);
 
-        if (connect(pcpt->client_sock, &stream->client_addr, 0x10) != -1) {
+        if (connect(pcpt->client_sock, (PSOCKADDR)&stream->client_addr,
+                    sizeof stream->client_addr) != -1) {
             WSAEventSelect(pcpt->client_sock, 0, 0);
             WSACloseEvent(pcpt->client_event);
             pcpt->client_event = 0;
@@ -503,7 +506,7 @@ e_pcpt_t pcptRecv(pcpt_t *sock, unsigned char *recv_buf, size_t *recv_buf_len,
 
         if (timeout_ms != TIMEOUT_NONE) {
             amiTimerGet(&now);
-            uint elapsed = _amTimeDelta(now, start);
+            timeout_t elapsed = _amTimeDelta(now, start);
 
             if (elapsed < timeout_ms)
                 timeout_ms = timeout_ms - elapsed;
@@ -535,7 +538,7 @@ e_pcpt_t pcptRecv(pcpt_t *sock, unsigned char *recv_buf, size_t *recv_buf_len,
     return sock->err;
 }
 
-e_pcpt_t pcptSend(pcpt_t *sock, unsigned char *send_buf, size_t *send_len, uint param_4,
+e_pcpt_t pcptSend(pcpt_t *sock, const unsigned char *send_buf, size_t *send_len, uint param_4,
                   timeout_t timeout_ms) {
     e_pcpt_t err;
     amtime_t now;
@@ -569,7 +572,7 @@ e_pcpt_t pcptSend(pcpt_t *sock, unsigned char *send_buf, size_t *send_len, uint
 
         if (err == e_pcpt_ok) {
             amiTimerGet(&now);
-            uint elapsed = _amTimeDelta(now, start_time);
+            timeout_t elapsed = _amTimeDelta(now, start_time);
             if (timeout_ms != TIMEOUT_NONE) {
                 if (elapsed < timeout_ms)
                     timeout_ms = timeout_ms - elapsed;
@@ -622,10 +625,10 @@ e_pcpt_t pcptSendAllMsg(pcpt_t *sock, timeout_t timeout_ms) {
 
         bVar2 = false;
         amiTimerGet(&now);
-        uint elapsed = _amTimeDelta(now, start);
+        timeout_t elapsed = _amTimeDelta(now, start);
         if (timeout_ms != TIMEOUT_NONE && timeout_ms < elapsed) return e_pcpt_to;
 
-        uint wait_time;
+        timeout_t wait_time;
         if (bVar3) {
             wait_time = timeout_ms;
             if (timeout_ms != TIMEOUT_NONE) wait_time = timeout_ms - elapsed;
@@ -662,7 +665,7 @@ e_pcpt_t pcptSendAllMsg(pcpt_t *sock, timeout_t timeout_ms) {
     }
 }
 
-void pcptSetConfig(pcpt_t *stream, uint config, uint value) {
+void pcptSetConfig(pcpt_t *stream, pcpt_config_t config, int value) {
     if (stream == NULL) {
         amiDebugLog("error don't set stream");
         return;
@@ -683,6 +686,25 @@ void pcptSetConfig(pcpt_t *stream, uint config, uint value) {
             break;
     }
 }
+int pcptGetConfig(pcpt_t *stream, pcpt_config_t config) {
+    if (stream == NULL) {
+        amiDebugLog("error don't set stream");
+        return -1;
+    }
+
+    switch (config) {
+        case 0:
+            return stream->config_0;
+        case 1:
+            return stream->config_1;
+        case 2:
+            return stream->so_linger;
+        case 3:
+            return stream->tcp_nodelay;
+        default:
+            return 0;
+    }
+}
 
 // TODO: TIDY
 
@@ -772,7 +794,8 @@ e_pcpt_t pcptIsBusy(pcpt_t *sock, timeout_t timeout_ms) {
                         return sock->err;
                     }
                     WSAEventSelect(sock->client_sock, event, FD_CONNECT | FD_CLOSE);
-                    iVar7 = connect(sock->client_sock, &sock->client_addr, 16);
+                    iVar7 = connect(sock->client_sock, (PSOCKADDR)&sock->client_addr,
+                                    sizeof sock->client_addr);
                     if (iVar7 != -1) {
                         WSAEventSelect(sock->client_sock, 0, 0);
                         WSACloseEvent(sock->client_event);

src/micetools/lib/libpcp/pcpt.h

@@ -26,6 +26,13 @@ typedef enum e_pcpt {
     e_pcpt_unknown = -17,
 } e_pcpt_t;
 
+typedef enum {
+    PCPT_CONFIG_0 = 0,
+    PCPT_CONFIG_1 = 1,
+    PCPT_SO_LINGER = 2,
+    PCPT_TCP_NODELAY = 3,
+} pcpt_config_t;
+
 e_pcpt_t _pcptGetErrorFromWin(int err);
 #define _errW2T(err) _pcptGetErrorFromWin(err)
 
@@ -35,34 +42,40 @@ typedef struct pcpt {
     int client_open;
     int open;
     e_pcpt_t err;
-    uint field_0x14;
+    timeout_t field_0x14;
-    uint config_0;
+    timeout_t config_0;
     uint config_1;
     uint so_linger;
     uint tcp_nodelay;
     WSAEVENT client_event;
     WSAEVENT server_event;
-    unsigned char* send_buf;
+    const unsigned char* send_buf;
     size_t* send_buf_count;
     unsigned char* recv_buf;
     size_t* recv_buf_count;
     uint field_0x40;
-    SOCKADDR client_addr;
+    SOCKADDR_IN client_addr;
     int field_0x54;
     int field_0x58;
 } pcpt_t;
 
-e_pcpt_t pcptInitStream(pcpt_t* sock);
+// Confirmed with nrs.pdb
 void pcptClose(pcpt_t* sock);
 void pcptCloseDataSock(pcpt_t* sock);
+int pcptGetConfig(pcpt_t* sock, pcpt_config_t config);
+e_pcpt_t pcptInitStream(pcpt_t* sock);
+e_pcpt_t pcptIsBusy(pcpt_t* sock, timeout_t timeout_ms);
+e_pcpt_t pcptOpenClient(pcpt_t* stream, char* ipAddr, ushort port, timeout_t timeout);
+e_pcpt_t pcptRecv(pcpt_t* sock, unsigned char* recv_buf, size_t* recv_buf_len,
+                  timeout_t timeout_ms);
+e_pcpt_t pcptSend(pcpt_t* sock, const unsigned char* send_buf, size_t* send_len, uint param_4,
+                  timeout_t timeout_ms);
+void pcptSetConfig(pcpt_t* sock, pcpt_config_t config, int value);
+
+// Unconfirmed
 e_pcpt_t pcptAcceptServer(pcpt_t* stream, timeout_t timeout_ms);
 e_pcpt_t pcptCheckConnectAble(pcpt_t* sock, timeout_t timeout_ms);
 e_pcpt_t pcptCheckEvent(HANDLE event, timeout_t timeout_ms, SOCKET socket, uint event_mask);
-e_pcpt_t pcptIsBusy(pcpt_t* sock, timeout_t timeout_ms);
 e_pcpt_t pcptOpenDataSockServer(pcpt_t* sock, timeout_t timeout_ms);
-e_pcpt_t pcptOpenServer(pcpt_t* sock, int open_mode, ushort port);
-e_pcpt_t pcptOpenClient(pcpt_t *stream, char *ipAddr, ushort port, timeout_t timeout);
-e_pcpt_t pcptRecv(pcpt_t* sock, unsigned char* recv_buf, size_t* recv_buf_len, timeout_t timeout_ms);
-e_pcpt_t pcptSend(pcpt_t* sock, unsigned char* send_buf, size_t* send_len, uint param_4, timeout_t timeout_ms);
 e_pcpt_t pcptSendAllMsg(pcpt_t* sock, timeout_t timeout_ms);
-void pcptSetConfig(pcpt_t* sock, uint config, uint value);
+e_pcpt_t pcptOpenServer(pcpt_t* sock, int open_mode, ushort port);

src/micetools/lib/mice/config.c

@@ -14,7 +14,9 @@ config_t MiceConfig = {
 #define CFG_bool(s, n, default, comment) .n = default,
 #define CFG_int(s, n, default, comment) .n = default,
 #define CFG_hex(s, n, precision, default, comment) .n = 0x##default,
-#define CFG_ipv4(s, n, a, b, c, d, comment) .n = (a << 24) | (b << 16) | (c << 8) | d,
+#define CFG_ipv4(s, n, a, b, c, d, comment)                                   \
+    .n = (unsigned int)(((unsigned char)a << 24) | ((unsigned char)b << 16) | \
+                        ((unsigned char)c << 8) | (unsigned char)d),
 #define ENDSECTION(s) \
     }                 \
     ,
@@ -98,7 +100,7 @@ void save_current_config() {
     }
     keybindBuffer[i] = '\0';
     free(MiceConfig.keys.keys);
-    MiceConfig.keys.keys = strdup(keybindBuffer);
+    MiceConfig.keys.keys = _strdup(keybindBuffer);
 
     FILE *config_file;
     fopen_s(&config_file, CONFIG_PATH, "w");
@@ -172,9 +174,10 @@ static int handler(void *user, const char *section, const char *name, const char
         cfg->s.n = strtol(value, &end, 16);                                                 \
         unsigned char ip_a, ip_b, ip_c, ip_d;                                               \
         if (sscanf_s(value, "%hhu.%hhu.%hhu.%hhu", &ip_a, &ip_b, &ip_c, &ip_d) == 4)        \
-            cfg->s.n = (ip_a << 24) | (ip_b << 16) | (ip_c << 8) | ip_d;             \
+            cfg->s.n = (unsigned int)((ip_a << 24) | (ip_b << 16) | (ip_c << 8) | ip_d);    \
         else                                                                                \
-            cfg->s.n = (a << 24) | (b << 16) | (c << 8) | d;                         \
+            cfg->s.n = (unsigned int)(((unsigned char)a << 24) | ((unsigned char)b << 16) | \
+                                      ((unsigned char)c << 8) | (unsigned char)d);          \
     }
 
 #include "config.def"

src/micetools/lib/mice/config.def

@@ -99,7 +99,7 @@ SECTION(keys, "Raw keybinding data. Edit this using the built in binding tool!")
 CFG_int(keys, test, 0, "")
 CFG_int(keys, service, 0, "")
 CFG_int(keys, board_count, 1, "")
-CFG_str(keys, keys, 0, "")
+CFG_str(keys, keys, "", "")
 ENDSECTION(keys)
 
 SECTION(devices, "Register attached hardware devices. COM4 is reserved for JVS.")

src/micetools/lib/mice/patch.c

@@ -71,7 +71,7 @@ bool load_patches_file(const char* filename) {
                     printf("Invalid address length: %d\n", rbPtr);
                     return false;
                 }
-                hex_to_int(&(size_t)patch->address, readBuffer);
+                hex_to_int(&(patch->address), readBuffer);
 
                 state = parse_patches_state_colon;
                 rbPtr = 0;

src/micetools/lib/mice/patch.h

@@ -8,7 +8,7 @@ bool load_patches_file(const char* filename);
 bool load_patches(char* indexPath, char* exeName);
 
 typedef struct _patch {
-    void* address;
+    size_t address;
     size_t count;
     unsigned char* match;
     unsigned char* replace;

src/micetools/lib/mxk/mxkAb.c

@@ -142,7 +142,7 @@ MXK_STATUS mxkAbGameId(MXK_CACHE cache, char* gameId, unsigned char* err) {
         memcpy(gameId, AppBoot.m_Cache.m_Header.m_GameId, 4);
         return MXK_STATUS_OK;
     }
-LAB_00401c6a:
+// LAB_00401c6a:
     KEYCHIP_ERROR = 2;
     KEYCHIP_STATUS = 2;
     *err = 2;

src/micetools/lib/mxk/mxkCrypt.c

@@ -268,7 +268,7 @@ void mxkSignValue(unsigned int value, unsigned char* signature) {
     mxkSign(&hash_data, sizeof hash_data, signature);
 }
 
-int mxkCryptCalcHashWithHmacSha1(void* key, unsigned char* md, size_t* nbuffer,
+int mxkCryptCalcHashWithHmacSha1(PHmacKey_t key, PHmacSum_t md, size_t* nbuffer,
                                  unsigned char* buffer, size_t nin) {
     if (key == NULL || buffer == NULL || md == NULL || nbuffer == NULL) {
         amiDebugLog("Error: Invalid param.");
@@ -290,17 +290,17 @@ int mxkCryptCalcHashWithHmacSha1(void* key, unsigned char* md, size_t* nbuffer,
     HMAC_CTX_init(&hmac_ctx);
     HMAC_Init_ex(&hmac_ctx, key, 20, EVP_sha1(), NULL);
     HMAC_Update(&hmac_ctx, buffer, nin);
-    HMAC_Final(&hmac_ctx, md, nbuffer);
+    HMAC_Final(&hmac_ctx, (unsigned char*)md, nbuffer);
     HMAC_CTX_cleanup(&hmac_ctx);
 
     return 0;
 }
 
-void mxkCryptCalcHashWithSha1(unsigned char* data, size_t nbytes, unsigned char* sum) {
+void mxkCryptCalcHashWithSha1(unsigned char* data, size_t nbytes, PSha1Sum_t sum) {
     EVP_MD_CTX* ctx = EVP_MD_CTX_create();
     EVP_DigestInit(ctx, EVP_sha1());
     EVP_DigestUpdate(ctx, data, nbytes);
     unsigned int outlen;
-    EVP_DigestFinal_ex(ctx, sum, &outlen);
+    EVP_DigestFinal_ex(ctx, (unsigned char*)sum, &outlen);
     EVP_MD_CTX_destroy(ctx);
 }

src/micetools/lib/mxk/mxkN2.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <stdint.h>
-#include <varargs.h>
 
 #include "mxkCrypt.h"
 #include "../../segastructs.h"

src/micetools/lib/util/hex.c

@@ -46,9 +46,11 @@ unsigned char hex_value(char c) {
             return 0xFF;
     }
 }
-int hex_to_bin(char *hex, unsigned char *bin, int hex_len) {
+int hex_to_bin(char *hex, void *bin, int hex_len) {
     if (hex_len == 0) return 1;
 
+    unsigned char *lpucBin = (unsigned char *)bin;
+
     int work_len = 0;
     for (int hex_ptr = 0; hex_ptr < hex_len; hex_ptr += 2, work_len++) {
         char msn = hex[hex_ptr];
@@ -73,21 +75,23 @@ int hex_to_bin(char *hex, unsigned char *bin, int hex_len) {
         else
             return 0;
 
-        bin[work_len] = msn << 4 | lsn;
+        lpucBin[work_len] = msn << 4 | lsn;
     }
     return 1;
 }
-void bin_to_hex(char *hex, unsigned char *bin, int nbytes) {
+void bin_to_hex(char *hex, void *bin, int nbytes) {
-    for (int i = 0; i < nbytes; i++) {
+    unsigned char *lpucBin = (unsigned char *)bin;
-        if ((bin[i] & 0xf0) > 0x90)
-            hex[i * 2] = ((bin[i] & 0xf0) >> 4) - 0x0a + 'a';
-        else
-            hex[i * 2] = ((bin[i] & 0xf0) >> 4) + '0';
 
-        if ((bin[i] & 0x0f) > 0x09)
+    for (int i = 0; i < nbytes; i++) {
-            hex[i * 2 + 1] = (bin[i] & 0x0f) - 0x0a + 'a';
+        if ((lpucBin[i] & 0xf0) > 0x90)
+            hex[i * 2] = ((lpucBin[i] & 0xf0) >> 4) - 0x0a + 'a';
         else
-            hex[i * 2 + 1] = (bin[i] & 0x0f) + '0';
+            hex[i * 2] = ((lpucBin[i] & 0xf0) >> 4) + '0';
+
+        if ((lpucBin[i] & 0x0f) > 0x09)
+            hex[i * 2 + 1] = (lpucBin[i] & 0x0f) - 0x0a + 'a';
+        else
+            hex[i * 2 + 1] = (lpucBin[i] & 0x0f) + '0';
     }
     hex[nbytes * 2] = '\0';
 }

src/micetools/lib/util/hex.h

@@ -1,5 +1,5 @@
 int hex_to_byte(char *hex, unsigned char *val);
 unsigned char hex_value(char c);
-int hex_to_bin(char *hex, unsigned char *bin, int hex_len);
+int hex_to_bin(char *hex, void *bin, int hex_len);
 int hex_to_int(unsigned int *value, char *hex);
-void bin_to_hex(char *hex, unsigned char *bin, int nbytes);
+void bin_to_hex(char *hex, void *bin, int nbytes);

src/micetools/miceboot/TrueCrypt.cmd

@@ -1,4 +0,0 @@
-@echo off
-@REM "C:\Program Files (x86)\TrueCrypt\TrueCrypt.exe" %*
-echo %*
-pause

src/micetools/miceboot/meson.build

@@ -14,14 +14,6 @@ executable(
     ],
 )
 
-executable(
-    'truecrypt',
-    win_subsystem: subsystem,
-    sources: [
-        'truecrypt.c',
-    ],
-)
-
 executable(
     'mxmaster',
     win_subsystem: subsystem,

src/micetools/miceboot/truecrypt.c

@@ -1,5 +0,0 @@
-#include <stdio.h>
-
-int main(int argc, char** argv) {
-    puts("TrueCrypt.exe dummy hit");
-}

src/micetools/micemaster/config.c

@@ -81,8 +81,6 @@ static void make_default_config() {
 static int handler(void *user, const char *section, const char *name, const char *value) {
     config_t *cfg = (config_t *)user;
 
-    char *end;
-
     if (false)
         ;
 #define CFG_str(s, n, default, comment) \
@@ -92,16 +90,19 @@ static int handler(void *user, const char *section, const char *name, const char
         strcmp(value, "true") == 0;
 #define CFG_int(s, n, default, comment)                                          \
     else if (_stricmp(section, #s) == 0 && _stricmp(name, #n) == 0) {            \
+        char *end;                                                               \
         cfg->s.n = strtol(value, &end, 10);                                      \
         if (end == value || *end != '\0' || errno == ERANGE) cfg->s.n = default; \
     }
 #define CFG_hex(s, n, precision, default, comment)                                   \
     else if (_stricmp(section, #s) == 0 && _stricmp(name, #n) == 0) {                \
+        char *end;                                                                   \
         cfg->s.n = strtol(value, &end, 16);                                          \
         if (end == value || *end != '\0' || errno == ERANGE) cfg->s.n = 0x##default; \
     }
 #define CFG_ipv4(s, n, a, b, c, d, comment)                                          \
     else if (_stricmp(section, #s) == 0 && _stricmp(name, #n) == 0) {                \
+        char *end;                                                                   \
         cfg->s.n = strtol(value, &end, 16);                                          \
         unsigned char ip_a, ip_b, ip_c, ip_d;                                        \
         if (sscanf_s(value, "%hhu.%hhu.%hhu.%hhu", &ip_a, &ip_b, &ip_c, &ip_d) == 4) \

src/micetools/micemaster/main.c

@@ -266,6 +266,8 @@ void mxMasterFdcProcessesStart(MX_MASTER* mxMaster) {
 
     if (mxMaster->m_kcReady) {
         char* format;
+        // We can't use inet_ntop because we target XP
+#pragma warning(suppress : 4996)
         char* networkAddr = inet_ntoa(mxMaster->m_networkAddr);
 
         if (mxMaster->m_develop == 0) {

src/micetools/system_dummy/dummyinstaller/meson.build

@@ -1,18 +1,7 @@
-dependencies = []
-link_with = [libpcp, amiDebug]
-sources = [
-    'dummyinstaller.c',
-]
-
 dummyinstaller = static_library(
     'dummyinstaller',
-    sources: sources,
+    sources: [
-    link_with: link_with,
+        'dummyinstaller.c',
-)
+    ],
-executable(
+    link_with: [libpcp, amiDebug],
-    'dummyinstaller',
-    win_subsystem: subsystem,
-    sources: ['main.c'] + sources,
-    link_with: link_with,
-    dependencies: dependencies,
 )

src/micetools/system_dummy/dummykeychip/meson.build

@@ -1,22 +1,11 @@
-link_with = [libpcp, amiDebug, util_lib]
+dummykeychip = static_library(
-sources = [
+    'dummykeychip',
+    sources: [
         'callbacks-stub.c',
         'callbacks-crypto.c',
         'dummykeychip.c',
-]
+    ],
-
+    link_with: [libpcp, amiDebug, util_lib],
-dummykeychip = static_library(
-    'dummykeychip',
-    sources: sources,
-    link_with: link_with,
-    include_directories: [openssl_inc],
-    dependencies: [openssl_lib],
-)
-executable(
-    'dummykeychip',
-    win_subsystem: subsystem,
-    sources: ['main.c'] + sources,
-    link_with: link_with,
     include_directories: [openssl_inc],
     dependencies: [openssl_lib],
 )

src/micetools/system_dummy/dummymaster/meson.build

@@ -1,18 +1,7 @@
-dependencies = []
-link_with = [libpcp, amiDebug]
-sources = [
-    'dummymaster.c',
-]
-
 dummymaster = static_library(
     'dummymaster',
-    sources: sources,
+    sources: [
-    link_with: link_with,
+        'dummymaster.c',
-)
+    ],
-executable(
+    link_with: [libpcp, amiDebug],
-    'dummymaster',
-    win_subsystem: subsystem,
-    sources: ['main.c'] + sources,
-    link_with: link_with,
-    dependencies: dependencies,
 )

src/micetools/util/exio_test.c

@@ -303,7 +303,7 @@ int exio_mac_test(byte* buffer) {
 
 int keychip_ds_eeprom_dump(void) {
     byte pageData[32];
-    for (int page = 0; page < 4; page++) {
+    for (byte page = 0; page < 4; page++) {
         printf("Page %d\n", page);
         if (mxkDsKeychipReadEeprom(pageData, page)) {
             puts("Read failed");

src/micetools/util/meson.build

@@ -36,14 +36,6 @@ executable(
     ],
 )
 
-executable(
-    'micemonitor',
-    win_subsystem: subsystem,
-    sources: [
-        'micemonitor.c',
-    ],
-)
-
 executable(
     'exio_test',
     win_subsystem: subsystem,
@@ -64,13 +56,6 @@ executable(
     ],
 )
 
-executable(
-    'testBin',
-    win_subsystem: subsystem,
-    sources: [
-        'test.c',
-    ],
-)
 executable(
     'micegbdisk',
     win_subsystem: subsystem,
@@ -81,14 +66,3 @@ executable(
         amiDebug,
     ],
 )
-
-executable(
-    'micefs_test',
-    win_subsystem: subsystem,
-    sources: [
-        'micefs_test.c',
-    ],
-    link_with: [
-        mice_lib,
-    ],
-)

src/micetools/util/micefs_test.c

@@ -1,32 +0,0 @@
-#include <stdio.h>
-
-#include "../lib/mice/mice.h"
-
-// TODO: Ewww
-BOOL(WINAPI* TruePathFileExistsA)(LPCSTR pszPath) = PathFileExistsA;
-
-int main() {
-    MiceFSInit();
-    // MiceFSAddDevLayers();
-    // MiceFSAddRingedgeLayers(FALSE);
-
-    CHAR path[MAX_PATH + 1];
-    strcpy_s(path, sizeof path, "X:\\Systemconfig.txt");
-
-    MICE_FS_PATH_TOK pathTok;
-    LPSTR pathComponent = MiceFSPathTokA(path, _countof(path), &pathTok);
-
-    while (pathComponent) {
-        printf("Component : '%s'\n", pathComponent);
-        pathComponent = MiceFSPathTokNextA(&pathTok);
-    }
-
-
-    // CHAR tail[MAX_PATH + 1];
-    // printf("Test 1: %d\n", MiceFSMatchPathA("C:\\windows\\system32\\etc\\help.exe", "C:\\WINDOWS", tail, sizeof(tail)));
-    // printf("Tail: %s\n", tail);
-
-    // LPSTR redirected = NULL;
-    // MiceFSRedirectPathA("X:\\game.bat", &redirected);
-    // printf("Redirected path: %s\n", redirected);
-}

src/micetools/util/micemonitor.c

@@ -1,14 +0,0 @@
-#include <Windows.h>
-#include <stdio.h>
-
-#define P2A_PATH "C:\\ProgramData\\boost_interprocess\\ALLNetComP2A"
-#define A2P_PATH "C:\\ProgramData\\boost_interprocess\\ALLNetComA2P"
-
-int main(int argc, char* argv) {
-    FILE* f;
-    fopen_s(&f, "./test.txt", "w");
-    fprintf(f, "count: %d", argc);
-    fclose(f);
-
-    return 0;
-}

src/micetools/util/test.c

@@ -1,80 +0,0 @@
-#include <Windows.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-char path[MAX_PATH * 1000];
-int oldmain(int argc, char** argv) {
-    // printf("%d", QueryDosDeviceA(NULL, path, sizeof path));
-    // printf(" %03x\n", GetLastError());
-
-    // char* pPath = path;
-    // while (1) {
-    //     size_t len = strlen(pPath);
-    //     if (!len) break;
-    //     puts(pPath);
-    //     pPath += len + 1;
-    // }
-
-    DWORD volumeSerialNumber;
-
-    // Crackproof-style call
-    BOOL ret = GetVolumeInformationA("C:\\", NULL, 0, &volumeSerialNumber, NULL, NULL, NULL, 0);
-    printf("volumeSerialNumber: %08x\n", volumeSerialNumber);
-
-    // Exhaustive call
-    CHAR volumeNameBuffer[MAX_PATH];
-    DWORD maximumComponentLength;
-    DWORD fileSystemFlags;
-    CHAR fileSystemName[MAX_PATH];
-    ret = GetVolumeInformationA("C:\\", volumeNameBuffer, sizeof volumeNameBuffer,
-                                &volumeSerialNumber, &maximumComponentLength, &fileSystemFlags,
-                                fileSystemName, sizeof fileSystemName);
-
-    printf("volumeNameBuffer: %s\n", volumeNameBuffer);
-    printf("volumeSerialNumber: %08x\n", volumeSerialNumber);
-    printf("maximumComponentLength: %08x\n", maximumComponentLength);
-    printf("fileSystemFlags: %08x\n", fileSystemFlags);
-    printf("fileSystemName: %s\n", fileSystemName);
-
-    return 0;
-}
-
-#define RING
-
-#ifdef RING
-#define A2P \
-    "C:\\Documents and Settings\\All Users\\Application Data/boost_interprocess/ALLNetComA2P"
-#else
-#define A2P "G:\\MegaSync\\SDEY_1.99\\maimai\\dev\\c\\ProgramData/boost_interprocess/ALLNetComA2P"
-#endif
-
-int main(int argc, char** argv) {
-    unsigned char buf[1];
-    char buf2[4];
-    DWORD temp;
-
-    HANDLE hFile = CreateFileA(A2P, GENERIC_READ | GENERIC_WRITE,
-                               FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
-    if (hFile == INVALID_HANDLE_VALUE) {
-        printf("Failed to open A2P %03x\n", GetLastError());
-        return -1;
-    }
-
-    SetFilePointer(hFile, 4, NULL, 0);
-    buf[0] = '\1';
-    WriteFile(hFile, buf, sizeof buf, &temp, NULL);
-
-    // buf[0] = '\2'; // game start
-    buf[0] = '\3';  // game test
-    SetFilePointer(hFile, 0, NULL, 0);
-    WriteFile(hFile, buf, sizeof buf, &temp, NULL);
-
-    SetFilePointer(hFile, 8, NULL, 0);
-    buf2[0] = '1';
-    buf2[0] = '.';
-    buf2[0] = '9';
-    buf2[0] = '9';
-    WriteFile(hFile, buf2, sizeof buf2, &temp, NULL);
-
-    CloseHandle(hFile);
-}

src/tools/keys.py

@@ -1,40 +0,0 @@
-import json
-
-patches = []
-patchset = {
-    "name": "Rebind keys",
-    "description": "Automatically generated",
-    "apply": True,
-    "patches": patches
-}
-
-original = ['W', 'E', 'D', 'C', 'X', 'Z', 'A', 'Q']
-
-base = 1517787
-for i in range(8):
-    key = input(f"Key for {i+1}: ")
-    if len(key) != 1:
-        print("That's not one key!")
-        quit()
-
-    key = f"{ord(key.upper()):02x}"
-    orig = f"{ord(original[i].upper()):02x}"
-
-    if i == 0:
-        patches.append({
-            "at": base,
-            "from": f"c70424{orig}000000",
-            "to": f"c70424{key}000000",
-        })
-    else:
-        instr = f"c74424{4 * i:02x}"
-        patches.append({
-            "at": base + 7 + 8 * (i - 1),
-            "from": instr + orig + "000000",
-            "to": instr + key + "000000",
-        })
-
-with open("keybinds.json", "w") as f:
-    json.dump([patchset], f)
-
-print("Wrote patches to keybinds.json")

subprojects/cimgui_dep/imgui/backends/GL/freeglut.h

@@ -14,6 +14,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+#define GLUT_DISABLE_ATEXIT_HACK
 #include "freeglut_std.h"
 #include "freeglut_ext.h"
 

subprojects/cimgui_dep/imgui/backends/GL/freeglut_std.h

@@ -80,6 +80,7 @@
 #           if FREEGLUT_LIB_PRAGMAS
 // Disabled! We're going to to load freeglut in at runtime!
 // #             pragma comment (lib, "freeglut.lib")
+#undef FGAPI
 #           define FGAPI extern
 #           endif
 

subprojects/cimgui_dep/imgui/backends/GL/glut.h

@@ -14,6 +14,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+#define GLUT_DISABLE_ATEXIT_HACK
 #include "freeglut_std.h"
 
 /*** END OF FILE ***/