Enhanced migration (#83)

* Make it inject

* W.I.P.

* W.I.P.

* Drop atl dep

* WndProc use detour instead of SetWindowLongPtr

Fixes random crashes due to a dead wndproc ptr

* Rate limit Discord RPC updates

* Update discord-rpc

* Add exponential backoff to spinlock

* Remove cached batch scanning

With the speed of the current sig scanner caching the results is completely useless

* Misc

* Only log c++ exception in own module

* Minor fixes

* Renderer enhancements

* Fix release build

* Update menu/src/render/d3d12/context.cpp

Co-authored-by: Copilot <[email protected]>

* Fix review comments

---------

Co-authored-by: Copilot <[email protected]>

Author: X-rays5

common/src/concurrency/spinlock.cpp

@@ -11,7 +11,9 @@ namespace base::common::concurrency {
         return;
       }
 
-      while (lock_.load(std::memory_order_relaxed)) {
+      // Exponential backoff
+      for (int i = 0; i < 16; ++i) {
+        if (!lock_.load(std::memory_order_relaxed)) break;
         std::this_thread::yield();
       }
     }
@@ -27,7 +29,7 @@ namespace base::common::concurrency {
 
   void RecursiveSpinlock::Lock() noexcept {
     const auto thread_id = std::this_thread::get_id();
-    if (cur_locking_thread_.load(std::memory_order_consume) == thread_id) {
+    if (cur_locking_thread_.load(std::memory_order_acquire) == thread_id) {
       lock_count_ += 1;
       return;
     }

common/src/concurrency/spinlock.hpp

@@ -71,7 +71,7 @@ namespace base::common::concurrency {
     Spinlock spinlock_;
     std::atomic<std::thread::id> cur_locking_thread_;
     std::thread::id default_thread_id_;
-    std::size_t lock_count_{};
+    std::atomic<std::size_t> lock_count_{0};
   };
 
   /**

common/src/globals.hpp

@@ -8,8 +8,9 @@
 namespace base::common::globals {
   constexpr static auto* kBASE_NAME = "base";
   constexpr static auto* target_window_name = "";
-  constexpr static auto* target_window_class = "grcWindow";
-  constexpr static auto* target_process_name = "GTA5.exe";
+  constexpr static auto* target_window_class = "sgaWindow";
+  constexpr static auto* target_process_name = "GTA5_Enhanced.exe";
+  constexpr static auto* target_process_name_be = "GTA5_Enhanced_BE.exe";
 }
 
 #endif //GLOBALS_HPP_02231200

common/src/logging/exception/exception_report.cpp

@@ -51,7 +51,7 @@ namespace base::common::logging::exception {
       if (!mem_info_res) {
         LOG_CRITICAL("Failed to get memory information for exception at: 0x{:X}", addr);
       }
-      MEMORY_BASIC_INFORMATION mem_info = mem_info_res.value();
+      const MEMORY_BASIC_INFORMATION mem_info = mem_info_res.value();
 
       if (mem_info.AllocationProtect != PAGE_EXECUTE_READ && mem_info.AllocationProtect != PAGE_EXECUTE_READWRITE && mem_info.AllocationProtect != PAGE_EXECUTE_WRITECOPY) {
         LOG_ERROR("Address is not in executable memory.");
@@ -121,6 +121,9 @@ namespace base::common::logging::exception {
     msg << "***** Exception flags: " << except_rec->ExceptionFlags << " *****\n";
     msg << "***** Exception instruction: " << GetInstructionsStr(ctx->Rip).value_or("Failed to decompile exception area.") << " *****\n";
 
+    msg << "\n***** STACK DUMP *****\n";
+    msg << GetRegisters(ctx);
+    msg << '\n' << std::stacktrace::current(stacktrace_skip_count) << '\n';
 
     msg << "\nLoaded Modules:\n";
 
@@ -134,10 +137,6 @@ namespace base::common::logging::exception {
       msg << '\n';
     }
 
-    msg << "\n***** STACKDUMP *****\n";
-    msg << GetRegisters(ctx);
-    msg << '\n' << std::stacktrace::current(stacktrace_skip_count) << '\n';
-
     std::filesystem::path report_dir = common::fs::vfs::GetExceptionReportsDir() / fmt::format("report_{}", common::util::time::GetTimeStamp());
     if (!std::filesystem::create_directories(report_dir)) {
       LOG_ERROR("Failed to create exception report directory '{}'", report_dir);

common/src/logging/exception/vectored_handler.cpp

@@ -3,25 +3,102 @@
 //
 
 #include "vectored_handler.hpp"
+#include <Zydis/Zydis.h>
 #include "exception_report.hpp"
 #include "util.hpp"
 #include "../logger.hpp"
 #include "../../win32/memory.hpp"
 
+#define VECTORED_HANDLER_ATTEMPT_RECOVERY
+
 namespace base::common::logging::exception {
   namespace {
     PVOID cur_handler = nullptr;
 
+    // Thread-local variables to track recovery attempts
+    thread_local std::uint32_t recovery_attempts = 0;
+    thread_local std::chrono::steady_clock::time_point last_exception_time{};
+
+    // Configuration constants
+    constexpr std::uint32_t MAX_RECOVERY_ATTEMPTS = 100;
+    constexpr std::chrono::milliseconds RECOVERY_RESET_TIMEOUT{5000};
+
+    std::optional<ZydisDecodedInstruction> GetInstructionAtAddr(const std::uintptr_t addr) {
+      ZydisDecoder decoder;
+#ifdef _M_AMD64
+      if (!ZYAN_SUCCESS(ZydisDecoderInit(&decoder, ZYDIS_MACHINE_MODE_LONG_64, ZYDIS_STACK_WIDTH_64)))
+#else
+      if (!ZYAN_SUCCESS(ZydisDecoderInit(&decoder, ZYDIS_MACHINE_MODE_LONG_COMPAT_32, ZYDIS_STACK_WIDTH_32)))
+#endif
+        return std::nullopt;
+
+      ZydisDecodedInstruction instruction{};
+      ZydisDecodedOperand operands[ZYDIS_MAX_OPERAND_COUNT];
+      if (ZYAN_SUCCESS(ZydisDecoderDecodeFull(&decoder, reinterpret_cast<void*>(addr), 15, &instruction, operands))) {
+        return instruction;
+      }
+
+      return std::nullopt;
+    }
+
+    bool ShouldAttemptRecovery(std::uintptr_t exception_address) {
+      const auto now = std::chrono::steady_clock::now();
+
+      if (now - last_exception_time > RECOVERY_RESET_TIMEOUT) {
+        recovery_attempts = 0;
+        last_exception_time = now;
+      }
+
+      if (recovery_attempts >= MAX_RECOVERY_ATTEMPTS) {
+        LOG_ERROR("Maximum recovery attempts ({}) reached for address {:X}, giving up",  MAX_RECOVERY_ATTEMPTS, exception_address);
+        return false;
+      }
+
+      return true;
+    }
+
+    bool SkipToNextInstruction(const PCONTEXT ctx) {
+      const auto exception_address = ctx->Rip;
+
+      if (!ShouldAttemptRecovery(exception_address)) {
+        return false;
+      }
+
+      const auto instruction_opt = GetInstructionAtAddr(exception_address);
+      if (!instruction_opt.has_value()) {
+        LOG_ERROR("Failed to decode instruction at {:X}", exception_address);
+        recovery_attempts++; // Count failed decode as an attempt
+        return false;
+      }
+
+      const auto& instruction = instruction_opt.value();
+      auto next_instruction = exception_address + instruction.length;
+
+      recovery_attempts++;
+
+      LOG_WARN("Trying to recover from exception (attempt {}/{}): {:X} -> {:X}",  recovery_attempts, MAX_RECOVERY_ATTEMPTS, exception_address, next_instruction);
+
+      ctx->Rip = next_instruction;
+      return true;
+    }
+
     void MSVCException(const PEXCEPTION_POINTERS except) {
+      const auto exception_address = except->ContextRecord->Rip;
+
+      // Only log exceptions from our own module
+      if (!win32::memory::IsAddressInCurrentModule(exception_address)) {
+        return;
+      }
+
       const std::uint32_t pid = GetCurrentProcessId();
 
-      auto mod_name_res = win32::memory::GetModuleNameFromAddress(pid, except->ContextRecord->Rip);
+      auto mod_name_res = win32::memory::GetModuleNameFromAddress(pid, exception_address);
       std::string mod_name;
       if (mod_name_res.has_value()) {
         mod_name = mod_name_res.value();
       }
 
-      auto offset_res = win32::memory::GetModuleOffsetFromAddress(pid, except->ContextRecord->Rip);
+      auto offset_res = win32::memory::GetModuleOffsetFromAddress(pid, exception_address);
       std::uintptr_t offset = 0;
       if (offset_res.has_value()) {
         offset = offset_res.value();
@@ -57,7 +134,12 @@ namespace base::common::logging::exception {
         return EXCEPTION_CONTINUE_SEARCH;
       }
 
-      // TODO: implement some cursed fatal exception recovery
+#ifdef VECTORED_HANDLER_ATTEMPT_RECOVERY
+      // We will now attempt to recover by moving the RIP to the next instruction (Yes I'm serious)
+      if (SkipToNextInstruction(except->ContextRecord)) {
+        return EXCEPTION_CONTINUE_EXECUTION;
+      }
+#endif
 
       if (auto stacktrace_res = WriteExceptionReport(except, 7); stacktrace_res.has_value()) {
         LOG_CRITICAL(stacktrace_res.value());

common/src/win32/memory.cpp

@@ -3,11 +3,12 @@
 //
 
 #include "memory.hpp"
+#include <intrin.h>
 
 namespace base::win32::memory {
-  StatusOr<std::uintptr_t> GetModuleBaseAddress(std::uint32_t pid, const std::string& mod_name) {
+  StatusOr<std::uintptr_t> GetModuleBaseAddress(const std::uint32_t pid, const std::string& mod_name) {
     std::uint64_t mod_base_addr = 0;
-    HANDLE h_snap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, pid);
+    const HANDLE h_snap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, pid);
     if (h_snap == INVALID_HANDLE_VALUE) {
       return MakeFailure<ResultCode::kINVALID_HANDLE>();
     }
@@ -17,7 +18,7 @@ namespace base::win32::memory {
     if (Module32First(h_snap, &mod_entry)) {
       do {
         if (!_stricmp(mod_entry.szModule, mod_name.c_str())) {
-          mod_base_addr = (std::uint64_t)mod_entry.modBaseAddr;
+          mod_base_addr = reinterpret_cast<std::uint64_t>(mod_entry.modBaseAddr);
           break;
         }
       } while (Module32Next(h_snap, &mod_entry));
@@ -28,17 +29,17 @@ namespace base::win32::memory {
     return mod_base_addr;
   }
 
-  StatusOr<MODULEENTRY32> GetModuleFromAddress(std::uint32_t pid, std::uintptr_t addr) {
+  StatusOr<MODULEENTRY32> GetModuleFromAddress(const std::uint32_t pid, const std::uintptr_t addr) {
     MODULEENTRY32 mod_entry;
-    HANDLE h_snap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, pid);
+    const HANDLE h_snap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, pid);
     if (h_snap == INVALID_HANDLE_VALUE) {
       return MakeFailure<ResultCode::kINVALID_HANDLE>();
     }
 
     mod_entry.dwSize = sizeof(mod_entry);
     if (Module32First(h_snap, &mod_entry)) {
       do {
-        if ((std::uint64_t)mod_entry.modBaseAddr <= addr && addr <= (std::uint64_t)mod_entry.modBaseAddr + mod_entry.modBaseSize) {
+        if (reinterpret_cast<std::uint64_t>(mod_entry.modBaseAddr) <= addr && addr <= reinterpret_cast<std::uint64_t>(mod_entry.modBaseAddr) + mod_entry.modBaseSize) {
           break;
         }
       } while (Module32Next(h_snap, &mod_entry));
@@ -49,26 +50,26 @@ namespace base::win32::memory {
     return mod_entry;
   }
 
-  StatusOr<std::string> GetModuleNameFromAddress(std::uint32_t pid, std::uintptr_t addr) {
+  StatusOr<std::string> GetModuleNameFromAddress(const std::uint32_t pid, const std::uintptr_t addr) {
     auto mod_addr = GetModuleFromAddress(pid, addr);
     if (!mod_addr)
       return mod_addr.error().Forward();
 
     return mod_addr->szModule;
   }
 
-  StatusOr<uintptr_t> GetModuleOffsetFromAddress(std::uint32_t pid, std::uintptr_t addr) {
+  StatusOr<uintptr_t> GetModuleOffsetFromAddress(const std::uint32_t pid, const std::uintptr_t addr) {
     auto mod_addr = GetModuleFromAddress(pid, addr);
     if (!mod_addr)
       return mod_addr.error();
 
     return addr - reinterpret_cast<std::uintptr_t>(mod_addr->modBaseAddr);
   }
 
-  StatusOr<MODULEENTRY32> GetModuleFromHModule(HMODULE mod) {
+  StatusOr<MODULEENTRY32> GetModuleFromHModule(const HMODULE mod) {
     MODULEENTRY32 mod_entry{};
     mod_entry.dwSize = sizeof(MODULEENTRY32);
-    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, GetCurrentProcessId());
+    const HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, GetCurrentProcessId());
     if (hSnapshot == INVALID_HANDLE_VALUE) {
       return MakeFailure<ResultCode::kINVALID_HANDLE>();
     }
@@ -83,4 +84,26 @@ namespace base::win32::memory {
     CloseHandle(hSnapshot);
     return mod_entry;
   }
+
+  __declspec(noinline) bool IsAddressInCurrentModule(const std::uintptr_t addr) {
+    const std::uint32_t pid = GetCurrentProcessId();
+
+    // Get the module name of the caller (our DLL) using the return address
+    auto caller_address = reinterpret_cast<std::uintptr_t>(_ReturnAddress());
+    auto our_module_name = GetModuleNameFromAddress(pid, caller_address);
+
+    if (!our_module_name.has_value()) {
+      return false;
+    }
+
+    // Get the module name of the input address
+    auto addr_module_name = GetModuleNameFromAddress(pid, addr);
+
+    if (!addr_module_name.has_value()) {
+      return false;
+    }
+
+    // Compare the module names
+    return _stricmp(our_module_name->c_str(), addr_module_name->c_str()) == 0;
+  }
 }

common/src/win32/memory.hpp

@@ -44,6 +44,12 @@ namespace base::win32::memory {
   * \return The module entry of the module
   */
  StatusOr<MODULEENTRY32> GetModuleFromHModule(HMODULE mod);
+ /**
+  * \brief Check if an address is within the current module's memory space
+  * \param addr address to check
+  * \return true if the address is within the current module, false otherwise
+  */
+ bool IsAddressInCurrentModule(std::uintptr_t addr);
 }
 
 #endif //GTA_BASE_MEMORY_6E2CBAF0C25F49E69A8329E5694C9C0B_HPP

common/src/win32/misc.cpp

@@ -90,20 +90,21 @@ namespace base::win32 {
     return foreground_window == GetConsoleWindow() || window;
   }
 
-  bool IsTargetProcess(const std::string& target_process) {
-    const auto exe_name = std::make_unique<CHAR[]>(MAX_PATH);
-    const std::uint32_t str_len = GetModuleFileNameA(nullptr, exe_name.get(), MAX_PATH);
+  bool IsGameProcess() {
+    static const auto exe_name = std::make_unique<CHAR[]>(MAX_PATH);
+    static const std::uint32_t str_len = GetModuleFileNameA(nullptr, exe_name.get(), MAX_PATH);
 
     if (str_len == 0) {
       LOG_ERROR("Failed to get module file name. win32 err code: {}", GetLastError());
       return false;
     }
 
-    const std::string cur_proc_name = std::filesystem::path(std::string(exe_name.get(), str_len)).filename().string();
+    static const std::string cur_proc_name = std::filesystem::path(std::string(exe_name.get(), str_len)).filename().string();
 
-    return cur_proc_name == target_process;
+    return cur_proc_name == common::globals::target_process_name || cur_proc_name == common::globals::target_process_name_be;
   }
 
+
   std::string GetLastErrorStr() {
     DWORD err = GetLastError();
     if (err == 0) {

common/src/win32/misc.hpp

@@ -68,12 +68,12 @@ namespace base::win32 {
   * \return bool
   */
  bool IsForegroundWindow(HWND window = GetGameHwnd().value());
+
  /**
-  * \brief Check if the current process is the target process
-  * \param target_process The name of the target process
+  * \brief Check if the current process is the game process
   * \return bool
   */
- bool IsTargetProcess(const std::string& target_process = common::globals::target_process_name);
+ bool IsGameProcess();
 
  /**
   * \brief Convert the return value of GetLastError() to a string message

common/src/win32/signal.hpp

@@ -49,4 +49,4 @@ namespace base::win32 {
     HANDLE signal_h_;
   };
 }
-#endif //SIGNAL_HPP_02232550
+#endif //SIGNAL_HPP_02232550