#!/usr/bin/python3 import fcntl import http.client import json import math import os import re import runpy import shutil import signal import subprocess import sys import threading import time import urllib.request HOME = os.environ.get("HOME") or "/root" BIN = "/usr/local/bin" PROTON_RUN = os.path.join(BIN, "droiddeck-proton-run") GAME_DEBUG = runpy.run_path(os.path.join(os.path.dirname(os.path.abspath(__file__)), "droiddeck-game-debug")) APP_ID = "2596113170" INSTALLER_URL = "https://downloader.battle.net/download/getInstallerForGame?os=win&gameProgram=BATTLENET_APP&version=Live" CLIENT_DIR = ("Program Files (x86)", "Battle.net") LAUNCHER = "Battle.net Launcher.exe" CLIENT = "Battle.net.exe" CONFIG = ("users", "steamuser", "AppData", "Roaming", "Battle.net", "Battle.net.config") DEFAULT_CONFIG = {"Client": {"HardwareAcceleration": "false", "Streaming": {"StreamingEnabled": "false"}}} LAUNCH_BEHAVIOR = ("GameLaunchWindowBehavior", "2") CLIENT_32_BIT = ("s1",) CACHE = os.path.join(HOME, ".cache", "droiddeck", "battlenet") MENU = "/usr/local/share/applications/droiddeck-battlenet.desktop" WALLPAPER_DIR = ("users", "steamuser", "AppData", "Local", "DroidDeck") DESKTOP_KEY = "[Control Panel\\\\Desktop]" COLORS_KEY = "[Control Panel\\\\Colors]" WALLPAPER_EDGE = (4, 6, 11) USER_PREFERENCES = "UserPreferencesMask" WINE_USER_PREFERENCES = bytes((0x10, 0x00, 0x00, 0x80, 0x12, 0x00, 0x00, 0x00)) CLIENT_AREA_ANIMATION = (4, 0x02) WALLPAPER_MAX = (1280, 720) FEX_REQUEST = "battlenet-fex.request" FEX_RESULT = "battlenet-fex.result" FEX_WAIT = 120 START_GRACE = 90 POLL = 2 STOP_WAIT = 5 DRIVES = "defghijklmnopqruvwxy" PRODUCT_DB = ("ProgramData", "Battle.net", "Agent", "product.db") INSTALL_FOLDER = (1, 3, 1) CLOSE_GRACE = 15 HANDOFF_WAIT = 120 GAME_SETTLE = 20 AGENT_GONE = 30 AGENT = "agent.exe" CODE = re.compile(r"[A-Za-z0-9_]{1,16}") GAME_UID = re.compile(r"[a-z0-9_]{1,32}") HANDOVER_WAIT = 1800 CLIENT_READY = 5 READY_SETTLE = 5 CLIENT_WAIT = 300 GAME_GRACE = 15 LAUNCH_WAIT = 15 LAUNCH_ASKS = 3 CLIENT_PATH = re.compile(r"[a-z]:\\(program files \(x86\)\\battle\.net\\([^\\]+$|battle\.net\.\d+\\)|programdata\\battle\.net\\)") IDLE = {"agent.exe", "conhost.exe", "explorer.exe", "lsass.exe", "plugplay.exe", "rpcss.exe", "services.exe", "start.exe", "steam.exe", "svchost.exe", "tabtip.exe", "winedevice.exe", "wineserver"} NOT_GAME = IDLE | {"rundll32.exe", "wineboot.exe", "winemenubuilder.exe"} MIN_INSTALLER = 1 << 20 SETUP = "Battle.net-Setup.exe" REQUEST = "battlenet-request" REQUEST_FILE = re.compile(re.escape(REQUEST) + r"\.\d+") LIBRARY = None WOW_UID = re.compile(r"--uid=wow[a-z0-9_]*", re.I) GAMEPAD_SETTING = re.compile(r"(?im)^\s*SET\s+GamePadEnable\s") GX_API_SETTING = re.compile(r"(?im)^[ \t]*SET[ \t]+gxApi[ \t].*$") GX_API_MARK = ".droiddeck-d3d11" STEAM_CLIENT = {"steam", "steamwebhelper"} LOG = os.path.join(CACHE, "battlenet.log") AGENT_DIR = ("ProgramData", "Battle.net", "Agent") AGENT_BUILD = re.compile(r"Agent\.(\d+)") AGENT_PORT = re.compile(r"\d{2,5}") AGENT_START = 90 AGENT_HELPER = "agent.js" AGENT_RUNTIME = "agent-runtime" AGENT_LOG = "agent.log" AGENT_LOG_LIMIT = 4 << 20 HEADLESS = ["--backend", "headless", "-w", "640", "-h", "480"] PRODUCT = re.compile(r"[a-z0-9_]{1,32}") LOCALE = re.compile(r"[a-z]{2}[A-Z]{2}") COUNTRY = re.compile(r"[A-Z]{3}") REGION = re.compile(r"[A-Z]{2}") REPORT = "BNET" ETA_LIMIT = 30 * 86400 STALL = 600 MOVING = ("download_current", "download_total", "progress", "playable_progress", "state", "phase", "paused", "error") DONE_STATE = 1004 REPORTED = ("progress", "playable_progress", "download_rate", "download_remaining", "estimated_time_in_sec", "state", "playable", "paused", "download_complete", "installed", "error") AGENT_SCRIPT = r"""var a = WScript.Arguments, port = a(0), action = a(1), uid = a(2), product = a(3), dir = a(4); var lang = a(5), country = a(6), region = a(7), out = a(8), token = ""; var fso = new ActiveXObject("Scripting.FileSystemObject"); function save(name, text) { var f = fso.CreateTextFile(out + name + ".tmp", true, true); f.Write(text); f.Close(); if (fso.FileExists(out + name)) fso.DeleteFile(out + name); fso.MoveFile(out + name + ".tmp", out + name); } function call(method, path, body) { var r = new ActiveXObject("WinHttp.WinHttpRequest.5.1"); r.SetTimeouts(10000, 10000, 30000, 30000); r.Open(method, "http://127.0.0.1:" + port + path, false); r.SetRequestHeader("User-Agent", "phoenix-agent/1.0"); if (token) r.SetRequestHeader("Authorization", token); r.Send(body || ""); return r.ResponseText; } function field(text, name) { var m = new RegExp('"' + name + '"\\s*:\\s*"([^"]*)"').exec(text); return m ? m[1] : ""; } function object(text, name) { var start = new RegExp('"' + name + '"\\s*:\\s*\\{').exec(text); if (!start) return ""; var from = start.index + start[0].length, depth = 0; for (var i = from - 1; i < text.length; i++) { if (text.charAt(i) == "{") depth++; else if (text.charAt(i) == "}" && --depth == 0) return text.substring(from, i); } return ""; } function job(text) { if (/"error"\s*:\s*[1-9]/.test(text)) return false; var bare = text.replace(/"extended_status"\s*:\s*\{[^}]*\}/, ""); return /"state"\s*:\s*\d+/.test(bare) || /"download_current"\s*:/.test(bare); } function install() { // Blizzard's China repository moved to cn.patch.battlenet.com.cn; cn.patch.battle.net only redirects away from it. var patch = zone == "cn" ? "cn.patch.battlenet.com.cn" : zone + ".patch.battle.net"; var form = call("POST", "/install", '{"uid":"' + uid + '","instructions_patch_url":"http://' + patch + ':1119/' + product + '","instructions_product":"NGDP","monitor_pid":12345,"priority":{"insert_at_head":true,"value":900}}'); save(".form", form); if (form.indexOf('"' + lang + '"') < 0) lang = "enUS"; var locale = lang.toLowerCase(); call("POST", "/install/" + uid, '{"account_country":"' + country + '","finalized":true,"game_dir":"' + dir.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '","geo_ip_country":"' + region + '","language":["' + locale + '"],"selected_asset_locale":"' + locale + '","selected_locale":"' + locale + '","shortcut":"none","tome_torrent":""}'); watch("/install/" + uid); } function watch(path) { var started = false; for (var i = 0; ; i++) { var s = call("GET", path); save(".json", s); if (/"form"\s*:\s*\{/.test(s)) { var refused = /"error"\s*:\s*(\d+)/.exec(object(s, "game_dir")); if (refused && +refused[1] != 0) throw new Error(+refused[1] == 800 ? "the game folder already holds a game" : "Battle.net refused the game folder (error " + refused[1] + ")"); } else if (/"error"\s*:\s*[1-9]/.test(s)) break; var state = /"state"\s*:\s*(\d+)/.exec(s.replace(/"extended_status"\s*:\s*\{[^}]*\}/, "")), complete = /"download_complete"\s*:\s*true/.test(s); state = state ? +state[1] : 0; if (state == 1000 || state == 1003 || job(s) && !complete) started = true; if (started && (state == 1004 || complete && /"playable"\s*:\s*true/.test(s))) break; if (!started && state == 1004 && i >= 20) break; if (!started && i >= 180) { if (/"playable"\s*:\s*true/.test(call("GET", "/game/" + uid))) break; throw new Error("the agent did not start the " + action); } WScript.Sleep(1000); } save(".game", call("GET", "/game/" + uid)); } function update() { save(".form", call("POST", "/update", '{"uid":"' + uid + '","priority":{"insert_at_head":true,"value":900}}')); watch("/update/" + uid); } function uninstall() { save(".json", call("POST", "/uninstall", '{"uid":"' + uid + '","run_compaction":true}')); for (var i = 0; i < 900; i++) { var s = call("GET", "/game/" + uid); save(".game", s); if (!/"installed"\s*:\s*true/.test(s)) break; WScript.Sleep(1000); } } var zone = "us"; try { var agent = call("GET", "/agent"); token = field(agent, "authorization"); zone = field(agent, "region") || "us"; if (!token) throw new Error("no authorization from the agent"); if (action == "install") install(); else if (action == "update") update(); else uninstall(); } catch (e) { save(".error", e.message || "the agent stopped answering"); WScript.Quit(1); } """ LOG_LIMIT = 512 << 10 def say(message): line = "droiddeck-battlenet: %s" % message print(line, file=sys.stderr, flush=True) try: os.makedirs(CACHE, exist_ok=True) if os.path.exists(LOG) and os.path.getsize(LOG) > LOG_LIMIT: os.replace(LOG, LOG + ".1") with open(LOG, "a", encoding="utf-8") as f: f.write("%s [%d] %s\n" % (time.strftime("%Y-%m-%d %H:%M:%S"), os.getpid(), message)) except OSError: pass def notify(title, body, icon="dialog-information"): if not os.environ.get("DBUS_SESSION_BUS_ADDRESS") or not shutil.which("notify-send"): return try: subprocess.run(["notify-send", "-a", "DroidDeck", "-i", icon, title, body], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=5) except (OSError, subprocess.SubprocessError): pass def steam_root(): return os.environ.get("STEAM_COMPAT_CLIENT_INSTALL_PATH") or os.path.join(HOME, ".local", "share", "Steam") def prefix(root): return os.path.join(root, "steamapps", "compatdata", APP_ID) def drive_c(root): return os.path.join(prefix(root), "pfx", "drive_c") def client_dir(root): return os.path.join(drive_c(root), *CLIENT_DIR) def launcher(root): return os.path.join(client_dir(root), LAUNCHER) def installed(root): return os.path.isfile(launcher(root)) def dosdevices(root): return os.path.join(prefix(root), "pfx", "dosdevices") def volume_root(path): device = os.stat(path).st_dev while path != "/": parent = os.path.dirname(path) if os.stat(parent).st_dev != device: break path = parent return path def inside(path, folder): return path == folder or path.startswith(folder.rstrip("/") + "/") def mapped_drive(root, path, volume): folder = dosdevices(root) try: names = sorted(os.listdir(folder)) except OSError: return None for name in names: link = os.path.join(folder, name) if len(name) == 2 and name[0].lower() in DRIVES and name[1] == ":" and os.path.islink(link): target = os.path.realpath(link) if inside(target, volume) and inside(path, target): return name[0].lower(), target return None def map_drive(root, volume): folder = dosdevices(root) for letter in DRIVES: link = os.path.join(folder, letter + ":") if not os.path.lexists(link): try: os.makedirs(folder, exist_ok=True) os.symlink(volume, link) except OSError as error: say("%s not mapped to a Wine drive: %s" % (volume, error)) return None say("Wine drive %s: is %s" % (letter.upper(), volume)) return letter, volume say("%s not mapped to a Wine drive: every letter is taken" % volume) return None def install_path(root, library): library = library.rstrip("/") or "/" try: path = os.path.realpath(library) volume = volume_root(path) except OSError: return "Z:" + library if volume == "/": return "Z:" + library drive = mapped_drive(root, path, volume) if drive is None and not wine_processes(os.path.join(prefix(root), "pfx")): drive = map_drive(root, volume) if drive is None: return "Z:" + library letter, target = drive return letter.upper() + ":\\" + path[len(target):].strip("/").replace("/", "\\") def keeps_open(root): try: with open(os.path.join(drive_c(root), *CONFIG), encoding="utf-8-sig") as f: client = json.load(f).get("Client") except (OSError, ValueError, AttributeError): return False return isinstance(client, dict) and LAUNCH_BEHAVIOR[0] in client and client[LAUNCH_BEHAVIOR[0]] != LAUNCH_BEHAVIOR[1] def write_config(root, library=None): path = os.path.join(drive_c(root), *CONFIG) key, value = LAUNCH_BEHAVIOR try: with open(path, encoding="utf-8-sig") as f: config = json.load(f) except FileNotFoundError: config = None except (OSError, ValueError): return None first = config is None if first: config = json.loads(json.dumps(DEFAULT_CONFIG)) elif not (isinstance(config, dict) and isinstance(config.setdefault("Client", {}), dict)): return None client = config["Client"] changes = [] if key not in client: client[key] = value changes.append("launch") if client.get("HardwareAcceleration") != "false": client["HardwareAcceleration"] = "false" changes.append("acceleration") if library and isinstance(client.setdefault("Install", {}), dict) \ and str(client["Install"].get("DefaultInstallPath", "")).rstrip("/\\") != install_path(root, library).rstrip("\\"): client["Install"]["DefaultInstallPath"] = install_path(root, library) changes.append("library") games = config.setdefault("Games", {}) for uid in CLIENT_32_BIT if isinstance(games, dict) else (): game = games.setdefault(uid, {}) if isinstance(game, dict) and game.get("Run64BitSet") != "true": game.update(Run64Bit="false", Run64BitSet="true") changes.append("32-bit") if not changes: return None os.makedirs(os.path.dirname(path), exist_ok=True) with open(path + ".tmp", "w", encoding="utf-8") as f: json.dump(config, f, indent=4) os.replace(path + ".tmp", path) return "first" if first else " ".join(changes) def wallpaper_bmp(width, height): scale = min(width / 1920.0, height / 1080.0) ox, oy = (width - 1920 * scale) / 2, (height - 1080 * scale) / 2 stops = ((0.0, (20, 33, 58)), (0.5, (10, 17, 32)), (1.0, WALLPAPER_EDGE)) glow = (26, 159, 255) logo_px = scale * 1.6 def background(u, v): t = min(math.hypot(u - 960, v - 540) / 1150, 1.0) (t0, c0), (t1, c1) = (stops[0], stops[1]) if t <= 0.5 else (stops[1], stops[2]) f = (t - t0) / (t1 - t0) color = [c0[i] + (c1[i] - c0[i]) * f for i in range(3)] d = math.hypot(u - 947.21, v - 540) / 420 if d < 1: a = 0.22 * (1 - d) color = [color[i] * (1 - a) + glow[i] * a for i in range(3)] return color def box(x, y, x0, y0, x1, y1): dx, dy = max(x0 - x, x - x1), max(y0 - y, y - y1) return math.hypot(max(dx, 0), max(dy, 0)) + min(max(dx, dy), 0) def white(x, y): half = max(math.hypot(x - 63.97, y - 111.86) - 111.86, 63.97 - x) shape = min(box(x, y, -31.98, 0, 63.97, 223.72), half) hole = min(math.hypot(x - 63.98, y - 111.86) - 71.81, box(x, y, 56.055, -1, 71.885, 45), box(x, y, 56.055, 178.72, 71.885, 225)) return max(shape, -hole) rows = [] pad = b"\0" * ((4 - width * 3 % 4) % 4) for y in range(height - 1, -1, -1): v = (y + 0.5 - oy) / scale ly = (v - 361.02) / 1.6 row = bytearray() for x in range(width): u = (x + 0.5 - ox) / scale color = background(u, v) lx = (u - 844.84) / 1.6 if -40 < lx < 185 and -8 < ly < 232: for sd, ink in ((white(lx, ly), (255, 255, 255)), (math.hypot(lx - 63.98, ly - 111.86) - 55.98, glow)): cover = min(max(0.5 - sd * logo_px, 0.0), 1.0) if cover: color = [color[i] * (1 - cover) + ink[i] * cover for i in range(3)] row += bytes((int(color[2] + 0.5), int(color[1] + 0.5), int(color[0] + 0.5))) rows.append(bytes(row) + pad) pixels = b"".join(rows) header = b"BM" + (54 + len(pixels)).to_bytes(4, "little") + b"\0\0\0\0" + (54).to_bytes(4, "little") info = (40).to_bytes(4, "little") + width.to_bytes(4, "little") + height.to_bytes(4, "little") + \ (1).to_bytes(2, "little") + (24).to_bytes(2, "little") + b"\0" * 4 + len(pixels).to_bytes(4, "little") + \ (2835).to_bytes(4, "little") * 2 + b"\0" * 8 return header + info + pixels def reg_value(reg, key, name, value): return reg_line(reg, key, name, '"%s"="%s"' % (name, value.replace("\\", "\\\\").replace('"', '\\"'))) def reg_dword(reg, key, name, number): return reg_line(reg, key, name, '"%s"=dword:%08x' % (name, number)) def reg_read(reg, key, name): with open(reg, encoding="utf-8", errors="replace") as f: rows = f.read().splitlines() inside, last = False, None for row in rows: if row.startswith("["): inside = row.startswith(key + " ") or row == key elif inside and row.startswith('"%s"=' % name): last = row return last def reg_line(reg, key, name, line): try: last = reg_read(reg, key, name) except OSError: return False if last != line: with open(reg, "a", encoding="utf-8") as out: out.write("\n%s %d\n%s\n" % (key, int(time.time()), line)) return True def still_pages(root): reg = os.path.join(prefix(root), "pfx", "user.reg") if not os.path.isfile(reg): return False row = reg_read(reg, DESKTOP_KEY, USER_PREFERENCES) found = re.fullmatch(r'"%s"=hex:([0-9a-fA-F]{2}(?:,[0-9a-fA-F]{2})*)' % USER_PREFERENCES, row or "") mask = bytearray(bytes.fromhex(found.group(1).replace(",", "")) if found else WINE_USER_PREFERENCES) at, bit = CLIENT_AREA_ANIMATION if len(mask) <= at or not mask[at] & bit: return False mask[at] &= ~bit if wine_processes(os.path.join(prefix(root), "pfx")): say("Battle.net's prefix is in use; Windows animations go off the next time it starts on its own") return False reg_line(reg, DESKTOP_KEY, USER_PREFERENCES, '"%s"=hex:%s' % (USER_PREFERENCES, ",".join("%02x" % b for b in mask))) return True def desktop_size(): width, height = os.environ.get("DD_WIDTH", ""), os.environ.get("DD_HEIGHT", "") if width.isdigit() and height.isdigit() and 0 < int(width) <= 7680 and 0 < int(height) <= 4320: return int(width), int(height) return 1280, 720 def desktop_dpi(): width, height = desktop_size() return 96 * max(4, int(min(width / 1920.0, height / 1080.0) * 4)) // 4 def dpi(root): reg = os.path.join(prefix(root), "pfx", "user.reg") return os.path.isfile(reg) and reg_dword(reg, DESKTOP_KEY, "LogPixels", desktop_dpi()) def wallpaper(root): width, height = desktop_size() shrink = min(1.0, WALLPAPER_MAX[0] / width, WALLPAPER_MAX[1] / height) width, height = max(1, round(width * shrink)), max(1, round(height * shrink)) name = "wallpaper-%dx%d.bmp" % (width, height) folder = os.path.join(drive_c(root), *WALLPAPER_DIR) path = os.path.join(folder, name) reg = os.path.join(prefix(root), "pfx", "user.reg") if not os.path.isfile(reg): return False if not os.path.isfile(path): os.makedirs(folder, exist_ok=True) with open(path + ".tmp", "wb") as f: f.write(wallpaper_bmp(width, height)) os.replace(path + ".tmp", path) say("drew DroidDeck's wallpaper for Battle.net's %dx%d desktop" % (width, height)) windows = "C:\\" + "\\".join(WALLPAPER_DIR + (name,)) reg_value(reg, DESKTOP_KEY, "Wallpaper", windows) reg_value(reg, DESKTOP_KEY, "TileWallpaper", "0") reg_value(reg, DESKTOP_KEY, "WallpaperStyle", "2" if shrink < 1 else "0") reg_value(reg, COLORS_KEY, "Background", "%d %d %d" % WALLPAPER_EDGE) return True def windows_path(root, path): found = re.match(r"(?i)^([a-z]):[\\/](.*)$", path.strip()) if not found: return None parts = [part for part in re.split(r"[\\/]+", found.group(2)) if part] if ".." in parts: return None letter = found.group(1).lower() link = os.path.join(dosdevices(root), letter + ":") if letter == "c": target = drive_c(root) elif os.path.islink(link): target = os.path.realpath(link) elif letter == "z": target = "/" else: return None return os.path.join(target, *parts) def varint(data, at): value = shift = 0 while at < len(data) and shift < 64: byte = data[at] at += 1 value |= (byte & 0x7F) << shift if not byte & 0x80: return value, at shift += 7 raise ValueError("varint") def encode_varint(value): out = bytearray() while value > 0x7F: out.append(value & 0x7F | 0x80) value >>= 7 out.append(value) return bytes(out) def rewrite_field(data, path, change): out, at = bytearray(), 0 while at < len(data): start = at tag, at = varint(data, at) kind = tag & 7 if kind == 0: at = varint(data, at)[1] elif kind == 1: at += 8 elif kind == 5: at += 4 elif kind == 2: size, body = varint(data, at) at = body + size else: raise ValueError("wire type") if at > len(data): raise ValueError("length") if kind == 2 and tag >> 3 == path[0]: value = data[body:at] value = change(value) if len(path) == 1 else rewrite_field(value, path[1:], change) out += encode_varint(tag) + encode_varint(len(value)) + value else: out += data[start:at] return bytes(out) def drive_folder(root, value): try: text = value.decode("utf-8") except UnicodeDecodeError: return value if not re.match(r"(?i)^z:[\\/]", text): return value folder = windows_path(root, text) if not folder or not os.path.isdir(folder): return value moved = install_path(root, folder) return value if moved.startswith("Z:") else moved.replace("\\", "/").encode("utf-8") def move_installs(root): path = os.path.join(drive_c(root), *PRODUCT_DB) try: with open(path, "rb") as f: data = f.read() moved = rewrite_field(data, INSTALL_FOLDER, lambda value: drive_folder(root, value)) if moved == data or wine_processes(os.path.join(prefix(root), "pfx")): return False with open(path, "rb") as f: if f.read() != data: return False except (OSError, ValueError): return False with open(path + ".tmp", "wb") as f: f.write(moved) shutil.copymode(path, path + ".tmp") os.replace(path + ".tmp", path) return True def wow_folders(root): try: with open(os.path.join(prefix(root), "pfx", "system.reg"), encoding="utf-8", errors="replace") as f: rows = f.read().splitlines() except OSError: return [] folders, location, wow = [], None, False for row in rows + ["["]: if row.startswith("["): if wow and location: folders.append(location) location, wow = None, False elif row.startswith('"InstallLocation"='): location = windows_path(root, row.split("=", 1)[1].strip().strip('"').replace("\\\\", "\\")) elif row.startswith('"UninstallString"=') and WOW_UID.search(row): wow = True return [folder for folder in dict.fromkeys(folders) if os.path.isdir(folder)] def wow_settings(root): changed = [] for folder in wow_folders(root): try: flavors = sorted(name for name in os.listdir(folder) if len(name) > 2 and name.startswith("_") and name.endswith("_")) except OSError: continue for name in flavors: if not os.path.isdir(os.path.join(folder, name)): continue wtf = os.path.join(folder, name, "WTF") path = os.path.join(wtf, "Config.wtf") mark = os.path.join(wtf, GX_API_MARK) try: with open(path, encoding="utf-8", errors="replace") as f: text = f.read() except FileNotFoundError: text = "" except OSError: continue updated, notes = text, [] if not GAMEPAD_SETTING.search(updated): updated += ("\n" if updated and not updated.endswith("\n") else "") + 'SET GamePadEnable "1"\n' notes.append("controller support on") first = not os.path.exists(mark) if first: before = updated updated, found = GX_API_SETTING.subn('SET gxApi "D3D11"', updated) if not found: updated += ("\n" if updated and not updated.endswith("\n") else "") + 'SET gxApi "D3D11"\n' if updated != before: notes.append("DirectX 11") if updated == text and not first: continue try: os.makedirs(wtf, exist_ok=True) if updated != text: with open(path + ".tmp", "w", encoding="utf-8") as f: f.write(updated) os.replace(path + ".tmp", path) if first: with open(mark, "w", encoding="utf-8"): pass except OSError as error: say("World of Warcraft's settings not written in %s: %s" % (path, error)) continue if notes: changed.append(path) say("World of Warcraft's settings in %s: %s" % (path, ", ".join(notes))) return changed def steam_running(proc="/proc"): try: pids = [p for p in os.listdir(proc) if p.isdigit()] except OSError: return False for pid in pids: try: with open(os.path.join(proc, pid, "cmdline"), "rb") as f: argv = [os.path.basename(a.decode("utf-8", "replace")) for a in f.read().split(b"\0")[:2] if a] except OSError: continue if argv[:1] and argv[0] in ("FEX", "FEXInterpreter"): argv = argv[1:] if argv[:1] and argv[0] in STEAM_CLIENT: return True return False def proton_env(): env = dict(os.environ) env = GAME_DEBUG["apply_game_debug_logs"](env) if not steam_running(): env.setdefault("PROTON_SPOOF_STEAMINPUT_VIDPID", "1") return env def configure(root, library=None): if library: try: os.makedirs(library, exist_ok=True) except OSError as error: say("%s not made: %s" % (library, error)) try: change = write_config(root, library) except OSError as error: say("Battle.net's config not written: %s" % error) return try: if move_installs(root): say("Battle.net's installed games on a mapped volume now use its Wine drive") except OSError as error: say("Battle.net's installed games not moved to their Wine drive: %s" % error) try: wallpaper(root) except OSError as error: say("Battle.net's desktop wallpaper not set: %s" % error) try: dpi(root) except OSError as error: say("Battle.net's desktop scale not set: %s" % error) try: if still_pages(root): say("Battle.net's desktop: Windows animations off, so its pages do not play videos the CPU has to draw") except OSError as error: say("Battle.net's desktop animations not set: %s" % error) wow_settings(root) if change == "first": say("wrote Battle.net's first config: hardware acceleration off, streaming off, closing itself as it launches a game, " "StarCraft on its 32-bit client") elif change: if "launch" in change: say("Battle.net's config: closing itself as it launches a game") if "library" in change: say("Battle.net's config: games install to %s" % library) if "acceleration" in change: say("Battle.net's config: browser hardware acceleration off") if "32-bit" in change: say("Battle.net's config: StarCraft starts its 32-bit client") def write_menu(path=MENU): body = ("[Desktop Entry]\nType=Application\nName=Battle.net\nComment=Blizzard's games and launcher\n" "Exec=%s\nIcon=applications-games\nTerminal=false\nCategories=Network;\n" % os.path.join(BIN, "droiddeck-battlenet")) try: with open(path, encoding="utf-8") as f: if f.read() == body: return except OSError: pass try: os.makedirs(os.path.dirname(path), exist_ok=True) with open(path + ".tmp", "w", encoding="utf-8") as f: f.write(body) os.replace(path + ".tmp", path) except OSError as error: say("menu entry not written: %s" % error) def ask_fex(launch_dir, wait=FEX_WAIT): if not launch_dir or not os.path.isdir(launch_dir): say("not inside a DroidDeck session; FEX stays as Components has it") return None result = os.path.join(launch_dir, FEX_RESULT) request = os.path.join(launch_dir, FEX_REQUEST) try: os.unlink(result) except OSError: pass with open(request + ".tmp", "w", encoding="utf-8") as f: f.write("appid=%s\n" % APP_ID) os.replace(request + ".tmp", request) deadline = time.monotonic() + wait while time.monotonic() < deadline: try: with open(result, encoding="utf-8") as f: answer = f.read().strip() except OSError: time.sleep(0.5) continue os.unlink(result) return answer return None def wine_processes(pfx, proc="/proc"): want = os.path.realpath(pfx).rstrip("/") found = [] try: pids = [p for p in os.listdir(proc) if p.isdigit()] except OSError: return found for pid in pids: try: with open(os.path.join(proc, pid, "environ"), "rb") as f: env = f.read().split(b"\0") with open(os.path.join(proc, pid, "cmdline"), "rb") as f: argv = [a.decode("utf-8", "replace") for a in f.read().split(b"\0") if a] except OSError: continue for item in env: if item.startswith(b"WINEPREFIX="): value = item[len(b"WINEPREFIX="):].decode("utf-8", "replace") if os.path.realpath(value).rstrip("/") == want: found.append((int(pid), argv)) break return found def program(argv): return re.split(r"[\\/]", argv[0])[-1].lower() if argv else "" def is_client(argv): return program(argv) == CLIENT.lower() def idle(processes): return all(program(argv) in IDLE for _, argv in processes) def running(pfx): return any(is_client(argv) for _, argv in wine_processes(pfx)) def is_battlenet(argv): return bool(argv) and bool(CLIENT_PATH.match(argv[0].replace("/", "\\").lower())) def is_game(argv): if not argv or program(argv) in NOT_GAME or not re.match(r"[A-Za-z]:[\\/]", argv[0]): return False return not is_battlenet(argv) def launched(argv): return is_game(argv) and "-uid" in (arg.lower() for arg in argv[1:]) def shares_sign_in(argv): return "-sso" in (arg.lower() for arg in argv[1:]) def agent_up(processes): return any(is_client(argv) for _, argv in processes) and any(program(argv) == AGENT for _, argv in processes) class Tidy: def __init__(self, settle=None, gone=None): self.settle = GAME_SETTLE if settle is None else settle self.gone = AGENT_GONE if gone is None else gone self.game_since = None self.closed_for_game = False self.agent_seen = False self.agent_lost = None def __call__(self, processes, now): own = [(pid, argv) for pid, argv in processes if is_battlenet(argv)] games = [argv for _, argv in processes if launched(argv)] if games: self.game_since = self.game_since if self.game_since is not None else now if own and not self.closed_for_game and now - self.game_since >= self.settle: self.closed_for_game, self.agent_seen, self.agent_lost = True, False, None if keeps_open(steam_root()): say("Battle.net is set to stay open as a game launches: left open") return False if any(is_client(argv) for _, argv in own) and any(shares_sign_in(argv) for argv in games): say("Battle.net stayed open beside a game signing in with its token: left open") return False say("the game is up: closing what is left of Battle.net (%d process(es)) to leave it their memory" % len(own)) stop(own) return True return False self.game_since, self.closed_for_game = None, False if not any(is_client(argv) for _, argv in processes): self.agent_seen, self.agent_lost = False, None elif agent_up(processes): self.agent_seen, self.agent_lost = True, None elif self.agent_seen: self.agent_lost = self.agent_lost if self.agent_lost is not None else now if now - self.agent_lost >= self.gone: say("Battle.net has outlived its Agent: closing it (%d process(es))" % len(own)) stop(own) notify("Battle.net was closed", "It had lost Blizzard's update service. Open it again to reconnect.", "dialog-warning") self.agent_seen, self.agent_lost = False, None return True return False def desktop_gpu(): if os.environ.get("DD_DESKTOP") != "1" or os.environ.get("DD_DESKTOP_GPU_CHILD"): return None if os.environ.get("DD_DESKTOP_GPU", "on").strip().lower() in ("off", "0", "no", "false"): return None gpu = os.path.join(BIN, "droiddeck-gpu") return gpu if os.access(gpu, os.X_OK) else None def proton_options(): if os.environ.get("DD_DESKTOP") == "1" and not os.environ.get("DD_DESKTOP_GPU_CHILD"): return ["--window"] width, height = os.environ.get("DD_WIDTH", ""), os.environ.get("DD_HEIGHT", "") options = ["--desktop", "%sx%s" % (width, height)] if width.isdigit() and height.isdigit() else [] game = os.environ.get("SteamGameId", "") return options + (["--game-id", game] if game.isdigit() and game != "0" else []) def stop(processes, wait=STOP_WAIT): pids = [pid for pid, _ in processes] for sig in (signal.SIGTERM, signal.SIGKILL): for pid in pids: try: os.kill(pid, sig) except OSError: pass deadline = time.monotonic() + wait while time.monotonic() < deadline: pids = [pid for pid in pids if os.path.exists("/proc/%d" % pid)] if not pids: return time.sleep(0.2) def queued_requests(launch_dir): try: names = os.listdir(launch_dir) except OSError: return [] return sorted(name for name in names if REQUEST_FILE.fullmatch(name)) def serve_requests(pfx, processes=None, launch_dir=None): launch_dir = launch_dir or os.environ.get("DD_LAUNCH_DIR") names = queued_requests(launch_dir) if launch_dir else [] if not names or not agent_up(wine_processes(pfx) if processes is None else processes): return False client = os.path.join(pfx, "drive_c", *CLIENT_DIR, CLIENT) served = False for name in names: path = os.path.join(launch_dir, name) try: with open(path, encoding="utf-8") as f: args = [line for line in f.read().splitlines() if line] os.unlink(path) except OSError: continue if len(args) == 2 and args[0] == "install-game" and GAME_UID.fullmatch(args[1]): spawn(client, "run", ["--install", "--game=%s" % args[1]]) elif len(args) == 2 and args[0] == "launch" and CODE.fullmatch(args[1]): spawn(client, "run", ["--exec=launch %s" % args[1]]) else: say("not a request: %s" % " ".join(args)) continue say("the app asked for %s" % " ".join(args)) served = True return served def wait_while_open(pfx, grace, poll=None): deadline = time.monotonic() + grace seen = False while True: serve_requests(pfx) if running(pfx): seen = True elif seen or time.monotonic() >= deadline: return seen time.sleep(POLL if poll is None else poll) def proton(exe, args=(), verb=None, watch=None, poll=None, close_grace=None, tidy=None): cmd = [PROTON_RUN] + proton_options() + ["--prefix", APP_ID] + (["--verb", verb] if verb else []) + [exe] + list(args) say(" ".join(cmd)) try: process = subprocess.Popen(cmd, env=proton_env()) except OSError as error: say("%s: %s" % (PROTON_RUN, error)) return 127, False seen = False closed_at = None grace = CLOSE_GRACE if close_grace is None else close_grace tidy = Tidy() if tidy is None else tidy while True: try: status = process.wait(timeout=POLL if poll is None else poll) return status, seen except subprocess.TimeoutExpired: pass if watch is None: continue processes = wine_processes(watch) serve_requests(watch, processes) now = time.monotonic() if tidy(processes, now): seen = True processes = wine_processes(watch) if any(is_client(argv) for _, argv in processes): seen, closed_at = True, None elif seen and idle(processes): closed_at = closed_at if closed_at is not None else now if now - closed_at >= grace: say("Battle.net closed; stopping %d process(es) it left in its prefix" % len(processes)) stop(processes) closed_at = None else: closed_at = None def setup_ready(path): try: with open(path, "rb") as f: return f.read(2) == b"MZ" and os.path.getsize(path) >= MIN_INSTALLER except OSError: return False def download(url=INSTALLER_URL, folder=CACHE): os.makedirs(folder, exist_ok=True) dest = os.path.join(folder, SETUP) if setup_ready(dest): return dest part = dest + ".part" try: try: request = urllib.request.Request(url, headers={"User-Agent": "DroidDeck"}) with urllib.request.urlopen(request, timeout=60) as response, open(part, "wb") as f: shutil.copyfileobj(response, f) length = response.headers.get("Content-Length", "") if length.isdigit() and f.tell() != int(length): raise OSError("the download ended early") except (OSError, http.client.HTTPException) as error: if not shutil.which("curl"): raise say("download through Python failed (%s); trying curl" % error) if subprocess.call(["curl", "-fsSL", "--max-time", "300", "-o", part, url]) != 0: raise OSError("curl could not download it") if not setup_ready(part): raise OSError("not a Windows program") os.replace(part, dest) except (OSError, http.client.HTTPException) as error: say("installer download failed: %s" % error) try: os.unlink(part) except OSError: pass return dest if os.path.isfile(dest) else None def install(root, pfx, verb=None): setup = download() if setup is None: notify("Battle.net could not be downloaded", "Check the connection and try again.", "dialog-error") return False, False configure(root, LIBRARY) notify("Installing Battle.net", "Blizzard's installer opens in a window. It can take a few minutes.") _, seen = proton(setup, verb=verb, watch=pfx) return installed(root), seen def acquire(folder=CACHE): os.makedirs(folder, exist_ok=True) handle = open(os.path.join(folder, "battlenet.lock"), "w") try: fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB) except OSError: handle.close() return None return handle def status(root): pfx = os.path.join(prefix(root), "pfx") return {"appid": int(APP_ID), "prefix": prefix(root), "installed": installed(root), "launcher": launcher(root), "running": running(pfx)} def spawn(program, verb, args=()): cmd = [PROTON_RUN] + proton_options() + ["--prefix", APP_ID, "--verb", verb, program] + list(args) say(" ".join(cmd)) try: os.makedirs(CACHE, exist_ok=True) with open(os.path.join(CACHE, "spawned.log"), "ab") as log: child = subprocess.Popen(cmd, stdin=subprocess.DEVNULL, stdout=log, stderr=log, start_new_session=True, env=proton_env()) threading.Thread(target=child.wait, daemon=True).start() except OSError as error: say("%s: %s" % (PROTON_RUN, error)) return 127 return 0 def show(root, wait=None, poll=None, args=()): pfx = os.path.join(prefix(root), "pfx") client = os.path.join(client_dir(root), CLIENT) deadline = time.monotonic() + (HANDOFF_WAIT if wait is None else wait) while True: processes = wine_processes(pfx) if any(is_client(argv) for _, argv in processes) and os.path.isfile(client) \ and (agent_up(processes) or time.monotonic() >= deadline): spawn(client, "run", args) return None lock = acquire() if lock is not None: say("the other start has ended; opening Battle.net") return lock if time.monotonic() >= deadline: say("the other start neither opened Battle.net nor ended") notify("Battle.net is busy", "Another start is still running; try again in a moment.", "dialog-warning") return None time.sleep(POLL if poll is None else poll) def stop_leftovers(pfx): processes = wine_processes(pfx) if not processes: return True if not idle(processes): say("the prefix is in use (%s); Battle.net starts beside it" % ", ".join(sorted({program(a) for _, a in processes} - IDLE))) return False say("stopping %d process(es) a closed Battle.net left in its prefix" % len(processes)) stop(processes) return True def open_client(root, reinstall=False): pfx = os.path.join(prefix(root), "pfx") write_menu() answer = ask_fex(os.environ.get("DD_LAUNCH_DIR")) say("FEX: %s" % (answer or "no answer from the app; Components' choice stays")) if running(pfx): say("Battle.net is already running in its prefix; waiting for it to close") wait_while_open(pfx, grace=0) return 0 verb = None if stop_leftovers(pfx) else "run" if reinstall or not installed(root): done, seen = install(root, pfx, verb) if not done: notify("Battle.net did not install", "The session's desktop.log says why.", "dialog-error") return 1 if wait_while_open(pfx, grace=0 if seen else START_GRACE) or seen: return 0 verb = None if stop_leftovers(pfx) else "run" configure(root, LIBRARY) status_code, seen = proton(launcher(root), verb=verb, watch=pfx) say("Proton returned %d; Battle.net %s" % (status_code, "ran" if seen else "has not been seen yet")) if not (wait_while_open(pfx, grace=0 if seen else START_GRACE) or seen): say("Battle.net did not start (the launcher exited with %d)" % status_code) notify("Battle.net did not start", "The session's desktop.log says why.", "dialog-error") return status_code or 1 say("Battle.net closed") return 0 def start(exe, verb=None): cmd = [PROTON_RUN] + proton_options() + ["--prefix", APP_ID] + (["--verb", verb] if verb else []) + [exe] say(" ".join(cmd)) try: return subprocess.Popen(cmd, env=proton_env()) except OSError as error: say("%s: %s" % (PROTON_RUN, error)) return None def wait_ready(pfx, wait=None, poll=None, settle=None): deadline = time.monotonic() + (CLIENT_WAIT if wait is None else wait) while True: count = sum(1 for _, argv in wine_processes(pfx) if is_client(argv)) if count >= CLIENT_READY: time.sleep(READY_SETTLE if settle is None else settle) return True if time.monotonic() >= deadline: return count > 0 time.sleep(POLL if poll is None else poll) def follow(pfx, poll=None, grace=None, tidy=None, ask=None): seen, gone_at = False, None asked, asks = None, 1 grace = GAME_GRACE if grace is None else grace tidy = Tidy() if tidy is None else tidy while True: processes = wine_processes(pfx) serve_requests(pfx, processes) now = time.monotonic() if tidy(processes, now): processes = wine_processes(pfx) games = sorted({program(argv) for _, argv in processes if is_game(argv)}) if games: if not seen: say("game running: %s" % ", ".join(games)) seen, gone_at = True, None elif seen or not any(is_client(argv) for _, argv in processes): gone_at = gone_at if gone_at is not None else now if now - gone_at >= grace: say("the game has exited" if seen else "Battle.net closed before a game started") return seen else: gone_at = None asked = now if asked is None else asked if ask is not None and asks < LAUNCH_ASKS and now - asked >= LAUNCH_WAIT: say("Battle.net has not started the game yet; asking again") ask() asked, asks = now, asks + 1 time.sleep(POLL if poll is None else poll) def launch(root, code): pfx = os.path.join(prefix(root), "pfx") client = os.path.join(client_dir(root), CLIENT) if not installed(root) or not os.path.isfile(client): say("Battle.net is not installed; %s is not launched" % code) notify("Battle.net is not installed", "Install it from its tile on DroidDeck's Desktop tab.", "dialog-error") return 1 lock = acquire() try: own = None if lock is not None and not running(pfx): answer = ask_fex(os.environ.get("DD_LAUNCH_DIR")) say("FEX: %s" % (answer or "no answer from the app; Components' choice stays")) verb = None if stop_leftovers(pfx) else "run" configure(root, LIBRARY) own = start(launcher(root), verb) if own is None: return 127 if not wait_ready(pfx): say("Battle.net did not open; %s is not launched" % code) notify("Battle.net did not start", "The session's desktop.log says why.", "dialog-error") return 1 if code.lower().startswith("wow"): wow_settings(root) say("launching %s" % code) spawn(client, "run", ["--exec=launch %s" % code]) played = follow(pfx, ask=lambda: spawn(client, "run", ["--exec=launch %s" % code])) if own is not None: leftovers = wine_processes(pfx) say("stopping what the Battle.net opened for %s left: %d process(es)" % (code, len(leftovers))) stop(leftovers) try: own.wait(timeout=STOP_WAIT * 4) except subprocess.TimeoutExpired: say("its Proton is still ending") return 0 if played else 1 finally: if lock is not None: lock.close() def hand_over(root, args, wait=None): if not wait_ready(os.path.join(prefix(root), "pfx"), wait=HANDOVER_WAIT if wait is None else wait): say("Battle.net did not come up; %s not asked for" % " ".join(args)) return False spawn(os.path.join(client_dir(root), CLIENT), "run", args) return True def install_game(root, uid): args = ["--install", "--game=%s" % uid] if installed(root) and agent_up(wine_processes(os.path.join(prefix(root), "pfx"))): say("asking the open Battle.net to install %s" % uid) spawn(os.path.join(client_dir(root), CLIENT), "run", args) return 0 lock = acquire() if lock is None: say("another start holds the lock") lock = show(root, args=args) if lock is None: return 0 threading.Thread(target=hand_over, args=(root, args), daemon=True).start() with lock: return open_client(root) def agent_exe(root): folder = os.path.join(drive_c(root), *AGENT_DIR) try: names = os.listdir(folder) except OSError: return None builds = sorted(((int(m.group(1)), name) for name in names for m in [AGENT_BUILD.fullmatch(name)] if m), reverse=True) for _, name in builds: exe = os.path.join(folder, name, "Agent.exe") if os.path.isfile(exe): return exe return None def agent_port(root): try: with open(os.path.join(drive_c(root), *AGENT_DIR, "Agent.dat"), encoding="ascii", errors="replace") as f: text = f.read().strip() except OSError: return None return int(text) if AGENT_PORT.fullmatch(text) else None def answers(port, timeout=2): try: conn = http.client.HTTPConnection("127.0.0.1", port, timeout=timeout) try: conn.request("GET", "/agent", headers={"User-Agent": "phoenix-agent/1.0"}) conn.getresponse().read() finally: conn.close() return True except (OSError, http.client.HTTPException): return False def agent_env(): env = proton_env() env["PROTON_USE_XALIA"] = "0" return env def agent_failed(status, reason): say(reason) try: with open(status.replace("\\", "/")[2:] + ".error", "w", encoding="utf-8") as f: f.write(reason) except OSError: pass def agent_serve(root, args, wait=None, poll=None): exe = agent_exe(root) if exe is None: agent_failed(args[-1], "no Blizzard Agent in the Battle.net prefix") return 3 cmd = [PROTON_RUN, "--prefix", APP_ID, "--verb", "run"] say("starting Blizzard's Agent on its own: %s" % exe) try: agent = subprocess.Popen(cmd + [exe, "--internalclienttools"], stdin=subprocess.DEVNULL, env=agent_env()) except OSError as error: say("%s: %s" % (PROTON_RUN, error)) return 127 deadline = time.monotonic() + (AGENT_START if wait is None else wait) port = None while time.monotonic() < deadline: port = agent_port(root) if port and answers(port): break if agent.poll() is not None and not any(program(argv) == AGENT for _, argv in wine_processes(os.path.join(prefix(root), "pfx"))): agent_failed(args[-1], "the Agent exited before it answered") return 4 port = None time.sleep(POLL if poll is None else poll) if port is None: agent_failed(args[-1], "the Agent did not answer in time") return 4 helper = os.path.join(CACHE, AGENT_HELPER) with open(helper, "w", encoding="utf-8") as f: f.write(AGENT_SCRIPT) cscript = os.path.join(drive_c(root), "windows", "system32", "cscript.exe") say("the Agent answers on port %d; %s %s" % (port, args[0], args[1])) return subprocess.call(cmd + [cscript, "//nologo", "Z:" + helper.replace("/", "\\"), str(port)] + list(args), env=agent_env()) def emit(kind, value=""): print(("%s_%s %s" % (REPORT, kind, value)).rstrip(), flush=True) def read_status(path): try: with open(path, "rb") as f: data = f.read() except OSError: return None for encoding in ("utf-16", "utf-8-sig"): try: value = json.loads(data.decode(encoding)) except (UnicodeDecodeError, ValueError): continue if isinstance(value, dict): return value return None def summary(status): out = {key: status[key] for key in REPORTED if key in status} for key in ("download_current", "download_total"): value = status.get(key) if isinstance(value, list) and value and isinstance(value[0], (int, float)): out[key] = value[0] phase = (status.get("extended_status") or {}).get("state") if isinstance(phase, int): out["phase"] = phase eta = out.get("estimated_time_in_sec") if not isinstance(eta, int) or not 0 <= eta <= ETA_LIMIT: out.pop("estimated_time_in_sec", None) return out def agent_job(root, action, uid, product="", folder="", locale="enUS", country="USA", region="US", poll=None, wait=None, stall=None): pfx = os.path.join(prefix(root), "pfx") if not installed(root) or agent_exe(root) is None: emit("ERROR", "client") return 3 windows = "" if action == "install": if not folder.startswith("/") or any(c in folder for c in '"\\\n'): emit("ERROR", "folder") return 2 try: os.makedirs(folder, exist_ok=True) except OSError as error: say("%s not made: %s" % (folder, error)) emit("ERROR", "folder") return 2 told = None while True: processes = wine_processes(pfx) busy = bool(processes) and not idle(processes) lock = None if busy else acquire() if lock is not None: break state = "waiting" if busy else "queued" if told != state: say("%s; the %s of %s waits for it" % ("Battle.net or a game is open" if busy else "another Battle.net job holds the prefix", action, uid)) emit("STATE", state) told = state time.sleep(POLL if poll is None else poll) with lock: stop_leftovers(pfx) if action == "install": windows = install_path(root, folder) emit("STATE", "starting") base = os.path.join(CACHE, "agent-%s" % uid) for suffix in (".json", ".game", ".form", ".error"): try: os.unlink(base + suffix) except OSError: pass runtime = os.path.join(CACHE, AGENT_RUNTIME) os.makedirs(runtime, mode=0o700, exist_ok=True) env = agent_env() for name in ("DISPLAY", "WAYLAND_DISPLAY"): env.pop(name, None) env["XDG_RUNTIME_DIR"] = runtime cmd = ["gamescope"] + HEADLESS + ["--", os.path.abspath(sys.argv[0]), "agent-serve", action, uid, product or "-", windows or "-", locale, country, region, "Z:" + base.replace("/", "\\")] say("%s %s through the Agent: %s" % (action, uid, " ".join(cmd))) output = os.path.join(CACHE, AGENT_LOG) try: if os.path.getsize(output) > AGENT_LOG_LIMIT: os.replace(output, output + ".1") except OSError: pass before = {pid for pid, _ in wine_processes(pfx)} with open(output, "ab") as log: try: child = subprocess.Popen(cmd, stdin=subprocess.DEVNULL, stdout=log, stderr=log, env=env) except OSError as error: emit("ERROR", "stopped gamescope: %s" % error) return 1 seen = None mark = None moved = time.monotonic() stalled = False while True: done = child.poll() is not None status = read_status(base + ".json") if status is not None and action != "uninstall": brief = summary(status) if brief != seen: emit("PROGRESS", json.dumps(brief, sort_keys=True)) seen = brief signature = tuple(brief.get(key) for key in MOVING) if signature != mark: mark = signature moved = time.monotonic() if done: break if action != "uninstall" and time.monotonic() - moved > (STALL if stall is None else stall): say("the %s of %s made no progress for %d s; stopping it" % (action, uid, STALL if stall is None else stall)) stalled = True child.kill() child.wait() break time.sleep(POLL if poll is None else poll) leftovers = wine_processes(pfx) if leftovers and idle(leftovers): stop(leftovers) elif stalled: stop([(pid, argv) for pid, argv in leftovers if pid not in before and program(argv) == AGENT]) if stalled: emit("ERROR", "stalled") return 6 answer = read_status(base + ".game") game = answer or {} status = read_status(base + ".json") or {} try: with open(base + ".error", "rb") as f: data = f.read() reason = data.decode("utf-16" if data[:2] in (b"\xff\xfe", b"\xfe\xff") else "utf-8", "replace").strip() \ or "the agent stopped answering" except OSError: reason = None code = status.get("error") if reason is None and isinstance(code, int) and code > 0: emit("ERROR", "agent %d" % code) say("the %s of %s stopped: Agent error %d" % (action, uid, code)) return 5 if reason is None and action != "uninstall" and game.get("installed") is True \ and (game.get("playable") is True or status.get("state") == DONE_STATE): binary = ((game.get("binaries") or {}).get("game") or {}).get("relative_path", "") emit("DONE", json.dumps({"install_dir": game.get("install_dir", windows), "exe": binary, "version": game.get("local_version", "")}, sort_keys=True)) say("%s %s in %s" % (uid, "updated" if action == "update" else "installed", game.get("install_dir", windows))) return 0 if reason is None and action == "uninstall" and (game.get("installed") is False or answer == {}): emit("DONE", json.dumps({"uninstalled": uid})) say("%s uninstalled" % uid) return 0 reason = reason or "exit %d" % child.returncode say("the %s of %s stopped: %s" % (action, uid, reason)) emit("ERROR", "stopped %s" % reason.replace("\n", " ")) return 1 def main(argv): global LIBRARY argv = list(argv) if len(argv) >= 2 and argv[0] == "--library": if not argv[1].startswith("/") or "\n" in argv[1]: say("%s is not a folder" % argv[1]) return 2 LIBRARY = os.path.normpath(argv[1]) argv = argv[2:] action = argv[0] if argv else "open" if action == "agent-serve" and len(argv) == 9: return agent_serve(steam_root(), argv[1:]) if action == "agent-install" and len(argv) == 7 and GAME_UID.fullmatch(argv[1]) and PRODUCT.fullmatch(argv[2]) and argv[3].startswith("/") \ and LOCALE.fullmatch(argv[4]) and COUNTRY.fullmatch(argv[5]) and REGION.fullmatch(argv[6]): return agent_job(steam_root(), "install", argv[1], argv[2], os.path.normpath(argv[3]), argv[4], argv[5], argv[6]) if action in ("agent-update", "agent-uninstall") and len(argv) == 2 and GAME_UID.fullmatch(argv[1]): return agent_job(steam_root(), action[len("agent-"):], argv[1]) launching = action == "launch" and len(argv) == 2 and CODE.fullmatch(argv[1]) getting = action == "install-game" and len(argv) == 2 and GAME_UID.fullmatch(argv[1]) if not (launching or getting) and (action not in ("open", "install", "status") or len(argv) > 1): say("usage: droiddeck-battlenet [--library DIR] [open | install | status | launch CODE | install-game ID | " "agent-install ID PRODUCT DIR LOCALE COUNTRY REGION | agent-update ID | agent-uninstall ID]") return 2 root = steam_root() if action == "status": print(json.dumps(status(root))) return 0 gpu = desktop_gpu() if gpu: say("the desktop starts Battle.net on the GPU") os.execv(gpu, [gpu, os.path.abspath(sys.argv[0])] + list(sys.argv[1:])) os.environ["DD_BATTLENET"] = "1" if launching: say("launch %s" % argv[1]) return launch(root, argv[1]) if getting: say("install-game %s" % argv[1]) return install_game(root, argv[1]) say("%s (%s)" % (action, "from the menu" if not sys.stderr.isatty() else "from a terminal")) lock = acquire() if lock is None: say("another start holds the lock") lock = show(root) if lock is None: return 0 with lock: return open_client(root, reinstall=action == "install") if __name__ == "__main__": sys.exit(main(sys.argv[1:]))