Merge branch 'master' into fix/skip_av_wine

Author: Xenius97

Client/ceflauncher/Main.cpp

@@ -27,7 +27,7 @@ struct HINSTANCE__;
 using HINSTANCE = HINSTANCE__*;
 using LPSTR = char*;
 
-[[nodiscard("InitCEF return value must be used")]] __declspec(dllimport) auto InitCEF() -> int;
+extern "C" [[nodiscard("InitCEF return value must be used")]] __declspec(dllimport) int __cdecl InitCEF();
 
 // Users are faced with vague crashes in CEFLauncher.exe, so rather than over-engineering all this is intended
 // Do note that CEFLauncher.exe ends up hosting any GPU rendering processes of CEF

Client/ceflauncher_DLL/Main.cpp

@@ -9,111 +9,170 @@
  *
  *****************************************************************************/
 
+// #define CEF_ENABLE_SANDBOX
+
+#include <atomic>
+
 #define WIN32_NO_STATUS
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
+
 #undef WIN32_NO_STATUS
 #include <ntstatus.h>
-#include <winnt.h>
 #include <winternl.h>
 #include <delayimp.h>
+
 #include "CCefApp.h"
-#include <string>
-#include <cef3/cef/include/cef_sandbox_win.h>
-#include <SharedUtil.h>
+#include "SharedUtil.h"
 
-// #define CEF_ENABLE_SANDBOX
 #ifdef CEF_ENABLE_SANDBOX
-    #pragma comment(lib, "cef_sandbox.lib")
+#include <cef3/cef/include/cef_sandbox_win.h>
+#pragma comment(lib, "cef_sandbox.lib")
 #endif
 
-DWORD WINAPI CheckParentProcessAliveness(LPVOID);
+// Return codes
+inline constexpr int CEF_INIT_SUCCESS                = 0;
+inline constexpr int CEF_INIT_ERROR_NO_BASE_DIR      = -1;
+inline constexpr int CEF_INIT_ERROR_DLL_LOAD_FAILED  = -2;
 
-int _declspec(dllexport) InitCEF()
-{
-    // Get MTA base directory and set DLL directory to MTA folder
-    const SString strBaseDir = SharedUtil::GetMTAProcessBaseDir();
-    
-    if (strBaseDir.empty())
-    {
-        // Unable to determine base directory - CEF cannot initialize
-        return -1;
-    }
-    
-    const SString strMTADir = SharedUtil::PathJoin(strBaseDir, "MTA");
-    
-    SetDllDirectoryW(SharedUtil::FromUTF8(strMTADir));
+inline constexpr DWORD       CEF_PARENT_CHECK_INTERVAL       = 1000;
+inline constexpr const char* CEF_DLL_NAME                    = "libcef.dll";
+inline constexpr const char* CEF_MTA_SUBDIR                  = "MTA";
 
-    // Load libcef.dll from the DLL directory
-    assert(SUCCEEDED(__HrLoadAllImportsForDll("libcef.dll")));
+inline constexpr DWORD PARENT_CHECK_ERROR_NO_QUERY_FUNC    = 1;
+inline constexpr DWORD PARENT_CHECK_ERROR_QUERY_FAILED     = 2;
+inline constexpr DWORD PARENT_CHECK_ERROR_OPEN_FAILED      = 3;
 
-    // Load CEF
-    CefMainArgs        mainArgs(GetModuleHandle(NULL));
-    CefRefPtr<CCefApp> app{new CCefApp};
+using NtQueryInformationProcessFunc = NTSTATUS(NTAPI*)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG);
 
-    void* sandboxInfo = nullptr;
-#ifdef CEF_ENABLE_SANDBOX
-    CefScopedSandboxInfo scopedSandbox;
-    sandboxInfo = scopedSandbox.sandbox_info();
-#endif
+// Safe parent monitor thread shutdown
+std::atomic<bool> g_bShouldTerminateMonitor{false};
+std::atomic<HANDLE> g_hMonitorThread{nullptr};
 
-    const HANDLE parentCheckThread = CreateThread(nullptr, 0, CheckParentProcessAliveness, nullptr, 0, nullptr);
+namespace
+{
+    [[nodiscard]] auto GetNtQueryInformationProcess() noexcept -> NtQueryInformationProcessFunc
+    {
+        const auto ntdll = GetModuleHandleW(L"ntdll.dll");
+        if (!ntdll)
+            return nullptr;
+            
+        const auto procAddr = GetProcAddress(ntdll, "NtQueryInformationProcess");
+        if (!procAddr)
+            return nullptr;
+            
+        return reinterpret_cast<NtQueryInformationProcessFunc>(procAddr);
+    }
 
-    const int exitCode = CefExecuteProcess(mainArgs, app, sandboxInfo);
+    [[nodiscard]] auto GetParentProcessId(NtQueryInformationProcessFunc queryFunc) noexcept -> DWORD
+    {
+        PROCESS_BASIC_INFORMATION info{};
+        ULONG returnLength = 0;
+        
+        if (const auto status = queryFunc(GetCurrentProcess(), ProcessBasicInformation, &info, sizeof(info), &returnLength);
+            !NT_SUCCESS(status) || returnLength < sizeof(PROCESS_BASIC_INFORMATION))
+        {
+            return 0;
+        }
 
-    if (parentCheckThread != nullptr)
+        return static_cast<DWORD>(reinterpret_cast<ULONG_PTR>(info.Reserved3));
+    }
+
+    void MonitorParentProcess(HANDLE parentProcess) noexcept
     {
-        TerminateThread(parentCheckThread, 0);
-        CloseHandle(parentCheckThread);
+        while (!g_bShouldTerminateMonitor.load(std::memory_order_acquire))
+        {
+            const DWORD result = WaitForSingleObject(parentProcess, CEF_PARENT_CHECK_INTERVAL);
+            
+            if (result == WAIT_OBJECT_0)
+            {
+                DWORD exitCode = 0;
+                if (GetExitCodeProcess(parentProcess, &exitCode))
+                    ExitProcess(exitCode);
+                else
+                    ExitProcess(0);
+            }
+            else if (result == WAIT_FAILED)
+            {
+                // Wine/Proton compatibility: Exit thread instead of terminating process
+                // Wine's handle implementation dont support all wait operations reliably
+                break;
+            }
+        }
     }
+}            // namespace
 
-    return exitCode;
-}
+DWORD WINAPI CheckParentProcessAliveness(LPVOID) noexcept;
 
-static DWORD WINAPI CheckParentProcessAliveness(LPVOID)
+BOOL APIENTRY DllMain(HMODULE hModule, DWORD dwReason, [[maybe_unused]] LPVOID lpReserved)
 {
-    NTSTATUS(NTAPI * queryInformation)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG) = nullptr;
-
-    if (auto ntdll = GetModuleHandleW(L"ntdll.dll"); ntdll != nullptr)
+    if (dwReason == DLL_PROCESS_ATTACH)
     {
-        auto procAddr = GetProcAddress(ntdll, "NtQueryInformationProcess");
-        queryInformation = reinterpret_cast<decltype(queryInformation)>(reinterpret_cast<void*>(procAddr));
+        DisableThreadLibraryCalls(hModule);
+        g_bShouldTerminateMonitor.store(false, std::memory_order_relaxed);
+        g_hMonitorThread.store(nullptr, std::memory_order_relaxed);
     }
+    else if (dwReason == DLL_PROCESS_DETACH)
+    {
+        g_bShouldTerminateMonitor.store(true, std::memory_order_release);
+    }
+    
+    return TRUE;
+}
 
-    if (queryInformation == nullptr)
-        return 1;
+extern "C" [[nodiscard]] __declspec(dllexport) auto InitCEF() noexcept -> int
+{
+    const auto baseDir = SharedUtil::GetMTAProcessBaseDir();
+    if (baseDir.empty())
+        return CEF_INIT_ERROR_NO_BASE_DIR;
+    
+    const auto mtaDir = SharedUtil::PathJoin(baseDir, CEF_MTA_SUBDIR);
+    SetDllDirectoryW(SharedUtil::FromUTF8(mtaDir));
 
-    PROCESS_BASIC_INFORMATION info{};
+    if (FAILED(__HrLoadAllImportsForDll(CEF_DLL_NAME)))
+        return CEF_INIT_ERROR_DLL_LOAD_FAILED;
 
-    ULONG    returnLength = 0;
-    NTSTATUS status = queryInformation(GetCurrentProcess(), ProcessBasicInformation, &info, sizeof(info), &returnLength);
+    const CefMainArgs mainArgs(GetModuleHandleW(nullptr));
+    const CefRefPtr<CCefApp> app{new CCefApp};
 
-    if (!NT_SUCCESS(status) || returnLength < sizeof(PROCESS_BASIC_INFORMATION))
-        return 2;
+    void* sandboxInfo = nullptr;
+#ifdef CEF_ENABLE_SANDBOX
+    const CefScopedSandboxInfo scopedSandbox;
+    sandboxInfo = scopedSandbox.sandbox_info();
+#endif
 
-    const auto   parentProcessId = static_cast<DWORD>(reinterpret_cast<ULONG_PTR>(info.Reserved3));
-    const HANDLE parentProcess = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_LIMITED_INFORMATION, FALSE, parentProcessId);
+    const auto hThread = CreateThread(nullptr, 0, CheckParentProcessAliveness, nullptr, 0, nullptr);
+    if (hThread)
+        g_hMonitorThread.store(hThread, std::memory_order_release);
 
-    if (parentProcess == nullptr)
-    {
-        if (GetLastError() == ERROR_INVALID_PARAMETER)
-            ExitProcess(0);
+    return CefExecuteProcess(mainArgs, app, sandboxInfo);
+}
 
-        return 3;
-    }
+static auto WINAPI CheckParentProcessAliveness([[maybe_unused]] LPVOID) noexcept -> DWORD
+{
+    const auto queryFunc = GetNtQueryInformationProcess();
+    if (!queryFunc)
+        return PARENT_CHECK_ERROR_NO_QUERY_FUNC;
 
-    while (true)
-    {
-        DWORD exitCode{};
+    const auto parentProcessId = GetParentProcessId(queryFunc);
+    if (parentProcessId == 0)
+        return PARENT_CHECK_ERROR_QUERY_FAILED;
 
-        if (!GetExitCodeProcess(parentProcess, &exitCode) || exitCode != STILL_ACTIVE)
+    const auto parentProcess = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_LIMITED_INFORMATION, false, parentProcessId);
+    if (!parentProcess)
+    {
+        // Wine/Proton fallback: PROCESS_QUERY_LIMITED_INFORMATION may not be implemented
+        const auto parentProcessFallback = OpenProcess(SYNCHRONIZE, false, parentProcessId);
+        if (parentProcessFallback)
         {
-            CloseHandle(parentProcess);
-            ExitProcess(exitCode);
+            MonitorParentProcess(parentProcessFallback);
+            CloseHandle(parentProcessFallback);
+            return CEF_INIT_SUCCESS;
         }
-
-        Sleep(1000);
+        return PARENT_CHECK_ERROR_OPEN_FAILED;
     }
 
-    return 0;
+    MonitorParentProcess(parentProcess);
+    CloseHandle(parentProcess);
+    return CEF_INIT_SUCCESS;
 }

Client/cefweb/CAjaxResourceHandler.cpp

@@ -2,52 +2,47 @@
  *
  *  PROJECT:     Multi Theft Auto v1.0
  *  LICENSE:     See LICENSE in the top level directory
- *  FILE:        core/AjaxResourceHandler.cpp
+ *  FILE:        cefweb/CAjaxResourceHandler.cpp
  *  PURPOSE:     CEF Handler for Ajax Requests with delayed results
  *
+ *  Multi Theft Auto is available from https://www.multitheftauto.com/
+ *
  *****************************************************************************/
 
 #include "StdInc.h"
-#include "CWebCore.h"
-#include "CWebView.h"
 #include "CAjaxResourceHandler.h"
 #undef min
 
 CAjaxResourceHandler::CAjaxResourceHandler(std::vector<SString>& vecGet, std::vector<SString>& vecPost, const CefString& strMime)
-    : m_vecGetData(vecGet), m_vecPostData(vecPost), m_strMime(strMime)
+    : m_vecGetData(std::move(vecGet)), m_vecPostData(std::move(vecPost)), m_strMime(strMime)
 {
 }
 
 CAjaxResourceHandler::~CAjaxResourceHandler()
 {
     // Ensure callback is released if handler is destroyed before completion
-    if (m_callback)
-    {
-        m_callback = nullptr;
-    }
-}
-
-std::vector<SString>& CAjaxResourceHandler::GetGetData()
-{
-    return m_vecGetData;
-}
+    if (!m_callback)
+        return;
 
-std::vector<SString>& CAjaxResourceHandler::GetPostData()
-{
-    return m_vecPostData;
+    m_callback = nullptr;
 }
 
 void CAjaxResourceHandler::SetResponse(const SString& data)
 {
+    // Prevent response corruption: ignore subsequent calls after data is set
+    if (m_bHasData) [[unlikely]]
+        return;
+
     m_strResponse = data;
     m_bHasData = true;
 
-    if (m_callback)
-    {
-        m_callback->Continue();
-        // Release callback to prevent memory leak
-        m_callback = nullptr;
-    }
+    if (!m_callback)
+        return;
+
+    // Release callback to prevent memory leak
+    auto callback = std::exchange(m_callback, nullptr);
+    if (callback)
+        callback->Continue();
 }
 
 // CefResourceHandler implementation
@@ -59,42 +54,64 @@ void CAjaxResourceHandler::Cancel()
 
 void CAjaxResourceHandler::GetResponseHeaders(CefRefPtr<CefResponse> response, int64& response_length, CefString& redirectUrl)
 {
-    response->SetStatus(200);
+    if (!response) [[unlikely]]
+        return;
+
+    constexpr int HTTP_OK = 200;
+    response->SetStatus(HTTP_OK);
     response->SetStatusText("OK");
-    response->SetMimeType(m_strMime);
+    
+    // Use default MIME type if none provided
+    if (!m_strMime.empty())
+        response->SetMimeType(m_strMime);
+    else
+        response->SetMimeType("application/octet-stream");
+    
     response_length = -1;
 }
 
-bool CAjaxResourceHandler::ProcessRequest(CefRefPtr<CefRequest> request, CefRefPtr<CefCallback> callback)
+bool CAjaxResourceHandler::ProcessRequest([[maybe_unused]] CefRefPtr<CefRequest> request, CefRefPtr<CefCallback> callback)
 {
-    // Since we have nothing to process yet, continue
-    callback->Continue();
+    // Don't call Continue() here - let ReadResponse handle async flow
+    // Calling Continue() immediately would use the callback before data is ready
     return true;
 }
 
 bool CAjaxResourceHandler::ReadResponse(void* data_out, int bytes_to_read, int& bytes_read, CefRefPtr<CefCallback> callback)
 {
+    // Validate input parameters first
+    if (!data_out || bytes_to_read <= 0) [[unlikely]]
+    {
+        bytes_read = 0;
+        return false;
+    }
+
     // If we have no data yet, wait
     if (!m_bHasData)
     {
         bytes_read = 0;
-        m_callback = callback;
-
+        // Store callback only if we don't already have one (prevent overwrite/leak)
+        if (callback && !m_callback)
+            m_callback = callback;
         return true;
     }
 
-    // Are we done?
-    if (m_strResponse.length() - m_DataOffset <= 0) [[unlikely]]
-        return false;
-
-    if (bytes_to_read <= 0) [[unlikely]]
+    // Are we done or response is empty?
+    const auto responseLength = m_strResponse.length();
+    if (m_DataOffset >= responseLength) [[unlikely]]
+    {
+        bytes_read = 0;
         return false;
+    }
 
-    const size_t copyBytes = std::min(static_cast<size_t>(bytes_to_read), m_strResponse.length() - m_DataOffset);
+    const auto remainingBytes = responseLength - m_DataOffset;
+    const auto copyBytes = std::min(static_cast<size_t>(bytes_to_read), remainingBytes);
 
     memcpy(data_out, m_strResponse.c_str() + m_DataOffset, copyBytes);
+    
+    // copyBytes is bounded by bytes_to_read (an int), so cast is always safe
     bytes_read = static_cast<int>(copyBytes);
-
+    
     m_DataOffset += copyBytes;
 
     return true;