fix(dat): always map the client's handle; retry until it's ready

Drop the "open our own handle" fast path - toolbox only runs injected in
the client, which holds Gw.dat exclusively, so our own open never wins.
Always locate and map the client's open handle.

Because a texture request could momentarily race ahead of the client
opening the dat, make loading retryable: EnsureLoaded now retries the
scan on each call (mutex-guarded, atomic fast-path once loaded) instead
of latching the first failure via call_once, and ParseIndex resets its
state so a retry starts clean.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: 3vcloud

GWToolboxdll/Modules/GwDatTextureModule.cpp

@@ -197,18 +197,14 @@ bool GwDatTextureModule::ReadDatFile(const wchar_t* file_name, std::vector<uint8
         return false;
     auto& dat = GwDatArchive::Instance();
     const bool ok = dat.ReadFile(file_id, *bytes_out, stream_id);
-    // Report the archive outcome exactly once.
-    static std::once_flag reported;
-    std::call_once(reported, [&dat] {
-        if (!dat.Loaded()) {
-            Log::LogW(L"[GwDat] Could not open dat '%s' (Win32 error %lu)",
-                      dat.DatPath().c_str(), dat.LastError());
-        }
-        else {
-            Log::LogW(L"[GwDat] Opened dat '%s' via %s handle", dat.DatPath().c_str(),
-                      dat.UsingGameHandle() ? L"the client's" : L"our own");
-        }
-    });
+    // Log once, the first time the archive is available (early failures are
+    // transient - the client may not have opened the dat yet).
+    if (dat.Loaded()) {
+        static std::once_flag reported;
+        std::call_once(reported, [&dat] {
+            Log::LogW(L"[GwDat] Mapped client's Gw.dat ('%s')", dat.DatPath().c_str());
+        });
+    }
     return ok;
 }
 

GWToolboxdll/Utils/GwDat/GwDatArchive.cpp

@@ -81,37 +81,21 @@ GwDatArchive& GwDatArchive::Instance()
 
 bool GwDatArchive::EnsureLoaded()
 {
-    std::call_once(m_load_once, [this] { m_loaded = ParseIndex(); });
-    return m_loaded;
+    if (m_loaded.load(std::memory_order_acquire))
+        return true;
+    std::lock_guard<std::mutex> lock(m_load_mutex);
+    if (!m_loaded.load(std::memory_order_relaxed) && ParseIndex())
+        m_loaded.store(true, std::memory_order_release);
+    return m_loaded.load(std::memory_order_relaxed);
 }
 
 bool GwDatArchive::AcquireMapping()
 {
-    // Fast path: open and map our own handle. Works when the client isn't holding
-    // the dat exclusively (e.g. it isn't running).
-    const HANDLE own = CreateFileW(m_dat_path.c_str(), GENERIC_READ,
-                                   FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                                   nullptr, OPEN_EXISTING, 0, nullptr);
-    if (own != INVALID_HANDLE_VALUE) {
-        const HANDLE mapping = MapDat(own);
-        LARGE_INTEGER sz;
-        if (GetFileSizeEx(own, &sz))
-            m_file_size = sz.QuadPart;
-        CloseHandle(own);
-        if (mapping) {
-            m_mapping = mapping;
-            m_using_game_handle = false;
-            return true;
-        }
-    }
-    else {
-        m_last_error = GetLastError();
-    }
-
     // The running client opens Gw.dat read/write with no sharing (NtFile.cpp), so
-    // our own open fails. It is bound to the client's I/O completion port, so we
-    // must not ReadFile it - instead map the client's already-open handle. Scan
-    // the process handle table for the disk handle that maps to the archive magic.
+    // we can't open our own handle, and it binds the handle to its I/O completion
+    // port, so we must not ReadFile it either. Instead map the client's already-open
+    // handle: scan the process handle table for the disk handle that maps to the
+    // archive magic. If none is found the client hasn't opened the dat yet.
     for (ULONG_PTR v = 4; v <= 0x40000; v += 4) {
         const HANDLE h = reinterpret_cast<HANDLE>(v);
         if (GetFileType(h) != FILE_TYPE_DISK)
@@ -123,15 +107,24 @@ bool GwDatArchive::AcquireMapping()
         if (GetFileSizeEx(h, &sz))
             m_file_size = sz.QuadPart;
         m_mapping = mapping;
-        m_using_game_handle = true;
         return true;
     }
     return false;
 }
 
 bool GwDatArchive::ParseIndex()
 {
-    m_dat_path = ResolveDatPath();
+    // Reset any state from a previous failed attempt so retries start clean.
+    if (m_mapping) {
+        CloseHandle(reinterpret_cast<HANDLE>(m_mapping));
+        m_mapping = nullptr;
+    }
+    m_file_size = 0;
+    m_slots.clear();
+    m_fileid_to_slot.clear();
+
+    if (m_dat_path.empty())
+        m_dat_path = ResolveDatPath();
     if (m_dat_path.empty())
         return false;
 

GWToolboxdll/Utils/GwDat/GwDatArchive.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <atomic>
 #include <cstdint>
 #include <mutex>
 #include <string>
@@ -18,16 +19,15 @@ class GwDatArchive {
 public:
     static GwDatArchive& Instance();
 
-    // Opens and indexes Gw.dat on first use. Thread-safe and idempotent.
+    // Indexes Gw.dat by mapping the client's open handle. Retries on each call
+    // until it succeeds, so an early request before the client has opened the dat
+    // doesn't latch failure. Thread-safe.
     bool EnsureLoaded();
 
-    // Diagnostics (valid after EnsureLoaded()): the resolved dat path, whether the
-    // index loaded, the Win32 error from a failing CreateFile (0 if none), and
-    // whether we fell back to the client's own (exclusively-held) dat handle.
+    // Diagnostics (valid after EnsureLoaded()): the resolved dat path and whether
+    // the index has loaded.
     const std::wstring& DatPath() const { return m_dat_path; }
-    bool Loaded() const { return m_loaded; }
-    unsigned long LastError() const { return m_last_error; }
-    bool UsingGameHandle() const { return m_using_game_handle; }
+    bool Loaded() const { return m_loaded.load(std::memory_order_acquire); }
 
     // Reads the decompressed bytes for a GW file id (the dat "file number", the
     // same value ArenaNetFileParser::FileHashToFileId produces). stream_id is an
@@ -71,13 +71,11 @@ class GwDatArchive {
 #pragma pack(pop)
     static_assert(sizeof(MftEntry) == 24, "on-disk MFT entry must be 24 bytes");
 
-    bool ParseIndex();      // reads header + MFT once, driven by EnsureLoaded's call_once
-    bool AcquireMapping();  // maps the dat via our own handle, or the client's open one
+    bool ParseIndex();      // resets state, then reads header + MFT; safe to retry
+    bool AcquireMapping();  // maps the client's open dat handle; false if not found yet
 
-    std::once_flag m_load_once;
-    bool m_loaded = false;
-    bool m_using_game_handle = false;
-    unsigned long m_last_error = 0; // Win32 error from a failed CreateFile
+    std::mutex m_load_mutex;
+    std::atomic<bool> m_loaded{false};
     void* m_mapping = nullptr;      // file-mapping HANDLE for the dat, kept for the archive lifetime
     long long m_file_size = 0;      // dat size captured when the mapping was created
     std::wstring m_dat_path;