Bottersnike/micetools
Bottersnike
/
micetools
4
4
Fork 0
Code Issues 5 Pull Requests Projects Releases Wiki Activity

Resolve all compiled warnings

This commit is contained in:
Bottersnike 2023-04-11 11:27:25 +09:00
parent e8cc8e8013
commit 701887940c
Signed by: Bottersnike
SSH Key Fingerprint: SHA256:3g0ghwd4dNX1k1RX8qazbiT+3RIYn/daeBevHZVCiU0
48 changed files with 306 additions and 503 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
Makefile
View File

@ -19,8 +19,8 @@ mice:
-@subst $(BUILD_DRIVE) .
@cd /D $(BUILD_DRIVE) \
& $(VCVARS) \
& meson setup --cross cross-32.ini $(BUILD_DRIVE)\$(BUILD_DIR) \
& meson compile -C $(BUILD_DRIVE)\$(BUILD_DIR)
& meson.py setup --cross cross-32.ini $(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/*"

1
cross-32.ini
View File

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

1
meson.py
View File

@ -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

2
src/micetools/dll/amvStub/amv.c
View File

@ -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) {

3
src/micetools/dll/devices/smb_at24c64an.c
View File

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

4
src/micetools/dll/drivers/mxsram.c
View File

@ -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;
}

2
src/micetools/dll/hooks/files.c
View File

@ -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() {

15
src/micetools/dll/hooks/network.c
View File

@ -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 = {
.sin_addr = 0x0100007f,
static SOCKADDR_IN toLocalhost = {
.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);

2
src/micetools/dll/hooks/registry.c
View File

@ -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;

11
src/micetools/dll/hooks/system.c
View File

@ -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);
}

4
src/micetools/dll/util/_util.h
View File

@ -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);

19
src/micetools/dll/util/misc.c
View File

@ -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) {
make_dirs(path);
*file = _CreateFileW(path, GENERIC_READ | GENERIC_WRITE,
void* open_mapped_file(LPCWSTR lpFilename, DWORD size, HANDLE* file, HANDLE* file_mapping) {
char szFileName[MAX_PATH] = { 0 };
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;
}

30
src/micetools/lib/am/amDongle.c
View File

@ -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.",
pcpa_err);
amiDebugLog("Error: System error happened in pcp stream. ErrorCode = %d.", 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)
amiDebugLog("Error : pcpaOpenClient(%d)", pcpa_err);
if (amDongleDebugLevel > 0) 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 =
pcpaSetSendPacket(&amDongle.pcpa, "keychip.setiv", "?");
pcp_send_data_t *send_data = 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 =
pcpaSetSendPacket(&amDongle.pcpa, "keychip.appboot.seed", "?");
pcp_send_data_t *send_data = pcpaSetSendPacket(&amDongle.pcpa, "keychip.appboot.seed", "?");
if (send_data == NULL && amDongleDebugLevel > 0) {
amiDebugLog("Error: pcpaSetSendPacket return NULL");
}

5
src/micetools/lib/ami/amiCrc.c
View File

@ -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;
}

2
src/micetools/lib/ami/amiTimer.h
View File

@ -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);

9
src/micetools/lib/libpcp/pcp.h
View File

@ -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)

14
src/micetools/lib/libpcp/pcpa.c
View File

@ -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 {

8
src/micetools/lib/libpcp/pcpa.h
View File

@ -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 pcpaRecvBinary(pcpa_t* stream, undefined4 something);
e_pcpa_t pcpaSendBinary(pcpa_t* stream, undefined4 something);
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, timeout_t 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);

203
src/micetools/lib/libpcp/pcpp.c
View File

@ -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] == '>') {
if (cursor < stream->read_bytes_num) {
do {
*pos = pos[1];
pos++;
} while (pos + (-204 - (int)stream) < (char*)stream->read_bytes_num);
}
// Scan for the prompt character
if (stream->read_bytes_buf[cursor] != PCP_CHAR_PROMPT) continue;
stream->read_bytes_num--;
stream->read_bytes_size++;
found = true;
found = true;
// 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++;
}
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)
memcpy(recv_data + local_4, recv_data, stream->read_bytes_num);
if (local_4 < 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),
&recvb_local);
eVar3 = pcptSend(&stream->sock, send_buf, psVar1, stream->field_0x208,
recvb_local);
iVar2 = pcppGetBlockingTime(stream->field_0x20c, timeout, stream, _amTimeMs(now),
&timeout_local);
eVar3 = pcptSend(&stream->sock, send_buf, psVar1, stream->field_0x208, timeout_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),
&recvb_local);
iVar2 = pcppGetBlockingTime(stream->field_0x208, timeout, stream, _amTimeMs(now),
&timeout_local);
*psVar1 = PCP_SEND_BUF_MAX;
ZERO(stream->send_buf);
eVar3 =
pcptRecv(&stream->data_sock, send_buf, psVar1, recvb_local);
eVar3 = pcptRecv(&stream->data_sock, send_buf, psVar1, timeout_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) {
while (*(char*)((int)&stream->send_buf + uVar6) != PCP_CHAR_BINACK) {
uVar6 = uVar6 + 1;
if (stream->field_0x1e8 <= uVar6) {
return stream->err;
}
for (uint i = 0; i < stream->field_0x1e8; i++) {
if (stream->send_buf[i] == PCP_CHAR_BINACK) {
return (stream->err = e_pcpp_ok);
}
stream->err = e_pcpp_ok;
}
eVar3 = stream->err;
return (stream->err = e_pcpp_data_format_error);
}
}
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;
uint uVar10;
uint uVar11;
timeout_t uVar10;
timeout_t 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 =
-(uint)((uint)((local_8.microseconds - local_18.microseconds) / 1000 +
(local_8.seconds - local_18.seconds) * 1000) < uVar11) &
uVar11;
uVar6 = amiTimerDiffMsec(&local_18, &local_8) < uVar11 ? uVar11 : 0;
}
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) /
1000 +
(local_8.seconds - local_18.seconds) * 1000) <
uVar11) &
uVar11;
amiTimerDiffMsec(&local_18, &local_8) < uVar11 ? uVar11 : 0;
}
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);
uVar11 = timeout;
pcVar9 = pcVar8;
if (timeout < stream->read_bytes_num) {
do {
*pcVar9 = pcVar8[uVar11];
uVar11 = uVar11 + 1;
pcVar9 = pcVar9 + 1;
} while (uVar11 < stream->read_bytes_num);
uint lenout;
pcppChangeRequest(stream, &lenout);
if (lenout < stream->read_bytes_num) {
for (uint i = 0; i < stream->read_bytes_num - lenout; i++) {
pcVar8[i] = pcVar8[i + lenout];
}
}
LAB_00458226:
stream->read_bytes_num = stream->read_bytes_num - timeout;
stream->read_bytes_size = stream->read_bytes_size + timeout;
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);
@ -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 {
if (*(char*)((int)&stream->send_buf + uVar11) == PCP_CHAR_BINACK) {
for (uint i = 0; i < stream->field_0x1e8; i++) {
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;
if (stream->field_0x1e8 != 0) {
while (*(char*)((int)&stream->send_buf + uVar11) != PCP_CHAR_BINACK) {
uVar11 = uVar11 + 1;
if (stream->field_0x1e8 <= uVar11) {
return stream->err;
}
for (uint i = 0; i < stream->field_0x1e8; i++) {
if (stream->send_buf[i] == PCP_CHAR_BINACK) {
return (stream->err = e_pcpp_ok);
}
LAB_00457676:
stream->err = e_pcpp_ok;
return e_pcpp_ok;
}
return (stream->err = e_pcpp_data_format_error);
}
break;
return stream->err;
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);
uVar11 = timeout;
pcVar9 = pcVar8;
if (timeout < stream->read_bytes_num) {
do {
*pcVar9 = pcVar8[uVar11];
uVar11 = uVar11 + 1;
pcVar9 = pcVar9 + 1;
} while (uVar11 < stream->read_bytes_num);
uint lenout;
pcppChangeRequest(stream, &lenout);
if (lenout < stream->read_bytes_num) {
for (uint i = 0; i < stream->read_bytes_num - lenout; i++) {
pcVar8[i] = pcVar8[i + lenout];
}
}
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;
uint blocking_time;
timeout_t iVar1;
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 {
*pcVar3 = pcVar5[ppVar2];
ppVar2++;
pcVar3++;
} while (ppVar2 < stream->read_bytes_num);
for (uint i = 0; i < stream->read_bytes_num - lenout; i++) {
pcVar5[i] = pcVar5[i + lenout];
}
}
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;

18
src/micetools/lib/libpcp/pcpp.h
View File

@ -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);

53
src/micetools/lib/libpcp/pcpt.c
View File

@ -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;
SOCKET client = accept(stream->server_sock, &stream->client_addr, &addrlen);
int addrlen = sizeof stream->client_addr;
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;
uint uVar3;
timeout_t DVar1;
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);

35
src/micetools/lib/libpcp/pcpt.h
View File

@ -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;
uint config_0;
timeout_t field_0x14;
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);

23
src/micetools/lib/mice/config.c
View File

@ -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");
@ -167,14 +169,15 @@ static int handler(void *user, const char *section, const char *name, const char
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) { \
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; \
else \
cfg->s.n = (a << 24) | (b << 16) | (c << 8) | d; \
#define CFG_ipv4(s, n, a, b, c, d, comment) \
else if (_stricmp(section, #s) == 0 && _stricmp(name, #n) == 0) { \
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 = (unsigned int)((ip_a << 24) | (ip_b << 16) | (ip_c << 8) | ip_d); \
else \
cfg->s.n = (unsigned int)(((unsigned char)a << 24) | ((unsigned char)b << 16) | \
((unsigned char)c << 8) | (unsigned char)d); \
}
#include "config.def"

2
src/micetools/lib/mice/config.def
View File

@ -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.")

2
src/micetools/lib/mice/patch.c
View File

@ -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;

2
src/micetools/lib/mice/patch.h
View File

@ -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;

2
src/micetools/lib/mxk/mxkAb.c
View File

@ -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;

8
src/micetools/lib/mxk/mxkCrypt.c
View File

@ -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);
}

1
src/micetools/lib/mxk/mxkN2.h
View File

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

26
src/micetools/lib/util/hex.c
View File

@ -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) {
for (int i = 0; i < nbytes; i++) {
if ((bin[i] & 0xf0) > 0x90)
hex[i * 2] = ((bin[i] & 0xf0) >> 4) - 0x0a + 'a';
else
hex[i * 2] = ((bin[i] & 0xf0) >> 4) + '0';
void bin_to_hex(char *hex, void *bin, int nbytes) {
unsigned char *lpucBin = (unsigned char *)bin;
if ((bin[i] & 0x0f) > 0x09)
hex[i * 2 + 1] = (bin[i] & 0x0f) - 0x0a + 'a';
for (int i = 0; i < nbytes; i++) {
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';
}

4
src/micetools/lib/util/hex.h
View File

@ -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);

4
src/micetools/miceboot/TrueCrypt.cmd
View File

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

8
src/micetools/miceboot/meson.build
View File

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

5
src/micetools/miceboot/truecrypt.c
View File

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

9
src/micetools/micemaster/config.c
View File

@ -55,8 +55,8 @@ static void make_default_config() {
if (strlen(comment) != 0) fprintf_prefix(config_file, "; ", comment); \
fprintf(config_file, "%s = %d\n", #n, default);
#define CFG_hex(s, n, precision, default, comment) \
if (strlen(comment) != 0) fprintf_prefix(config_file, "; ", comment); \
#define CFG_hex(s, n, precision, default, comment) \
if (strlen(comment) != 0) fprintf_prefix(config_file, "; ", comment); \
fprintf(config_file, "%s = %.*X\n", #n, precision, 0x##default, precision, \
precision == 1 ? "" : "s");
@ -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) \

2
src/micetools/micemaster/main.c
View File

@ -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) {

19
src/micetools/system_dummy/dummyinstaller/meson.build
View File

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

23
src/micetools/system_dummy/dummykeychip/meson.build
View File

@ -1,22 +1,11 @@
link_with = [libpcp, amiDebug, util_lib]
sources = [
'callbacks-stub.c',
'callbacks-crypto.c',
'dummykeychip.c',
]
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,
sources: [
'callbacks-stub.c',
'callbacks-crypto.c',
'dummykeychip.c',
],
link_with: [libpcp, amiDebug, util_lib],
include_directories: [openssl_inc],
dependencies: [openssl_lib],
)

19
src/micetools/system_dummy/dummymaster/meson.build
View File

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

2
src/micetools/util/exio_test.c
View File

@ -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");

26
src/micetools/util/meson.build
View File

@ -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,
],
)

32
src/micetools/util/micefs_test.c
View File

@ -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);
}

14
src/micetools/util/micemonitor.c
View File

@ -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;
}

80
src/micetools/util/test.c
View File

@ -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);
}

40
src/tools/keys.py
View File

@ -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")

1
subprojects/cimgui_dep/imgui/backends/GL/freeglut.h
View File

@ -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"

1
subprojects/cimgui_dep/imgui/backends/GL/freeglut_std.h
View File

@ -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

1
subprojects/cimgui_dep/imgui/backends/GL/glut.h
View File

@ -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 ***/