Files
DroidDeck/tools/linuxfs/overlay/usr/local/bin/droiddeck-epic
T
2026-11-15 09:36:27 -05:00

1955 lines
67 KiB
Python

#!/usr/bin/python3
import contextlib
import collections
import fcntl
import filecmp
import http.client
import json
import os
import re
import runpy
import select
import shutil
import signal
import socket
import subprocess
import sys
import tarfile
import threading
import time
import urllib.error
import urllib.parse
import urllib.request
HOME = os.environ.get("HOME") or "/root"
SELF = os.path.abspath(__file__)
BIN_DIR = os.path.dirname(SELF)
GAME_DEBUG = runpy.run_path(os.path.join(BIN_DIR, "droiddeck-game-debug"))
STATE = os.path.join(HOME, ".local", "share", "droiddeck-epic")
CURRENT = os.path.join(STATE, "current.json")
APPS = os.path.join(STATE, "app")
RUNTIMES = os.path.join(STATE, "runtime")
LOGS = os.path.join(STATE, "logs")
SHIMS = os.path.join(STATE, "bin")
FEX_CONFIG = os.path.join(STATE, "fex")
FEX_CACHE = os.path.join(HOME, ".cache", "droiddeck-epic")
DATA = os.path.join(HOME, ".local", "share", "com.epicgames.eglv2")
SETTINGS = os.path.join(DATA, "settings", "app-settings.json")
API_FILE = os.path.join(DATA, "api.json")
INSTALLATIONS = os.path.join(DATA, "installations.jsonl")
STEAM_RUN = re.compile(r"^steam://(?:rungameid|run)/([1-9][0-9]{0,19})(?:[/?].*)?$")
V1_MANIFESTS = os.path.join(HOME, ".local", "share", "Epic", "EpicGamesLauncher", "Data", "Manifests")
AUTH_FILE = os.path.join(DATA, "auth", "auth.json")
AUTH_ENV = "prod"
AUTO_SIGN_IN = os.path.join(STATE, "auto-sign-in")
SIGNED_OUT = os.path.join(STATE, "signed-out")
WEB_COOKIES = os.path.join(DATA, "cookies")
A11Y_OFF = ("NO_AT_BRIDGE", "GTK_A11Y")
A11Y_WEB_ROOT = "/org/a11y/webkit/accessible"
A11Y_LIMIT = 4000
A11Y_BUDGET = 3.0
A11Y_ACCESSIBLE = "org.a11y.atspi.Accessible"
FIRST_RUN_LABEL = "Get started"
SIGN_IN_LABEL = "Sign in"
PROTON_ROOT = os.path.join(DATA, "compat", "runtime")
PROTON_PIN = "GE-Proton10-34"
PROTON_RUN = os.path.join(BIN_DIR, "droiddeck-proton-run")
LAUNCH_DIR_FILE = "/tmp/droiddeck-browser/launch-dir"
WEBKIT_INPUT = "libwebkitinput.so"
WEBKIT_INPUT_SOURCE = "/usr/local/lib/droiddeck-fex/x86_64/" + WEBKIT_INPUT
WEBKIT_INPUT_GUEST = "/usr/lib/x86_64-linux-gnu/droiddeck/" + WEBKIT_INPUT
PLAYING = "epic-playing"
OPEN = "epic-open"
STEAM_PRELOAD = "DROIDDECK_STEAM_PRELOAD"
STEAM_ANCESTORS = 32
READY = ".droiddeck-ready"
SIDECAR = ".droiddeck-store.json"
LAUNCHER = ".droiddeck-launch.bat"
ARGS_FILE = ".droiddeck-epic-args"
HANDLED = "DROIDDECK_EPIC_HANDLED"
BROKER_ENV = "DROIDDECK_EPIC_BROKER"
APP_ID = "com.epicgames.eglv2"
DBUS_NAME = APP_ID + ".SingleInstance"
DBUS_PATH = "/" + APP_ID.replace(".", "/") + "/SingleInstance"
DBUS_METHOD = "org.SingleInstance.DBus.ExecuteCallback"
APP_BIN = "usr/bin/EpicGamesLauncher"
DEB_ICON = "usr/share/icons/hicolor/256x256@2/apps/EpicGamesLauncher.png"
ICON = "epic-games-launcher.png"
DESKTOP = "desktop"
DESKTOP_KEEP = ("usr/lib/x86_64-linux-gnu/", "usr/share/glib-2.0/schemas/")
DESKTOP_LIB = DESKTOP + "/usr/lib/x86_64-linux-gnu"
WEBKIT_DIR = "webkit2gtk-4.1"
WEBKIT_LIB = "libwebkit2gtk-4.1.so.0"
SKIPPED = ("lib/i386-linux-gnu", "lib32", "libx32", "i686-pc-linux-gnu", "share/doc", "include")
SETTINGS_SEED = {
"minimizeToTray": False,
"startOnBoot": False,
"cloudSavesEnabled": False,
"automaticDownloadsEnabled": False,
"autoLaunchOnDownloadComplete": False,
"showWhatsNewOnStartup": False,
"suppressNotificationsWhileGaming": True,
"verboseLogs": False,
"v1Migrated": True,
}
CLIENT_ENV = {
"EGL_DISABLE_TELEMETRY": "1",
"EGL_DISABLE_SENTRY": "1",
"EGL_DISABLE_SELF_UPDATE": "1",
"EGL_DISABLE_SOCIAL_PANEL": "1",
"EGL_PROTON_PIN": PROTON_PIN,
"WEBKIT_DISABLE_SANDBOX_THIS_IS_DANGEROUS": "1",
"WEBKIT_DISABLE_COMPOSITING_MODE": "1",
"WEBKIT_DISABLE_DMABUF_RENDERER": "1",
"WEBKIT_SKIA_ENABLE_CPU_RENDERING": "1",
"NO_AT_BRIDGE": "1",
"GTK_A11Y": "none",
"LIBGL_ALWAYS_SOFTWARE": "1",
"JSC_useDFGJIT": "0",
"JSC_useFTLJIT": "0",
}
HIDDEN_ENV = {
"DROIDDECK_EPIC_HIDDEN": "1",
"EGL_DISABLE_STORE_PREWARM": "1",
}
KEPT_ENV = ("HOME", "USER", "LOGNAME", "LANG", "LANGUAGE", "LC_ALL", "LC_MESSAGES", "TZ", "XDG_RUNTIME_DIR", "BL_LAUNCH_DIR")
LAUNCH_VERBS = ("waitforexitandrun", "run", "runinprefix")
EPIC_ARGS = ("-auth_", "-epic")
CMD_SPECIAL = "&|<>^"
WIDTH, HEIGHT = 1280, 720
LAUNCH_TIMEOUT = 150.0
HANDOFF_WAIT = 30.0
STEAM_WAIT = 20.0
STEAM_CLAIM_WAIT = 90.0
CLAIM_PEEK = 0.5
SIGN_IN_WAIT = 90.0
REGISTER_WAIT = 30.0
AUTO_SIGN_IN_FRESH = 120.0
FIRST_RUN_PRESSES = 3
BROKER_WAIT = 60.0
HIDDEN_IDLE = 240.0
EXIT_GRACE = 6.0
SIGN_OUT_GRACE = 4.0
STOP_WAIT = 8.0
LOG_CAP = 8 << 20
DISPLAY_PROBE = ("import os, sys, time\nparent = os.getppid()\n"
"with open(sys.argv[1] + '.tmp', 'w') as f:\n f.write(os.environ.get('DISPLAY', ''))\n"
"os.replace(sys.argv[1] + '.tmp', sys.argv[1])\n"
"while os.getppid() == parent:\n time.sleep(1)\n")
SHIM = "#!/bin/sh\nunset LD_PRELOAD LD_LIBRARY_PATH\nexec /usr/bin/python3 -I %s %s \"$@\"\n"
class Failure(Exception):
pass
def say(message):
print("droiddeck-epic: %s" % message, file=sys.stderr, flush=True)
def read_json(path, default=None):
try:
with open(path, encoding="utf-8") as f:
return json.load(f)
except (OSError, ValueError):
return default
def write_json(path, data):
os.makedirs(os.path.dirname(path), exist_ok=True)
tmp = "%s.%d.tmp" % (path, os.getpid())
with open(tmp, "w", encoding="utf-8") as f:
json.dump(data, f, indent=2)
f.write("\n")
os.replace(tmp, path)
def install_preload(files):
target = os.path.join(files, "lib", "x86_64-linux-gnu", "droiddeck", WEBKIT_INPUT)
line = ""
if os.path.isfile(WEBKIT_INPUT_SOURCE):
if not (os.path.isfile(target) and filecmp.cmp(WEBKIT_INPUT_SOURCE, target, shallow=False)):
os.makedirs(os.path.dirname(target), exist_ok=True)
tmp = "%s.%d.tmp" % (target, os.getpid())
shutil.copyfile(WEBKIT_INPUT_SOURCE, tmp)
os.chmod(tmp, 0o644)
os.replace(tmp, target)
line = WEBKIT_INPUT_GUEST + "\n"
else:
remove(target)
write_text(os.path.join(files, "etc", "ld.so.preload"), line)
def write_text(path, text, mode=0o644):
os.makedirs(os.path.dirname(path), exist_ok=True)
try:
with open(path, encoding="utf-8") as f:
if f.read() == text:
os.chmod(path, mode)
return False
except (OSError, UnicodeDecodeError):
pass
tmp = "%s.%d.tmp" % (path, os.getpid())
with open(tmp, "w", encoding="utf-8") as f:
f.write(text)
os.chmod(tmp, mode)
os.replace(tmp, path)
return True
def remove(path):
if not os.path.lexists(path):
return
if os.path.isdir(path) and not os.path.islink(path):
shutil.rmtree(path, ignore_errors=True)
else:
os.unlink(path)
def version_name(value):
return re.sub(r"[^A-Za-z0-9._+-]", "_", value or "")[:80]
@contextlib.contextmanager
def locked(name, wait=True):
os.makedirs(STATE, exist_ok=True)
with open(os.path.join(STATE, name), "a") as handle:
fcntl.flock(handle, fcntl.LOCK_EX if wait else fcntl.LOCK_EX | fcntl.LOCK_NB)
try:
yield
finally:
fcntl.flock(handle, fcntl.LOCK_UN)
def run_dir(env=None):
env = os.environ if env is None else env
runtime = env.get("XDG_RUNTIME_DIR")
if runtime and os.path.isdir(runtime) and os.access(runtime, os.W_OK):
return os.path.join(runtime, "droiddeck-epic")
return os.path.join(STATE, "run")
def instance_file():
return os.path.join(STATE, "instance.json")
def broker_path():
return os.path.join(run_dir(), "broker.sock")
def safe_name(name):
parts = [part for part in name.replace("\\", "/").split("/") if part not in ("", ".")]
if not parts or ".." in parts:
return None
return "/".join(parts)
def skipped(relative):
return any(relative == s or relative.startswith(s + "/") for s in SKIPPED)
def rooted_link(files_root, link, target):
if not target.startswith("/"):
return target
relative = target.lstrip("/")
if relative == "usr" or relative.startswith("usr/"):
relative = relative[4:]
return os.path.relpath(os.path.join(files_root, relative), os.path.dirname(link))
def inside(root, path):
real = os.path.realpath(path)
return real == root or real.startswith(root + os.sep)
def unpack_member(archive, member, staging, root, name, link):
target = os.path.join(staging, name)
if not inside(root, os.path.dirname(target)):
return False
if member.isdir():
os.makedirs(target, exist_ok=True)
return False
os.makedirs(os.path.dirname(target), exist_ok=True)
if not inside(root, os.path.dirname(target)):
return False
if member.issym():
remove(target)
os.symlink(link(target, member.linkname), target)
elif member.islnk():
source = safe_name(member.linkname)
source = os.path.join(staging, source) if source else None
if source and os.path.isfile(source) and inside(root, source):
remove(target)
shutil.copy2(source, target)
elif member.isfile():
remove(target)
with archive.extractfile(member) as src, open(target, "wb") as out:
shutil.copyfileobj(src, out, 1 << 20)
os.chmod(target, (member.mode & 0o777) | 0o600)
else:
return False
return True
def extract_runtime(tarball, dest):
staging = dest + ".staging"
remove(staging)
os.makedirs(staging)
root = os.path.realpath(staging)
files_root = os.path.join(staging, "files")
count = 0
with tarfile.open(tarball, "r:*") as archive:
for member in archive:
name = safe_name(member.name)
if name is None:
continue
top, _, rest = name.partition("/")
if top not in ("files", "metadata"):
continue
if top == "files" and rest and skipped(rest):
continue
if top == "files":
link = lambda target, linkname: rooted_link(files_root, target, linkname)
else:
link = lambda target, linkname: linkname
if unpack_member(archive, member, staging, root, name, link):
count += 1
if not os.path.isfile(os.path.join(files_root, "lib", "x86_64-linux-gnu", "libc.so.6")) and \
not os.path.islink(os.path.join(files_root, "lib", "x86_64-linux-gnu", "libc.so.6")):
remove(staging)
raise Failure("runtime-incomplete")
if not os.path.lexists(os.path.join(files_root, "usr")):
os.symlink(".", os.path.join(files_root, "usr"))
return staging, count
@contextlib.contextmanager
def deb_data(path, reason):
with open(path, "rb") as f:
if f.read(8) != b"!<arch>\n":
raise Failure(reason)
while True:
header = f.read(60)
if len(header) < 60:
raise Failure(reason)
name = header[:16].decode("ascii", "replace").strip().rstrip("/")
size = int(header[48:58].decode("ascii").strip())
if name.startswith("data.tar"):
with tarfile.open(fileobj=f, mode="r|*") as archive:
yield archive
return
f.seek(size + size % 2, os.SEEK_CUR)
def is_deb(path):
try:
with open(path, "rb") as f:
return f.read(21) == b"!<arch>\ndebian-binary"
except OSError:
return False
def install_gles(deb, files_root):
libdir = os.path.join(files_root, "lib", "x86_64-linux-gnu")
os.makedirs(libdir, exist_ok=True)
with deb_data(deb, "gles-format") as archive:
for member in archive:
base = os.path.basename(member.name)
if not base.startswith("libGLESv2.so"):
continue
target = os.path.join(libdir, base)
remove(target)
if member.issym():
os.symlink(os.path.basename(member.linkname), target)
elif member.isfile():
with archive.extractfile(member) as src, open(target, "wb") as out:
shutil.copyfileobj(src, out)
os.chmod(target, 0o644)
if not os.path.exists(os.path.join(libdir, "libGLESv2.so.2")):
raise Failure("gles-missing")
def extract_deb(deb, dest, wanted=None):
root = os.path.realpath(dest)
def link(target, linkname):
if not linkname.startswith("/"):
return linkname
return os.path.relpath(os.path.join(dest, linkname.lstrip("/")), os.path.dirname(target))
count = 0
with deb_data(deb, "app-format") as archive:
for member in archive:
name = safe_name(member.name)
if name is None or (wanted is not None and not wanted(name)):
continue
if unpack_member(archive, member, dest, root, name, link):
count += 1
return count
def extract_app(image, dest, desktop=()):
staging = dest + ".staging"
remove(staging)
os.makedirs(staging)
try:
if not is_deb(image):
raise Failure("app-format")
extract_deb(image, staging)
layer = os.path.join(staging, DESKTOP)
if not inside(os.path.realpath(staging), layer):
raise Failure("app-extract")
os.makedirs(layer, exist_ok=True)
for package in desktop:
if not is_deb(package):
raise Failure("desktop-format")
extract_deb(package, layer, lambda name: any(name.startswith(prefix) for prefix in DESKTOP_KEEP))
icon = os.path.join(staging, DEB_ICON)
if os.path.isfile(icon):
remove(os.path.join(staging, ICON))
shutil.copyfile(icon, os.path.join(staging, ICON))
if not app_complete(staging):
raise Failure("app-extract")
except Exception:
remove(staging)
raise
remove(dest)
os.rename(staging, dest)
def app_complete(root):
if not os.path.isfile(os.path.join(root, APP_BIN)):
return False
return os.path.isfile(os.path.join(root, "AppRun")) or os.path.isfile(os.path.join(root, DESKTOP_LIB, WEBKIT_LIB))
def app_command(app_dir):
apprun = os.path.join(app_dir, "AppRun")
return apprun if os.path.isfile(apprun) else os.path.join(app_dir, APP_BIN)
def desktop_libs(app_dir):
path = os.path.join(app_dir, DESKTOP_LIB)
return path if os.path.isdir(path) else None
def link_webkit(files, libs):
target = os.path.join(files, "lib", "x86_64-linux-gnu", WEBKIT_DIR)
if os.path.isdir(target) and not os.path.islink(target):
return
source = os.path.join(libs, WEBKIT_DIR) if libs else None
if source is None or not os.path.isdir(source):
remove(target)
return
link = os.path.relpath(source, os.path.dirname(target))
if os.path.islink(target) and os.readlink(target) == link:
return
remove(target)
os.symlink(link, target)
def ready(path):
return os.path.isfile(os.path.join(path, READY))
def mark_ready(path):
write_text(os.path.join(path, READY), "1\n")
def prune(parent, keep):
try:
names = os.listdir(parent)
except OSError:
return
for name in names:
if name != keep:
remove(os.path.join(parent, name))
def install(options):
with locked("install.lock"):
current = read_json(CURRENT, {}) or {}
app = version_name(options.get("app-version") or current.get("app"))
runtime = version_name(options.get("runtime-version") or current.get("runtime"))
if not app or not runtime:
raise Failure("no-version")
app_dir = os.path.join(APPS, app)
runtime_dir = os.path.join(RUNTIMES, runtime)
if not ready(app_dir):
image = options.get("app")
if not image or not os.path.isfile(image):
raise Failure("no-app-image")
desktop = options.get("desktop") or []
if not all(os.path.isfile(package) for package in desktop):
raise Failure("no-desktop-package")
say("unpacking the Epic Games Launcher %s (%d desktop packages)" % (app, len(desktop)))
extract_app(image, app_dir, desktop)
mark_ready(app_dir)
if not ready(runtime_dir):
tarball, deb = options.get("runtime"), options.get("gles")
if not tarball or not os.path.isfile(tarball) or not deb or not os.path.isfile(deb):
raise Failure("no-runtime-archive")
say("unpacking the x86 runtime %s" % runtime)
staging, count = extract_runtime(tarball, runtime_dir)
install_gles(deb, os.path.join(staging, "files"))
write_text(os.path.join(staging, "files", "etc", "ld.so.preload"), "")
remove(runtime_dir)
os.rename(staging, runtime_dir)
mark_ready(runtime_dir)
say("x86 runtime ready (%d entries)" % count)
with instance_guard() as free:
write_json(CURRENT, {"app": app, "runtime": runtime})
if free:
prune(APPS, app)
prune(RUNTIMES, runtime)
report = status()
print(json.dumps(report))
return 0 if report["installed"] else 1
@contextlib.contextmanager
def instance_guard():
os.makedirs(STATE, exist_ok=True)
with open(os.path.join(STATE, "instance.lock"), "a") as handle:
try:
fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
except OSError:
yield False
return
try:
yield True
finally:
fcntl.flock(handle, fcntl.LOCK_UN)
def current_dirs():
current = read_json(CURRENT, {}) or {}
app = version_name(current.get("app"))
runtime = version_name(current.get("runtime"))
app_dir = os.path.join(APPS, app) if app else None
runtime_dir = os.path.join(RUNTIMES, runtime) if runtime else None
if app_dir and ready(app_dir) and app_complete(app_dir) and runtime_dir and ready(runtime_dir):
return app_dir, os.path.join(runtime_dir, "files"), current
return None, None, current
def signed_in():
auth = read_json(AUTH_FILE)
entry = auth.get(AUTH_ENV) if isinstance(auth, dict) else None
return isinstance(entry, dict) and isinstance(entry.get("refresh_token"), str) and bool(entry["refresh_token"])
def forget_sign_in():
if not os.path.exists(SIGNED_OUT):
return False
remove(AUTH_FILE)
remove(WEB_COOKIES)
remove(SIGNED_OUT)
say("DroidDeck's Epic store was signed out; the launcher starts signed out")
return True
def utc_now():
return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
def read_installations():
header, entries = None, []
try:
with open(INSTALLATIONS, encoding="utf-8") as f:
lines = [line for line in f.read().splitlines() if line.strip()]
except OSError:
return None, []
for index, line in enumerate(lines):
try:
value = json.loads(line)
except ValueError:
continue
if not isinstance(value, dict):
continue
if index == 0 and "entries" in value and "installationId" not in value:
header = value
else:
entries.append(value)
return header, entries
def droiddeck_dir(path):
sidecar = read_json(os.path.join(path, SIDECAR)) if path else None
if not isinstance(sidecar, dict) or sidecar.get("store") != "epic":
return False
extra = sidecar.get("extra")
return not (isinstance(extra, dict) and extra.get("clientManaged") == "true")
def droiddeck_installs():
found = []
try:
names = sorted(os.listdir(V1_MANIFESTS))
except OSError:
return found
for name in names:
if not name.endswith(".item"):
continue
item = read_json(os.path.join(V1_MANIFESTS, name))
if not isinstance(item, dict) or item.get("bIsIncompleteInstall"):
continue
if not droiddeck_dir(item.get("InstallLocation")):
continue
if not all(item.get(key) for key in ("InstallationGuid", "CatalogNamespace", "CatalogItemId", "AppName")):
continue
found.append(item)
return found
def installation_record(item):
tags = [""] + [tag for tag in item.get("InstallTags") or [] if isinstance(tag, str) and tag]
sidecar = {"revision": int(item.get("SidecarConfigRevision") or 0)}
if item.get("SidecarDeploymentId"):
sidecar["deploymentId"] = item["SidecarDeploymentId"]
return {
"installationId": item["InstallationGuid"],
"complete": True,
"dir": item["InstallLocation"],
"platform": "Windows",
"namespace": item["CatalogNamespace"],
"itemId": item["CatalogItemId"],
"artifactId": item["AppName"],
"version": item.get("AppVersionString") or "",
"tags": tags,
"sidecar": sidecar,
"launchCommand": item.get("LaunchCommand") or "",
"launchExecutable": item.get("LaunchExecutable") or "",
"writtenAt": utc_now(),
}
def sync_installations():
installs = droiddeck_installs()
header, entries = read_installations()
latest = {}
for entry in entries:
key = entry.get("installationId") or entry.get("artifactId")
if key:
latest[key] = entry
changed = 0
moved = {}
for item in installs:
key = item["InstallationGuid"] if item["InstallationGuid"] in latest else \
next((k for k, e in latest.items() if e.get("artifactId") == item["AppName"]), None)
if key is None:
record = installation_record(item)
entries.append(record)
latest[record["installationId"]] = record
changed += 1
elif latest[key].get("dir") != item["InstallLocation"] and not os.path.lexists(latest[key].get("dir") or ""):
moved[key] = item["InstallLocation"]
for key, current in latest.items():
fix = {}
if key in moved:
fix["dir"] = moved[key]
if current.get("platform") != "Windows" and droiddeck_dir(moved.get(key, current.get("dir"))):
fix["platform"] = "Windows"
if not fix:
continue
for entry in entries:
if (entry.get("installationId") or entry.get("artifactId")) == key:
entry.update(fix)
changed += 1
if not changed:
return False
head = dict(header or {"version": 1})
head["writtenAt"] = utc_now()
head["entries"] = len(entries)
tmp = "%s.%d.tmp" % (INSTALLATIONS, os.getpid())
os.makedirs(DATA, exist_ok=True)
with open(tmp, "w", encoding="utf-8") as f:
for value in [head] + entries:
f.write(json.dumps(value, separators=(",", ":")) + "\n")
os.replace(tmp, INSTALLATIONS)
say("updated %d DroidDeck Epic installs in the launcher" % changed)
return True
def parent_pid(pid):
try:
with open("/proc/%d/stat" % pid, encoding="utf-8", errors="replace") as f:
return int(f.read().rsplit(")", 1)[1].split()[1])
except (OSError, IndexError, ValueError):
return 0
def steam_app_id(pid=None):
pid = os.getppid() if pid is None else pid
for _ in range(STEAM_ANCESTORS):
if pid <= 1:
break
try:
with open("/proc/%d/cmdline" % pid, "rb") as f:
args = f.read().split(b"\0")
except OSError:
break
if b"SteamLaunch" in args:
ids = [a[6:].decode("ascii", "replace") for a in args if a.startswith(b"AppId=")]
return ids[0] if ids and ids[0].isdigit() else ""
pid = parent_pid(pid)
return ""
@contextlib.contextmanager
def marked(name, value="1"):
folder = launch_dir()
path = os.path.join(folder, name) if folder else ""
if path:
write_text(path, value + "\n")
try:
yield
finally:
if path:
remove(path)
def playing():
return marked(PLAYING)
def clear_playing():
folder = launch_dir()
if folder:
remove(os.path.join(folder, PLAYING))
def launch_dir():
found = os.environ.get("BL_LAUNCH_DIR", "")
if not found:
try:
with open(LAUNCH_DIR_FILE, encoding="utf-8") as f:
found = f.read().strip()
except OSError:
found = ""
return found
_fex = None
def fex_module():
global _fex
if _fex is None:
_fex = runpy.run_path(os.path.join(BIN_DIR, "droiddeck-fex"))
return _fex
def fex_tool(request=False):
try:
module = fex_module()
found = module["fex_install"]()
if found and found.get("server"):
return found
if request:
module["request_install"]()
except Exception as error:
say("FEX lookup failed (%s)" % error)
return None
def status():
app_dir, files, current = current_dirs()
fex = fex_tool()
report = {
"app": current.get("app"),
"runtime": current.get("runtime"),
"installed": app_dir is not None,
"fex": bool(fex),
"signedIn": signed_in(),
}
return report
def seed_settings():
current = read_json(SETTINGS)
settings = current if isinstance(current, dict) else {}
changed = False
for key, value in SETTINGS_SEED.items():
if settings.get(key) != value:
settings[key] = value
changed = True
if changed:
write_json(SETTINGS, settings)
return changed
def install_shims():
write_text(os.path.join(SHIMS, "xdg-open"), SHIM % (SELF, "xdg-open"), 0o755)
proton = SHIM % (SELF, "proton")
os.makedirs(PROTON_ROOT, exist_ok=True)
names = {PROTON_PIN}
try:
names |= {name for name in os.listdir(PROTON_ROOT) if name.startswith("GE-Proton") and not name.startswith(".")}
except OSError:
pass
for name in sorted(names):
folder = os.path.join(PROTON_ROOT, name)
entry = os.path.join(folder, "proton")
if os.path.isdir(entry) and not os.path.islink(entry):
shutil.rmtree(entry, ignore_errors=True)
write_text(entry, proton, 0o755)
write_text(os.path.join(folder, "version"), "%d %s\n" % (0, name))
def fex_environment(fex, files, env):
fex_data = os.path.join(run_dir(env), "fex")
for directory in (FEX_CONFIG, fex_data, FEX_CACHE):
os.makedirs(directory, exist_ok=True)
write_text(os.path.join(FEX_CONFIG, "Config.json"), json.dumps({"Config": {"RootFS": files}}, indent=2) + "\n")
result = {
"FEX_APP_CONFIG_LOCATION": FEX_CONFIG + "/",
"FEX_APP_DATA_LOCATION": fex_data + "/",
"FEX_APP_CACHE_LOCATION": FEX_CACHE + "/",
"FEX_ROOTFS": files,
"FEX_SILENTLOG": "0",
"FEX_OUTPUTLOG": "",
}
if fex.get("portable"):
result["FEX_PORTABLE"] = "1"
return result
def client_environment(base, fex, files, display, bus, broker, a11y=None, hidden=False, libs=None):
env = {name: base[name] for name in KEPT_ENV if base.get(name)}
env.setdefault("HOME", HOME)
env.setdefault("LANG", "C.UTF-8")
env["PATH"] = SHIMS + ":/usr/bin:/bin"
if libs:
env["LD_LIBRARY_PATH"] = libs
data = os.path.normpath(os.path.join(os.path.dirname(libs), "..", "share"))
env["XDG_DATA_DIRS"] = data + ":/usr/local/share:/usr/share"
env["GSETTINGS_SCHEMA_DIR"] = os.path.join(data, "glib-2.0", "schemas")
env["DISPLAY"] = display
env["DBUS_SESSION_BUS_ADDRESS"] = bus
env[BROKER_ENV] = broker
env.update(CLIENT_ENV)
if hidden:
env.update(HIDDEN_ENV)
if a11y:
for name in A11Y_OFF:
env.pop(name, None)
env["AT_SPI_BUS_ADDRESS"] = a11y
env.update(fex_environment(fex, files, base))
return env
def windows_path(path):
return "Z:" + path.replace("/", "\\")
def native_path(path):
if len(path) >= 2 and path[1] == ":" and path[0].upper() == "Z":
return path[2:].replace("\\", "/") or "/"
return path.replace("\\", "/")
ARG_PATH = re.compile(r'^(-[^=\s]+=)"?(/[^"]*)"?$')
def path_like(path):
return os.path.exists(path) or os.path.isdir(os.path.dirname(path))
def convert_arg(arg):
if arg.startswith("/") and path_like(arg):
return windows_path(arg)
match = ARG_PATH.match(arg)
if match and path_like(match.group(2)):
return '%s"%s"' % (match.group(1), windows_path(match.group(2)))
return arg
def epic_managed(arg):
low = arg.lower()
return low.startswith(EPIC_ARGS)
def merge_args(client, own):
merged = [convert_arg(arg) for arg in client if arg]
for arg in own or []:
if arg and not epic_managed(arg) and arg not in merged:
merged.append(arg)
return merged
def quote_arg(arg):
clean = "".join(ch for ch in arg if ch >= " " and ch != "\x7f")
if clean.count('"') % 2:
clean = clean.replace('"', "")
if (" " in clean or "\t" in clean) and '"' not in clean:
return '"%s"' % clean
return clean
def cmd_escape(line):
out, quoted = [], False
for ch in line:
if ch == '"':
quoted = not quoted
elif ch in CMD_SPECIAL and not quoted:
out.append("^")
out.append(ch)
return "".join(out)
def command_line(args):
return cmd_escape(" ".join(quote_arg(arg) for arg in args if arg))
def find_store_game(path):
folder = os.path.dirname(os.path.abspath(path)) if not os.path.isdir(path) else os.path.abspath(path)
for _ in range(8):
sidecar = read_json(os.path.join(folder, SIDECAR))
if isinstance(sidecar, dict) and sidecar.get("store") and sidecar.get("id"):
return folder, sidecar
parent = os.path.dirname(folder)
if parent == folder:
break
folder = parent
return None
def write_args(folder, sidecar, client_args):
line = command_line(merge_args(client_args, sidecar.get("args") if isinstance(sidecar.get("args"), list) else []))
path = os.path.join(folder, ARGS_FILE)
tmp = "%s.%d.tmp" % (path, os.getpid())
remove(tmp)
with open(os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600), "w", encoding="utf-8", newline="") as f:
f.write(line + "\r\n")
os.replace(tmp, path)
return line
def launcher_takes_args(folder):
try:
with open(os.path.join(folder, LAUNCHER), encoding="utf-8", errors="replace") as f:
return ARGS_FILE in f.read()
except OSError:
return False
def send(sock, message):
sock.sendall((json.dumps(message) + "\n").encode("utf-8"))
def receive(sock, timeout=None):
sock.settimeout(timeout)
data = b""
while b"\n" not in data:
chunk = sock.recv(65536)
if not chunk:
raise ConnectionError("closed")
data += chunk
return json.loads(data.split(b"\n", 1)[0].decode("utf-8"))
def ask_broker(message, timeout=5.0, path=None):
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
sock.settimeout(timeout)
sock.connect(path or broker_path())
send(sock, message)
return receive(sock, timeout)
def pid_alive(pid):
try:
os.kill(int(pid), 0)
return True
except (OSError, ValueError, TypeError):
return False
def live_instance():
info = read_json(instance_file())
if not isinstance(info, dict) or not pid_alive(info.get("pid")):
return None
try:
answer = ask_broker({"op": "status"}, timeout=3.0, path=info.get("broker"))
except (OSError, ValueError):
return None
return dict(info, **answer) if isinstance(answer, dict) else None
class Launch:
def __init__(self, request):
self.request = request
self.done = threading.Event()
self.code = 0
self.claimed = False
class Broker:
def __init__(self, path, mode, session_env):
self.path = path
self.mode = mode
self.session_env = session_env
self.cond = threading.Condition()
self.launches = []
self.running = []
self.waiters = 0
self.awaiting = collections.Counter()
self.game = None
self.owner = None
self.closing = False
self.exited_at = None
self.last_contact = time.monotonic()
remove(path)
os.makedirs(os.path.dirname(path), exist_ok=True)
self.server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.server.bind(path)
os.chmod(path, 0o600)
self.server.listen(16)
threading.Thread(target=self.accept, name="broker", daemon=True).start()
def accept(self):
while True:
try:
conn, _ = self.server.accept()
except OSError:
return
threading.Thread(target=self.serve, args=(conn,), daemon=True).start()
def serve(self, conn):
with conn:
try:
request = receive(conn, 30.0)
op = request.get("op") if isinstance(request, dict) else None
if op == "status":
send(conn, {"mode": self.mode, "pid": os.getpid(), "game": self.game is not None})
elif op == "await":
self.wait_for_launch(conn, request)
elif op == "launch":
self.launched(conn, request)
elif op == "exited":
self.exited(int(request.get("code") or 0))
send(conn, {"ok": True})
elif op == "stop":
self.close()
send(conn, {"ok": True})
else:
send(conn, {"ok": False, "reason": "unknown-op"})
except (OSError, ValueError, TypeError) as error:
say("broker: %s" % type(error).__name__)
def wait_for_launch(self, conn, request):
app = request.get("app") or ""
deadline = time.monotonic() + float(request.get("timeout") or LAUNCH_TIMEOUT)
with self.cond:
self.waiters += 1
self.awaiting[app.lower()] += 1
self.last_contact = time.monotonic()
try:
while True:
found = next((item for item in self.launches if not item.claimed and is_game(item.request, app)), None)
if found is not None:
found.claimed = True
self.launches.remove(found)
self.cond.notify_all()
self.game = found
self.owner = request.get("owner")
self.exited_at = None
break
left = deadline - time.monotonic()
if self.closing or left <= 0:
send(conn, {"ok": False, "reason": "closing" if self.closing else "timeout"})
return
self.cond.wait(min(left, 1.0))
finally:
self.waiters -= 1
self.awaiting[app.lower()] -= 1
if self.awaiting[app.lower()] <= 0:
del self.awaiting[app.lower()]
self.last_contact = time.monotonic()
try:
send(conn, {"ok": True, "exe": found.request.get("exe"), "args": found.request.get("args") or []})
except OSError:
self.exited(1)
def launched(self, conn, request):
exe = request.get("exe") or ""
say("the client starts %s (%d arguments)" % (os.path.basename(exe), len(request.get("args") or [])))
if not is_game(request):
send(conn, {"code": 0})
return
item = Launch(request)
if self.mode == "visible" and not self.awaited(request):
with self.cond:
self.launches.append(item)
self.cond.notify_all()
if not play_in_steam(request):
with self.cond:
unclaimed = not item.claimed
if unclaimed and item in self.launches:
self.launches.remove(item)
if unclaimed:
with playing():
code = run_game(request, self.session_env, self.running)
send(conn, {"code": code})
return
send(conn, {"code": self.hand_over(item, STEAM_CLAIM_WAIT)})
return
send(conn, {"code": self.hand_over(item, 20.0)})
def awaited(self, request):
with self.cond:
return any(is_game(request, app) for app in self.awaiting if app)
def hand_over(self, item, wait):
deadline = time.monotonic() + wait
with self.cond:
if item not in self.launches and not item.claimed:
self.launches.append(item)
self.cond.notify_all()
while not item.claimed and not self.closing:
left = deadline - time.monotonic()
if left <= 0:
break
self.cond.wait(left)
if not item.claimed and item in self.launches:
self.launches.remove(item)
if not item.claimed:
return 0
while not item.done.wait(1.0):
if self.closing:
break
return item.code
def exited(self, code):
with self.cond:
game = self.game
if game is None:
return
game.code = code
game.done.set()
self.game = None
self.owner = None
self.exited_at = time.monotonic()
self.cond.notify_all()
def close(self):
with self.cond:
self.closing = True
for item in self.launches:
item.done.set()
if self.game is not None:
self.game.done.set()
self.cond.notify_all()
def shutdown(self):
self.close()
with contextlib.suppress(OSError):
self.server.close()
remove(self.path)
def is_game(request, app=None):
args = [str(arg).lower() for arg in request.get("args") or []]
if app:
return "-epicapp=" + app.lower() in args
return any(arg.startswith("-epicapp=") for arg in args)
def client_artifact(exe):
latest = {}
for entry in read_installations()[1]:
key = entry.get("installationId") or entry.get("artifactId")
if key:
latest[key] = entry
target = os.path.abspath(exe)
for entry in latest.values():
folder = entry.get("dir")
if entry.get("deleted") or not isinstance(folder, str) or not folder:
continue
folder = os.path.abspath(folder)
if (target == folder or target.startswith(folder + os.sep)) and entry.get("artifactId"):
return str(entry["artifactId"])
return None
def play_in_steam(request):
exe = native_path(request.get("exe") or "")
found = find_store_game(exe)
if found and found[1].get("store") == "epic" and found[1].get("id"):
game = str(found[1]["id"])
elif not found:
game = client_artifact(exe)
if not game:
return False
else:
return False
reply = ask_app({"op": "epic-play-in-steam", "id": game}, STEAM_WAIT)
if not isinstance(reply, dict):
reply = {}
if reply.get("ok"):
say("handed %s to Steam" % game)
return True
say("Steam could not take %s (%s); running it here" % (game, reply.get("reason") or "no answer"))
return False
def run_game(request, session_env, running=None):
exe = native_path(request.get("exe") or "")
args = request.get("args") or []
env = {k: v for k, v in session_env.items() if not k.startswith(("FEX_", "DROIDDECK_EPIC", "EGL_", "WEBKIT_"))}
env = GAME_DEBUG["apply_game_debug_logs"](env)
preload = env.pop(STEAM_PRELOAD, "")
if preload:
env["LD_PRELOAD"] = preload
found = find_store_game(exe)
if found and found[1].get("store") == "epic" and launcher_takes_args(found[0]):
folder, sidecar = found
write_args(folder, sidecar, args)
env[HANDLED] = "1"
command = [PROTON_RUN, os.path.join(folder, LAUNCHER)]
else:
command = [PROTON_RUN, exe] + [convert_arg(arg) for arg in args]
say("running %s" % os.path.basename(command[1]))
try:
proc = subprocess.Popen(command, env=env, cwd=os.path.dirname(command[1]) or "/", start_new_session=True)
except OSError as error:
say("could not run the game (%s)" % error)
return 1
if running is not None:
running.append(proc)
try:
return proc.wait()
finally:
if running is not None and proc in running:
running.remove(proc)
def wait_for(check, timeout, step=0.1):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
if check():
return True
time.sleep(step)
return check()
def capped_log(path):
os.makedirs(os.path.dirname(path), exist_ok=True)
handle = open(path, "wb")
read, write = os.pipe()
def pump():
written = 0
with os.fdopen(read, "rb") as source:
while True:
chunk = source.read1(65536) if hasattr(source, "read1") else source.read(65536)
if not chunk:
break
if written < LOG_CAP:
handle.write(chunk[:LOG_CAP - written])
handle.flush()
written += len(chunk)
handle.close()
threading.Thread(target=pump, daemon=True).start()
return write
class Session:
def __init__(self, mode):
self.mode = mode
self.carried = False
self.a11y = None
self.press_at = 0.0
self.first_run_presses = 0
self.sign_in_pressed = False
self.was_signed_in = False
self.signed_out_at = None
self.procs = []
self.client = None
self.command = None
self.env = None
self.broker = None
self.bus = None
self.rundir = run_dir()
def spawn(self, command, env, log=None, group=False):
out = capped_log(log) if log else subprocess.DEVNULL
try:
proc = subprocess.Popen(command, env=env, stdin=subprocess.DEVNULL, stdout=out, stderr=out,
start_new_session=group, cwd="/")
finally:
if log:
os.close(out)
self.procs.append(proc)
return proc
def start_bus(self, env, name="bus"):
path = os.path.join(self.rundir, name)
remove(path)
address = "unix:path=" + path
proc = self.spawn(["dbus-daemon", "--session", "--nofork", "--nopidfile", "--address=" + address], env)
if not wait_for(lambda: os.path.exists(path) or proc.poll() is not None, 10) or not os.path.exists(path):
raise Failure("no-session-bus")
return address
def start_display(self, env, bus):
marker = os.path.join(self.rundir, "display")
remove(marker)
scope_env = dict(env, DBUS_SESSION_BUS_ADDRESS=bus)
for name in ("DISPLAY", "WAYLAND_DISPLAY", "GAMESCOPE_WAYLAND_DISPLAY"):
scope_env.pop(name, None)
size = ["-W", str(WIDTH), "-H", str(HEIGHT), "-w", str(WIDTH), "-h", str(HEIGHT)]
self.spawn(["gamescope", "--backend", "headless"] + size + ["--", sys.executable, "-I", "-c", DISPLAY_PROBE, marker],
scope_env, os.path.join(LOGS, "gamescope.log"))
display = {}
def ready():
try:
with open(marker, encoding="utf-8") as f:
display["name"] = f.read().strip()
except OSError:
return False
return bool(display["name"])
if not wait_for(ready, 30):
raise Failure("no-display")
return display["name"]
def run(self):
app_dir, files, current = current_dirs()
if app_dir is None:
raise Failure("not-installed")
fex = fex_tool(request=True)
if fex is None:
raise Failure("no-fex")
os.makedirs(self.rundir, exist_ok=True)
os.makedirs(LOGS, exist_ok=True)
base = dict(os.environ)
base.setdefault("XDG_RUNTIME_DIR", self.rundir)
seed_settings()
install_shims()
install_preload(files)
libs = desktop_libs(app_dir)
link_webkit(files, libs)
fex_module()["install_fonts"](files)
clear_playing()
sync_installations()
forget_sign_in()
self.carried = carry_sign_in()
bus = self.start_bus(base)
self.bus = bus
if self.carried:
self.a11y = self.start_bus(base, "a11y")
if self.mode == "hidden":
display = self.start_display(base, bus)
else:
display = base.get("DISPLAY") or ":0"
path = broker_path()
self.broker = Broker(path, self.mode, base)
write_json(instance_file(), {"pid": os.getpid(), "mode": self.mode, "bus": bus, "broker": path})
env = client_environment(base, fex, files, display, bus, path, self.a11y, hidden=self.mode == "hidden", libs=libs)
self.command = [fex["bin"], app_command(app_dir)]
self.env = env
say("starting the Epic Games Launcher %s (%s, display %s)" % (current.get("app"), self.mode, display))
self.start_client()
return self.watch()
def start_client(self):
self.client = self.spawn(self.command, self.env, os.path.join(LOGS, "client-%s.log" % self.mode), group=True)
def restart_signed_out(self):
say("DroidDeck's Epic store was signed out; restarting the launcher signed out")
self.end_client()
forget_sign_in()
self.carried = False
self.was_signed_in = False
self.signed_out_at = None
self.start_client()
def carry_on(self, now):
if signed_in():
self.carried = False
self.was_signed_in = True
remove(AUTO_SIGN_IN)
say("the launcher is signed in")
return
if now < self.press_at or self.sign_in_pressed:
return
self.press_at = now + 2.0
buttons = a11y_buttons(self.a11y)
if SIGN_IN_LABEL in buttons:
write_text(AUTO_SIGN_IN, "%d\n" % time.time())
if a11y_press(self.a11y, buttons[SIGN_IN_LABEL]):
self.sign_in_pressed = True
say("asked the launcher to sign in")
elif FIRST_RUN_LABEL in buttons and self.first_run_presses < FIRST_RUN_PRESSES:
self.first_run_presses += 1
if a11y_press(self.a11y, buttons[FIRST_RUN_LABEL]):
say("moved past the launcher's welcome screen")
def follow_sign_out(self, now):
if signed_in():
self.was_signed_in = True
self.signed_out_at = None
return
if not self.was_signed_in:
return
if self.signed_out_at is None:
self.signed_out_at = now
return
if now - self.signed_out_at < SIGN_OUT_GRACE:
return
self.was_signed_in = False
self.signed_out_at = None
channel = launch_dir()
if channel:
post(channel, {"op": "epic-signed-out"})
say("the launcher was signed out; signing DroidDeck's Epic store out too")
def watch(self):
started = time.monotonic()
broker = self.broker
while True:
if self.client.poll() is not None:
say("the Epic Games Launcher exited (%s)" % self.client.returncode)
return 0 if self.mode == "visible" else 1
now = time.monotonic()
if broker.closing:
return 0
if broker.game is None and os.path.exists(SIGNED_OUT):
if self.mode != "visible":
say("DroidDeck's Epic store was signed out; closing")
return 0
self.restart_signed_out()
continue
if self.carried:
self.carry_on(now)
elif self.mode == "visible":
self.follow_sign_out(now)
owner = broker.owner
if broker.game is not None and owner and not pid_alive(owner):
say("the game's launcher process is gone")
broker.exited(0)
if self.mode == "hidden":
idle = broker.game is None and broker.waiters == 0
if idle and broker.exited_at is not None:
if now - broker.exited_at >= EXIT_GRACE:
return 0
elif idle and now - max(started, broker.last_contact) > HIDDEN_IDLE:
say("no launch was asked for; closing")
return 0
elif idle and broker.last_contact > started and now - broker.last_contact > 5.0:
say("the launch was given up; closing")
return 0
time.sleep(0.5)
def end_client(self):
if self.client is None:
return
if self.client.poll() is None:
with contextlib.suppress(OSError):
os.killpg(self.client.pid, signal.SIGTERM)
try:
self.client.wait(STOP_WAIT)
except subprocess.TimeoutExpired:
with contextlib.suppress(OSError):
os.killpg(self.client.pid, signal.SIGKILL)
with contextlib.suppress(subprocess.TimeoutExpired):
self.client.wait(5)
with contextlib.suppress(OSError):
os.killpg(self.client.pid, signal.SIGKILL)
def stop(self):
if self.broker is not None:
self.broker.shutdown()
for game in list(self.broker.running):
stop_group(game)
clear_playing()
info = read_json(instance_file())
if isinstance(info, dict) and info.get("pid") == os.getpid():
remove(instance_file())
self.end_client()
forget_sign_in()
for proc in reversed(self.procs):
if proc is self.client or proc.poll() is not None:
continue
proc.terminate()
try:
proc.wait(3)
except subprocess.TimeoutExpired:
proc.kill()
with contextlib.suppress(subprocess.TimeoutExpired):
proc.wait(2)
def terminate(*_):
raise SystemExit(0)
def retire_hidden():
info = read_json(instance_file())
if not isinstance(info, dict) or info.get("mode") != "hidden" or not pid_alive(info.get("pid")):
return
say("closing the hidden launcher first")
with contextlib.suppress(OSError, ValueError):
ask_broker({"op": "stop"}, timeout=3.0, path=info.get("broker"))
wait_for(lambda: not pid_alive(info.get("pid")), STOP_WAIT + 10, 0.25)
def serve(mode):
if mode == "visible":
retire_hidden()
with instance_guard() as free:
if not free:
say("the Epic Games Launcher is already running")
return 3
session = Session(mode)
signal.signal(signal.SIGTERM, terminate)
signal.signal(signal.SIGHUP, terminate)
try:
with marked(OPEN, steam_app_id() or "1") if mode == "visible" else contextlib.nullcontext():
return session.run()
except (Failure, OSError) as failure:
say("could not start: %s" % failure)
return 2
finally:
signal.signal(signal.SIGTERM, signal.SIG_IGN)
signal.signal(signal.SIGHUP, signal.SIG_IGN)
session.stop()
def api():
info = read_json(API_FILE)
if not isinstance(info, dict) or not info.get("port") or not info.get("machineSecret"):
return None
return info
def api_get(info, path, timeout=5.0):
request = urllib.request.Request("http://127.0.0.1:%d%s" % (int(info["port"]), path),
headers={"x-epic-machine-secret": str(info["machineSecret"])})
opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
with opener.open(request, timeout=timeout) as reply:
return json.loads(reply.read().decode("utf-8"))
def holds(value, wanted):
if isinstance(value, dict):
return any(holds(v, wanted) for v in value.values())
if isinstance(value, list):
return any(holds(v, wanted) for v in value)
return isinstance(value, str) and value == wanted
def installed(info, app):
try:
listing = api_get(info, "/api/v1/installation/installations")
except (OSError, ValueError, urllib.error.URLError, http.client.HTTPException):
return None
return holds(listing.get("installations") if isinstance(listing, dict) else listing, app)
def deep_link(namespace, item, app):
target = ":".join((namespace, item, app))
return "com.epicgames.launcher://apps/%s?action=launch&silent=true" % urllib.parse.quote(target, safe="")
def forward(bus, url):
command = ["dbus-send", "--session", "--print-reply", "--type=method_call", "--dest=" + DBUS_NAME, DBUS_PATH,
DBUS_METHOD, "array:string:EpicGamesLauncher,%s" % url, "string:/"]
env = dict(os.environ, DBUS_SESSION_BUS_ADDRESS=bus)
try:
return subprocess.call(command, env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=15) == 0
except (OSError, subprocess.SubprocessError):
return False
def parse_options(args, flags=(), lists=()):
options, rest = {}, []
while args:
arg = args.pop(0)
if arg.startswith("--") and arg[2:] in flags:
options[arg[2:]] = True
elif arg.startswith("--") and arg[2:] in lists and args:
options.setdefault(arg[2:], []).append(args.pop(0))
elif arg.startswith("--") and args:
options[arg[2:]] = args.pop(0)
else:
rest.append(arg)
return options, rest
def answer(ok, **fields):
print(json.dumps(dict(fields, ok=ok)), flush=True)
return 0 if ok else 1
def launch(options):
app = options.get("app") or ""
namespace = options.get("namespace") or ""
item = options.get("item") or ""
folder = os.path.abspath(options.get("folder") or "")
try:
timeout = float(options.get("timeout") or LAUNCH_TIMEOUT)
except ValueError:
timeout = LAUNCH_TIMEOUT
if not 0 < timeout < float("inf"):
timeout = LAUNCH_TIMEOUT
deadline = time.monotonic() + timeout
if not (app and namespace and item and options.get("folder")):
return answer(False, reason="missing-game")
sidecar = read_json(os.path.join(folder, SIDECAR))
if not isinstance(sidecar, dict) or sidecar.get("id") != app:
return answer(False, reason="no-sidecar")
if not launcher_takes_args(folder):
return answer(False, reason="old-launcher")
report = status()
if not report["installed"]:
return answer(False, reason="not-installed")
if not report["fex"]:
return answer(False, reason="no-fex")
if not report["signedIn"] and not handoff_ready():
return answer(False, reason="signed-out")
remove(os.path.join(folder, ARGS_FILE))
info = live_instance()
spawned = None
if info is None:
log = os.path.join(LOGS, "hidden.log")
os.makedirs(LOGS, exist_ok=True)
with contextlib.suppress(OSError):
os.replace(log, log + ".1")
with open(log, "wb") as out:
spawned = subprocess.Popen([sys.executable, SELF, "serve", "--mode", "hidden"], stdin=subprocess.DEVNULL,
stdout=out, stderr=out, start_new_session=True)
if not wait_for(lambda: live_instance() is not None or spawned.poll() is not None, BROKER_WAIT, 0.25) \
or spawned.poll() is not None:
stop_spawned(spawned, read_json(instance_file()))
return answer(False, reason="client-start")
info = live_instance()
try:
reply = hand_off(info, spawned, app, namespace, item, options.get("owner"), deadline)
except (OSError, ValueError, subprocess.SubprocessError) as error:
reply = {"ok": False, "reason": "error-" + type(error).__name__}
if not reply.get("ok"):
stop_spawned(spawned, info)
return answer(False, reason=reply.get("reason") or "no-launch")
write_args(folder, sidecar, reply.get("args") or [])
say("the client handed over %s with %d arguments" % (os.path.basename(reply.get("exe") or ""), len(reply.get("args") or [])))
return answer(True)
def hand_off(info, spawned, app, namespace, item, owner, deadline):
def left():
return max(0.0, deadline - time.monotonic())
def gone():
return (spawned is not None and spawned.poll() is not None) or not pid_alive(info.get("pid"))
if info is None:
return {"ok": False, "reason": "client-start"}
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as conn:
conn.connect(info["broker"])
send(conn, {"op": "await", "app": app, "owner": owner, "timeout": max(1.0, left())})
if info.get("mode") == "visible" and select.select([conn], [], [], CLAIM_PEEK)[0]:
try:
reply = receive(conn, max(1.0, left()))
except (OSError, ValueError):
return {"ok": False, "reason": "client-exited" if gone() else "timeout"}
if isinstance(reply, dict) and reply.get("ok"):
say("took the launch the client already started for %s" % app)
return reply if isinstance(reply, dict) else {"ok": False, "reason": "bad-reply"}
state = {}
def ready():
current = api()
if current is not None and installed(current, app) is not None:
state["api"] = current
return gone() or "api" in state
if not wait_for(ready, left(), 1.0) or gone():
return {"ok": False, "reason": "client-exited" if gone() else "client-not-ready"}
if not wait_for(lambda: gone() or installed(state["api"], app) is True, min(REGISTER_WAIT, left()), 1.0) or gone():
return {"ok": False, "reason": "client-exited" if gone() else "not-registered"}
if not wait_for(lambda: gone() or signed_in(), min(SIGN_IN_WAIT, left()), 1.0) or gone():
return {"ok": False, "reason": "client-exited" if gone() else "signed-out"}
url = deep_link(namespace, item, app)
if not wait_for(lambda: gone() or forward(info["bus"], url), min(20.0, left()), 1.0) or gone():
return {"ok": False, "reason": "client-exited" if gone() else "deep-link"}
say("asked the client to launch %s" % app)
try:
reply = receive(conn, max(1.0, left()))
except (OSError, ValueError):
return {"ok": False, "reason": "client-exited" if gone() else "timeout"}
return reply if isinstance(reply, dict) else {"ok": False, "reason": "bad-reply"}
def stop_group(proc, wait=STOP_WAIT):
if proc.poll() is None:
with contextlib.suppress(OSError):
os.killpg(proc.pid, signal.SIGTERM)
try:
proc.wait(wait)
except subprocess.TimeoutExpired:
pass
with contextlib.suppress(OSError):
os.killpg(proc.pid, signal.SIGKILL)
with contextlib.suppress(subprocess.TimeoutExpired):
proc.wait(5)
def stop_spawned(proc, info=None):
if proc is None:
return
path = info.get("broker") if isinstance(info, dict) and info.get("pid") == proc.pid else None
asked = False
if path:
with contextlib.suppress(OSError, ValueError):
ask_broker({"op": "stop"}, timeout=3.0, path=path)
asked = True
try:
proc.wait(STOP_WAIT + 10 if asked else 0)
except subprocess.TimeoutExpired:
stop_group(proc)
def exited(options):
info = read_json(instance_file())
if not isinstance(info, dict) or info.get("mode") not in ("hidden", "visible") or not pid_alive(info.get("pid")):
return 0
with contextlib.suppress(OSError, ValueError):
ask_broker({"op": "exited", "code": int(options.get("code") or 0)}, timeout=3.0, path=info.get("broker"))
return 0
def sign_in_url(url):
try:
parts = urllib.parse.urlsplit(url)
query = urllib.parse.parse_qs(parts.query)
redirect = urllib.parse.urlsplit((query.get("redirect_uri") or [""])[0])
except ValueError:
return False
return parts.scheme == "https" and parts.hostname in ("www.epicgames.com", "epicgames.com") \
and parts.path.startswith("/id/authorize") and redirect.scheme == "http" \
and redirect.hostname in ("127.0.0.1", "localhost") and redirect.port is not None
def post(channel, request):
req = os.path.join(channel, "stores", "req")
os.makedirs(req, exist_ok=True)
rid = "epic-%d-%d" % (os.getpid(), time.time_ns())
tmp = os.path.join(req, rid + ".json.tmp")
with open(tmp, "w", encoding="utf-8") as f:
json.dump(request, f)
os.rename(tmp, os.path.join(req, rid + ".json"))
return rid
def hand_over(op, url, launch_dir, auto=False):
request = {"op": op, "url": url}
if auto:
request["auto"] = True
post(launch_dir, request)
def ask_app(request, timeout):
channel = launch_dir()
if not channel:
return None
rid = post(channel, request)
reply = os.path.join(channel, "stores", "resp", rid + ".json")
value = {}
def answered():
found = read_json(reply)
if isinstance(found, dict):
value.update(found)
return True
return False
if not wait_for(answered, timeout, 0.1):
remove(os.path.join(channel, "stores", "req", rid + ".json"))
return None
remove(reply)
return value
def handoff_ready():
reply = ask_app({"op": "epic-client-handoff"}, HANDOFF_WAIT)
if isinstance(reply, dict) and reply.get("ok"):
return True
say("no DroidDeck Epic account to sign the launcher in with (%s)" % ((reply or {}).get("reason") or "no answer"))
return False
def carry_sign_in():
remove(AUTO_SIGN_IN)
if signed_in() or not handoff_ready():
return False
say("signing the launcher in with DroidDeck's Epic account")
return True
def a11y_connect(address):
try:
from gi.repository import Gio
flags = Gio.DBusConnectionFlags.AUTHENTICATION_CLIENT | Gio.DBusConnectionFlags.MESSAGE_BUS_CONNECTION
return Gio.DBusConnection.new_for_address_sync(address, flags, None, None)
except Exception:
return None
def a11y_call(conn, name, path, interface, method, args=None, reply=None):
from gi.repository import GLib
answer = conn.call_sync(name, path, interface, method, args, GLib.VariantType(reply) if reply else None,
0, 2000, None)
return answer.unpack()
def a11y_buttons(address):
conn = a11y_connect(address) if address else None
if conn is None:
return {}
from gi.repository import GLib
found = {}
try:
names = a11y_call(conn, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus",
"ListNames", None, "(as)")[0]
queue = collections.deque()
for name in names:
if not name.startswith(":"):
continue
try:
xml = a11y_call(conn, name, A11Y_WEB_ROOT, "org.freedesktop.DBus.Introspectable", "Introspect", None, "(s)")[0]
except Exception:
continue
queue.extend((name, A11Y_WEB_ROOT + "/" + node) for node in re.findall(r'<node name="([^"]+)"', xml))
seen = set()
deadline = time.monotonic() + A11Y_BUDGET
while queue and len(seen) < A11Y_LIMIT and time.monotonic() < deadline:
node = queue.popleft()
if node in seen:
continue
seen.add(node)
try:
attrs = a11y_call(conn, node[0], node[1], A11Y_ACCESSIBLE, "GetAttributes", None, "(a{ss})")[0]
if attrs.get("tag") == "button":
label = a11y_call(conn, node[0], node[1], "org.freedesktop.DBus.Properties", "Get",
GLib.Variant("(ss)", (A11Y_ACCESSIBLE, "Name")), "(v)")[0]
if isinstance(label, str) and label.strip():
found.setdefault(label.strip(), node)
continue
queue.extend(tuple(kid) for kid in
a11y_call(conn, node[0], node[1], A11Y_ACCESSIBLE, "GetChildren", None, "(a(so))")[0])
except Exception:
continue
except Exception:
return found
finally:
conn.close_sync(None)
return found
def a11y_press(address, target):
conn = a11y_connect(address)
if conn is None:
return False
from gi.repository import GLib
try:
return bool(a11y_call(conn, target[0], target[1], "org.a11y.atspi.Action", "DoAction",
GLib.Variant("(i)", (0,)), "(b)")[0])
except Exception:
return False
finally:
conn.close_sync(None)
def auto_sign_in():
try:
return 0 <= time.time() - os.stat(AUTO_SIGN_IN).st_mtime < AUTO_SIGN_IN_FRESH
except OSError:
return False
def shim_open(argv):
url = argv[0] if argv else ""
channel = launch_dir()
steam = STEAM_RUN.match(url)
if steam and channel:
post(channel, {"op": "steam-run", "id": steam.group(1)})
say("xdg-open: handed Steam game %s to the app" % steam.group(1))
return 0
if not url.startswith(("https://", "http://")) or not channel:
say("xdg-open: nothing to hand over")
return 1
op = "epic-sign-in" if sign_in_url(url) else "open-url"
hand_over(op, url, channel, op == "epic-sign-in" and auto_sign_in())
say("xdg-open: handed %s to the app" % op)
return 0
def shim_proton(argv):
verb, rest = (argv[0], argv[1:]) if argv else ("", [])
if verb == "getcompatpath":
print(windows_path(rest[0]) if rest else "")
return 0
if verb == "getnativepath":
print(native_path(rest[0]) if rest else "")
return 0
if verb not in LAUNCH_VERBS:
return 0
if not rest:
return 1
request = {"op": "launch", "verb": verb, "exe": rest[0], "args": rest[1:], }
try:
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
sock.connect(os.environ.get(BROKER_ENV) or broker_path())
send(sock, request)
reply = receive(sock, None)
except (OSError, ValueError) as error:
say("proton: no broker (%s)" % type(error).__name__)
return 1
try:
return int(reply.get("code") or 0) if isinstance(reply, dict) else 1
except (TypeError, ValueError):
return 1
def main(argv):
if not argv:
say("usage: droiddeck-epic install|run|launch|exited|serve")
return 2
action, args = argv[0], list(argv[1:])
try:
if action == "proton":
return shim_proton(args)
if action == "xdg-open":
return shim_open(args)
if action == "install":
options, _ = parse_options(args, lists=("desktop",))
try:
return install(options)
except (ValueError, tarfile.TarError, OSError) as error:
raise Failure("unpack-" + type(error).__name__)
if action == "run":
return serve("visible")
if action == "serve":
options, _ = parse_options(args)
return serve(options.get("mode") or "hidden")
if action == "launch":
options, _ = parse_options(args)
return launch(options)
if action == "exited":
options, _ = parse_options(args)
return exited(options)
except Failure as failure:
say("failed: %s" % failure)
print(json.dumps({"ok": False, "reason": str(failure)}))
return 1
say("unknown action %s" % action)
return 2
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))