488 lines
18 KiB
Python
Executable File
488 lines
18 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
#script to launch Wine with the correct environment
|
|
|
|
import fcntl
|
|
import array
|
|
import filecmp
|
|
import json
|
|
import os
|
|
import shutil
|
|
import errno
|
|
import subprocess
|
|
import sys
|
|
import tarfile
|
|
|
|
from filelock import FileLock
|
|
|
|
CURRENT_PREFIX_VERSION="5.8"
|
|
|
|
PFX="Proton: "
|
|
ld_path_var = "LD_LIBRARY_PATH"
|
|
|
|
def nonzero(s):
|
|
return len(s) > 0 and s != "0"
|
|
|
|
def log(msg):
|
|
sys.stderr.write(PFX + msg + os.linesep)
|
|
sys.stderr.flush()
|
|
|
|
def file_is_wine_fake_dll(path):
|
|
if not os.path.exists(path):
|
|
return False
|
|
try:
|
|
sfile = open(path, "rb")
|
|
sfile.seek(0x40)
|
|
tag = sfile.read(20)
|
|
return tag == b"Wine placeholder DLL"
|
|
except IOError:
|
|
return False
|
|
|
|
def makedirs(path):
|
|
try:
|
|
os.makedirs(path)
|
|
except OSError:
|
|
#already exists
|
|
pass
|
|
|
|
def try_copy(src, dst):
|
|
try:
|
|
if os.path.isdir(dst):
|
|
dstfile = dst + "/" + os.path.basename(src)
|
|
if os.path.lexists(dstfile):
|
|
os.remove(dstfile)
|
|
elif os.path.lexists(dst):
|
|
os.remove(dst)
|
|
shutil.copy(src, dst)
|
|
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
|
|
|
|
def real_copy(src, dst):
|
|
if os.path.islink(src):
|
|
os.symlink(os.readlink(src), dst)
|
|
else:
|
|
try_copy(src, dst)
|
|
|
|
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)
|
|
except OSError:
|
|
#no problem
|
|
pass
|
|
os.close(dr)
|
|
|
|
class Proton:
|
|
def __init__(self, base_dir):
|
|
self.base_dir = os.environ["STEAM_COMPAT_DATA_PATH"]
|
|
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/")
|
|
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"
|
|
self.wineserver_bin = self.bin_dir + "wineserver"
|
|
self.gamemoderun = "gamemoderun"
|
|
self.dist_lock = FileLock(self.path("dist.lock"), timeout=-1)
|
|
|
|
def path(self, d):
|
|
return self.base_dir + d
|
|
|
|
def make_default_prefix(self):
|
|
with self.dist_lock:
|
|
local_env = dict(g_session.env)
|
|
if not os.path.isdir(self.default_pfx_dir):
|
|
#make default prefix
|
|
local_env["WINEPREFIX"] = self.default_pfx_dir
|
|
local_env["WINEDEBUG"] = "-all"
|
|
g_session.run_proc([self.wine_bin, "wineboot"], local_env)
|
|
g_session.run_proc([self.wineserver_bin, "-w"], local_env)
|
|
|
|
class CompatData:
|
|
def __init__(self, compatdata):
|
|
self.base_dir = os.environ["STEAM_COMPAT_DATA_PATH"]
|
|
self.prefix_dir = self.path("pfx/")
|
|
self.version_file = self.path("version")
|
|
self.tracked_files_file = self.path("tracked_files")
|
|
# if "PW_FILELOCK" in os.environ and nonzero(os.environ["PW_FILELOCK"]):
|
|
self.prefix_lock = FileLock(self.path("pfx.lock"), timeout=-1)
|
|
|
|
def path(self, d):
|
|
return self.base_dir + d
|
|
|
|
def remove_tracked_files(self):
|
|
if not os.path.exists(self.tracked_files_file):
|
|
log("Prefix has no tracked_files??")
|
|
return
|
|
|
|
with open(self.tracked_files_file, "r") as tracked_files:
|
|
dirs = []
|
|
for f in tracked_files:
|
|
path = self.prefix_dir + f.strip()
|
|
if os.path.exists(path):
|
|
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
|
|
|
|
os.remove(self.tracked_files_file)
|
|
os.remove(self.version_file)
|
|
|
|
def upgrade_pfx(self, old_ver):
|
|
if old_ver == CURRENT_PREFIX_VERSION:
|
|
return
|
|
|
|
#replace broken .NET installations with wine-mono support
|
|
if os.path.exists(self.prefix_dir + "/drive_c/windows/Microsoft.NET/NETFXRepair.exe") and \
|
|
file_is_wine_fake_dll(self.prefix_dir + "/drive_c/windows/system32/mscoree.dll"):
|
|
log("Broken .NET installation detected, switching to wine-mono.")
|
|
#deleting this directory allows wine-mono to work
|
|
shutil.rmtree(self.prefix_dir + "/drive_c/windows/Microsoft.NET")
|
|
|
|
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)
|
|
if not os.path.exists(dst_dir):
|
|
os.makedirs(dst_dir)
|
|
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_)
|
|
if os.path.islink(src_file) and not os.path.exists(dst_file):
|
|
real_copy(src_file, dst_file)
|
|
for file_ in files:
|
|
src_file = os.path.join(src_dir, file_)
|
|
dst_file = os.path.join(dst_dir, file_)
|
|
if not os.path.exists(dst_file):
|
|
real_copy(src_file, dst_file)
|
|
tracked_files.write(rel_dir + file_ + "\n")
|
|
|
|
def create_fonts_symlinks(self):
|
|
fontsmap = [
|
|
( "LiberationSans-Regular.ttf", "arial.ttf" ),
|
|
( "LiberationSans-Bold.ttf", "arialbd.ttf" ),
|
|
( "LiberationSerif-Regular.ttf", "times.ttf" ),
|
|
( "LiberationMono-Regular.ttf", "cour.ttf" ),
|
|
( "SourceHanSansSCRegular.otf", "msyh.ttf" ),
|
|
]
|
|
|
|
windowsfonts = self.prefix_dir + "/drive_c/windows/Fonts"
|
|
makedirs(windowsfonts)
|
|
for p in fontsmap:
|
|
lname = os.path.join(windowsfonts, p[1])
|
|
fname = os.path.join(g_proton.fonts_dir, p[0])
|
|
if os.path.lexists(lname):
|
|
if os.path.islink(lname):
|
|
os.remove(lname)
|
|
os.symlink(fname, lname)
|
|
else:
|
|
os.symlink(fname, lname)
|
|
|
|
def setup_prefix(self):
|
|
with self.prefix_lock:
|
|
if os.path.exists(self.version_file):
|
|
with open(self.version_file, "r") as f:
|
|
self.upgrade_pfx(f.readline().strip())
|
|
else:
|
|
self.upgrade_pfx(None)
|
|
|
|
if not os.path.exists(self.prefix_dir):
|
|
makedirs(self.prefix_dir + "/drive_c")
|
|
set_dir_casefold_bit(self.prefix_dir + "/drive_c")
|
|
|
|
if not os.path.exists(self.prefix_dir + "/user.reg"):
|
|
self.copy_pfx()
|
|
|
|
with open(self.version_file, "w") as f:
|
|
f.write(CURRENT_PREFIX_VERSION + "\n")
|
|
|
|
#create font files symlinks
|
|
self.create_fonts_symlinks()
|
|
|
|
if "wined3d" in g_session.compat_config:
|
|
dxvkfiles = ["dxvk_config"]
|
|
wined3dfiles = ["d3d11", "d3d10", "d3d10core", "d3d10_1", "d3d9"]
|
|
else:
|
|
dxvkfiles = ["dxvk_config", "d3d11", "d3d10", "d3d10core", "d3d10_1", "d3d9"]
|
|
wined3dfiles = []
|
|
|
|
#if the user asked for dxvk's dxgi (dxgi=n), then copy it into place
|
|
if "PW_DXGI_FOR_VKD3D" in os.environ and nonzero(os.environ["PW_DXGI_FOR_VKD3D"]):
|
|
wined3dfiles.append("dxgi") #VKD3D
|
|
else:
|
|
dxvkfiles.append("dxgi") #OPENGL and DXVK
|
|
|
|
for f in wined3dfiles:
|
|
try_copy(g_proton.default_pfx_dir + "drive_c/windows/system32/" + f + ".dll",
|
|
self.prefix_dir + "drive_c/windows/system32/" + f + ".dll")
|
|
try_copy(g_proton.default_pfx_dir + "drive_c/windows/syswow64/" + f + ".dll",
|
|
self.prefix_dir + "drive_c/windows/syswow64/" + f + ".dll")
|
|
|
|
for f in dxvkfiles:
|
|
try_copy(g_proton.lib64_dir + "wine/dxvk/" + f + ".dll",
|
|
self.prefix_dir + "drive_c/windows/system32/" + f + ".dll")
|
|
try_copy(g_proton.lib_dir + "wine/dxvk/" + f + ".dll",
|
|
self.prefix_dir + "drive_c/windows/syswow64/" + f + ".dll")
|
|
g_session.dlloverrides[f] = "n"
|
|
|
|
def comma_escaped(s):
|
|
escaped = False
|
|
idx = -1
|
|
while s[idx] == '\\':
|
|
escaped = not escaped
|
|
idx = idx - 1
|
|
return escaped
|
|
|
|
class Session:
|
|
def __init__(self):
|
|
self.log_file = None
|
|
self.env = dict(os.environ)
|
|
self.dlloverrides = {
|
|
"steam.exe": "n"
|
|
}
|
|
|
|
self.compat_config = set()
|
|
self.cmdlineappend = []
|
|
|
|
if "STEAM_COMPAT_CONFIG" in os.environ:
|
|
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)
|
|
|
|
#turn forcelgadd on by default unless it is disabled in compat config
|
|
if not "noforcelgadd" in self.compat_config:
|
|
self.compat_config.add("forcelgadd")
|
|
|
|
def init_wine(self):
|
|
if "HOST_LC_ALL" in self.env and len(self.env["HOST_LC_ALL"]) > 0:
|
|
#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.
|
|
self.env["LC_ALL"] = self.env["HOST_LC_ALL"]
|
|
else:
|
|
self.env.pop("LC_ALL", "")
|
|
|
|
self.env.pop("WINEARCH", "")
|
|
|
|
if ld_path_var in os.environ:
|
|
self.env[ld_path_var] = g_proton.lib64_dir + ":" + g_proton.lib_dir + ":" + os.environ[ld_path_var]
|
|
else:
|
|
self.env[ld_path_var] = g_proton.lib64_dir + ":" + g_proton.lib_dir
|
|
|
|
self.env["WINEDLLPATH"] = g_proton.lib64_dir + "/wine:" + g_proton.lib_dir + "/wine"
|
|
|
|
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/")
|
|
|
|
if "PATH" in os.environ:
|
|
self.env["PATH"] = g_proton.bin_dir + ":" + os.environ["PATH"]
|
|
else:
|
|
self.env["PATH"] = g_proton.bin_dir
|
|
|
|
def check_environment(self, env_name, config_name):
|
|
if not env_name in self.env:
|
|
return False
|
|
if nonzero(self.env[env_name]):
|
|
self.compat_config.add(config_name)
|
|
else:
|
|
self.compat_config.discard(config_name)
|
|
return True
|
|
|
|
def init_session(self):
|
|
self.env["WINEPREFIX"] = g_compatdata.prefix_dir
|
|
|
|
if "PW_LOG" in os.environ and nonzero(os.environ["PW_LOG"]):
|
|
self.env.setdefault("WINEDEBUG", "fixme-all")
|
|
self.env.setdefault("DXVK_LOG_LEVEL", "info")
|
|
self.env.setdefault("VKD3D_DEBUG", "warn")
|
|
self.env.setdefault("WINE_MONO_TRACE", "E:System.NotImplementedException")
|
|
|
|
#for performance, logging is disabled by default; override with user_settings.py
|
|
self.env.setdefault("WINEDEBUG", "-all")
|
|
self.env.setdefault("DXVK_LOG_LEVEL", "none")
|
|
self.env.setdefault("VKD3D_DEBUG", "none")
|
|
|
|
#default wine-mono override for FNA games
|
|
self.env.setdefault("WINE_MONO_OVERRIDES", "Microsoft.Xna.Framework.*,Gac=n")
|
|
|
|
if "wined3d11" in self.compat_config:
|
|
self.compat_config.add("wined3d")
|
|
|
|
if not self.check_environment("PW_USE_WINED3D", "wined3d"):
|
|
self.check_environment("PW_USE_WINED3D11", "wined3d")
|
|
self.check_environment("PW_NO_D3D11", "nod3d11")
|
|
self.check_environment("PW_NO_D3D10", "nod3d10")
|
|
self.check_environment("PW_NO_D9VK", "nod3d9")
|
|
self.check_environment("PW_NO_ESYNC", "noesync")
|
|
self.check_environment("PW_NO_FSYNC", "nofsync")
|
|
self.check_environment("PW_FORCE_LARGE_ADDRESS_AWARE", "forcelgadd")
|
|
self.check_environment("PW_OLD_GL_STRING", "oldglstr")
|
|
self.check_environment("PW_USE_SECCOMP", "seccomp")
|
|
self.check_environment("PW_NO_VR", "novrclient")
|
|
self.check_environment("PW_NO_WINEMFPLAY", "nomfplay")
|
|
self.check_environment("PW_NO_WRITE_WATCH", "nowritewatch")
|
|
self.check_environment("PW_DXVK_ASYNC", "dxvkasync")
|
|
self.check_environment("PW_NVAPI_DISABLE", "nonvapi")
|
|
self.check_environment("PW_WINEDBG_DISABLE", "nowinedbg")
|
|
self.check_environment("PW_PULSE_LOWLATENCY", "pulselowlat")
|
|
|
|
if not "noesync" in self.compat_config:
|
|
self.env["WINEESYNC"] = "1"
|
|
|
|
if not "nofsync" in self.compat_config:
|
|
self.env["WINEFSYNC"] = "1"
|
|
|
|
if "seccomp" in self.compat_config:
|
|
self.env["WINESECCOMP"] = "1"
|
|
|
|
if "oldglstr" in self.compat_config:
|
|
#mesa override
|
|
self.env["MESA_EXTENSION_MAX_YEAR"] = "2003"
|
|
#nvidia override
|
|
self.env["__GL_ExtensionStringVersion"] = "17700"
|
|
|
|
if "forcelgadd" in self.compat_config:
|
|
self.env["WINE_LARGE_ADDRESS_AWARE"] = "1"
|
|
|
|
if "dxvkasync" in self.compat_config:
|
|
self.env["DXVK_ASYNC"] = "1"
|
|
|
|
if "pulselowlat" in self.compat_config:
|
|
self.env["PULSE_LATENCY_MSEC"] = "60"
|
|
|
|
g_compatdata.setup_prefix()
|
|
|
|
if "nod3d11" in self.compat_config:
|
|
self.dlloverrides["d3d11"] = ""
|
|
if "dxgi" in self.dlloverrides:
|
|
del self.dlloverrides["dxgi"]
|
|
|
|
if "nod3d10" in self.compat_config:
|
|
self.dlloverrides["d3d10_1"] = ""
|
|
self.dlloverrides["d3d10"] = ""
|
|
self.dlloverrides["dxgi"] = ""
|
|
|
|
if "nod3d9" in self.compat_config:
|
|
self.dlloverrides["d3d9"] = ""
|
|
|
|
if "novrclient" in self.compat_config:
|
|
self.dlloverrides["vrclient"] = ""
|
|
self.dlloverrides["vrclient_x64"] = ""
|
|
self.dlloverrides["openvr_api_dxvk"] = ""
|
|
|
|
if "nomfplay" in self.compat_config:
|
|
self.dlloverrides["mfplay"] = "n"
|
|
|
|
if "nowritewatch" in self.compat_config:
|
|
self.env["WINE_DISABLE_WRITE_WATCH"] = "1"
|
|
|
|
if "nonvapi" in self.compat_config:
|
|
self.dlloverrides["nvapi"] = "d"
|
|
self.dlloverrides["nvapi64"] = "d"
|
|
|
|
if "nowinedbg" in self.compat_config:
|
|
self.dlloverrides["winedbg.exe"] = "d"
|
|
|
|
s = ""
|
|
for dll in self.dlloverrides:
|
|
setting = self.dlloverrides[dll]
|
|
if len(s) > 0:
|
|
s = s + ";" + dll + "=" + setting
|
|
else:
|
|
s = dll + "=" + setting
|
|
|
|
if "WINEDLLOVERRIDES" in os.environ:
|
|
self.env["WINEDLLOVERRIDES"] = os.environ["WINEDLLOVERRIDES"] + ";" + s
|
|
else:
|
|
self.env["WINEDLLOVERRIDES"] = s
|
|
|
|
def run_proc(self, args, local_env=None):
|
|
if local_env is None:
|
|
local_env = self.env
|
|
subprocess.call(args, env=local_env)
|
|
|
|
def run(self):
|
|
if "PW_GAMEMODERUN" in os.environ and nonzero(os.environ["PW_GAMEMODERUN"]):
|
|
self.run_proc([g_proton.gamemoderun] + [g_proton.wine_bin] + sys.argv[2:] + sys.argv[3:])
|
|
else:
|
|
self.run_proc([g_proton.wine_bin] + sys.argv[2:] + sys.argv[3:])
|
|
|
|
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]))
|
|
|
|
g_compatdata = CompatData(os.environ["STEAM_COMPAT_DATA_PATH"])
|
|
|
|
g_session = Session()
|
|
|
|
g_session.init_wine()
|
|
|
|
g_proton.make_default_prefix()
|
|
|
|
g_session.init_session()
|
|
|
|
#determine mode
|
|
if sys.argv[1] == "run":
|
|
#start target app
|
|
g_session.run()
|
|
elif sys.argv[1] == "waitforexitandrun":
|
|
#wait for wineserver to shut down
|
|
g_session.run_proc([g_proton.wineserver_bin, "-w"])
|
|
#then run
|
|
g_session.run()
|
|
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)
|
|
sys.stdout.buffer.write(path)
|
|
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)
|
|
sys.stdout.buffer.write(path)
|
|
else:
|
|
log("Need a verb.")
|
|
sys.exit(1)
|
|
|
|
sys.exit(0)
|
|
|
|
#pylint --disable=C0301,C0326,C0330,C0111,C0103,R0902,C1801,R0914,R0912,R0915
|
|
# vim: set syntax=python:
|