2018-10-05 18:51:21 +03:00
|
|
|
#!/usr/bin/env python3
|
2018-01-18 23:00:48 +03:00
|
|
|
|
|
|
|
#script to launch Wine with the correct environment
|
|
|
|
|
2019-06-27 22:49:29 +03:00
|
|
|
import fcntl
|
|
|
|
import array
|
2018-01-19 20:03:54 +03:00
|
|
|
import filecmp
|
2020-07-17 06:55:44 +03:00
|
|
|
import fnmatch
|
2018-01-18 23:00:48 +03:00
|
|
|
import json
|
|
|
|
import os
|
|
|
|
import shutil
|
2019-02-01 02:02:36 +03:00
|
|
|
import errno
|
2021-09-07 23:35:18 +03:00
|
|
|
import platform
|
2020-09-15 19:37:32 +03:00
|
|
|
import stat
|
2018-01-18 23:00:48 +03:00
|
|
|
import subprocess
|
|
|
|
import sys
|
2018-01-19 20:03:54 +03:00
|
|
|
import tarfile
|
2021-11-19 23:23:45 +03:00
|
|
|
import shlex
|
2018-01-18 23:00:48 +03:00
|
|
|
|
2021-05-11 07:53:15 +03:00
|
|
|
from ctypes import CDLL
|
2021-09-07 23:35:18 +03:00
|
|
|
from ctypes import CFUNCTYPE
|
2021-05-11 07:53:15 +03:00
|
|
|
from ctypes import POINTER
|
|
|
|
from ctypes import Structure
|
|
|
|
from ctypes import addressof
|
|
|
|
from ctypes import cast
|
2021-09-07 23:35:18 +03:00
|
|
|
from ctypes import get_errno
|
|
|
|
from ctypes import sizeof
|
2021-05-11 07:53:15 +03:00
|
|
|
from ctypes import c_int
|
2021-09-07 23:35:18 +03:00
|
|
|
from ctypes import c_int64
|
|
|
|
from ctypes import c_uint
|
|
|
|
from ctypes import c_long
|
2021-05-11 07:53:15 +03:00
|
|
|
from ctypes import c_char_p
|
|
|
|
from ctypes import c_void_p
|
2021-09-07 23:35:18 +03:00
|
|
|
from ctypes import c_size_t
|
|
|
|
from ctypes import c_ssize_t
|
2021-05-11 07:53:15 +03:00
|
|
|
|
2018-10-24 22:22:22 +03:00
|
|
|
from filelock import FileLock
|
2021-05-22 01:10:23 +03:00
|
|
|
from random import randrange
|
2018-03-16 18:08:29 +03:00
|
|
|
|
2018-06-21 17:09:10 +03:00
|
|
|
#To enable debug logging, copy "user_settings.sample.py" to "user_settings.py"
|
|
|
|
#and edit it if needed.
|
2018-03-16 19:02:04 +03:00
|
|
|
|
2023-06-06 11:51:38 +03:00
|
|
|
CURRENT_PREFIX_VERSION="8.0-103"
|
2018-02-15 21:53:47 +03:00
|
|
|
|
2018-01-18 23:00:48 +03:00
|
|
|
PFX="Proton: "
|
2018-10-11 16:50:23 +03:00
|
|
|
ld_path_var = "LD_LIBRARY_PATH"
|
2018-03-06 21:13:24 +03:00
|
|
|
|
2022-02-09 18:10:04 +03:00
|
|
|
def file_exists(s, *, follow_symlinks):
|
|
|
|
if follow_symlinks:
|
|
|
|
#'exists' returns False on broken symlinks
|
|
|
|
return os.path.exists(s)
|
|
|
|
#'lexists' returns True on broken symlinks
|
|
|
|
return os.path.lexists(s)
|
|
|
|
|
2019-02-05 17:08:13 +03:00
|
|
|
def nonzero(s):
|
|
|
|
return len(s) > 0 and s != "0"
|
|
|
|
|
2020-12-03 19:46:39 +03:00
|
|
|
def prepend_to_env_str(env, variable, prepend_str, separator):
|
|
|
|
if not variable in env:
|
|
|
|
env[variable] = prepend_str
|
|
|
|
else:
|
|
|
|
env[variable] = prepend_str + separator + env[variable]
|
|
|
|
|
|
|
|
def append_to_env_str(env, variable, append_str, separator):
|
|
|
|
if not variable in env:
|
|
|
|
env[variable] = append_str
|
|
|
|
else:
|
|
|
|
env[variable] = env[variable] + separator + append_str
|
|
|
|
|
2018-01-18 23:00:48 +03:00
|
|
|
def log(msg):
|
proton: Don't crash if sys.stderr is not usable
If a Steam user runs Steam from a terminal, puts it in the background
and then exits from that terminal, or if they restart their desktop
session from a terminal (as in ValveSoftware/Proton#6277) and then exit
from that terminal, then we can inherit a stdout and/or stderr file
descriptor pointing to an invalid file descriptor. Writing to such a
file descriptor fails with EIO. Similarly, we could get write errors
as a result of OS state, such as ENOSPC if we are writing to a disk
that is full, or EPIPE if a stream to a logging framework such as the
systemd journal has been shut down.
In sufficiently pathological situations, the file descriptor could even
become invalid while the `proton` script is running, so even checking
for validity on startup would not be enough to prevent this.
The ability to log to stderr is important but not functionally critical,
and it's not like there is anything we can usefully do about a write
failure here (or even anywhere we can usefully put a warning message),
so just ignore write errors. This is similar to the behaviour of the
`logging` framework in the Python standard library (which writes to
`stderr` if a user-defined handler fails, but takes no other action)
and also similar to the approach taken to solve
ValveSoftware/steam-for-linux#8069.
Signed-off-by: Simon McVittie <smcv@collabora.com>
Link: https://github.com/ValveSoftware/Proton/pull/6341
2022-11-25 17:23:15 +03:00
|
|
|
try:
|
|
|
|
sys.stderr.write(PFX + msg + os.linesep)
|
|
|
|
sys.stderr.flush()
|
|
|
|
except OSError:
|
|
|
|
# e.g. see https://github.com/ValveSoftware/Proton/issues/6277
|
|
|
|
# There's not much we can usefully do about this: printing a
|
|
|
|
# warning to stderr isn't going to work any better the second time
|
|
|
|
pass
|
2018-02-15 21:53:47 +03:00
|
|
|
|
2020-07-10 22:41:06 +03:00
|
|
|
def file_is_wine_builtin_dll(path):
|
|
|
|
if os.path.islink(path):
|
|
|
|
contents = os.readlink(path)
|
2022-02-08 17:45:52 +03:00
|
|
|
if os.path.dirname(contents).endswith((
|
|
|
|
'/lib/wine',
|
|
|
|
'/lib64/wine',
|
|
|
|
'/lib/wine/fakedlls',
|
|
|
|
'/lib64/wine/fakedlls',
|
|
|
|
'/lib/wine/i386-unix',
|
|
|
|
'/lib/wine/i386-windows',
|
|
|
|
'/lib64/wine/x86_64-unix',
|
|
|
|
'/lib64/wine/x86_64-windows'
|
|
|
|
)):
|
2020-07-10 22:41:06 +03:00
|
|
|
# This may be a broken link to a dll in a removed Proton install
|
|
|
|
return True
|
2022-02-09 18:10:04 +03:00
|
|
|
if not file_exists(path, follow_symlinks=True):
|
2019-04-08 22:27:31 +03:00
|
|
|
return False
|
|
|
|
try:
|
|
|
|
sfile = open(path, "rb")
|
|
|
|
sfile.seek(0x40)
|
|
|
|
tag = sfile.read(20)
|
2020-07-10 22:41:06 +03:00
|
|
|
return tag.startswith((b"Wine placeholder DLL", b"Wine builtin DLL"))
|
2019-04-08 22:27:31 +03:00
|
|
|
except IOError:
|
|
|
|
return False
|
|
|
|
|
2018-01-23 17:03:43 +03:00
|
|
|
def makedirs(path):
|
|
|
|
try:
|
2022-02-09 20:11:11 +03:00
|
|
|
#replace broken symlinks with a new directory
|
|
|
|
if os.path.islink(path) and not file_exists(path, follow_symlinks=True):
|
|
|
|
os.remove(path)
|
2018-01-23 17:03:43 +03:00
|
|
|
os.makedirs(path)
|
2018-10-11 16:50:23 +03:00
|
|
|
except OSError:
|
2018-01-23 17:03:43 +03:00
|
|
|
#already exists
|
|
|
|
pass
|
|
|
|
|
2021-05-27 19:23:08 +03:00
|
|
|
def merge_user_dir(src, dst):
|
|
|
|
extant_dirs = []
|
|
|
|
for src_dir, dirs, files in os.walk(src):
|
|
|
|
dst_dir = src_dir.replace(src, dst, 1)
|
|
|
|
|
|
|
|
#as described below, avoid merging game save subdirs, too
|
|
|
|
child_of_extant_dir = False
|
|
|
|
for dir_ in extant_dirs:
|
|
|
|
if dir_ in dst_dir:
|
|
|
|
child_of_extant_dir = True
|
|
|
|
break
|
|
|
|
if child_of_extant_dir:
|
|
|
|
continue
|
|
|
|
|
|
|
|
#we only want to copy into directories which don't already exist. games
|
|
|
|
#may not react well to two save directory instances being merged.
|
2022-02-09 18:10:04 +03:00
|
|
|
if not file_exists(dst_dir, follow_symlinks=True) or os.path.samefile(dst_dir, dst):
|
2021-05-27 19:23:08 +03:00
|
|
|
makedirs(dst_dir)
|
|
|
|
for dir_ in dirs:
|
|
|
|
src_file = os.path.join(src_dir, dir_)
|
|
|
|
dst_file = os.path.join(dst_dir, dir_)
|
2022-02-09 18:10:04 +03:00
|
|
|
if os.path.islink(src_file) and not file_exists(dst_file, follow_symlinks=True):
|
2021-08-25 19:22:12 +03:00
|
|
|
try_copy(src_file, dst_file, copy_metadata=True, follow_symlinks=False)
|
2021-05-27 19:23:08 +03:00
|
|
|
for file_ in files:
|
|
|
|
src_file = os.path.join(src_dir, file_)
|
|
|
|
dst_file = os.path.join(dst_dir, file_)
|
2022-02-09 18:10:04 +03:00
|
|
|
if not file_exists(dst_file, follow_symlinks=True):
|
2021-08-25 19:22:12 +03:00
|
|
|
try_copy(src_file, dst_file, copy_metadata=True, follow_symlinks=False)
|
2021-05-27 19:23:08 +03:00
|
|
|
else:
|
|
|
|
extant_dirs += dst_dir
|
|
|
|
|
2021-12-16 13:49:30 +03:00
|
|
|
def try_copy(src, dst, prefix=None, add_write_perm=True, copy_metadata=False, optional=False,
|
2021-12-16 14:03:53 +03:00
|
|
|
follow_symlinks=True, track_file=False, link_debug=False):
|
2019-02-01 02:02:36 +03:00
|
|
|
try:
|
2021-12-16 13:49:30 +03:00
|
|
|
if prefix is not None:
|
|
|
|
dst = os.path.join(prefix, dst)
|
|
|
|
|
2019-07-11 23:09:20 +03:00
|
|
|
if os.path.isdir(dst):
|
2021-12-16 13:34:07 +03:00
|
|
|
dst = os.path.join(dst, os.path.basename(src))
|
|
|
|
|
2022-02-09 18:10:04 +03:00
|
|
|
if file_exists(dst, follow_symlinks=False):
|
2021-12-16 13:34:07 +03:00
|
|
|
os.remove(dst)
|
2021-12-16 13:58:22 +03:00
|
|
|
elif track_file and prefix is not None:
|
|
|
|
track_file.write(os.path.relpath(dst, prefix) + '\n')
|
2020-09-15 19:37:32 +03:00
|
|
|
|
2021-09-07 23:35:18 +03:00
|
|
|
if os.path.islink(src) and not follow_symlinks:
|
|
|
|
shutil.copyfile(src, dst, follow_symlinks=False)
|
|
|
|
else:
|
|
|
|
copyfile(src, dst)
|
|
|
|
|
2021-05-27 19:23:08 +03:00
|
|
|
if copy_metadata:
|
2021-09-07 23:35:18 +03:00
|
|
|
shutil.copystat(src, dst, follow_symlinks=follow_symlinks)
|
2021-05-27 19:23:08 +03:00
|
|
|
else:
|
2021-09-07 23:35:18 +03:00
|
|
|
shutil.copymode(src, dst, follow_symlinks=follow_symlinks)
|
2020-09-15 19:37:32 +03:00
|
|
|
|
|
|
|
if add_write_perm:
|
2021-12-16 13:34:07 +03:00
|
|
|
new_mode = os.lstat(dst).st_mode | stat.S_IWUSR | stat.S_IWGRP
|
|
|
|
os.chmod(dst, new_mode)
|
2020-09-15 19:37:32 +03:00
|
|
|
|
2022-02-09 18:10:04 +03:00
|
|
|
if not file_exists(src + '.debug', follow_symlinks=True):
|
2021-12-16 14:03:53 +03:00
|
|
|
link_debug = False
|
|
|
|
|
2022-02-09 18:10:04 +03:00
|
|
|
if file_exists(dst + '.debug', follow_symlinks=False):
|
2021-12-16 14:03:53 +03:00
|
|
|
os.remove(dst + '.debug')
|
|
|
|
elif link_debug:
|
|
|
|
track_file.write(os.path.relpath(dst + '.debug', prefix) + '\n')
|
|
|
|
|
|
|
|
if link_debug:
|
|
|
|
os.symlink(src + '.debug', dst + '.debug')
|
|
|
|
|
2021-05-11 07:53:15 +03:00
|
|
|
except FileNotFoundError as e:
|
|
|
|
if optional:
|
|
|
|
log('Error while copying to \"' + dst + '\": ' + e.strerror)
|
|
|
|
else:
|
|
|
|
raise
|
|
|
|
|
2019-02-01 02:02:36 +03:00
|
|
|
except PermissionError as e:
|
|
|
|
if e.errno == errno.EPERM:
|
|
|
|
#be forgiving about permissions errors; if it's a real problem, things will explode later anyway
|
|
|
|
log('Error while copying to \"' + dst + '\": ' + e.strerror)
|
|
|
|
else:
|
|
|
|
raise
|
|
|
|
|
2021-09-07 23:35:18 +03:00
|
|
|
# copy_file_range implementation for old Python versions
|
|
|
|
__syscall__copy_file_range = None
|
|
|
|
|
|
|
|
def copy_file_range_ctypes(fd_in, fd_out, count):
|
|
|
|
"Copy data using the copy_file_range syscall through ctypes, assuming x86_64 Linux"
|
|
|
|
global __syscall__copy_file_range
|
|
|
|
__NR_copy_file_range = 326
|
|
|
|
|
|
|
|
if __syscall__copy_file_range is None:
|
|
|
|
c_int64_p = POINTER(c_int64)
|
|
|
|
prototype = CFUNCTYPE(c_ssize_t, c_long, c_int, c_int64_p,
|
|
|
|
c_int, c_int64_p, c_size_t, c_uint, use_errno=True)
|
|
|
|
__syscall__copy_file_range = prototype(('syscall', CDLL(None, use_errno=True)))
|
|
|
|
|
|
|
|
while True:
|
|
|
|
ret = __syscall__copy_file_range(__NR_copy_file_range, fd_in, None, fd_out, None, count, 0)
|
|
|
|
if ret >= 0 or get_errno() != errno.EINTR:
|
|
|
|
break
|
|
|
|
|
|
|
|
if ret < 0:
|
|
|
|
raise OSError(get_errno(), errno.errorcode.get(get_errno(), 'unknown'))
|
|
|
|
|
|
|
|
return ret
|
|
|
|
|
|
|
|
def copyfile_reflink(srcname, dstname):
|
|
|
|
"Copy srcname to dstname, making reflink if possible"
|
|
|
|
global copyfile
|
|
|
|
with open(srcname, 'rb', buffering=0) as src:
|
|
|
|
bytes_to_copy = os.fstat(src.fileno()).st_size
|
|
|
|
try:
|
|
|
|
with open(dstname, 'wb', buffering=0) as dst:
|
|
|
|
while bytes_to_copy > 0:
|
|
|
|
bytes_to_copy -= copy_file_range(src.fileno(), dst.fileno(), bytes_to_copy)
|
|
|
|
except OSError as e:
|
|
|
|
if e.errno not in (errno.EXDEV, errno.ENOSYS, errno.EINVAL):
|
|
|
|
raise e
|
|
|
|
if e.errno == errno.ENOSYS:
|
|
|
|
copyfile = shutil.copyfile
|
|
|
|
shutil.copyfile(srcname, dstname)
|
|
|
|
|
|
|
|
if hasattr(os, 'copy_file_range'):
|
|
|
|
copyfile = copyfile_reflink
|
|
|
|
copy_file_range = os.copy_file_range
|
|
|
|
elif sys.platform == 'linux' and platform.machine() == 'x86_64' and sizeof(c_void_p) == 8:
|
|
|
|
copyfile = copyfile_reflink
|
|
|
|
copy_file_range = copy_file_range_ctypes
|
|
|
|
else:
|
|
|
|
copyfile = shutil.copyfile
|
|
|
|
|
2020-07-28 20:30:14 +03:00
|
|
|
def try_copyfile(src, dst):
|
|
|
|
try:
|
|
|
|
if os.path.isdir(dst):
|
2021-09-07 23:35:18 +03:00
|
|
|
dst = dst + "/" + os.path.basename(src)
|
|
|
|
if file_exists(dst, follow_symlinks=False):
|
2020-07-28 20:30:14 +03:00
|
|
|
os.remove(dst)
|
2021-09-07 23:35:18 +03:00
|
|
|
copyfile(src, dst)
|
2020-07-28 20:30:14 +03:00
|
|
|
except PermissionError as e:
|
|
|
|
if e.errno == errno.EPERM:
|
|
|
|
#be forgiving about permissions errors; if it's a real problem, things will explode later anyway
|
|
|
|
log('Error while copying to \"' + dst + '\": ' + e.strerror)
|
|
|
|
else:
|
|
|
|
raise
|
|
|
|
|
2020-07-17 06:38:24 +03:00
|
|
|
def getmtimestr(*path_fragments):
|
|
|
|
path = os.path.join(*path_fragments)
|
|
|
|
try:
|
|
|
|
return str(os.path.getmtime(path))
|
|
|
|
except IOError:
|
|
|
|
return "0"
|
|
|
|
|
2020-12-03 22:36:48 +03:00
|
|
|
def try_get_game_library_dir():
|
|
|
|
if not "STEAM_COMPAT_INSTALL_PATH" in g_session.env or \
|
|
|
|
not "STEAM_COMPAT_LIBRARY_PATHS" in g_session.env:
|
|
|
|
return None
|
|
|
|
|
|
|
|
#find library path which is a subset of the game path
|
|
|
|
library_paths = g_session.env["STEAM_COMPAT_LIBRARY_PATHS"].split(":")
|
|
|
|
for l in library_paths:
|
|
|
|
if l in g_session.env["STEAM_COMPAT_INSTALL_PATH"]:
|
|
|
|
return l
|
|
|
|
|
|
|
|
return None
|
|
|
|
|
2022-03-11 19:10:42 +03:00
|
|
|
def try_get_steam_dir():
|
|
|
|
if not "STEAM_COMPAT_CLIENT_INSTALL_PATH" in g_session.env:
|
|
|
|
return None
|
|
|
|
|
|
|
|
return g_session.env["STEAM_COMPAT_CLIENT_INSTALL_PATH"]
|
|
|
|
|
|
|
|
def setup_dir_drive(compat_option, drive_name, dest_dir):
|
|
|
|
drive_path = g_compatdata.prefix_dir + "dosdevices/" + drive_name
|
|
|
|
if compat_option in g_session.compat_config:
|
|
|
|
if not dest_dir:
|
|
|
|
if file_exists(drive_path, follow_symlinks=False):
|
|
|
|
os.remove(drive_path)
|
2022-01-07 00:52:13 +03:00
|
|
|
else:
|
2022-03-11 19:10:42 +03:00
|
|
|
if file_exists(drive_path, follow_symlinks=False):
|
|
|
|
cur_tgt = os.readlink(drive_path)
|
|
|
|
if cur_tgt != dest_dir:
|
|
|
|
os.remove(drive_path)
|
|
|
|
os.symlink(dest_dir, drive_path)
|
2022-01-07 00:52:13 +03:00
|
|
|
else:
|
2022-03-11 19:10:42 +03:00
|
|
|
os.symlink(dest_dir, drive_path)
|
|
|
|
elif file_exists(drive_path, follow_symlinks=False):
|
|
|
|
os.remove(drive_path)
|
|
|
|
|
|
|
|
def setup_game_dir_drive():
|
|
|
|
setup_dir_drive("gamedrive", "s:", try_get_game_library_dir())
|
|
|
|
|
|
|
|
def setup_steam_dir_drive():
|
|
|
|
setup_dir_drive("steamdrive", "t:", try_get_steam_dir())
|
2022-01-07 00:52:13 +03:00
|
|
|
|
2021-05-11 07:53:15 +03:00
|
|
|
# Function to find the installed location of DLL files for use by Wine/Proton
|
|
|
|
# from the NVIDIA Linux driver
|
|
|
|
#
|
|
|
|
# See https://gitlab.steamos.cloud/steamrt/steam-runtime-tools/-/issues/71 for
|
|
|
|
# background on the chosen method of DLL discovery.
|
|
|
|
#
|
|
|
|
# On success, returns a str() of the absolute-path to the directory at which DLL
|
|
|
|
# files are stored
|
|
|
|
#
|
|
|
|
# On failure, returns None
|
|
|
|
def find_nvidia_wine_dll_dir():
|
|
|
|
try:
|
|
|
|
libdl = CDLL("libdl.so.2")
|
|
|
|
except (OSError):
|
|
|
|
return None
|
|
|
|
|
|
|
|
try:
|
|
|
|
libglx_nvidia = CDLL("libGLX_nvidia.so.0")
|
|
|
|
except OSError:
|
|
|
|
return None
|
|
|
|
|
|
|
|
# from dlinfo(3)
|
|
|
|
#
|
|
|
|
# struct link_map {
|
|
|
|
# ElfW(Addr) l_addr; /* Difference between the
|
|
|
|
# address in the ELF file and
|
|
|
|
# the address in memory */
|
|
|
|
# char *l_name; /* Absolute pathname where
|
|
|
|
# object was found */
|
|
|
|
# ElfW(Dyn) *l_ld; /* Dynamic section of the
|
|
|
|
# shared object */
|
|
|
|
# struct link_map *l_next, *l_prev;
|
|
|
|
# /* Chain of loaded objects */
|
|
|
|
#
|
|
|
|
# /* Plus additional fields private to the
|
|
|
|
# implementation */
|
|
|
|
# };
|
|
|
|
RTLD_DI_LINKMAP = 2
|
|
|
|
class link_map(Structure):
|
|
|
|
_fields_ = [("l_addr", c_void_p), ("l_name", c_char_p), ("l_ld", c_void_p)]
|
|
|
|
|
|
|
|
# from dlinfo(3)
|
|
|
|
#
|
|
|
|
# int dlinfo (void *restrict handle, int request, void *restrict info)
|
|
|
|
dlinfo_func = libdl.dlinfo
|
|
|
|
dlinfo_func.argtypes = c_void_p, c_int, c_void_p
|
|
|
|
dlinfo_func.restype = c_int
|
|
|
|
|
|
|
|
# Allocate a link_map object
|
|
|
|
glx_nvidia_info_ptr = POINTER(link_map)()
|
|
|
|
|
|
|
|
# Run dlinfo(3) on the handle to libGLX_nvidia.so.0, storing results at the
|
|
|
|
# address represented by glx_nvidia_info_ptr
|
|
|
|
if dlinfo_func(libglx_nvidia._handle,
|
|
|
|
RTLD_DI_LINKMAP,
|
|
|
|
addressof(glx_nvidia_info_ptr)) != 0:
|
|
|
|
return None
|
|
|
|
|
|
|
|
# Grab the contents our of our pointer
|
|
|
|
glx_nvidia_info = cast(glx_nvidia_info_ptr, POINTER(link_map)).contents
|
|
|
|
|
|
|
|
# Decode the path to our library to a str()
|
|
|
|
if glx_nvidia_info.l_name is None:
|
|
|
|
return None
|
|
|
|
try:
|
|
|
|
libglx_nvidia_path = os.fsdecode(glx_nvidia_info.l_name)
|
|
|
|
except UnicodeDecodeError:
|
|
|
|
return None
|
|
|
|
|
|
|
|
# Follow any symlinks to the actual file
|
|
|
|
libglx_nvidia_realpath = os.path.realpath(libglx_nvidia_path)
|
|
|
|
|
|
|
|
# Go to the relative path ./nvidia/wine from our library
|
|
|
|
nvidia_wine_dir = os.path.join(os.path.dirname(libglx_nvidia_realpath), "nvidia", "wine")
|
|
|
|
|
|
|
|
# Check that nvngx.dll exists here, or fail
|
2022-02-09 18:10:04 +03:00
|
|
|
if file_exists(os.path.join(nvidia_wine_dir, "nvngx.dll"), follow_symlinks=True):
|
2021-05-11 07:53:15 +03:00
|
|
|
return nvidia_wine_dir
|
|
|
|
|
|
|
|
return None
|
|
|
|
|
2019-07-29 20:17:22 +03:00
|
|
|
EXT2_IOC_GETFLAGS = 0x80086601
|
|
|
|
EXT2_IOC_SETFLAGS = 0x40086602
|
|
|
|
|
|
|
|
EXT4_CASEFOLD_FL = 0x40000000
|
|
|
|
|
|
|
|
def set_dir_casefold_bit(dir_path):
|
|
|
|
dr = os.open(dir_path, 0o644)
|
|
|
|
if dr < 0:
|
|
|
|
return
|
|
|
|
try:
|
|
|
|
dat = array.array('I', [0])
|
|
|
|
if fcntl.ioctl(dr, EXT2_IOC_GETFLAGS, dat, True) >= 0:
|
|
|
|
dat[0] = dat[0] | EXT4_CASEFOLD_FL
|
|
|
|
fcntl.ioctl(dr, EXT2_IOC_SETFLAGS, dat, False)
|
2020-10-13 15:46:59 +03:00
|
|
|
except (OSError, IOError):
|
2019-07-29 20:17:22 +03:00
|
|
|
#no problem
|
|
|
|
pass
|
|
|
|
os.close(dr)
|
2018-07-20 16:26:15 +03:00
|
|
|
|
2019-07-29 18:49:26 +03:00
|
|
|
class Proton:
|
|
|
|
def __init__(self, base_dir):
|
|
|
|
self.base_dir = base_dir + "/"
|
|
|
|
self.dist_dir = self.path("dist/")
|
|
|
|
self.bin_dir = self.path("dist/bin/")
|
|
|
|
self.lib_dir = self.path("dist/lib/")
|
|
|
|
self.lib64_dir = self.path("dist/lib64/")
|
|
|
|
self.fonts_dir = self.path("dist/share/fonts/")
|
2021-04-23 14:12:03 +03:00
|
|
|
self.wine_fonts_dir = self.path("dist/share/wine/fonts/")
|
2021-12-23 21:45:16 +03:00
|
|
|
self.wine_inf = self.path("dist/share/wine/wine.inf")
|
2019-07-29 18:49:26 +03:00
|
|
|
self.version_file = self.path("version")
|
|
|
|
self.default_pfx_dir = self.path("dist/share/default_pfx/")
|
|
|
|
self.user_settings_file = self.path("user_settings.py")
|
|
|
|
self.wine_bin = self.bin_dir + "wine"
|
2021-10-05 15:49:21 +03:00
|
|
|
self.wine64_bin = self.bin_dir + "wine64"
|
2019-07-29 18:49:26 +03:00
|
|
|
self.wineserver_bin = self.bin_dir + "wineserver"
|
|
|
|
self.dist_lock = FileLock(self.path("dist.lock"), timeout=-1)
|
|
|
|
|
|
|
|
def path(self, d):
|
|
|
|
return self.base_dir + d
|
|
|
|
|
2020-05-12 12:12:38 +03:00
|
|
|
def need_tarball_extraction(self):
|
|
|
|
'''Checks if the proton_dist tarball archive must be extracted. Returns true if extraction is needed, false otherwise'''
|
2022-02-09 18:10:04 +03:00
|
|
|
return not file_exists(self.dist_dir, follow_symlinks=True) or \
|
|
|
|
not file_exists(self.path("dist/version"), follow_symlinks=True) or \
|
2020-05-12 12:12:38 +03:00
|
|
|
not filecmp.cmp(self.version_file, self.path("dist/version"))
|
|
|
|
|
2019-07-29 19:13:36 +03:00
|
|
|
def extract_tarball(self):
|
|
|
|
with self.dist_lock:
|
2020-05-12 12:12:38 +03:00
|
|
|
if self.need_tarball_extraction():
|
2022-02-09 18:10:04 +03:00
|
|
|
if file_exists(self.dist_dir, follow_symlinks=True):
|
2019-07-29 19:13:36 +03:00
|
|
|
shutil.rmtree(self.dist_dir)
|
2019-10-18 18:09:36 +03:00
|
|
|
tar = None
|
|
|
|
for sf in ["", ".xz", ".bz2", ".gz"]:
|
2022-02-09 18:10:04 +03:00
|
|
|
if file_exists(self.path("proton_dist.tar" + sf), follow_symlinks=True):
|
2019-10-18 18:09:36 +03:00
|
|
|
tar = tarfile.open(self.path("proton_dist.tar" + sf), mode="r:*")
|
|
|
|
break
|
|
|
|
if not tar:
|
|
|
|
log("No proton_dist tarball??")
|
|
|
|
sys.exit(1)
|
2019-07-29 19:13:36 +03:00
|
|
|
tar.extractall(path=self.dist_dir)
|
|
|
|
tar.close()
|
|
|
|
try_copy(self.version_file, self.dist_dir)
|
|
|
|
|
2020-05-12 12:12:38 +03:00
|
|
|
def missing_default_prefix(self):
|
|
|
|
'''Check if the default prefix dir is missing. Returns true if missing, false if present'''
|
|
|
|
return not os.path.isdir(self.default_pfx_dir)
|
|
|
|
|
2019-07-29 21:59:15 +03:00
|
|
|
def make_default_prefix(self):
|
2019-07-29 19:13:36 +03:00
|
|
|
with self.dist_lock:
|
2019-07-29 21:59:15 +03:00
|
|
|
local_env = dict(g_session.env)
|
2020-05-12 12:12:38 +03:00
|
|
|
if self.missing_default_prefix():
|
2019-07-29 19:13:36 +03:00
|
|
|
#make default prefix
|
|
|
|
local_env["WINEPREFIX"] = self.default_pfx_dir
|
2019-07-31 15:59:37 +03:00
|
|
|
local_env["WINEDEBUG"] = "-all"
|
2019-07-29 22:13:28 +03:00
|
|
|
g_session.run_proc([self.wine_bin, "wineboot"], local_env)
|
|
|
|
g_session.run_proc([self.wineserver_bin, "-w"], local_env)
|
2019-07-29 19:13:36 +03:00
|
|
|
|
2019-07-29 19:09:18 +03:00
|
|
|
class CompatData:
|
|
|
|
def __init__(self, compatdata):
|
|
|
|
self.base_dir = compatdata + "/"
|
|
|
|
self.prefix_dir = self.path("pfx/")
|
|
|
|
self.version_file = self.path("version")
|
2020-07-17 06:38:24 +03:00
|
|
|
self.config_info_file = self.path("config_info")
|
2019-07-29 19:09:18 +03:00
|
|
|
self.tracked_files_file = self.path("tracked_files")
|
|
|
|
self.prefix_lock = FileLock(self.path("pfx.lock"), timeout=-1)
|
|
|
|
|
|
|
|
def path(self, d):
|
|
|
|
return self.base_dir + d
|
|
|
|
|
2019-07-29 20:33:18 +03:00
|
|
|
def remove_tracked_files(self):
|
2022-02-09 18:10:04 +03:00
|
|
|
if not file_exists(self.tracked_files_file, follow_symlinks=True):
|
2019-07-29 20:17:22 +03:00
|
|
|
log("Prefix has no tracked_files??")
|
|
|
|
return
|
|
|
|
|
2019-07-29 20:33:18 +03:00
|
|
|
with open(self.tracked_files_file, "r") as tracked_files:
|
2019-07-29 20:17:22 +03:00
|
|
|
dirs = []
|
|
|
|
for f in tracked_files:
|
2019-07-29 20:33:18 +03:00
|
|
|
path = self.prefix_dir + f.strip()
|
2022-02-09 20:11:11 +03:00
|
|
|
if file_exists(path, follow_symlinks=False):
|
2019-07-29 20:17:22 +03:00
|
|
|
if os.path.isfile(path) or os.path.islink(path):
|
|
|
|
os.remove(path)
|
|
|
|
else:
|
|
|
|
dirs.append(path)
|
|
|
|
for d in dirs:
|
|
|
|
try:
|
|
|
|
os.rmdir(d)
|
|
|
|
except OSError:
|
|
|
|
#not empty
|
|
|
|
pass
|
|
|
|
|
2019-07-29 20:33:18 +03:00
|
|
|
os.remove(self.tracked_files_file)
|
|
|
|
os.remove(self.version_file)
|
2019-07-29 20:17:22 +03:00
|
|
|
|
|
|
|
def upgrade_pfx(self, old_ver):
|
|
|
|
if old_ver == CURRENT_PREFIX_VERSION:
|
|
|
|
return
|
|
|
|
|
2019-07-29 20:33:18 +03:00
|
|
|
log("Upgrading prefix from " + str(old_ver) + " to " + CURRENT_PREFIX_VERSION + " (" + self.base_dir + ")")
|
2019-07-29 20:17:22 +03:00
|
|
|
|
|
|
|
if old_ver is None:
|
|
|
|
return
|
|
|
|
|
|
|
|
if not '-' in old_ver:
|
|
|
|
#How can this happen??
|
|
|
|
log("Prefix has an invalid version?! You may want to back up user files and delete this prefix.")
|
|
|
|
#If it does, just let the Wine upgrade happen and hope it works...
|
|
|
|
return
|
|
|
|
|
|
|
|
try:
|
|
|
|
old_proton_ver, old_prefix_ver = old_ver.split('-')
|
|
|
|
old_proton_maj, old_proton_min = old_proton_ver.split('.')
|
|
|
|
new_proton_ver, new_prefix_ver = CURRENT_PREFIX_VERSION.split('-')
|
|
|
|
new_proton_maj, new_proton_min = new_proton_ver.split('.')
|
|
|
|
|
|
|
|
if int(new_proton_maj) < int(old_proton_maj) or \
|
|
|
|
(int(new_proton_maj) == int(old_proton_maj) and \
|
|
|
|
int(new_proton_min) < int(old_proton_min)):
|
|
|
|
log("Removing newer prefix")
|
2022-02-09 18:10:04 +03:00
|
|
|
if old_proton_ver == "3.7" and not file_exists(self.tracked_files_file, follow_symlinks=True):
|
2019-07-29 20:17:22 +03:00
|
|
|
#proton 3.7 did not generate tracked_files, so copy it into place first
|
2019-07-29 20:33:18 +03:00
|
|
|
try_copy(g_proton.path("proton_3.7_tracked_files"), self.tracked_files_file)
|
|
|
|
self.remove_tracked_files()
|
2019-07-29 20:17:22 +03:00
|
|
|
return
|
|
|
|
|
|
|
|
if old_proton_ver == "3.7" and old_prefix_ver == "1":
|
2022-02-09 18:10:04 +03:00
|
|
|
if not file_exists(self.prefix_dir + "/drive_c/windows/syswow64/kernel32.dll", follow_symlinks=True):
|
2019-07-29 20:17:22 +03:00
|
|
|
#shipped a busted 64-bit-only installation on 20180822. detect and wipe clean
|
|
|
|
log("Detected broken 64-bit-only installation, re-creating prefix.")
|
2019-07-29 20:33:18 +03:00
|
|
|
shutil.rmtree(self.prefix_dir)
|
2019-07-29 20:17:22 +03:00
|
|
|
return
|
|
|
|
|
|
|
|
#replace broken .NET installations with wine-mono support
|
2022-02-09 18:10:04 +03:00
|
|
|
if file_exists(self.prefix_dir + "/drive_c/windows/Microsoft.NET/NETFXRepair.exe", follow_symlinks=True) and \
|
2020-07-10 22:41:06 +03:00
|
|
|
file_is_wine_builtin_dll(self.prefix_dir + "/drive_c/windows/system32/mscoree.dll"):
|
2019-07-29 20:17:22 +03:00
|
|
|
log("Broken .NET installation detected, switching to wine-mono.")
|
|
|
|
#deleting this directory allows wine-mono to work
|
2019-07-29 20:33:18 +03:00
|
|
|
shutil.rmtree(self.prefix_dir + "/drive_c/windows/Microsoft.NET")
|
2019-07-29 20:17:22 +03:00
|
|
|
|
2019-08-13 22:56:07 +03:00
|
|
|
#prior to prefix version 4.11-2, all controllers were xbox controllers. wipe out the old registry entries.
|
|
|
|
if (int(old_proton_maj) < 4 or (int(old_proton_maj) == 4 and int(old_proton_min) == 11)) and \
|
|
|
|
int(old_prefix_ver) < 2:
|
|
|
|
log("Removing old xinput registry entries.")
|
|
|
|
with open(self.prefix_dir + "system.reg", "r") as reg_in:
|
|
|
|
with open(self.prefix_dir + "system.reg.new", "w") as reg_out:
|
|
|
|
for line in reg_in:
|
|
|
|
if line[0] == '[' and "CurrentControlSet" in line and "IG_" in line:
|
|
|
|
if "DeviceClasses" in line:
|
|
|
|
reg_out.write(line.replace("DeviceClasses", "DeviceClasses_old"))
|
|
|
|
elif "Enum" in line:
|
|
|
|
reg_out.write(line.replace("Enum", "Enum_old"))
|
|
|
|
else:
|
|
|
|
reg_out.write(line)
|
|
|
|
try:
|
|
|
|
os.rename(self.prefix_dir + "system.reg", self.prefix_dir + "system.reg.old")
|
|
|
|
except OSError:
|
|
|
|
os.remove(self.prefix_dir + "system.reg")
|
|
|
|
pass
|
|
|
|
|
|
|
|
try:
|
|
|
|
os.rename(self.prefix_dir + "system.reg.new", self.prefix_dir + "system.reg")
|
|
|
|
except OSError:
|
|
|
|
log("Unable to write new registry file to " + self.prefix_dir + "system.reg")
|
|
|
|
pass
|
|
|
|
|
2021-05-22 01:10:23 +03:00
|
|
|
# Prior to prefix version 6.3-3, ShellExecute* APIs used DDE.
|
|
|
|
# Wipe out old registry entries.
|
|
|
|
if int(old_proton_maj) < 6 or (int(old_proton_maj) == 6 and int(old_proton_min) < 3) or \
|
|
|
|
(int(old_proton_maj) == 6 and int(old_proton_min) == 3 and int(old_prefix_ver) < 3):
|
|
|
|
delete_keys = {
|
|
|
|
"[Software\\\\Classes\\\\htmlfile\\\\shell\\\\open\\\\ddeexec",
|
|
|
|
"[Software\\\\Classes\\\\pdffile\\\\shell\\\\open\\\\ddeexec",
|
|
|
|
"[Software\\\\Classes\\\\xmlfile\\\\shell\\\\open\\\\ddeexec",
|
|
|
|
"[Software\\\\Classes\\\\ftp\\\\shell\\\\open\\\\ddeexec",
|
|
|
|
"[Software\\\\Classes\\\\http\\\\shell\\\\open\\\\ddeexec",
|
|
|
|
"[Software\\\\Classes\\\\https\\\\shell\\\\open\\\\ddeexec",
|
|
|
|
}
|
|
|
|
dde_wb = '@="\\"C:\\\\windows\\\\system32\\\\winebrowser.exe\\" -nohome"'
|
|
|
|
|
|
|
|
sysreg_fp = self.prefix_dir + "system.reg"
|
|
|
|
new_sysreg_fp = self.prefix_dir + "system.reg.new"
|
|
|
|
|
|
|
|
log("Removing ShellExecute DDE registry entries.")
|
|
|
|
|
|
|
|
with open(sysreg_fp, "r") as reg_in:
|
|
|
|
with open(new_sysreg_fp, "w") as reg_out:
|
|
|
|
for line in reg_in:
|
|
|
|
if line[:line.find("ddeexec")+len("ddeexec")] in delete_keys:
|
|
|
|
reg_out.write(line.replace("ddeexec", "ddeexec_old", 1))
|
|
|
|
elif line.rstrip() == dde_wb:
|
|
|
|
reg_out.write(line.replace("-nohome", "%1"))
|
|
|
|
else:
|
|
|
|
reg_out.write(line)
|
|
|
|
|
|
|
|
# Slightly randomize backup file name to avoid colliding with
|
|
|
|
# other backups.
|
|
|
|
backup_sysreg_fp = "{}system.reg.{:x}.old".format(self.prefix_dir, randrange(16 ** 8))
|
|
|
|
|
|
|
|
try:
|
|
|
|
os.rename(sysreg_fp, backup_sysreg_fp)
|
|
|
|
except OSError:
|
|
|
|
log("Failed to back up old system.reg. Simply deleting it.")
|
|
|
|
os.remove(sysreg_fp)
|
|
|
|
pass
|
|
|
|
|
|
|
|
try:
|
|
|
|
os.rename(new_sysreg_fp, sysreg_fp)
|
|
|
|
except OSError:
|
|
|
|
log("Unable to write new registry file to " + sysreg_fp)
|
|
|
|
pass
|
|
|
|
|
2021-04-22 12:43:54 +03:00
|
|
|
stale_builtins = [self.prefix_dir + "/drive_c/windows/system32/amd_ags_x64.dll",
|
2023-04-28 12:19:30 +03:00
|
|
|
self.prefix_dir + "/drive_c/windows/syswow64/amd_ags_x64.dll",
|
|
|
|
self.prefix_dir + "/drive_c/windows/system32/ir50_32.dll",
|
|
|
|
self.prefix_dir + "/drive_c/windows/syswow64/ir50_32.dll" ]
|
2021-04-22 12:43:54 +03:00
|
|
|
for builtin in stale_builtins:
|
2022-02-09 18:10:04 +03:00
|
|
|
if file_exists(builtin, follow_symlinks=False) and file_is_wine_builtin_dll(builtin):
|
2021-04-22 12:43:54 +03:00
|
|
|
log("Removing stale builtin " + builtin)
|
|
|
|
os.remove(builtin)
|
|
|
|
|
2019-07-29 20:17:22 +03:00
|
|
|
except ValueError:
|
|
|
|
log("Prefix has an invalid version?! You may want to back up user files and delete this prefix.")
|
|
|
|
#Just let the Wine upgrade happen and hope it works...
|
|
|
|
return
|
|
|
|
|
2020-07-28 20:30:14 +03:00
|
|
|
def pfx_copy(self, src, dst, dll_copy=False):
|
2020-07-10 22:41:06 +03:00
|
|
|
if os.path.islink(src):
|
|
|
|
contents = os.readlink(src)
|
2021-10-01 18:24:17 +03:00
|
|
|
if os.path.dirname(contents).endswith(('/lib/wine/i386-unix', '/lib/wine/i386-windows', '/lib64/wine/x86_64-unix', '/lib64/wine/x86_64-windows')):
|
2020-07-10 22:41:06 +03:00
|
|
|
# wine builtin dll
|
|
|
|
# make the destination an absolute symlink
|
|
|
|
contents = os.path.normpath(os.path.join(os.path.dirname(src), contents))
|
2020-07-17 06:55:44 +03:00
|
|
|
if dll_copy:
|
2020-07-28 20:30:14 +03:00
|
|
|
try_copyfile(src, dst)
|
2020-07-17 06:55:44 +03:00
|
|
|
else:
|
|
|
|
os.symlink(contents, dst)
|
2020-07-10 22:41:06 +03:00
|
|
|
else:
|
2020-07-28 20:30:14 +03:00
|
|
|
try_copyfile(src, dst)
|
2020-07-10 22:41:06 +03:00
|
|
|
|
2019-07-29 20:33:18 +03:00
|
|
|
def copy_pfx(self):
|
|
|
|
with open(self.tracked_files_file, "w") as tracked_files:
|
|
|
|
for src_dir, dirs, files in os.walk(g_proton.default_pfx_dir):
|
|
|
|
rel_dir = src_dir.replace(g_proton.default_pfx_dir, "", 1).lstrip('/')
|
|
|
|
if len(rel_dir) > 0:
|
|
|
|
rel_dir = rel_dir + "/"
|
|
|
|
dst_dir = src_dir.replace(g_proton.default_pfx_dir, self.prefix_dir, 1)
|
2022-02-09 20:11:11 +03:00
|
|
|
if not file_exists(dst_dir, follow_symlinks=True):
|
|
|
|
makedirs(dst_dir)
|
2019-07-29 20:33:18 +03:00
|
|
|
tracked_files.write(rel_dir + "\n")
|
|
|
|
for dir_ in dirs:
|
|
|
|
src_file = os.path.join(src_dir, dir_)
|
|
|
|
dst_file = os.path.join(dst_dir, dir_)
|
2022-02-09 18:10:04 +03:00
|
|
|
if os.path.islink(src_file) and not file_exists(dst_file, follow_symlinks=True):
|
2020-07-28 20:30:14 +03:00
|
|
|
self.pfx_copy(src_file, dst_file)
|
2019-07-29 20:33:18 +03:00
|
|
|
for file_ in files:
|
|
|
|
src_file = os.path.join(src_dir, file_)
|
|
|
|
dst_file = os.path.join(dst_dir, file_)
|
2022-02-09 18:10:04 +03:00
|
|
|
if not file_exists(dst_file, follow_symlinks=True):
|
2020-07-28 20:30:14 +03:00
|
|
|
self.pfx_copy(src_file, dst_file)
|
2019-07-29 20:33:18 +03:00
|
|
|
tracked_files.write(rel_dir + file_ + "\n")
|
2021-12-23 21:45:16 +03:00
|
|
|
# Set .update-timestamp so Wine doesn't try to update the prefix.
|
|
|
|
# This is needed in case the mtime of wine.inf has changed in distribution.
|
|
|
|
with open(os.path.join(self.prefix_dir, '.update-timestamp'), 'w') as update_timestamp:
|
|
|
|
mtime = int(os.stat(g_proton.wine_inf).st_mtime)
|
|
|
|
update_timestamp.write(str(mtime))
|
2019-07-29 20:33:18 +03:00
|
|
|
|
2020-07-17 06:55:44 +03:00
|
|
|
def update_builtin_libs(self, dll_copy_patterns):
|
|
|
|
dll_copy_patterns = dll_copy_patterns.split(',')
|
2020-07-10 22:41:06 +03:00
|
|
|
prev_tracked_files = set()
|
|
|
|
with open(self.tracked_files_file, "r") as tracked_files:
|
|
|
|
for line in tracked_files:
|
|
|
|
prev_tracked_files.add(line.strip())
|
|
|
|
with open(self.tracked_files_file, "a") as tracked_files:
|
|
|
|
for src_dir, dirs, files in os.walk(g_proton.default_pfx_dir):
|
|
|
|
rel_dir = src_dir.replace(g_proton.default_pfx_dir, "", 1).lstrip('/')
|
|
|
|
if len(rel_dir) > 0:
|
|
|
|
rel_dir = rel_dir + "/"
|
|
|
|
dst_dir = src_dir.replace(g_proton.default_pfx_dir, self.prefix_dir, 1)
|
2022-02-09 20:11:11 +03:00
|
|
|
if not file_exists(dst_dir, follow_symlinks=True):
|
|
|
|
makedirs(dst_dir)
|
2020-07-10 22:41:06 +03:00
|
|
|
tracked_files.write(rel_dir + "\n")
|
|
|
|
for file_ in files:
|
|
|
|
src_file = os.path.join(src_dir, file_)
|
|
|
|
dst_file = os.path.join(dst_dir, file_)
|
|
|
|
if not file_is_wine_builtin_dll(src_file):
|
|
|
|
# Not a builtin library
|
|
|
|
continue
|
|
|
|
if file_is_wine_builtin_dll(dst_file):
|
|
|
|
os.unlink(dst_file)
|
2022-02-09 18:10:04 +03:00
|
|
|
elif file_exists(dst_file, follow_symlinks=False):
|
2020-07-10 22:41:06 +03:00
|
|
|
# builtin library was replaced
|
|
|
|
continue
|
|
|
|
else:
|
|
|
|
os.makedirs(dst_dir, exist_ok=True)
|
2020-07-17 06:55:44 +03:00
|
|
|
dll_copy = any(fnmatch.fnmatch(file_, pattern) for pattern in dll_copy_patterns)
|
2020-07-28 20:30:14 +03:00
|
|
|
self.pfx_copy(src_file, dst_file, dll_copy)
|
2020-07-10 22:41:06 +03:00
|
|
|
tracked_name = rel_dir + file_
|
|
|
|
if tracked_name not in prev_tracked_files:
|
|
|
|
tracked_files.write(tracked_name + "\n")
|
|
|
|
|
2023-01-24 16:55:03 +03:00
|
|
|
def create_symlink(self, lname, fname):
|
|
|
|
if file_exists(lname, follow_symlinks=False):
|
|
|
|
if os.path.islink(lname):
|
|
|
|
os.remove(lname)
|
|
|
|
os.symlink(fname, lname)
|
|
|
|
else:
|
|
|
|
os.symlink(fname, lname)
|
|
|
|
|
2019-07-29 20:33:18 +03:00
|
|
|
def create_fonts_symlinks(self):
|
2023-01-24 16:55:03 +03:00
|
|
|
ALTERNATIVES = {
|
|
|
|
('1313860', 'arial.ttf'), # FIFA 21
|
|
|
|
('1506830', 'arial.ttf'), # FIFA 22
|
|
|
|
}
|
2019-07-29 20:33:18 +03:00
|
|
|
windowsfonts = self.prefix_dir + "/drive_c/windows/Fonts"
|
2019-07-29 20:17:22 +03:00
|
|
|
makedirs(windowsfonts)
|
2023-01-24 16:55:03 +03:00
|
|
|
sgi = os.environ.get('SteamGameId', '')
|
2023-01-24 14:13:54 +03:00
|
|
|
for fonts_dir in [g_proton.fonts_dir, g_proton.wine_fonts_dir]:
|
|
|
|
for font in os.listdir(fonts_dir):
|
|
|
|
if not font.endswith('.ttf') and not font.endswith('.ttc'):
|
|
|
|
continue
|
|
|
|
lname = os.path.join(windowsfonts, font)
|
|
|
|
fname = os.path.join(fonts_dir, font)
|
2023-01-24 16:55:03 +03:00
|
|
|
if (sgi, font) in ALTERNATIVES:
|
|
|
|
fname = os.path.join(fonts_dir, 'alt', font)
|
|
|
|
self.create_symlink(lname, fname)
|
2019-07-29 20:17:22 +03:00
|
|
|
|
2021-05-27 19:23:08 +03:00
|
|
|
def migrate_user_paths(self):
|
|
|
|
#move winxp-style paths to vista+ paths. we can't do this in
|
|
|
|
#upgrade_pfx because Steam may drop cloud files here at any time.
|
|
|
|
for (old, new, link) in \
|
|
|
|
[
|
2021-08-19 18:12:07 +03:00
|
|
|
("drive_c/users/steamuser/Local Settings/Application Data",
|
2021-05-27 19:23:08 +03:00
|
|
|
self.prefix_dir + "drive_c/users/steamuser/AppData/Local",
|
|
|
|
"../AppData/Local"),
|
2021-08-19 18:12:07 +03:00
|
|
|
("drive_c/users/steamuser/Application Data",
|
2021-05-27 19:23:08 +03:00
|
|
|
self.prefix_dir + "drive_c/users/steamuser/AppData/Roaming",
|
|
|
|
"./AppData/Roaming"),
|
2021-08-19 18:12:07 +03:00
|
|
|
("drive_c/users/steamuser/My Documents",
|
2021-05-27 19:23:08 +03:00
|
|
|
self.prefix_dir + "drive_c/users/steamuser/Documents",
|
|
|
|
"./Documents"),
|
|
|
|
]:
|
2021-08-19 18:12:07 +03:00
|
|
|
|
|
|
|
#running unofficial Proton/Wine builds against a Proton prefix could
|
|
|
|
#create an infinite symlink loop. detect this and clean it up.
|
2022-02-09 18:10:04 +03:00
|
|
|
if file_exists(new, follow_symlinks=False) and os.path.islink(new) and os.readlink(new).endswith(old):
|
2021-08-19 18:12:07 +03:00
|
|
|
os.remove(new)
|
|
|
|
|
|
|
|
old = self.prefix_dir + old
|
|
|
|
|
2022-02-09 18:10:04 +03:00
|
|
|
if file_exists(old, follow_symlinks=False) and not os.path.islink(old):
|
2021-05-27 19:23:08 +03:00
|
|
|
merge_user_dir(src=old, dst=new)
|
|
|
|
os.rename(old, old + " BACKUP")
|
2022-02-09 18:10:04 +03:00
|
|
|
if not file_exists(old, follow_symlinks=False):
|
2021-05-27 19:23:08 +03:00
|
|
|
makedirs(os.path.dirname(old))
|
|
|
|
os.symlink(src=link, dst=old)
|
|
|
|
elif os.path.islink(old) and not (os.readlink(old) == link):
|
|
|
|
os.remove(old)
|
|
|
|
os.symlink(src=link, dst=old)
|
|
|
|
|
2019-07-29 21:06:51 +03:00
|
|
|
def setup_prefix(self):
|
2019-07-29 20:33:18 +03:00
|
|
|
with self.prefix_lock:
|
2022-02-09 18:10:04 +03:00
|
|
|
if file_exists(self.version_file, follow_symlinks=True):
|
2019-07-29 20:33:18 +03:00
|
|
|
with open(self.version_file, "r") as f:
|
2020-07-17 06:38:24 +03:00
|
|
|
old_ver = f.readline().strip()
|
2019-07-29 20:17:22 +03:00
|
|
|
else:
|
2020-07-17 06:38:24 +03:00
|
|
|
old_ver = None
|
|
|
|
|
|
|
|
self.upgrade_pfx(old_ver)
|
2019-07-29 20:17:22 +03:00
|
|
|
|
2022-02-09 18:10:04 +03:00
|
|
|
if not file_exists(self.prefix_dir, follow_symlinks=True):
|
2019-07-29 20:33:18 +03:00
|
|
|
makedirs(self.prefix_dir + "/drive_c")
|
|
|
|
set_dir_casefold_bit(self.prefix_dir + "/drive_c")
|
2019-07-29 20:17:22 +03:00
|
|
|
|
2022-02-09 18:10:04 +03:00
|
|
|
if not file_exists(self.prefix_dir + "/user.reg", follow_symlinks=True):
|
2019-07-29 20:33:18 +03:00
|
|
|
self.copy_pfx()
|
2019-07-29 20:17:22 +03:00
|
|
|
|
2021-05-27 19:23:08 +03:00
|
|
|
self.migrate_user_paths()
|
|
|
|
|
2021-03-25 21:14:33 +03:00
|
|
|
if not os.path.lexists(self.prefix_dir + "/dosdevices/c:"):
|
|
|
|
os.symlink("../drive_c", self.prefix_dir + "/dosdevices/c:")
|
|
|
|
|
|
|
|
if not os.path.lexists(self.prefix_dir + "/dosdevices/z:"):
|
|
|
|
os.symlink("/", self.prefix_dir + "/dosdevices/z:")
|
|
|
|
|
2020-07-17 06:38:24 +03:00
|
|
|
# collect configuration info
|
2021-05-18 16:45:37 +03:00
|
|
|
steamdir = os.environ["STEAM_COMPAT_CLIENT_INSTALL_PATH"]
|
2020-07-17 06:38:24 +03:00
|
|
|
|
|
|
|
use_wined3d = "wined3d" in g_session.compat_config
|
2021-06-02 17:18:43 +03:00
|
|
|
use_dxvk_dxgi = not use_wined3d and \
|
|
|
|
not ("WINEDLLOVERRIDES" in g_session.env and "dxgi=b" in g_session.env["WINEDLLOVERRIDES"])
|
2021-05-11 00:27:49 +03:00
|
|
|
use_nvapi = 'enablenvapi' in g_session.compat_config
|
2020-07-17 06:38:24 +03:00
|
|
|
|
2020-07-29 17:11:37 +03:00
|
|
|
builtin_dll_copy = os.environ.get("PROTON_DLL_COPY",
|
|
|
|
#dxsetup redist
|
|
|
|
"d3dcompiler_*.dll," +
|
|
|
|
"d3dcsx*.dll," +
|
|
|
|
"d3dx*.dll," +
|
2023-08-02 16:37:19 +03:00
|
|
|
"dx8vb.dll," +
|
2020-07-29 17:11:37 +03:00
|
|
|
"x3daudio*.dll," +
|
|
|
|
"xactengine*.dll," +
|
|
|
|
"xapofx*.dll," +
|
|
|
|
"xaudio*.dll," +
|
2020-08-06 23:46:17 +03:00
|
|
|
"xinput*.dll," +
|
|
|
|
|
2020-09-10 21:09:03 +03:00
|
|
|
#vcruntime redist
|
|
|
|
"atl1*.dll," +
|
|
|
|
"concrt1*.dll," +
|
|
|
|
"msvcp1*.dll," +
|
|
|
|
"msvcr1*.dll," +
|
|
|
|
"vcamp1*.dll," +
|
|
|
|
"vcomp1*.dll," +
|
|
|
|
"vccorlib1*.dll," +
|
|
|
|
"vcruntime1*.dll," +
|
|
|
|
|
2020-08-06 23:46:17 +03:00
|
|
|
#some games balk at ntdll symlink(?)
|
|
|
|
"ntdll.dll," +
|
|
|
|
|
|
|
|
#some games require official vulkan loader
|
|
|
|
"vulkan-1.dll"
|
2020-07-29 17:11:37 +03:00
|
|
|
)
|
2020-07-17 06:55:44 +03:00
|
|
|
|
2020-07-17 06:38:24 +03:00
|
|
|
# If any of this info changes, we must rerun the tasks below
|
|
|
|
prefix_info = '\n'.join((
|
|
|
|
CURRENT_PREFIX_VERSION,
|
|
|
|
g_proton.fonts_dir,
|
|
|
|
g_proton.lib_dir,
|
|
|
|
g_proton.lib64_dir,
|
|
|
|
steamdir,
|
|
|
|
getmtimestr(steamdir, 'legacycompat', 'steamclient.dll'),
|
|
|
|
getmtimestr(steamdir, 'legacycompat', 'steamclient64.dll'),
|
|
|
|
getmtimestr(steamdir, 'legacycompat', 'Steam.dll'),
|
|
|
|
g_proton.default_pfx_dir,
|
|
|
|
getmtimestr(g_proton.default_pfx_dir, 'system.reg'),
|
|
|
|
str(use_wined3d),
|
|
|
|
str(use_dxvk_dxgi),
|
2020-07-17 06:55:44 +03:00
|
|
|
builtin_dll_copy,
|
2021-05-11 00:27:49 +03:00
|
|
|
str(use_nvapi),
|
2020-07-17 06:38:24 +03:00
|
|
|
))
|
|
|
|
|
2021-06-16 07:00:22 +03:00
|
|
|
# check whether any prefix config has changed
|
|
|
|
try:
|
|
|
|
with open(self.config_info_file, "r") as f:
|
|
|
|
old_prefix_info = f.read()
|
|
|
|
except IOError:
|
|
|
|
old_prefix_info = ""
|
|
|
|
|
|
|
|
if old_ver != CURRENT_PREFIX_VERSION or old_prefix_info != prefix_info:
|
|
|
|
# update builtin dll symlinks or copies
|
|
|
|
self.update_builtin_libs(builtin_dll_copy)
|
|
|
|
|
|
|
|
with open(self.config_info_file, "w") as f:
|
|
|
|
f.write(prefix_info)
|
2020-07-17 06:38:24 +03:00
|
|
|
|
2019-07-29 20:33:18 +03:00
|
|
|
with open(self.version_file, "w") as f:
|
2019-07-29 20:17:22 +03:00
|
|
|
f.write(CURRENT_PREFIX_VERSION + "\n")
|
|
|
|
|
|
|
|
#create font files symlinks
|
2019-07-29 20:33:18 +03:00
|
|
|
self.create_fonts_symlinks()
|
2019-07-29 20:17:22 +03:00
|
|
|
|
2020-08-10 22:23:31 +03:00
|
|
|
with open(self.tracked_files_file, "a") as tracked_files:
|
|
|
|
#copy steam files into place
|
|
|
|
steam_dir = "drive_c/Program Files (x86)/Steam/"
|
2021-12-16 13:58:22 +03:00
|
|
|
makedirs(self.prefix_dir + steam_dir)
|
2020-08-10 22:23:31 +03:00
|
|
|
filestocopy = [("steamclient.dll", "steamclient.dll"),
|
|
|
|
("steamclient64.dll", "steamclient64.dll"),
|
|
|
|
("GameOverlayRenderer64.dll", "GameOverlayRenderer64.dll"),
|
|
|
|
("SteamService.exe", "steam.exe"),
|
|
|
|
("Steam.dll", "Steam.dll")]
|
|
|
|
for (src,tgt) in filestocopy:
|
|
|
|
srcfile = steamdir + '/legacycompat/' + src
|
|
|
|
if os.path.isfile(srcfile):
|
2021-12-16 14:03:53 +03:00
|
|
|
try_copy(srcfile, steam_dir + tgt, prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2020-08-10 22:23:31 +03:00
|
|
|
|
|
|
|
filestocopy = [("steamclient64.dll", "steamclient64.dll"),
|
|
|
|
("GameOverlayRenderer.dll", "GameOverlayRenderer.dll"),
|
|
|
|
("GameOverlayRenderer64.dll", "GameOverlayRenderer64.dll")]
|
|
|
|
for (src,tgt) in filestocopy:
|
|
|
|
srcfile = g_proton.path(src)
|
|
|
|
if os.path.isfile(srcfile):
|
2021-12-16 14:03:53 +03:00
|
|
|
try_copy(srcfile, steam_dir + tgt, prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2019-07-29 20:17:22 +03:00
|
|
|
|
2021-12-17 17:59:35 +03:00
|
|
|
#copy openvr files into place
|
|
|
|
makedirs(self.prefix_dir + "/drive_c/vrclient/bin")
|
|
|
|
try_copy(g_proton.lib_dir + "wine/i386-windows/vrclient.dll", "drive_c/vrclient/bin",
|
2021-12-16 14:03:53 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2021-12-17 17:59:35 +03:00
|
|
|
try_copy(g_proton.lib64_dir + "wine/x86_64-windows/vrclient_x64.dll", "drive_c/vrclient/bin",
|
2021-12-16 14:03:53 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2019-10-22 17:42:06 +03:00
|
|
|
|
2021-12-17 17:59:35 +03:00
|
|
|
try_copy(g_proton.lib_dir + "wine/dxvk/openvr_api_dxvk.dll", "drive_c/windows/syswow64",
|
2021-12-16 14:03:53 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2021-12-17 17:59:35 +03:00
|
|
|
try_copy(g_proton.lib64_dir + "wine/dxvk/openvr_api_dxvk.dll", "drive_c/windows/system32",
|
2021-12-16 14:03:53 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2021-12-17 17:59:35 +03:00
|
|
|
|
|
|
|
makedirs(self.prefix_dir + "/drive_c/openxr")
|
|
|
|
try_copy(g_proton.default_pfx_dir + "drive_c/openxr/wineopenxr64.json", "drive_c/openxr",
|
2021-12-16 14:03:53 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2019-07-29 20:17:22 +03:00
|
|
|
|
2021-12-17 17:59:35 +03:00
|
|
|
#copy vkd3d files into place
|
2022-12-19 16:47:25 +03:00
|
|
|
try_copy(g_proton.lib64_dir + "vkd3d/libvkd3d-1.dll", "drive_c/windows/system32",
|
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
|
|
|
try_copy(g_proton.lib_dir + "vkd3d/libvkd3d-1.dll", "drive_c/windows/syswow64",
|
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2021-12-17 17:59:35 +03:00
|
|
|
try_copy(g_proton.lib64_dir + "vkd3d/libvkd3d-shader-1.dll", "drive_c/windows/system32",
|
2021-12-16 14:03:53 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2021-12-17 17:59:35 +03:00
|
|
|
try_copy(g_proton.lib_dir + "vkd3d/libvkd3d-shader-1.dll", "drive_c/windows/syswow64",
|
2021-12-16 14:03:53 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2019-07-29 21:06:51 +03:00
|
|
|
|
2021-12-17 17:59:35 +03:00
|
|
|
if use_wined3d:
|
2022-02-04 19:40:20 +03:00
|
|
|
dxvkfiles = []
|
2022-07-20 18:40:50 +03:00
|
|
|
vkd3d_protonfiles = []
|
|
|
|
wined3dfiles = ["d3d12", "d3d11", "d3d10", "d3d10core", "d3d10_1", "d3d9"]
|
2021-12-17 17:59:35 +03:00
|
|
|
else:
|
2022-02-04 19:40:20 +03:00
|
|
|
dxvkfiles = ["d3d11", "d3d10core", "d3d9"]
|
2023-03-16 13:45:29 +03:00
|
|
|
vkd3d_protonfiles = ["d3d12", "d3d12core"]
|
2021-12-17 17:59:35 +03:00
|
|
|
wined3dfiles = []
|
|
|
|
|
|
|
|
if use_dxvk_dxgi:
|
|
|
|
dxvkfiles.append("dxgi")
|
|
|
|
else:
|
|
|
|
wined3dfiles.append("dxgi")
|
|
|
|
|
|
|
|
for f in wined3dfiles:
|
|
|
|
try_copy(g_proton.default_pfx_dir + "drive_c/windows/system32/" + f + ".dll", "drive_c/windows/system32",
|
2021-12-16 14:03:53 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2021-12-17 17:59:35 +03:00
|
|
|
try_copy(g_proton.default_pfx_dir + "drive_c/windows/syswow64/" + f + ".dll", "drive_c/windows/syswow64",
|
2021-12-16 14:03:53 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2021-12-17 17:59:35 +03:00
|
|
|
|
|
|
|
for f in dxvkfiles:
|
|
|
|
try_copy(g_proton.lib64_dir + "wine/dxvk/" + f + ".dll", "drive_c/windows/system32",
|
2021-12-16 14:03:53 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2021-12-17 17:59:35 +03:00
|
|
|
try_copy(g_proton.lib_dir + "wine/dxvk/" + f + ".dll", "drive_c/windows/syswow64",
|
2021-12-16 14:03:53 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2021-12-17 17:59:35 +03:00
|
|
|
g_session.dlloverrides[f] = "n"
|
|
|
|
|
2022-07-20 18:40:50 +03:00
|
|
|
for f in vkd3d_protonfiles:
|
2023-03-16 13:45:29 +03:00
|
|
|
optional = False
|
|
|
|
if f == "d3d12core":
|
|
|
|
optional = True
|
2022-07-20 18:40:50 +03:00
|
|
|
try_copy(g_proton.lib64_dir + "wine/vkd3d-proton/" + f + ".dll", "drive_c/windows/system32",
|
2023-03-16 13:45:29 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True, optional=optional)
|
2022-07-20 18:40:50 +03:00
|
|
|
try_copy(g_proton.lib_dir + "wine/vkd3d-proton/" + f + ".dll", "drive_c/windows/syswow64",
|
2023-03-16 13:45:29 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True, optional=optional)
|
2022-07-20 18:40:50 +03:00
|
|
|
g_session.dlloverrides[f] = "n"
|
|
|
|
|
2021-12-17 17:59:35 +03:00
|
|
|
# If the user requested the NVAPI be available, copy it into place.
|
|
|
|
# If they didn't, clean up any stray nvapi DLLs.
|
|
|
|
if use_nvapi:
|
|
|
|
try_copy(g_proton.lib64_dir + "wine/nvapi/nvapi64.dll", "drive_c/windows/system32",
|
2021-12-16 14:03:53 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2021-12-17 17:59:35 +03:00
|
|
|
try_copy(g_proton.lib_dir + "wine/nvapi/nvapi.dll", "drive_c/windows/syswow64",
|
2021-12-16 14:03:53 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2021-12-17 17:59:35 +03:00
|
|
|
g_session.dlloverrides["nvapi64"] = "n"
|
|
|
|
g_session.dlloverrides["nvapi"] = "n"
|
|
|
|
g_session.dlloverrides["nvcuda"] = "b"
|
|
|
|
else:
|
|
|
|
nvapi64_dll = self.prefix_dir + "drive_c/windows/system32/nvapi64.dll"
|
|
|
|
nvapi32_dll = self.prefix_dir + "drive_c/windows/syswow64/nvapi.dll"
|
2022-02-09 20:11:11 +03:00
|
|
|
if file_exists(nvapi64_dll, follow_symlinks=False):
|
2021-12-17 17:59:35 +03:00
|
|
|
os.unlink(nvapi64_dll)
|
2022-02-09 20:11:11 +03:00
|
|
|
if file_exists(nvapi64_dll + '.debug', follow_symlinks=False):
|
2021-12-16 14:03:53 +03:00
|
|
|
os.unlink(nvapi64_dll + '.debug')
|
2022-02-09 20:11:11 +03:00
|
|
|
if file_exists(nvapi32_dll, follow_symlinks=False):
|
2021-12-17 17:59:35 +03:00
|
|
|
os.unlink(nvapi32_dll)
|
2022-02-09 20:11:11 +03:00
|
|
|
if file_exists(nvapi32_dll + '.debug', follow_symlinks=False):
|
2021-12-16 14:03:53 +03:00
|
|
|
os.unlink(nvapi32_dll + '.debug')
|
2021-12-17 17:59:35 +03:00
|
|
|
|
|
|
|
# Try to detect known DLLs that ship with the NVIDIA Linux Driver
|
|
|
|
# and add them into the prefix
|
|
|
|
nvidia_wine_dll_dir = find_nvidia_wine_dll_dir()
|
|
|
|
if nvidia_wine_dll_dir:
|
|
|
|
for dll in ["_nvngx.dll", "nvngx.dll"]:
|
|
|
|
try_copy(nvidia_wine_dll_dir + "/" + dll, "drive_c/windows/system32", optional=True,
|
2021-12-16 14:03:53 +03:00
|
|
|
prefix=self.prefix_dir, track_file=tracked_files, link_debug=True)
|
2021-12-17 17:59:35 +03:00
|
|
|
|
2022-01-07 00:52:13 +03:00
|
|
|
setup_game_dir_drive()
|
2022-03-11 19:10:42 +03:00
|
|
|
setup_steam_dir_drive()
|
2020-12-03 22:36:48 +03:00
|
|
|
|
2021-12-21 01:35:06 +03:00
|
|
|
# add Steam ffmpeg libraries to path
|
2022-07-13 13:11:45 +03:00
|
|
|
use_ffmpeg = "PROTON_NO_STEAM_FFMPEG" not in os.environ or not nonzero(os.environ["PROTON_NO_STEAM_FFMPEG"])
|
|
|
|
if use_ffmpeg and 'nosteamffmpeg' not in g_session.compat_config:
|
|
|
|
prepend_to_env_str(g_session.env, ld_path_var, steamdir + "/ubuntu12_64/video/:" + steamdir + "/ubuntu12_32/video/", ":")
|
2021-12-21 01:35:06 +03:00
|
|
|
|
2020-03-18 21:50:34 +03:00
|
|
|
def comma_escaped(s):
|
|
|
|
escaped = False
|
|
|
|
idx = -1
|
|
|
|
while s[idx] == '\\':
|
|
|
|
escaped = not escaped
|
|
|
|
idx = idx - 1
|
|
|
|
return escaped
|
|
|
|
|
2022-02-10 23:14:36 +03:00
|
|
|
#hopefully short-lived, app-specific workarounds for Proton bugs
|
|
|
|
def default_compat_config():
|
|
|
|
ret = set()
|
|
|
|
if "SteamAppId" in os.environ:
|
|
|
|
appid = os.environ["SteamAppId"]
|
2022-04-05 18:07:05 +03:00
|
|
|
if appid in [
|
2022-02-23 18:38:05 +03:00
|
|
|
#affected by CW bug 19126
|
2022-05-09 18:29:46 +03:00
|
|
|
"536280", #Disintegration
|
2022-05-11 00:41:02 +03:00
|
|
|
"707030", #POSTAL 4: No Regerts
|
2022-11-23 20:45:47 +03:00
|
|
|
"1331440", #FUSER
|
|
|
|
"1359980", #POSTAL: Brain Damaged
|
|
|
|
"1766430", #POSTAL Brain Damaged Demo
|
2023-05-16 20:59:32 +03:00
|
|
|
"692890", #Roboquest
|
2022-02-23 18:38:05 +03:00
|
|
|
|
|
|
|
#affected by CW bug 19741
|
|
|
|
"1017900", #Age of Empires: Definitive Edition
|
|
|
|
]:
|
|
|
|
ret.add("nomfdxgiman")
|
2022-06-28 18:20:01 +03:00
|
|
|
|
|
|
|
if appid in [
|
|
|
|
# OPWR may be causing text input delays in login windows in these games on Wayland due to
|
|
|
|
# blit happening before presentation
|
|
|
|
"1172620", #Sea of Thieves
|
|
|
|
"962130", #Grounded
|
|
|
|
"495420", #State of Decay 2: Juggernaut Edition
|
|
|
|
"976730", #Halo: The Master Chief Collection
|
|
|
|
"1017900", #Age of Empires: Definitive Edition
|
|
|
|
"1056090", #Ori and the Will of the Wisps
|
|
|
|
"1293830", #Forza Horizon 4
|
|
|
|
"1551360", #Forza Horizon 5
|
|
|
|
"271590", #Grand Theft Auto V
|
|
|
|
"5699", #Grand Theft Auto V Premium Edition
|
|
|
|
"1174180", #Red Dead Redemption 2
|
|
|
|
"1404210", #Red Dead Online
|
|
|
|
"12210", #Grand Theft Auto IV: Complete Edition
|
|
|
|
"204100", #Max Payne 3
|
|
|
|
"110800", #L.A. Noire
|
|
|
|
"12200", #Bully: Scholarship Edition
|
|
|
|
"12120", #Grand Theft Auto: San Andreas
|
|
|
|
"12110", #Grand Theft Auto: Vice City
|
|
|
|
"12100", #Grand Theft Auto III
|
|
|
|
"722230", #L.A. Noire: The VR Case Files
|
|
|
|
"813780", #Age of Empires II: Definitive Edition
|
|
|
|
"933110", #Age of Empires III: Definitive Edition
|
|
|
|
"1466860", #Age of Empires IV
|
|
|
|
"1097840", #Gears 5
|
|
|
|
"1244950", #Battletoads
|
|
|
|
"1189800", #Bleeding Edge
|
|
|
|
"1184050", #Gears Tactics
|
|
|
|
"1240440", #Halo Infinite
|
|
|
|
"1250410", #Microsoft Flight Simulator
|
|
|
|
"1672970", #Minecraft Dungeons
|
|
|
|
"1180660", #Tell Me Why
|
|
|
|
"1238430", #Tell Me Why Chapter 2
|
|
|
|
"1266670", #Tell Me Why Chapter 3
|
2022-07-08 22:25:14 +03:00
|
|
|
# Other issues arising from OWPR code path in apps, e. g., hitting unimplemented bits in
|
|
|
|
# d3dcompiler.
|
|
|
|
"230410", #Warframe
|
2022-06-28 18:20:01 +03:00
|
|
|
]:
|
|
|
|
ret.add("noopwr")
|
|
|
|
|
2022-09-14 01:41:57 +03:00
|
|
|
if appid == "1621680":
|
|
|
|
ret.add("noforcelgadd")
|
|
|
|
|
2022-12-22 21:14:07 +03:00
|
|
|
if appid in [
|
2023-07-11 16:58:44 +03:00
|
|
|
"1341820", #As Dusk falls
|
|
|
|
"280790", #Creativerse
|
|
|
|
"306130", #The Elder Scrolls Online
|
|
|
|
"24010", #Train Simulator
|
|
|
|
"374320", #DARK SOULS III
|
2023-07-14 20:10:13 +03:00
|
|
|
"65500", #Aura: Fate of the Ages
|
2023-07-31 18:25:25 +03:00
|
|
|
"4000", #Garry's Mod
|
2023-09-01 18:36:58 +03:00
|
|
|
"383120", #Empyrion - Galactic Survival
|
2023-09-01 18:39:02 +03:00
|
|
|
"2371630", #Sword Art Online: Integral Factor
|
2022-12-22 21:14:07 +03:00
|
|
|
]:
|
2022-11-02 04:24:45 +03:00
|
|
|
ret.add("gamedrive")
|
|
|
|
|
2022-09-14 02:14:56 +03:00
|
|
|
if appid in [
|
|
|
|
"202990", #Call of Duty: Black Ops II - Multiplayer
|
|
|
|
"212910", #Call of Duty: Black Ops II - Zombies
|
2023-07-11 13:01:49 +03:00
|
|
|
"499100", #Dark Parables: The Exiled Prince Collector's Edition (499100)
|
2023-09-23 03:01:56 +03:00
|
|
|
"1404090", #Trivia Tricks
|
2022-09-14 02:14:56 +03:00
|
|
|
]:
|
|
|
|
ret.add("heapdelayfree")
|
|
|
|
|
2023-05-31 06:29:04 +03:00
|
|
|
if appid in [
|
|
|
|
"2630", #Call of Duty 2
|
|
|
|
]:
|
|
|
|
ret.add("nofsync")
|
|
|
|
ret.add("noesync")
|
|
|
|
|
2022-08-26 23:38:28 +03:00
|
|
|
if appid in [
|
|
|
|
# enable dxvknvapi for titles verified to benefit (e.g. working DLSS)
|
2023-07-19 01:42:06 +03:00
|
|
|
"1938800", #Alone in the Dark Prologue
|
|
|
|
"1310410", #Alone in the Dark
|
2022-08-26 23:38:28 +03:00
|
|
|
"673130", #amid evil
|
|
|
|
"1182900", #A Plague Tale: Requiem
|
|
|
|
"1291680", #apocalypse: 2.0 edition
|
|
|
|
"979690", #the ascent
|
|
|
|
"805550", #assetto corsa competizione
|
2023-05-12 22:34:38 +03:00
|
|
|
"668580", #Atomic Heart
|
|
|
|
"2407990", #Atomic Heart demo
|
2022-08-26 23:38:28 +03:00
|
|
|
"924970", #back 4 blood
|
2023-05-12 22:34:38 +03:00
|
|
|
"1086940", #Baldur's Gate 3
|
2022-08-26 23:38:28 +03:00
|
|
|
"1178830", #bright memory infinite
|
|
|
|
"1409670", #bright memory infinite benchmark
|
2023-04-28 22:04:26 +03:00
|
|
|
"1016800", #chernobylite enhanced edition
|
2022-08-26 23:38:28 +03:00
|
|
|
"1153640", #chorus
|
|
|
|
"1791040", #chorus demo
|
|
|
|
"1577240", #cions of vega
|
|
|
|
"1632760", #cions of vega demo
|
|
|
|
"870780", #control ultimate edition
|
|
|
|
"884660", #CRSED
|
|
|
|
"1091500", #cyberpunk 2077
|
2023-04-28 22:04:26 +03:00
|
|
|
"1693980", #dead space (remake)
|
2022-08-26 23:38:28 +03:00
|
|
|
"1190460", #death stranding
|
|
|
|
"1850570", #Death Stranding Director's Cut
|
|
|
|
"1252330", #deathloop
|
|
|
|
"548430", #deep rock galactic
|
|
|
|
"428660", #deliver us the moon
|
2023-05-12 22:34:38 +03:00
|
|
|
"1929610", #Demonologist
|
|
|
|
"2302560", #Demonologist demo
|
2023-07-19 01:42:06 +03:00
|
|
|
"2097490", #Desordre
|
|
|
|
"2373430", #Desordre (demo)
|
|
|
|
"2211940", #Doge Simulator
|
|
|
|
"2312000", #Doge Simulator (demo)
|
2022-08-26 23:38:28 +03:00
|
|
|
"534380", #dying light 2
|
|
|
|
"269190", #edge of eternity
|
|
|
|
"1871990", #engine evolution 2022
|
|
|
|
"1952070", #engine evolution 2022 demo
|
|
|
|
"1128920", #everspace 2
|
|
|
|
"1312800", #everspace 2 demo
|
|
|
|
"1330470", #F.I.S.T.: Forged In Shadow Torch
|
|
|
|
"1332390", #F.I.S.T.: Forged In Shadow Torch Demo
|
|
|
|
"1641960", #Forever Skies
|
|
|
|
"2141060", #Forever Skies Demo
|
2023-04-28 22:04:26 +03:00
|
|
|
"1680880", #forspoken
|
|
|
|
"2228080", #forspoken demo
|
|
|
|
"1551360", #Forza Horizon 5
|
2022-08-26 23:38:28 +03:00
|
|
|
"1080110", #f1 2020
|
|
|
|
"1098130", #get stuffed
|
|
|
|
"1139900", #ghostrunner
|
|
|
|
"1249200", #ghostrunner demo
|
|
|
|
"1475810", #Ghostwire: Tokyo
|
|
|
|
"1593500", #god of war
|
|
|
|
"1496790", #Gotham Knights
|
|
|
|
"414340", #hellblade: senua's sacrifice
|
2023-04-28 22:04:26 +03:00
|
|
|
"1817230", #hi-fi rush
|
2022-08-26 23:38:28 +03:00
|
|
|
"1659040", #hitman 3
|
|
|
|
"1847520", #hitman 3 free starter pack
|
|
|
|
"1151640", #Horizon Zero Dawn
|
2023-05-12 22:34:38 +03:00
|
|
|
"1149460", #Icarus
|
2022-08-26 23:38:28 +03:00
|
|
|
"1650150", #island of the ancients
|
|
|
|
"1987940", #island of the ancients demo
|
|
|
|
"1371480", #iron conflict
|
2023-05-12 22:34:38 +03:00
|
|
|
"1946700", #Layers of Fear
|
|
|
|
"2237040", #Layers of Fear (demo)
|
2022-08-26 23:38:28 +03:00
|
|
|
"1544360", #lego builder's journey
|
2023-07-19 01:42:06 +03:00
|
|
|
"1265780", #Lord of the Rings: Gollum
|
2022-08-26 23:38:28 +03:00
|
|
|
"1363080", #Manor Lords
|
|
|
|
"2122820", #Manor Lords Demo
|
2023-04-28 22:04:26 +03:00
|
|
|
"997070", #marvel's avengers
|
2022-08-26 23:38:28 +03:00
|
|
|
"1817070", #marvel's spider-man remastered
|
|
|
|
"784080", #mechwarrior 5: mercenaries
|
|
|
|
"1170950", #mortal online 2
|
|
|
|
"261550", #mount & blade II: bannerlord
|
|
|
|
"1222370", #Necromunda: Hired Gun
|
2023-04-28 22:04:26 +03:00
|
|
|
"1846380", #need for speed unbound
|
|
|
|
"1325200", #nioh 2
|
2022-08-26 23:38:28 +03:00
|
|
|
"275850", #no man's sky
|
|
|
|
"1386900", #Observer: System Redux
|
|
|
|
"1140100", #the persistence
|
|
|
|
"1322170", #pluviophile
|
|
|
|
"400", #Portal [RTX]
|
2023-07-19 01:42:06 +03:00
|
|
|
"2410180", #Portal Prelude RTX
|
2023-04-28 22:04:26 +03:00
|
|
|
"1549180", #propnight
|
2022-08-26 23:38:28 +03:00
|
|
|
"1186640", #pumpkin jack
|
2023-07-19 01:42:06 +03:00
|
|
|
"1895880", #Ratchet & Clank: Rift Apart
|
2022-08-26 23:38:28 +03:00
|
|
|
"1144200", #Ready Or Not
|
2022-10-19 20:49:00 +03:00
|
|
|
"1404210", #Red Dead Online
|
|
|
|
"1174180", #Red Dead Redemption 2
|
2023-04-28 22:04:26 +03:00
|
|
|
"1294810", #Redfall
|
2023-07-19 01:42:06 +03:00
|
|
|
"1282100", #Remnant 2
|
2023-04-28 22:04:26 +03:00
|
|
|
"1649240", #returnal
|
2022-08-26 23:38:28 +03:00
|
|
|
"391220", #rise of the tomb raider
|
2023-04-28 22:04:26 +03:00
|
|
|
"1599660", #sackboy: a big adventure
|
|
|
|
"872670", #SCP: 5K - alpha testing
|
|
|
|
"513710", #scum
|
2023-05-12 22:34:38 +03:00
|
|
|
"1227690", #Severed Steel
|
|
|
|
"1631910", #Severed Steel demo
|
2022-08-26 23:38:28 +03:00
|
|
|
"750920", #shadow of the tomb raider
|
2023-07-19 01:42:06 +03:00
|
|
|
"1949030", #Sherlock Holmes: The Awakened
|
2023-05-12 22:34:38 +03:00
|
|
|
"1155330", #Showgunners
|
|
|
|
"2022460", #Showgunners demo
|
2022-08-26 23:38:28 +03:00
|
|
|
"1602080", #soulstice
|
|
|
|
"2015300", #soulstice demo
|
2023-07-19 01:42:06 +03:00
|
|
|
"1817190", #Spider-Man: Miles Morales
|
2022-08-26 23:38:28 +03:00
|
|
|
"1296010", #stay in the light
|
2023-05-12 22:34:38 +03:00
|
|
|
"2162020", #Strayed Lights
|
|
|
|
"2311720", #Strayed Lights demo
|
2022-08-26 23:38:28 +03:00
|
|
|
"813630", #supraland
|
|
|
|
"487390", #system shock demo
|
|
|
|
"868270", #the cycle: frontier
|
|
|
|
"306130", #the elder scrolls online
|
2023-04-28 22:04:26 +03:00
|
|
|
"1888930", #the last of us part 1
|
2022-08-26 23:38:28 +03:00
|
|
|
"1096200", #the orville: interactive fan experience
|
|
|
|
"1843860", #the redress of mira
|
|
|
|
"2050550", #the redress of mira demo
|
|
|
|
"1567740", #to hell with it
|
2023-07-19 01:42:06 +03:00
|
|
|
"1164940", #Trepang2
|
|
|
|
"1210600", #Trepang2 (demo)
|
2022-08-26 23:38:28 +03:00
|
|
|
"1662690", #twin stones: the journey of bukka
|
|
|
|
"1659420", #Uncharted Legacy of Thieves
|
2023-05-12 22:34:38 +03:00
|
|
|
"1159690", #Voidtrain
|
|
|
|
"1321660", #Voidtrain demo
|
|
|
|
"1361210", #Warhammer 40,000: Darktide
|
2022-08-26 23:38:28 +03:00
|
|
|
"236390", #war thunder
|
2023-04-28 22:04:26 +03:00
|
|
|
"2239550", #watch dogs legion
|
2022-08-26 23:38:28 +03:00
|
|
|
"936720", #wrench
|
|
|
|
"1249800", #xuan-yuan sword VII
|
2023-04-07 02:56:40 +03:00
|
|
|
"1358700", #STRANGER OF PARADISE FINAL FANTASY ORIGIN
|
2023-02-14 14:18:45 +03:00
|
|
|
"1446780", #monster hunter rise
|
2023-08-30 18:42:48 +03:00
|
|
|
"2379390", #Rainbow Six Extraction
|
2023-11-08 23:06:05 +03:00
|
|
|
"883710", #Resident Evil 2
|
2023-11-09 00:15:06 +03:00
|
|
|
"952060", #Resident Evil 3
|
2023-11-09 00:34:03 +03:00
|
|
|
"1196590", #Resident Evil Village
|
2023-11-09 01:23:57 +03:00
|
|
|
"418370", #Resident Evil 7 Biohazard
|
2023-11-09 21:50:22 +03:00
|
|
|
"990080", #Hogwarts Legacy
|
2023-11-30 00:35:06 +03:00
|
|
|
"526870", #Satisfactory
|
2022-08-26 23:38:28 +03:00
|
|
|
]:
|
|
|
|
ret.add("enablenvapi")
|
|
|
|
|
2023-08-31 00:04:02 +03:00
|
|
|
if appid in [
|
|
|
|
"1245620", #Elden Ring
|
|
|
|
"1888160", #Armored Core VI
|
2023-11-11 21:57:02 +03:00
|
|
|
"1888930", #the last of us part 1
|
2023-08-31 00:04:02 +03:00
|
|
|
"814380", #Sekiro: Shadows Die Twice
|
|
|
|
"2379390", #Rainbow Six Extraction
|
2023-11-08 23:05:42 +03:00
|
|
|
"883710", #Resident Evil 2
|
2023-11-09 00:14:32 +03:00
|
|
|
"952060", #Resident Evil 3
|
2023-11-09 00:33:35 +03:00
|
|
|
"1196590", #Resident Evil Village
|
2023-11-09 01:23:43 +03:00
|
|
|
"418370", #Resident Evil 7 Biohazard
|
2023-11-09 21:51:00 +03:00
|
|
|
"990080", #Hogwarts Legacy
|
2023-12-01 22:46:44 +03:00
|
|
|
"1328670", #Mass Effect Legendary Edition
|
2023-12-01 22:47:38 +03:00
|
|
|
"627270", #Injustice 2
|
2023-12-07 23:13:10 +03:00
|
|
|
"530940", #BIOHAZARD 7 resident evil
|
|
|
|
"895950", #BIOHAZARD RE:2 Z Version
|
|
|
|
"1100830", #BIOHAZARD RE:3 Z Version
|
|
|
|
"1196600", #BIOHAZARD VILLAGE Z Version
|
2023-12-15 20:26:51 +03:00
|
|
|
"601150", #Devil May Cry 5
|
2023-08-31 00:04:02 +03:00
|
|
|
]:
|
|
|
|
ret.add("enableamdags")
|
|
|
|
|
2022-02-10 23:14:36 +03:00
|
|
|
return ret
|
|
|
|
|
2019-07-29 21:06:51 +03:00
|
|
|
class Session:
|
|
|
|
def __init__(self):
|
|
|
|
self.log_file = None
|
|
|
|
self.env = dict(os.environ)
|
|
|
|
self.dlloverrides = {
|
|
|
|
"steam.exe": "b", #always use our special built-in steam.exe
|
2020-10-17 00:40:56 +03:00
|
|
|
"dotnetfx35.exe": "b", #replace the broken installer, as does Windows
|
2022-06-03 21:03:43 +03:00
|
|
|
"dotnetfx35setup.exe": "b",
|
2021-03-24 21:55:33 +03:00
|
|
|
"beclient.dll": "b,n",
|
|
|
|
"beclient_x64.dll": "b,n",
|
2019-07-29 21:06:51 +03:00
|
|
|
}
|
2020-03-18 21:50:34 +03:00
|
|
|
|
2022-12-27 05:36:58 +03:00
|
|
|
# CW Bug 21737. Locoland executable happens to be steam.exe.
|
|
|
|
if os.environ.get("SteamGameId", 0) == "352130":
|
|
|
|
del self.dlloverrides["steam.exe"]
|
|
|
|
|
2022-02-10 23:14:36 +03:00
|
|
|
self.compat_config = default_compat_config()
|
2020-03-18 21:50:34 +03:00
|
|
|
self.cmdlineappend = []
|
|
|
|
|
2019-07-29 21:06:51 +03:00
|
|
|
if "STEAM_COMPAT_CONFIG" in os.environ:
|
2020-03-18 21:50:34 +03:00
|
|
|
config = os.environ["STEAM_COMPAT_CONFIG"]
|
|
|
|
|
|
|
|
while config:
|
|
|
|
(cur, sep, config) = config.partition(',')
|
|
|
|
if cur.startswith("cmdlineappend:"):
|
|
|
|
while comma_escaped(cur):
|
|
|
|
(a, b, c) = config.partition(',')
|
|
|
|
cur = cur[:-1] + ',' + a
|
|
|
|
config = c
|
|
|
|
self.cmdlineappend.append(cur[14:].replace('\\\\','\\'))
|
|
|
|
else:
|
|
|
|
self.compat_config.add(cur)
|
2020-03-05 22:21:29 +03:00
|
|
|
|
|
|
|
#turn forcelgadd on by default unless it is disabled in compat config
|
|
|
|
if not "noforcelgadd" in self.compat_config:
|
|
|
|
self.compat_config.add("forcelgadd")
|
2019-07-29 20:17:22 +03:00
|
|
|
|
2019-07-29 21:41:01 +03:00
|
|
|
def init_wine(self):
|
2019-07-29 21:53:16 +03:00
|
|
|
if "HOST_LC_ALL" in self.env and len(self.env["HOST_LC_ALL"]) > 0:
|
2019-07-29 21:41:01 +03:00
|
|
|
#steam sets LC_ALL=C to help some games, but Wine requires the real value
|
|
|
|
#in order to do path conversion between win32 and host. steam sets
|
|
|
|
#HOST_LC_ALL to allow us to use the real value.
|
2019-07-29 21:53:16 +03:00
|
|
|
self.env["LC_ALL"] = self.env["HOST_LC_ALL"]
|
2019-07-29 21:41:01 +03:00
|
|
|
else:
|
2019-07-29 21:53:16 +03:00
|
|
|
self.env.pop("LC_ALL", "")
|
2019-07-29 20:17:22 +03:00
|
|
|
|
2019-07-29 21:53:16 +03:00
|
|
|
self.env.pop("WINEARCH", "")
|
2018-01-18 23:00:48 +03:00
|
|
|
|
2020-04-01 19:49:02 +03:00
|
|
|
if 'ORIG_'+ld_path_var not in os.environ:
|
|
|
|
# Allow wine to restore this when calling an external app.
|
|
|
|
self.env['ORIG_'+ld_path_var] = os.environ.get(ld_path_var, '')
|
|
|
|
|
2020-12-03 19:46:39 +03:00
|
|
|
prepend_to_env_str(self.env, ld_path_var, g_proton.lib64_dir + ":" + g_proton.lib_dir, ":")
|
2018-01-18 23:00:48 +03:00
|
|
|
|
2019-07-29 21:53:16 +03:00
|
|
|
self.env["WINEDLLPATH"] = g_proton.lib64_dir + "/wine:" + g_proton.lib_dir + "/wine"
|
2019-07-29 19:13:36 +03:00
|
|
|
|
2020-01-29 23:43:56 +03:00
|
|
|
self.env["GST_PLUGIN_SYSTEM_PATH_1_0"] = g_proton.lib64_dir + "gstreamer-1.0" + ":" + g_proton.lib_dir + "gstreamer-1.0"
|
|
|
|
self.env["WINE_GST_REGISTRY_DIR"] = g_compatdata.path("gstreamer-1.0/")
|
|
|
|
|
2020-07-28 16:20:33 +03:00
|
|
|
if "STEAM_COMPAT_MEDIA_PATH" in os.environ:
|
2022-01-21 16:39:33 +03:00
|
|
|
old_audiofoz_path = os.environ["STEAM_COMPAT_MEDIA_PATH"] + "/audio.foz"
|
2022-02-09 18:10:04 +03:00
|
|
|
if file_exists(old_audiofoz_path, follow_symlinks=False):
|
2022-01-21 16:39:33 +03:00
|
|
|
os.remove(old_audiofoz_path)
|
|
|
|
self.env["MEDIACONV_AUDIO_DUMP_FILE"] = os.environ["STEAM_COMPAT_MEDIA_PATH"] + "/audiov2.foz"
|
2020-07-28 16:20:33 +03:00
|
|
|
self.env["MEDIACONV_VIDEO_DUMP_FILE"] = os.environ["STEAM_COMPAT_MEDIA_PATH"] + "/video.foz"
|
2020-11-26 07:26:18 +03:00
|
|
|
|
|
|
|
if "STEAM_COMPAT_TRANSCODED_MEDIA_PATH" in os.environ:
|
|
|
|
self.env["MEDIACONV_AUDIO_TRANSCODED_FILE"] = os.environ["STEAM_COMPAT_TRANSCODED_MEDIA_PATH"] + "/transcoded_audio.foz"
|
|
|
|
self.env["MEDIACONV_VIDEO_TRANSCODED_FILE"] = os.environ["STEAM_COMPAT_TRANSCODED_MEDIA_PATH"] + "/transcoded_video.foz"
|
2020-07-28 16:20:33 +03:00
|
|
|
|
2020-12-03 19:46:39 +03:00
|
|
|
prepend_to_env_str(self.env, "PATH", g_proton.bin_dir, ":")
|
2018-01-19 20:03:54 +03:00
|
|
|
|
2019-07-29 21:41:01 +03:00
|
|
|
def check_environment(self, env_name, config_name):
|
2019-07-29 21:53:16 +03:00
|
|
|
if not env_name in self.env:
|
2019-07-29 21:41:01 +03:00
|
|
|
return False
|
2019-07-29 21:53:16 +03:00
|
|
|
if nonzero(self.env[env_name]):
|
|
|
|
self.compat_config.add(config_name)
|
2019-07-29 21:41:01 +03:00
|
|
|
else:
|
2019-07-29 21:53:16 +03:00
|
|
|
self.compat_config.discard(config_name)
|
2019-07-29 21:41:01 +03:00
|
|
|
return True
|
|
|
|
|
2020-10-29 18:56:11 +03:00
|
|
|
def try_log_slr_versions(self):
|
|
|
|
try:
|
|
|
|
if "PRESSURE_VESSEL_RUNTIME_BASE" in self.env:
|
|
|
|
with open(self.env["PRESSURE_VESSEL_RUNTIME_BASE"] + "/VERSIONS.txt", "r") as f:
|
|
|
|
for l in f:
|
|
|
|
l = l.strip()
|
|
|
|
if len(l) > 0 and not l.startswith("#"):
|
|
|
|
cleaned = l.split("#")[0].strip().replace("\t", " ")
|
|
|
|
split = cleaned.split(" ", maxsplit=1)
|
|
|
|
self.log_file.write(split[0] + ": " + split[1] + "\n")
|
|
|
|
except (OSError, IOError, TypeError, KeyError):
|
|
|
|
pass
|
|
|
|
|
2022-02-22 17:28:52 +03:00
|
|
|
def setup_logging(self, *, append_forever):
|
2021-07-09 20:30:55 +03:00
|
|
|
basedir = self.env.get("PROTON_LOG_DIR", os.environ["HOME"])
|
|
|
|
|
|
|
|
if append_forever:
|
|
|
|
#SteamGameId is not always available
|
|
|
|
lfile_path = basedir + "/steam-proton.log"
|
|
|
|
else:
|
|
|
|
if not "SteamGameId" in os.environ:
|
|
|
|
return False
|
|
|
|
|
|
|
|
lfile_path = basedir + "/steam-" + os.environ["SteamGameId"] + ".log"
|
|
|
|
|
2022-02-09 20:11:11 +03:00
|
|
|
if file_exists(lfile_path, follow_symlinks=False):
|
2021-07-09 20:30:55 +03:00
|
|
|
os.remove(lfile_path)
|
|
|
|
|
|
|
|
makedirs(basedir)
|
|
|
|
self.log_file = open(lfile_path, "a")
|
|
|
|
return True
|
|
|
|
|
2021-05-12 01:07:14 +03:00
|
|
|
def init_session(self, update_prefix_files):
|
2019-07-29 21:53:16 +03:00
|
|
|
self.env["WINEPREFIX"] = g_compatdata.prefix_dir
|
2019-07-29 21:41:01 +03:00
|
|
|
|
|
|
|
#load environment overrides
|
2021-04-22 21:30:10 +03:00
|
|
|
used_user_settings = {}
|
2022-02-09 18:10:04 +03:00
|
|
|
if file_exists(g_proton.user_settings_file, follow_symlinks=True):
|
2019-07-29 21:41:01 +03:00
|
|
|
try:
|
|
|
|
import user_settings
|
2019-07-31 15:59:37 +03:00
|
|
|
for key, value in user_settings.user_settings.items():
|
2021-04-22 21:30:10 +03:00
|
|
|
if not key in self.env:
|
|
|
|
self.env[key] = value
|
|
|
|
used_user_settings[key] = value
|
2019-07-29 21:41:01 +03:00
|
|
|
except:
|
|
|
|
log("************************************************")
|
|
|
|
log("THERE IS AN ERROR IN YOUR user_settings.py FILE:")
|
|
|
|
log("%s" % sys.exc_info()[1])
|
|
|
|
log("************************************************")
|
|
|
|
|
2019-07-31 15:59:37 +03:00
|
|
|
if "PROTON_LOG" in self.env and nonzero(self.env["PROTON_LOG"]):
|
2023-04-22 00:07:29 +03:00
|
|
|
self.env.setdefault("WINEDEBUG", "+timestamp,+pid,+tid,+seh,+unwind,+threadname,+debugstr,+loaddll,+mscoree")
|
2019-07-31 15:59:37 +03:00
|
|
|
self.env.setdefault("DXVK_LOG_LEVEL", "info")
|
2019-11-04 18:51:22 +03:00
|
|
|
self.env.setdefault("VKD3D_DEBUG", "warn")
|
2021-11-17 14:11:21 +03:00
|
|
|
self.env.setdefault("VKD3D_SHADER_DEBUG", "fixme")
|
2019-07-31 15:59:37 +03:00
|
|
|
self.env.setdefault("WINE_MONO_TRACE", "E:System.NotImplementedException")
|
|
|
|
|
2022-02-21 18:09:22 +03:00
|
|
|
if self.env["PROTON_LOG"] != "1":
|
|
|
|
append_to_env_str(self.env, "WINEDEBUG", self.env["PROTON_LOG"], ",")
|
|
|
|
|
2019-07-31 15:59:37 +03:00
|
|
|
#for performance, logging is disabled by default; override with user_settings.py
|
|
|
|
self.env.setdefault("WINEDEBUG", "-all")
|
|
|
|
self.env.setdefault("DXVK_LOG_LEVEL", "none")
|
2019-11-04 18:51:22 +03:00
|
|
|
self.env.setdefault("VKD3D_DEBUG", "none")
|
2021-11-17 14:11:21 +03:00
|
|
|
self.env.setdefault("VKD3D_SHADER_DEBUG", "none")
|
2019-07-31 15:59:37 +03:00
|
|
|
|
2021-03-15 19:28:38 +03:00
|
|
|
#disable XIM support until libx11 >= 1.7 is widespread
|
|
|
|
self.env.setdefault("WINE_ALLOW_XIM", "0")
|
|
|
|
|
2019-07-29 21:53:16 +03:00
|
|
|
if "wined3d11" in self.compat_config:
|
|
|
|
self.compat_config.add("wined3d")
|
2019-07-29 21:41:01 +03:00
|
|
|
|
|
|
|
if not self.check_environment("PROTON_USE_WINED3D", "wined3d"):
|
|
|
|
self.check_environment("PROTON_USE_WINED3D11", "wined3d")
|
|
|
|
self.check_environment("PROTON_NO_D3D11", "nod3d11")
|
|
|
|
self.check_environment("PROTON_NO_D3D10", "nod3d10")
|
|
|
|
self.check_environment("PROTON_NO_ESYNC", "noesync")
|
|
|
|
self.check_environment("PROTON_NO_FSYNC", "nofsync")
|
|
|
|
self.check_environment("PROTON_FORCE_LARGE_ADDRESS_AWARE", "forcelgadd")
|
|
|
|
self.check_environment("PROTON_OLD_GL_STRING", "oldglstr")
|
2020-06-01 19:09:41 +03:00
|
|
|
self.check_environment("PROTON_NO_WRITE_WATCH", "nowritewatch")
|
2020-08-11 17:31:52 +03:00
|
|
|
self.check_environment("PROTON_HIDE_NVIDIA_GPU", "hidenvgpu")
|
2020-12-03 22:36:48 +03:00
|
|
|
self.check_environment("PROTON_SET_GAME_DRIVE", "gamedrive")
|
2022-03-11 19:10:42 +03:00
|
|
|
self.check_environment("PROTON_SET_STEAM_DRIVE", "steamdrive")
|
2021-03-15 19:28:38 +03:00
|
|
|
self.check_environment("PROTON_NO_XIM", "noxim")
|
2021-03-15 21:13:36 +03:00
|
|
|
self.check_environment("PROTON_HEAP_DELAY_FREE", "heapdelayfree")
|
2021-05-11 00:27:49 +03:00
|
|
|
self.check_environment("PROTON_ENABLE_NVAPI", "enablenvapi")
|
2023-08-31 00:04:02 +03:00
|
|
|
self.check_environment("PROTON_ENABLE_AMD_AGS", "enableamdags")
|
2019-07-29 21:41:01 +03:00
|
|
|
|
2020-04-27 15:51:44 +03:00
|
|
|
if "noesync" in self.compat_config:
|
|
|
|
self.env.pop("WINEESYNC", "")
|
|
|
|
else:
|
2019-07-29 21:53:16 +03:00
|
|
|
self.env["WINEESYNC"] = "1"
|
2019-07-29 21:41:01 +03:00
|
|
|
|
2021-03-15 19:28:38 +03:00
|
|
|
if not "noxim" in self.compat_config:
|
|
|
|
self.env.pop("WINE_ALLOW_XIM")
|
|
|
|
|
2020-04-27 15:51:44 +03:00
|
|
|
if "nofsync" in self.compat_config:
|
|
|
|
self.env.pop("WINEFSYNC", "")
|
|
|
|
else:
|
2019-07-29 21:53:16 +03:00
|
|
|
self.env["WINEFSYNC"] = "1"
|
2019-07-29 21:41:01 +03:00
|
|
|
|
2020-06-01 19:09:41 +03:00
|
|
|
if "nowritewatch" in self.compat_config:
|
|
|
|
self.env["WINE_DISABLE_WRITE_WATCH"] = "1"
|
|
|
|
|
2019-07-29 21:53:16 +03:00
|
|
|
if "oldglstr" in self.compat_config:
|
2019-07-29 21:41:01 +03:00
|
|
|
#mesa override
|
2019-07-29 21:53:16 +03:00
|
|
|
self.env["MESA_EXTENSION_MAX_YEAR"] = "2003"
|
2019-07-29 21:41:01 +03:00
|
|
|
#nvidia override
|
2019-07-29 21:53:16 +03:00
|
|
|
self.env["__GL_ExtensionStringVersion"] = "17700"
|
2019-07-29 21:41:01 +03:00
|
|
|
|
2019-07-29 21:53:16 +03:00
|
|
|
if "forcelgadd" in self.compat_config:
|
|
|
|
self.env["WINE_LARGE_ADDRESS_AWARE"] = "1"
|
2023-11-04 00:23:49 +03:00
|
|
|
else:
|
|
|
|
if "noforcelgadd" in self.compat_config:
|
|
|
|
self.env["WINE_LARGE_ADDRESS_AWARE"] = "0"
|
2019-07-29 21:41:01 +03:00
|
|
|
|
2021-03-15 21:13:36 +03:00
|
|
|
if "heapdelayfree" in self.compat_config:
|
|
|
|
self.env["WINE_HEAP_DELAY_FREE"] = "1"
|
|
|
|
|
2020-12-03 19:35:34 +03:00
|
|
|
if "vkd3dbindlesstb" in self.compat_config:
|
2020-12-03 19:46:39 +03:00
|
|
|
append_to_env_str(self.env, "VKD3D_CONFIG", "force_bindless_texel_buffer", ",")
|
2020-12-03 19:35:34 +03:00
|
|
|
|
2020-07-15 23:01:55 +03:00
|
|
|
if "vkd3dfl12" in self.compat_config:
|
|
|
|
if not "VKD3D_FEATURE_LEVEL" in self.env:
|
|
|
|
self.env["VKD3D_FEATURE_LEVEL"] = "12_0"
|
|
|
|
|
2022-10-31 21:43:21 +03:00
|
|
|
# enablenvapi beats hidenvgpu
|
|
|
|
if "hidenvgpu" in self.compat_config and "enablenvapi" not in self.compat_config:
|
2020-08-11 17:31:52 +03:00
|
|
|
self.env["WINE_HIDE_NVIDIA_GPU"] = "1"
|
|
|
|
|
2021-10-05 17:37:22 +03:00
|
|
|
if "usenativexinput13" in self.compat_config:
|
|
|
|
self.dlloverrides["xinput1_3"] = "n"
|
|
|
|
|
2021-10-20 15:17:17 +03:00
|
|
|
if "disablelibglesv2" in self.compat_config:
|
|
|
|
self.dlloverrides["libglesv2"] = "d"
|
|
|
|
|
2022-02-23 18:38:05 +03:00
|
|
|
if "nomfdxgiman" in self.compat_config:
|
|
|
|
self.env["WINE_DO_NOT_CREATE_DXGI_DEVICE_MANAGER"] = "1"
|
|
|
|
|
2022-06-28 18:20:01 +03:00
|
|
|
if "noopwr" in self.compat_config:
|
|
|
|
self.env["WINE_DISABLE_VULKAN_OPWR"] = "1"
|
|
|
|
|
2021-05-19 00:02:44 +03:00
|
|
|
if "PROTON_CRASH_REPORT_DIR" in self.env:
|
|
|
|
self.env["WINE_CRASH_REPORT_DIR"] = self.env["PROTON_CRASH_REPORT_DIR"]
|
|
|
|
|
2023-03-01 20:13:55 +03:00
|
|
|
if "PROTON_LOG" in self.env and nonzero(self.env["PROTON_LOG"]):
|
2021-07-09 20:30:55 +03:00
|
|
|
if self.setup_logging(append_forever=False):
|
2019-07-29 21:53:16 +03:00
|
|
|
self.log_file.write("======================\n")
|
2019-07-29 21:41:01 +03:00
|
|
|
with open(g_proton.version_file, "r") as f:
|
2019-07-29 21:53:16 +03:00
|
|
|
self.log_file.write("Proton: " + f.readline().strip() + "\n")
|
2021-07-09 20:30:55 +03:00
|
|
|
if "SteamGameId" in self.env:
|
|
|
|
self.log_file.write("SteamGameId: " + self.env["SteamGameId"] + "\n")
|
2020-03-18 21:50:34 +03:00
|
|
|
self.log_file.write("Command: " + str(sys.argv[2:] + self.cmdlineappend) + "\n")
|
2019-07-29 21:53:16 +03:00
|
|
|
self.log_file.write("Options: " + str(self.compat_config) + "\n")
|
2021-07-09 20:30:55 +03:00
|
|
|
|
2020-10-29 18:56:11 +03:00
|
|
|
self.try_log_slr_versions()
|
2021-04-22 21:30:10 +03:00
|
|
|
|
2021-10-11 19:26:33 +03:00
|
|
|
try:
|
|
|
|
uname = os.uname()
|
|
|
|
kernel_version = f"{uname.sysname} {uname.release} {uname.version} {uname.machine}"
|
|
|
|
except OSError:
|
|
|
|
kernel_version = "unknown"
|
|
|
|
|
|
|
|
self.log_file.write(f"Kernel: {kernel_version}\n")
|
2023-01-11 14:00:56 +03:00
|
|
|
self.log_file.write("Language: LC_ALL " + str(self.env.get("HOST_LC_ALL", None)) +
|
|
|
|
", LC_MESSAGES " + str(self.env.get("LC_MESSAGES", None)) +
|
|
|
|
", LC_CTYPE " + str(self.env.get("LC_CTYPE", None)) + "\n")
|
2021-10-11 19:26:33 +03:00
|
|
|
|
2021-04-22 21:30:10 +03:00
|
|
|
#dump some important variables into the log header
|
|
|
|
for var in ["WINEDLLOVERRIDES", "WINEDEBUG"]:
|
|
|
|
if var in os.environ:
|
|
|
|
self.log_file.write("System " + var + ": " + os.environ[var] + "\n")
|
|
|
|
if var in used_user_settings:
|
|
|
|
self.log_file.write("User settings " + var + ": " + used_user_settings[var] + "\n")
|
2023-05-17 18:38:47 +03:00
|
|
|
if var in self.env:
|
|
|
|
self.log_file.write("Effective " + var + ": " + self.env[var] + "\n")
|
2021-04-22 21:30:10 +03:00
|
|
|
|
2019-07-29 21:53:16 +03:00
|
|
|
self.log_file.write("======================\n")
|
|
|
|
self.log_file.flush()
|
2021-07-09 20:30:55 +03:00
|
|
|
else:
|
|
|
|
self.env["WINEDEBUG"] = "-all"
|
2018-01-18 23:00:48 +03:00
|
|
|
|
2021-06-24 12:54:08 +03:00
|
|
|
if "PROTON_REMOTE_DEBUG_CMD" in self.env:
|
2021-11-19 23:23:45 +03:00
|
|
|
self.remote_debug_cmd = shlex.split(self.env.get("PROTON_REMOTE_DEBUG_CMD"))
|
2021-06-24 12:54:08 +03:00
|
|
|
else:
|
|
|
|
self.remote_debug_cmd = None
|
|
|
|
|
2021-05-12 01:07:14 +03:00
|
|
|
if update_prefix_files:
|
|
|
|
g_compatdata.setup_prefix()
|
2019-02-05 17:06:03 +03:00
|
|
|
|
2019-07-29 21:53:16 +03:00
|
|
|
if "nod3d11" in self.compat_config:
|
|
|
|
self.dlloverrides["d3d11"] = ""
|
|
|
|
if "dxgi" in self.dlloverrides:
|
|
|
|
del self.dlloverrides["dxgi"]
|
2018-05-11 15:14:04 +03:00
|
|
|
|
2019-07-29 21:53:16 +03:00
|
|
|
if "nod3d10" in self.compat_config:
|
|
|
|
self.dlloverrides["d3d10_1"] = ""
|
|
|
|
self.dlloverrides["d3d10"] = ""
|
|
|
|
self.dlloverrides["dxgi"] = ""
|
2018-02-14 22:59:35 +03:00
|
|
|
|
2021-02-05 17:16:17 +03:00
|
|
|
if "nativevulkanloader" in self.compat_config:
|
|
|
|
self.dlloverrides["vulkan-1"] = "n"
|
|
|
|
|
2022-03-16 02:38:59 +03:00
|
|
|
if "enablenvapi" in self.compat_config:
|
|
|
|
self.env["DXVK_ENABLE_NVAPI"] = "1"
|
|
|
|
|
2023-08-31 00:04:02 +03:00
|
|
|
if "enableamdags" in self.compat_config:
|
|
|
|
self.dlloverrides["amd_ags_x64"] = "b"
|
|
|
|
|
2019-07-29 21:41:01 +03:00
|
|
|
s = ""
|
2019-07-29 21:53:16 +03:00
|
|
|
for dll in self.dlloverrides:
|
|
|
|
setting = self.dlloverrides[dll]
|
2019-07-29 21:41:01 +03:00
|
|
|
if len(s) > 0:
|
|
|
|
s = s + ";" + dll + "=" + setting
|
|
|
|
else:
|
|
|
|
s = dll + "=" + setting
|
2020-12-03 19:46:39 +03:00
|
|
|
append_to_env_str(self.env, "WINEDLLOVERRIDES", s, ";")
|
2019-07-29 21:41:01 +03:00
|
|
|
|
|
|
|
def dump_dbg_env(self, f):
|
2019-07-29 21:53:16 +03:00
|
|
|
f.write("PATH=\"" + self.env["PATH"] + "\" \\\n")
|
2019-07-29 21:41:01 +03:00
|
|
|
f.write("\tTERM=\"xterm\" \\\n") #XXX
|
|
|
|
f.write("\tWINEDEBUG=\"-all\" \\\n")
|
2019-07-29 21:53:16 +03:00
|
|
|
f.write("\tWINEDLLPATH=\"" + self.env["WINEDLLPATH"] + "\" \\\n")
|
|
|
|
f.write("\t" + ld_path_var + "=\"" + self.env[ld_path_var] + "\" \\\n")
|
|
|
|
f.write("\tWINEPREFIX=\"" + self.env["WINEPREFIX"] + "\" \\\n")
|
|
|
|
if "WINEESYNC" in self.env:
|
|
|
|
f.write("\tWINEESYNC=\"" + self.env["WINEESYNC"] + "\" \\\n")
|
2020-02-18 20:52:22 +03:00
|
|
|
if "WINEFSYNC" in self.env:
|
|
|
|
f.write("\tWINEFSYNC=\"" + self.env["WINEFSYNC"] + "\" \\\n")
|
2019-07-29 21:53:16 +03:00
|
|
|
if "SteamGameId" in self.env:
|
|
|
|
f.write("\tSteamGameId=\"" + self.env["SteamGameId"] + "\" \\\n")
|
|
|
|
if "SteamAppId" in self.env:
|
|
|
|
f.write("\tSteamAppId=\"" + self.env["SteamAppId"] + "\" \\\n")
|
|
|
|
if "WINEDLLOVERRIDES" in self.env:
|
|
|
|
f.write("\tWINEDLLOVERRIDES=\"" + self.env["WINEDLLOVERRIDES"] + "\" \\\n")
|
|
|
|
if "STEAM_COMPAT_CLIENT_INSTALL_PATH" in self.env:
|
|
|
|
f.write("\tSTEAM_COMPAT_CLIENT_INSTALL_PATH=\"" + self.env["STEAM_COMPAT_CLIENT_INSTALL_PATH"] + "\" \\\n")
|
|
|
|
if "WINE_LARGE_ADDRESS_AWARE" in self.env:
|
|
|
|
f.write("\tWINE_LARGE_ADDRESS_AWARE=\"" + self.env["WINE_LARGE_ADDRESS_AWARE"] + "\" \\\n")
|
2020-07-28 16:20:33 +03:00
|
|
|
if "GST_PLUGIN_SYSTEM_PATH_1_0" in self.env:
|
|
|
|
f.write("\tGST_PLUGIN_SYSTEM_PATH_1_0=\"" + self.env["GST_PLUGIN_SYSTEM_PATH_1_0"] + "\" \\\n")
|
|
|
|
if "WINE_GST_REGISTRY_DIR" in self.env:
|
|
|
|
f.write("\tWINE_GST_REGISTRY_DIR=\"" + self.env["WINE_GST_REGISTRY_DIR"] + "\" \\\n")
|
|
|
|
if "MEDIACONV_AUDIO_DUMP_FILE" in self.env:
|
|
|
|
f.write("\tMEDIACONV_AUDIO_DUMP_FILE=\"" + self.env["MEDIACONV_AUDIO_DUMP_FILE"] + "\" \\\n")
|
|
|
|
if "MEDIACONV_AUDIO_TRANSCODED_FILE" in self.env:
|
|
|
|
f.write("\tMEDIACONV_AUDIO_TRANSCODED_FILE=\"" + self.env["MEDIACONV_AUDIO_TRANSCODED_FILE"] + "\" \\\n")
|
|
|
|
if "MEDIACONV_VIDEO_DUMP_FILE" in self.env:
|
|
|
|
f.write("\tMEDIACONV_VIDEO_DUMP_FILE=\"" + self.env["MEDIACONV_VIDEO_DUMP_FILE"] + "\" \\\n")
|
|
|
|
if "MEDIACONV_VIDEO_TRANSCODED_FILE" in self.env:
|
|
|
|
f.write("\tMEDIACONV_VIDEO_TRANSCODED_FILE=\"" + self.env["MEDIACONV_VIDEO_TRANSCODED_FILE"] + "\" \\\n")
|
2019-07-29 21:41:01 +03:00
|
|
|
|
|
|
|
def dump_dbg_scripts(self):
|
|
|
|
exe_name = os.path.basename(sys.argv[2])
|
|
|
|
|
2019-07-29 21:53:16 +03:00
|
|
|
tmpdir = self.env.get("PROTON_DEBUG_DIR", "/tmp") + "/proton_" + os.environ["USER"] + "/"
|
2019-07-29 21:41:01 +03:00
|
|
|
makedirs(tmpdir)
|
|
|
|
|
|
|
|
with open(tmpdir + "winedbg", "w") as f:
|
|
|
|
f.write("#!/bin/bash\n")
|
|
|
|
f.write("#Run winedbg with args\n\n")
|
|
|
|
f.write("cd \"" + os.getcwd() + "\"\n")
|
|
|
|
self.dump_dbg_env(f)
|
|
|
|
f.write("\t\"" + g_proton.wine_bin + "\" winedbg \"$@\"\n")
|
|
|
|
os.chmod(tmpdir + "winedbg", 0o755)
|
|
|
|
|
|
|
|
with open(tmpdir + "winedbg_run", "w") as f:
|
|
|
|
f.write("#!/bin/bash\n")
|
|
|
|
f.write("#Run winedbg and prepare to run game or given program\n\n")
|
|
|
|
f.write("cd \"" + os.getcwd() + "\"\n")
|
|
|
|
f.write("DEF_CMD=(")
|
|
|
|
first = True
|
|
|
|
for arg in sys.argv[2:]:
|
|
|
|
if first:
|
|
|
|
f.write("\"" + arg + "\"")
|
|
|
|
first = False
|
|
|
|
else:
|
|
|
|
f.write(" \"" + arg + "\"")
|
|
|
|
f.write(")\n")
|
|
|
|
self.dump_dbg_env(f)
|
|
|
|
f.write("\t\"" + g_proton.wine_bin + "\" winedbg \"${@:-${DEF_CMD[@]}}\"\n")
|
|
|
|
os.chmod(tmpdir + "winedbg_run", 0o755)
|
|
|
|
|
|
|
|
with open(tmpdir + "gdb_attach", "w") as f:
|
|
|
|
f.write("#!/bin/bash\n")
|
|
|
|
f.write("#Run winedbg in gdb mode and auto-attach to already-running program\n\n")
|
|
|
|
f.write("cd \"" + os.getcwd() + "\"\n")
|
|
|
|
f.write("EXE_NAME=${1:-\"" + exe_name + "\"}\n")
|
2021-09-14 10:02:43 +03:00
|
|
|
f.write("WPID_HEX=$(\"" + tmpdir + "winedbg\" --command 'info process' | grep -i \"$EXE_NAME\" | cut -f2 -d' ' | sed -e 's/^0*//')\n")
|
2019-07-29 21:41:01 +03:00
|
|
|
f.write("if [ -z \"$WPID_HEX\" ]; then \n")
|
|
|
|
f.write(" echo \"Program does not appear to be running: \\\"$EXE_NAME\\\"\"\n")
|
|
|
|
f.write(" exit 1\n")
|
|
|
|
f.write("fi\n")
|
|
|
|
f.write("WPID_DEC=$(printf %d 0x$WPID_HEX)\n")
|
|
|
|
self.dump_dbg_env(f)
|
|
|
|
f.write("\t\"" + g_proton.wine_bin + "\" winedbg --gdb $WPID_DEC\n")
|
|
|
|
os.chmod(tmpdir + "gdb_attach", 0o755)
|
|
|
|
|
|
|
|
with open(tmpdir + "gdb_run", "w") as f:
|
|
|
|
f.write("#!/bin/bash\n")
|
|
|
|
f.write("#Run winedbg in gdb mode and prepare to run game or given program\n\n")
|
|
|
|
f.write("cd \"" + os.getcwd() + "\"\n")
|
|
|
|
f.write("DEF_CMD=(")
|
|
|
|
first = True
|
|
|
|
for arg in sys.argv[2:]:
|
|
|
|
if first:
|
|
|
|
f.write("\"" + arg + "\"")
|
|
|
|
first = False
|
|
|
|
else:
|
|
|
|
f.write(" \"" + arg + "\"")
|
|
|
|
f.write(")\n")
|
|
|
|
self.dump_dbg_env(f)
|
|
|
|
f.write("\t\"" + g_proton.wine_bin + "\" winedbg --gdb \"${@:-${DEF_CMD[@]}}\"\n")
|
|
|
|
os.chmod(tmpdir + "gdb_run", 0o755)
|
|
|
|
|
|
|
|
with open(tmpdir + "run", "w") as f:
|
|
|
|
f.write("#!/bin/bash\n")
|
|
|
|
f.write("#Run game or given command in environment\n\n")
|
|
|
|
f.write("cd \"" + os.getcwd() + "\"\n")
|
|
|
|
f.write("DEF_CMD=(")
|
|
|
|
first = True
|
|
|
|
for arg in sys.argv[2:]:
|
|
|
|
if first:
|
|
|
|
f.write("\"" + arg + "\"")
|
|
|
|
first = False
|
|
|
|
else:
|
|
|
|
f.write(" \"" + arg + "\"")
|
|
|
|
f.write(")\n")
|
|
|
|
self.dump_dbg_env(f)
|
2021-10-04 15:30:38 +03:00
|
|
|
f.write("\t\"" + g_proton.wine64_bin + "\" c:\\\\windows\\\\system32\\\\steam.exe \"${@:-${DEF_CMD[@]}}\"\n")
|
2019-07-29 21:41:01 +03:00
|
|
|
os.chmod(tmpdir + "run", 0o755)
|
2018-02-14 22:59:35 +03:00
|
|
|
|
2019-07-29 21:59:15 +03:00
|
|
|
def run_proc(self, args, local_env=None):
|
2019-07-29 22:13:28 +03:00
|
|
|
if local_env is None:
|
2019-07-29 21:59:15 +03:00
|
|
|
local_env = self.env
|
2021-10-27 17:25:56 +03:00
|
|
|
return subprocess.call(args, env=local_env, stderr=self.log_file, stdout=self.log_file)
|
2018-01-18 23:00:48 +03:00
|
|
|
|
2019-07-29 21:41:01 +03:00
|
|
|
def run(self):
|
proton: Allow forwarding commands into the Proton environment
Recent versions of the Steam Runtime include an IPC server/client pair
which can be used to run commands inside the container environment
(or any other special execution environment), analogous to sshd/ssh or
flatpak-portal/flatpak-spawn. The server runs inside the Steam Runtime
container and accepts commands over D-Bus; the client runs on the host
system, asks the server to run a command, and forwards its stdin, stdout
and stderr back to the host.
https://gitlab.steamos.cloud/steamrt/steamlinuxruntime/-/merge_requests/72
adds support for injecting commands into the SteamLinuxRuntime_soldier
compatibility tool (and any later version, such as sniper). However,
Steam compatibility tools are stackable: in particular, Proton runs in a
soldier container (or presumably sniper in future). If we are debugging
a Proton game, then ideally we will want to inject commands into Proton's
execution environment rather than soldier's, so that they run with the
correct environment variables etc. to communicate with a running Proton
session. In particular, it's important that the `WINEPREFIX` is correct.
The steam-runtime-launcher-interface-0 program implements the
interface for compatibility tools to use to decide where, if anywhere,
to launch the command server.
This commit does not alter the scripts produced by
PROTON_DUMP_DEBUG_COMMANDS. To run those scripts' commands in the
container environment, pass their filenames to
steam-runtime-launch-client.
Signed-off-by: Simon McVittie <smcv@collabora.com>
Link: https://github.com/ValveSoftware/Proton/pull/5891
2022-06-08 20:17:05 +03:00
|
|
|
if shutil.which('steam-runtime-launcher-interface-0') is not None:
|
|
|
|
adverb = ['steam-runtime-launcher-interface-0', 'proton']
|
|
|
|
else:
|
|
|
|
adverb = []
|
|
|
|
|
2019-07-29 21:53:16 +03:00
|
|
|
if "PROTON_DUMP_DEBUG_COMMANDS" in self.env and nonzero(self.env["PROTON_DUMP_DEBUG_COMMANDS"]):
|
2019-07-29 21:41:01 +03:00
|
|
|
try:
|
|
|
|
self.dump_dbg_scripts()
|
|
|
|
except OSError:
|
|
|
|
log("Unable to write debug scripts! " + str(sys.exc_info()[1]))
|
2021-06-24 12:54:08 +03:00
|
|
|
|
|
|
|
if self.remote_debug_cmd:
|
2021-11-19 23:23:45 +03:00
|
|
|
remote_debug_cmd = self.remote_debug_cmd
|
|
|
|
if not os.path.isabs(remote_debug_cmd[0]):
|
|
|
|
remote_debug_cmd[0] = g_proton.path(remote_debug_cmd[0])
|
2021-06-24 12:54:08 +03:00
|
|
|
remote_debug_proc = subprocess.Popen([g_proton.wine_bin] + self.remote_debug_cmd,
|
|
|
|
env=self.env, stderr=self.log_file, stdout=self.log_file)
|
|
|
|
else:
|
|
|
|
remote_debug_proc = None
|
|
|
|
|
2022-01-21 23:26:09 +03:00
|
|
|
# CoD: Black Ops 3 workaround
|
|
|
|
if os.environ.get("SteamGameId", 0) == "311210":
|
proton: Allow forwarding commands into the Proton environment
Recent versions of the Steam Runtime include an IPC server/client pair
which can be used to run commands inside the container environment
(or any other special execution environment), analogous to sshd/ssh or
flatpak-portal/flatpak-spawn. The server runs inside the Steam Runtime
container and accepts commands over D-Bus; the client runs on the host
system, asks the server to run a command, and forwards its stdin, stdout
and stderr back to the host.
https://gitlab.steamos.cloud/steamrt/steamlinuxruntime/-/merge_requests/72
adds support for injecting commands into the SteamLinuxRuntime_soldier
compatibility tool (and any later version, such as sniper). However,
Steam compatibility tools are stackable: in particular, Proton runs in a
soldier container (or presumably sniper in future). If we are debugging
a Proton game, then ideally we will want to inject commands into Proton's
execution environment rather than soldier's, so that they run with the
correct environment variables etc. to communicate with a running Proton
session. In particular, it's important that the `WINEPREFIX` is correct.
The steam-runtime-launcher-interface-0 program implements the
interface for compatibility tools to use to decide where, if anywhere,
to launch the command server.
This commit does not alter the scripts produced by
PROTON_DUMP_DEBUG_COMMANDS. To run those scripts' commands in the
container environment, pass their filenames to
steam-runtime-launch-client.
Signed-off-by: Simon McVittie <smcv@collabora.com>
Link: https://github.com/ValveSoftware/Proton/pull/5891
2022-06-08 20:17:05 +03:00
|
|
|
argv = [g_proton.wine_bin, "c:\\Program Files (x86)\\Steam\\steam.exe"]
|
2022-01-21 23:26:09 +03:00
|
|
|
else:
|
proton: Allow forwarding commands into the Proton environment
Recent versions of the Steam Runtime include an IPC server/client pair
which can be used to run commands inside the container environment
(or any other special execution environment), analogous to sshd/ssh or
flatpak-portal/flatpak-spawn. The server runs inside the Steam Runtime
container and accepts commands over D-Bus; the client runs on the host
system, asks the server to run a command, and forwards its stdin, stdout
and stderr back to the host.
https://gitlab.steamos.cloud/steamrt/steamlinuxruntime/-/merge_requests/72
adds support for injecting commands into the SteamLinuxRuntime_soldier
compatibility tool (and any later version, such as sniper). However,
Steam compatibility tools are stackable: in particular, Proton runs in a
soldier container (or presumably sniper in future). If we are debugging
a Proton game, then ideally we will want to inject commands into Proton's
execution environment rather than soldier's, so that they run with the
correct environment variables etc. to communicate with a running Proton
session. In particular, it's important that the `WINEPREFIX` is correct.
The steam-runtime-launcher-interface-0 program implements the
interface for compatibility tools to use to decide where, if anywhere,
to launch the command server.
This commit does not alter the scripts produced by
PROTON_DUMP_DEBUG_COMMANDS. To run those scripts' commands in the
container environment, pass their filenames to
steam-runtime-launch-client.
Signed-off-by: Simon McVittie <smcv@collabora.com>
Link: https://github.com/ValveSoftware/Proton/pull/5891
2022-06-08 20:17:05 +03:00
|
|
|
argv = [g_proton.wine64_bin, "c:\\windows\\system32\\steam.exe"]
|
|
|
|
|
|
|
|
rc = self.run_proc(adverb + argv + sys.argv[2:] + self.cmdlineappend)
|
2018-01-25 22:22:24 +03:00
|
|
|
|
2021-06-24 12:54:08 +03:00
|
|
|
if remote_debug_proc:
|
|
|
|
remote_debug_proc.kill()
|
|
|
|
try:
|
|
|
|
remote_debug_proc.communicate(2)
|
|
|
|
except subprocess.TimeoutExpired as e:
|
|
|
|
log("terminate remote debugger")
|
|
|
|
remote_debug_proc.terminate()
|
|
|
|
remote_debug_proc.communicate()
|
2018-01-18 23:00:48 +03:00
|
|
|
|
2021-10-27 17:25:56 +03:00
|
|
|
return rc
|
|
|
|
|
2019-07-29 22:09:28 +03:00
|
|
|
if __name__ == "__main__":
|
|
|
|
if not "STEAM_COMPAT_DATA_PATH" in os.environ:
|
|
|
|
log("No compat data path?")
|
|
|
|
sys.exit(1)
|
|
|
|
|
|
|
|
g_proton = Proton(os.path.dirname(sys.argv[0]))
|
|
|
|
|
2020-05-12 12:12:38 +03:00
|
|
|
if g_proton.need_tarball_extraction():
|
|
|
|
g_proton.extract_tarball()
|
2019-07-29 22:09:28 +03:00
|
|
|
|
|
|
|
g_compatdata = CompatData(os.environ["STEAM_COMPAT_DATA_PATH"])
|
|
|
|
|
|
|
|
g_session = Session()
|
|
|
|
|
|
|
|
g_session.init_wine()
|
|
|
|
|
2020-05-12 12:12:38 +03:00
|
|
|
if g_proton.missing_default_prefix():
|
|
|
|
g_proton.make_default_prefix()
|
2019-07-29 22:09:28 +03:00
|
|
|
|
2021-05-12 01:07:14 +03:00
|
|
|
g_session.init_session(sys.argv[1] != "runinprefix")
|
2019-07-29 22:09:28 +03:00
|
|
|
|
|
|
|
#determine mode
|
2021-10-27 17:25:56 +03:00
|
|
|
rc = 0
|
2019-07-29 22:09:28 +03:00
|
|
|
if sys.argv[1] == "run":
|
|
|
|
#start target app
|
2022-01-07 00:52:13 +03:00
|
|
|
setup_game_dir_drive()
|
2022-03-11 19:10:42 +03:00
|
|
|
setup_steam_dir_drive()
|
2021-10-27 17:25:56 +03:00
|
|
|
rc = g_session.run()
|
2019-07-29 22:09:28 +03:00
|
|
|
elif sys.argv[1] == "waitforexitandrun":
|
|
|
|
#wait for wineserver to shut down
|
|
|
|
g_session.run_proc([g_proton.wineserver_bin, "-w"])
|
|
|
|
#then run
|
2021-10-27 17:25:56 +03:00
|
|
|
rc = g_session.run()
|
2021-05-12 01:07:14 +03:00
|
|
|
elif sys.argv[1] == "runinprefix":
|
2021-10-27 17:25:56 +03:00
|
|
|
rc = g_session.run_proc([g_proton.wine_bin] + sys.argv[2:])
|
2022-01-20 23:36:09 +03:00
|
|
|
elif sys.argv[1] == "destroyprefix":
|
|
|
|
g_compatdata.remove_tracked_files()
|
2019-07-29 22:09:28 +03:00
|
|
|
elif sys.argv[1] == "getcompatpath":
|
|
|
|
#linux -> windows path
|
|
|
|
path = subprocess.check_output([g_proton.wine_bin, "winepath", "-w", sys.argv[2]], env=g_session.env, stderr=g_session.log_file)
|
2020-01-06 17:21:54 +03:00
|
|
|
sys.stdout.buffer.write(path)
|
2019-07-29 22:09:28 +03:00
|
|
|
elif sys.argv[1] == "getnativepath":
|
|
|
|
#windows -> linux path
|
|
|
|
path = subprocess.check_output([g_proton.wine_bin, "winepath", sys.argv[2]], env=g_session.env, stderr=g_session.log_file)
|
2020-01-06 17:21:54 +03:00
|
|
|
sys.stdout.buffer.write(path)
|
2019-07-29 22:09:28 +03:00
|
|
|
else:
|
|
|
|
log("Need a verb.")
|
|
|
|
sys.exit(1)
|
|
|
|
|
2021-10-27 17:25:56 +03:00
|
|
|
sys.exit(rc)
|
2018-08-29 15:45:41 +03:00
|
|
|
|
2019-07-29 22:13:28 +03:00
|
|
|
#pylint --disable=C0301,C0326,C0330,C0111,C0103,R0902,C1801,R0914,R0912,R0915
|
2018-08-29 15:45:41 +03:00
|
|
|
# vim: set syntax=python:
|