Read vcredist installers from Steam install scripts, track them by HasRunKey, install 2022 with winetricks-style overrides

app/src/main/java/app/gamenative/utils/PreInstallSteps.kt

@@ -4,6 +4,7 @@ import app.gamenative.data.GameSource
 import app.gamenative.enums.Marker
 import com.winlator.container.Container
 import java.io.File
+import timber.log.Timber
 
 /**
  * Determines whether pre-install steps (VC Redist, GOG script interpreter) need to run
@@ -97,6 +98,10 @@ object PreInstallSteps {
         val gameDir = getGameDir(container) ?: return
         val gameDirPath = gameDir.absolutePath
         MarkerUtils.addMarker(gameDirPath, marker)
+        currentSteps().filter { it.marker == marker }.forEach { step ->
+            runCatching { step.onCompleted(container, gameDir) }
+                .onFailure { Timber.w(it, "onCompleted failed for ${marker.name}") }
+        }
         touchPrefixStamp(container)
     }
 

app/src/main/java/app/gamenative/utils/SteamInstallScriptRegistry.kt

@@ -35,7 +35,7 @@ object SteamInstallScriptRegistry {
     private const val USER_PROFILE = "C:\\users\\${ImageFs.USER}"
     private val TOKEN_PATTERN = Regex("(?i)%([A-Z_]+)%([\\\\/]?)")
 
-    private fun tokens(installDir: String): Map<String, String> = mapOf(
+    internal fun tokens(installDir: String): Map<String, String> = mapOf(
         "INSTALLDIR" to installDir,
         "ROOTDRIVE" to installDir.substringBefore(':'),
         "WINDIR" to "C:\\windows",
@@ -148,7 +148,7 @@ object SteamInstallScriptRegistry {
         }
     }
 
-    private fun splitHive(path: String): Pair<Hive, String>? {
+    internal fun splitHive(path: String): Pair<Hive, String>? {
         val separator = path.indexOf('\\')
         val hiveName = if (separator < 0) path else path.substring(0, separator)
         val rest = if (separator < 0) "" else path.substring(separator + 1).trim('\\')
@@ -161,14 +161,14 @@ object SteamInstallScriptRegistry {
         return hive to rest
     }
 
-    private fun redirectTo32BitView(path: String): String {
+    internal fun redirectTo32BitView(path: String): String {
         val segments = path.split('\\')
         if (segments.size < 2 || !segments[0].equals("Software", ignoreCase = true)) return path
         if (segments[1].equals("Wow6432Node", ignoreCase = true)) return path
         return (listOf(segments[0], "Wow6432Node") + segments.drop(1)).joinToString("\\")
     }
 
-    private fun expandTokens(value: String, tokens: Map<String, String>): String =
+    internal fun expandTokens(value: String, tokens: Map<String, String>): String =
         TOKEN_PATTERN.replace(value) { match ->
             val replacement = tokens[match.groupValues[1].uppercase()] ?: return@replace match.value
             val separator = match.groupValues[2]

app/src/main/java/app/gamenative/utils/SteamInstallScriptRunProcess.kt

@@ -0,0 +1,103 @@
+package app.gamenative.utils
+
+import com.winlator.core.WineRegistryEditor
+import `in`.dragonbra.javasteam.types.KeyValue
+import timber.log.Timber
+import java.io.File
+
+object SteamInstallScriptRunProcess {
+    data class Entry(
+        val winPath: String,
+        val args: String,
+        val hostFile: File,
+        val hasRunKey: String = syntheticHasRunKey(winPath),
+    ) {
+        val exeName: String get() = winPath.substringAfterLast('\\')
+        val commandLine: String
+            get() {
+                val exe = if (winPath.contains(' ')) "\"$winPath\"" else winPath
+                return if (args.isBlank()) exe else "$exe ${args.trim()}"
+            }
+    }
+
+    private const val GAME_DRIVE_ROOT = "A:\\"
+    private const val SCRIPT_NAME = "installscript.vdf"
+    private const val SYNTHETIC_KEY_ROOT = "Software\\Wow6432Node\\Valve\\Steam\\Apps\\CommonRedist\\GameNative"
+    private val PROCESS_KEY = Regex("(?i)^process\\s*(\\d+)$")
+
+    fun syntheticHasRunKey(winPath: String): String =
+        SYNTHETIC_KEY_ROOT + "\\" + winPath.substringAfter(':').trim('\\')
+
+    fun hasRun(prefixDir: File, entry: Entry): Boolean {
+        val systemReg = File(prefixDir, "system.reg")
+        if (!systemReg.isFile) return false
+        return WineRegistryEditor(systemReg).use { it.hasKey(entry.hasRunKey) }
+    }
+
+    fun markRun(prefixDir: File, entries: List<Entry>) {
+        if (entries.isEmpty()) return
+        val systemReg = File(prefixDir, "system.reg")
+        if (!systemReg.isFile) {
+            prefixDir.mkdirs()
+            systemReg.writeText("WINE REGISTRY Version 2\n\n")
+        }
+        WineRegistryEditor(systemReg).use { editor ->
+            editor.setCreateKeyIfNotExist(true)
+            for (entry in entries) editor.setDwordValue(entry.hasRunKey, "Installed", 1)
+        }
+    }
+
+    fun entries(gameDir: File, installDir: String = GAME_DRIVE_ROOT): List<Entry> =
+        scripts(gameDir).flatMap { script ->
+            runCatching { parse(script.readText(), gameDir, installDir) }
+                .onFailure { Timber.w(it, "Failed to read ${script.absolutePath}") }
+                .getOrDefault(emptyList())
+        }.distinctBy { it.winPath.lowercase() }
+
+    internal fun parse(vdf: String, gameDir: File, installDir: String = GAME_DRIVE_ROOT): List<Entry> {
+        val root = runCatching { KeyValue.loadFromString(vdf) }.getOrNull() ?: return emptyList()
+        val runProcess = root["InstallScript"]["Run Process"].takeUnless { it === KeyValue.INVALID }
+            ?: root["Run Process"].takeUnless { it === KeyValue.INVALID }
+            ?: return emptyList()
+        val tokens = SteamInstallScriptRegistry.tokens(installDir)
+        val entries = mutableListOf<Entry>()
+        for (block in runProcess.children) {
+            for (child in block.children) {
+                val index = PROCESS_KEY.find(child.name.orEmpty())?.groupValues?.get(1) ?: continue
+                val winPath = SteamInstallScriptRegistry.expandTokens(child.value.orEmpty().trim(), tokens)
+                if (!winPath.startsWith(installDir, ignoreCase = true)) {
+                    Timber.d("Skipping run-process entry outside the install dir: $winPath")
+                    continue
+                }
+                val relative = winPath.substring(installDir.length).replace('\\', '/')
+                val hostFile = resolveCaseInsensitive(gameDir, relative) ?: continue
+                val args = SteamInstallScriptRegistry.expandTokens(block["command $index"].value.orEmpty(), tokens)
+                val hasRunKey = block["HasRunKey"].value?.let { scriptHasRunKey(it) } ?: syntheticHasRunKey(winPath)
+                entries += Entry(winPath, args, hostFile, hasRunKey)
+            }
+        }
+        return entries
+    }
+
+    private fun scriptHasRunKey(raw: String): String? {
+        val (hive, path) = SteamInstallScriptRegistry.splitHive(raw.trim()) ?: return null
+        if (hive != SteamInstallScriptRegistry.Hive.HKLM) return null
+        return SteamInstallScriptRegistry.redirectTo32BitView(path)
+    }
+
+    private fun scripts(gameDir: File): List<File> {
+        val root = gameDir.listFiles()?.filter { it.isFile && it.name.equals(SCRIPT_NAME, ignoreCase = true) }.orEmpty()
+        val redist = gameDir.listFiles()?.firstOrNull { it.isDirectory && it.name.equals("_CommonRedist", ignoreCase = true) }
+            ?.walkTopDown()?.filter { it.isFile && it.name.equals(SCRIPT_NAME, ignoreCase = true) }?.toList().orEmpty()
+        return root + redist.sortedBy { it.path }
+    }
+
+    private fun resolveCaseInsensitive(root: File, relativePath: String): File? {
+        var current = root
+        for (segment in relativePath.split('/').filter { it.isNotEmpty() }) {
+            if (segment == "." || segment == "..") return null
+            current = current.listFiles()?.firstOrNull { it.name.equals(segment, ignoreCase = true) } ?: return null
+        }
+        return current.takeIf { it.isFile }
+    }
+}

app/src/main/java/app/gamenative/utils/preInstallSteps/PreInstallStep.kt

@@ -21,4 +21,6 @@ interface PreInstallStep {
         gameDir: File,
         gameDirPath: String,
     ): String?
+
+    fun onCompleted(container: Container, gameDir: File) {}
 }

app/src/main/java/app/gamenative/utils/preInstallSteps/VcRedistStep.kt

@@ -3,6 +3,8 @@ package app.gamenative.utils
 import app.gamenative.enums.Marker
 import app.gamenative.data.GameSource
 import com.winlator.container.Container
+import com.winlator.core.WineRegistryEditor
+import timber.log.Timber
 import java.io.File
 
 /** Windows path -> installer args, checked against host filesystem to see which exist. */
@@ -45,16 +47,28 @@ private val vcRedistMap: Map<String, String> = mapOf(
     "A:\\_CommonRedist\\VC_redist.x64.exe" to "/install /passive /norestart",
 )
 
+private const val DLL_OVERRIDES_KEY = "Software\\Wine\\DllOverrides"
+private val v140NativeDlls = listOf(
+    "concrt140",
+    "msvcp140",
+    "msvcp140_1",
+    "msvcp140_2",
+    "msvcp140_atomic_wait",
+    "msvcp140_codecvt_ids",
+    "vccorlib140",
+    "vcomp140",
+    "vcruntime140",
+    "vcruntime140_1",
+)
+
 object VcRedistStep : PreInstallStep {
     override val marker: Marker = Marker.VCREDIST_INSTALLED
 
     override fun appliesTo(
         container: Container,
         gameSource: GameSource,
         gameDirPath: String,
-    ): Boolean {
-        return !MarkerUtils.hasMarker(gameDirPath, Marker.VCREDIST_INSTALLED)
-    }
+    ): Boolean = true
 
     override fun buildCommand(
         container: Container,
@@ -63,28 +77,72 @@ object VcRedistStep : PreInstallStep {
         gameDir: File,
         gameDirPath: String,
     ): String? {
-        val parts = mutableListOf<String>()
+        val pending = pendingEntries(container, gameDir)
+        if (pending.isEmpty()) return null
+        if (pending.any { isV140Installer(it.exeName) }) writeV140Overrides(container)
+        return pending.joinToString(" & ") { it.commandLine }
+    }
+
+    override fun onCompleted(container: Container, gameDir: File) {
+        val prefixDir = prefixDir(container) ?: return
+        SteamInstallScriptRunProcess.markRun(prefixDir, pendingEntries(container, gameDir))
+    }
+
+    private fun prefixDir(container: Container): File? =
+        container.rootDir?.path?.takeIf { it.isNotEmpty() }?.let { File(it, ".wine") }
+
+    private fun pendingEntries(container: Container, gameDir: File): List<SteamInstallScriptRunProcess.Entry> {
+        val prefixDir = prefixDir(container) ?: return candidates(gameDir)
+        return candidates(gameDir).filter { !SteamInstallScriptRunProcess.hasRun(prefixDir, it) }
+    }
+
+    private fun candidates(gameDir: File): List<SteamInstallScriptRunProcess.Entry> {
+        val scripted = SteamInstallScriptRunProcess.entries(gameDir).filter { isVcRedistExe(it.exeName) }
+        if (scripted.isNotEmpty()) return scripted
+
+        val fallback = mutableListOf<SteamInstallScriptRunProcess.Entry>()
         for ((winPath, args) in vcRedistMap) {
             if (winPath.length < 4 || winPath[1] != ':' || winPath[2] != '\\') continue
             val rest = winPath.substring(3)
-            val lastSep = rest.lastIndexOf('\\')
-            if (lastSep < 0) continue
+            if (rest.lastIndexOf('\\') < 0) continue
             val hostFile = File(gameDir, rest.replace('\\', '/'))
             if (!hostFile.isFile) continue
-            parts.add(if (args.isEmpty()) winPath else "$winPath $args")
+            fallback += SteamInstallScriptRunProcess.Entry(winPath, args, hostFile)
         }
         val covered = vcRedistMap.keys.map { it.lowercase() }.toSet()
         File(gameDir, "_CommonRedist/vcredist").listFiles()?.sortedBy { it.name }?.forEach { yearDir ->
-            if (!yearDir.isDirectory || (yearDir.name.toIntOrNull() ?: 0) >= 2022) return@forEach
+            if (!yearDir.isDirectory) return@forEach
             yearDir.listFiles()?.sortedBy { it.name }?.forEach { exe ->
-                val name = exe.name.lowercase()
-                if (!exe.isFile || !name.endsWith(".exe") || !(name.startsWith("vc_redist") || name.startsWith("vcredist"))) return@forEach
+                if (!exe.isFile || !isVcRedistExe(exe.name)) return@forEach
                 val winPath = "A:\\_CommonRedist\\vcredist\\${yearDir.name}\\${exe.name}"
                 if (winPath.lowercase() in covered) return@forEach
-                parts.add("$winPath /install /passive /norestart")
+                fallback += SteamInstallScriptRunProcess.Entry(winPath, "/install /passive /norestart", exe)
             }
         }
-        return if (parts.isEmpty()) null else parts.joinToString(" & ")
+        return fallback
+    }
+
+    private fun isVcRedistExe(name: String): Boolean {
+        val lower = name.lowercase()
+        return lower.endsWith(".exe") && (lower.startsWith("vc_redist") || lower.startsWith("vcredist"))
+    }
+
+    private fun isV140Installer(exeName: String): Boolean = exeName.startsWith("vc_redist", ignoreCase = true)
+
+    private fun writeV140Overrides(container: Container) {
+        val prefixDir = prefixDir(container) ?: return
+        val userReg = File(prefixDir, "user.reg")
+        runCatching {
+            if (!userReg.isFile) {
+                prefixDir.mkdirs()
+                userReg.writeText("WINE REGISTRY Version 2\n\n")
+            }
+            WineRegistryEditor(userReg).use { editor ->
+                editor.setCreateKeyIfNotExist(true)
+                editor.setStringValue(DLL_OVERRIDES_KEY, "ucrtbase", "builtin")
+                for (dll in v140NativeDlls) editor.setStringValue(DLL_OVERRIDES_KEY, dll, "native,builtin")
+            }
+        }.onFailure { Timber.w(it, "Failed to write v140 DLL overrides to ${userReg.absolutePath}") }
     }
 }
 

app/src/main/java/com/winlator/core/WineRegistryEditor.java

@@ -161,6 +161,11 @@ private Location createKey(String key) {
         }
     }
 
+    public boolean hasKey(String key) {
+        resetLastParentKeyPositionIfNeed(key);
+        return getKeyLocation(key) != null;
+    }
+
     public String getStringValue(String key, String name) {
         return getStringValue(key, name, null);
     }

app/src/test/java/app/gamenative/utils/PreInstallStepsTest.kt

@@ -42,6 +42,7 @@ class PreInstallStepsTest {
         gameDir = createTempDirectory(prefix = "preinstall-steps-test").toFile()
         every { container.drives } returns "A:${gameDir.absolutePath}"
         every { container.containerVariant } returns Container.BIONIC
+        every { container.rootDir } returns File(gameDir, "container")
     }
 
     @After