mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 04:46:08 +00:00
Bring the runtime up to date with Bannerlator, and end a session the way proot can survive
From Bannerlator's feat/linux-gamescope-runtime since this repo was cut: - Session teardown (4509d788): proot was SIGKILLed, which never lets its --kill-on-exit cleanup run; its tracees lived on with no tracer, every seccomp-trapped syscall failing with ENOSYS, spinning at a full core for over an hour. Now SIGTERM, a grace for proot's own cleanup, SIGKILL only if it will not go, then a sweep of the tree it had — snapshotted first, each pid checked against its start time. - The Steam client's controller interposer is its own source (fakeinput_steam.cpp, 28922e7c), separate from the one preloaded into Wine. - The seeder runs on a beat so a prefix the client creates mid-session is covered before its install scripts run (6ee86bff). - GE-Proton and proton-cachyos as compatibility tools: the registrar bannerlator-proton-extra and the compat script's adopt_extras (03867656). - space.c in the session shim: a library's own free space, not the phone's. The env-vs-args ordering bug (98d38931) does not apply here: nothing is added after the script name.
This commit is contained in:
1 parent
9ee59066a3
commit
b74aa97996
9 files changed
+622
-12
No files matched your search
@@ -0,0 +1,217 @@
|
||||
#!/usr/bin/python3
|
||||
# Installs a third-party Proton build into the client's compatibilitytools.d, so it appears in the
|
||||
# Compatibility dropdown beside Bannerlator Proton (ARM64) and can be picked per game.
|
||||
#
|
||||
# bannerlator-proton-extra <steam root> ge [--tag GE-Proton11-7]
|
||||
# bannerlator-proton-extra <steam root> cachyos [--tag cachyos-11.0-20260703-slr]
|
||||
# bannerlator-proton-extra <steam root> <url of an aarch64 tarball>
|
||||
# bannerlator-proton-extra <steam root> /path/to/an/aarch64/tarball
|
||||
# bannerlator-proton-extra <steam root> --list what is installed now
|
||||
#
|
||||
# Both projects publish native ARM64 builds - GloriousEggroll as "*-aarch64.tar.gz", CachyOS as
|
||||
# "*-arm64.tar.xz" - and both are ordinary Proton trees: a python entry point beside a files/
|
||||
# directory holding Wine, DXVK and VKD3D. That is the same shape as the depot the Steam client
|
||||
# downloads, so the runtime can run them the same way.
|
||||
#
|
||||
# What it cannot use is their toolmanifest. Like Valve's ARM64 depot they declare
|
||||
# require_tool_appid, which makes Steam stack pressure-vessel underneath - and pressure-vessel
|
||||
# needs unprivileged user namespaces, which an Android app does not get. Patching that out is
|
||||
# bannerlator-steam-compat's job (adopt_extras); this script only puts the tree in place and then
|
||||
# calls it, so an install is usable without restarting the client.
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
|
||||
RELEASES = "https://api.github.com/repos/%s/releases"
|
||||
# Each source: the GitHub repo, and how its ARM64 asset is named. Ordered newest-release-first by
|
||||
# the API, so "latest usable" is the first release that actually carries an ARM64 asset - the
|
||||
# projects do not build one for every tag.
|
||||
SOURCES = {
|
||||
"ge": ("GloriousEggroll/proton-ge-custom", re.compile(r"aarch64\.tar\.(gz|xz)$")),
|
||||
"cachyos": ("CachyOS/proton-cachyos", re.compile(r"arm64\.tar\.(gz|xz)$")),
|
||||
}
|
||||
USER_AGENT = "bannerlator-proton-extra"
|
||||
# Room for the tarball and the tree it unpacks to. GE-Proton's aarch64 build is ~650 MB packed and
|
||||
# unpacks to about three times that; refusing early beats a half-written tool directory.
|
||||
NEED_BYTES = 4 * 1024 * 1024 * 1024
|
||||
|
||||
|
||||
def log(*args):
|
||||
print("bannerlator-proton-extra:", *args, flush=True)
|
||||
|
||||
|
||||
def fetch_json(url):
|
||||
req = urllib.request.Request(url, headers={
|
||||
"User-Agent": USER_AGENT, "Accept": "application/vnd.github+json"})
|
||||
with urllib.request.urlopen(req, timeout=60) as r:
|
||||
return json.load(r)
|
||||
|
||||
|
||||
def pick_asset(source):
|
||||
"""(release tag, asset url, sha512 url or None) for the newest release with an ARM64 build."""
|
||||
repo, pattern = SOURCES[source]
|
||||
for release in fetch_json(RELEASES % repo + "?per_page=15"):
|
||||
if release.get("draft"):
|
||||
continue
|
||||
assets = {a["name"]: a["browser_download_url"] for a in release.get("assets", ())}
|
||||
for name in sorted(assets):
|
||||
if pattern.search(name):
|
||||
sums = [u for n, u in assets.items()
|
||||
if n.startswith(name.split(".tar")[0]) and "sha512" in n]
|
||||
return release["tag_name"], assets[name], (sums[0] if sums else None)
|
||||
return None, None, None
|
||||
|
||||
|
||||
def release_asset(source, tag):
|
||||
repo, pattern = SOURCES[source]
|
||||
release = fetch_json(RELEASES % repo + "/tags/" + tag)
|
||||
assets = {a["name"]: a["browser_download_url"] for a in release.get("assets", ())}
|
||||
for name in sorted(assets):
|
||||
if pattern.search(name):
|
||||
sums = [u for n, u in assets.items()
|
||||
if n.startswith(name.split(".tar")[0]) and "sha512" in n]
|
||||
return tag, assets[name], (sums[0] if sums else None)
|
||||
raise SystemExit("bannerlator-proton-extra: %s has no ARM64 asset" % tag)
|
||||
|
||||
|
||||
def download(url, path):
|
||||
"""Resumable, because this is hundreds of megabytes over a phone's connection. curl is used
|
||||
rather than urllib so a retry continues rather than starting again."""
|
||||
log("downloading %s" % os.path.basename(path))
|
||||
rc = subprocess.call([
|
||||
"curl", "-fL", "--retry", "5", "--retry-delay", "3", "--retry-connrefused",
|
||||
"-C", "-", "-A", USER_AGENT, "-o", path, url])
|
||||
if rc != 0:
|
||||
raise SystemExit("bannerlator-proton-extra: download failed (curl %d)" % rc)
|
||||
log("downloaded %.0f MB" % (os.path.getsize(path) / 1048576.0))
|
||||
|
||||
|
||||
def verify(path, sums_url):
|
||||
if not sums_url:
|
||||
log("no checksum published; skipping verification")
|
||||
return
|
||||
try:
|
||||
req = urllib.request.Request(sums_url, headers={"User-Agent": USER_AGENT})
|
||||
with urllib.request.urlopen(req, timeout=60) as r:
|
||||
want = r.read().decode("utf-8", "replace").split()[0].lower()
|
||||
except (urllib.error.URLError, IndexError, OSError) as e:
|
||||
log("could not read the checksum (%s); skipping verification" % e)
|
||||
return
|
||||
h = hashlib.sha512()
|
||||
with open(path, "rb") as f:
|
||||
for chunk in iter(lambda: f.read(4 << 20), b""):
|
||||
h.update(chunk)
|
||||
if h.hexdigest() != want:
|
||||
os.unlink(path)
|
||||
raise SystemExit("bannerlator-proton-extra: checksum mismatch; the download was deleted")
|
||||
log("checksum ok")
|
||||
|
||||
|
||||
def extract(tarball, into):
|
||||
os.makedirs(into, exist_ok=True)
|
||||
log("unpacking (a few minutes; nothing is shown while tar runs)")
|
||||
rc = subprocess.call(["tar", "-xf", tarball, "-C", into])
|
||||
if rc != 0:
|
||||
raise SystemExit("bannerlator-proton-extra: tar failed (%d)" % rc)
|
||||
# A Proton tarball holds one top-level directory. Take whichever entry has the entry point so a
|
||||
# stray ._ file or a nested layout does not decide it.
|
||||
entries = [e for e in sorted(os.listdir(into)) if not e.startswith(".")]
|
||||
for entry in entries:
|
||||
path = os.path.join(into, entry)
|
||||
if os.path.isdir(path) and os.path.isfile(os.path.join(path, "toolmanifest.vdf")):
|
||||
return path
|
||||
if len(entries) == 1 and os.path.isdir(os.path.join(into, entries[0])):
|
||||
return os.path.join(into, entries[0])
|
||||
raise SystemExit("bannerlator-proton-extra: no Proton tree in the archive")
|
||||
|
||||
|
||||
def installed(tools):
|
||||
out = []
|
||||
for entry in sorted(os.listdir(tools)) if os.path.isdir(tools) else ():
|
||||
if entry.startswith("."):
|
||||
continue
|
||||
if os.path.isfile(os.path.join(tools, entry, "toolmanifest.vdf")):
|
||||
out.append(entry)
|
||||
return out
|
||||
|
||||
|
||||
def main():
|
||||
argv = sys.argv[1:]
|
||||
if not argv:
|
||||
raise SystemExit(__doc__ or "usage: bannerlator-proton-extra <steam root> ge|cachyos|<url>")
|
||||
steam_root = argv.pop(0)
|
||||
tools = os.path.join(steam_root, "compatibilitytools.d")
|
||||
os.makedirs(tools, exist_ok=True)
|
||||
|
||||
if not argv or argv[0] in ("--list", "-l"):
|
||||
for name in installed(tools):
|
||||
log("installed: %s" % name)
|
||||
return
|
||||
|
||||
what = argv.pop(0)
|
||||
tag = None
|
||||
if argv and argv[0] in ("--tag", "-t"):
|
||||
argv.pop(0)
|
||||
tag = argv.pop(0) if argv else None
|
||||
|
||||
# A tarball already on the device is used as it is: a session that has to pull 650 MB down
|
||||
# first shows nothing on screen for ten minutes, so the download can be done ahead of time and
|
||||
# handed over by path.
|
||||
local = None
|
||||
if what in SOURCES:
|
||||
tag, url, sums = release_asset(what, tag) if tag else pick_asset(what)
|
||||
if not url:
|
||||
raise SystemExit("bannerlator-proton-extra: no ARM64 build published for %s" % what)
|
||||
log("%s -> %s" % (what, tag))
|
||||
elif what.startswith("http"):
|
||||
url, sums = what, None
|
||||
elif os.path.isfile(what):
|
||||
local, url, sums = what, None, None
|
||||
log("using %s" % what)
|
||||
else:
|
||||
raise SystemExit(
|
||||
"bannerlator-proton-extra: expected ge, cachyos, a URL or a tarball path, got %r" % what)
|
||||
|
||||
free = shutil.disk_usage(tools).free
|
||||
if free < NEED_BYTES:
|
||||
raise SystemExit("bannerlator-proton-extra: needs about %d GB free, has %.1f GB" % (
|
||||
NEED_BYTES // (1024 ** 3), free / float(1024 ** 3)))
|
||||
|
||||
staging = os.path.join(tools, ".bannerlator-download")
|
||||
os.makedirs(staging, exist_ok=True)
|
||||
if local:
|
||||
tarball = local
|
||||
else:
|
||||
tarball = os.path.join(staging, os.path.basename(url.split("?")[0]))
|
||||
download(url, tarball)
|
||||
verify(tarball, sums)
|
||||
|
||||
unpacked = os.path.join(staging, "unpacked")
|
||||
shutil.rmtree(unpacked, ignore_errors=True)
|
||||
tree = extract(tarball, unpacked)
|
||||
name = os.path.basename(tree)
|
||||
final = os.path.join(tools, name)
|
||||
# Replaced rather than merged: a half-written tree from an interrupted run would otherwise
|
||||
# leave stale files behind that Proton would load.
|
||||
if os.path.exists(final):
|
||||
shutil.rmtree(final, ignore_errors=True)
|
||||
os.rename(tree, final)
|
||||
if local:
|
||||
shutil.rmtree(os.path.join(staging, "unpacked"), ignore_errors=True)
|
||||
else:
|
||||
shutil.rmtree(staging, ignore_errors=True)
|
||||
log("installed %s" % name)
|
||||
|
||||
# Patches out require_tool_appid and wraps the entry point, which is what makes it launchable
|
||||
# here. Doing it now means the client picks the tool up on its next restart with no extra step.
|
||||
subprocess.call(["bannerlator-steam-compat", steam_root])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -118,6 +118,39 @@ case $mode in
|
||||
steam_root=$XDG_DATA_HOME/Steam
|
||||
# Register the card library (bound at /mnt/bannerlator-sd) with the client - internal storage is
|
||||
# its main library already - and the ARM64 Proton that lets it launch the Windows ones.
|
||||
# A request left in ~/.bl-proton-extra installs a third-party Proton before the client starts,
|
||||
# so it is in the Compatibility dropdown the first time the user looks. One per line, each the
|
||||
# arguments to bannerlator-proton-extra: "ge", "cachyos", "ge --tag GE-Proton11-7", or a URL.
|
||||
# Hundreds of megabytes each, so it is only ever done on request, and the line is dropped once
|
||||
# it has succeeded - a failed download stays and is retried next session.
|
||||
if [ -s "$HOME/.bl-proton-extra" ]; then
|
||||
_bl_left=$HOME/.bl-proton-extra.left
|
||||
: > "$_bl_left"
|
||||
while read -r _bl_extra || [ -n "$_bl_extra" ]; do
|
||||
case ${_bl_extra# } in ""|"#"*) continue ;; esac
|
||||
step "installing Proton '$_bl_extra' (large download, several minutes)"
|
||||
if bannerlator-proton-extra "$steam_root" $_bl_extra; then
|
||||
step "installed Proton '$_bl_extra'"
|
||||
else
|
||||
step "Proton '$_bl_extra' failed; will retry next session"
|
||||
echo "$_bl_extra" >> "$_bl_left"
|
||||
fi
|
||||
done < "$HOME/.bl-proton-extra"
|
||||
mv -f "$_bl_left" "$HOME/.bl-proton-extra"
|
||||
fi
|
||||
# steam:// URLs left in ~/.bl-steam-urls are handed to the client on its command line. The app
|
||||
# writes one when the user asks for a Proton that is one of Valve's own depots rather than a
|
||||
# tarball: those are not files anywhere, the client fetches them like any other app. One per
|
||||
# line, and the file is cleared once they have been passed on - the client either acts on a URL
|
||||
# or it does not, and repeating it every session would re-ask forever.
|
||||
if [ -s "$HOME/.bl-steam-urls" ]; then
|
||||
while read -r _bl_url || [ -n "$_bl_url" ]; do
|
||||
case ${_bl_url# } in steam://*) ;; *) continue ;; esac
|
||||
step "asking the client for $_bl_url"
|
||||
set -- "$@" "$_bl_url"
|
||||
done < "$HOME/.bl-steam-urls"
|
||||
rm -f "$HOME/.bl-steam-urls"
|
||||
fi
|
||||
step "registering the app's game library with Steam"
|
||||
bannerlator-steam-library "$steam_root" || true
|
||||
step "setting up the ARM64 Proton compatibility tool"
|
||||
@@ -136,10 +169,27 @@ case $mode in
|
||||
# titles are installed: a title installed this session gets the client's own per-app Proton
|
||||
# choice, which it cannot start. Refresh the per-app entries every so often; the registrar is
|
||||
# idempotent, so a repeat costs nothing.
|
||||
# The seeder has the same problem and a worse consequence. It marks the shared redistributables
|
||||
# as already run in each prefix that exists, and a game's prefix is not created until the
|
||||
# client launches it - so a title played for the first time this session was never covered, and
|
||||
# its install scripts run for real. That is exactly the hang the seeder exists to prevent: Need
|
||||
# for Speed Payback sat on "Running install script" with vcredist_x86.exe blocked in pipe_read,
|
||||
# holding both ends of a pipe nobody would write to, while the client waited for it to exit.
|
||||
# Seeding again on the same beat covers a prefix the moment it appears.
|
||||
# The seeder runs on a shorter beat than the registrar because it is racing something. The
|
||||
# client creates a prefix when it launches a title and runs that title's install scripts
|
||||
# moments later, so the seeder has only that gap to mark the redistributables as already run.
|
||||
# It stamps each prefix it has covered and skips it thereafter, so the extra passes cost
|
||||
# almost nothing.
|
||||
(
|
||||
for _ in $(seq 1 240); do
|
||||
sleep 15
|
||||
bannerlator-steam-compat "$steam_root" >/dev/null 2>&1 || true
|
||||
beat=0
|
||||
for _ in $(seq 1 720); do
|
||||
sleep 5
|
||||
bannerlator-seed-redists "$steam_root" >/dev/null 2>&1 || true
|
||||
beat=$((beat + 1))
|
||||
if [ "$((beat % 3))" -eq 0 ]; then
|
||||
bannerlator-steam-compat "$steam_root" >/dev/null 2>&1 || true
|
||||
fi
|
||||
done
|
||||
) &
|
||||
# Debug aid while the runtime is being brought up: an app id dropped in ~/.bl-autolaunch is
|
||||
|
||||
@@ -100,6 +100,56 @@ echo "bannerlator-proton: no ARM64 Proton depot yet - the client downloads one a
|
||||
exit 1
|
||||
""" % " ".join('"%s"' % n for n in SOURCES)
|
||||
|
||||
# A third-party Proton dropped into compatibilitytools.d - GE-Proton, proton-cachyos, anything of
|
||||
# that shape - is adopted rather than used as shipped, for the same two reasons Valve's ARM64 depot
|
||||
# is: its manifest declares require_tool_appid, and the client's overlay library has to come out of
|
||||
# LD_PRELOAD. Its own entry point is left untouched and called through this wrapper.
|
||||
EXTRA_WRAPPER = "bannerlator-proton-wrap"
|
||||
EXTRA_MANIFEST_VDF = """"manifest"
|
||||
{
|
||||
"version" "2"
|
||||
"commandline" "/%s %%verb%%"
|
||||
"use_sessions" "1"
|
||||
"compatmanager_layer_name" "proton"
|
||||
}
|
||||
""" % EXTRA_WRAPPER
|
||||
# %s is the tool's own entry point, read out of the manifest it shipped with.
|
||||
EXTRA_WRAPPER_SH = """#!/bin/bash
|
||||
# Bannerlator: runs a Proton installed into compatibilitytools.d without the Steam Linux Runtime
|
||||
# container its own manifest asks for - pressure-vessel needs unprivileged user namespaces, which
|
||||
# an Android app does not get, and the launch dies before Proton is reached.
|
||||
verb=$1; shift
|
||||
here=$(dirname "$0")
|
||||
# See bannerlator-proton: in a gamescope session the client's overlay draws nothing, but it stands
|
||||
# in front of open() and read() on /dev/input and answers every read of the session's pad with
|
||||
# nothing - a controller that never reports. Dropped here; anything else in LD_PRELOAD is kept.
|
||||
kept=
|
||||
IFS=': '
|
||||
for lib in ${LD_PRELOAD:-}; do
|
||||
case $lib in */gameoverlayrenderer.so) ;; *) kept=${kept:+$kept:}$lib ;; esac
|
||||
done
|
||||
unset IFS
|
||||
if [ -n "$kept" ]; then export LD_PRELOAD="$kept"; else unset LD_PRELOAD; fi
|
||||
# Proton takes its base directory from dirname(sys.argv[0]) without resolving it, so it has to be
|
||||
# started from its own tree.
|
||||
exec "$here/%s" "$verb" "$@"
|
||||
"""
|
||||
EXTRA_COMPAT_TOOL_VDF = """"compatibilitytools"
|
||||
{
|
||||
"compat_tools"
|
||||
{
|
||||
"%s"
|
||||
{
|
||||
"install_path" "."
|
||||
"display_name" "%s (Bannerlator)"
|
||||
"from_oslist" "windows"
|
||||
"to_oslist" "linux"
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
|
||||
|
||||
TOKEN = re.compile(r'\s*(?:"((?:[^"\\]|\\.)*)"|([{}])|//[^\n]*)')
|
||||
|
||||
|
||||
@@ -169,6 +219,88 @@ def serialize(tokens):
|
||||
return "\n".join(out) + "\n"
|
||||
|
||||
|
||||
def first_key(path, section):
|
||||
"""The single key naming a block inside `section`, or None. Used to keep a third-party tool's
|
||||
own internal name, so a mapping the user already made against it keeps working."""
|
||||
try:
|
||||
with open(path, encoding="utf-8", errors="replace") as f:
|
||||
tokens = tokenize(f.read())
|
||||
except OSError:
|
||||
return None
|
||||
block = find_block(tokens, section)
|
||||
if block is None:
|
||||
return None
|
||||
for i in range(block + 1, block_end(tokens, block)):
|
||||
if tokens[i] == "}":
|
||||
break
|
||||
if i + 1 < len(tokens) and tokens[i + 1] == "{":
|
||||
return tokens[i].strip('"')
|
||||
return None
|
||||
|
||||
|
||||
def manifest_entry_point(path):
|
||||
"""The script a toolmanifest's commandline runs, relative to the tool directory."""
|
||||
try:
|
||||
with open(path, encoding="utf-8", errors="replace") as f:
|
||||
tokens = tokenize(f.read())
|
||||
except OSError:
|
||||
return None
|
||||
for i in range(len(tokens) - 1):
|
||||
if tokens[i].lower() == '"commandline"':
|
||||
command = tokens[i + 1].strip('"').split()
|
||||
if command:
|
||||
return command[0].lstrip("/")
|
||||
return None
|
||||
|
||||
|
||||
def adopt_extras(tools):
|
||||
"""Makes every other Proton in compatibilitytools.d launchable here, and returns the tool names
|
||||
to leave alone in CompatToolMapping - the whole point of installing one is to pick it per game,
|
||||
so register_default must not repoint it back at ours."""
|
||||
adopted = {}
|
||||
try:
|
||||
entries = sorted(os.listdir(tools))
|
||||
except OSError:
|
||||
return adopted
|
||||
for entry in entries:
|
||||
if entry == TOOL or entry.startswith("."):
|
||||
continue
|
||||
tool_dir = os.path.join(tools, entry)
|
||||
manifest = os.path.join(tool_dir, "toolmanifest.vdf")
|
||||
if not os.path.isdir(tool_dir) or not os.path.isfile(manifest):
|
||||
continue
|
||||
# The shipped manifest is kept, once, and stays the source of the entry point: re-running
|
||||
# must not read back our own rewritten commandline and wrap the wrapper.
|
||||
original = manifest + ".bannerlator-orig"
|
||||
if not os.path.isfile(original):
|
||||
try:
|
||||
shutil.copy2(manifest, original)
|
||||
except OSError:
|
||||
continue
|
||||
entry_point = manifest_entry_point(original)
|
||||
if not entry_point or entry_point == EXTRA_WRAPPER:
|
||||
entry_point = "proton"
|
||||
if not os.path.exists(os.path.join(tool_dir, entry_point)):
|
||||
print("bannerlator-steam-compat: %s has no %s; left alone" % (entry, entry_point))
|
||||
continue
|
||||
compat_vdf = os.path.join(tool_dir, "compatibilitytool.vdf")
|
||||
name = first_key(compat_vdf, ["compatibilitytools", "compat_tools"]) or entry
|
||||
wrapper = os.path.join(tool_dir, EXTRA_WRAPPER)
|
||||
try:
|
||||
with open(wrapper, "w", encoding="utf-8") as f:
|
||||
f.write(EXTRA_WRAPPER_SH % entry_point)
|
||||
os.chmod(wrapper, 0o755)
|
||||
with open(manifest, "w", encoding="utf-8") as f:
|
||||
f.write(EXTRA_MANIFEST_VDF)
|
||||
with open(compat_vdf, "w", encoding="utf-8") as f:
|
||||
f.write(EXTRA_COMPAT_TOOL_VDF % (name, entry))
|
||||
except OSError as e:
|
||||
print("bannerlator-steam-compat: could not adopt %s (%s)" % (entry, e))
|
||||
continue
|
||||
adopted[name] = entry
|
||||
return adopted
|
||||
|
||||
|
||||
# Steam's own tools and runtimes live in steamapps beside the games; they are not titles and must
|
||||
# not be mapped to a compatibility tool.
|
||||
NOT_GAMES = frozenset((
|
||||
@@ -200,9 +332,11 @@ def installed_apps(steam_root):
|
||||
return sorted(apps, key=int)
|
||||
|
||||
|
||||
def register_default(config_path, apps=(), name=None):
|
||||
def register_default(config_path, apps=(), name=None, protect=()):
|
||||
"""Writes the mapping. `name` defaults to our own tool; the first-run seed passes Valve's."""
|
||||
tool = name or TOOL
|
||||
# Tool names the user may deliberately have chosen (see adopt_extras); never repointed.
|
||||
keep = {n.lower() for n in protect}
|
||||
with open(config_path, encoding="utf-8", errors="replace") as f:
|
||||
tokens = tokenize(f.read())
|
||||
steam = find_block(tokens, ["InstallConfigStore", "Software", "Valve", "Steam"])
|
||||
@@ -218,7 +352,8 @@ def register_default(config_path, apps=(), name=None):
|
||||
# Repoint every per-app entry the client aimed at a Proton it cannot actually start.
|
||||
for i in range(mapping, block_end(tokens, mapping)):
|
||||
named = tokens[i + 1].strip('"').lower()
|
||||
if tokens[i] == '"name"' and named.startswith("proton") and named != tool:
|
||||
if (tokens[i] == '"name"' and named.startswith("proton")
|
||||
and named != tool.lower() and named not in keep):
|
||||
tokens[i + 1] = '"%s"' % tool
|
||||
if find_block(tokens[mapping + 1:], ["0"]) is None:
|
||||
tokens[mapping + 1:mapping + 1] = entry
|
||||
@@ -270,6 +405,9 @@ def main():
|
||||
tools = os.path.join(steam_root, "compatibilitytools.d")
|
||||
os.makedirs(tools, exist_ok=True)
|
||||
build_tool(os.path.join(tools, TOOL))
|
||||
extras = adopt_extras(tools)
|
||||
for name, directory in sorted(extras.items()):
|
||||
print("bannerlator-steam-compat: adopted %s as %s" % (directory, name))
|
||||
depot = find_source(steam_root)
|
||||
print("bannerlator-steam-compat: registered %s (%s)" % (
|
||||
TOOL, "depot %s present" % os.path.basename(depot) if depot else
|
||||
@@ -277,7 +415,7 @@ def main():
|
||||
config = os.path.join(steam_root, "config", "config.vdf")
|
||||
if os.path.isfile(config):
|
||||
apps = installed_apps(steam_root)
|
||||
register_default(config, apps)
|
||||
register_default(config, apps, protect=extras)
|
||||
print("bannerlator-steam-compat: default and %d installed title(s) set to %s" % (len(apps), TOOL))
|
||||
|
||||
|
||||
|
||||
@@ -11,7 +11,10 @@ import sys
|
||||
|
||||
# The client's own library is internal storage (its steamapps/common is bound to the app's root);
|
||||
# the card is the one extra library folder.
|
||||
LIBRARIES = (("/mnt/bannerlator-sd", "Bannerlator (card)"),)
|
||||
LIBRARIES = (("/mnt/bannerlator-sd", "SD Card"),)
|
||||
# The client calls its own library "Local Drive (/)", which says nothing about where that is.
|
||||
# It is the phone's internal storage, so say so.
|
||||
MAIN_LABEL = "Internal Storage"
|
||||
|
||||
|
||||
def register(steam_root, library, label):
|
||||
@@ -92,12 +95,64 @@ def forget(steam_root, library):
|
||||
print("bannerlator-steam-library: forgot %s" % library)
|
||||
|
||||
|
||||
def relabel(steam_root, target, label):
|
||||
"""Names a library for what it is. The client writes its own entry with an empty label and
|
||||
falls back to showing the mount point - "Local Drive (/)" - so the install dialog gives no
|
||||
clue which of the two places is the phone and which is the card. A library registered on an
|
||||
earlier run keeps whatever label it was given then, so both are named here every time."""
|
||||
path = os.path.join(steam_root, "steamapps", "libraryfolders.vdf")
|
||||
if not os.path.isfile(path):
|
||||
return
|
||||
with open(path, encoding="utf-8", errors="replace") as f:
|
||||
lines = f.read().split("\n")
|
||||
out, depth, block, changed = [], 0, None, False
|
||||
for line in lines:
|
||||
if depth == 1 and re.fullmatch(r'\t"\d+"', line):
|
||||
block = [line]
|
||||
continue
|
||||
if block is not None:
|
||||
block.append(line)
|
||||
depth += line.count("{") - line.count("}")
|
||||
if depth == 1:
|
||||
text = "\n".join(block)
|
||||
if re.search(r'"path"\s+"%s"' % re.escape(target), text):
|
||||
new = re.sub(r'("label"\s+")[^"]*(")', r"\g<1>%s\g<2>" % label, text, count=1)
|
||||
if new != text:
|
||||
changed = True
|
||||
text = new
|
||||
out.extend(text.split("\n"))
|
||||
block = None
|
||||
continue
|
||||
depth += line.count("{") - line.count("}")
|
||||
out.append(line)
|
||||
if changed:
|
||||
with open(path, "w", encoding="utf-8") as f:
|
||||
f.write("\n".join(out))
|
||||
print("bannerlator-steam-library: labelled %s %r" % (target, label))
|
||||
# A library also carries its own libraryfolder.vdf, and the client takes the label from there
|
||||
# back into the list above - so editing the list alone is undone on the next start. The
|
||||
# client's own library has no such file, which is why that one kept the new name and the card
|
||||
# went back to the name it was first registered with.
|
||||
marker = os.path.join(target, "libraryfolder.vdf")
|
||||
if not os.path.isfile(marker):
|
||||
return
|
||||
with open(marker, encoding="utf-8", errors="replace") as f:
|
||||
text = f.read()
|
||||
new = re.sub(r'("label"\s+")[^"]*(")', r"\g<1>%s\g<2>" % label, text, count=1)
|
||||
if new != text:
|
||||
with open(marker, "w", encoding="utf-8") as f:
|
||||
f.write(new)
|
||||
print("bannerlator-steam-library: labelled %s in its own marker too" % target)
|
||||
|
||||
|
||||
def main():
|
||||
steam_root = sys.argv[1]
|
||||
for library in RETIRED:
|
||||
forget(steam_root, library)
|
||||
relabel(steam_root, steam_root, MAIN_LABEL)
|
||||
for library, label in LIBRARIES:
|
||||
register(steam_root, library, label)
|
||||
relabel(steam_root, library, label)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
/*
|
||||
* The free space a library reports.
|
||||
*
|
||||
* A library's games can live somewhere the folder that names the library does not. The card
|
||||
* library is exactly that: its steamapps/common is bound to the card, but the directory above it
|
||||
* belongs to the runtime image in the phone's own storage, and that directory is what the client
|
||||
* measures. So it offers both install locations with the phone's free space against each, and the
|
||||
* card's real figure - seventeen gigabytes more, on the device this was found on - never appears.
|
||||
*
|
||||
* The number is not only cosmetic: the client refuses an install it believes will not fit. Once
|
||||
* the phone fills up it would turn down a card install with room to spare, and say nothing about
|
||||
* why.
|
||||
*
|
||||
* Moving the whole library onto the card would fix the number and break something worse. The
|
||||
* prefixes under steamapps/compatdata want symlinks and file locks, and the card is served over
|
||||
* FUSE, which gives us neither - that is why they are kept in the runtime image in the first
|
||||
* place. So the question is answered where the content actually is: a query about a library root
|
||||
* named in BL_LIBRARY_SPACE is served from its steamapps/common, the bind that points at the
|
||||
* card. Every other path is passed through untouched.
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include <dlfcn.h>
|
||||
#include <stddef.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/statfs.h>
|
||||
#include <sys/statvfs.h>
|
||||
|
||||
/* A library root, or its steamapps, resolved to the directory that holds the games. Returns the
|
||||
* rewritten path in `buf`, or NULL when `path` is not one of ours and should be left alone. */
|
||||
static const char *content_of(const char *path, char *buf, size_t len) {
|
||||
const char *roots = getenv("BL_LIBRARY_SPACE");
|
||||
if (!path || !roots || !*roots)
|
||||
return NULL;
|
||||
|
||||
size_t path_len = strlen(path);
|
||||
while (*roots) {
|
||||
const char *end = strchr(roots, ':');
|
||||
size_t root_len = end ? (size_t)(end - roots) : strlen(roots);
|
||||
if (root_len > 0) {
|
||||
/* The root itself, or the steamapps directly beneath it. Anything deeper is already inside
|
||||
* a bind and answers for itself. */
|
||||
int match = (path_len == root_len && !strncmp(path, roots, root_len)) ||
|
||||
(path_len == root_len + 10 && !strncmp(path, roots, root_len) &&
|
||||
!strcmp(path + root_len, "/steamapps"));
|
||||
if (match) {
|
||||
if (root_len + sizeof("/steamapps/common") > len)
|
||||
return NULL;
|
||||
memcpy(buf, roots, root_len);
|
||||
strcpy(buf + root_len, "/steamapps/common");
|
||||
return buf;
|
||||
}
|
||||
}
|
||||
if (!end)
|
||||
break;
|
||||
roots = end + 1;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#define FORWARD(name, type) \
|
||||
int name(const char *path, type *out) { \
|
||||
static int (*real)(const char *, type *); \
|
||||
char buf[4096]; \
|
||||
const char *content; \
|
||||
if (!real) \
|
||||
real = dlsym(RTLD_NEXT, #name); \
|
||||
if (!real) \
|
||||
return -1; \
|
||||
content = content_of(path, buf, sizeof(buf)); \
|
||||
return real(content ? content : path, out); \
|
||||
}
|
||||
|
||||
FORWARD(statfs, struct statfs)
|
||||
FORWARD(statvfs, struct statvfs)
|
||||
#ifdef __USE_LARGEFILE64
|
||||
FORWARD(statfs64, struct statfs64)
|
||||
FORWARD(statvfs64, struct statvfs64)
|
||||
#endif
|
||||
Reference in new issue
Block a user