#!/usr/bin/python3 import base64 import binascii import json import os import re import shlex import shutil import stat import sys import time import subprocess import tempfile import hashlib import threading from pathlib import Path LAUNCHER = ".droiddeck-launch.bat" SIDECAR = ".droiddeck-store.json" EPIC_CODE = ".droiddeck-epic-code" EPIC_ARGS = ".droiddeck-epic-args" EPIC_CLIENT = "/usr/local/bin/droiddeck-epic" EPIC_CLIENT_CURRENT = ".local/share/droiddeck-epic/current.json" EPIC_HANDLED = "DROIDDECK_EPIC_HANDLED" CLIENT_TIMEOUT = 150.0 TIMEOUT = 5.0 STALE_SECONDS = 300 SERVER_WAIT = 8.0 BROWSER = "/usr/local/bin/droiddeck-open-url" EOS_KEY = "[Software\\\\Epic Games\\\\EOS]" BROWSER_KEY = "[Software\\\\Wine\\\\WineBrowser]" def log(line): print("droiddeck-store-launch: " + line, file=sys.stderr, flush=True) MAX_DEPTH = 6 def sidecar_at(folder): try: sidecar = json.loads((folder / SIDECAR).read_text()) except (OSError, ValueError): return None if not isinstance(sidecar, dict) or not sidecar.get("store") or not sidecar.get("id"): return None return sidecar def find_store_game(argv, depth=MAX_DEPTH): for raw in argv: arg = raw.strip().strip('"').strip("'").replace("\\", "/") low = arg.lower() if not (low.endswith(LAUNCHER) or low.endswith(".exe") or low.endswith(".bat")) or "/" not in arg: continue folder = Path(arg).parent for _ in range(depth): sidecar = sidecar_at(folder) if sidecar is not None: return folder, sidecar if folder.parent == folder: break folder = folder.parent return None def store_launcher(path): real = os.path.realpath(path) for start in dict.fromkeys([os.path.abspath(path), real]): found = find_store_game([start], depth=len(Path(start).parts)) if found is None: continue folder, sidecar = found launcher, exe = str(sidecar.get("launcher") or ""), str(sidecar.get("exe") or "") if not launcher or not exe or (folder / launcher).is_symlink() or not (folder / launcher).is_file(): continue if os.path.realpath(folder / exe).lower() == real.lower(): return str(folder / launcher) return None def drop_stale(folder, now=None): code = folder / EPIC_CODE try: if (now if now is not None else time.time()) - code.stat().st_mtime > STALE_SECONDS: code.unlink() return True except OSError: pass return False def client_wanted(): home = os.environ.get("HOME") or "/root" return os.access(EPIC_CLIENT, os.X_OK) and os.path.isfile(os.path.join(home, EPIC_CLIENT_CURRENT)) def through_client(folder, sidecar, timeout=CLIENT_TIMEOUT): extra = sidecar.get("extra") if isinstance(sidecar.get("extra"), dict) else {} namespace, item = str(extra.get("namespace") or ""), str(extra.get("catalogItemId") or "") if not namespace or not item: return "no-catalog-ids" command = [EPIC_CLIENT, "launch", "--app", str(sidecar.get("id")), "--namespace", namespace, "--item", item, "--folder", str(folder), "--owner", str(os.getppid()), "--timeout", str(int(timeout))] try: run = subprocess.run(command, stdout=subprocess.PIPE, stdin=subprocess.DEVNULL, timeout=timeout + 30) answer = json.loads(run.stdout.decode("utf-8", "replace").strip().splitlines()[-1]) except (OSError, ValueError, IndexError, subprocess.TimeoutExpired) as error: return "error-" + type(error).__name__ if not isinstance(answer, dict): return "no-answer" if answer.get("ok") and (folder / EPIC_ARGS).is_file(): return "ok" return str(answer.get("reason") or "failed") def ask(channel, request, timeout=TIMEOUT): req_dir, resp_dir = channel / "req", channel / "resp" req_dir.mkdir(parents=True, exist_ok=True) resp_dir.mkdir(parents=True, exist_ok=True) rid = "%d-%d" % (os.getpid(), int(time.time() * 1000)) tmp = req_dir / (rid + ".json.tmp") tmp.write_text(json.dumps(request)) os.rename(tmp, req_dir / (rid + ".json")) answer = resp_dir / (rid + ".json") deadline = time.monotonic() + timeout while time.monotonic() < deadline: try: value = json.loads(answer.read_text()) answer.unlink() return value except (OSError, ValueError): time.sleep(0.05) try: (req_dir / (rid + ".json")).unlink() except OSError: pass return None def windows_path(unix): return "Z:" + unix.replace("/", "\\") def reg_escape(value): return value.replace("\\", "\\\\").replace('"', '\\"') def set_value(reg, key, name, value, now=None): if not reg.is_file(): return False line = '"%s"="%s"' % (name, reg_escape(value)) inside, last = False, None for row in reg.read_text(errors="replace").splitlines(): if row.startswith("["): inside = row.startswith(key + " ") or row == key elif inside and row.startswith('"%s"=' % name): last = row if last == line: return True with open(reg, "a") as out: out.write("\n%s %d\n%s\n" % (key, int(now if now is not None else time.time()), line)) return True def remove_value(reg, key, name): if not reg.is_file(): return False rows, inside, dropped = [], False, False for row in reg.read_text(errors="replace").splitlines(keepends=True): if row.startswith("["): inside = row.startswith(key + " ") or row.rstrip("\n") == key elif inside and row.startswith('"%s"=' % name): dropped = True continue rows.append(row) if dropped: tmp = reg.with_name(reg.name + ".dd-new") tmp.write_text("".join(rows)) os.replace(tmp, reg) return dropped def options(sidecar): e = sidecar.get("epic") if isinstance(sidecar.get("epic"), dict) else {} return {"eos": e.get("eos", True) is not False, "offline": e.get("offline", False) is True} def server_socket(pfx): try: st = os.stat(pfx) except OSError: return None base = os.environ.get("DD_WINE_SERVER_BASE") or "/tmp/.wine-%d" % os.getuid() return Path(base) / ("server-%x-%x" % (st.st_dev, st.st_ino)) / "socket" def wait_for_server(pfx, timeout=SERVER_WAIT): sock = server_socket(pfx) if sock is None: return True deadline = time.monotonic() + timeout while sock.exists() and time.monotonic() < deadline: time.sleep(0.1) return not sock.exists() def has_value(reg, key, name, value=None): if not reg.is_file(): return False inside, last = False, None for row in reg.read_text(errors="replace").splitlines(): if row.startswith("["): inside = row.startswith(key + " ") or row == key elif inside and row.startswith('"%s"=' % name): last = row if last is None: return False return value is None or last == '"%s"="%s"' % (name, reg_escape(value)) def provision_prefix(compat_data, wait=SERVER_WAIT): if not compat_data: return "no-prefix" pfx = Path(compat_data) / "pfx" reg = pfx / "user.reg" if not reg.is_file(): return "prefix-not-created" busy = not wait_for_server(pfx, wait) set_value(reg, BROWSER_KEY, "Browsers", BROWSER + ",xdg-open") removed = remove_value(reg, EOS_KEY, "OverlayPath") state = "browser-set" if has_value(reg, BROWSER_KEY, "Browsers", BROWSER + ",xdg-open") else "browser-not-written" if removed: state += " old-overlay-removed" return state + (" server-running" if busy else "") def create_prefix(compat_data, proton, timeout=120): if not compat_data or not proton or not Path(proton).is_file(): return "no-proton" reg = Path(compat_data) / "pfx/user.reg" if reg.is_file(): return "present" try: Path(compat_data).mkdir(parents=True, exist_ok=True) subprocess.run([proton, "run", "cmd.exe", "/d", "/c", "exit"], stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=timeout) except subprocess.TimeoutExpired: return "timeout" except OSError: return "failed" return "created" if reg.is_file() else "failed" CLOUD_TIMEOUT = 15.0 CLOUD_STORES = ("gog", "epic") STORE_GAME = 10 RAN = 11 RAN_FAILED = 12 BATTLENET = "/usr/local/bin/droiddeck-battlenet" BATTLENET_EXE = re.compile(r"(?i)/compatdata/2596113170/pfx/drive_c/Program Files \(x86\)/Battle\.net/Battle\.net\.exe$") BATTLENET_LAUNCH = re.compile(r'(?i)^--exec=\s*"?launch\s+([A-Za-z0-9_]{1,16})"?$') def battlenet(argv, env=os.environ): if env.get("DD_BATTLENET"): return None exe, code = False, None for raw in argv: arg = raw.strip().strip('"').strip("'") if BATTLENET_EXE.search(arg.replace("\\", "/")): exe = True found = BATTLENET_LAUNCH.match(arg) if found: code = found.group(1) if not exe: return None return [BATTLENET, "launch", code] if code else [BATTLENET, "open"] def cloud_on(sidecar): return str(sidecar.get("store")) in CLOUD_STORES and sidecar.get("cloud", True) is not False def exited(argv, code=0): found = find_store_game(argv) launch_dir = os.environ.get("DD_LAUNCH_DIR", "") if found is not None and launch_dir and str(found[1].get("store")) == "rockstar": ask(Path(launch_dir) / "stores", {"op": "rockstar-exited", "store": "rockstar", "id": str(found[1].get("id"))}, timeout=1.0) compat_data = os.environ.get("STEAM_COMPAT_DATA_PATH") if compat_data: (Path(compat_data) / "pfx" / ROCKSTAR_FOLDER / "launch.json").unlink(missing_ok=True) for line in rockstar_launcher_log(compat_data): log("rockstar launcher: " + line) return 0 if found is not None and str(found[1].get("store")) == "epic" and os.environ.get(EPIC_HANDLED) != "1" \ and os.access(EPIC_CLIENT, os.X_OK): try: subprocess.run([EPIC_CLIENT, "exited", "--code", str(code)], stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, timeout=10) except (OSError, subprocess.TimeoutExpired): pass if found is not None and launch_dir and str(found[1].get("store")) == "ea": ask(Path(launch_dir) / "stores", {"op": "ea-exited", "store": "ea", "id": str(found[1].get("id"))}, timeout=1.0) log("ea %s exited" % found[1].get("id")) return 0 if found is None or not launch_dir or not cloud_on(found[1]): return 0 store, game = str(found[1].get("store")), str(found[1].get("id")) ask(Path(launch_dir) / "stores", {"op": "cloud-up", "store": store, "id": game}, timeout=1.0) log("cloud %s %s up requested" % (store, game)) return 0 UBISOFT_DIR = "drive_c/Program Files (x86)/Ubisoft/Ubisoft Game Launcher" UBISOFT_WINDOWS_DIR = "C:\\Program Files (x86)\\Ubisoft\\Ubisoft Game Launcher\\" UBISOFT_INSTALLER_URL = "https://static3.cdn.ubi.com/orbit/launcher_installer/UbisoftConnectInstaller.exe" ROCKSTAR_SERVICE = Path("/usr/local/lib/droiddeck-rockstar") SERVICE_WAIT = 300.0 ROCKSTAR_FOLDER = "drive_c/Program Files/Rockstar Games/Launcher" ROCKSTAR_TITLES = {"gta3": "Grand Theft Auto III", "gtavc": "Grand Theft Auto: Vice City", "gtasa": "GTA: San Andreas", "gta4": "Grand Theft Auto IV", "lanoire": "LANoireMTL"} def rockstar_launcher_log(compat_data, limit=65536): pfx = Path(compat_data) / "pfx" target = pfx / ROCKSTAR_FOLDER if not target.resolve().is_relative_to(pfx.resolve()): return [] path = target / "launcher.log" try: descriptor = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK) except OSError: return [] try: if not stat.S_ISREG(os.fstat(descriptor).st_mode): return [] with os.fdopen(descriptor, "rb", closefd=False) as source: data = source.read(limit) path.unlink(missing_ok=True) except OSError: return [] finally: os.close(descriptor) return [line.strip() for line in data.decode("utf-8", "replace").splitlines() if line.strip()] def rockstar_sdk(folder, sidecar): if str(sidecar.get("id")) in ("gta4", "lanoire"): return True root = folder.resolve() exe = (folder / str(sidecar.get("exe") or "").replace("\\", "/")).resolve() if not exe.is_relative_to(root): return False for directory in {root, exe.parent}: if directory.is_dir() and any(p.is_file() and not p.is_symlink() and p.name.lower() in ("socialclub.dll", "socialclub64.dll") for p in directory.iterdir()): return True if str(sidecar.get("id")) in ROCKSTAR_TITLES: return False level = [root] for _ in range(4): children = [] for directory in level: for path in directory.iterdir(): if path.is_symlink(): continue if path.name.lower() == "title.rgl" and path.is_file() and path.resolve().is_relative_to(root) and 112 <= path.stat().st_size <= 1048576: with path.open("rb") as source: if source.read(4) == b"RGLM": return True if len(children) < 256 and path.is_dir() and path.resolve().is_relative_to(root): children.append(path) level = children return False def rockstar_registry(folder, title, compat_data, proton, sdk_arch=None): pfx = Path(compat_data) / "pfx" launcher = r"C:\Program Files\Rockstar Games\Launcher" values = [(r"Rockstar Games\Launcher", launcher)] if title: values.append(("Rockstar Games\\" + title, windows_path(str(folder)))) entries = [("Software\\" + view + key, value) for view in ("", "Wow6432Node\\") for key, value in values] if sdk_arch: entries.append((r"Software\Rockstar Games\Rockstar Games Social Club", r"C:\Program Files\Rockstar Games\Social Club")) program = "Program Files (x86)" if sdk_arch == "x86" else "Program Files" entries.append((r"Software\Wow6432Node\Rockstar Games\Rockstar Games Social Club", "C:\\" + program + r"\Rockstar Games\Social Club")) reg = pfx / "system.reg" if all(has_value(reg, "[" + key.replace("\\", "\\\\") + "]", "InstallFolder", value) for key, value in entries): return True if wait_for_server(pfx, 2): return all(set_value(reg, "[" + key.replace("\\", "\\\\") + "]", "InstallFolder", value) for key, value in entries) with tempfile.TemporaryDirectory(prefix="droiddeck-rockstar-") as temp: path = Path(temp) / "install.reg" text = "Windows Registry Editor Version 5.00\r\n\r\n" text += "\r\n".join('[HKEY_LOCAL_MACHINE\\%s]\r\n"InstallFolder"="%s"\r\n' % (key, reg_escape(value)) for key, value in entries) path.write_text(text, encoding="utf-16") result = subprocess.run([proton, "run", "reg.exe", "import", windows_path(str(path))], stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=45) return result.returncode == 0 def rockstar_runtime(folder, exe, compat_data, arch): if arch == "x86": rockstar_runtime(folder, exe, compat_data, "x64") pfx = Path(compat_data) / "pfx" target = pfx / "drive_c" / ("Program Files (x86)" if arch == "x86" else "Program Files") / "Rockstar Games/Social Club" if not target.resolve().is_relative_to(pfx.resolve()): raise ValueError("invalid Social Club destination") required = ("socialclub.dll", "socialclub.pak") + (("SocialClubHelper.exe",) if arch == "x64" else ()) marker = target / ".droiddeck-installing" if all((target / name).is_file() for name in required) and not marker.exists(): return "present" root = folder.resolve() installers = [base / sub / "Social-Club-Setup.exe" for base in (root, exe.parent) for sub in ("Redistributables", "Installers")] installer = next((p for p in installers if p.is_file() and p.resolve().is_relative_to(root) and p.stat().st_size <= 256 * 1024 * 1024), None) if installer is None: return "game-runtime" tool = shutil.which("7z") if not tool: return "no-unpacker" listing = subprocess.run([tool, "l", "-t7z", "-slt", "-ba", str(installer)], capture_output=True, stdin=subprocess.DEVNULL, timeout=30) if listing.returncode: return "installer-unreadable" entries, size = [], 0 for block in listing.stdout.decode("utf-8", "replace").split("\n\n"): fields = dict(line.split(" = ", 1) for line in block.splitlines() if " = " in line) name = fields.get("Path", "").replace("\\", "/") if not name.startswith(arch + "/"): continue if ".." in name.split("/") or ":" in name or fields.get("Symbolic Link") or fields.get("Hard Link"): raise ValueError("invalid Social Club archive path") entry_size = int(fields.get("Size", "0")) if entry_size < 0: raise ValueError("invalid Social Club member size") size += entry_size entries.append(name) if not entries or len(entries) > 2048 or size > 768 * 1024 * 1024: raise ValueError("invalid Social Club archive size") with tempfile.TemporaryDirectory(prefix="droiddeck-socialclub-") as temporary: result = subprocess.run([tool, "x", "-t7z", "-y", "-o" + temporary, str(installer), arch + "/*"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL, timeout=180) source = Path(temporary) / arch if result.returncode or not all((source / name).is_file() for name in required): return "installer-incomplete" target.mkdir(parents=True, exist_ok=True) if marker.is_symlink(): raise ValueError("invalid Social Club install marker") marker.touch() for path in source.rglob("*"): if path.is_symlink() or not path.resolve().is_relative_to(source.resolve()): raise ValueError("invalid Social Club archive member") if not path.is_file(): continue output = target / path.relative_to(source) if not output.resolve().is_relative_to(pfx.resolve()): raise ValueError("invalid Social Club output path") output.parent.mkdir(parents=True, exist_ok=True) with tempfile.NamedTemporaryFile(dir=output.parent, delete=False) as stage: stage_path = Path(stage.name) try: with path.open("rb") as stream: shutil.copyfileobj(stream, stage) except BaseException: stage_path.unlink(missing_ok=True) raise os.replace(stage_path, output) marker.unlink() return "installed" def fetch_service(service, store, launch_dir, ask_app=None): if service.is_file(): return True if not launch_dir: return False answer = (ask_app or ask)(Path(launch_dir) / "stores", {"op": "store-service", "store": store}, timeout=SERVICE_WAIT) return isinstance(answer, dict) and bool(answer.get("ok")) and service.is_file() def prepare_rockstar(folder, sidecar, compat_data, launch_dir, proton="", ask_app=None): if not compat_data: return "no-prefix" target = Path(compat_data) / "pfx" / ROCKSTAR_FOLDER if not target.resolve().is_relative_to((Path(compat_data) / "pfx").resolve()): return "invalid-service-path" config = target / "launch.json" config.unlink(missing_ok=True) (target / "launcher.log").unlink(missing_ok=True) legacy = str(sidecar.get("id")) in ROCKSTAR_TITLES sdk = rockstar_sdk(folder, sidecar) title = ROCKSTAR_TITLES.get(str(sidecar.get("id"))) if not launch_dir: return "no-channel" root = folder.resolve() exe = (folder / str(sidecar.get("exe") or "").replace("\\", "/")).resolve() if not exe.is_relative_to(root): return "invalid-game-path" workdir = (folder / str(sidecar["workdir"])).resolve() if sidecar.get("workdir") is not None else exe.parent if not workdir.is_relative_to(root) or not exe.is_file() or legacy and not any((p / "MTLX.dll").is_file() for p in (root, exe.parent)): return "invalid-game-path" args = sidecar.get("args") or [] if not isinstance(args, list) or any(not isinstance(arg, str) or "\0" in arg for arg in args): return "invalid-game-arguments" with exe.open("rb") as source: if source.read(2) != b"MZ": return "invalid-game-exe" source.seek(0x3c) raw = source.read(4) if len(raw) != 4: return "invalid-game-exe" source.seek(int.from_bytes(raw, "little")) signature = source.read(6) if len(signature) != 6 or signature[:4] != b"PE\0\0" or signature[4:] not in (b"\x4c\x01", b"\x64\x86"): return "invalid-game-exe" service = ROCKSTAR_SERVICE / ("Launcher32.exe" if signature[4:] == b"\x4c\x01" else "Launcher64.exe") if not fetch_service(service, "rockstar", launch_dir, ask_app): return "no-service" made = "present" if (Path(compat_data) / "pfx/user.reg").is_file() else create_prefix(compat_data, proton) if made not in ("created", "present"): return "prefix-" + made arch = "x86" if signature[4:] == b"\x4c\x01" else "x64" if sdk: log("rockstar runtime: " + rockstar_runtime(folder, exe, compat_data, arch)) if not rockstar_registry(folder, title, compat_data, proton, sdk_arch=arch if sdk else None): return "registry-unavailable" target.mkdir(parents=True, exist_ok=True) with tempfile.NamedTemporaryFile(prefix="Launcher-", suffix=".exe", dir=target, delete=False) as temporary: temporary_path = Path(temporary.name) try: with service.open("rb") as source: shutil.copyfileobj(source, temporary) except BaseException: temporary_path.unlink(missing_ok=True) raise os.replace(temporary_path, target / "Launcher.exe") answer = (ask_app or ask)(Path(launch_dir) / "stores", {"op": "rockstar-launch", "store": "rockstar", "id": str(sidecar.get("id"))}, timeout=120.0) if not isinstance(answer, dict) or not answer.get("ok"): return "session-" + (str(answer.get("reason") or "refused") if isinstance(answer, dict) else "timeout") if legacy and (not isinstance(answer.get("material"), str) or not re.fullmatch(r"[0-9A-Fa-f]{640}", answer["material"])): return "invalid-material" expires = answer.get("expiresAt") if not isinstance(expires, int) or not time.time() * 1000 < expires <= time.time() * 1000 + 120_000: return "invalid-expiry" launch = {"folder": windows_path(str(root)), "exe": windows_path(str(exe)), "workdir": windows_path(str(workdir)), "args": args, "expiresAt": expires} if legacy: launch.update(pipe=answer.get("pipe"), material=answer["material"]) if sdk: session = answer.get("session") if not isinstance(session, dict) or not isinstance(session.get("accountId"), str) \ or not re.fullmatch(r"[1-9][0-9]{0,19}", session["accountId"]) or int(session["accountId"]) > 2**64 - 1 \ or any(not isinstance(session.get(key), str) or not session[key] or "\0" in session[key] or len(session[key].encode("utf-8")) > limit for key, limit in (("identity", 512), ("ticket", 49152))): return "invalid-sdk-session" launch["session"] = {key: session[key] for key in ("accountId", "identity", "ticket")} if "titleId" in session: if not isinstance(session["titleId"], str) or not re.fullmatch(r"[a-z][a-z0-9_]{0,63}", session["titleId"]): return "invalid-sdk-title" launch["session"]["titleId"] = session["titleId"] if len(json.dumps(launch).encode("utf-8")) > 65536: return "handoff-too-large" with tempfile.NamedTemporaryFile(mode="w", prefix="launch-", suffix=".json", dir=target, delete=False) as temporary: temporary_path = Path(temporary.name) try: json.dump(launch, temporary) except BaseException: temporary_path.unlink(missing_ok=True) raise os.replace(temporary_path, config) return "ready" UBISOFT_CACHE = Path("/root/.cache/droiddeck/ubisoft") UBISOFT_LAUNCH = ".droiddeck-ubisoft.json" UBISOFT_SERVICE = Path("/usr/local/lib/droiddeck-ubisoft/droiddeck-upc.exe") UBISOFT_ASK_WAIT = 45.0 UBISOFT_EXTRACT_WAIT = 300 # Ubisoft's own game-side runtime from the Connect installer, unmodified: the API and aux DLLs the # game's loader opens from InstallDir, the starter it re-executes into and its imports, and the overlay # DLLs uplay_r1.dll loads even with the overlay off (its startup fails without them). UBISOFT_RUNTIME = ("uplay_r1.dll", "uplay_r164.dll", "uplay_aux_r1.dll", "uplay_aux_r164.dll", "uplay_r2.dll", "uplay_r264.dll", "ubiorbitapi_r2.dll", "ubiorbitapi_r264.dll", "UbisoftGameLauncher.exe", "UbisoftGameLauncher64.exe", "discord-rpc.x86.dll", "discord-rpc.x64.dll", "steam_api.dll", "steam_api64.dll", "overlay.dll", "overlay64.dll") UBISOFT_VIEWS = ("[Software\\\\Ubisoft\\\\Launcher%s]", "[Software\\\\Wow6432Node\\\\Ubisoft\\\\Launcher%s]") MIN_INSTALLER = 1 << 20 def ubisoft_runtime_dir(compat_data): return Path(compat_data) / "pfx" / UBISOFT_DIR def ubisoft_runtime_ready(compat_data): folder = ubisoft_runtime_dir(compat_data) return all((folder / name).is_file() for name in UBISOFT_RUNTIME) def fetch_installer(url=UBISOFT_INSTALLER_URL, folder=UBISOFT_CACHE): target = folder / "UbisoftConnectInstaller.exe" if target.is_file() and target.stat().st_size >= MIN_INSTALLER: return target import urllib.request folder.mkdir(parents=True, exist_ok=True) part = target.with_name(target.name + ".part") request = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"}) with urllib.request.urlopen(request, timeout=60) as reply, open(part, "wb") as out: shutil.copyfileobj(reply, out) if part.stat().st_size < MIN_INSTALLER: part.unlink() raise OSError("installer too small") os.replace(part, target) return target def install_runtime(compat_data, wait=UBISOFT_EXTRACT_WAIT): if ubisoft_runtime_ready(compat_data): return "present" if not (Path(compat_data) / "pfx").is_dir(): return "no-prefix" try: installer = fetch_installer() except OSError as error: return "download-failed-" + type(error).__name__ target = ubisoft_runtime_dir(compat_data) target.mkdir(parents=True, exist_ok=True) with tempfile.TemporaryDirectory(prefix="droiddeck-ubisoft-", dir=str(UBISOFT_CACHE)) as tmp: try: subprocess.run(["7z", "e", "-y", "-o" + tmp, str(installer)] + list(UBISOFT_RUNTIME), stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=wait) except subprocess.TimeoutExpired: return "extract-timeout" except OSError: return "no-7z" missing = [name for name in UBISOFT_RUNTIME if not (Path(tmp) / name).is_file()] if missing: return "extract-missing-" + ",".join(missing) for name in UBISOFT_RUNTIME: shutil.copyfile(Path(tmp) / name, target / name) if not ubisoft_runtime_ready(compat_data): return "copy-failed" try: installer.unlink() except OSError: pass return "installed" def ubisoft_product(sidecar): extra = sidecar.get("extra") if isinstance(sidecar.get("extra"), dict) else {} try: return int(str(extra.get("productId") or "")) except ValueError: return None def ubisoft_install_dir(folder): return windows_path(str(folder)).replace("\\", "/").rstrip("/") + "/" def register_ubisoft(folder, product, compat_data): reg = Path(compat_data) / "pfx" / "system.reg" if not reg.is_file(): return "no-registry" if not wait_for_server(reg.parent): return "server-running" for view in UBISOFT_VIEWS: set_value(reg, view % "", "InstallDir", UBISOFT_WINDOWS_DIR) set_value(reg, view % ("\\\\Installs\\\\%d" % product), "InstallDir", ubisoft_install_dir(folder)) return "registered %d" % product UBISOFT_HIVES = {"HKEY_LOCAL_MACHINE": "system.reg", "HKEY_CURRENT_USER": "user.reg"} def manifest_value(values, folder, language): """The value Connect writes for a manifest registry entry: the install folder, the entry for the language being played, or the only entry there is.""" entries = [v for v in values if isinstance(v, dict)] if not entries: return None names = [str(v.get("name") or "") for v in entries] if "$INSTALL_DIR" in names: return windows_path(str(folder)).rstrip("\\") + "\\" for v in entries: if str(v.get("value") or "").lower() == language.lower(): return str(v.get("value")) prefix = language.split("-")[0].lower() for v in entries: if str(v.get("value") or "").lower().split("-")[0] == prefix: return str(v.get("value")) return str(entries[0].get("value") or entries[0].get("name") or "") def apply_manifest_registry(compat_data, registry, folder, language): written = 0 for item in registry or []: if not isinstance(item, dict): continue path = str(item.get("key") or "").replace("/", "\\") hive, _, rest = path.partition("\\") target = UBISOFT_HIVES.get(hive.upper()) if not target or "\\" not in rest: continue subkey, _, name = rest.rpartition("\\") value = manifest_value(item.get("values"), folder, language) if value is None or not name: continue reg = Path(compat_data) / "pfx" / target parts = subkey.split("\\") views = [parts] if target == "system.reg" and len(parts) > 1 and parts[0].lower() == "software" and parts[1].lower() != "wow6432node": views.append(parts[:1] + ["Wow6432Node"] + parts[1:]) for view in views: key = "[" + "\\\\".join(view) + "]" if set_value(reg, key, name, value): written += 1 return written def ubisoft_launch(folder, sidecar, product, compat_data, answer): """The launch file droiddeck-upc.exe reads: the game, the account and this launch's ticket.""" account = answer.get("account") if isinstance(answer.get("account"), dict) else {} user = str(account.get("userId") or "user") saves = Path(compat_data) / "pfx" / "drive_c/users/steamuser/Saved Games/Ubisoft" / user / str(product) saves.mkdir(parents=True, exist_ok=True) exe = str(sidecar.get("exe") or "").replace("\\", "/") workdir = folder / str(sidecar.get("workdir")) if sidecar.get("workdir") else folder UBISOFT_CACHE.mkdir(parents=True, exist_ok=True) return { "productId": product, "exe": windows_path(str(folder / exe)), "args": " ".join(str(a) for a in sidecar.get("args") or []), "workdir": windows_path(str(workdir)), "account": account, "ticket": str(answer.get("ticket") or ""), "owned": [int(i) for i in answer.get("owned") or [] if str(i).isdigit()], "products": [p for p in answer.get("products") or [] if isinstance(p, dict) and isinstance(p.get("id"), int)], "appId": str(answer.get("appId") or ""), "chunks": [c for c in answer.get("chunks") or [] if isinstance(c, dict) and isinstance(c.get("id"), int)], "saves": "C:/users/steamuser/Saved Games/Ubisoft/%s/%d/" % (user, product), "language": str(answer.get("language") or "en-US"), "bridge": windows_path(str(UBISOFT_CACHE / ("bridge-%d" % product))), "log": windows_path(str(UBISOFT_CACHE / ("upc-%d.log" % product))), } def prepare_ubisoft(folder, sidecar, compat_data, launch_dir, proton="", ask_app=None): launch = folder / UBISOFT_LAUNCH try: launch.unlink() except OSError: pass if not compat_data: return "no-prefix" product = ubisoft_product(sidecar) if product is None: return "no-product" if not fetch_service(UBISOFT_SERVICE, "ubisoft", launch_dir, ask_app): return "no-service" made = create_prefix(compat_data, proton) if not (Path(compat_data) / "pfx/user.reg").is_file() else "present" if made not in ("present", "created"): return "prefix " + made runtime = install_runtime(compat_data) if not ubisoft_runtime_ready(compat_data): return "runtime " + runtime registry = register_ubisoft(folder, product, compat_data) if not launch_dir: return "runtime %s, %s, no-channel" % (runtime, registry) answer = (ask_app or ask)(Path(launch_dir) / "stores", {"op": "ubisoft-launch", "store": "ubisoft", "id": str(sidecar.get("id"))}, timeout=UBISOFT_ASK_WAIT) if not isinstance(answer, dict) or not answer.get("ok") or not answer.get("ticket"): reason = "timeout" if answer is None else str(answer.get("reason") or "refused") return "runtime %s, %s, session %s" % (runtime, registry, reason) written = 0 if answer.get("registry") and wait_for_server(Path(compat_data) / "pfx"): written = apply_manifest_registry(compat_data, answer.get("registry"), folder, str(answer.get("language") or "en-US")) tmp = launch.with_name(launch.name + ".tmp") tmp.write_text(json.dumps(ubisoft_launch(folder, sidecar, product, compat_data, answer))) os.replace(tmp, launch) return "runtime %s, %s, %d manifest value(s), session ready" % (runtime, registry, written) COMET_DIR = Path("/usr/local/lib/droiddeck-comet") def provision_galaxy(compat_data, proton, timeout=90): if not compat_data or not proton or not Path(proton).is_file(): return "no-proton" data = Path(compat_data) data.mkdir(parents=True, exist_ok=True) marker = data / "pfx/.droiddeck-comet-service" try: version = (COMET_DIR / "version").read_text().strip() tools = [COMET_DIR / "GalaxyCommunication.exe", COMET_DIR / "update-permissions.exe"] if not all(p.is_file() for p in tools): return "not-installed" stamp = version + " " + " ".join(hashlib.sha256(p.read_bytes()).hexdigest() for p in tools) if marker.is_file() and marker.read_text() == stamp and (data / "pfx/system.reg").is_file(): return "ready" with tempfile.TemporaryDirectory(prefix="droiddeck-galaxy-") as tmp: folder = Path(tmp) result = folder / "result" bat = folder / "install.bat" src = windows_path(str(COMET_DIR)) answer = windows_path(str(result)) target = r"C:\ProgramData\GOG.com\Galaxy\redists" lines = ["@echo off", "setlocal", 'set "DD_DIR=%s"' % target, "sc query GalaxyCommunication >nul 2>&1", 'if not errorlevel 1 if not exist "%DD_DIR%\\droiddeck-comet" goto existing', 'if not exist "%DD_DIR%" mkdir "%DD_DIR%"', 'copy /y "%s\\GalaxyCommunication.exe" "%s\\GalaxyCommunication.exe" >nul' % (src, target), 'if errorlevel 1 exit /b 1', 'sc query GalaxyCommunication >nul 2>&1', 'if errorlevel 1 sc create GalaxyCommunication binpath= "%s\\GalaxyCommunication.exe"' % target, 'if errorlevel 1 exit /b 1', '"%s\\update-permissions.exe"' % src, 'if errorlevel 1 exit /b 1', 'sc query GalaxyCommunication >nul 2>&1', 'if errorlevel 1 exit /b 1', 'echo managed>"%s\\droiddeck-comet"' % target, ':existing', 'echo ready>"%s"' % answer, 'exit /b 0'] bat.write_bytes(("\r\n".join(lines) + "\r\n").encode()) env = os.environ.copy() env["DD_COMET_BOOTSTRAP"] = "1" run = subprocess.run([proton, "run", "cmd.exe", "/d", "/c", windows_path(str(bat))], env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=timeout) if run.returncode or not result.is_file() or result.read_text().strip() != "ready": return "service-unavailable" marker.write_text(stamp) return "ready" except subprocess.TimeoutExpired: return "timeout" except (OSError, ValueError): return "service-unavailable" def prepare_gog(sidecar, compat_data, launch_dir): if not launch_dir: log("gog achievements unavailable: no-channel") return False answer = ask(Path(launch_dir) / "stores", {"op": "gog-achievements", "store": "gog", "id": str(sidecar.get("id"))}, timeout=25.0) if not isinstance(answer, dict) or not answer.get("ready"): log("gog achievements: " + (str(answer.get("reason", "unavailable")) if isinstance(answer, dict) else "timeout")) return False state = provision_galaxy(compat_data, os.environ.get("DD_STORE_PROTON", "")) log("gog achievements prefix: " + state) return state == "ready" GOG_SCRIPTS = "goggame-*.script" GOG_REGISTRY_MARK = ".droiddeck-gog-registry" GOG_SUPPORT_MARK = ".droiddeck-gog-support" GOG_ROOTS = {"HKEY_LOCAL_MACHINE": "HKEY_LOCAL_MACHINE", "HKLM": "HKEY_LOCAL_MACHINE", "HKEY_CURRENT_USER": "HKEY_CURRENT_USER", "HKCU": "HKEY_CURRENT_USER", "HKEY_CLASSES_ROOT": "HKEY_CLASSES_ROOT", "HKCR": "HKEY_CLASSES_ROOT"} WINE_USER = "C:\\users\\steamuser" # GOG completes some installs by running a support installer from the game folder (the # goggame-.script "Execute" action). Under ARM64 FEX that 32-bit self-extractor stops at # "Path not found", so the values it would write are applied here instead. Only products GOG # ships no setRegistry action for are listed; a script's own entries always win. # The Witcher: Enhanced Edition (#694) exits during startup unless the installer's # HKLM\Software\CD Projekt Red\The Witcher keys exist - the same ones The Witcher's own # setup writes (InstallFolder, RegionVersion, IsDjinniInstalled) plus its language. GOG_INSTALL_REGISTRY = { "1207658924": [ ("HKLM", "Software\\CD Projekt Red\\The Witcher", "InstallFolder", "string", "{app}\\"), ("HKLM", "Software\\CD Projekt Red\\The Witcher", "RegionVersion", "string", "US"), ("HKLM", "Software\\CD Projekt Red\\The Witcher", "IsDjinniInstalled", "dword", 1), ("HKLM", "Software\\CD Projekt Red\\The Witcher", "Language", "string", "{language}"), ("HKCU", "Software\\CD Projekt RED\\Witcher\\Settings", "TextLanguage", "string", "{language}"), ("HKCU", "Software\\CD Projekt RED\\Witcher\\Settings", "VoiceLanguage", "string", "{language}"), ], } # The Witcher's text and voice language IDs, from its installer's registry data. GOG_LANGUAGE_IDS = {"en": 3, "fr": 11, "de": 10, "es": 12, "it": 13, "ru": 14, "cs": 15, "hu": 16, "zh": 21, "pl": 5} def gog_paths(folder, product): app = windows_path(str(folder)) support = app + "\\support\\" + product return {"app": app, "productid": product, "support": support, "supportdir": support, "localappdata": WINE_USER + "\\AppData\\Local", "userdocs": WINE_USER + "\\Documents"} def gog_expand(text, paths): return re.sub(r"\{([A-Za-z]+)\}", lambda m: paths[m.group(1).lower()], text) def gog_number(data): if isinstance(data, bool): raise ValueError if isinstance(data, int): return data text = str(data).strip() try: return int(text, 0) except ValueError: return int(text, 10) def gog_value(kind, data): kind = str(kind).lower() if kind == "string": text = str(data) if any(c in text for c in "\r\n\0"): return None return '"%s"' % reg_escape(text) if kind == "dword": return "dword:%08x" % (gog_number(data) & 0xFFFFFFFF) if kind == "binary": return "hex:" + ",".join("%02x" % b for b in base64.b64decode(str(data), validate=True)) return None def gog_entry(arguments, paths): if not isinstance(arguments, dict): return None try: root = GOG_ROOTS.get(str(arguments.get("root") or "").upper()) subkey = gog_expand(str(arguments.get("subkey") or ""), paths).strip("\\") if root is None or not subkey or any(c in subkey for c in "\r\n\0"): return None section = "[%s\\%s]" % (root, subkey) if not arguments.get("valueType"): return section data = arguments.get("valueData") value = gog_value(arguments["valueType"], gog_expand(data, paths) if isinstance(data, str) else data) name = gog_expand(str(arguments.get("valueName") or ""), paths) if value is None or any(c in name for c in "\r\n\0"): return None return section + "\r\n" + ('"%s"' % reg_escape(name) if name else "@") + "=" + value except (KeyError, ValueError, TypeError, binascii.Error): return None def gog_installed_products(folder): products = {} for info in sorted(Path(folder).glob("goggame-*.info")): product = info.name[len("goggame-"):-len(".info")] if not product.isdigit(): continue try: products[product] = json.loads(info.read_text(encoding="utf-8-sig")) except (OSError, ValueError): products[product] = {} return products def gog_language_id(info): languages = info.get("languages") if isinstance(info, dict) else None if isinstance(languages, str): languages = [languages] code = str(languages[0]).lower()[:2] if isinstance(languages, list) and languages else "" return GOG_LANGUAGE_IDS.get(code, GOG_LANGUAGE_IDS["en"]) GOG_VALUE_HIVES = {"hklm": "local_machine", "hkey_local_machine": "local_machine", "hkcu": "current_user", "hkey_current_user": "current_user", "hkcr": "classes_root", "hkey_classes_root": "classes_root"} def gog_value_key(root, section, name, view32=True): """A registry value's identity, keeping the root and the 32-bit view apart. The fallback import always targets the 32-bit view (`/reg:32`), which Wine keeps under `Software\\Wow6432Node` for HKLM: a native HKLM value must not pass for the 32-bit one. HKCU\\Software is shared by both views, so its values read the same either way. """ text = section.replace("\\\\", "\\").strip("\\").lower() hive = GOG_VALUE_HIVES.get(root.lower(), root.lower()) if text.startswith("software\\wow6432node\\"): text = text[len("software\\wow6432node\\"):] elif hive == "local_machine" and not view32 and text.startswith("software\\"): text = "native\\" + text elif text.startswith("software\\"): text = text[len("software\\"):] return "%s|%s|%s" % (hive, text, name.lower()) def gog_registry_values(pfx): """Values already in the prefix, so install defaults never overwrite a player's choice.""" values = set() for file, root in (("system.reg", "hklm"), ("user.reg", "hkcu")): try: lines = (pfx / file).read_text(encoding="utf-8", errors="ignore").splitlines() except OSError: continue section = "" for line in lines: if line.startswith("["): end = line.find("]") section = line[1:end] if end > 0 else line[1:] continue match = re.match(r'^"([^"]+)"=', line) if match and section: values.add(gog_value_key(root, section, match.group(1), view32=False)) return values def gog_scripted_products(folder): products = set() for script in sorted(Path(folder).glob(GOG_SCRIPTS)): try: actions = json.loads(script.read_text(encoding="utf-8-sig")).get("actions") except (OSError, ValueError, AttributeError): continue if isinstance(actions, list) and any( isinstance(action, dict) and isinstance(action.get("install"), dict) and action["install"].get("action") == "setRegistry" for action in actions): products.add(script.name[len("goggame-"):-len(".script")]) return products def gog_expected_values(folder): """The fallback values a launch must find, so the marker never hides one that was deleted.""" scripted = gog_scripted_products(folder) return [gog_value_key(root, subkey, name) for product in gog_installed_products(folder) if product in GOG_INSTALL_REGISTRY and product not in scripted for root, subkey, name, _kind, _value in GOG_INSTALL_REGISTRY[product]] def gog_registry(folder, existing=()): entries, skipped, scripted = [], 0, set() for script in sorted(Path(folder).glob(GOG_SCRIPTS)): product = script.name[len("goggame-"):-len(".script")] try: actions = json.loads(script.read_text(encoding="utf-8-sig")).get("actions") except (OSError, ValueError, AttributeError): continue paths = gog_paths(folder, product) for action in actions if isinstance(actions, list) else []: install = action.get("install") if isinstance(action, dict) else None if not isinstance(install, dict) or install.get("action") != "setRegistry": continue entry = gog_entry(install.get("arguments"), paths) if entry is None: skipped += 1 else: entries.append(entry) scripted.add(product) for product, info in gog_installed_products(folder).items(): if product in scripted or product not in GOG_INSTALL_REGISTRY: continue paths = dict(gog_paths(folder, product), language=str(gog_language_id(info))) for root, subkey, name, kind, value in GOG_INSTALL_REGISTRY[product]: if gog_value_key(root, subkey, name) in existing: continue entry = gog_entry({"root": root, "subkey": subkey, "valueName": name, "valueType": kind, "valueData": value}, paths) if entry is None: skipped += 1 else: entries.append(entry) return entries, skipped def apply_gog_registry(folder, compat_data, proton, timeout=90, installation=None): pfx = Path(compat_data) / "pfx" if compat_data else None existing = gog_registry_values(pfx) if pfx else set() entries, skipped = gog_registry(folder, existing) expected = gog_expected_values(folder) if installation: product = str(installation["id"]) if not product.isdigit(): raise ValueError("Invalid GOG product identifier") values = {"PATH": windows_path(str(folder))} identity = Path(folder) / ("goggame-%s.id" % product) if identity.is_file(): actual = json.loads(identity.read_text(encoding="utf-8-sig")).get("buildId") if actual and installation.get("build") and str(actual) != str(installation["build"]): raise ValueError("GOG build metadata changed before patch setup") if installation.get("build"): values["BUILDID"] = installation["build"] if installation.get("version"): values["VER"] = installation["version"] for key, value in values.items(): entry = gog_entry({"root": "HKLM", "subkey": "Software\\GOG.com\\Games\\" + product, "valueName": key, "valueData": value, "valueType": "string"}, {}) if entry: entries.append(entry) note = " skipped=%d" % skipped if skipped else "" if not entries: return "none" + note if not compat_data or not proton or not Path(proton).is_file(): return "no-proton" + note text = "Windows Registry Editor Version 5.00\r\n\r\n" + "".join(entry + "\r\n\r\n" for entry in entries) stamp = hashlib.sha256(text.encode("utf-8")).hexdigest() marker = pfx / GOG_REGISTRY_MARK try: if (marker.is_file() and marker.read_text() == stamp and (pfx / "system.reg").is_file() and set(expected) <= existing): return "ready" + note Path(compat_data).mkdir(parents=True, exist_ok=True) with tempfile.TemporaryDirectory(prefix="droiddeck-gog-") as tmp: source = Path(tmp) / "registry.reg" source.write_bytes(b"\xff\xfe" + text.encode("utf-16-le")) executable = pfx / "drive_c/windows/system32/reg.exe" run = subprocess.run([proton, "run", str(executable) if executable.is_file() else "reg.exe", "import", windows_path(str(source)), "/reg:32"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=timeout) if run.returncode or not (pfx / "system.reg").is_file(): return "import-failed" + note marker.write_text(stamp) return "written=%d%s" % (len(entries), note) except subprocess.TimeoutExpired: return "timeout" + note except OSError: return "import-failed" + note EA_HARDWARE = ".droiddeck-ea-hw.json" EA_CLIENT = "C:\\Program Files (x86)\\Origin\\Origin.exe" EA_WMI = ( ("boardManufacturer", "Win32_BaseBoard", "Manufacturer"), ("boardSerial", "Win32_BaseBoard", "SerialNumber"), ("biosManufacturer", "Win32_BIOS", "Manufacturer"), ("biosSerial", "Win32_BIOS", "SerialNumber"), ("osInstallDate", "Win32_OperatingSystem", "InstallDate"), ("osSerial", "Win32_OperatingSystem", "SerialNumber"), ("gpuPnpId", "Win32_VideoController", "PNPDeviceID"), ("cpuManufacturer", "Win32_Processor", "Manufacturer"), ("processorId", "Win32_Processor", "ProcessorId"), ("brand", "Win32_Processor", "Name"), ) EA_ROOTS = {"HKLM": "HKEY_LOCAL_MACHINE", "HKCU": "HKEY_CURRENT_USER"} def decode_output(data): if data[:2] in (b"\xff\xfe", b"\xfe\xff") or (len(data) > 1 and data[1:2] == b"\x00"): return data.decode("utf-16", "replace") return data.decode("utf-8", "replace") def wmi_value(text): rows = [row.strip() for row in text.replace("\r", "\n").split("\n") if row.strip()] return rows[1] if len(rows) > 1 else "" CPUID_LEAVES = (0, 1, 0x80000002, 0x80000003, 0x80000004) def cpuid_exe(): """A 32-bit console program that writes the raw CPUID leaves an x86 game sees under the emulator.""" import struct base, rva = 0x400000, 0x1000 buf, written = base + rva + 0x180, base + rva + 0x1D0 iat = base + rva + 0x138 code = b"\x53\x57\xbf" + struct.pack(" "%s"' % (cls, prop, windows_path(str(folder / (key + ".txt"))))) lines.append('vol C: > "%s"' % windows_path(str(folder / "volume.txt"))) lines.append('hostname > "%s"' % windows_path(str(folder / "hostname.txt"))) (folder / "cpuid.exe").write_bytes(cpuid_exe()) lines.append('"%s" > "%s"' % (windows_path(str(folder / "cpuid.exe")), windows_path(str(folder / "cpuid.bin")))) bat = folder / "probe.bat" bat.write_bytes(("\r\n".join(lines) + "\r\n").encode()) try: subprocess.run([proton, "run", "cmd.exe", "/d", "/c", windows_path(str(bat))], stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=timeout) except subprocess.TimeoutExpired: return {}, "timeout" except OSError: return {}, "failed" for key, _, _ in EA_WMI: try: values[key] = wmi_value(decode_output((folder / (key + ".txt")).read_bytes())) except OSError: values[key] = "" try: found = re.search(r"([0-9A-Fa-f]{4})-([0-9A-Fa-f]{4})", decode_output((folder / "volume.txt").read_bytes())) values["volumeSerial"] = (found.group(1) + found.group(2)).lower() if found else "" except OSError: values["volumeSerial"] = "" try: values["hostname"] = decode_output((folder / "hostname.txt").read_bytes()).strip().splitlines()[0].strip() except (OSError, IndexError): values["hostname"] = "" try: values.update(cpuid_values((folder / "cpuid.bin").read_bytes())) except OSError: pass if probe_complete(values): try: cache.write_text(json.dumps(values)) except OSError: pass return values, "probed" return values, "incomplete" def ea_registry_entries(folder, sidecar): install = windows_path(str(folder)).rstrip("\\") + "\\" extra = sidecar.get("extra") if isinstance(sidecar.get("extra"), dict) else {} title = str(extra.get("displayName") or sidecar.get("title") or folder.name).strip() locale = str(extra.get("locale") or "en_US") entries = [ ("HKEY_LOCAL_MACHINE\\SOFTWARE\\Electronic Arts\\EA Desktop", "InstallSuccessful", "true"), ("HKEY_LOCAL_MACHINE\\SOFTWARE\\Electronic Arts\\Origin", "InstallSuccessful", "true"), ("HKEY_LOCAL_MACHINE\\SOFTWARE\\Electronic Arts\\Origin", "ClientPath", EA_CLIENT), ("HKEY_LOCAL_MACHINE\\SOFTWARE\\Origin", "ClientPath", EA_CLIENT), ] for content in [c.strip() for c in str(extra.get("contentIds") or extra.get("contentId") or "").split(",")]: if re.fullmatch(r"[A-Za-z0-9._-]{1,64}", content): key = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Origin Games\\" + content entries += [(key, "DisplayName", title), (key, "Install Dir", install), (key, "Locale", locale)] try: keys = json.loads(extra.get("registry") or "[]") except ValueError: keys = [] for pair in keys if isinstance(keys, list) else []: if not isinstance(pair, list) or len(pair) != 2: continue key, name = str(pair[0]), str(pair[1]) root, _, rest = key.partition("\\") key = EA_ROOTS.get(root.upper(), root) + ("\\" + rest if rest else "") if key.upper().startswith(("HKEY_LOCAL_MACHINE\\", "HKEY_CURRENT_USER\\")) and name and "\n" not in key + name: entries.append((key, name, install)) if title: entries.append((key, "DisplayName", title)) entries.append((key, "Locale", locale)) return entries def ea_registry(folder, sidecar, compat_data, proton, timeout=90): if not compat_data or not proton or not Path(proton).is_file(): return "no-proton" pfx = Path(compat_data) / "pfx" text = "Windows Registry Editor Version 5.00\r\n\r\n" + "".join( '[%s]\r\n"%s"="%s"\r\n\r\n' % (key, reg_escape(name), reg_escape(value)) for key, name, value in ea_registry_entries(folder, sidecar)) stamp = hashlib.sha256(text.encode("utf-8")).hexdigest() marker = pfx / (".droiddeck-ea-registry-" + re.sub(r"[^A-Za-z0-9._-]", "_", str(sidecar.get("id")))) try: if marker.is_file() and marker.read_text() == stamp and (pfx / "system.reg").is_file(): return "ready" with tempfile.TemporaryDirectory(prefix="droiddeck-ea-") as tmp: source = Path(tmp) / "registry.reg" source.write_bytes(b"\xff\xfe" + text.encode("utf-16-le")) executable = pfx / "drive_c/windows/system32/reg.exe" for view in ("/reg:32", "/reg:64"): run = subprocess.run([proton, "run", str(executable) if executable.is_file() else "reg.exe", "import", windows_path(str(source)), view], stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=timeout) if run.returncode: return "import-failed" marker.write_text(stamp) return "written" except subprocess.TimeoutExpired: return "timeout" except OSError: return "import-failed" def find_case(folder, relative): current = Path(folder) for part in [p for p in relative.replace("\\", "/").split("/") if p and p != "."]: exact = current / part if exact.exists(): current = exact continue try: current = next(c for c in current.iterdir() if c.name.lower() == part.lower()) except (OSError, StopIteration): return None return current if current != Path(folder) else None def touchup_args(raw, locale, install): raw = raw.replace("{locale}", locale) raw = raw.replace('"{installLocation}"', '"%s"' % install).replace("{installLocation}", install) try: return shlex.split(raw.replace("\\", "\\\\")) except ValueError: return raw.split() def ea_touchup(folder, sidecar, compat_data, proton, timeout=900): extra = sidecar.get("extra") if isinstance(sidecar.get("extra"), dict) else {} relative = str(extra.get("touchup") or "") if not relative: return "none" exe = find_case(folder, relative) if exe is None or not exe.is_file(): return "missing" if not compat_data or not proton or not Path(proton).is_file(): return "no-proton" pfx = Path(compat_data) / "pfx" stamp = str(sidecar.get("installVersion") or "") + " " + str(sidecar.get("installedAt") or "") marker = pfx / (".droiddeck-ea-touchup-" + re.sub(r"[^A-Za-z0-9._-]", "_", str(sidecar.get("id")))) try: if marker.is_file() and marker.read_text() == stamp: return "done" except OSError: pass args = touchup_args(str(extra.get("touchupArgs") or ""), str(extra.get("locale") or "en_US"), windows_path(str(folder)).rstrip("\\")) try: run = subprocess.run([proton, "run", str(exe)] + args, cwd=str(exe.parent), stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=timeout) result = "ok" if run.returncode == 0 else "exit-%d" % run.returncode except subprocess.TimeoutExpired: result = "timeout" except OSError: return "failed" try: marker.write_text(stamp) except OSError: pass return result def write_licenses(compat_data, licenses): if not compat_data: return 0 root = Path(compat_data) / "pfx/drive_c" written = 0 for item in licenses or []: relative = str(item.get("path") or "") if isinstance(item, dict) else "" if not relative or relative.startswith("/") or ".." in relative.split("/"): continue target = root / relative try: target.parent.mkdir(parents=True, exist_ok=True) target.write_bytes(base64.b64decode(item.get("data") or "")) written += 1 except (OSError, binascii.Error): pass return written def prepare_ea(folder, sidecar, compat_data, launch_dir): game = str(sidecar.get("id")) proton = os.environ.get("DD_STORE_PROTON", "") made = create_prefix(compat_data, proton) ready = made in ("present", "created") or (compat_data and (Path(compat_data) / "pfx/user.reg").is_file()) stub = install_origin_stub(compat_data) if ready else "no-prefix" hardware, probe = ea_hardware(compat_data, proton) if ready else ({}, "no-prefix") answer = None if launch_dir: answer = ask(Path(launch_dir) / "stores", {"op": "ea-prepare", "store": "ea", "id": game, "hardware": hardware}, timeout=40.0) sidecar = sidecar_at(Path(folder)) or sidecar log("ea %s prefix=%s stub=%s hardware=%s registry=%s touchup=%s" % ( game, made, stub, probe, ea_registry(folder, sidecar, compat_data, proton), ea_touchup(folder, sidecar, compat_data, proton))) if answer is None: log("ea %s session=no reason=%s" % (game, "timeout" if launch_dir else "no-channel")) return written = write_licenses(compat_data, answer.get("licenses")) log("ea %s session=%s reason=%s lsx=%s licence=%s files=%d" % ( game, "yes" if answer.get("ok") else "no", answer.get("reason", ""), answer.get("lsx"), answer.get("license", ""), written)) def gog_support_actions(folder): found = [] for script in sorted(Path(folder).glob(GOG_SCRIPTS)): product = script.name[len("goggame-"):-len(".script")] try: actions = json.loads(script.read_text(encoding="utf-8-sig")).get("actions") except (OSError, ValueError, AttributeError): continue for action in actions if isinstance(actions, list) else []: install = action.get("install") if isinstance(action, dict) else None if isinstance(install, dict) and install.get("action") == "supportData" \ and isinstance(install.get("arguments"), dict): found.append((product, install["arguments"])) return found def gog_support_bases(folder, product, pfx): user = Path(pfx) / "drive_c" / "users" / "steamuser" support = Path(folder) / "support" / product return {"app": Path(folder), "supportdir": support, "support": support, "userdocs": user / "Documents", "localappdata": user / "AppData" / "Local"} def gog_inside(path, base): root = os.path.realpath(base) real = os.path.realpath(path) return real == root or real.startswith(root + os.sep) def gog_support_path(text, bases): match = re.fullmatch(r"\{(\w+)\}(.*)", text) if isinstance(text, str) else None if not match or match.group(1).lower() not in bases: return None parts = [part for part in re.split(r"[\\/]+", match.group(2)) if part] if any(part in (".", "..") for part in parts): return None base = bases[match.group(1).lower()] path = base for part in parts: exact = path / part if not exact.exists() and path.is_dir(): exact = next((child for child in path.iterdir() if child.name.lower() == part.lower()), exact) path = exact if path != base and not gog_inside(path.parent, base): return None return path, base def gog_copy_file(source, target, root): if not gog_inside(target.parent, root): raise OSError("outside " + str(root)) target.parent.mkdir(parents=True, exist_ok=True) if target.is_symlink(): target.unlink() shutil.copy2(source, target, follow_symlinks=False) def gog_support_data(folder, compat_data, proton): actions = gog_support_actions(folder) if not actions: return "none" pfx = Path(compat_data) / "pfx" if compat_data else None if not pfx or not (pfx / "drive_c" / "users" / "steamuser").is_dir(): made = create_prefix(compat_data, proton) if made not in ("present", "created") or not (pfx / "drive_c" / "users" / "steamuser").is_dir(): return "no-prefix" stamp = hashlib.sha256(json.dumps(actions, sort_keys=True).encode("utf-8")).hexdigest() marker = pfx / GOG_SUPPORT_MARK try: if marker.is_file() and marker.read_text() == stamp: return "ready" except OSError: pass copied = skipped = missing = 0 for product, arguments in actions: bases = gog_support_bases(folder, product, pfx) found = gog_support_path(arguments.get("target"), bases) origin = gog_support_path(arguments["source"], bases) if "source" in arguments else None if found is None or ("source" in arguments and origin is None): skipped += 1 continue target, root = found source = origin[0] if origin else None try: if source is None: target.mkdir(parents=True, exist_ok=True) elif not source.exists(): missing += 1 elif source.is_dir() and not source.is_symlink(): for top, dirs, files in os.walk(source): for name in sorted(files + [d for d in dirs if (Path(top) / d).is_symlink()]): item = Path(top) / name destination = target / item.relative_to(source) if (destination.exists() or destination.is_symlink()) and not arguments.get("overwrite"): continue gog_copy_file(item, destination, root) copied += 1 target.mkdir(parents=True, exist_ok=True) elif (target.exists() or target.is_symlink()) and not arguments.get("overwrite"): continue else: gog_copy_file(source, target, root) copied += 1 except OSError: skipped += 1 note = "".join(" %s=%d" % (name, count) for name, count in (("skipped", skipped), ("missing", missing)) if count) if not skipped: try: marker.write_text(stamp) except OSError: pass return "copied=%d%s" % (copied, note) def main(argv): if os.environ.get("DROIDDECK_GOG_MAINTENANCE") == "1": return 0 if argv and argv[0] == "--exited": rest, code = argv[1:], 0 if rest[:1] == ["--code"] and len(rest) > 1: try: code = int(rest[1]) except ValueError: pass rest = rest[2:] return exited(rest, code) command = battlenet(argv) if command is not None: log("battlenet " + " ".join(command[1:])) return RAN if subprocess.call(command) == 0 else RAN_FAILED found = find_store_game(argv) if found is None: return 0 folder, sidecar = found store, game = str(sidecar.get("store")), str(sidecar.get("id")) if store == "gog": helper = Path(__file__).resolve().with_name("droiddeck-gog-maintenance") if helper.is_file(): child = subprocess.Popen([sys.executable, str(helper), "lease", str(folder), str(os.getppid())], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL, start_new_session=True) ready = child.stdout.readline().decode().strip() child.stdout.close() threading.Thread(target=child.wait, daemon=True).start() if ready != "ready": log("gog: close or recover the maintenance operation before playing") return RAN_FAILED compat_data = os.environ.get("STEAM_COMPAT_DATA_PATH", "").rstrip("/") prefix_id = os.path.basename(compat_data) if compat_data else "" launch_dir = os.environ.get("DD_LAUNCH_DIR", "") if launch_dir and cloud_on(sidecar): made = create_prefix(compat_data, os.environ.get("DD_STORE_PROTON", "")) if made != "present": log("cloud %s %s prefix=%s" % (store, game, made)) if store == "gog": prepare_gog(sidecar, compat_data, launch_dir) log("gog registry: " + apply_gog_registry(folder, compat_data, os.environ.get("DD_STORE_PROTON", ""))) log("gog support data: " + gog_support_data(folder, compat_data, os.environ.get("DD_STORE_PROTON", ""))) if store == "rockstar": if game not in ROCKSTAR_TITLES and not rockstar_sdk(folder, sidecar): if compat_data: (Path(compat_data) / "pfx" / ROCKSTAR_FOLDER / "launch.json").unlink(missing_ok=True) return STORE_GAME try: state = prepare_rockstar(folder, sidecar, compat_data, launch_dir, os.environ.get("DD_STORE_PROTON", "")) except (OSError, ValueError, subprocess.TimeoutExpired): state = "preparation-failed" log("rockstar %s: %s" % (game, state)) if state != "ready" and launch_dir: ask(Path(launch_dir) / "stores", {"op": "rockstar-exited", "store": "rockstar", "id": game}, timeout=1.0) return STORE_GAME if state == "ready" else RAN_FAILED if store == "ubisoft": try: log("ubisoft %s: %s" % (game, prepare_ubisoft(folder, sidecar, compat_data, launch_dir, os.environ.get("DD_STORE_PROTON", "")))) except OSError as e: try: (folder / UBISOFT_LAUNCH).unlink() except OSError: pass log("ubisoft %s: not prepared (%s), starting directly" % (game, e)) if store == "epic": handled = os.environ.get(EPIC_HANDLED) == "1" and (folder / EPIC_ARGS).is_file() if not handled: drop_stale(folder) try: (folder / EPIC_ARGS).unlink() except OSError: pass choice = options(sidecar) client = None if handled: client = "ok" elif choice["eos"] and not choice["offline"] and client_wanted(): client = through_client(folder, sidecar) log("epic launch id=%s client=%s" % (game, client)) if client == "ok": try: (folder / EPIC_CODE).unlink() except OSError: pass log("epic launch id=%s through=client" % game) elif not (choice["eos"] and not choice["offline"]): try: (folder / EPIC_CODE).unlink() except OSError: pass log("epic launch id=%s code=no reason=%s" % (game, "offline" if choice["offline"] else "eos-off")) elif not launch_dir: log("epic launch id=%s code=no reason=no-channel" % game) else: answer = ask(Path(launch_dir) / "stores", {"op": "epic-code", "store": store, "id": game, "prefix": prefix_id}) if answer is None: log("epic launch id=%s code=no reason=timeout" % game) else: got = bool(answer.get("code")) log("epic launch id=%s code=%s reason=%s" % (game, "yes" if got else "no", answer.get("reason", ""))) log("epic prefix=%s %s" % (prefix_id or "?", provision_prefix(compat_data))) if store == "ea": prepare_ea(folder, sidecar, compat_data, launch_dir) return STORE_GAME if not cloud_on(sidecar): if store in CLOUD_STORES: log("cloud %s %s down result=skipped reason=off" % (store, game)) return 0 if launch_dir: answer = ask(Path(launch_dir) / "stores", {"op": "cloud-down", "store": store, "id": game}, timeout=CLOUD_TIMEOUT) if answer is None: log("cloud %s %s down result=timeout" % (store, game)) else: log("cloud %s %s down result=%s files=%s reason=%s" % (store, game, answer.get("result", "?"), answer.get("files", 0), answer.get("reason", ""))) else: log("cloud %s %s down result=skipped reason=no-channel" % (store, game)) return STORE_GAME if __name__ == "__main__": try: sys.exit(main(sys.argv[1:])) except Exception as e: log("skipped: %s" % type(e).__name__) sys.exit(0)