diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 3c0dac30d4..8164df8bb1 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -173,7 +173,7 @@ jobs: uses: actions/cache@v4 with: path: app/src/main/assets/linuxfs - key: preloads-${{ env.PRELOAD_CACHE_VERSION }}-${{ hashFiles('app/src/main/cpp/fakeinput_steam.cpp', 'tools/linuxfs/preload/*.c', 'tools/linuxfs/build-x86-preloads.sh', 'tools/linuxfs/fex/*', 'tools/linuxfs/clipboard/*.c', 'tools/linuxfs/ssbs/*.c', 'tools/proot/fastpath/*.c', 'tools/linuxfs/overlay/usr/local/bin/*', 'tools/linuxfs/overlay/usr/bin/**', 'tools/linuxfs/desktop/*', 'tools/gamescope/release.env', 'tools/wlroots/release.env', 'tools/linuxfs/uruntime.env', 'tools/linuxfs/licenses/*', 'tools/mangoapp/*') }} + key: preloads-${{ env.PRELOAD_CACHE_VERSION }}-${{ hashFiles('app/src/main/cpp/fakeinput_steam.cpp', 'tools/linuxfs/preload/*.c', 'tools/linuxfs/build-x86-preloads.sh', 'tools/linuxfs/fex/*', 'tools/linuxfs/clipboard/*.c', 'tools/linuxfs/ssbs/*.c', 'tools/proot/fastpath/*.c', 'tools/linuxfs/overlay/usr/local/bin/*', 'tools/linuxfs/overlay/usr/bin/**', 'tools/linuxfs/desktop/*', 'tools/gamescope/release.env', 'tools/wlroots/release.env', 'tools/linuxfs/uruntime.env', 'tools/linuxfs/licenses/*', 'tools/mangoapp/*', 'tools/msitools/**') }} - name: Build libfakeinput.so and libblsession.so (glibc aarch64) if: steps.preloads.outputs.cache-hit != 'true' @@ -250,6 +250,26 @@ jobs: install -Dm644 tools/mangoapp/mangoapp "$D/usr/local/bin/mangoapp" rm -rf mango-pkgs ls -l "$M" + # The Windows components installer's tools (tools/msitools/packages.txt). + T="$D/usr/local/lib/droiddeck-msitools" + mkdir -p "$T" msi-pkgs + grep -v '^#' tools/msitools/packages.txt | while read -r sum url; do + [ -n "$url" ] || continue + curl -fsSL --retry 3 -o msi-pkgs/pkg.tar.xz "$url" + echo "$sum msi-pkgs/pkg.tar.xz" | sha256sum -c - + tar -xJf msi-pkgs/pkg.tar.xz -C msi-pkgs + rm msi-pkgs/pkg.tar.xz + done + install -m644 msi-pkgs/usr/bin/msiinfo "$T/msiinfo" + install -m644 msi-pkgs/usr/bin/cabextract "$T/cabextract" + for so in libmsi-1.0.so.0 libgsf-1.so.114 libgcab-1.0.so.0; do + cp -L "msi-pkgs/usr/lib/$so" "$T/$so" + done + for f in NOTICE GPL-2 GPL-3 LGPL-2.1; do + install -Dm644 "tools/msitools/licenses/$f" "$D/usr/local/share/licenses/droiddeck-msitools/$f" + done + rm -rf msi-pkgs + ls -l "$T" install -Dm644 tools/linuxfs/desktop/droiddeck-desktop "$D/usr/local/bin/droiddeck-desktop" install -Dm644 tools/linuxfs/desktop/droiddeck-gpu "$D/usr/local/bin/droiddeck-gpu" install -Dm644 tools/linuxfs/desktop/droiddeck-desktop-gpu "$D/usr/local/bin/droiddeck-desktop-gpu" @@ -376,6 +396,10 @@ jobs: done test -f "$D/usr/local/bin/droiddeck-session" test -f "$D/usr/local/bin/droiddeck-proton-extra" + test -f "$D/usr/local/bin/droiddeck-msi-install" + for f in msiinfo cabextract libmsi-1.0.so.0 libgsf-1.so.114 libgcab-1.0.so.0; do + test -f "$D/usr/local/lib/droiddeck-msitools/$f" || { echo "::error::droiddeck-msitools/$f missing"; exit 1; } + done - name: Cache the CMake build tree uses: actions/cache@v4 diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt index 3414627450..530631c792 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt @@ -32,6 +32,7 @@ object SessionFiles { val files = arrayOf( "usr/local/bin/droiddeck-game-env" to "usr/local/bin/droiddeck-game-env", "usr/local/bin/droiddeck-wincomponents" to "usr/local/bin/droiddeck-wincomponents", + "usr/local/bin/droiddeck-msi-install" to "usr/local/bin/droiddeck-msi-install", "usr/local/bin/droiddeck-esync" to "usr/local/bin/droiddeck-esync", "usr/local/bin/droiddeck-steam-compat" to "usr/local/bin/droiddeck-steam-compat", "usr/local/bin/droiddeck-fex" to "usr/local/bin/droiddeck-fex", @@ -106,6 +107,10 @@ object SessionFiles { "usr/local/lib/mangoapp/libtraceevent.so.1", "usr/local/lib/mangoapp/libtracefs.so.1", ).map { it to it } + // What the Windows components installer reads .msi packages with (tools/msitools). + val msitools = listOf("msiinfo", "cabextract", "libmsi-1.0.so.0", "libgsf-1.so.114", "libgcab-1.0.so.0") + .map { "usr/local/lib/droiddeck-msitools/$it" } + + listOf("NOTICE", "GPL-2", "GPL-3", "LGPL-2.1").map { "usr/local/share/licenses/droiddeck-msitools/$it" } // The patched wlroots (tools/wlroots) the desktop loads for its vulkan / gles2 renderers. val wlroots = if (File(root, "usr/bin/labwc").isFile) { arrayOf("usr/local/lib/droiddeck-wlroots/libwlroots-0.20.so" to "usr/local/lib/droiddeck-wlroots/libwlroots-0.20.so") @@ -117,7 +122,7 @@ object SessionFiles { "usr/local/bin/gamescope" to "usr/local/bin/gamescope", "usr/local/lib/droiddeck/uruntime" to "usr/local/lib/droiddeck/uruntime", "usr/local/share/licenses/uruntime/LICENSE" to "usr/local/share/licenses/uruntime/LICENSE", - ) + wlroots + mangoapp + fexPreloads).filter { (asset, _) -> + ) + wlroots + mangoapp + msitools.map { it to it } + fexPreloads).filter { (asset, _) -> val dir = asset.substringBeforeLast('/') runCatching { context.assets.list("linuxfs/$dir")?.contains(asset.substringAfterLast('/')) == true }.getOrDefault(false) } diff --git a/app/src/main/java/com/droiddeck/launcher/session/WinComponents.kt b/app/src/main/java/com/droiddeck/launcher/session/WinComponents.kt index 21618d28e2..d344127535 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/WinComponents.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/WinComponents.kt @@ -6,6 +6,7 @@ import android.util.Log import com.droiddeck.launcher.core.ArchivePaths import com.droiddeck.launcher.core.Downloader import com.droiddeck.launcher.core.FileUtils +import com.droiddeck.launcher.runtime.GuestCommand import com.droiddeck.launcher.runtime.LinuxRuntime import org.apache.commons.compress.archivers.tar.TarArchiveInputStream import org.apache.commons.compress.compressors.xz.XZCompressorInputStream @@ -28,9 +29,12 @@ import java.util.zip.ZipInputStream * ~/.config/droiddeck/wincomponents.json, and droiddeck-wincomponents copies the picked components * into the game's prefix at every launch (see that script for why every launch). * - * Only components made of file copies and overrides install this way. One that runs a Windows - * installer (install_exe/install_msi), unpacks a cabinet or edits the prefix's registry is listed - * with the reason it cannot be installed yet. + * A component whose installer is a Windows Installer package (.msi: XNA, PhysX, Games for Windows + * Live, MSXML...) installs here too, without running it: droiddeck-msi-install reads the package's + * tables in the runtime and lays out its files (Program Files, the .NET GAC, winsxs) and registry + * values the way Wine's msiexec would, under the same store folder. One that runs any other + * installer (.exe), unpacks a cabinet or edits the prefix's registry by itself is listed with the + * reason it cannot be installed yet. */ object WinComponents { private const val TAG = "WinComponents" @@ -43,6 +47,11 @@ object WinComponents { // at the same path, so the native file at that path is the one the registration loads. private val FILE_STEPS = setOf("download_archive", "archive_extract", "copy_dll", "copy_file", "override_dll", "register_dll") private val INSTALLER_STEPS = setOf("install_exe", "install_msi") + private const val MSI_INSTALL = "/usr/local/bin/droiddeck-msi-install" + /** Where a downloaded .msi waits for the installer, inside the runtime so it can read it. */ + private const val MSI_CACHE = "$STORE/.packages" + /** Catalog entries Proton already provides newer copies of, which an install would only shadow. */ + private val PROTON_PROVIDES = setOf("gecko") fun validId(id: String): Boolean = ID.matches(id) && ".." !in id @@ -57,6 +66,11 @@ object WinComponents { enum class Support { READY, NEEDS_INSTALLER, UNSUPPORTED } + /** A step that installs a Windows Installer package, which droiddeck-msi-install does here. */ + private fun isMsi(step: Step): Boolean = step.action in INSTALLER_STEPS && step.str("url").startsWith("https://") && + (step.action == "install_msi" || listOf(step.str("file_name"), step.str("url").substringBefore('?')) + .any { it.endsWith(".msi", ignoreCase = true) }) + fun fetch(): List? { val body = Downloader.downloadString(CATALOG_URL) ?: return null return try { @@ -80,9 +94,12 @@ object WinComponents { /** Whether [c] can be installed here, its bundled components included. */ fun support(c: Component, all: Map, depth: Int = 0): Support { - if (c.status != "ready" || depth > 8) return Support.UNSUPPORTED + if (c.status != "ready" || depth > 8 || c.name in PROTON_PROVIDES) return Support.UNSUPPORTED + val installers = c.steps.filter { it.action in INSTALLER_STEPS } val own = when { - c.steps.any { it.action in INSTALLER_STEPS } -> Support.NEEDS_INSTALLER + installers.isNotEmpty() && installers.all { isMsi(it) } && + c.steps.all { it in installers || it.action == "delete_dlls" || it.action in FILE_STEPS && fileStepOk(it) } -> Support.READY + installers.isNotEmpty() -> Support.NEEDS_INSTALLER c.steps.all { it.action in FILE_STEPS && fileStepOk(it) } -> Support.READY else -> Support.UNSUPPORTED } @@ -147,7 +164,20 @@ object WinComponents { val staging = File(root, "$STORE/.${c.name}.new").apply { FileUtils.delete(this); mkdirs() } val overrides = ArrayList() var source: File? = null + var msi: JSONObject? = null for (step in c.steps) when (step.action) { + // A component may have several packages (PowerShell's 32- and 64-bit): each adds to the + // same folder, the first one names the component. + "install_msi", "install_exe" -> { + val (result, problem) = installMsi(context, c, step, staging, onProgress) + if (result == null) return problem + msi = msi?.apply { + val notes = optJSONArray("notes") ?: JSONArray().also { put("notes", it) } + result.optJSONArray("notes")?.let { for (i in 0 until it.length()) notes.put(it.get(i)) } + } ?: result + } + // A catalog step that makes room for the installer's own copy; ours is copied anyway. + "delete_dlls" -> Unit "download_archive", "archive_extract" -> { val url = step.str("url") if (!url.startsWith("http")) continue @@ -196,17 +226,60 @@ object WinComponents { "register_dll" -> Unit else -> return "unsupported step ${step.action}" } - val version = Regex("""\b(\d+\.\d+(\.\d+)*)\b""").find(c.description)?.value ?: "catalog" - FileUtils.writeString(File(staging, "component.json"), JSONObject() + val version = msi?.optString("version")?.takeIf { it.isNotEmpty() } + ?: Regex("""\b(\d+\.\d+(\.\d+)*)\b""").find(c.description)?.value ?: "catalog" + val meta = JSONObject() .put("id", c.name).put("version", version) .put("overrides", JSONArray(overrides.distinct())) - .put("requires", JSONArray(c.dependencies)).toString(1)) + .put("requires", JSONArray(c.dependencies)) + msi?.let { meta.put("kind", "msi").put("product", it.optString("product")).put("notes", it.optJSONArray("notes") ?: JSONArray()) } + FileUtils.writeString(File(staging, "component.json"), meta.toString(1)) val target = File(root, "$STORE/${c.name}") FileUtils.delete(target) if (!staging.renameTo(target)) return "could not place the files" return null } + /** + * Downloads the component's .msi into the runtime and has droiddeck-msi-install lay it out in + * [staging]. Returns the installer's result (product, version, counts, notes), or null and why. + * Everything the installer prints also goes to Download/DroidDeck/tools. + */ + private fun installMsi(context: Context, c: Component, step: Step, staging: File, onProgress: (String, Int) -> Unit): Pair { + val root = LinuxRuntime.rootDir(context) + val url = step.str("url") + val name = url.substringBefore('?').substringAfterLast('/') + val cache = File(root, MSI_CACHE).apply { mkdirs() } + val file = File(cache, "${c.name}.msi") + try { + if (!Downloader.downloadFile(url, file, false) { f -> onProgress("${c.name}: $name", if (f < 0) -1 else Math.round(f * 100f)) }) { + return null to "download failed: $name" + } + step.str("file_checksum").takeIf { it.length == 32 }?.let { md5 -> + if (!digest(file, "MD5").equals(md5, ignoreCase = true)) return null to "checksum mismatch: $name" + } + onProgress("${c.name}: installing", -1) + var result: JSONObject? = null + var problem: String? = null + val status = GuestCommand.run(context, listOf(MSI_INSTALL, "/$MSI_CACHE/${file.name}", "/$STORE/${staging.name}"), + logName = "wincomponents-${c.name}") { line -> + when { + line.startsWith("progress ") -> onProgress("${c.name}: ${line.removePrefix("progress ")}", -1) + line.startsWith("result ") -> result = runCatching { JSONObject(line.removePrefix("result ")) }.getOrNull() + line.startsWith("error ") -> problem = line.removePrefix("error ") + } + } + val done = result + if (status != 0 || done == null) return null to (problem ?: "the installer stopped (status $status)") + return done to "" + } catch (e: Exception) { + Log.e(TAG, "msi ${c.name}", e) + return null to (e.message ?: "the installer failed") + } finally { + file.delete() + } + } + private fun digest(file: File, algorithm: String): String { val md = MessageDigest.getInstance(algorithm) FileInputStream(file).use { input -> diff --git a/app/src/main/java/com/droiddeck/launcher/ui/WinComponentsEditor.kt b/app/src/main/java/com/droiddeck/launcher/ui/WinComponentsEditor.kt index 85c22c2ee1..9538f345e7 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/WinComponentsEditor.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/WinComponentsEditor.kt @@ -26,6 +26,9 @@ import androidx.compose.ui.draw.alpha import androidx.compose.ui.draw.clip import androidx.compose.ui.focus.FocusRequester import androidx.compose.ui.focus.focusRequester +import androidx.compose.ui.focus.onFocusChanged +import androidx.compose.ui.input.InputMode +import androidx.compose.ui.platform.LocalInputModeManager import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.res.stringResource import androidx.compose.ui.text.font.FontWeight @@ -59,6 +62,7 @@ private fun installable(name: String, all: Map) return if (twin != null && WinComponents.support(twin, all) == Support.READY) dll else name } +@OptIn(androidx.compose.ui.ExperimentalComposeUiApi::class) @Composable internal fun WinComponentsDialog( appKey: String, gameName: String, gameDir: File?, byPad: Boolean, @@ -80,13 +84,18 @@ internal fun WinComponentsDialog( var picks by remember { mutableStateOf(WinComponents.picks(context, appKey)) } var progress by remember { mutableStateOf?>(null) } var error by remember { mutableStateOf(null) } + // The component the error is about, so it shows on its own row and not only at the bottom. + var failed by remember { mutableStateOf(null) } var showWaiting by remember { mutableStateOf(false) } - // With a pad: Done holds focus while the list loads, then the first component takes it; LB and RB - // jump between the sections, since the full list runs past sixty switches. + // Done holds focus while the list loads, then the top switch takes it - opened by touch or by + // pad, so the d-pad always has somewhere to start; LB and RB jump between the sections, since + // the full list runs past sixty switches. val recFocus = remember { FocusRequester() } val allFocus = remember { FocusRequester() } val waitFocus = remember { FocusRequester() } val doneFocus = remember { FocusRequester() } + val inputMode = LocalInputModeManager.current + var switchFocused by remember { mutableStateOf(false) } LaunchedEffect(Unit) { val (entries, found) = withContext(Dispatchers.IO) { @@ -110,6 +119,7 @@ internal fun WinComponentsDialog( // then is ignored here. if (progress != null) return error = null + failed = null if (!on) { setPicks(picks - id); return } val all = catalog.orEmpty() val c = all[id] @@ -121,7 +131,7 @@ internal fun WinComponentsDialog( } progress = null installed = withContext(Dispatchers.IO) { WinComponents.installedIds(context).toSet() } - if (problem != null) error = problem else setPicks(picks + id) + if (problem != null) { error = problem; failed = id } else setPicks(picks + id) } } @@ -144,14 +154,21 @@ internal fun WinComponentsDialog( runCatching { sections[section].requestFocus() } } LaunchedEffect(all != null) { - if (!byPad || all == null) return@LaunchedEffect - repeat(2) { withFrameNanos { } } + // The dialog's window starts in touch mode, where a switch cannot hold focus at all. + inputMode.requestInputMode(InputMode.Keyboard) section = 0 - runCatching { sections.first().requestFocus() } + val target = if (all == null) doneFocus else sections.first() + switchFocused = false + // It animates in and the list composes over a few frames: ask until the switch has it. + repeat(60) { + withFrameNanos { } + runCatching { target.requestFocus() } + withFrameNanos { } + if (switchFocused || (target !== recFocus && target !== allFocus)) return@LaunchedEffect + } } AppDialog(shown, close, "winComponents", wide = true, modifier = Modifier.bumpers({ jump(-1) }, { jump(1) })) { - PadFocus(byPad, doneFocus) DialogHeader(gameName, stringResource(R.string.wincomp_title)) Small(stringResource(R.string.wincomp_applies)) if (byPad) Small(stringResource(R.string.wincomp_pad_hint)) @@ -162,6 +179,7 @@ internal fun WinComponentsDialog( val c = all?.get(id) val support = supportOf(id) val status = when { + id == failed && error != null -> stringResource(R.string.wincomp_failed, error.orEmpty()) id in here && id !in picks -> stringResource(R.string.wincomp_already_here) id in installed -> stringResource(R.string.wincomp_downloaded) support == Support.NEEDS_INSTALLER -> stringResource(R.string.wincomp_needs_installer) @@ -173,7 +191,8 @@ internal fun WinComponentsDialog( val usable = support == Support.READY ComponentRow( WinComponentNames.of(id), detail, checked = id in picks, enabled = usable || id in picks, - dim = !usable, modifier = if (usable && focus != null) Modifier.focusRequester(focus) else Modifier, + dim = !usable, modifier = (if (usable && focus != null) Modifier.focusRequester(focus) else Modifier) + .onFocusChanged { if (it.isFocused) switchFocused = true }, ) { on -> toggle(id, on) } } /** The section's requester goes to its first switch that can take focus. */ diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index d55ed8f500..9132f72616 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -326,6 +326,7 @@ Needs a Windows installer (coming) Not supported here yet Loading the components… + Could not install: %1$s Downloaded %1$s download Takes effect the next time the game starts. diff --git a/app/src/test/java/com/droiddeck/launcher/session/WinComponentsSupportTest.kt b/app/src/test/java/com/droiddeck/launcher/session/WinComponentsSupportTest.kt new file mode 100644 index 0000000000..2e43be1ce9 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/session/WinComponentsSupportTest.kt @@ -0,0 +1,46 @@ +package com.droiddeck.launcher.session + +import com.droiddeck.launcher.session.WinComponents.Support +import org.json.JSONObject +import org.junit.Assert.assertEquals +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [33]) +class WinComponentsSupportTest { + private val base = "https://github.com/The412Banner/winlator-contents/releases/download/system-libraries-v1" + + private fun step(action: String, vararg pairs: Pair) = + WinComponents.Step(action, JSONObject().apply { pairs.forEach { (k, v) -> put(k, v) } }) + + private fun component(name: String, vararg steps: WinComponents.Step) = + WinComponents.Component(name, "", "", "ready", emptyList(), steps.toList()) + + private fun support(c: WinComponents.Component) = WinComponents.support(c, mapOf(c.name to c)) + + @Test fun windowsInstallerPackagesInstallHere() { + assertEquals(Support.READY, support(component("xna40", step("install_msi", "url" to "$base/xna40.msi")))) + // The catalog names some .msi packages install_exe. + assertEquals(Support.READY, support(component("XLiveRedist", + step("install_exe", "url" to "$base/XLiveRedist.msi", "file_name" to "XLiveRedist1.2.0238.msi")))) + assertEquals(Support.READY, support(component("msxml3", step("delete_dlls", "dest" to "win32"), + step("override_dll", "dll" to "msxml3", "type" to "native"), step("install_msi", "url" to "$base/msxml3.msi")))) + assertEquals(Support.READY, support(component("powershell_core", + step("install_msi", "url" to "$base/ps-x86.msi"), step("install_msi", "url" to "$base/ps-x64.msi")))) + } + + @Test fun otherInstallersStillWait() { + assertEquals(Support.NEEDS_INSTALLER, support(component("dotnet48", step("install_exe", "url" to "$base/ndp48.exe")))) + // An uninstall step first (wine-mono) is not something done here. + assertEquals(Support.NEEDS_INSTALLER, support(component("mono", step("uninstall"), + step("install_msi", "url" to "$base/mono.msi")))) + assertEquals(Support.NEEDS_INSTALLER, support(component("plain", step("install_msi", "url" to "http://example.com/a.msi")))) + } + + @Test fun whatProtonShipsIsNotOffered() { + assertEquals(Support.UNSUPPORTED, support(component("gecko", step("install_msi", "url" to "$base/gecko.msi")))) + } +} diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-msi-install b/tools/linuxfs/overlay/usr/local/bin/droiddeck-msi-install new file mode 100755 index 0000000000..3df6861736 --- /dev/null +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-msi-install @@ -0,0 +1,771 @@ +#!/usr/bin/python3 +"""Installs a Windows Installer package (.msi) the way Wine's own msiexec would, without running it. + +droiddeck-msi-install + +A .msi is a database: which files go to which folder, which registry values to write, which .NET +and side-by-side assemblies to register. This reads those tables (msiinfo), unpacks the package's +cabinets (cabextract, which knows every compression a cabinet can use) and lays the result out +for droiddeck-wincomponents, which puts it into a game's prefix at launch: + + /drive_c/... the files, at the paths they get on 64-bit Windows + /registry.json the registry values, in the view (32/64-bit) Windows uses + +What a package does by running its own code (custom actions such as DXSETUP, self-registering +DLLs) cannot be done this way; each is named in the notes, so nothing is left out silently. + +Prints "progress " lines while it works and ends with "result ": the counts and notes. +""" +import json +import os +import re +import shutil +import subprocess +import sys +import tempfile +from pathlib import Path + +TOOLS = Path(os.environ.get("DROIDDECK_MSITOOLS", "/usr/local/lib/droiddeck-msitools")) +MSIINFO = os.environ.get("DROIDDECK_MSIINFO", str(TOOLS / "msiinfo")) +CABEXTRACT = os.environ.get("DROIDDECK_CABEXTRACT", str(TOOLS / "cabextract")) + + +def tool_env(): + """The environment the tools run in: their own libraries (libmsi, libgsf, libgcab) beside them.""" + env = dict(os.environ) + env["LD_LIBRARY_PATH"] = ":".join(p for p in (str(TOOLS), env.get("LD_LIBRARY_PATH", "")) if p) + return env + +# The folders Windows Installer knows by name, as a 64-bit Windows 10 prefix lays them out (Proton's +# user is steamuser). None is a folder whose files a game never needs: installer temp files and +# shortcuts. +SKIP = None +KNOWN_FOLDERS = { + "TARGETDIR": "C:\\", "ROOTDRIVE": "C:\\", "WindowsVolume": "C:\\", + "WindowsFolder": "C:\\windows\\", + "SystemFolder": "C:\\windows\\syswow64\\", + "System64Folder": "C:\\windows\\system32\\", + "System16Folder": "C:\\windows\\system\\", + "FontsFolder": "C:\\windows\\Fonts\\", + "ProgramFilesFolder": "C:\\Program Files (x86)\\", + "ProgramFiles64Folder": "C:\\Program Files\\", + "CommonFilesFolder": "C:\\Program Files (x86)\\Common Files\\", + "CommonFiles64Folder": "C:\\Program Files\\Common Files\\", + "CommonAppDataFolder": "C:\\ProgramData\\", + "AppDataFolder": "C:\\users\\steamuser\\AppData\\Roaming\\", + "LocalAppDataFolder": "C:\\users\\steamuser\\AppData\\Local\\", + "PersonalFolder": "C:\\users\\steamuser\\Documents\\", +} +for _name in ("TempFolder", "DesktopFolder", "ProgramMenuFolder", "StartMenuFolder", "StartupFolder", + "SendToFolder", "FavoritesFolder", "NetHoodFolder", "PrintHoodFolder", "RecentFolder", + "TemplateFolder", "MyPicturesFolder", "AdminToolsFolder"): + KNOWN_FOLDERS[_name] = SKIP + +# What Wine's msi reports on a 64-bit Windows 10 prefix, for the packages' conditions. +SYSTEM_PROPERTIES = { + "VersionNT": "603", "VersionNT64": "603", "WindowsBuild": "9600", "ServicePackLevel": "0", + "Msix64": "6", "ALLUSERS": "1", "Privileged": "1", "AdminUser": "1", "MsiNTProductType": "1", + "UILevel": "2", "INSTALLLEVEL": "1", "ProgramFilesFolder": None, "VersionMsi": "5.00", +} + +# Win64 component (msidbComponentAttributes64bit); file attributes. +COMPONENT_64BIT = 0x100 +FILE_NONCOMPRESSED = 0x2000 +# Custom action types that only set a property or a folder: done here, the rest are named in notes. +SET_PROPERTY, SET_DIRECTORY, ERROR_ACTION = 51, 35, 19 +# Microsoft's "SFP CA" merge module (MDAC, MSXML): on Windows 2000 and later it parks system DLLs in a +# cache folder and its own code copies them into the system folder past Windows File Protection. +# Skipping the folder change puts them where that copy would. Its actions, and the side-by-side +# merge module's (done here from MsiAssembly), are then left out of the notes. +SFP_CACHE_ACTION = "CDirSystemSFPCacheDir" +HANDLED_ACTIONS = ("Wdsfpca_", "SxsInstallCA", "SxsUninstallCA") +# Tables whose work needs the package's own code or is not done here yet. +UNSUPPORTED_TABLES = ("SelfReg", "Class", "ProgId", "TypeLib", "Extension", "Verb", "MIME", "AppId", + "IniFile", "ServiceInstall", "MoveFile", "IsolatedComponent", "PublishComponent", + "ODBCDriver", "ODBCDataSource") + + +class MsiError(Exception): + pass + + +def progress(text): + print("progress " + text, flush=True) + + +# ---------------------------------------------------------------- reading the package + +IDT_ESCAPES = str.maketrans({"\x19": "\n", "\x11": "\r", "\x15": "\t", "\x1b": ";"}) + + +def msiinfo(*args, binary=False): + try: + result = subprocess.run([MSIINFO, *args], capture_output=True, timeout=600, env=tool_env()) + except OSError as error: + raise MsiError("msitools is not available (%s)" % error) + if result.returncode != 0: + raise MsiError("msiinfo %s: %s" % (args[0], result.stderr.decode("utf-8", "replace").strip()[:300])) + return result.stdout if binary else result.stdout.decode("utf-8", "replace") + + +class Package: + def __init__(self, path): + self.path = str(path) + self.table_names = set(msiinfo("tables", self.path).split()) + self._tables = {} + self.summary = {} + for line in msiinfo("suminfo", self.path).splitlines(): + name, sep, value = line.partition(":") + if sep: + self.summary[name.strip().lower()] = value.strip() + + def table(self, name): + """The table's rows as dicts by column name; an absent table has none.""" + if name in self._tables: + return self._tables[name] + rows = [] + if name in self.table_names: + lines = [line.rstrip("\r") for line in msiinfo("export", self.path, name).split("\n")] + columns = lines[0].split("\t") if lines else [] + for line in lines[3:]: + if not line: + continue + cells = [cell.translate(IDT_ESCAPES) for cell in line.split("\t")] + cells += [""] * (len(columns) - len(cells)) + rows.append(dict(zip(columns, cells))) + self._tables[name] = rows + return rows + + def stream(self, name, target): + Path(target).write_bytes(msiinfo("extract", self.path, name, binary=True)) + + +def long_name(value): + """A Directory/File name column: "short|long", the long one when there are two.""" + return value.split("|")[-1] + + +def to_int(value, default=0): + try: + return int(str(value).strip()) + except ValueError: + return default + + +# ---------------------------------------------------------------- conditions + +TOKEN = re.compile(r'\s*(?:(?P"[^"]*")|(?P-?\d+)(?![\w.])|(?P~?(?:<>|<=|>=|><|<<|>>|=|<|>))' + r'|(?P[()])|(?P[%$?&!]?[A-Za-z_][\w.]*))') +KEYWORDS = {"not", "and", "or", "xor", "eqv", "imp"} + + +class Conditions: + """Windows Installer's condition language, enough of it for what packages ask at install time.""" + + def __init__(self, props, feature_state=None, component_state=None): + self.props = props + self.feature_state = feature_state or (lambda name: None) + self.component_state = component_state or (lambda name: None) + + def evaluate(self, text, default=True): + text = (text or "").strip() + if not text: + return True + try: + self.tokens = self.tokenize(text) + self.pos = 0 + value = self.expression() + if self.pos != len(self.tokens): + return default + return self.truth(value) + except (ValueError, IndexError): + return default + + def tokenize(self, text): + tokens, pos = [], 0 + while pos < len(text): + if text[pos:].strip() == "": + break + match = TOKEN.match(text, pos) + if not match or match.end() == pos: + raise ValueError(text) + pos = match.end() + kind = match.lastgroup + value = match.group(kind) + if kind == "word" and value.lower() in KEYWORDS: + tokens.append(("kw", value.lower())) + else: + tokens.append((kind, value)) + return tokens + + def peek(self): + return self.tokens[self.pos] if self.pos < len(self.tokens) else (None, None) + + def take(self, kind, value=None): + token = self.peek() + if token[0] == kind and (value is None or token[1] == value): + self.pos += 1 + return True + return False + + def expression(self): + value = self.binary(0) + return value + + LEVELS = ("imp", "eqv", "xor", "or", "and") + + def binary(self, level): + if level == len(self.LEVELS): + return self.negation() + left = self.binary(level + 1) + op = self.LEVELS[level] + while self.take("kw", op): + right = self.truth(self.binary(level + 1)) + a = self.truth(left) + left = {"and": a and right, "or": a or right, "xor": a != right, + "eqv": a == right, "imp": (not a) or right}[op] + return left + + def negation(self): + if self.take("kw", "not"): + return not self.truth(self.negation()) + return self.comparison() + + def comparison(self): + left = self.operand() + kind, op = self.peek() + if kind != "op": + return left + self.pos += 1 + right = self.operand() + return self.compare(left, op, right) + + def operand(self): + kind, value = self.peek() + self.pos += 1 + if kind == "paren" and value == "(": + inner = self.expression() + if not self.take("paren", ")"): + raise ValueError("unbalanced") + return inner + if kind == "str": + return value[1:-1] + if kind == "num": + return int(value) + if kind == "word": + sigil, name = (value[0], value[1:]) if value[0] in "%$?&!" else ("", value) + if sigil == "%": + return os.environ.get(name, "") + if sigil in ("&", "!"): + state = self.feature_state(name) + return state if state is not None else -1 + if sigil in ("$", "?"): + state = self.component_state(name) + return state if state is not None else -1 + found = self.props.get(name) + return "" if found is None else found + raise ValueError("operand expected") + + @staticmethod + def number(value): + if isinstance(value, bool): + return int(value) + if isinstance(value, int): + return value + if isinstance(value, str) and re.fullmatch(r"-?\d+", value.strip()): + return int(value) + return None + + def compare(self, left, op, right): + fold = op.startswith("~") + op = op.lstrip("~") + a, b = self.number(left), self.number(right) + if a is not None and b is not None: + return {"=": a == b, "<>": a != b, "<": a < b, ">": a > b, "<=": a <= b, ">=": a >= b, + "><": (a & b) != 0, "<<": (a >> 16) == b, ">>": (a & 0xFFFF) == b}[op] + if isinstance(left, (int, bool)) or isinstance(right, (int, bool)): + return op == "<>" + a, b = str(left), str(right) + if fold: + a, b = a.lower(), b.lower() + return {"=": a == b, "<>": a != b, "<": a < b, ">": a > b, "<=": a <= b, ">=": a >= b, + "><": b in a, "<<": a.startswith(b), ">>": a.endswith(b)}[op] + + @staticmethod + def truth(value): + if isinstance(value, bool): + return value + if isinstance(value, int): + return value != 0 + return value not in ("", None) + + +# ---------------------------------------------------------------- the install + +def win_to_rel(path): + """C:\\windows\\x\\ -> drive_c/windows/x; None for a path off drive C or a folder left out.""" + if not path: + return None + match = re.match(r"^[Cc]:\\?(.*)$", path) + if not match: + return None + rest = [part for part in match.group(1).replace("/", "\\").split("\\") if part not in ("", ".")] + if any(part == ".." for part in rest): + return None + return "/".join(["drive_c"] + rest) + + +def rel_to_win(rel, folder=True): + parts = rel.split("/")[1:] + return "C:\\" + "\\".join(parts) + ("\\" if folder and parts else "") + + +def clean_version(version): + parts = [str(to_int(p)) for p in version.split(".") if p != ""] + return ".".join(parts) if parts else "0.0.0.0" + + +def clr_version(path): + """The .NET runtime an assembly was built for ("v4.0.30319"), from its metadata header.""" + try: + data = Path(path).read_bytes() + except OSError: + return "" + at = data.find(b"BSJB") + if at < 0 or at + 16 > len(data): + return "" + length = int.from_bytes(data[at + 12:at + 16], "little") + return data[at + 16:at + 16 + min(length, 32)].split(b"\0")[0].decode("ascii", "replace") + + +class Installer: + def __init__(self, msi, out, package=None): + self.pkg = package or Package(msi) + self.out = Path(out) + self.notes = [] + self.registry = [] + self.files = {} # File key -> rel path it was installed to + self.counts = {"files": 0, "assemblies": 0, "registry": 0} + template = self.pkg.summary.get("template", "") + self.platform = template.split(";")[0].strip().lower() + self.props = {k: v for k, v in SYSTEM_PROPERTIES.items() if v is not None} + if self.platform in ("", "intel"): + self.props["Intel"] = "6" + for name, path in KNOWN_FOLDERS.items(): + self.props[name] = path if path is not None else "\0skip" + for row in self.pkg.table("Property"): + # The package's own defaults, but never over the folders and the system it runs on. + if row["Property"] not in self.props or row["Property"] in ("INSTALLLEVEL", "ALLUSERS", "UILevel"): + self.props[row["Property"]] = row["Value"] + self.props["ALLUSERS"] = "1" + self.directories = {row["Directory"]: row for row in self.pkg.table("Directory")} + self.components = {row["Component"]: row for row in self.pkg.table("Component")} + self.included_features = set() + self.included_components = set() + self.conditions = Conditions(self.props, self.feature_state, self.component_state) + self._resolving = set() + self._set_by_action = set() + + # -- states, folders, formatted text + + def feature_state(self, name): + return 3 if name in self.included_features else -1 + + def component_state(self, name): + return 3 if name in self.included_components else -1 + + def directory(self, key): + """The folder a Directory key resolves to, as drive_c/..., or None when it is left out.""" + if key in self._resolving: + return None + value = self.props.get(key) + row = self.directories.get(key) + # A folder Windows knows by name, one a custom action set, or a property naming a path. + if key in KNOWN_FOLDERS or key in self._set_by_action or row is None: + return None if value in (None, "", "\0skip") else win_to_rel(value) + parent_key = row.get("Directory_Parent", "") + default = long_name(row.get("DefaultDir", "").split(":")[0]) + if not parent_key or parent_key == key: + # A root: TARGETDIR (SourceDir) is drive C. + return "drive_c" + self._resolving.add(key) + try: + parent = self.directory(parent_key) + finally: + self._resolving.discard(key) + if parent is None: + return None + if default in (".", ""): + return parent + if "\\" in default or "/" in default or default == "..": + return None + return parent + "/" + default + + def format(self, text): + """Formatted text: [Property], [Folder], [#file], [$component], [%env], [\\x], [~].""" + if not text: + return text + + def one(match): + inner = match.group(1) + if inner.startswith("\\") and len(inner) == 2: + return inner[1] + if inner == "~": + return "\0" + if inner.startswith("#") or inner.startswith("!"): + rel = self.files.get(inner[1:]) + return rel_to_win(rel, folder=False) if rel else "" + if inner.startswith("$"): + comp = self.components.get(inner[1:]) + rel = self.directory(comp["Directory_"]) if comp else None + return rel_to_win(rel) if rel else "" + if inner.startswith("%"): + return os.environ.get(inner[1:], "") + if inner in self.directories or inner in KNOWN_FOLDERS: + rel = self.directory(inner) + return rel_to_win(rel) if rel else "" + value = self.props.get(inner, "") + return "" if value == "\0skip" else value + + previous = None + for _ in range(8): + if text == previous: + break + previous = text + text = re.sub(r"\[([^\[\]]*)\]", one, text) + return text + + # -- what gets installed + + def run_set_actions(self): + """The property/folder-setting custom actions, in sequence order; the rest go to the notes.""" + actions = {row["Action"]: row for row in self.pkg.table("CustomAction")} + sequence = {} + for table in ("InstallUISequence", "InstallExecuteSequence"): + for row in self.pkg.table(table): + if row["Action"] in actions and row["Action"] not in sequence: + sequence[row["Action"]] = (to_int(row.get("Sequence"), 0), row.get("Condition", "")) + skipped = [] + sfp = "_SfpCaInf" in self.pkg.table_names + for name, (_, condition) in sorted(sequence.items(), key=lambda item: item[1][0]): + row = actions[name] + kind = to_int(row["Type"]) & 0x3F + if name.startswith(HANDLED_ACTIONS) or (sfp and name.startswith(SFP_CACHE_ACTION)): + continue + if kind in (SET_PROPERTY, SET_DIRECTORY): + if not self.conditions.evaluate(condition, default=True): + continue + value = self.format(row.get("Target", "")) + self.props[row["Source"]] = value + self._set_by_action.add(row["Source"]) + elif kind != ERROR_ACTION and self.conditions.evaluate(condition, default=True): + skipped.append(name) + if skipped: + self.notes.append("setup actions not run (they need the installer's own code): " + ", ".join(skipped[:8]) + + (" and %d more" % (len(skipped) - 8) if len(skipped) > 8 else "")) + + def select(self): + install_level = to_int(self.props.get("INSTALLLEVEL"), 1) or 1 + features = {row["Feature"]: dict(row) for row in self.pkg.table("Feature")} + for row in self.pkg.table("Condition"): + feature = features.get(row["Feature_"]) + if feature is not None and self.conditions.evaluate(row["Condition"], default=False): + feature["Level"] = row["Level"] + + def included(name, depth=0): + feature = features.get(name) + if feature is None or depth > 32: + return False + level = to_int(feature.get("Level"), 0) + if level <= 0 or level > install_level: + return False + parent = feature.get("Feature_Parent", "") + return not parent or parent == name or included(parent, depth + 1) + + self.included_features = {name for name in features if included(name)} + mapped = {} + for row in self.pkg.table("FeatureComponents"): + mapped.setdefault(row["Component_"], set()).add(row["Feature_"]) + for name, row in self.components.items(): + owners = mapped.get(name) + if owners is not None and not owners & self.included_features: + continue + if not self.conditions.evaluate(row.get("Condition", ""), default=True): + continue + self.included_components.add(name) + + def assemblies(self): + """Component -> where its files go when it is a global assembly (the GAC or winsxs).""" + names = {} + for row in self.pkg.table("MsiAssemblyName"): + names.setdefault(row["Component_"], {})[row["Name"].lower()] = row["Value"] + placed = {} + for row in self.pkg.table("MsiAssembly"): + comp = row["Component_"] + if comp not in self.included_components or row.get("File_Application"): + continue + ident = names.get(comp, {}) + placed[comp] = (to_int(row.get("Attributes"), 0), ident, row.get("File_Manifest", "")) + return placed + + def gac_folder(self, ident, assembly_file): + name = ident.get("name", "") + token = ident.get("publickeytoken", "").lower() + if not name or not token or "/" in name or "\\" in name: + return None + version = clean_version(ident.get("version", "0.0.0.0")) + culture = ident.get("culture", "neutral") + culture = "" if culture.lower() == "neutral" else culture + arch = ident.get("processorarchitecture", "").lower() + gac = {"x86": "GAC_32", "amd64": "GAC_64", "x64": "GAC_64", "msil": "GAC_MSIL"}.get(arch, "GAC_MSIL" if arch else "GAC") + if clr_version(assembly_file).startswith("v4"): + return "drive_c/windows/Microsoft.NET/assembly/%s/%s/v4.0_%s_%s_%s" % (gac, name, version, culture, token) + return "drive_c/windows/assembly/%s/%s/%s_%s_%s" % (gac, name, version, culture, token) + + @staticmethod + def sxs_names(ident): + """Wine's winsxs names for a side-by-side assembly: its folder and, for a policy, the policy folder.""" + arch = ident.get("processorarchitecture", "x86").lower() or "x86" + name = ident.get("name", "").lower() + token = ident.get("publickeytoken", "").lower() + version = ident.get("version", "") + if not name or not token or not version or "/" in name or "\\" in name: + return None + if ident.get("type", "").lower() == "win32-policy": + target = re.sub(r"^policy\.\d+\.\d+\.", "", name) + return "policy", "drive_c/windows/winsxs/policies/%s_%s_%s_none_deadbeef" % (arch, target, token), version + return "assembly", "%s_%s_%s_%s_none_deadbeef" % (arch, name, token, version), version + + def unpack(self, work): + """Every cabinet in the package, unpacked; returns File key -> unpacked file.""" + found = {} + for index, row in enumerate(self.pkg.table("Media")): + cabinet = row.get("Cabinet", "") + if not cabinet: + continue + if not cabinet.startswith("#"): + self.notes.append("external cabinet %s is not part of the package; its files are missing" % cabinet) + continue + progress("unpacking %s" % cabinet[1:]) + cab = Path(work) / ("media%d.cab" % index) + self.pkg.stream(cabinet[1:], cab) + dest = Path(work) / ("media%d" % index) + dest.mkdir() + result = subprocess.run([CABEXTRACT, "-q", "-d", str(dest), str(cab)], capture_output=True, timeout=1800, + env=tool_env()) + if result.returncode != 0: + raise MsiError("cabextract: %s" % result.stderr.decode("utf-8", "replace").strip()[:300]) + cab.unlink() + for entry in dest.rglob("*"): + if entry.is_file(): + found.setdefault(entry.relative_to(dest).as_posix(), entry) + return found + + def put(self, source, rel): + target = self.out / rel + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(source, target) + + def install_files(self, unpacked): + assemblies = self.assemblies() + files = self.pkg.table("File") + missing = 0 + destinations = {} + # Where each file goes: its component's folder, or the assembly store for a global assembly. + for row in files: + comp = row["Component_"] + if comp not in self.included_components: + continue + name = long_name(row["FileName"]) + if not name or "/" in name or "\\" in name or name in (".", ".."): + continue + if comp in assemblies: + kind, ident, manifest = assemblies[comp] + if kind == 0: + source = unpacked.get(self.components[comp].get("KeyPath", "")) + folder = self.gac_folder(ident, source) if source else None + destinations[row["File"]] = folder + "/" + name if folder else None + else: + names = self.sxs_names(ident) + if names is None: + destinations[row["File"]] = None + elif names[0] == "policy": + destinations[row["File"]] = (names[1] + "/" + names[2] + ".policy") if row["File"] == manifest else None + elif row["File"] == manifest: + destinations[row["File"]] = "drive_c/windows/winsxs/manifests/%s.manifest" % names[1] + elif name.lower().endswith(".cat"): + destinations[row["File"]] = None + else: + destinations[row["File"]] = "drive_c/windows/winsxs/%s/%s" % (names[1], name) + continue + folder = self.directory(self.components[comp]["Directory_"]) + destinations[row["File"]] = folder + "/" + name if folder else None + for key, rel in destinations.items(): + if rel: + self.files[key] = rel + assembly_folders = set() + for key, rel in destinations.items(): + if not rel: + continue + source = unpacked.get(key) + if source is None: + missing += 1 + continue + self.put(source, rel) + self.counts["files"] += 1 + if "/assembly/" in rel or "/winsxs/" in rel: + assembly_folders.add(rel.rsplit("/", 1)[0]) + self.counts["assemblies"] = len(assembly_folders) + for row in self.pkg.table("DuplicateFile"): + if row["Component_"] not in self.included_components or row["File_"] not in self.files: + continue + folder = self.directory(row["DestFolder"]) if row.get("DestFolder") else self.files[row["File_"]].rsplit("/", 1)[0] + name = long_name(row.get("DestName", "")) or self.files[row["File_"]].rsplit("/", 1)[1] + source = self.out / self.files[row["File_"]] + if folder and source.is_file() and "/" not in name: + self.put(source, folder + "/" + name) + self.counts["files"] += 1 + if missing: + self.notes.append("%d file(s) were not in the package's cabinets" % missing) + + def value(self, hive, key, name, kind, data, wow64): + # A 32-bit component writes through the 32-bit view, as Wine's msi does: HKLM\Software is + # Software\Wow6432Node, and the prefix's link keys there (Classes, TypeLib, Fonts...) lead + # to the keys both views share - droiddeck-wincomponents follows them when it writes. + lower = key.lower() + if hive == "HKLM" and wow64 and lower.startswith("software\\") and not lower.startswith("software\\wow6432node\\"): + key = "Software\\Wow6432Node\\" + key[len("software\\"):] + self.registry.append({"hive": hive, "key": key, "name": name, "type": kind, "data": data}) + + def registry_data(self, raw): + """A Registry table Value: (type, data) as droiddeck-wincomponents writes them.""" + if raw is None or raw == "": + return "sz", "" + if raw.startswith("#x") or raw.startswith("#X"): + hexdigits = re.sub(r"[^0-9A-Fa-f]", "", self.format(raw[2:])) + if len(hexdigits) % 2: + hexdigits = "0" + hexdigits + return "binary", hexdigits.lower() + if raw.startswith("#%"): + return "expand_sz", self.format(raw[2:]) + if raw.startswith("##"): + return "sz", self.format(raw[1:]) + if raw.startswith("#"): + number = self.format(raw[1:]) + if re.fullmatch(r"[+-]?\d+", number.strip()): + return "dword", int(number) & 0xFFFFFFFF + return "sz", number + text = self.format(raw) + if "\0" in text: + parts = [part for part in text.split("\0") if part] + return "multi_sz", parts + return "sz", text + + def install_registry(self): + for row in self.pkg.table("Registry"): + comp = row["Component_"] + if comp not in self.included_components: + continue + root = to_int(row["Root"], 2) + hive, prefix = {-1: ("HKLM", ""), 0: ("HKLM", "Software\\Classes\\"), 1: ("HKCU", ""), + 2: ("HKLM", "")}.get(root, (None, None)) + if hive is None: + continue + key = prefix + self.format(row["Key"]).strip("\\") + wow64 = not (to_int(self.components[comp].get("Attributes"), 0) & COMPONENT_64BIT) + name = row.get("Name", "") + raw = row.get("Value", "") + if name in ("+", "-", "*") and not raw: + self.value(hive, key, None, "key", None, wow64) + continue + if not name and not raw: + self.value(hive, key, None, "key", None, wow64) + continue + kind, data = self.registry_data(raw) + self.value(hive, key, self.format(name) or "", kind, data, wow64) + self.counts["registry"] += 1 + for row in self.pkg.table("Environment"): + if row["Component_"] not in self.included_components: + continue + flags = re.match(r"^[=+\-!*]*", row["Name"]).group(0) + name = row["Name"][len(flags):] + if "!" in flags or not name: + continue + raw = row.get("Value", "") or "" + hive, key = ("HKLM", "System\\CurrentControlSet\\Control\\Session Manager\\Environment") if "*" in flags \ + else ("HKCU", "Environment") + mode = "set" + if raw.startswith("[~]"): + mode, raw = "append", raw[3:] + elif raw.endswith("[~]"): + mode, raw = "prepend", raw[:-3] + separator = ";" + if mode == "append" and raw[:1] in ";:": + separator, raw = raw[0], raw[1:] + elif mode == "prepend" and raw[-1:] in ";:": + separator, raw = raw[-1], raw[:-1] + value = self.format(raw) + if value: + self.registry.append({"hive": hive, "key": key, "name": name, "type": mode, "data": value, "separator": separator}) + self.counts["registry"] += 1 + for row in self.pkg.table("Font"): + rel = self.files.get(row["File_"]) + if not rel: + continue + title = row.get("FontTitle") or Path(rel).stem + " (TrueType)" + self.value("HKLM", "Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts", title, "sz", + rel.rsplit("/", 1)[1], False) + self.counts["registry"] += 1 + + def check(self): + for row in self.pkg.table("LaunchCondition"): + if not self.conditions.evaluate(row["Condition"], default=True): + self.notes.append("the package says: " + self.format(row.get("Description", "")).strip()) + for name in UNSUPPORTED_TABLES: + count = len(self.pkg.table(name)) if name in self.pkg.table_names else 0 + if count: + what = "self-registering DLL(s) not registered" if name == "SelfReg" else "%s entries not written" % name + self.notes.append("%d %s" % (count, what)) + + def install(self): + progress("reading %s" % (self.pkg.summary.get("subject") or Path(self.pkg.path).name)) + self.run_set_actions() + self.select() + with tempfile.TemporaryDirectory(dir=str(self.out.parent), prefix=".msi-") as work: + unpacked = self.unpack(work) + progress("placing files") + self.install_files(unpacked) + self.install_registry() + self.check() + if not self.counts["files"] and not self.registry: + raise MsiError("the package installs nothing here") + # A component made of several packages (32- and 64-bit) gets them all in one registry.json. + values = [] + try: + with open(self.out / "registry.json", encoding="utf-8") as source: + values = json.load(source).get("values", []) + except (FileNotFoundError, ValueError, AttributeError): + pass + with open(self.out / "registry.json", "w", encoding="utf-8") as out: + json.dump({"version": 1, "values": values + self.registry}, out, indent=1) + return {"product": self.props.get("ProductName", ""), "version": self.props.get("ProductVersion", ""), + "counts": self.counts, "notes": self.notes} + + +def main(): + if len(sys.argv) != 3: + print("usage: droiddeck-msi-install ", file=sys.stderr) + return 2 + out = Path(sys.argv[2]) + out.mkdir(parents=True, exist_ok=True) + try: + result = Installer(sys.argv[1], out).install() + except MsiError as error: + print("error " + str(error), flush=True) + return 1 + print("result " + json.dumps(result), flush=True) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-wincomponents b/tools/linuxfs/overlay/usr/local/bin/droiddeck-wincomponents index 828ad57471..78ec90bc81 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-wincomponents +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-wincomponents @@ -8,9 +8,14 @@ the components it bundles ("requires"). The ids are Bannerlator's catalog names oalinst_dll...). The user picks components per game; the picks are in SELECTION as {"version": 1, "games": {"": ["oalinst_dll", ...]}}. +A component installed from a Windows Installer package (droiddeck-msi-install) also has drive_c/, +its files at their Windows paths (Program Files, the .NET GAC, winsxs...), and registry.json, the +values its package writes. + droiddeck-game-env calls apply() before every game launch. It copies what is missing or changed -into compatdata//pfx and returns the overrides for WINEDLLOVERRIDES, so nothing is written -to the prefix's registry and Wine never has to be running. +into compatdata//pfx, writes the components' registry values into the prefix's registry +files (system.reg, user.reg) and returns the overrides for WINEDLLOVERRIDES, so Wine never has to +be running. A prefix Proton has not made yet gets the registry values on the launch after. Proton leaves the files alone afterwards: its builtin refresh (update_builtin_libs) replaces only files that are its own builtins, and a new prefix is built around files already there (copy_pfx @@ -22,6 +27,7 @@ import os import re import shutil import sys +import time from pathlib import Path STORE = Path("/opt/droiddeck/wincomponents") @@ -34,6 +40,10 @@ BACKUP = ".droiddeck-wincomponents-backup" BUILTIN_MARKS = (b"Wine builtin DLL", b"Wine placeholder DLL") ARCH_DIRS = ("system32", "syswow64") ID = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,63}") +# The registry file of each hive in a prefix, and the kinds of value registry.json holds: "key" +# makes a key, "append"/"prepend" add to a list such as PATH unless it is already there. +HIVES = {"HKLM": "system.reg", "HKCU": "user.reg"} +VALUE_TYPES = {"key", "sz", "expand_sz", "multi_sz", "dword", "binary", "append", "prepend"} def valid_id(value): @@ -71,8 +81,28 @@ def component(store, cid): if entry.is_file() and not entry.is_symlink(): rel = entry.relative_to(folder).as_posix().lower() files.append(("drive_c/windows/%s/%s" % (arch, rel), entry)) + drive = root / "drive_c" + if drive.is_dir(): + for entry in sorted(drive.rglob("*")): + if entry.is_file() and not entry.is_symlink(): + files.append(("drive_c/" + entry.relative_to(drive).as_posix(), entry)) requires = [r for r in meta.get("requires", []) if valid_id(r)] - return [str(o) for o in meta.get("overrides", [])], files, requires + return [str(o) for o in meta.get("overrides", [])], files, requires, registry_values(root) + + +def registry_values(root): + """The component's registry values (registry.json), the ones that are well formed.""" + try: + with open(Path(root) / "registry.json", encoding="utf-8") as source: + values = json.load(source).get("values", []) + except (FileNotFoundError, ValueError, AttributeError): + return [] + good = [] + for value in values if isinstance(values, list) else []: + if isinstance(value, dict) and value.get("hive") in HIVES and isinstance(value.get("key"), str) \ + and value.get("type") in VALUE_TYPES and value["key"].strip("\\") and "\0" not in value["key"]: + good.append(value) + return good def expand(store, ids): @@ -93,13 +123,33 @@ def expand(store, ids): return out +def spelled(path): + """path with each folder that exists spelled as the prefix spells it (Windows names ignore case).""" + parts = path.parts + current = Path(parts[0]) + for part in parts[1:]: + candidate = current / part + if not candidate.exists(): + try: + with os.scandir(current) as entries: + for entry in entries: + if entry.name.lower() == part.lower() and entry.is_dir(): + candidate = current / entry.name + break + except OSError: + pass + current = candidate + return current + + def existing(path): """The file at path as the prefix spells it: Windows names ignore case, the filesystem may not.""" - folder = path.parent + folder = spelled(path.parent) + path = folder / path.name try: with os.scandir(folder) as entries: for entry in entries: - if entry.name.lower() == path.name: + if entry.name.lower() == path.name.lower(): return folder / entry.name except OSError: pass @@ -130,6 +180,7 @@ def builtin(path): def place(src, target, backup=None): """Copies src over target unless it is already there; a file of someone else's goes to backup first.""" + target = spelled(target.parent) / target.name target.parent.mkdir(parents=True, exist_ok=True) found = existing(target) if found is not None and same(src, found): @@ -145,6 +196,312 @@ def place(src, target, backup=None): return True +# ---------------------------------------------------------------- the prefix's registry files + +def reg_escape(text, extra=""): + """A string as Wine's registry files write it.""" + out = [] + for ch in text: + if ch == "\\" or ch == '"' or ch in extra: + out.append("\\" + ch) + elif ch == "\n": + out.append("\\n") + elif ch == "\r": + out.append("\\r") + elif ch == "\t": + out.append("\\t") + elif ch == "\0": + out.append("\\0") + elif ch < " " or ch > "~": + out.append("\\x%04x" % ord(ch)) + else: + out.append(ch) + return "".join(out) + + +def reg_unescape(text): + out, i = [], 0 + while i < len(text): + ch = text[i] + if ch != "\\" or i + 1 >= len(text): + out.append(ch) + i += 1 + continue + nxt = text[i + 1] + if nxt == "x": + match = re.match(r"[0-9a-fA-F]{1,4}", text[i + 2:]) + if match: + out.append(chr(int(match.group(0), 16))) + i += 2 + len(match.group(0)) + continue + out.append({"n": "\n", "r": "\r", "t": "\t", "0": "\0"}.get(nxt, nxt)) + i += 2 + return "".join(out) + + +def reg_key_line(key): + return "[%s]" % "\\\\".join(reg_escape(part, "[]") for part in key.strip("\\").split("\\")) + + +def reg_value_line(name, kind, data): + """name=data as one registry file line; None for a kind that has no line of its own.""" + head = "@" if name == "" else '"%s"' % reg_escape(name) + if kind == "sz": + return '%s="%s"' % (head, reg_escape(str(data))) + if kind == "expand_sz": + return '%s=str(2):"%s"' % (head, reg_escape(str(data))) + if kind == "multi_sz": + parts = [str(part) for part in data] if isinstance(data, list) else [str(data)] + return '%s=str(7):"%s"' % (head, reg_escape("".join(part + "\0" for part in parts))) + if kind == "dword": + return "%s=dword:%08x" % (head, int(data) & 0xFFFFFFFF) + if kind == "binary": + digits = re.sub(r"[^0-9a-f]", "", str(data).lower()) + return "%s=hex:%s" % (head, ",".join(digits[i:i + 2] for i in range(0, len(digits) - 1, 2))) + return None + + +def reg_string(line): + """The text of a string value line (plain or str(2)), or None for any other kind.""" + match = re.match(r'^(?:@|"(?:[^"\\]|\\.)*")=(?:str\(2\):)?"((?:[^"\\]|\\.)*)"\s*$', line) + return reg_unescape(match.group(1)) if match else None + + +class RegistryFile: + """One of a prefix's registry files, as Wine keeps them: [key] sections of name=value lines.""" + + def __init__(self, path): + self.path = Path(path) + with open(self.path, encoding="utf-8", errors="surrogateescape", newline="") as source: + self.lines = source.read().split("\n") + self.changed = False + self.index = {} + self.links = {} + root = "" + for line in self.lines[:4]: + match = re.match(r"^;; All keys relative to (.*)$", line) + if match: + root = reg_unescape(match.group(1)).strip("\\").lower() + current = None + for number, line in enumerate(self.lines): + if line.startswith("["): + key = self.parse_key(line) + current = key + if key is not None: + self.index.setdefault(key.lower(), number) + elif line == "#link" and current is not None: + target = self.link_target(number, root) + if target: + self.links[current.lower()] = target + + def link_target(self, number, root): + """Where the link key whose "#link" line is at number leads, relative to this file's root.""" + for at in range(number + 1, min(number + 8, len(self.lines))): + line = self.lines[at] + if line.startswith("["): + return None + if line.startswith('"SymbolicLinkValue"=hex(6):'): + data = line.split(":", 1)[1] + while data.endswith("\\") and at + 1 < len(self.lines): + at += 1 + data = data[:-1] + self.lines[at].strip() + try: + raw = bytes(int(part, 16) for part in data.split(",") if part.strip()) + target = raw.decode("utf-16-le").strip("\\") + except ValueError: + return None + if root and target.lower().startswith(root + "\\"): + return target[len(root) + 1:] + return None + return None + + def resolve(self, key): + """The key Wine really keeps key in: a path through a link key leads to the link's target.""" + key = key.strip("\\") + for _ in range(8): + lower = key.lower() + for link, target in self.links.items(): + if lower == link or lower.startswith(link + "\\"): + key = target + key[len(link):] + break + else: + return key + return key + + @staticmethod + def parse_key(line): + end, i = None, 1 + while i < len(line): + if line[i] == "\\": + i += 2 + continue + if line[i] == "]": + end = i + break + i += 1 + return None if end is None else reg_unescape(line[1:end]) + + def section(self, key): + """(start, end) line numbers of the key's values, or None.""" + start = self.index.get(self.resolve(key).lower()) + if start is None: + return None + end = start + 1 + while end < len(self.lines) and not self.lines[end].startswith("["): + end += 1 + return start + 1, end + + @staticmethod + def value_name(line): + if line.startswith("@="): + return "" + match = re.match(r'^"((?:[^"\\]|\\.)*)"=', line) + return reg_unescape(match.group(1)).lower() if match else None + + def find(self, key, name): + """(first, last + 1) of the value's lines, or None.""" + span = self.section(key) + if span is None: + return None + wanted = name.lower() + number = span[0] + while number < span[1]: + line = self.lines[number] + last = number + while self.lines[last].endswith("\\") and last + 1 < span[1]: + last += 1 + if self.value_name(line) == wanted: + return number, last + 1 + number = last + 1 + return None + + def get(self, key, name): + found = self.find(key, name) + return None if found is None else "\n".join(self.lines[found[0]:found[1]]) + + def ensure_key(self, key): + key = self.resolve(key) + if key.lower() in self.index: + return + now = time.time() + while self.lines and self.lines[-1] == "": + self.lines.pop() + self.lines += ["", "%s %d" % (reg_key_line(key), int(now)), + "#time=%x" % (int(now * 10000000) + 116444736000000000)] + self.index[key.lower()] = len(self.lines) - 2 + self.lines.append("") + self.changed = True + + def put(self, key, name, raw): + """Sets the value's line(s) to raw, or removes the value when raw is None; True if that changed it.""" + found = self.find(key, name) + if raw is None: + if found is None: + return False + del self.lines[found[0]:found[1]] + self.shift(found[0], found[0] - found[1]) + self.changed = True + return True + new = raw.split("\n") + if found is not None: + if self.lines[found[0]:found[1]] == new: + return False + self.lines[found[0]:found[1]] = new + self.shift(found[0], len(new) - (found[1] - found[0])) + else: + self.ensure_key(key) + start, end = self.section(key) + while end > start and self.lines[end - 1] == "": + end -= 1 + self.lines[end:end] = new + self.shift(end, len(new)) + self.changed = True + return True + + def shift(self, at, by): + if by: + for key, number in self.index.items(): + if number >= at: + self.index[key] = number + by + + def save(self): + if not self.changed: + return + temp = self.path.with_name("." + self.path.name + ".droiddeck") + with open(temp, "w", encoding="utf-8", errors="surrogateescape", newline="") as out: + out.write("\n".join(self.lines)) + shutil.copymode(self.path, temp) + os.replace(temp, self.path) + self.changed = False + + +def list_line(name, current, item, separator, add, at_end=True): + """current (a string value line) with item added to or taken out of its list, None if it had + nothing else; a value that is not a string is left as it is.""" + text = reg_string(current) if current is not None else "" + if text is None: + return current + items = [part for part in text.split(separator) if part and part.lower() != item.lower()] + if add: + items = items + [item] if at_end else [item] + items + if not items: + return None + expand = current is None or "=str(2):" in current + return reg_value_line(name, "expand_sz" if expand else "sz", separator.join(items)) + + +def apply_registry(pfx, values, state): + """Writes the picked components' registry values into the prefix and takes out the ones of + components turned off: a value goes back to what it was before, an entry added to a list such + as PATH just leaves the list. Returns (values written, notes).""" + files = {} + for hive, name in HIVES.items(): + if (pfx / name).is_file(): + files[hive] = RegistryFile(pfx / name) + old = state.get("registry") if isinstance(state.get("registry"), dict) else {} + keep, notes, written, waiting = {}, [], 0, 0 + for cid, value in values: + reg = files.get(value["hive"]) + if reg is None: + waiting += 1 + continue + if value["type"] == "key": + reg.ensure_key(value["key"]) + continue + name = value.get("name") or "" + ident = "%s\t%s\t%s" % (value["hive"], value["key"].lower(), name.lower()) + current = reg.get(value["key"], name) + record = keep.get(ident) or (old.get(ident) if isinstance(old.get(ident), dict) else None) or {"prev": current} + if value["type"] in ("append", "prepend"): + line = list_line(name, current, str(value.get("data", "")), value.get("separator") or ";", True, + value["type"] == "append") + record = dict(record, item=str(value.get("data", "")), separator=value.get("separator") or ";") + else: + line = reg_value_line(name, value["type"], value.get("data")) + if line != current and reg.put(value["key"], name, line): + written += 1 + keep[ident] = dict(record, cid=cid, hive=value["hive"], key=value["key"], name=name) + for ident, record in old.items(): + if ident in keep or not isinstance(record, dict) or not isinstance(record.get("key"), str): + continue + reg = files.get(record.get("hive")) + if reg is None: + keep[ident] = record + continue + name = record.get("name") or "" + if "item" in record: + line = list_line(name, reg.get(record["key"], name), record["item"], record.get("separator") or ";", False) + else: + line = record.get("prev") + if reg.put(record["key"], name, line): + written += 1 + for reg in files.values(): + reg.save() + state["registry"] = keep + if waiting: + notes.append("%d registry value(s) wait for the prefix: they go in on the next launch" % waiting) + return written, notes + def load_state(compat): try: with open(compat / STATE, encoding="utf-8") as source: @@ -167,19 +524,21 @@ def apply(compat_path, app_id, selection=SELECTION, store=STORE): pfx = compat / "pfx" ids = wanted(app_id, selection) state = load_state(compat) - if not ids and not state["files"]: + if not ids and not state["files"] and not state.get("registry"): return [], [] notes, overrides, keep = [], [], {} copied = 0 installed = [] + values = [] for cid in expand(store, ids): found = component(store, cid) if found is None: notes.append("%s is not installed; skipped" % cid) continue installed.append(cid) - names, files, _ = found + names, files, _, registry = found overrides += names + values += [(cid, value) for value in registry] for rel, src in files: # A file this prefix already has from us is ours to replace; anything else is kept. if place(src, pfx / rel, None if rel in state["files"] else compat / BACKUP / rel): @@ -206,10 +565,16 @@ def apply(compat_path, app_id, selection=SELECTION, store=STORE): except FileNotFoundError: pass compat.mkdir(parents=True, exist_ok=True) - save_state(compat, {"files": keep, "components": installed}) - if copied or removed or restored: + new_state = {"files": keep, "components": installed, "registry": state.get("registry", {})} + written = 0 + if values or new_state["registry"]: + written, registry_notes = apply_registry(pfx, values, new_state) + notes += registry_notes + save_state(compat, new_state) + if copied or removed or restored or written: note = "components %s: %d file(s) placed, %d removed" % (",".join(ids) or "none", copied, removed) - notes.append(note + (", %d put back as they were" % restored if restored else "")) + note += ", %d put back as they were" % restored if restored else "" + notes.append(note + (", %d registry value(s) written" % written if written else "")) return overrides, notes diff --git a/tools/msitools/licenses/GPL-2 b/tools/msitools/licenses/GPL-2 new file mode 100644 index 0000000000..9efa6fbc96 --- /dev/null +++ b/tools/msitools/licenses/GPL-2 @@ -0,0 +1,338 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, see . + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Moe Ghoul, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/tools/msitools/licenses/GPL-3 b/tools/msitools/licenses/GPL-3 new file mode 100644 index 0000000000..f288702d2f --- /dev/null +++ b/tools/msitools/licenses/GPL-3 @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/tools/msitools/licenses/LGPL-2.1 b/tools/msitools/licenses/LGPL-2.1 new file mode 100644 index 0000000000..f6683e74e0 --- /dev/null +++ b/tools/msitools/licenses/LGPL-2.1 @@ -0,0 +1,501 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, see . + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Moe Ghoul, President of Vice + +That's all there is to it! diff --git a/tools/msitools/licenses/NOTICE b/tools/msitools/licenses/NOTICE new file mode 100644 index 0000000000..ee62a42c51 --- /dev/null +++ b/tools/msitools/licenses/NOTICE @@ -0,0 +1,14 @@ +Windows components installer tools (usr/local/lib/droiddeck-msitools), Arch Linux ARM's aarch64 +builds, unchanged: + + msiinfo, libmsi-1.0.so.0 msitools 0.106 GPL-2.0-or-later / LGPL-2.1-or-later + https://gitlab.gnome.org/GNOME/msitools + libgsf-1.so.114 libgsf 1.14.60 LGPL-2.1-only + https://gitlab.gnome.org/GNOME/libgsf + libgcab-1.0.so.0 gcab 1.6 LGPL-2.1-or-later + https://gitlab.gnome.org/GNOME/gcab + cabextract cabextract 1.11 GPL-3.0-or-later + https://www.cabextract.org.uk/ + +The packages and their sources: https://github.com/Droid-Deck/DroidDeck/releases/tag/msitools-0.106-r1, +https://github.com/archlinuxarm/PKGBUILDs. The licence texts are beside this file. diff --git a/tools/msitools/packages.txt b/tools/msitools/packages.txt new file mode 100644 index 0000000000..5a04b4c626 --- /dev/null +++ b/tools/msitools/packages.txt @@ -0,0 +1,12 @@ +# What droiddeck-msi-install runs: msitools' msiinfo reads a Windows Installer package's tables +# and streams, cabextract unpacks its cabinets (every compression a cabinet can use, which gcab +# alone cannot). Arch Linux ARM's aarch64 packages, hosted unchanged on this repo's +# msitools-0.106-r1 release because the mirror keeps only the newest of each. CI fetches each, +# checks the sha256 and stages the files below into the apk under usr/local/lib/droiddeck-msitools; +# SessionFiles copies them into the runtime at every launch. Everything else they need (glib, gio, +# libxml2.so.16, zlib, bzip2, libgcc_s) is in the runtime already. +# sha256 url +4ab93d800b320d19c6c1090e21b69e5764ee241b6370012459e0c5df03739a8d https://github.com/Droid-Deck/DroidDeck/releases/download/msitools-0.106-r1/msitools-0.106-3-aarch64.pkg.tar.xz +4028f44d83b2956ba2931d32aee8cceecbd6481e2febf86a3b6bfed69ef403d5 https://github.com/Droid-Deck/DroidDeck/releases/download/msitools-0.106-r1/libgsf-1.14.60-1-aarch64.pkg.tar.xz +3d7bd103313cb36d6cb703a5e583363e56ff255f105bcc0727916d195967976d https://github.com/Droid-Deck/DroidDeck/releases/download/msitools-0.106-r1/gcab-1.6-2-aarch64.pkg.tar.xz +87fe375a22de1519982234ce99f909ae13c06500784baaa1e8d7a0c0be0d14ee https://github.com/Droid-Deck/DroidDeck/releases/download/msitools-0.106-r1/cabextract-1.11-3-aarch64.pkg.tar.xz diff --git a/tools/tests/test_msi_install.py b/tools/tests/test_msi_install.py new file mode 100644 index 0000000000..16e8807f1f --- /dev/null +++ b/tools/tests/test_msi_install.py @@ -0,0 +1,292 @@ +import json +import runpy +import tempfile +import unittest +from pathlib import Path + +BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin" +MSI = runpy.run_path(str(BIN / "droiddeck-msi-install")) +COMPONENTS = runpy.run_path(str(BIN / "droiddeck-wincomponents")) + + +class FakePackage: + """A package's tables in memory, as msiinfo would give them.""" + + def __init__(self, tables, summary=None): + self.path = "fake.msi" + self.tables = tables + self.table_names = set(tables) + self.summary = summary or {"template": "Intel;1033"} + + def table(self, name): + return self.tables.get(name, []) + + def stream(self, name, target): + raise AssertionError("no cabinets in a fake package") + + +def rows(columns, *values): + names = columns.split() + return [dict(zip(names, value)) for value in values] + + +def installer(tables, out="/tmp/unused", summary=None): + return MSI["Installer"]("fake.msi", out, FakePackage(tables, summary)) + + +class ToolsTest(unittest.TestCase): + def test_the_tools_find_their_own_libraries(self): + paths = MSI["tool_env"]()["LD_LIBRARY_PATH"].split(":") + self.assertEqual(paths[0], str(MSI["TOOLS"])) + + +class ConditionsTest(unittest.TestCase): + def evaluate(self, text, props=None, default="default"): + return MSI["Conditions"](props or {"VersionNT": "603", "VersionNT64": "603"}).evaluate(text, default) + + def test_windows_10_64_bit_passes_the_usual_checks(self): + self.assertTrue(self.evaluate("(VersionNT > 501) OR (VersionNT = 501 AND ServicePackLevel >= 2)")) + self.assertTrue(self.evaluate("VersionNT64")) + self.assertTrue(self.evaluate("VersionNT AND (VersionNT >= 500)")) + self.assertFalse(self.evaluate("(VersionNT < 501) or Version9X")) + self.assertFalse(self.evaluate("(VersionNT < 600) or Version9X")) + + def test_unset_properties_are_false_and_not_inverts(self): + self.assertFalse(self.evaluate("NEWERVERSIONDETECTED")) + self.assertTrue(self.evaluate("NOT Installed")) + self.assertFalse(self.evaluate("Installed AND NOT REINSTALL")) + + def test_strings_and_case_folding(self): + props = {"A": "Hello"} + self.assertTrue(self.evaluate('A = "Hello"', props)) + self.assertFalse(self.evaluate('A = "hello"', props)) + self.assertTrue(self.evaluate('A ~= "hello"', props)) + self.assertTrue(self.evaluate('A >< "ell"', props)) + + def test_component_and_feature_states(self): + conditions = MSI["Conditions"]({}, lambda f: 3 if f == "Main" else None, lambda c: 3 if c == "Dll" else None) + self.assertTrue(conditions.evaluate("&Main = 3")) + self.assertTrue(conditions.evaluate("$Dll = 3")) + self.assertFalse(conditions.evaluate("$Other = 3")) + + def test_nonsense_gives_the_default(self): + self.assertEqual(self.evaluate("(VersionNT >"), "default") + + +class LayoutTest(unittest.TestCase): + def test_folders_resolve_as_on_64_bit_windows(self): + inst = installer({ + "Directory": rows("Directory Directory_Parent DefaultDir", + ("TARGETDIR", "", "SourceDir"), + ("ProgramFilesFolder", "TARGETDIR", "PFiles"), + ("INSTALLDIR", "ProgramFilesFolder", "xendvbfk|Microsoft XNA"), + ("Same", "INSTALLDIR", "."), + ("SystemFolder", "TARGETDIR", "SysFldr"), + ("TempFolder", "TARGETDIR", "TmpFldr"), + ("Temp2", "TempFolder", "x")), + }) + self.assertEqual(inst.directory("INSTALLDIR"), "drive_c/Program Files (x86)/Microsoft XNA") + self.assertEqual(inst.directory("Same"), "drive_c/Program Files (x86)/Microsoft XNA") + self.assertEqual(inst.directory("SystemFolder"), "drive_c/windows/syswow64") + self.assertIsNone(inst.directory("Temp2")) + + def test_a_folder_set_by_a_custom_action_wins(self): + inst = installer({ + "Directory": rows("Directory Directory_Parent DefaultDir", + ("TARGETDIR", "", "SourceDir"), + ("WinVC", "TARGETDIR", "Win"), + ("SysVC", "WinVC", "System")), + "CustomAction": rows("Action Type Source Target", + ("SetSys", "51", "SysVC", "[SystemFolder]"), + ("RunIt", "3154", "File", "/silent")), + "InstallExecuteSequence": rows("Action Condition Sequence", ("SetSys", "", "2"), ("RunIt", "NOT Installed", "6000")), + }) + inst.run_set_actions() + self.assertEqual(inst.directory("SysVC"), "drive_c/windows/syswow64") + self.assertIn("RunIt", inst.notes[0]) + + def test_conditions_pick_components_and_features(self): + inst = installer({ + "Feature": rows("Feature Feature_Parent Level", ("Main", "", "1"), ("X64", "", "0"), ("Off", "", "0")), + "Condition": rows("Feature_ Level Condition", ("X64", "1", "VersionNT64")), + "Component": rows("Component Directory_ Attributes Condition", + ("Up", "TARGETDIR", "0", "(VersionNT >= 600)"), + ("Down", "TARGETDIR", "0", "(VersionNT < 600) or Version9X"), + ("Wide", "TARGETDIR", "256", ""), + ("Never", "TARGETDIR", "0", "")), + "FeatureComponents": rows("Feature_ Component_", ("Main", "Up"), ("Main", "Down"), ("X64", "Wide"), ("Off", "Never")), + }) + inst.select() + self.assertEqual(inst.included_components, {"Up", "Wide"}) + + def test_global_assembly_paths(self): + with tempfile.TemporaryDirectory() as tmp: + dll = Path(tmp) / "a.dll" + dll.write_bytes(b"MZ....BSJB" + b"\0" * 8 + (12).to_bytes(4, "little") + b"v4.0.30319\0\0") + inst = installer({}) + folder = inst.gac_folder({"name": "Microsoft.Xna.Framework", "version": "4.0.0.00000", "culture": "neutral", + "publickeytoken": "842CF8BE1DE50553", "processorarchitecture": "x86"}, dll) + self.assertEqual(folder, "drive_c/windows/Microsoft.NET/assembly/GAC_32/Microsoft.Xna.Framework/v4.0_4.0.0.0__842cf8be1de50553") + dll.write_bytes(b"MZ....BSJB" + b"\0" * 8 + (12).to_bytes(4, "little") + b"v2.0.50727\0\0") + folder = inst.gac_folder({"name": "Old", "version": "1.0.0.0", "publickeytoken": "AB", "processorarchitecture": "MSIL"}, dll) + self.assertEqual(folder, "drive_c/windows/assembly/GAC_MSIL/Old/1.0.0.0__ab") + + def test_side_by_side_names_follow_wines_winsxs(self): + names = MSI["Installer"].sxs_names + ident = {"name": "Microsoft.VC80.CRT", "publickeytoken": "1fc8b3b9a1e18e3b", "version": "8.0.50727.762", + "processorarchitecture": "x86", "type": "win32"} + self.assertEqual(names(ident), ("assembly", "x86_microsoft.vc80.crt_1fc8b3b9a1e18e3b_8.0.50727.762_none_deadbeef", "8.0.50727.762")) + policy = dict(ident, name="policy.8.0.Microsoft.VC80.CRT", type="win32-policy") + self.assertEqual(names(policy)[1], "drive_c/windows/winsxs/policies/x86_microsoft.vc80.crt_1fc8b3b9a1e18e3b_none_deadbeef") + + def test_registry_values_go_to_the_32_bit_view_for_32_bit_components(self): + inst = installer({ + "Directory": rows("Directory Directory_Parent DefaultDir", ("TARGETDIR", "", "SourceDir"), + ("CommonV2Dir", "TARGETDIR", "XNA")), + "Component": rows("Component Directory_ Attributes Condition", ("C32", "TARGETDIR", "0", ""), + ("C64", "TARGETDIR", "256", "")), + "Registry": rows("Registry Root Key Name Value Component_", + ("r1", "2", "Software\\Microsoft\\XNA\\Framework\\v4.0", "Installed", "#1", "C32"), + ("r2", "2", "Software\\Microsoft\\XNA\\Framework\\v4.0", "NativeLibraryPath", "[CommonV2Dir]", "C32"), + ("r3", "0", "CLSID\\{X}\\InprocServer32", "", "a[~]b", "C32"), + ("r4", "2", "SOFTWARE\\AGEIA", "Bin", "#x0A0b", "C64"), + ("r5", "2", "Software\\Keys", "+", "", "C64")), + "Environment": rows("Environment Name Value Component_", ("e", "=-*PATH", "[CommonV2Dir];[~]", "C32")), + }) + inst.select() + inst.install_registry() + got = {(v["key"], v["name"]): (v["type"], v["data"]) for v in inst.registry} + self.assertEqual(got[("Software\\Wow6432Node\\Microsoft\\XNA\\Framework\\v4.0", "Installed")], ("dword", 1)) + self.assertEqual(got[("Software\\Wow6432Node\\Microsoft\\XNA\\Framework\\v4.0", "NativeLibraryPath")], ("sz", "C:\\XNA\\")) + self.assertEqual(got[("Software\\Wow6432Node\\Classes\\CLSID\\{X}\\InprocServer32", "")], ("multi_sz", ["a", "b"])) + self.assertEqual(got[("SOFTWARE\\AGEIA", "Bin")], ("binary", "0a0b")) + self.assertEqual(got[("Software\\Keys", None)], ("key", None)) + env = [v for v in inst.registry if v["name"] == "PATH"][0] + self.assertEqual((env["key"], env["type"], env["data"]), + ("System\\CurrentControlSet\\Control\\Session Manager\\Environment", "prepend", "C:\\XNA\\")) + + +SYSTEM_REG = '''WINE REGISTRY Version 2 +;; All keys relative to REGISTRY\\\\Machine + +#arch=win64 + +[Software\\\\Classes\\\\Wow6432Node\\\\CLSID] 1791145014 +#time=1dd543d4c84d0a2 + +[Software\\\\Wow6432Node\\\\Classes] 1791145014 +#time=1dd543d4c84d0a2 +#link +"SymbolicLinkValue"=hex(6):5c,00,52,00,65,00,67,00,69,00,73,00,74,00,72,00,79,00,\\ + 5c,00,4d,00,61,00,63,00,68,00,69,00,6e,00,65,00,5c,00,53,00,6f,00,66,00,74,00,\\ + 77,00,61,00,72,00,65,00,5c,00,43,00,6c,00,61,00,73,00,73,00,65,00,73,00,5c,00,\\ + 57,00,6f,00,77,00,36,00,34,00,33,00,32,00,4e,00,6f,00,64,00,65,00 + +[Software\\\\Wow6432Node\\\\Old] 1791145014 +#time=1dd543d4c84d0a2 +"Kept"="mine" +"Version"="1.0" + +[System\\\\ControlSet001\\\\Control\\\\Session Manager\\\\Environment] 1791169864 +#time=1dd547728528ad2 +"PATH"=str(2):"%SystemRoot%\\\\system32;%SystemRoot%" + +[System\\\\CurrentControlSet] 1791145014 +#time=1dd543d4c84d0a2 +#link +"SymbolicLinkValue"=hex(6):5c,00,52,00,65,00,67,00,69,00,73,00,74,00,72,00,79,00,\\ + 5c,00,4d,00,61,00,63,00,68,00,69,00,6e,00,65,00,5c,00,53,00,79,00,73,00,74,00,\\ + 65,00,6d,00,5c,00,43,00,6f,00,6e,00,74,00,72,00,6f,00,6c,00,53,00,65,00,74,00,\\ + 30,00,30,00,31,00 +''' + + +class RegistryApplyTest(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + root = Path(self.tmp.name) + self.store = root / "store" + self.compat = root / "compatdata/42" + self.pfx = self.compat / "pfx" + self.selection = root / "sel.json" + folder = self.store / "xna40" + (folder / "drive_c/Program Files (x86)/Microsoft XNA").mkdir(parents=True) + (folder / "drive_c/Program Files (x86)/Microsoft XNA/xna.dll").write_bytes(b"xna") + (folder / "component.json").write_text(json.dumps({"id": "xna40", "overrides": []})) + (folder / "registry.json").write_text(json.dumps({"version": 1, "values": [ + {"hive": "HKLM", "key": "Software\\Wow6432Node\\Old", "name": "Version", "type": "sz", "data": "4.0"}, + {"hive": "HKLM", "key": "Software\\Wow6432Node\\Classes\\CLSID\\{X}", "name": "", "type": "sz", "data": "Thing"}, + {"hive": "HKLM", "key": "Software\\Wow6432Node\\New", "name": "Installed", "type": "dword", "data": 1}, + {"hive": "HKLM", "key": "System\\CurrentControlSet\\Control\\Session Manager\\Environment", "name": "PATH", + "type": "prepend", "data": "C:\\PhysX", "separator": ";"}, + {"hive": "HKCU", "key": "Software\\Game", "name": "Opt", "type": "dword", "data": 2}, + ]})) + + def tearDown(self): + self.tmp.cleanup() + + def make_prefix(self): + (self.pfx / "drive_c/program files (x86)").mkdir(parents=True) + (self.pfx / "system.reg").write_text(SYSTEM_REG) + (self.pfx / "user.reg").write_text("WINE REGISTRY Version 2\n;; All keys relative to REGISTRY\\\\User\\\\S-1-5-21\n\n#arch=win64\n") + + def apply(self, *ids): + self.selection.write_text(json.dumps({"version": 1, "games": {"42": list(ids)}})) + return COMPONENTS["apply"](self.compat, "42", self.selection, self.store) + + def test_values_follow_wines_links_and_come_out_again(self): + self.make_prefix() + self.apply("xna40") + text = (self.pfx / "system.reg").read_text() + self.assertIn('"Version"="4.0"', text) + self.assertIn('"Kept"="mine"', text) + # Through the Wow6432Node\Classes link into the shared Classes\Wow6432Node key, never under the link. + self.assertIn('[Software\\\\Classes\\\\Wow6432Node\\\\CLSID\\\\{X}]', text) + self.assertNotIn('[Software\\\\Wow6432Node\\\\Classes\\\\CLSID', text) + self.assertIn('"PATH"=str(2):"C:\\\\PhysX;%SystemRoot%\\\\system32;%SystemRoot%"', text) + self.assertNotIn("[System\\\\CurrentControlSet\\\\", text) + self.assertIn('"Opt"=dword:00000002', (self.pfx / "user.reg").read_text()) + # The prefix's own spelling of Program Files (x86) is kept. + self.assertTrue((self.pfx / "drive_c/program files (x86)/Microsoft XNA/xna.dll").is_file()) + self.assertFalse((self.pfx / "drive_c/Program Files (x86)").exists()) + + before = (self.pfx / "system.reg").read_text() + _, notes = self.apply("xna40") + self.assertEqual((self.pfx / "system.reg").read_text(), before) + self.assertEqual(notes, []) + + self.apply() + text = (self.pfx / "system.reg").read_text() + self.assertIn('"Version"="1.0"', text) + self.assertNotIn('"Installed"=dword:00000001', text) + self.assertNotIn("Thing", text) + self.assertIn('"PATH"=str(2):"%SystemRoot%\\\\system32;%SystemRoot%"', text) + self.assertNotIn('"Opt"', (self.pfx / "user.reg").read_text()) + self.assertFalse((self.pfx / "drive_c/program files (x86)/Microsoft XNA/xna.dll").exists()) + + def test_turning_off_keeps_what_others_added_to_path_since(self): + self.make_prefix() + self.apply("xna40") + reg = self.pfx / "system.reg" + reg.write_text(reg.read_text().replace("C:\\\\PhysX;", "C:\\\\PhysX;C:\\\\Other;")) + self.apply() + self.assertIn('"PATH"=str(2):"C:\\\\Other;%SystemRoot%\\\\system32;%SystemRoot%"', reg.read_text()) + + def test_values_wait_for_a_prefix_proton_has_not_made(self): + _, notes = self.apply("xna40") + self.assertTrue(any("wait for the prefix" in note for note in notes)) + self.assertFalse((self.pfx / "system.reg").exists()) + self.make_prefix() + self.apply("xna40") + self.assertIn('"Version"="4.0"', (self.pfx / "system.reg").read_text()) + + def test_registry_lines_round_trip(self): + line = COMPONENTS["reg_value_line"]('we"ird\\', "sz", 'a"b\\c\u00e9') + self.assertEqual(line, '"we\\"ird\\\\"="a\\"b\\\\c\\x00e9"') + self.assertEqual(COMPONENTS["reg_string"](line), 'a"b\\c\u00e9') + self.assertEqual(COMPONENTS["reg_value_line"]("m", "multi_sz", ["a", "b"]), '"m"=str(7):"a\\0b\\0"') + self.assertEqual(COMPONENTS["reg_value_line"]("", "binary", "0a0b"), "@=hex:0a,0b") + + +if __name__ == "__main__": + unittest.main()