Merge pull request 'Edition-2024 follow-up: the three gates only the PR's own CI could reach' (#180) from worktree-edition-2024 into main

clients/linux/src/app.rs

@@ -870,6 +870,23 @@ fn deliver_deep_link(url: String) {
     }
 }
 
+/// The crate's one runtime env mutation, isolated so `main.rs`'s `deny(unsafe_code)` covers
+/// everything else and the exemption is a named function rather than a whole call site.
+#[allow(unsafe_code)]
+fn clear_steam_sdl_device_filter() {
+    for var in [
+        "SDL_GAMECONTROLLER_IGNORE_DEVICES",
+        "SDL_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT",
+    ] {
+        if let Ok(v) = std::env::var(var) {
+            tracing::info!(var, value = %v, "clearing Steam's SDL device filter");
+            // SAFETY: called at the top of `run()`, before GTK init or any other thread
+            // exists in this process — nothing reads the environment concurrently.
+            unsafe { std::env::remove_var(var) };
+        }
+    }
+}
+
 pub fn run() -> glib::ExitCode {
     tracing_subscriber::fmt()
         .with_env_filter(
@@ -879,17 +896,7 @@ pub fn run() -> glib::ExitCode {
     // Steam launches its shortcuts with SDL_GAMECONTROLLER_IGNORE_DEVICES naming every
     // physical pad Steam Input has virtualized; the Settings controller list needs the
     // real devices (same rationale as the session binary).
-    for var in [
-        "SDL_GAMECONTROLLER_IGNORE_DEVICES",
-        "SDL_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT",
-    ] {
-        if let Ok(v) = std::env::var(var) {
-            tracing::info!(var, value = %v, "clearing Steam's SDL device filter");
-            // SAFETY: top of `run()`, before GTK init or any other thread exists in this
-            // process — nothing reads the environment concurrently.
-            unsafe { std::env::remove_var(var) };
-        }
-    }
+    clear_steam_sdl_device_filter();
     // Headless paths (no GTK window).
     if let Some(pin) = crate::cli::arg_value("--pair") {
         return crate::cli::headless_pair(&pin);

clients/linux/src/main.rs

@@ -3,7 +3,10 @@
 //! Hosts, pairing/trust, settings, and the desktop library page; every stream (and the
 //! console game library) runs in the spawned `punktfunk-session` Vulkan binary — the
 //! shell never touches video (punktfunk-planning `linux-client-rearchitecture.md`).
-#![forbid(unsafe_code)]
+// `deny`, not `forbid`, since edition 2024: clearing Steam's SDL device filter and the spawn
+// test's `HOME` scoping mutate the process env, which is now an unsafe call. Both carry a named
+// `#[allow(unsafe_code)]` with the proof at the site; everything else stays compiler-refused.
+#![deny(unsafe_code)]
 
 // The UI-agnostic plumbing lives in `pf-client-core`, shared with the session binary.
 // Root re-exports keep every `crate::trust`-style path resolving unchanged.

clients/linux/src/spawn.rs

@@ -128,6 +128,8 @@ mod tests {
     /// that is merely capped. One test, one `HOME` — the stores are read from it, so this
     /// deliberately does not split into several that would race over the same env var.
     #[test]
+    // The crate's one test env mutation (the `HOME` scoping below) — see main.rs's deny note.
+    #[allow(unsafe_code)]
     fn the_plan_carries_resolved_settings_not_defaults() {
         use pf_client_core::profiles::{ProfilesFile, SettingsOverlay, StreamProfile};
         use pf_client_core::trust::{KnownHost, KnownHosts, Settings};

crates/pf-win-display/src/adl_emul.rs

@@ -222,13 +222,16 @@ struct Adl {
 /// out-pointers and expects the app to own them.
 unsafe extern "C" fn adl_malloc(size: i32) -> *mut c_void {
     let size = size.max(1) as usize;
+    // Panic-free: a panic here would cross the extern boundary and abort the host. The Err arm
+    // is unreachable in practice (size ≤ i32::MAX can't overflow the layout), and ADL treats a
+    // null from its allocator as an ordinary failure.
+    let Ok(layout) = std::alloc::Layout::from_size_align(size, 16) else {
+        return std::ptr::null_mut();
+    };
     // SAFETY: non-zero size with a fixed valid alignment; the resulting buffers are deliberately
     // never freed — ADL's contract wants an ADL_Main_Memory_Free symmetry, and leaking the <1 KiB
     // of board-layout arrays in a one-shot probe is simpler than proving allocator parity.
-    unsafe {
-        std::alloc::alloc(std::alloc::Layout::from_size_align(size, 16).expect("tiny ADL alloc"))
-            as *mut c_void
-    }
+    unsafe { std::alloc::alloc(layout) as *mut c_void }
 }
 
 impl Adl {

crates/punktfunk-host/src/main.rs

@@ -57,8 +57,8 @@ mod gamestream;
 mod gpuclocks;
 mod hooks;
 // Network-facing on the secure default host (see the forbid block at `mod mgmt` below). Test
-// builds carve out like `native`: the identity tests scope `PUNKTFUNK_CONFIG_DIR` via
-// `env::set_var`, which edition 2024 makes an unsafe fn; shipped code keeps the forbid.
+// builds carve out like `native`: the identity tests scope `PUNKTFUNK_CONFIG_DIR` by mutating
+// the process env, which edition 2024 makes an unsafe call; shipped code keeps the forbid.
 #[cfg_attr(not(test), forbid(unsafe_code))]
 mod identity;
 // The input-injection backends live in the `pf-inject` subsystem crate (plan §W6); this shim keeps
@@ -84,8 +84,8 @@ mod log_capture;
 // here means a future edit cannot quietly introduce unsafe into a network-facing module.
 // (`native` carves out its `#[cfg(test)]` C-ABI roundtrip tests, which exercise the CLIENT
 // side of punktfunk-core against this host in-process and are unsafe by nature; `mgmt` and
-// `identity` carve out test builds too — their tests scope `PUNKTFUNK_CONFIG_DIR` via
-// `env::set_var`, an unsafe fn since edition 2024.)
+// `identity` carve out test builds too — their tests scope `PUNKTFUNK_CONFIG_DIR` by mutating
+// the process env, an unsafe call since edition 2024.)
 #[cfg_attr(not(test), forbid(unsafe_code))]
 mod mgmt;
 #[forbid(unsafe_code)]