mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 12:56:06 +00:00
1595 lines
60 KiB
Python
Executable File
1595 lines
60 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 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:]))
|