Fix breaking changes from nix update.

Author: WINSDK

Cargo.toml

@@ -4,4 +4,4 @@ version = "1.0.0"
 edition = "2021"
 
 [dependencies]
-nix = "0.28"
+nix = { version = "0.28", features = ["ptrace", "sched", "personality", "signal", "fs"] }

examples/spawning.rs

@@ -1,4 +1,5 @@
 use std::io::Write;
+use std::os::fd::{AsRawFd, BorrowedFd};
 use std::sync::Arc;
 use std::{ffi::CString, path::Path};
 
@@ -20,19 +21,20 @@ fn spawn<P: AsRef<Path>>(tracer: &Tracer, path: P) -> Result<Pid, nix::Error> {
 
     // Create a communication pipe for error handling.
     let (pipe_read, pipe_write) = nix::unistd::pipe()?;
+    let (pipe_read, pipe_write) = (pipe_read.as_raw_fd(), pipe_write.as_raw_fd());
 
     // Tell write pipe to close on exec (required for checking successful execution).
-    fcntl(pipe_write, FcntlArg::F_SETFD(FdFlag::FD_CLOEXEC))?;
+    fcntl(pipe_write.as_raw_fd(), FcntlArg::F_SETFD(FdFlag::FD_CLOEXEC))?;
 
     let child = move || unsafe {
         let _ = nix::unistd::close(pipe_read);
 
-        let report_error = |err| {
+        let report_error = move |err| {
             // Convert error to bytes.
             let errno = (err as i32).to_ne_bytes();
 
             // Write error status to pipe.
-            let _ = nix::unistd::write(pipe_write, &errno);
+            let _ = nix::unistd::write(std::mem::transmute::<_, BorrowedFd>(pipe_write), &errno);
 
             // Explicitly close the write end of the pipe to ensure the parent can read EOF
             // if exec hasn't been called.
@@ -69,11 +71,11 @@ fn spawn<P: AsRef<Path>>(tracer: &Tracer, path: P) -> Result<Pid, nix::Error> {
     let _ = nix::unistd::close(pipe_write);
 
     let mut errno = [0; 4];
-    match nix::unistd::read(pipe_read, &mut errno) {
+    match nix::unistd::read(pipe_read.as_raw_fd(), &mut errno) {
         // Child ran into error.
         Ok(4) => {
             let errno = i32::from_ne_bytes(errno);
-            let errno = nix::Error::from_i32(errno);
+            let errno = nix::Error::from_raw(errno);
             return Err(errno);
         }
         // Child ran successfully.

src/lib.rs

@@ -1,4 +1,4 @@
-use nix::errno::Errno;
+use nix::Error;
 use nix::libc;
 use nix::sys::ptrace::{Request, RequestType};
 use nix::sys::signal::Signal;
@@ -31,15 +31,15 @@ impl PtraceRequest {
         );
 
         if ret == -1 {
-            -(nix::errno::errno() as c_long)
+            -(Error::last() as c_long)
         } else {
             ret
         }
     }
 
     unsafe fn peek(self) -> c_long {
         let ret = unsafe {
-            Errno::clear();
+            Error::clear();
             libc::ptrace(
                 self.ty as RequestType,
                 libc::pid_t::from(self.pid),
@@ -49,12 +49,12 @@ impl PtraceRequest {
         };
 
         if ret == -1 {
-            let errno = nix::errno::errno();
+            let errno = Error::last();
 
-            if errno == Errno::UnknownErrno as i32 {
+            if errno == Error::UnknownErrno {
                 ret
             } else {
-                -errno as c_long
+                -(errno as c_long)
             }
         } else {
             ret
@@ -126,7 +126,7 @@ impl Tracer {
         *lock = c_long::MIN;
 
         if result < 0 {
-            Err(Errno::from_i32(-result as i32))
+            Err(Error::from_raw(-result as i32))
         } else {
             Ok(result)
         }
@@ -145,7 +145,7 @@ impl Tracer {
         *lock = c_long::MIN;
 
         if result < 0 {
-            Err(Errno::from_i32(-result as i32))
+            Err(Error::from_raw(-result as i32))
         } else {
             Ok(Pid::from_raw(result as i32))
         }
@@ -170,6 +170,25 @@ impl Tracer {
         .map(drop)
     }
 
+    /// Continue execution until the next syscall, as with `ptrace(PTRACE_SYSCALL, ...)`
+    ///
+    /// Arranges for the tracee to be stopped at the next entry to or exit from a system call,
+    /// optionally delivering a signal specified by `sig`.
+    pub fn syscall<T: Into<Option<Signal>>>(&self, pid: Pid, sig: T) -> Result<()> {
+        let data = match sig.into() {
+            Some(s) => s as i32 as usize,
+            None => 0,
+        };
+
+        self.send(PtraceRequest {
+            ty: Request::PTRACE_SYSCALL,
+            pid,
+            addr: 0,
+            data,
+        })
+        .map(drop)
+    }
+
     /// Sets the process as traceable, as with `ptrace(PTRACE_TRACEME, ...)`
     ///
     /// Indicates that this process is to be traced by its parent.