mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 21:06:09 +00:00
* feat(ubisoft): keep Denuvo game tokens per account and product until the game invalidates them * feat(ubisoft): sync cloud saves through Ubisoft's cloud save service * fix(xbox): turning cloud saves off passes the offline mode the game save runtime reads * fix(ubisoft): Ubisoft games list their shared prefix, so they get a saves and cloud tab * feat(ea): sync cloud saves through EA's cloud sync service * fix(ea): sync at EA launch and exit, keep one rule snapshot, and check the cloud copy under the write lock * fix(ubisoft): exact slot versions, scoped save export, and a Denuvo cache bound to its account * fix(ea): fresh rules per sync, checksums required, backup before restore, and sign-in shown on the saves tab * fix(ubisoft): launch-time sync on the shared prefix, saves scoped to the game, and Denuvo bound to each launch's account * fix(ea): back up only the saves a restore replaces, refuse truncated manifests, and need a master title id * fix(ubisoft): treat a slot whose bytes changed since the last sync as a conflict before uploading over it * fix(ea): one resolved save folder per sync, refuse case collisions, and walk each folder once * fix(ubisoft): sync only identified slots, keep live saves and backups safe, and tie a pending eviction to its account * fix(cloud): a forced download fetches every saved conflict and keeps the ones it could not write * test(ea): keep the cloud save cases in EaTest * fix(ubisoft): report only written slots, keep drift conflicts, read whole headers, and never rename a named eviction * fix(ea): keep real save folders in the inventory, back up any restored file, refuse duplicate or malformed cloud listings * fix(cloud): commit Ubisoft slots one at a time and stop on a newer cloud write, name skipped and blocked slots, keep unsent conflicts * fix(ubisoft): acknowledge an invalidation only once its marker is published and never serve a kept token after it * fix(cloud): a cloud request the launcher cannot write still starts the game and keeps the exit upload * fix(cloud): scope Ubisoft sync state to the account and product, compare alike slots, keep committed progress, and name partial slots * fix(ea): ask for sign-in after a rejected refresh, upload saves reached through folder aliases * fix(cloud): a launch that stops waiting for the cloud download claims it back, so no save is written once the game starts * fix(ubisoft): name the account in an invalidation marker and never hold the token lock across a pipe write * fix(ea): only invalid_grant asks for sign-in again, and case collisions count only among synced saves * test(epic): let the launcher's ask doubles take the claim flag * fix(ea): apply save rules in their order, match bare patterns inside the save folder, and resolve LocalLow and install folders * fix(ubisoft): stamp a fresh identifier into a new save that has none, so it can sync * fix(ubisoft): answer a burn ticket request as unavailable instead of leaving the game waiting * fix(cloud): read EA manifests with the XML parser, clear conflicts whose sides match, and bound the claim and stall tests
1716 lines
75 KiB
Python
Executable File
1716 lines
75 KiB
Python
Executable File
#!/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, claim=False):
|
|
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")
|
|
|
|
def wait(seconds):
|
|
deadline = time.monotonic() + seconds
|
|
while time.monotonic() < deadline:
|
|
try:
|
|
value = json.loads(answer.read_text())
|
|
answer.unlink()
|
|
return value
|
|
except (OSError, ValueError):
|
|
time.sleep(0.05)
|
|
return None
|
|
|
|
value = wait(timeout)
|
|
if value is not None:
|
|
return value
|
|
for pending in (req_dir / (rid + ".json"), resp_dir / (rid + ".taken")):
|
|
abandoned = pending.with_name(rid + ".abandoned")
|
|
try:
|
|
os.rename(pending, abandoned)
|
|
except OSError:
|
|
continue
|
|
try:
|
|
abandoned.unlink()
|
|
except OSError:
|
|
pass
|
|
return None
|
|
return wait(CLAIMED_TIMEOUT) if claim else 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
|
|
CLAIMED_TIMEOUT = 120.0
|
|
CLOUD_STORES = ("gog", "epic", "ea", "ubisoft")
|
|
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"))
|
|
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"))
|
|
try:
|
|
ask(Path(launch_dir) / "stores", {"op": "cloud-up", "store": store, "id": game}, timeout=1.0)
|
|
except OSError as error:
|
|
log("cloud %s %s up not requested (%s)" % (store, game, type(error).__name__))
|
|
return 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-<id>.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("<I", buf)
|
|
for leaf in CPUID_LEAVES:
|
|
code += b"\xb8" + struct.pack("<I", leaf) + b"\x31\xc9\x0f\xa2\x89\x07\x89\x5f\x04\x89\x4f\x08\x89\x57\x0c\x83\xc7\x10"
|
|
code += b"\x6a\xf5\xff\x15" + struct.pack("<I", iat)
|
|
code += b"\x6a\x00\x68" + struct.pack("<I", written) + b"\x6a\x50\x68" + struct.pack("<I", buf) + b"\x50\xff\x15" + struct.pack("<I", iat + 4)
|
|
code += b"\x6a\x00\xff\x15" + struct.pack("<I", iat + 8)
|
|
section = bytearray(0x200)
|
|
section[:len(code)] = code
|
|
names = [(0x148, b"GetStdHandle"), (0x158, b"WriteFile"), (0x164, b"ExitProcess")]
|
|
struct.pack_into("<IIIII", section, 0x100, rva + 0x128, 0, 0, rva + 0x172, rva + 0x138)
|
|
for i, (at, name) in enumerate(names):
|
|
struct.pack_into("<I", section, 0x128 + 4 * i, rva + at)
|
|
struct.pack_into("<I", section, 0x138 + 4 * i, rva + at)
|
|
section[at + 2:at + 2 + len(name)] = name
|
|
section[0x172:0x172 + 12] = b"KERNEL32.dll"
|
|
header = bytearray(0x200)
|
|
header[0:2] = b"MZ"
|
|
struct.pack_into("<I", header, 0x3C, 0x40)
|
|
header[0x40:0x44] = b"PE\0\0"
|
|
struct.pack_into("<HHIIIHH", header, 0x44, 0x14C, 1, 0, 0, 0, 0xE0, 0x0103)
|
|
opt = struct.pack("<HBBIIIIIIIIIHHHHHHIIIIHHIIIIII", 0x10B, 0, 0, 0x200, 0, 0, rva, rva, rva, base, 0x1000, 0x200,
|
|
4, 0, 0, 0, 4, 0, 0, 0x2000, 0x200, 0, 3, 0, 0x100000, 0x1000, 0x100000, 0x1000, 0, 16)
|
|
dirs = bytearray(128)
|
|
struct.pack_into("<II", dirs, 8, rva + 0x100, 40)
|
|
struct.pack_into("<II", dirs, 96, rva + 0x138, 16)
|
|
header[0x58:0x58 + 0xE0] = opt + bytes(dirs)
|
|
header[0x138:0x138 + 40] = struct.pack("<8sIIIIIIHHI", b".text", 0x1000, rva, 0x200, 0x200, 0, 0, 0, 0, 0xE0000060)
|
|
return bytes(header) + bytes(section)
|
|
|
|
|
|
EA_STUB_DIR = "Program Files (x86)/Origin"
|
|
EA_STUB = "C:\\Program Files (x86)\\Origin\\Origin.exe"
|
|
|
|
|
|
def origin_stub_exe():
|
|
"""A 32-bit program that only sleeps: the process older EA SDKs look for while a game runs."""
|
|
import struct
|
|
base, rva = 0x400000, 0x1000
|
|
iat = base + rva + 0x138
|
|
code = b"\x6a\xff\xff\x15" + struct.pack("<I", iat) + b"\xeb\xf6"
|
|
section = bytearray(0x200)
|
|
section[:len(code)] = code
|
|
struct.pack_into("<IIIII", section, 0x100, rva + 0x128, 0, 0, rva + 0x172, rva + 0x138)
|
|
struct.pack_into("<I", section, 0x128, rva + 0x148)
|
|
struct.pack_into("<I", section, 0x138, rva + 0x148)
|
|
section[0x14A:0x14A + 5] = b"Sleep"
|
|
section[0x172:0x172 + 12] = b"KERNEL32.dll"
|
|
header = bytearray(cpuid_exe()[:0x200])
|
|
struct.pack_into("<H", header, 0x58 + 68, 2)
|
|
return bytes(header) + bytes(section)
|
|
|
|
|
|
def install_origin_stub(compat_data):
|
|
if not compat_data:
|
|
return "no-prefix"
|
|
target = Path(compat_data) / "pfx/drive_c" / EA_STUB_DIR / "Origin.exe"
|
|
data = origin_stub_exe()
|
|
try:
|
|
if target.is_file() and target.read_bytes() == data:
|
|
return "ready"
|
|
target.parent.mkdir(parents=True, exist_ok=True)
|
|
target.write_bytes(data)
|
|
return "written"
|
|
except OSError:
|
|
return "failed"
|
|
|
|
|
|
def cpuid_values(raw):
|
|
import struct
|
|
if len(raw) < 80:
|
|
return {}
|
|
regs = [struct.unpack_from("<IIII", raw, 16 * i) for i in range(5)]
|
|
vendor = struct.pack("<III", regs[0][1], regs[0][3], regs[0][2]).split(b"\0")[0].decode("latin-1")
|
|
brand = b"".join(struct.pack("<IIII", *r) for r in regs[2:]).split(b"\0")[0].decode("latin-1")
|
|
return {"cpuVendor": vendor, "cpuEax": "%08X" % regs[1][0], "cpuEdx": "%08X" % regs[1][3],
|
|
"cpuEcx": "%08x" % regs[1][2], "cpuBrand": brand}
|
|
|
|
|
|
EA_PROBE_FIELDS = ("boardManufacturer", "biosManufacturer", "osInstallDate", "osSerial", "volumeSerial", "hostname",
|
|
"cpuVendor", "cpuEax", "cpuEdx", "cpuEcx")
|
|
|
|
|
|
def probe_complete(values):
|
|
return all(str(values.get(key) or "").strip() for key in EA_PROBE_FIELDS)
|
|
|
|
|
|
def ea_hardware(compat_data, proton, timeout=240):
|
|
pfx = Path(compat_data) / "pfx"
|
|
cache = pfx / EA_HARDWARE
|
|
try:
|
|
cached = json.loads(cache.read_text())
|
|
if isinstance(cached, dict) and probe_complete(cached):
|
|
return cached, "cached"
|
|
except (OSError, ValueError):
|
|
pass
|
|
if not proton or not Path(proton).is_file():
|
|
return {}, "no-proton"
|
|
values = {}
|
|
with tempfile.TemporaryDirectory(prefix="droiddeck-ea-") as tmp:
|
|
folder = Path(tmp)
|
|
lines = ["@echo off"]
|
|
for key, cls, prop in EA_WMI:
|
|
lines.append('wmic path %s get %s > "%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) and store != "ea":
|
|
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)
|
|
if not cloud_on(sidecar):
|
|
if store in CLOUD_STORES:
|
|
log("cloud %s %s down result=skipped reason=off" % (store, game))
|
|
return STORE_GAME if store == "ea" else 0
|
|
if launch_dir:
|
|
try:
|
|
answer = ask(Path(launch_dir) / "stores", {"op": "cloud-down", "store": store, "id": game}, timeout=CLOUD_TIMEOUT, claim=True)
|
|
except OSError as error:
|
|
log("cloud %s %s down result=failed reason=%s" % (store, game, type(error).__name__))
|
|
return STORE_GAME
|
|
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)
|