Further Error U01 fixes after 59428cf & 575040e.

Dutchman101 · Dutchman101 · commit 2ab6fe07c8bd · 2026-05-03T23:30:12.000+08:00
This is first and foremost important for 1.6 as we need a reliable aotu-updater when the time to release comes; the class of U01 root causes being addressed here happens right after update from upcache.
diff --git a/Client/loader/CInstallManager.cpp b/Client/loader/CInstallManager.cpp
@@ -304,17 +304,28 @@ void CInstallManager::InitSequencer()
 //////////////////////////////////////////////////////////
 void CInstallManager::SetMTASAPathSource(const SString& strCommandLineIn)
 {
-    // Update some settings which are used by ReportLog
-    UpdateSettingsForReportLog();
-
     InitSequencer();
     RestoreSequencerFromSnapshot(strCommandLineIn);
 
     // If command line says we're not running from the launch directory, get the launch directory location from the registry
     if (m_pSequencer->GetVariable(INSTALL_LOCATION) == "far")
+    {
+        // Process B carried the real install root through the sequencer state. Honor it here so this
+        // temp launcher process can resolve its base dir without depending only on the registry.
+        // The override must be installed before UpdateSettingsForReportLog runs, because that helper
+        // reaches GetInstallPathForLauncher / GetMTASAPath through UpdateMTAVersionApplicationSetting.
+        const SString strRealInstallRoot = m_pSequencer->GetVariable(INSTALL_ROOT);
+        if (!strRealInstallRoot.empty() && IsUsableMtasaInstallRoot(strRealInstallRoot) && !IsTemporaryUpdateLaunchPath(strRealInstallRoot))
+            SharedUtil::SetMTASABaseDirOverride(strRealInstallRoot);
+
         ::SetMTASAPathSource(true);
+    }
     else
         ::SetMTASAPathSource(false);
+
+    // Update some settings which are used by ReportLog. Must run after the path source is resolved
+    // so that report-log helpers see the real install root rather than a temp extraction directory.
+    UpdateSettingsForReportLog();
 }
 
 //////////////////////////////////////////////////////////
@@ -1026,6 +1037,11 @@ SString CInstallManager::_MaybeSwitchToTempExe()
     // If a new "Multi Theft Auto.exe" exists, let that complete the install
     if (m_pSequencer->GetVariable(INSTALL_LOCATION) == "far")
     {
+        // Carry the current real install root forward to the temp launcher so it can set a base-dir
+        // override before reading the registry. Without this, the temp launcher has only Last Run
+        // Location to fall back on, which can be missing, stale, or denied by HKLM write failures.
+        m_pSequencer->SetVariable(INSTALL_ROOT, GetMTASAPath());
+
         ReleaseSingleInstanceMutex();
         if (ShellExecuteNonBlocking("open", GetLauncherPathFilename(), GetSequencerSnapshot()))
             ExitProcess(0);  // All done here
@@ -1049,8 +1065,13 @@ SString CInstallManager::_SwitchBackFromTempExe()
     {
         m_pSequencer->SetVariable(INSTALL_LOCATION, "near");
 
-        SString strLauncherPathFilename = PathJoin(GetInstallPathForLauncher(), MTA_EXE_NAME);
-        if (!FileExists(strLauncherPathFilename))
+        // GetInstallPathForLauncher returns empty when running from a temp update directory and no
+        // usable non-temp install root could be resolved. PathJoin would then produce a root-relative
+        // probe like "\Multi Theft Auto.exe", which could match an unrelated file on the current drive
+        // and cause us to launch the wrong executable. Skip straight to the GetMTASAPath() fallback.
+        const SString strRealInstallRoot = GetInstallPathForLauncher();
+        SString       strLauncherPathFilename = strRealInstallRoot.empty() ? SString() : PathJoin(strRealInstallRoot, MTA_EXE_NAME);
+        if (strLauncherPathFilename.empty() || !FileExists(strLauncherPathFilename))
         {
             strLauncherPathFilename = PathJoin(GetMTASAPath(), MTA_EXE_NAME);
             if (!FileExists(strLauncherPathFilename))
@@ -1707,7 +1728,10 @@ SString CInstallManager::_ProcessAppCompatChecks()
     IsWow64Process(GetCurrentProcess(), &bIsWOW64);
     uint    uiHKLMFlags = bIsWOW64 ? KEY_WOW64_64KEY : 0;
     WString strGTAExePathFilename = GetGameExecutablePath().wstring();
-    WString strMTAExePathFilename = FromUTF8(PathJoin(GetInstallPathForLauncher(), MTA_EXE_NAME));
+    SString strMTAInstallPath = GetInstallPathForLauncher();
+    if (strMTAInstallPath.empty())
+        strMTAInstallPath = GetMTASAPath();
+    WString strMTAExePathFilename = FromUTF8(PathJoin(strMTAInstallPath, MTA_EXE_NAME));
     WString strCompatModeRegKey = L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\AppCompatFlags\\Layers";
     int     bWin816BitColorOption = GetApplicationSettingInt("Win8Color16");
     int     bWin8MouseOption = GetApplicationSettingInt("Win8MouseFix");
diff --git a/Client/loader/CInstallManager.h b/Client/loader/CInstallManager.h
@@ -15,6 +15,7 @@
 // Common command line keys
 #define INSTALL_STAGE    "install_stage"
 #define INSTALL_LOCATION "install_loc"
+#define INSTALL_ROOT     "install_root"
 #define HIDE_PROGRESS    "hide_prog"
 
 typedef CBadLang<class CInstallManager> CSequencerType;
diff --git a/Client/loader/MainFunctions.cpp b/Client/loader/MainFunctions.cpp
@@ -461,9 +461,17 @@ void InitLocalization(bool bShowErrors)
         return;
 
     const SString strLaunchPath = GetLaunchPath();
+    const SString strMTASAPath = GetMTASAPath();
+
+    // Probe the install root first and only fall back to the launch path. In the auto-update flow,
+    // Process C runs from a temp directory under \upcache\_*_tmp_*\ which does not contain mta\core.dll;
+    // the real install root is carried into g_strMTASAPath via the install manager's SetMTASABaseDirOverride
+    // path, so GetMTASAPath returns it even though GetLaunchPath still points at the temp tree. On a normal
+    // non-temp launch the two paths are equal and the first probe succeeds.
+    SString strCoreDLL = PathJoin(strMTASAPath, "mta", MTA_DLL_NAME);
+    if (!FileExists(strCoreDLL))
+        strCoreDLL = PathJoin(strLaunchPath, "mta", MTA_DLL_NAME);
 
-    // Check for core.dll
-    const SString strCoreDLL = PathJoin(strLaunchPath, "mta", MTA_DLL_NAME);
     if (!FileExists(strCoreDLL))
     {
         if (!bShowErrors)
@@ -474,7 +482,6 @@ void InitLocalization(bool bShowErrors)
     }
 
     // Setup DLL search paths
-    const SString strMTASAPath = GetMTASAPath();
     SetDllDirectory(PathJoin(strMTASAPath, "mta"));
 
     // See if xinput is loadable (XInput9_1_0.dll or xinput1_3.dll)
@@ -817,7 +824,9 @@ void ConfigureWerDumpPath()
 {
     using WerRegisterAppLocalDumpFn = HRESULT(WINAPI*)(PCWSTR);
 
-    const SString strInstallPath = GetInstallPathForLauncher();
+    SString strInstallPath = GetInstallPathForLauncher();
+    if (strInstallPath.empty())
+        strInstallPath = GetMTASAPath();
     if (strInstallPath.empty())
         return;
 
diff --git a/Client/loader/Utils.cpp b/Client/loader/Utils.cpp
@@ -466,27 +466,6 @@ namespace
         return PathJoin(GetProductRegistryPath(), GetMajorVersionString(), strPath).TrimEnd("\\");
     }
 
-    bool IsTemporaryUpdateLaunchPath(const SString& strLaunchPath)
-    {
-        if (strLaunchPath.empty())
-            return false;
-
-        if (!strLaunchPath.ContainsI("\\upcache\\"))
-            return false;
-
-        return ExtractFilename(strLaunchPath).ContainsI("_tmp_");
-    }
-
-    bool IsUsableMtasaInstallRoot(const SString& strPath)
-    {
-        if (strPath.empty())
-            return false;
-
-        return FileExists(PathJoin(strPath, "Multi Theft Auto.exe")) || FileExists(PathJoin(strPath, "Multi Theft Auto_d.exe")) ||
-               FileExists(PathJoin(strPath, "mta", "core.dll")) || FileExists(PathJoin(strPath, "MTA", "core.dll")) ||
-               FileExists(PathJoin(strPath, "mta", "core_d.dll")) || FileExists(PathJoin(strPath, "MTA", "core_d.dll"));
-    }
-
     bool HasDistinct64BitRegistryView()
     {
 #if defined(_WIN64)
@@ -580,6 +559,62 @@ namespace
                        static_cast<DWORD>((wstrValue.length() + 1) * sizeof(wchar_t)));
         RegCloseKey(hKey);
     }
+
+    // Read Last Run Location from a specific registry view. viewFlag should be one of
+    // KEY_WOW64_64KEY, KEY_WOW64_32KEY, or 0 (no view override). Returns empty string on any failure.
+    // Oversized values are rejected without allocation so a malformed registry entry on the U01
+    // recovery path cannot turn into a large allocation; the same 1 MB cap is used by the generic
+    // ReadRegistryStringValue helper in SharedUtil.Misc.hpp.
+    SString ReadInstallRootRegistryView(REGSAM viewFlag)
+    {
+        constexpr DWORD kMaxRegistryValueBytes = 1024u * 1024u;
+
+        const WString wstrSubKey = FromUTF8(MakeCurrentVersionRegistryPath(""));
+        const WString wstrValueName = FromUTF8("Last Run Location");
+
+        HKEY hKey = nullptr;
+        if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, wstrSubKey.c_str(), 0, KEY_READ | viewFlag, &hKey) != ERROR_SUCCESS || !hKey)
+            return "";
+
+        DWORD valueType = REG_SZ;
+        DWORD valueSize = 0;
+        LONG  result = RegQueryValueExW(hKey, wstrValueName.c_str(), nullptr, &valueType, nullptr, &valueSize);
+        if (result != ERROR_SUCCESS || (valueType != REG_SZ && valueType != REG_EXPAND_SZ) || valueSize == 0 || valueSize > kMaxRegistryValueBytes)
+        {
+            RegCloseKey(hKey);
+            return "";
+        }
+
+        std::vector<wchar_t> buffer((valueSize / sizeof(wchar_t)) + 1u, L'\0');
+        result = RegQueryValueExW(hKey, wstrValueName.c_str(), nullptr, &valueType, reinterpret_cast<LPBYTE>(buffer.data()), &valueSize);
+        RegCloseKey(hKey);
+
+        if (result != ERROR_SUCCESS || (valueType != REG_SZ && valueType != REG_EXPAND_SZ) || valueSize > kMaxRegistryValueBytes)
+            return "";
+
+        if (valueSize >= sizeof(wchar_t))
+            buffer[(valueSize / sizeof(wchar_t)) - 1u] = L'\0';
+        else
+            buffer[0] = L'\0';
+
+        // Expand environment variable references for REG_EXPAND_SZ values so callers see a real
+        // filesystem path. Without this, a value like "%ProgramFiles%\..." would fail validation.
+        // The expansion is bounded by the same 1 MB cap so a value containing a self-referential or
+        // explosive expansion cannot trigger a large allocation here.
+        if (valueType == REG_EXPAND_SZ)
+        {
+            constexpr DWORD kMaxExpandChars = kMaxRegistryValueBytes / sizeof(wchar_t);
+            const DWORD     expandedChars = ExpandEnvironmentStringsW(buffer.data(), nullptr, 0);
+            if (expandedChars > 0 && expandedChars <= kMaxExpandChars)
+            {
+                std::vector<wchar_t> expanded(expandedChars, L'\0');
+                if (ExpandEnvironmentStringsW(buffer.data(), expanded.data(), expandedChars))
+                    return ToUTF8(expanded.data());
+            }
+        }
+
+        return ToUTF8(buffer.data());
+    }
 }
 
 SString GetInstallPathForLauncher()
@@ -588,15 +623,63 @@ SString GetInstallPathForLauncher()
     if (!IsTemporaryUpdateLaunchPath(strLaunchPath))
         return strLaunchPath;
 
-    const SString strSavedInstallPath = GetRegistryValue("", "Last Run Location");
-    if (IsUsableMtasaInstallRoot(strSavedInstallPath) && !IsTemporaryUpdateLaunchPath(strSavedInstallPath))
-        return strSavedInstallPath;
+    // Prefer the resolved base dir over the registry when one was already established. In the
+    // far-update Process C, CInstallManager applies SetMTASABaseDirOverride from the sequencer
+    // carried INSTALL_ROOT and runs ::SetMTASAPathSource(true) before any consumer reaches here,
+    // so g_strMTASAPath holds the validated real install root that Process B was updating. A stale
+    // or differently-installed registry "Last Run Location" must not win over that carried root and
+    // aim consumers at a different MTA install. Read g_strMTASAPath directly rather than calling
+    // GetMTASAPath(), because GetMTASAPath() lazy-inits via SetMTASAPathSource(false), which calls
+    // back into GetInstallPathForLauncher() and would recurse for any temp launcher whose g_strMTASAPath
+    // has not yet been populated by the far-update sequencer path. Empty string falls through to the
+    // per-view registry loop below, preserving the temp-launcher-without-far-update fallback.
+    if (!g_strMTASAPath.empty() && IsUsableMtasaInstallRoot(g_strMTASAPath) && !IsTemporaryUpdateLaunchPath(g_strMTASAPath) &&
+        !g_strMTASAPath.CompareI(strLaunchPath))
+        return g_strMTASAPath;
+
+    // Read each registry view independently so a stale value in one view cannot shadow a usable value in another.
+    REGSAM viewFlags[3] = {0, 0, 0};
+    int    viewCount = 0;
+#if defined(KEY_WOW64_64KEY)
+    viewFlags[viewCount++] = KEY_WOW64_64KEY;
+#endif
+#if defined(KEY_WOW64_32KEY)
+    viewFlags[viewCount++] = KEY_WOW64_32KEY;
+#endif
+    viewFlags[viewCount++] = 0;
+
+    for (int i = 0; i < viewCount; ++i)
+    {
+        const SString strSavedInstallPath = ReadInstallRootRegistryView(viewFlags[i]);
+        if (IsUsableMtasaInstallRoot(strSavedInstallPath) && !IsTemporaryUpdateLaunchPath(strSavedInstallPath))
+            return strSavedInstallPath;
+    }
 
-    const SString strSavedInstallPath64 = GetRegistryValue64("", "Last Run Location");
-    if (IsUsableMtasaInstallRoot(strSavedInstallPath64) && !IsTemporaryUpdateLaunchPath(strSavedInstallPath64))
-        return strSavedInstallPath64;
+    // No usable non-temp install root resolved. Returning empty forces callers to use their own fallbacks
+    // (such as a base-dir override carried forward from the parent launcher) instead of treating a temp
+    // update directory as the real install location.
+    return SString();
+}
 
-    return strLaunchPath;
+bool IsUsableMtasaInstallRoot(const SString& strPath)
+{
+    if (strPath.empty())
+        return false;
+
+    return FileExists(PathJoin(strPath, "Multi Theft Auto.exe")) || FileExists(PathJoin(strPath, "Multi Theft Auto_d.exe")) ||
+           FileExists(PathJoin(strPath, "mta", "core.dll")) || FileExists(PathJoin(strPath, "MTA", "core.dll")) ||
+           FileExists(PathJoin(strPath, "mta", "core_d.dll")) || FileExists(PathJoin(strPath, "MTA", "core_d.dll"));
+}
+
+bool IsTemporaryUpdateLaunchPath(const SString& strLaunchPath)
+{
+    if (strLaunchPath.empty())
+        return false;
+
+    if (!strLaunchPath.ContainsI("\\upcache\\"))
+        return false;
+
+    return ExtractFilename(strLaunchPath).ContainsI("_tmp_");
 }
 
 void SetMTASAPathSource(bool bReadFromRegistry)
@@ -612,6 +695,14 @@ void SetMTASAPathSource(bool bReadFromRegistry)
         SString strLaunchPath = GetLaunchPath();
         SString strInstallPath = GetInstallPathForLauncher();
 
+        // GetInstallPathForLauncher returns empty when running from a temp update directory and no
+        // usable non-temp install root could be resolved. In that case the safest local fallback is
+        // the launch path itself, which preserves the prior behavior for non-update launches without
+        // contaminating the registry from the auto-update flow (Process C now goes through the far
+        // branch with a base-dir override carried forward by CInstallManager).
+        if (strInstallPath.empty())
+            strInstallPath = strLaunchPath;
+
         if (!strInstallPath.CompareI(strLaunchPath))
         {
             AddReportLog(1063, SString("SetMTASAPathSource: preserving install path '%s' for temp launcher '%s'", strInstallPath.c_str(),
@@ -620,6 +711,17 @@ void SetMTASAPathSource(bool bReadFromRegistry)
             return;
         }
 
+        // Refuse to write a temp update extraction directory into the install-location registry
+        // values. A temp launcher started without the far-update sequencer state would otherwise
+        // contaminate Last Run Location with an upcache\_*_tmp_* path that gets deleted later by
+        // CleanDownloadCache, leaving a stale registry pointer that produces U01 on the next launch.
+        if (IsTemporaryUpdateLaunchPath(strLaunchPath))
+        {
+            AddReportLog(1063, SString("SetMTASAPathSource: refusing to record temp launch path '%s' in registry", strLaunchPath.c_str()));
+            g_strMTASAPath = strLaunchPath;
+            return;
+        }
+
         SString strHash = "-";
         {
             MD5        md5;
@@ -1292,6 +1394,20 @@ void UpdateMTAVersionApplicationSetting(bool bQuiet)
         bFreeModule = hModule != NULL;
     }
 
+    // GetInstallPathForLauncher returns empty when running from a temp update directory and no
+    // usable non-temp install root could be resolved. GetMTASAPath consults SetMTASABaseDirOverride
+    // (which the install manager populates from the sequencer-carried INSTALL_ROOT in the far branch),
+    // so this attempt covers the recovered far-update case before falling back to the launch dir.
+    if (!hModule)
+    {
+        const SString strBaseDirPath = GetMTASAPath();
+        if (IsUsableMtasaInstallRoot(strBaseDirPath) && !strBaseDirPath.CompareI(strInstallPath))
+        {
+            hModule = LoadVersionModule(strBaseDirPath, dwLastError);
+            bFreeModule = hModule != NULL;
+        }
+    }
+
     if (!hModule)
     {
         hModule = LoadVersionModule(GetLaunchPath(), dwLastError);
diff --git a/Client/loader/Utils.h b/Client/loader/Utils.h
@@ -79,6 +79,8 @@ auto    GetGameBaseDirectory() -> std::filesystem::path;
 auto    GetGameLaunchDirectory() -> std::filesystem::path;
 auto    GetGameExecutablePath() -> std::filesystem::path;
 SString GetInstallPathForLauncher();
+bool    IsUsableMtasaInstallRoot(const SString& strPath);
+bool    IsTemporaryUpdateLaunchPath(const SString& strLaunchPath);
 
 void            SetMTASAPathSource(bool bReadFromRegistry);
 SString         GetMTASAPath();
diff --git a/Shared/sdk/SharedUtil.Misc.hpp b/Shared/sdk/SharedUtil.Misc.hpp
