mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-20 05:16:01 +00:00
447 lines
19 KiB
Python
Executable File
447 lines
19 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Resolve added games against the signed-in Steam client's licenses."""
|
|
import ctypes as C
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
import unicodedata
|
|
import urllib.parse
|
|
import urllib.request
|
|
|
|
STATE = ".droiddeck-games.json"
|
|
WINNATIVE = ".winnative-steam/steamapps"
|
|
LIBRARY = "/mnt/droiddeck-sd"
|
|
LEGACY_LIBRARY = "/mnt/bannerlator-sd"
|
|
PARKED = ".droiddeck-parked"
|
|
BASE_ID = 76561197960265728
|
|
|
|
|
|
def read_json(path, default):
|
|
try:
|
|
return json.loads(Path(path).read_text())
|
|
except (OSError, ValueError):
|
|
return default
|
|
|
|
|
|
def save_json(path, value):
|
|
path = Path(path)
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
temp = path.with_suffix(".tmp")
|
|
temp.write_text(json.dumps(value))
|
|
os.replace(temp, path)
|
|
|
|
|
|
def title_key(name):
|
|
return "".join(c for c in unicodedata.normalize("NFKC", name.replace("™", "").replace("®", "")).casefold() if c.isalnum())
|
|
|
|
|
|
def edition_key(name):
|
|
name = re.sub(r"(?i)\s+(?:windows edition|intergrade)\s*$", "", name)
|
|
return title_key(name)
|
|
|
|
|
|
def legacy_path(path):
|
|
path = str(path)
|
|
return LEGACY_LIBRARY + path[len(LIBRARY):] if path == LIBRARY or path.startswith(LIBRARY + "/") else path
|
|
|
|
|
|
def source_stamp(game):
|
|
try:
|
|
exe = Path(game["exe"])
|
|
stat = exe.stat()
|
|
hints = []
|
|
for parent in sorted({Path(game["folder"]), exe.parent}):
|
|
hint = parent / "steam_appid.txt"
|
|
hints.append(hint.read_text().strip() if hint.is_file() else "")
|
|
return [game["name"], str(exe), stat.st_size, stat.st_mtime_ns, hints]
|
|
except (OSError, ValueError):
|
|
return None
|
|
|
|
|
|
def store_game(game):
|
|
"""Games a store client installed belong to that store: the Steam copy of the same title is
|
|
another license with its own files, and an import would let Steam update over the store's."""
|
|
return bool(game.get("store"))
|
|
|
|
|
|
def manifest_ids(steamapps, name):
|
|
matches = []
|
|
for manifest in Path(steamapps).glob("appmanifest_*.acf"):
|
|
try:
|
|
install = re.search(r'"installdir"\s*"([^"\\]*)"', manifest.read_text(), re.I)
|
|
if install and install[1] == name:
|
|
matches.append(int(manifest.stem.removeprefix("appmanifest_")))
|
|
except (OSError, ValueError):
|
|
pass
|
|
return matches
|
|
|
|
|
|
def identify(game):
|
|
folder = Path(game["folder"])
|
|
steamapps = folder.parent.parent
|
|
for library in ([steamapps] if folder.parent.name == "common" and steamapps.name == "steamapps" else []) + [folder.parent / WINNATIVE]:
|
|
matches = manifest_ids(library, folder.name)
|
|
if matches:
|
|
return matches[0] if len(matches) == 1 else None
|
|
ids = set()
|
|
for parent in {folder, Path(game["exe"]).parent}:
|
|
try:
|
|
appid = int((parent / "steam_appid.txt").read_text().strip())
|
|
if 0 < appid < 0x80000000:
|
|
ids.add(appid)
|
|
except (OSError, ValueError):
|
|
pass
|
|
if ids:
|
|
return next(iter(ids)) if len(ids) == 1 else None
|
|
url = "https://store.steampowered.com/api/storesearch/?l=english&cc=US&term=" + urllib.parse.quote(game["name"])
|
|
try:
|
|
with urllib.request.urlopen(url, timeout=5) as response:
|
|
items = json.loads(response.read(1024 * 1024)).get("items", [])
|
|
for key in (title_key, edition_key):
|
|
ids = {int(item["id"]) for item in items
|
|
if key(item.get("name", "")) == key(game["name"]) and key(game["name"])}
|
|
if ids:
|
|
return next(iter(ids)) if len(ids) == 1 else None
|
|
return None
|
|
except (OSError, ValueError, KeyError):
|
|
return None
|
|
|
|
|
|
def method(obj, slot, result, *args):
|
|
if not obj:
|
|
raise RuntimeError("Steam interface unavailable")
|
|
table = C.cast(obj, C.POINTER(C.POINTER(C.c_void_p))).contents
|
|
return C.CFUNCTYPE(result, C.c_void_p, *args)(table[slot])
|
|
|
|
|
|
def probe(steam_root, ids):
|
|
library = C.CDLL(str(Path(steam_root) / "steamrtarm64/steamclient.so"))
|
|
library.CreateInterface.argtypes = [C.c_char_p, C.c_void_p]
|
|
library.CreateInterface.restype = C.c_void_p
|
|
client = library.CreateInterface(b"SteamClient020", None)
|
|
pipe = method(client, 0, C.c_int)(client)
|
|
if not pipe:
|
|
raise RuntimeError("Steam pipe unavailable")
|
|
user = 0
|
|
try:
|
|
user = method(client, 2, C.c_int, C.c_int)(client, pipe)
|
|
if not user:
|
|
raise RuntimeError("No signed-in Steam user")
|
|
get_interface = lambda slot, version: method(client, slot, C.c_void_p, C.c_int, C.c_int, C.c_char_p)(client, user, pipe, version)
|
|
account = get_interface(5, b"SteamUser021")
|
|
if not method(account, 1, C.c_bool)(account):
|
|
raise RuntimeError("Steam is offline")
|
|
steamid = method(account, 2, C.c_uint64)(account)
|
|
apps = get_interface(15, b"STEAMAPPS_INTERFACE_VERSION008")
|
|
subscribed = method(apps, 6, C.c_bool, C.c_uint32)
|
|
return {"account": str(steamid - BASE_ID), "checked": time.time(),
|
|
"owned": {str(appid): bool(subscribed(apps, appid)) for appid in ids}}
|
|
finally:
|
|
if user:
|
|
method(client, 4, None, C.c_int, C.c_int)(client, pipe, user)
|
|
method(client, 1, C.c_bool, C.c_int)(client, pipe)
|
|
|
|
|
|
def game_running():
|
|
"""Whether a Proton game is up: a wineserver is there for as long as any prefix is in use."""
|
|
try:
|
|
pids = [p for p in os.listdir("/proc") if p.isdigit()]
|
|
except OSError:
|
|
return False
|
|
for pid in pids:
|
|
try:
|
|
with open("/proc/%s/comm" % pid) as f:
|
|
if f.read().strip() == "wineserver":
|
|
return True
|
|
except OSError:
|
|
pass
|
|
return False
|
|
|
|
|
|
def downloads_idle(steam_root):
|
|
try:
|
|
return not any(Path(steam_root, "steamapps/downloading").iterdir())
|
|
except OSError:
|
|
return True
|
|
|
|
|
|
def request_restart(steam_root):
|
|
"""The client reads manifests and shortcuts only at start, so an import needs one restart;
|
|
the session's loop runs the importer between the exit and the next start."""
|
|
Path(os.environ.get("HOME", "/root"), ".bl-restart-once").touch()
|
|
subprocess.run([str(Path(steam_root) / "steamrtarm64/steam"), "-shutdown"],
|
|
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=30)
|
|
|
|
|
|
def unimported(steam_root, snapshot, candidates):
|
|
routes = read_json(Path(steam_root) / "userdata" / snapshot["account"] / "config/.droiddeck-routes.json", {})
|
|
routed = set(routes.values()) if isinstance(routes, dict) else set()
|
|
return sorted({appid for appid in candidates.values() if snapshot["owned"].get(str(appid)) is True} - routed)
|
|
|
|
|
|
def watch(steam_root, listing):
|
|
games = [game for game in read_json(listing, []) if not store_game(game)]
|
|
if os.environ.get("BL_STEAM_OFFLINE") == "1" or not games:
|
|
return
|
|
candidates, sources = {}, {}
|
|
next_lookup = 0
|
|
last_status = None
|
|
probed, next_probe, failures = None, 0, 0
|
|
pending, requested = [], []
|
|
while True:
|
|
now = time.monotonic()
|
|
for game in games:
|
|
folder = game["folder"]
|
|
stamp = source_stamp(game)
|
|
if now >= next_lookup or stamp != sources.get(folder):
|
|
sources[folder] = stamp
|
|
appid = identify(game)
|
|
if appid:
|
|
candidates[folder] = appid
|
|
else:
|
|
candidates.pop(folder, None)
|
|
if now >= next_lookup:
|
|
next_lookup = now + 300
|
|
status = "waiting for a matching Steam title"
|
|
key = (dict(candidates), dict(sources))
|
|
if candidates and (key != probed or now >= next_probe) and game_running():
|
|
status = last_status
|
|
elif candidates and (key != probed or now >= next_probe):
|
|
probed, next_probe = key, now + 300
|
|
try:
|
|
result = subprocess.run([sys.executable, __file__, "probe", steam_root,
|
|
*map(str, sorted(set(candidates.values())))],
|
|
capture_output=True, text=True, timeout=15)
|
|
if result.returncode != 0:
|
|
status = "ownership probe failed: " + (result.stderr.strip()[-300:] or str(result.returncode))
|
|
failures += 1
|
|
next_probe = now + min(300, 30 * 2 ** failures)
|
|
else:
|
|
failures = 0
|
|
line = next(line for line in result.stdout.splitlines() if line.startswith("DROIDDECK_OWNERSHIP="))
|
|
snapshot = json.loads(line.removeprefix("DROIDDECK_OWNERSHIP="))
|
|
if not snapshot["account"].isdigit() or int(snapshot["account"]) <= 0:
|
|
raise ValueError("invalid Steam account")
|
|
snapshot["candidates"] = candidates
|
|
snapshot["sources"] = sources
|
|
save_json(Path(steam_root) / "userdata" / snapshot["account"] / "config" / STATE, snapshot)
|
|
pending = unimported(steam_root, snapshot, candidates)
|
|
status = "matched %d/%d games; %d owned" % (len(candidates), len(games), sum(snapshot["owned"].values()))
|
|
except (OSError, ValueError, KeyError, StopIteration, subprocess.TimeoutExpired) as error:
|
|
status = "ownership check unavailable: " + str(error)
|
|
failures += 1
|
|
next_probe = now + min(300, 30 * 2 ** failures)
|
|
elif candidates:
|
|
status = last_status
|
|
if pending and pending != requested and not game_running() and downloads_idle(steam_root):
|
|
requested = pending
|
|
print("droiddeck-steam-games: restarting the client once to import %s" % pending, flush=True)
|
|
try:
|
|
request_restart(steam_root)
|
|
except (OSError, subprocess.TimeoutExpired) as error:
|
|
print("droiddeck-steam-games: restart unavailable: %s" % error, flush=True)
|
|
if status != last_status:
|
|
print("droiddeck-steam-games: " + status, flush=True)
|
|
last_status = status
|
|
time.sleep(30)
|
|
|
|
|
|
def installed_build(folder, appid, installdir):
|
|
"""The build another Steam client recorded for these files, so Steam updates from it
|
|
instead of verifying every file."""
|
|
try:
|
|
text = (folder.parent / WINNATIVE / f"appmanifest_{appid}.acf").read_text()
|
|
install = re.search(r'("installdir"\s*")([^"\\]*)(")', text, re.I)
|
|
flags = re.search(r'"StateFlags"\s*"(\d+)"', text)
|
|
if (install and install[2] == folder.name and flags and flags[1] == "4"
|
|
and re.search(rf'"appid"\s*"{appid}"', text) and '"InstalledDepots"' in text):
|
|
return text[:install.start(2)] + installdir + text[install.end(2):]
|
|
except OSError:
|
|
pass
|
|
if not (folder / ".download_complete").is_file():
|
|
return None
|
|
try:
|
|
ids = json.loads((folder / ".DepotDownloader/depot.config").read_text())["installedManifestIDs"]
|
|
depots = sorted((int(depot), int(gid)) for depot, gid in ids.items())
|
|
except (OSError, ValueError, KeyError, TypeError, AttributeError):
|
|
return None
|
|
if not depots or not all(0 < depot < 0x80000000 and 0 < gid < 0x7FFFFFFFFFFFFFFF for depot, gid in depots):
|
|
return None
|
|
return "".join(f' "{depot}"\n {{\n "manifest" "{gid}"\n }}\n' for depot, gid in depots)
|
|
|
|
|
|
def update_not_started(text, steamapps, appid, installdir):
|
|
fields = dict(re.findall(r'^\s*"(\w+)"\s*"([^"]*)"', text, re.M))
|
|
return (fields.get("installdir") == installdir and fields.get("buildid", "0") == "0"
|
|
and fields.get("BytesDownloaded", "0") == "0" and fields.get("BytesStaged", "0") == "0"
|
|
and re.search(r'"InstalledDepots"\s*\{\s*\}', text) is not None
|
|
and not (steamapps / "downloading" / str(appid)).exists())
|
|
|
|
|
|
def libraries(steam_root):
|
|
try:
|
|
text = (Path(steam_root) / "steamapps/libraryfolders.vdf").read_text(errors="replace")
|
|
except OSError:
|
|
text = ""
|
|
paths = [path.replace("\\\\", "\\") for path in re.findall(r'"path"\s+"((?:[^"\\]|\\.)*)"', text)]
|
|
return list(dict.fromkeys([Path(steam_root), Path(LIBRARY)] + [Path(path) for path in paths]))
|
|
|
|
|
|
def ours(manifest, appid):
|
|
try:
|
|
return re.search(rf'"installdir"\s*"DroidDeck-{appid}"', manifest.read_text(errors="replace")) is not None
|
|
except OSError:
|
|
return False
|
|
|
|
|
|
def unpark(steamapps):
|
|
for manifest in sorted((steamapps / PARKED).glob("appmanifest_*.acf")):
|
|
appid = manifest.stem.removeprefix("appmanifest_")
|
|
live = steamapps / manifest.name
|
|
if os.path.lexists(live):
|
|
manifest.unlink(missing_ok=True)
|
|
elif (steamapps / "common" / f"DroidDeck-{appid}").is_dir():
|
|
os.replace(manifest, live)
|
|
|
|
|
|
def park(steamapps):
|
|
for target in sorted((steamapps / "common").glob("DroidDeck-*")):
|
|
appid = target.name.removeprefix("DroidDeck-")
|
|
manifest = steamapps / f"appmanifest_{appid}.acf"
|
|
if appid.isdigit() and target.is_symlink() and not target.exists() and manifest.is_file() and ours(manifest, appid):
|
|
(steamapps / PARKED).mkdir(exist_ok=True)
|
|
os.replace(manifest, steamapps / PARKED / manifest.name)
|
|
print(f"droiddeck-steam-games: {appid} is not here this session; its install is set aside until it is")
|
|
|
|
|
|
def seed_install(steam_root, game, appid):
|
|
steamapps = Path(steam_root) / "steamapps"
|
|
common = steamapps / "common"
|
|
name = f"DroidDeck-{appid}"
|
|
target = common / name
|
|
source = Path(game["folder"])
|
|
title = game["name"].replace("\\", "\\\\").replace('"', '\\"').replace("\n", " ").replace("\r", " ")
|
|
minimal = ('"AppState"\n{\n' + f' "appid" "{appid}"\n "Universe" "1"\n "name" "{title}"\n'
|
|
+ f' "StateFlags" "4"\n "installdir" "{name}"\n' + '}\n')
|
|
legacy = minimal.replace(' "Universe" "1"\n', '')
|
|
build = installed_build(source, appid, name)
|
|
if build is None:
|
|
content = minimal
|
|
elif build.lstrip().startswith('"AppState"'):
|
|
content = build
|
|
else:
|
|
content = minimal[:-2] + ' "InstalledDepots"\n {\n' + build + ' }\n}\n'
|
|
manifest = steamapps / f"appmanifest_{appid}.acf"
|
|
if target.is_symlink() and os.readlink(target) != str(source) and os.readlink(target) == legacy_path(source):
|
|
relink = target.with_name(name + ".droiddeck")
|
|
relink.unlink(missing_ok=True)
|
|
relink.symlink_to(source, target_is_directory=True)
|
|
os.replace(relink, target)
|
|
for root in libraries(steam_root):
|
|
existing = root / "steamapps" / manifest.name
|
|
if existing.is_file():
|
|
if (existing == manifest and source.is_dir() and target.is_symlink()
|
|
and os.readlink(target) == str(source)
|
|
and existing.read_text() != content
|
|
and (existing.read_text() in (minimal, legacy, legacy.replace('"StateFlags" "4"', '"StateFlags" "2"'))
|
|
or (build is not None and update_not_started(existing.read_text(), steamapps, appid, name)))):
|
|
temp = manifest.with_suffix(".droiddeck")
|
|
temp.write_text(content)
|
|
os.replace(temp, manifest)
|
|
return True
|
|
if not source.is_dir():
|
|
return False
|
|
common.mkdir(parents=True, exist_ok=True)
|
|
if os.path.lexists(target):
|
|
if not target.is_symlink() or os.readlink(target) != str(source):
|
|
return False
|
|
else:
|
|
target.symlink_to(source, target_is_directory=True)
|
|
try:
|
|
with manifest.open("x") as output:
|
|
output.write(content)
|
|
except FileExistsError:
|
|
pass
|
|
return True
|
|
|
|
|
|
def release(steam_root, game):
|
|
"""Undoes an import made before store games were skipped. Only our symlink and manifest go;
|
|
the store's folder stays where it is."""
|
|
steamapps = Path(steam_root) / "steamapps"
|
|
sources = {game.get("folder", ""), legacy_path(game.get("folder", ""))}
|
|
for target in sorted((steamapps / "common").glob("DroidDeck-*")):
|
|
appid = target.name.removeprefix("DroidDeck-")
|
|
if not (appid.isdigit() and target.is_symlink() and os.readlink(target) in sources):
|
|
continue
|
|
for manifest in (steamapps / f"appmanifest_{appid}.acf", steamapps / PARKED / f"appmanifest_{appid}.acf"):
|
|
if manifest.is_file() and ours(manifest, appid):
|
|
manifest.unlink()
|
|
target.unlink()
|
|
print(f"droiddeck-steam-games: {game.get('name', appid)} came from {game['store']}; it is a shortcut again, not Steam app {appid}")
|
|
|
|
|
|
def route(steam_root, acct, games):
|
|
snapshot = read_json(Path(acct) / "config" / STATE, {})
|
|
if not isinstance(snapshot, dict):
|
|
snapshot = {}
|
|
owned = snapshot.get("owned", {}) if snapshot.get("account") == Path(acct).name else {}
|
|
candidates = snapshot.get("candidates", {})
|
|
sources = snapshot.get("sources", {})
|
|
if not all(isinstance(value, dict) for value in (owned, candidates, sources)):
|
|
owned, candidates, sources = {}, {}, {}
|
|
shortcuts, routes = [], {}
|
|
steamapps = Path(steam_root) / "steamapps"
|
|
try:
|
|
unpark(steamapps)
|
|
except OSError as error:
|
|
print(f"droiddeck-steam-games: set-aside installs not restored ({error})")
|
|
for game in games:
|
|
if store_game(game):
|
|
try:
|
|
release(steam_root, game)
|
|
except OSError as error:
|
|
print(f"droiddeck-steam-games: store import not undone ({error})")
|
|
shortcuts.append(game)
|
|
continue
|
|
folder = game.get("folder", "")
|
|
appid = candidates.get(folder, candidates.get(legacy_path(folder)))
|
|
stamp = source_stamp(game)
|
|
recorded = sources.get(folder, sources.get(legacy_path(folder)))
|
|
confirmed = (isinstance(appid, int) and 0 < appid < 0x80000000
|
|
and owned.get(str(appid)) is True and stamp is not None
|
|
and recorded in (stamp, [stamp[0], legacy_path(stamp[1])] + stamp[2:]))
|
|
if confirmed:
|
|
try:
|
|
if seed_install(steam_root, game, appid):
|
|
routes[str(game["appid"])] = appid
|
|
continue
|
|
except OSError as error:
|
|
print(f"droiddeck-steam-games: import unavailable ({error})")
|
|
shortcuts.append(game)
|
|
try:
|
|
park(steamapps)
|
|
except OSError as error:
|
|
print(f"droiddeck-steam-games: missing installs not set aside ({error})")
|
|
save_json(Path(acct) / "config/.droiddeck-routes.json", routes)
|
|
return shortcuts, routes
|
|
|
|
|
|
if __name__ == "__main__":
|
|
if len(sys.argv) < 4:
|
|
sys.exit(2)
|
|
try:
|
|
if sys.argv[1] == "probe":
|
|
print("DROIDDECK_OWNERSHIP=" + json.dumps(probe(sys.argv[2], [int(value) for value in sys.argv[3:]])), flush=True)
|
|
elif sys.argv[1] == "watch":
|
|
watch(sys.argv[2], sys.argv[3])
|
|
else:
|
|
sys.exit(2)
|
|
except (OSError, RuntimeError, ValueError) as error:
|
|
print(str(error), file=sys.stderr)
|
|
sys.exit(1)
|