feat: single-instance lock and detached background child

src/detach.rs

@@ -0,0 +1,71 @@
+use std::fs::File;
+use std::io;
+
+use anyhow::{Context, Result};
+
+use crate::lock::Lock;
+
+/// Runs `work` in a forked child that outlives valw, like `wl-copy` does.
+/// The parent returns right away.
+///
+/// The child drops the capture lock (so the next capture isn't blocked) and
+/// points stdio at /dev/null (so `valw ... -o - | x` sees EOF without waiting
+/// for the clipboard to be replaced).
+pub fn spawn(lock: Lock, work: impl FnOnce()) -> Result<()> {
+    lock.release();
+    // SAFETY: valw is single-threaded at this point, and the child only
+    // touches its own state before exiting with _exit.
+    match unsafe { libc::fork() } {
+        -1 => Err(io::Error::last_os_error()).context("could not fork the clipboard server"),
+        0 => {
+            let _ = rustix::process::setsid();
+            let _ = detach_stdio();
+            work();
+            // SAFETY: skips atexit handlers and destructors that belong to the parent.
+            unsafe { libc::_exit(0) }
+        }
+        _ => Ok(()),
+    }
+}
+
+fn detach_stdio() -> io::Result<()> {
+    let null = File::options().read(true).write(true).open("/dev/null")?;
+    rustix::stdio::dup2_stdin(&null)?;
+    rustix::stdio::dup2_stdout(&null)?;
+    rustix::stdio::dup2_stderr(&null)?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn child_holds_neither_lock_nor_stdio() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("valw.lock");
+        let lock = Lock::acquire(&path).unwrap();
+        let (report_r, report_w) = rustix::pipe::pipe().unwrap();
+        let (go_r, go_w) = rustix::pipe::pipe().unwrap();
+
+        spawn(lock, move || {
+            // Report whether stdout is /dev/null, then wait for the parent.
+            let null = rustix::fs::stat("/dev/null").unwrap();
+            let out = rustix::fs::fstat(rustix::stdio::stdout()).unwrap();
+            let is_null = out.st_rdev == null.st_rdev && out.st_ino == null.st_ino;
+            rustix::io::write(&report_w, &[is_null as u8]).unwrap();
+            let _ = rustix::io::read(&go_r, &mut [0u8; 1]);
+        })
+        .unwrap();
+
+        // The child is still running, yet the lock is free.
+        Lock::acquire(&path).unwrap();
+
+        let mut is_null = [0u8; 1];
+        rustix::io::read(&report_r, &mut is_null).unwrap();
+        assert_eq!(is_null, [1], "child stdout should be /dev/null");
+
+        // Closing our end lets the child exit.
+        drop(go_w);
+    }
+}