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,18 +7,21 @@ use libc::{c_char, c_int};
 use sigsafe::{AsRawFd as _, BorrowedFd, CWD};
 
 #[cfg(target_os = "linux")]
-fn get_fd_path<A: Allocator>(fd: BorrowedFd<'_>, allocator: A) -> nix::Result<Option<Vec<u8, A>>> {
+fn get_fd_path<'a, A: Allocator>(
+    fd: BorrowedFd<'_>,
+    allocator: &'a A,
+) -> 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::readlink(allocator, 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())),
     }
@@ -61,30 +64,35 @@ fn proc_fd_path<'buf>(
 }
 
 #[cfg(target_os = "macos")]
-fn get_fd_path<A: Allocator>(fd: BorrowedFd<'_>, allocator: A) -> nix::Result<Option<Vec<u8, A>>> {
+fn get_fd_path<'a, A: Allocator>(
+    fd: BorrowedFd<'_>,
+    allocator: &'a A,
+) -> 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 {
-    unsafe fn to_absolute_path<R, F: FnOnce(Option<&BStr>) -> nix::Result<R>>(
+    unsafe fn to_absolute_path<'a, A: Allocator>(
         self,
-        f: F,
-    ) -> nix::Result<R>;
+        allocator: &'a A,
+    ) -> nix::Result<Option<&'a BStr>>
+    where
+        Self: 'a;
 }
 
 pub struct Fd<'fd>(pub BorrowedFd<'fd>);
@@ -106,23 +114,14 @@ impl Fd<'_> {
 }
 
 impl ToAbsolutePath for Fd<'_> {
-    unsafe fn to_absolute_path<R, F: FnOnce(Option<&BStr>) -> nix::Result<R>>(
+    unsafe fn to_absolute_path<'a, A: Allocator>(
         self,
-        f: F,
-    ) -> nix::Result<R> {
-        #[cfg(target_os = "linux")]
-        {
-            let arena = sigsafe_alloc::arena();
-            let path = get_fd_path(self.0, &arena)?;
-            f(path.as_ref().map(|path| path.as_slice().as_bstr()))
-        }
-
-        #[cfg(target_os = "macos")]
-        {
-            let arena = sigsafe_alloc::arena();
-            let path = get_fd_path(self.0, &arena)?;
-            f(path.as_ref().map(|path| path.as_slice().as_bstr()))
-        }
+        allocator: &'a A,
+    ) -> nix::Result<Option<&'a BStr>>
+    where
+        Self: 'a,
+    {
+        get_fd_path(self.0, allocator)
     }
 }
 
@@ -141,51 +140,52 @@ impl<'path, Repr> PathAt<'_, 'path, Repr> {
 }
 
 impl<Repr> ToAbsolutePath for PathAt<'_, '_, Repr> {
-    unsafe fn to_absolute_path<R, F: FnOnce(Option<&BStr>) -> nix::Result<R>>(
+    unsafe fn to_absolute_path<'a, A: Allocator>(
         self,
-        f: F,
-    ) -> nix::Result<R> {
+        allocator: &'a A,
+    ) -> nix::Result<Option<&'a BStr>>
+    where
+        Self: 'a,
+    {
         // SAFETY: self.1 is a valid NUL-terminated string.
         let pathname = unsafe { CStr::from_ptr(self.1.as_ptr()) }.to_bytes().as_bstr();
 
         if pathname.first().copied() == Some(b'/') {
-            f(pathname.into())
+            Ok(Some(pathname))
         } else {
             // SAFETY: delegates the same caller-provided descriptor to Fd.
-            unsafe {
-                Fd(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) = (unsafe { Fd(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<Repr> ToAbsolutePath for sigsafe::CStr<'_, Repr> {
-    unsafe fn to_absolute_path<R, F: FnOnce(Option<&BStr>) -> nix::Result<R>>(
+    unsafe fn to_absolute_path<'a, A: Allocator>(
         self,
-        f: F,
-    ) -> nix::Result<R> {
+        allocator: &'a A,
+    ) -> nix::Result<Option<&'a BStr>>
+    where
+        Self: 'a,
+    {
         // SAFETY: delegates the same caller-provided C string to PathAt.
-        unsafe { PathAt(CWD, self).to_absolute_path(f) }
+        unsafe { PathAt(CWD, self).to_absolute_path(allocator) }
     }
 }
 

crates/fspy_preload_unix/src/client/mod.rs

@@ -109,15 +109,12 @@ 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 arena = sigsafe_alloc::arena();
         // SAFETY: path contains valid pointers to C strings/file descriptors, as provided by the caller
-        let () = unsafe {
-            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))))
-            })
-        }??;
+        let Some(abs_path) = (unsafe { path.to_absolute_path(&arena) })? else {
+            return Ok(());
+        };
+        self.send(mode, Path::new(OsStr::from_bytes(abs_path)))?;
 
         Ok(())
     }

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,42 @@ mod linux_only {
             reason = "suppresses unused warning on *::original"
         )]
         let _unused = execveat::original;
+        // SAFETY: pathname is a valid C string provided to execveat.
+        let pathname_bytes = unsafe { std::ffi::CStr::from_ptr(pathname) }.to_bytes();
+        if pathname_bytes.first().copied() == Some(b'/') {
+            return handle_exec(
+                ExecResolveConfig::search_path_disabled(),
+                pathname,
+                argv.cast(),
+                envp.cast(),
+            );
+        }
+
+        let arena = sigsafe_alloc::arena();
         // SAFETY: PathAt wraps a valid dirfd and pathname pointer from the interposed execveat call
         let abs_path_result = unsafe {
-            PathAt::borrow_raw(dirfd, sigsafe::CStr::from_ptr(pathname)).to_absolute_path(|path| {
-                let Some(path) = path else {
-                    return Ok(None);
-                };
-                Ok(Some(CString::new(&**path).unwrap()))
-            })
+            PathAt::borrow_raw(dirfd, sigsafe::CStr::from_ptr(pathname)).to_absolute_path(&arena)
         };
         let abs_path = match abs_path_result {
             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(