mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 04:46:08 +00:00
* feat(ubisoft): keep Denuvo game tokens per account and product until the game invalidates them * feat(ubisoft): sync cloud saves through Ubisoft's cloud save service * fix(xbox): turning cloud saves off passes the offline mode the game save runtime reads * fix(ubisoft): Ubisoft games list their shared prefix, so they get a saves and cloud tab * feat(ea): sync cloud saves through EA's cloud sync service * fix(ea): sync at EA launch and exit, keep one rule snapshot, and check the cloud copy under the write lock * fix(ubisoft): exact slot versions, scoped save export, and a Denuvo cache bound to its account * fix(ea): fresh rules per sync, checksums required, backup before restore, and sign-in shown on the saves tab * fix(ubisoft): launch-time sync on the shared prefix, saves scoped to the game, and Denuvo bound to each launch's account * fix(ea): back up only the saves a restore replaces, refuse truncated manifests, and need a master title id * fix(ubisoft): treat a slot whose bytes changed since the last sync as a conflict before uploading over it * fix(ea): one resolved save folder per sync, refuse case collisions, and walk each folder once * fix(ubisoft): sync only identified slots, keep live saves and backups safe, and tie a pending eviction to its account * fix(cloud): a forced download fetches every saved conflict and keeps the ones it could not write * test(ea): keep the cloud save cases in EaTest * fix(ubisoft): report only written slots, keep drift conflicts, read whole headers, and never rename a named eviction * fix(ea): keep real save folders in the inventory, back up any restored file, refuse duplicate or malformed cloud listings * fix(cloud): commit Ubisoft slots one at a time and stop on a newer cloud write, name skipped and blocked slots, keep unsent conflicts * fix(ubisoft): acknowledge an invalidation only once its marker is published and never serve a kept token after it * fix(cloud): a cloud request the launcher cannot write still starts the game and keeps the exit upload * fix(cloud): scope Ubisoft sync state to the account and product, compare alike slots, keep committed progress, and name partial slots * fix(ea): ask for sign-in after a rejected refresh, upload saves reached through folder aliases * fix(cloud): a launch that stops waiting for the cloud download claims it back, so no save is written once the game starts * fix(ubisoft): name the account in an invalidation marker and never hold the token lock across a pipe write * fix(ea): only invalid_grant asks for sign-in again, and case collisions count only among synced saves * test(epic): let the launcher's ask doubles take the claim flag * fix(ea): apply save rules in their order, match bare patterns inside the save folder, and resolve LocalLow and install folders * fix(ubisoft): stamp a fresh identifier into a new save that has none, so it can sync * fix(ubisoft): answer a burn ticket request as unavailable instead of leaving the game waiting * fix(cloud): read EA manifests with the XML parser, clear conflicts whose sides match, and bound the claim and stall tests
561 lines
24 KiB
Python
Executable File
561 lines
24 KiB
Python
Executable File
#!/usr/bin/python3
|
|
import hashlib
|
|
import hmac
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import runpy
|
|
import secrets
|
|
import shutil
|
|
import socket
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import threading
|
|
import xml.etree.ElementTree as ElementTree
|
|
|
|
BIN = Path(__file__).resolve().parent
|
|
RUNTIME = Path('/usr/local/lib/droiddeck-xbox')
|
|
DLLS = ('xgameruntime.dll', 'winhttp.dll', 'windows.web.dll', 'twinapi.appcore.dll', 'wintypes.dll', 'libnghttp2.dll')
|
|
CLASSES = {
|
|
'twinapi.appcore.dll': ('Windows.ApplicationModel.DataTransfer.DataTransferManager',
|
|
'Windows.Security.ExchangeActiveSyncProvisioning.EasClientDeviceInformation',
|
|
'Windows.System.Profile.AnalyticsInfo', 'Windows.System.UserProfile.AdvertisingManager',
|
|
'Windows.UI.ViewManagement.ApplicationView'),
|
|
'windows.web.dll': ('Windows.Data.Json.JsonArray', 'Windows.Data.Json.JsonObject', 'Windows.Data.Json.JsonValue'),
|
|
'wintypes.dll': ('Windows.Foundation.PropertyValue', 'Windows.Foundation.Collections.PropertySet',
|
|
'Windows.Foundation.Metadata.ApiInformation', 'Windows.Storage.Streams.Buffer',
|
|
'Windows.Storage.Streams.DataWriter'),
|
|
}
|
|
CLASS_KEY = 'Software\\Microsoft\\WindowsRuntime\\ActivatableClassId\\'
|
|
VIEW_DRIVES = 'xwvutsrqponmlkjihgfe'
|
|
|
|
|
|
def bridge(upstream):
|
|
key = secrets.token_hex(32).encode('ascii')
|
|
server = socket.socket()
|
|
server.bind(('127.0.0.1', 0))
|
|
server.listen(16)
|
|
clients = set()
|
|
lock = threading.Lock()
|
|
stopped = threading.Event()
|
|
|
|
def forward(source, target):
|
|
try:
|
|
while not stopped.is_set():
|
|
data = source.recv(65536)
|
|
if not data:
|
|
break
|
|
target.sendall(data)
|
|
except OSError:
|
|
pass
|
|
finally:
|
|
try:
|
|
target.shutdown(socket.SHUT_WR)
|
|
except OSError:
|
|
pass
|
|
|
|
def connect(client):
|
|
remote = None
|
|
try:
|
|
client.settimeout(10)
|
|
supplied = b''
|
|
while len(supplied) < len(key):
|
|
part = client.recv(len(key) - len(supplied))
|
|
if not part:
|
|
return
|
|
supplied += part
|
|
if not hmac.compare_digest(supplied, key):
|
|
return
|
|
remote = socket.socket(socket.AF_UNIX)
|
|
remote.connect(upstream)
|
|
client.settimeout(None)
|
|
with lock:
|
|
clients.add(remote)
|
|
writer = threading.Thread(target=forward, args=(client, remote), daemon=True)
|
|
writer.start()
|
|
forward(remote, client)
|
|
writer.join(2)
|
|
except OSError:
|
|
pass
|
|
finally:
|
|
for sock in (client, remote):
|
|
if sock is not None:
|
|
with lock:
|
|
clients.discard(sock)
|
|
sock.close()
|
|
|
|
def accept():
|
|
while not stopped.is_set():
|
|
try:
|
|
client, _ = server.accept()
|
|
except OSError:
|
|
break
|
|
with lock:
|
|
if len(clients) >= 64:
|
|
client.close()
|
|
continue
|
|
clients.add(client)
|
|
threading.Thread(target=connect, args=(client,), daemon=True).start()
|
|
|
|
threading.Thread(target=accept, daemon=True).start()
|
|
|
|
def close():
|
|
stopped.set()
|
|
server.close()
|
|
with lock:
|
|
for client in clients:
|
|
try:
|
|
client.shutdown(socket.SHUT_RDWR)
|
|
except OSError:
|
|
pass
|
|
client.close()
|
|
clients.clear()
|
|
|
|
return server.getsockname()[1], key.decode('ascii'), close
|
|
|
|
|
|
def register_classes(proton, prefix, env):
|
|
try:
|
|
registry = (prefix / 'system.reg').read_text(encoding='utf-8', errors='replace')
|
|
except OSError:
|
|
return
|
|
missing = [(name, dll) for dll, names in CLASSES.items() for name in names
|
|
if '[%s]' % (CLASS_KEY + name).replace('\\', '\\\\') not in registry]
|
|
if not missing:
|
|
return
|
|
text = 'Windows Registry Editor Version 5.00\r\n\r\n' + ''.join(
|
|
'[HKEY_LOCAL_MACHINE\\%s%s]\r\n"DllPath"="C:\\\\windows\\\\system32\\\\%s"\r\n\r\n' % (CLASS_KEY, name, dll)
|
|
for name, dll in missing)
|
|
with tempfile.TemporaryDirectory(prefix='droiddeck-xbox-') as temporary:
|
|
source = Path(temporary) / 'classes.reg'
|
|
source.write_bytes(b'\xff\xfe' + text.encode('utf-16-le'))
|
|
try:
|
|
failed = subprocess.run([proton, 'run', 'reg.exe', 'import', 'Z:' + str(source).replace('/', '\\')],
|
|
stdout=sys.stderr, env=env, timeout=90).returncode != 0
|
|
except subprocess.TimeoutExpired:
|
|
failed = True
|
|
if failed:
|
|
print('droiddeck-xbox: Windows Runtime class registration failed; launching without it', file=sys.stderr)
|
|
|
|
|
|
def game_config(exe):
|
|
path = Path(exe)
|
|
if not path.is_absolute():
|
|
return None
|
|
for folder in list(path.parents)[:4]:
|
|
config = folder / 'MicrosoftGame.config'
|
|
if config.is_file():
|
|
return config
|
|
return None
|
|
|
|
|
|
def windows_arguments(text):
|
|
arguments, current, quoted, started, at = [], [], False, False, 0
|
|
while at < len(text):
|
|
char = text[at]
|
|
if char == '\\':
|
|
run = len(text) - at - len(text[at:].lstrip('\\'))
|
|
at += run
|
|
if at < len(text) and text[at] == '"':
|
|
current.append('\\' * (run // 2))
|
|
if run % 2:
|
|
current.append('"')
|
|
at += 1
|
|
else:
|
|
current.append('\\' * run)
|
|
started = True
|
|
continue
|
|
if char == '"':
|
|
if quoted and text[at + 1:at + 2] == '"':
|
|
current.append('"')
|
|
at += 2
|
|
continue
|
|
quoted = not quoted
|
|
started = True
|
|
elif char in ' \t' and not quoted:
|
|
if started:
|
|
arguments.append(''.join(current))
|
|
current, started = [], False
|
|
else:
|
|
current.append(char)
|
|
started = True
|
|
at += 1
|
|
if started:
|
|
arguments.append(''.join(current))
|
|
return arguments
|
|
|
|
|
|
def install_actions(config):
|
|
try:
|
|
root = ElementTree.fromstring(config.read_bytes())
|
|
except (OSError, ElementTree.ParseError):
|
|
return []
|
|
actions = []
|
|
for registration in root.iter():
|
|
if registration.tag.rsplit('}', 1)[-1] != 'CustomInstallActions':
|
|
continue
|
|
folder = next((node.text or '' for node in registration if node.tag.rsplit('}', 1)[-1] == 'Folder'), '')
|
|
for node in registration.iter():
|
|
if node.tag.rsplit('}', 1)[-1] != 'InstallAction':
|
|
continue
|
|
name, file = node.get('Name', ''), node.get('File', '')
|
|
parts = [part for part in (folder.strip() + '\\' + file).replace('/', '\\').split('\\') if part]
|
|
if not name or not file or any(part in ('.', '..') or ':' in part for part in parts):
|
|
continue
|
|
target = config.parent.joinpath(*parts)
|
|
try:
|
|
inside = target.resolve().is_relative_to(config.parent.resolve())
|
|
except OSError:
|
|
inside = False
|
|
if inside and target.is_file() and target.suffix.lower() in ('.msi', '.exe'):
|
|
actions.append((name, target, windows_arguments(node.get('Arguments', ''))))
|
|
return actions
|
|
|
|
|
|
def run_install_actions(proton, prefix, exe, env):
|
|
config = game_config(exe)
|
|
if config is None:
|
|
return
|
|
done = prefix / 'drive_c' / 'ProgramData' / 'DroidDeck' / 'install-actions'
|
|
for name, target, arguments in install_actions(config):
|
|
try:
|
|
content = hashlib.sha256()
|
|
with target.open('rb') as source:
|
|
for block in iter(lambda: source.read(1 << 20), b''):
|
|
content.update(block)
|
|
identity = hashlib.sha256(name.encode('utf-8') + b'\0' + content.digest()).hexdigest()[:24]
|
|
marker = done / ('%s-%s' % (''.join(c for c in name if c.isalnum() or c in '-_')[:64], identity))
|
|
if marker.exists():
|
|
continue
|
|
except OSError as error:
|
|
print('droiddeck-xbox: install action %s could not be read (%s); launching without it' % (name, error), file=sys.stderr)
|
|
continue
|
|
windows = 'Z:' + str(target).replace('/', '\\')
|
|
if target.suffix.lower() == '.msi':
|
|
command = [proton, 'run', 'msiexec', '/i', windows, *arguments]
|
|
else:
|
|
command = [proton, 'run', windows, *arguments]
|
|
try:
|
|
code = subprocess.run(command, stdout=sys.stderr, env=env, timeout=600).returncode
|
|
except (OSError, subprocess.TimeoutExpired):
|
|
code = None
|
|
if code != 0:
|
|
print('droiddeck-xbox: install action %s did not finish; launching without it' % name, file=sys.stderr)
|
|
continue
|
|
try:
|
|
done.mkdir(parents=True, exist_ok=True)
|
|
marker.touch()
|
|
except OSError as error:
|
|
print('droiddeck-xbox: install action %s finished but could not be recorded (%s)' % (name, error), file=sys.stderr)
|
|
|
|
|
|
def view_drive(prefix, exe):
|
|
path = Path(exe)
|
|
view = next((parent for parent in path.parents if parent.name.startswith('droiddeck-xbox-')), None)
|
|
if not path.is_absolute() or view is None:
|
|
return exe, None
|
|
devices = prefix / 'dosdevices'
|
|
for letter in VIEW_DRIVES:
|
|
link = devices / (letter + ':')
|
|
staged = devices / ('.%s-%s' % (letter, secrets.token_hex(4)))
|
|
try:
|
|
if os.path.lexists(link) and (os.path.exists(link) or not os.readlink(link).startswith(str(view.parent.parent) + '/')):
|
|
continue
|
|
devices.mkdir(parents=True, exist_ok=True)
|
|
staged.symlink_to(view.parent)
|
|
os.replace(staged, link)
|
|
except OSError:
|
|
if os.path.lexists(staged):
|
|
staged.unlink()
|
|
continue
|
|
return letter.upper() + ':\\' + str(path.relative_to(view.parent)).replace('/', '\\'), link
|
|
return exe, None
|
|
|
|
|
|
def wine(argv, source_env=None):
|
|
source_env = os.environ if source_env is None else source_env
|
|
with open(source_env['DROIDDECK_XBOX_COMMAND_FILE'], encoding='utf-8') as file:
|
|
command = json.load(file)
|
|
if len(command) < 3 or command[1] != 'waitforexitandrun' or len(argv) != 1:
|
|
raise ValueError('Invalid Xbox Proton invocation')
|
|
env = dict(source_env)
|
|
for name in ('DROIDDECK_XBOX_CREDENTIAL_SOCKET', 'DROIDDECK_XBOX_CREDENTIAL_PORT', 'DROIDDECK_XBOX_CREDENTIAL_KEY'):
|
|
env.pop(name, None)
|
|
env.pop('DROIDDECK_XBOX_COMMAND_FILE', None)
|
|
prefix = Path(source_env['STEAM_COMPAT_DATA_PATH']) / 'pfx'
|
|
prefix.parent.mkdir(parents=True, exist_ok=True)
|
|
if not (prefix / 'system.reg').is_file():
|
|
result = subprocess.run([command[0], 'run', 'cmd', '/c', 'exit', '0'], stdout=sys.stderr, env=env)
|
|
if result.returncode:
|
|
return result.returncode
|
|
system = prefix / 'drive_c/windows/system32'
|
|
system.mkdir(parents=True, exist_ok=True)
|
|
for name in DLLS:
|
|
target = system / name
|
|
if target.is_symlink():
|
|
target.unlink()
|
|
shutil.copyfile(RUNTIME / 'windows' / name, target)
|
|
register_classes(command[0], prefix, env)
|
|
run_install_actions(command[0], prefix, argv[0], env)
|
|
overrides = ';'.join(name[:-4] + '=n' for name in DLLS if name != 'libnghttp2.dll')
|
|
env['WINEDLLOVERRIDES'] = overrides + ';' + env.get('WINEDLLOVERRIDES', '')
|
|
exe, drive = view_drive(prefix, argv[0])
|
|
try:
|
|
return subprocess.call([*command[:2], exe, *command[3:]], env=env)
|
|
finally:
|
|
if drive is not None:
|
|
try:
|
|
drive.unlink()
|
|
except OSError:
|
|
pass
|
|
|
|
|
|
# PlayFab Game Saves picks its provider from the Gaming Runtime unless HKLM\SOFTWARE\Microsoft\GamingServices
|
|
# ForceUseInprocGameSaves is set, and its in-process provider needs a save folder the title never passes on Windows.
|
|
# The runtime has no GRTS saves, so titles such as Forza Horizon 6 stop with E:0-17. xodus-nexus ships a proxy
|
|
# (scripts/runtime-compat/playfab-save-folder.c, MIT) that keeps the title's own SDK as nexus_pgs_native.dll and
|
|
# supplies both; this stages it the same way.
|
|
PGS_PROXY = RUNTIME / 'compat' / 'PlayFabGameSave.dll'
|
|
PGS_NATIVE = 'nexus_pgs_native.dll'
|
|
PGS_EXPORTS = (
|
|
'PFGameSaveFilesAddUserWithUiAsync', 'PFGameSaveFilesAddUserWithUiResult', 'PFGameSaveFilesGetFolder',
|
|
'PFGameSaveFilesGetFolderSize', 'PFGameSaveFilesGetRemainingQuota', 'PFGameSaveFilesGetSaveDescriptionForDebug',
|
|
'PFGameSaveFilesGetSaveDescriptionSizeForDebug', 'PFGameSaveFilesGetStatsJsonForDebug',
|
|
'PFGameSaveFilesGetStatsJsonSizeForDebug', 'PFGameSaveFilesInitialize', 'PFGameSaveFilesIsConnectedToCloud',
|
|
'PFGameSaveFilesPauseUploadForDebug', 'PFGameSaveFilesResetCloudAsync', 'PFGameSaveFilesResetCloudResult',
|
|
'PFGameSaveFilesResumeUploadForDebug', 'PFGameSaveFilesSetActiveDeviceChangedCallback',
|
|
'PFGameSaveFilesSetActiveDevicePollForceChangeForDebug', 'PFGameSaveFilesSetActiveDevicePollIntervalForDebug',
|
|
'PFGameSaveFilesSetForceNullPendingManifestForDebug', 'PFGameSaveFilesSetForceOutOfStorageErrorForDebug',
|
|
'PFGameSaveFilesSetForceSyncFailedErrorForDebug', 'PFGameSaveFilesSetMockDataFolderForDebug',
|
|
'PFGameSaveFilesSetMockDeviceIdForDebug', 'PFGameSaveFilesSetMockForceOfflineForDebug',
|
|
'PFGameSaveFilesSetMockManifestOffsetForDebug', 'PFGameSaveFilesSetMockRootFolderForDebug',
|
|
'PFGameSaveFilesSetSaveDescriptionAsync', 'PFGameSaveFilesSetSaveDescriptionResult',
|
|
'PFGameSaveFilesSetUiActiveDeviceContentionResponse', 'PFGameSaveFilesSetUiCallbacks',
|
|
'PFGameSaveFilesSetUiConflictResponse', 'PFGameSaveFilesSetUiOutOfStorageResponse',
|
|
'PFGameSaveFilesSetUiProgressResponse', 'PFGameSaveFilesSetUiSyncFailedResponse',
|
|
'PFGameSaveFilesSetWriteManifestsToDiskForDebug', 'PFGameSaveFilesUiProgressGetProgress',
|
|
'PFGameSaveFilesUninitializeAsync', 'PFGameSaveFilesUninitializeResult', 'PFGameSaveFilesUploadWithUiAsync',
|
|
'PFGameSaveFilesUploadWithUiResult',
|
|
)
|
|
|
|
|
|
def pe_exports(data):
|
|
"""(export address table size, [(name, ordinal index, forwarder or None) for each named export]) of an x64
|
|
PE image, or None. The table size also counts exports that have no name."""
|
|
def u16(offset):
|
|
return int.from_bytes(data[offset:offset + 2], 'little')
|
|
|
|
def u32(offset):
|
|
return int.from_bytes(data[offset:offset + 4], 'little')
|
|
|
|
def string(offset):
|
|
end = data.find(b'\0', offset)
|
|
return None if offset is None or end < 0 else data[offset:end].decode('ascii', 'replace')
|
|
|
|
if len(data) < 256 or data[:2] != b'MZ':
|
|
return None
|
|
pe = u32(60)
|
|
if data[pe:pe + 4] != b'PE\0\0' or u16(pe + 4) != 0x8664:
|
|
return None
|
|
count, optional_size = u16(pe + 6), u16(pe + 20)
|
|
optional = pe + 24
|
|
if optional_size < 120 or u16(optional) != 0x20B or u32(optional + 108) < 1:
|
|
return None
|
|
sections = optional + optional_size
|
|
|
|
def offset_of(address):
|
|
for index in range(count):
|
|
section = sections + index * 40
|
|
start, size, raw = u32(section + 12), u32(section + 16), u32(section + 20)
|
|
if start <= address < start + size and raw + address - start < len(data):
|
|
return raw + address - start
|
|
return None
|
|
|
|
directory_rva, directory_size = u32(optional + 112), u32(optional + 116)
|
|
directory = offset_of(directory_rva)
|
|
if directory is None or u32(directory + 16) != 1:
|
|
return None
|
|
functions, names = u32(directory + 20), u32(directory + 24)
|
|
function_table, name_table, ordinal_table = (offset_of(u32(directory + 28)), offset_of(u32(directory + 32)),
|
|
offset_of(u32(directory + 36)))
|
|
if None in (function_table, name_table, ordinal_table):
|
|
return None
|
|
exports = []
|
|
for index in range(names):
|
|
name = string(offset_of(u32(name_table + 4 * index)))
|
|
ordinal = u16(ordinal_table + 2 * index)
|
|
address = u32(function_table + 4 * ordinal) if ordinal < functions else 0
|
|
if name is None or not address:
|
|
return None
|
|
forward = string(offset_of(address)) if directory_rva <= address < directory_rva + directory_size else None
|
|
exports.append((name, ordinal, forward))
|
|
return functions, exports
|
|
|
|
|
|
def playfab_sdk(data):
|
|
"""The PlayFab Game Saves SDK the proxy was written for: exactly its 40 exports, all named, none forwarded."""
|
|
parsed = pe_exports(data)
|
|
if parsed is None or parsed[0] != len(PGS_EXPORTS):
|
|
return False
|
|
exports = parsed[1]
|
|
return ([(name, ordinal) for name, ordinal, _ in exports] == list(zip(PGS_EXPORTS, range(len(PGS_EXPORTS))))
|
|
and all(forward is None for _, _, forward in exports))
|
|
|
|
|
|
def playfab_proxy(data):
|
|
"""A save-folder proxy (this one or an earlier build): the same 40 exports, forwarding into nexus_pgs_native."""
|
|
parsed = pe_exports(data)
|
|
if parsed is None or parsed[0] != len(PGS_EXPORTS):
|
|
return False
|
|
exports = parsed[1]
|
|
return ([name for name, _, _ in exports] == list(PGS_EXPORTS)
|
|
and any((forward or '').startswith(PGS_NATIVE[:-4] + '.') for _, _, forward in exports))
|
|
|
|
|
|
def kept_sdk(native):
|
|
"""True when nexus_pgs_native.dll is a regular file holding a recognised SDK."""
|
|
return not native.is_symlink() and native.is_file() and playfab_sdk(native.read_bytes())
|
|
|
|
|
|
def replace_file(directory, name, data):
|
|
descriptor, temporary = tempfile.mkstemp(prefix='.droiddeck-pgs-', dir=directory)
|
|
try:
|
|
with os.fdopen(descriptor, 'wb') as file:
|
|
file.write(data)
|
|
file.flush()
|
|
os.fsync(file.fileno())
|
|
os.chmod(temporary, 0o644)
|
|
os.replace(temporary, Path(directory) / name)
|
|
except BaseException:
|
|
try:
|
|
os.unlink(temporary)
|
|
except OSError:
|
|
pass
|
|
raise
|
|
|
|
|
|
def stage_playfab_proxy(folder):
|
|
"""Put the save-folder proxy in front of every PlayFab Game Saves SDK in the game folder. Returns how many."""
|
|
try:
|
|
proxy = PGS_PROXY.read_bytes()
|
|
except OSError:
|
|
return 0
|
|
staged = 0
|
|
for root, _, files in os.walk(folder):
|
|
directory = Path(root)
|
|
for name in files:
|
|
if name.lower() != 'playfabgamesave.dll':
|
|
continue
|
|
path = directory / name
|
|
native = directory / PGS_NATIVE
|
|
try:
|
|
if path.is_symlink():
|
|
continue
|
|
data = path.read_bytes()
|
|
if playfab_sdk(data):
|
|
# A first launch, or a game update that brought a new SDK: the update's copy becomes the native one,
|
|
# but only in place of nothing or of an earlier SDK copy, never over an unknown file or a link.
|
|
if os.path.lexists(native) and not kept_sdk(native):
|
|
print('droiddeck-xbox: unknown %s next to the PlayFab Game Saves SDK in %s; left unchanged'
|
|
% (PGS_NATIVE, directory), file=sys.stderr)
|
|
continue
|
|
replace_file(directory, PGS_NATIVE, data)
|
|
elif not playfab_proxy(data):
|
|
print('droiddeck-xbox: PlayFab Game Saves SDK with unknown exports in %s; left unchanged' % directory,
|
|
file=sys.stderr)
|
|
continue
|
|
elif not kept_sdk(native):
|
|
print('droiddeck-xbox: PlayFab save proxy without its SDK in %s; left unchanged' % directory,
|
|
file=sys.stderr)
|
|
continue
|
|
if data != proxy:
|
|
replace_file(directory, name, proxy)
|
|
staged += 1
|
|
except OSError as error:
|
|
print('droiddeck-xbox: PlayFab save proxy not staged in %s (%s)' % (directory, error), file=sys.stderr)
|
|
return staged
|
|
|
|
|
|
def renew_lease(ask, channel, product, lease, stopped):
|
|
while not stopped.wait(15):
|
|
response = ask(channel, {'op': 'xbox-renew', 'id': product, 'lease': lease}, timeout=10)
|
|
if response is not None and response.get('ok') is False:
|
|
return
|
|
|
|
|
|
def launch(command, env):
|
|
if len(command) < 3 or command[1] != 'waitforexitandrun' or env.get('DROIDDECK_XBOX_ACTIVE') == '1':
|
|
return None
|
|
try:
|
|
store = runpy.run_path(str(BIN / 'droiddeck-store-launch'))
|
|
except Exception as error:
|
|
print('droiddeck-xbox: store detection unavailable (%s); stock launch' % error, file=sys.stderr)
|
|
return None
|
|
found = store['find_store_game'](command[2:])
|
|
if found is None or found[1].get('store') != 'xbox':
|
|
return None
|
|
folder, sidecar = found
|
|
for name in DLLS:
|
|
if not (RUNTIME / 'windows' / name).is_file():
|
|
raise RuntimeError('Xbox Windows runtime is missing; update the Linux runtime')
|
|
launch_dir = env.get('DD_LAUNCH_DIR')
|
|
if not launch_dir:
|
|
raise RuntimeError('No Xbox account channel; start the game from DroidDeck')
|
|
reply = store['ask'](Path(launch_dir) / 'stores', {'op': 'xbox-prepare', 'id': sidecar['id']}, timeout=190)
|
|
if not reply or not reply.get('ok'):
|
|
raise RuntimeError((reply or {}).get('reason') or 'Xbox account service is unavailable; sign in again and retry')
|
|
stopped = threading.Event()
|
|
close = lambda: None
|
|
try:
|
|
port, key, close = bridge(reply['socket'])
|
|
|
|
threading.Thread(target=renew_lease, args=(store['ask'], Path(launch_dir) / 'stores',
|
|
sidecar['id'], reply['lease'], stopped), daemon=True).start()
|
|
with tempfile.TemporaryDirectory(prefix='droiddeck-xbox-') as temporary:
|
|
context = Path(temporary) / 'command.json'
|
|
context.write_text(json.dumps(command), encoding='utf-8')
|
|
context.chmod(0o600)
|
|
owned_env = dict(env, DROIDDECK_XBOX_ACTIVE='1', DROIDDECK_XBOX_COMMAND_FILE=str(context),
|
|
XODUS_SOCKET=reply['socket'], XODUS_BRIDGE_PORT=str(port), XODUS_BRIDGE_KEY=key,
|
|
XODUS_LOG='off', RUST_LOG='off', XODUS_SAVE_SYNC='auto' if sidecar.get('cloud', True) else 'none')
|
|
for name in ('DROIDDECK_XBOX_CREDENTIAL_SOCKET', 'DROIDDECK_XBOX_CREDENTIAL_PORT', 'DROIDDECK_XBOX_CREDENTIAL_KEY'):
|
|
owned_env.pop(name, None)
|
|
if reply.get('playfab'):
|
|
owned_env['XODUS_XSTS_PLAYFAB'] = reply['playfab']
|
|
# The runtime mounts DLC only inside this backend-owned workspace (E_NOTIMPL without it).
|
|
mount_root = reply.get('mountRoot')
|
|
if isinstance(mount_root, str) and mount_root.startswith('/'):
|
|
owned_env['XODUS_MOUNT_ROOT'] = 'Z:' + mount_root.replace('/', '\\')
|
|
content = folder / '.xbox-content'
|
|
roots = []
|
|
if content.is_dir():
|
|
for entry in content.iterdir():
|
|
try:
|
|
marker = json.loads((entry / '.droiddeck-content.json').read_text())
|
|
if marker.get('parent') == sidecar['id'] and marker.get('productId') == entry.name and not entry.is_symlink():
|
|
roots.append('Z:' + str(entry).replace('/', '\\'))
|
|
except (OSError, ValueError, TypeError):
|
|
pass
|
|
if roots:
|
|
owned_env['XODUS_CONTENT_ROOTS'] = ';'.join(roots)
|
|
# No DLL override for the proxy or the kept SDK: Wine has no builtin of either, so both load from the
|
|
# game folder as they are. Forcing them native-only (as Nexus does) made Forza Horizon 6 fail with E:0-0-4.
|
|
try:
|
|
stage_playfab_proxy(folder)
|
|
except Exception as error:
|
|
print('droiddeck-xbox: PlayFab save proxy skipped (%s)' % error, file=sys.stderr)
|
|
return wine([reply['exe']], owned_env)
|
|
finally:
|
|
stopped.set()
|
|
close()
|
|
store['ask'](Path(launch_dir) / 'stores', {'op': 'xbox-released', 'lease': reply['lease']})
|
|
|
|
|
|
if __name__ == '__main__':
|
|
try:
|
|
sys.exit(wine(sys.argv[1:]))
|
|
except (OSError, ValueError, KeyError, RuntimeError):
|
|
print('droiddeck-xbox: Xbox launch failed; check your account, runtime and package.', file=sys.stderr)
|
|
sys.exit(1)
|