Create Wine wrapper dir more robustly

Create Wine wrapper scripts under either `$XDG_RUNTIME_DIR` and
`$XDG_CACHE_DIR`, depending on which location permits executables.
`$XDG_RUNTIME_DIR` is preferred if available.

Prior to this, we always created the directory for the Wine wrapper
scripts under `$XDG_CACHE_DIR`. This can be problematic as sometimes the
mount point has the `noexec` mount flag set, causing any Wine calls to
crash later.

Note that we also need to set sticky bits for files under
`$XDG_RUNTIME_DIR` to avoid automatic cleanup per XDG spec. A quick
search indicates no distro implements this cleanup yet, though. There
also doesn't seem to be any harm unnecessarily setting this sticky bit
for files residing elsewhere, so just set it everywhere for simplicity's
sake.

Fixes #307

Author: Matoking

CHANGELOG.md

@@ -10,6 +10,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Changed
  - `protontricks -c` and `protontricks-launch` now use the current working directory instead of the game's installation directory. `--cwd-app` can be used to restore old behavior. Scripts can also `$STEAM_APP_PATH` environment variable to determine the game's installation directory; this has been supported (albeit undocumented) since 1.8.0.
+ - Protontricks will now prefer `XDG_RUNTIME_DIR` for storing Wine wrapper script and fall back to `XDG_CACHE_DIR` if it's not set
+
+### Fixed
+ - Fix Wine crash due to Protontricks not properly checking for execute permission
 
 ## [1.11.1] - 2024-02-20
 ### Fixed

src/protontricks/data/scripts/bwrap_launcher.sh

@@ -35,7 +35,7 @@ BLACKLISTED_ROOT_DIRS=(
 )
 
 ADDITIONAL_MOUNT_DIRS=(
-    /run/media "$PROTON_PATH" "$WINEPREFIX"
+    /run/media "$PROTON_PATH" "$WINEPREFIX" "$PROTONTRICKS_PROXY_DIR"
 )
 
 mount_dirs=()

src/protontricks/util.py

@@ -15,7 +15,7 @@
     "is_steam_deck", "get_legacy_runtime_library_paths",
     "get_host_library_paths", "RUNTIME_ROOT_GLOB_PATTERNS",
     "get_runtime_library_paths", "WINE_SCRIPT_TEMPLATE",
-    "get_cache_dir", "create_wine_bin_dir", "run_command"
+    "get_cache_dir", "get_script_dir", "create_wine_bin_dir", "run_command"
 )
 
 logger = logging.getLogger("protontricks")
@@ -176,58 +176,75 @@ def find_runtime_app_root(runtime_app):
 ).read_text(encoding="utf-8")
 
 
-def get_cache_dir():
+def is_dir_exec(path):
     """
-    Get Protontricks' cache directory, creating it first if it does not
-    exist
+    Check if the directory is under a mount that allows execute permission.
+
+    Checking for execute permission on the file itself does not suffice as
+    the file system can forbid executables using 'noexec' mount flag.
     """
-    def is_dir_exec(path):
-        """
-        Check if the directory is under a mount that allows execute permission
-        """
-        path_ = path
-        try:
-            while not path_.is_mount():
-                path_ = path_.parent
+    path_ = path
+    while not path_.is_mount():
+        path_ = path_.parent
 
-                if str(path_) == "/":
-                    raise OSError("Did not find mount point!")
+        if str(path_) == "/":
+            raise OSError("Did not find mount point!")
 
-            # Parse mount point information
-            mount_data = Path("/proc/mounts").read_text()
+    # Parse mount point information
+    mount_data = Path("/proc/mounts").read_text()
 
-            for line in mount_data.split("\n"):
-                _, mount_path, _, mount_flags, *_ = line.split(" ")
+    for line in mount_data.split("\n"):
+        _, mount_path, _, mount_flags, *_ = line.split(" ")
 
-                if mount_path == str(path_):
-                    mount_flags = mount_flags.split(",")
+        if mount_path == str(path_):
+            mount_flags = mount_flags.split(",")
 
-                    # If mount has 'noexec' flag, the shell executables won't work
-                    return "noexec" not in mount_flags
+            # If mount has 'noexec' flag, the shell executables won't work
+            return "noexec" not in mount_flags
 
-            logger.warning(f"Could not find mount point for {path}")
-            return True
-        except OSError as exc:
-            print(f"shit {exc}")
+    logger.warning(
+        f"Could not find mount point for {path}. Assuming directory "
+        "has execute permissions."
+    )
+    return True
 
+
+def get_cache_dir():
+    """
+    Get Protontricks' cache directory, creating it first if it does not
+    exist
+    """
+    xdg_cache_dir = os.environ.get(
+        "XDG_CACHE_HOME", os.path.expanduser("~/.cache")
+    )
+    base_path = Path(xdg_cache_dir) / "protontricks"
+    os.makedirs(str(base_path), exist_ok=True)
+
+    return base_path
+
+
+def get_script_dir():
+    """
+    Get Protontricks' Wine wrapper script directory, creating it first
+    if it does not exist
+    """
     candidates = []
 
     if os.environ.get("XDG_RUNTIME_DIR"):
         candidates.append(
-            Path(os.environ["XDG_RUNTIME_DIR"]) / "protontricks"
+            Path(os.environ["XDG_RUNTIME_DIR"]) / "protontricks" / "proton"
         )
 
-    xdg_cache_dir = os.environ.get(
-        "XDG_CACHE_HOME", os.path.expanduser("~/.cache")
-    )
-    candidates.append(Path(xdg_cache_dir) / "protontricks")
+    candidates.append(get_cache_dir() / "proton")
 
     logger.debug(
         f"Candidates for Wine wrapper script directories: {candidates}"
     )
 
     for candidate in candidates:
         if is_dir_exec(candidate):
+            candidate.mkdir(exist_ok=True, parents=True)
+
             logger.info(f"Using {candidate} as Wine wrapper directory")
             return candidate
 
@@ -246,7 +263,7 @@ def create_wine_bin_dir(proton_app, use_bwrap=True):
     binaries = list((proton_app.proton_dist_path / "bin").iterdir())
 
     # Create the base directory containing files for every Proton installation
-    base_path = get_cache_dir() / "proton"
+    base_path = get_script_dir()
     os.makedirs(str(base_path), exist_ok=True)
 
     # Create a directory to hold the new executables for the specific
@@ -277,8 +294,18 @@ def create_wine_bin_dir(proton_app, use_bwrap=True):
         proxy_script_path.write_text(content, encoding="utf-8")
 
         script_stat = proxy_script_path.stat()
-        # Make the helper script executable
-        proxy_script_path.chmod(script_stat.st_mode | stat.S_IEXEC)
+
+        # Make the helper script executable.
+        #
+        # Also set the sticky bit in case the file resides under
+        # `XDG_RUNTIME_DIR`, as automatic cleanup might take place otherwise.
+        # No distro seems to implement this at the moment, though. Sticky bit
+        # on files doesn't seem to have any other effect on modern systems,
+        # so it's no problem even if the proxy script resides under
+        # `XDG_CACHE_DIR` instead.
+        proxy_script_path.chmod(
+            script_stat.st_mode | stat.S_IEXEC | stat.S_ISVTX
+        )
 
     # Create the wineserver keepalive batch script
     (bin_path / "wineserver-keepalive.bat").write_text(
@@ -292,11 +319,18 @@ def create_wine_bin_dir(proton_app, use_bwrap=True):
         )
     )
     keepalive_shell_script.chmod(
-        keepalive_shell_script.stat().st_mode | stat.S_IEXEC
+        keepalive_shell_script.stat().st_mode | stat.S_IEXEC | stat.S_ISVTX
     )
+
     launcher_script = bin_path / "bwrap-launcher"
-    launcher_script.write_text(BWRAP_LAUNCHER_SH_SCRIPT)
-    launcher_script.chmod(launcher_script.stat().st_mode | stat.S_IEXEC)
+    launcher_script_data = BWRAP_LAUNCHER_SH_SCRIPT
+    launcher_script_data = launcher_script_data.replace(
+        "@@script_path@@", str(proxy_script_path)
+    )
+    launcher_script.write_text(launcher_script_data)
+    launcher_script.chmod(
+        launcher_script.stat().st_mode | stat.S_IEXEC | stat.S_ISVTX
+    )
 
     return bin_path
 
@@ -501,6 +535,7 @@ def run_command(
     # configuring the environment and Wine before launching the underlying
     # Wine binaries.
     wine_bin_dir = create_wine_bin_dir(proton_app)
+    wine_environ["PROTONTRICKS_PROXY_DIR"] = str(wine_bin_dir)
     wine_environ["LEGACY_STEAM_RUNTIME_PATH"] = str(legacy_steam_runtime_path)
     wine_environ["PATH"] = os.pathsep.join(
         [str(wine_bin_dir), wine_environ["PATH"]]

tests/conftest.py

@@ -30,6 +30,7 @@ def env_vars(monkeypatch):
     """
     monkeypatch.setenv("STEAM_RUNTIME", "")
     monkeypatch.delenv("XDG_CONFIG_HOME", raising=False)
+    monkeypatch.delenv("XDG_RUNTIME_DIR", raising=False)
 
 
 @pytest.fixture(scope="function", autouse=True)