#!/usr/bin/env python3 #script to launch Wine with the correct environment import fcntl import array import filecmp import fnmatch import json import os import shutil import errno import stat import subprocess import sys import tarfile from filelock import FileLock #To enable debug logging, copy "user_settings.sample.py" to "user_settings.py" #and edit it if needed. CURRENT_PREFIX_VERSION="5.13-1" 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 log(msg): sys.stderr.write(PFX + msg + os.linesep) sys.stderr.flush() def file_is_wine_builtin_dll(path): if os.path.islink(path): contents = os.readlink(path) if os.path.dirname(contents).endswith(('/lib/wine', '/lib/wine/fakedlls', '/lib64/wine', '/lib64/wine/fakedlls')): # This may be a broken link to a dll in a removed Proton install return True if not os.path.exists(path): return False try: sfile = open(path, "rb") sfile.seek(0x40) tag = sfile.read(20) return tag.startswith((b"Wine placeholder DLL", b"Wine builtin DLL")) except IOError: return False def makedirs(path): try: os.makedirs(path) except OSError: #already exists pass def try_copy(src, dst, add_write_perm=True): try: if os.path.isdir(dst): dstfile = dst + "/" + os.path.basename(src) if os.path.lexists(dstfile): os.remove(dstfile) else: dstfile = dst if os.path.lexists(dst): os.remove(dst) shutil.copy(src, dst) if add_write_perm: new_mode = os.lstat(dstfile).st_mode | stat.S_IWUSR | stat.S_IWGRP os.chmod(dstfile, new_mode) 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 try_copyfile(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.copyfile(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 getmtimestr(*path_fragments): path = os.path.join(*path_fragments) try: return str(os.path.getmtime(path)) except IOError: return "0" 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 pfx_copy(self, src, dst, dll_copy=False): if os.path.islink(src): contents = os.readlink(src) if os.path.dirname(contents).endswith(('/lib/wine', '/lib/wine/fakedlls', '/lib64/wine', '/lib64/wine/fakedlls')): # wine builtin dll # make the destination an absolute symlink contents = os.path.normpath(os.path.join(os.path.dirname(src), contents)) if dll_copy: try_copyfile(src, dst) else: os.symlink(contents, dst) else: try_copyfile(src, dst) 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): self.pfx_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): self.pfx_copy(src_file, dst_file) tracked_files.write(rel_dir + file_ + "\n") def update_builtin_libs(self, dll_copy_patterns): dll_copy_patterns = dll_copy_patterns.split(',') 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) if not os.path.exists(dst_dir): os.makedirs(dst_dir) 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) elif os.path.lexists(dst_file): # builtin library was replaced continue else: os.makedirs(dst_dir, exist_ok=True) dll_copy = any(fnmatch.fnmatch(file_, pattern) for pattern in dll_copy_patterns) self.pfx_copy(src_file, dst_file, dll_copy) tracked_name = rel_dir + file_ if tracked_name not in prev_tracked_files: tracked_files.write(tracked_name + "\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 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() builtin_dll_copy = os.environ.get("PROTON_DLL_COPY", #dxsetup redist "d3dcompiler_*.dll," + "d3dcsx*.dll," + "d3dx*.dll," + "x3daudio*.dll," + "xactengine*.dll," + "xapofx*.dll," + "xaudio*.dll," + "xinput*.dll," + #vcruntime redist "atl1*.dll," + "concrt1*.dll," + "msvcp1*.dll," + "msvcr1*.dll," + "vcamp1*.dll," + "vcomp1*.dll," + "vccorlib1*.dll," + "vcruntime1*.dll," + #some games balk at ntdll symlink(?) "ntdll.dll," + #some games require official vulkan loader "vulkan-1.dll" ) 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_NATIVE" in os.environ and "1" in os.environ["PW_DXGI_NATIVE"]: dxvkfiles.append("dxgi") else: wined3dfiles.append("dxgi") 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" try_copy(g_proton.lib64_dir + "wine/vkd3d-proton/d3d12.dll", self.prefix_dir + "drive_c/windows/system32/d3d12.dll") try_copy(g_proton.lib_dir + "wine/vkd3d-proton/d3d12.dll", self.prefix_dir + "drive_c/windows/syswow64/d3d12.dll") 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", "steam": "n", "steam_api": "n", "steam_api64": "n", "steamclient": "n", "steamclient64": "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("/tmp/gstreamer-1.0/") if "PW_COMPAT_MEDIA_PATH" in os.environ: self.env["MEDIACONV_AUDIO_DUMP_FILE"] = os.environ["PW_COMPAT_MEDIA_PATH"] + "/tmp/audio.foz" self.env["MEDIACONV_AUDIO_TRANSCODED_FILE"] = os.environ["PW_COMPAT_MEDIA_PATH"] + "/tmp/transcoded_audio.foz" self.env["MEDIACONV_VIDEO_DUMP_FILE"] = os.environ["PW_COMPAT_MEDIA_PATH"] + "/tmp/video.foz" self.env["MEDIACONV_VIDEO_TRANSCODED_FILE"] = os.environ["PW_COMPAT_MEDIA_PATH"] + "/tmp/transcoded_video.foz" 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_D3D12", "nod3d12") self.check_environment("PW_NO_D3D11", "nod3d11") self.check_environment("PW_NO_D3D10", "nod3d10") self.check_environment("PW_NO_D3D9", "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 "nod3d12" in self.compat_config: self.dlloverrides["d3d12"] = "" 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"] = "" self.dlloverrides["dxgi"] = "" 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: