From bda32419bd93f23d94c992f61473d5508fba3e39 Mon Sep 17 00:00:00 2001 From: DuBearte <130190089+DuBearte@users.noreply.github.com> Date: Sun, 25 Oct 2026 01:56:01 +0000 Subject: [PATCH] Windows: a stuck icacls no longer freezes SolidCraft when it writes the control token (#6145) (#6182) * claim: #6145 * Windows: a stuck icacls no longer freezes SolidCraft when it writes the control token (#6145) Writing the control token runs icacls to drop the file's inherited permissions, and waited for it without a limit. On some computers the new icacls process stays suspended, so connecting an agent froze the app for good. It now waits at most 5 s; an icacls still running then is ended and the token written anyway, into the user's own local app data folder. Co-Authored-By: Claude Opus 5.5 --------- Co-authored-by: Claude Opus 5.5 --- crates/engine/src/control_auth.rs | 52 ++++++++++++++++++++++++++++--- 1 file changed, 48 insertions(+), 4 deletions(-) diff --git a/crates/engine/src/control_auth.rs b/crates/engine/src/control_auth.rs index 125fca8ed..43b624b2a 100644 --- a/crates/engine/src/control_auth.rs +++ b/crates/engine/src/control_auth.rs @@ -295,21 +295,50 @@ pub fn remove_token_file(path: &Path) { let _ = std::fs::remove_file(pid_path(path)); } -/// Windows: drop inherited entries and grant only the current user full access. +/// How long `icacls` may take (#6145). It finishes at once; on some computers the new process +/// is left suspended (security software holding it), and waiting on it without a limit froze +/// the app. +#[cfg(windows)] +const ICACLS_LIMIT: std::time::Duration = std::time::Duration::from_secs(5); + +/// Windows: drop inherited entries and grant only the current user full access. An `icacls` +/// that doesn't finish in time is ended and the file kept as made: it is in the user's own +/// local app data folder, which other users can't read by default. #[cfg(windows)] fn restrict_to_user(path: &Path) -> Result<()> { use std::os::windows::process::CommandExt; let user = std::env::var("USERNAME").map_err(|_| Error::other("USERNAME is not set"))?; let domain = std::env::var("USERDOMAIN").ok().filter(|d| !d.is_empty()); let who = domain.map_or(user.clone(), |d| format!("{d}\\{user}")); - let status = std::process::Command::new("icacls") + let child = std::process::Command::new("icacls") .arg(path) .args(["/inheritance:r", "/grant:r", &format!("{who}:F")]) .stdout(std::process::Stdio::null()) .stderr(std::process::Stdio::null()) .creation_flags(0x0800_0000) - .status()?; - if status.success() { Ok(()) } else { Err(Error::other(format!("icacls failed to restrict {}", path.display()))) } + .spawn()?; + match wait_within(child, ICACLS_LIMIT)? { + Some(status) if !status.success() => Err(Error::other(format!("icacls failed to restrict {}", path.display()))), + _ => Ok(()), + } +} + +/// Wait for `child` at most `limit`: its exit status, or `None` (and the child ended) when it +/// hasn't finished by then. +#[cfg(any(windows, test))] +fn wait_within(mut child: std::process::Child, limit: std::time::Duration) -> Result> { + let start = std::time::Instant::now(); + loop { + if let Some(status) = child.try_wait()? { + return Ok(Some(status)); + } + if start.elapsed() >= limit { + // Not waited for afterwards: a suspended process may not end at once. + let _ = child.kill(); + return Ok(None); + } + std::thread::sleep(std::time::Duration::from_millis(20)); + } } /// Removes the token file when the app ends. @@ -325,6 +354,21 @@ impl Drop for TokenFile { mod tests { use super::*; + /// #6145: a child that doesn't finish in time is given up on, not waited for forever. + #[cfg(unix)] + #[test] + fn a_slow_child_is_waited_for_only_so_long() { + use std::time::{Duration, Instant}; + let start = Instant::now(); + let slow = std::process::Command::new("sleep").arg("30").spawn().unwrap(); + assert!(wait_within(slow, Duration::from_millis(200)).unwrap().is_none()); + assert!(start.elapsed() < Duration::from_secs(5), "{:?}", start.elapsed()); + let quick = std::process::Command::new("true").spawn().unwrap(); + assert!(wait_within(quick, Duration::from_secs(5)).unwrap().is_some_and(|s| s.success())); + let failing = std::process::Command::new("false").spawn().unwrap(); + assert!(wait_within(failing, Duration::from_secs(5)).unwrap().is_some_and(|s| !s.success())); + } + #[test] fn tokens_compare_whole() { assert!(tokens_match("abc123", "abc123"));