refactor(fspy): return resolved paths without callbacks

Co-authored-by: GPT-5 Codex <codex@openai.com>

Author: wan9chi

crates/fspy_preload_unix/src/client/convert.rs

@@ -7,17 +7,20 @@ use libc::{c_char, c_int};
 use sigsafe::{AsRawFd as _, BorrowedFd, CWD};
 
 #[cfg(target_os = "linux")]
-fn get_fd_path<A: Allocator>(allocator: A, fd: BorrowedFd<'_>) -> nix::Result<Option<Vec<u8, A>>> {
+fn get_fd_path<'a, A: Allocator>(
+    allocator: &'a A,
+    fd: BorrowedFd<'_>,
+) -> nix::Result<Option<&'a BStr>> {
     if fd.as_raw_fd() == CWD.as_raw_fd() {
         let path = sigsafe_alloc::fs::getcwd(allocator)
             .map_err(|errno| nix::errno::Errno::from_raw(errno.raw_os_error()))?
             .into_bytes();
-        return Ok(Some(path));
+        return Ok(Some(path.leak().as_bstr()));
     }
     let mut path = [0; PROC_FD_PATH_CAPACITY];
     let path = proc_fd_path(fd, &mut path);
     match sigsafe_alloc::fs::readlinkat(allocator, CWD, path) {
-        Ok(path) => Ok(Some(path)),
+        Ok(path) => Ok(Some(path.leak().as_bstr())),
         Err(sigsafe::Errno::BADF | sigsafe::Errno::NOENT) => Ok(None),
         Err(errno) => Err(nix::errno::Errno::from_raw(errno.raw_os_error())),
     }
@@ -46,40 +49,40 @@ fn proc_fd_path<'buf>(
 }
 
 #[cfg(target_os = "macos")]
-fn get_fd_path<A: Allocator>(allocator: A, fd: BorrowedFd<'_>) -> nix::Result<Option<Vec<u8, A>>> {
+fn get_fd_path<'a, A: Allocator>(
+    allocator: &'a A,
+    fd: BorrowedFd<'_>,
+) -> nix::Result<Option<&'a BStr>> {
     if fd.as_raw_fd() == CWD.as_raw_fd() {
         let path = sigsafe_alloc::fs::getcwd(allocator)
             .map_err(|errno| nix::errno::Errno::from_raw(errno.raw_os_error()))?
             .into_bytes();
-        return Ok(Some(path));
+        return Ok(Some(path.leak().as_bstr()));
     }
 
     match sigsafe_alloc::fs::fcntl_getpath(allocator, fd) {
         Ok(path) => {
             // `F_GETPATH` does not return a length. Count at this caller before
             // converting its allocation into the returned path.
-            Ok(Some(path.count().into_bytes()))
+            Ok(Some(path.count().into_bytes().leak().as_bstr()))
         }
         Err(sigsafe::Errno::BADF | sigsafe::Errno::NOENT) => Ok(None),
         Err(errno) => Err(nix::errno::Errno::from_raw(errno.raw_os_error())),
     }
 }
 
 pub trait ToAbsolutePath {
-    fn to_absolute_path<R, F: FnOnce(Option<&BStr>) -> nix::Result<R>>(
-        self,
-        f: F,
-    ) -> nix::Result<R>;
+    fn to_absolute_path<'a, A: Allocator>(self, allocator: &'a A) -> nix::Result<Option<&'a BStr>>
+    where
+        Self: 'a;
 }
 
 impl ToAbsolutePath for BorrowedFd<'_> {
-    fn to_absolute_path<R, F: FnOnce(Option<&BStr>) -> nix::Result<R>>(
-        self,
-        f: F,
-    ) -> nix::Result<R> {
-        let arena = sigsafe_alloc::arena();
-        let path = get_fd_path(&arena, self)?;
-        f(path.as_ref().map(|path| path.as_slice().as_bstr()))
+    fn to_absolute_path<'a, A: Allocator>(self, allocator: &'a A) -> nix::Result<Option<&'a BStr>>
+    where
+        Self: 'a,
+    {
+        get_fd_path(allocator, self)
     }
 }
 
@@ -99,46 +102,43 @@ impl PathAt<'_, '_> {
 }
 
 impl ToAbsolutePath for PathAt<'_, '_> {
-    fn to_absolute_path<R, F: FnOnce(Option<&BStr>) -> nix::Result<R>>(
-        self,
-        f: F,
-    ) -> nix::Result<R> {
+    fn to_absolute_path<'a, A: Allocator>(self, allocator: &'a A) -> nix::Result<Option<&'a BStr>>
+    where
+        Self: 'a,
+    {
         let pathname = self.1.count().as_bytes().as_bstr();
 
         if pathname.starts_with(b"/") {
-            f(Some(pathname))
+            Ok(Some(pathname))
         } else {
-            self.0.to_absolute_path(|base| {
-                let Some(base) = base else {
-                    return f(None);
-                };
-                if pathname.is_empty() {
-                    return f(Some(base));
-                }
-
-                let arena = sigsafe_alloc::arena();
-                let needs_separator = !base.ends_with(b"/");
-                let mut abs_path = Vec::with_capacity_in(
-                    base.len() + usize::from(needs_separator) + pathname.len(),
-                    &arena,
-                );
-                abs_path.extend_from_slice(base);
-                if needs_separator {
-                    abs_path.push(b'/');
-                }
-                abs_path.extend_from_slice(pathname);
-                f(Some(abs_path.as_slice().as_bstr()))
-            })
+            let Some(base) = self.0.to_absolute_path(allocator)? else {
+                return Ok(None);
+            };
+            if pathname.is_empty() {
+                return Ok(Some(base));
+            }
+
+            let needs_separator = !base.ends_with(b"/");
+            let mut abs_path = Vec::with_capacity_in(
+                base.len() + usize::from(needs_separator) + pathname.len(),
+                allocator,
+            );
+            abs_path.extend_from_slice(base);
+            if needs_separator {
+                abs_path.push(b'/');
+            }
+            abs_path.extend_from_slice(pathname);
+            Ok(Some(abs_path.leak().as_bstr()))
         }
     }
 }
 
 impl ToAbsolutePath for sigsafe::CStr<'_, sigsafe::Thin> {
-    fn to_absolute_path<R, F: FnOnce(Option<&BStr>) -> nix::Result<R>>(
-        self,
-        f: F,
-    ) -> nix::Result<R> {
-        PathAt(CWD, self).to_absolute_path(f)
+    fn to_absolute_path<'a, A: Allocator>(self, allocator: &'a A) -> nix::Result<Option<&'a BStr>>
+    where
+        Self: 'a,
+    {
+        PathAt(CWD, self).to_absolute_path(allocator)
     }
 }
 

crates/fspy_preload_unix/src/client/mod.rs

@@ -109,14 +109,11 @@ impl Client {
     ) -> anyhow::Result<()> {
         // SAFETY: mode contains a valid pointer (if ModeStr) or a plain value, as provided by the caller
         let mode = unsafe { mode.to_access_mode() };
-        let () = path.to_absolute_path(|abs_path| {
-            let Some(abs_path) = abs_path else {
-                return Ok(Ok(()));
-            };
-            Ok(self.send(mode, Path::new(OsStr::from_bytes(abs_path))))
-        })??;
-
-        Ok(())
+        let arena = sigsafe_alloc::arena();
+        let Some(abs_path) = path.to_absolute_path(&arena)? else {
+            return Ok(());
+        };
+        self.send(mode, Path::new(OsStr::from_bytes(abs_path)))
     }
 }
 

crates/fspy_preload_unix/src/interceptions/spawn/exec/mod.rs

@@ -1,8 +1,5 @@
 mod with_argv;
 
-#[cfg(target_os = "linux")]
-use std::ffi::CString;
-
 use fspy_shared_unix::exec::ExecResolveConfig;
 use libc::{c_char, c_int};
 use with_argv::with_argv;
@@ -195,27 +192,39 @@ mod linux_only {
             reason = "suppresses unused warning on *::original"
         )]
         let _unused = execveat::original;
-        // SAFETY: PathAt wraps a valid dirfd and pathname pointer from the interposed execveat call
-        let abs_path_result = unsafe {
-            PathAt::borrow_raw(dirfd, pathname).to_absolute_path(|path| {
-                let Some(path) = path else {
-                    return Ok(None);
-                };
-                Ok(Some(CString::new(&**path).unwrap()))
-            })
-        };
-        let abs_path = match abs_path_result {
+        // SAFETY: pathname points to a valid C string, so its first byte is readable.
+        if unsafe { pathname.cast::<u8>().read() } == b'/' {
+            return handle_exec(
+                ExecResolveConfig::search_path_disabled(),
+                pathname,
+                argv.cast(),
+                envp.cast(),
+            );
+        }
+
+        let arena = sigsafe_alloc::arena();
+        // SAFETY: dirfd and pathname are valid arguments from the interposed execveat call.
+        let path = unsafe { PathAt::borrow_raw(dirfd, pathname) };
+        let abs_path = match path.to_absolute_path(&arena) {
             Ok(None) => {
                 // SAFETY: forwarding the original arguments to the real execveat syscall
                 return unsafe { execveat::original()(dirfd, pathname, argv, envp, flags) };
             }
-            Ok(Some(path)) => path.as_ptr(),
+            Ok(Some(path)) => path,
             Err(errno) => {
                 errno.set();
                 return -1;
             }
         };
-        handle_exec(ExecResolveConfig::search_path_disabled(), abs_path, argv.cast(), envp.cast())
+        let mut c_path = allocator_api2::vec::Vec::with_capacity_in(abs_path.len() + 1, &arena);
+        c_path.extend_from_slice(abs_path);
+        c_path.push(0);
+        handle_exec(
+            ExecResolveConfig::search_path_disabled(),
+            c_path.as_ptr().cast(),
+            argv.cast(),
+            envp.cast(),
+        )
     }
 
     intercept!(fexecve(64): unsafe extern "C" fn(