phaneron/Kelsidavis-WoWee
1
0
Fork 0
mirror of https://github.com/Kelsidavis/WoWee.git synced 2026-04-27 05:23:51 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fix all remaining build warnings and eliminate UB in binary parsers

Browse source 
Resolve 57 compiler warnings (unused params/vars, ignored return values,
enum mismatch) and replace undefined-behavior reinterpret_cast with
memcpy in DBC, BLP, and Warden module loaders for ARM64 portability.
This commit is contained in:
Kelsi 2026-02-23 19:58:38 -08:00
parent 22518f0936
commit aaab2115d1
12 changed files with 112 additions and 101 deletions
Download patch file Download diff file Expand all files Collapse all files

20
src/game/warden_emulator.cpp
View file

@ -122,7 +122,7 @@ bool WardenEmulator::initialize(const void* moduleCode, size_t moduleSize, uint3
uint32_t WardenEmulator::hookAPI(const std::string& dllName,
const std::string& functionName,
std::function<uint32_t(WardenEmulator&, const std::vector<uint32_t>&)> handler) {
[[maybe_unused]] std::function<uint32_t(WardenEmulator&, const std::vector<uint32_t>&)> handler) {
// Allocate address for this API stub
static uint32_t nextStubAddr = API_STUB_BASE;
uint32_t stubAddr = nextStubAddr;
@ -239,7 +239,7 @@ std::string WardenEmulator::readString(uint32_t address, size_t maxLen) {
return std::string(buffer.data());
}
uint32_t WardenEmulator::allocateMemory(size_t size, uint32_t protection) {
uint32_t WardenEmulator::allocateMemory(size_t size, [[maybe_unused]] uint32_t protection) {
// Align to 4KB
size = (size + 0xFFF) & ~0xFFF;
@ -315,7 +315,7 @@ uint32_t WardenEmulator::apiVirtualFree(WardenEmulator& emu, const std::vector<u
return emu.freeMemory(lpAddress) ? 1 : 0;
}
uint32_t WardenEmulator::apiGetTickCount(WardenEmulator& emu, const std::vector<uint32_t>& args) {
uint32_t WardenEmulator::apiGetTickCount([[maybe_unused]] WardenEmulator& emu, [[maybe_unused]] const std::vector<uint32_t>& args) {
auto now = std::chrono::steady_clock::now();
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
uint32_t ticks = static_cast<uint32_t>(ms & 0xFFFFFFFF);
@ -324,7 +324,7 @@ uint32_t WardenEmulator::apiGetTickCount(WardenEmulator& emu, const std::vector<
return ticks;
}
uint32_t WardenEmulator::apiSleep(WardenEmulator& emu, const std::vector<uint32_t>& args) {
uint32_t WardenEmulator::apiSleep([[maybe_unused]] WardenEmulator& emu, const std::vector<uint32_t>& args) {
if (args.size() < 1) return 0;
uint32_t dwMilliseconds = args[0];
@ -333,12 +333,12 @@ uint32_t WardenEmulator::apiSleep(WardenEmulator& emu, const std::vector<uint32_
return 0;
}
uint32_t WardenEmulator::apiGetCurrentThreadId(WardenEmulator& emu, const std::vector<uint32_t>& args) {
uint32_t WardenEmulator::apiGetCurrentThreadId([[maybe_unused]] WardenEmulator& emu, [[maybe_unused]] const std::vector<uint32_t>& args) {
std::cout << "[WinAPI] GetCurrentThreadId() = 1234" << '\n';
return 1234; // Fake thread ID
}
uint32_t WardenEmulator::apiGetCurrentProcessId(WardenEmulator& emu, const std::vector<uint32_t>& args) {
uint32_t WardenEmulator::apiGetCurrentProcessId([[maybe_unused]] WardenEmulator& emu, [[maybe_unused]] const std::vector<uint32_t>& args) {
std::cout << "[WinAPI] GetCurrentProcessId() = 5678" << '\n';
return 5678; // Fake process ID
}
@ -347,7 +347,7 @@ uint32_t WardenEmulator::apiReadProcessMemory(WardenEmulator& emu, const std::ve
// ReadProcessMemory(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesRead)
if (args.size() < 5) return 0;
uint32_t hProcess = args[0];
[[maybe_unused]] uint32_t hProcess = args[0];
uint32_t lpBaseAddress = args[1];
uint32_t lpBuffer = args[2];
uint32_t nSize = args[3];
@ -377,13 +377,11 @@ uint32_t WardenEmulator::apiReadProcessMemory(WardenEmulator& emu, const std::ve
// Unicorn Callbacks
// ============================================================================
void WardenEmulator::hookCode(uc_engine* uc, uint64_t address, uint32_t size, void* userData) {
WardenEmulator* emu = static_cast<WardenEmulator*>(userData);
void WardenEmulator::hookCode([[maybe_unused]] uc_engine* uc, uint64_t address, [[maybe_unused]] uint32_t size, [[maybe_unused]] void* userData) {
std::cout << "[Trace] 0x" << std::hex << address << std::dec << '\n';
}
void WardenEmulator::hookMemInvalid(uc_engine* uc, int type, uint64_t address, int size, int64_t value, void* userData) {
WardenEmulator* emu = static_cast<WardenEmulator*>(userData);
void WardenEmulator::hookMemInvalid([[maybe_unused]] uc_engine* uc, int type, uint64_t address, int size, [[maybe_unused]] int64_t value, [[maybe_unused]] void* userData) {
const char* typeStr = "UNKNOWN";
switch (type) {

24
src/game/warden_module.cpp
View file

@ -129,7 +129,7 @@ bool WardenModule::load(const std::vector<uint8_t>& moduleData,
}
bool WardenModule::processCheckRequest(const std::vector<uint8_t>& checkData,
std::vector<uint8_t>& responseOut) {
[[maybe_unused]] std::vector<uint8_t>& responseOut) {
if (!loaded_) {
std::cerr << "[WardenModule] Module not loaded, cannot process checks" << '\n';
return false;
@ -198,7 +198,7 @@ bool WardenModule::processCheckRequest(const std::vector<uint8_t>& checkData,
return false;
}
uint32_t WardenModule::tick(uint32_t deltaMs) {
uint32_t WardenModule::tick([[maybe_unused]] uint32_t deltaMs) {
if (!loaded_ || !funcList_.tick) {
return 0; // No tick needed
}
@ -209,7 +209,7 @@ uint32_t WardenModule::tick(uint32_t deltaMs) {
return 0;
}
void WardenModule::generateRC4Keys(uint8_t* packet) {
void WardenModule::generateRC4Keys([[maybe_unused]] uint8_t* packet) {
if (!loaded_ || !funcList_.generateRC4Keys) {
return;
}
@ -633,9 +633,11 @@ bool WardenModule::applyRelocations() {
currentOffset += delta;
if (currentOffset + 4 <= moduleSize_) {
uint32_t* ptr = reinterpret_cast<uint32_t*>(
static_cast<uint8_t*>(moduleMemory_) + currentOffset);
*ptr += moduleBase_;
uint8_t* addr = static_cast<uint8_t*>(moduleMemory_) + currentOffset;
uint32_t val;
std::memcpy(&val, addr, sizeof(uint32_t));
val += moduleBase_;
std::memcpy(addr, &val, sizeof(uint32_t));
relocCount++;
} else {
std::cerr << "[WardenModule] Relocation offset " << currentOffset
@ -755,16 +757,16 @@ bool WardenModule::initializeModule() {
void (*logMessage)(const char* msg);
};
// Setup client callbacks
ClientCallbacks callbacks = {};
// Setup client callbacks (used when calling module entry point below)
[[maybe_unused]] ClientCallbacks callbacks = {};
// Stub callbacks (would need real implementations)
callbacks.sendPacket = [](uint8_t* data, size_t len) {
callbacks.sendPacket = []([[maybe_unused]] uint8_t* data, size_t len) {
std::cout << "[WardenModule Callback] sendPacket(" << len << " bytes)" << '\n';
// TODO: Send CMSG_WARDEN_DATA packet
};
callbacks.validateModule = [](uint8_t* hash) {
callbacks.validateModule = []([[maybe_unused]] uint8_t* hash) {
std::cout << "[WardenModule Callback] validateModule()" << '\n';
// TODO: Validate module hash
};
@ -779,7 +781,7 @@ bool WardenModule::initializeModule() {
free(ptr);
};
callbacks.generateRC4 = [](uint8_t* seed) {
callbacks.generateRC4 = []([[maybe_unused]] uint8_t* seed) {
std::cout << "[WardenModule Callback] generateRC4()" << '\n';
// TODO: Re-key RC4 cipher
};