Files
DroidDeck/tools/linuxfs/overlay/usr/local/bin/droiddeck-battlenet
T
91a217879f fix: surface Battle.net's own reason when it refuses a game folder (#1661)
* fix: surface Battle.net's own reason when it refuses a game folder

watch() treated any "error": <nonzero> in the Agent's status JSON as fatal. The
install form carries nested errors of its own - language.error 704 when the
requested locale is not offered, game_dir.error when the folder is unusable - so
the loop ended before the install started and agent_job reported "exit 0".

A form with a non-zero game_dir.error now fails with that reason (800 reads as
"the game folder already holds a game"); otherwise the wait continues, and only
a top-level error still ends the loop.

* fix: move the form-failure regression out of the crowded test block

Keep the driver behavior unchanged; this only relocates the new regression case so
the branch can be merged with current main without a test-file conflict.

* fix: sync the agent-error change onto current main

Bring the two touched files up to the current main versions and apply the form
failure handling on top. This keeps the PR limited to the driver and its test
without pulling workflow files into the branch.

---------

Co-authored-by: visail <visail@users.noreply.github.com>
Co-authored-by: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com>
2026-11-15 10:51:05 -05:00

1583 lines
59 KiB
Python
Executable File

#!/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 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 client.get(key) != value:
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("BL_WIDTH", ""), os.environ.get("BL_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 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("BL_DESKTOP") != "1" or os.environ.get("BL_DESKTOP_GPU_CHILD"):
return None
if os.environ.get("BL_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("BL_DESKTOP") == "1" and not os.environ.get("BL_DESKTOP_GPU_CHILD"):
return ["--window"]
width, height = os.environ.get("BL_WIDTH", ""), os.environ.get("BL_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("BL_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("BL_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("BL_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["BL_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:]))