fix unix build

Author: domenukk

libafl/src/bolts/llmp.rs

@@ -1871,7 +1871,7 @@ where
         // (For now) the thread remote broker 2 broker just acts like a "normal" llmp client, except it proxies all messages to the attached socket, in both directions.
         thread::spawn(move || {
             // as always, call post_fork to potentially reconnect the provider (for threaded/forked use)
-            shmem_provider_clone.post_fork(true);
+            shmem_provider_clone.post_fork(true).unwrap();
 
             #[cfg(fature = "llmp_debug")]
             println!("B2b: Spawned proxy thread");
@@ -2064,7 +2064,7 @@ where
 
         let ret = thread::spawn(move || {
             // Call `post_fork` (even though this is not forked) so we get a new connection to the cloned `ShMemServer` if we are using a `ServedShMemProvider`
-            shmem_provider_clone.post_fork(true);
+            shmem_provider_clone.post_fork(true).unwrap();
 
             let mut current_client_id = llmp_tcp_id + 1;
 
@@ -2127,7 +2127,7 @@ where
             }
         });
 
-        self.shmem_provider.post_fork(false);
+        self.shmem_provider.post_fork(false)?;
         Ok(ret)
     }
 

libafl/src/bolts/os/ashmem_server.rs

@@ -76,8 +76,8 @@ impl ShMem for ServedShMem {
 impl ServedShMemProvider {
     /// Send a request to the server, and wait for a response
     #[allow(clippy::similar_names)] // id and fd
-    fn send_receive(&mut self, request: AshmemRequest) -> (i32, i32) {
-        let body = postcard::to_allocvec(&request).unwrap();
+    fn send_receive(&mut self, request: AshmemRequest) -> Result<(i32, i32), Error> {
+        let body = postcard::to_allocvec(&request)?;
 
         let header = (body.len() as u32).to_be_bytes();
         let mut message = header.to_vec();
@@ -95,8 +95,8 @@ impl ServedShMemProvider {
 
         let server_id = ShMemId::from_slice(&shm_slice);
         let server_id_str = server_id.to_string();
-        let server_fd: i32 = server_id_str.parse().unwrap();
-        (server_fd, fd_buf[0])
+        let server_fd: i32 = server_id_str.parse()?;
+        Ok((server_fd, fd_buf[0]))
     }
 }
 
@@ -118,18 +118,16 @@ impl ShMemProvider for ServedShMemProvider {
     /// Connect to the server and return a new [`ServedShMemProvider`]
     fn new() -> Result<Self, Error> {
         let mut res = Self {
-            stream: UnixStream::connect_to_unix_addr(
-                &UnixSocketAddr::new(ASHMEM_SERVER_NAME).unwrap(),
-            )?,
+            stream: UnixStream::connect_to_unix_addr(&UnixSocketAddr::new(ASHMEM_SERVER_NAME)?)?,
             inner: AshmemShMemProvider::new()?,
             id: -1,
         };
-        let (id, _) = res.send_receive(AshmemRequest::Hello(None));
+        let (id, _) = res.send_receive(AshmemRequest::Hello(None))?;
         res.id = id;
         Ok(res)
     }
     fn new_map(&mut self, map_size: usize) -> Result<Self::Mem, crate::Error> {
-        let (server_fd, client_fd) = self.send_receive(AshmemRequest::NewMap(map_size));
+        let (server_fd, client_fd) = self.send_receive(AshmemRequest::NewMap(map_size))?;
 
         Ok(ServedShMem {
             inner: ManuallyDrop::new(
@@ -145,7 +143,7 @@ impl ShMemProvider for ServedShMemProvider {
         let server_id_str = parts.get(0).unwrap();
         let (server_fd, client_fd) = self.send_receive(AshmemRequest::ExistingMap(
             ShMemDescription::from_string_and_size(server_id_str, size),
-        ));
+        ))?;
         Ok(ServedShMem {
             inner: ManuallyDrop::new(
                 self.inner
@@ -155,16 +153,21 @@ impl ShMemProvider for ServedShMemProvider {
         })
     }
 
-    fn post_fork(&mut self) {
-        self.stream =
-            UnixStream::connect_to_unix_addr(&UnixSocketAddr::new(ASHMEM_SERVER_NAME).unwrap())
-                .expect("Unable to reconnect to the ashmem service");
-        let (id, _) = self.send_receive(AshmemRequest::Hello(Some(self.id)));
-        self.id = id;
+    fn post_fork(&mut self, is_child: bool) -> Result<(), Error> {
+        if is_child {
+            // After fork, the child needs to reconnect as to not share the fds with the parent.
+            self.stream =
+                UnixStream::connect_to_unix_addr(&UnixSocketAddr::new(ASHMEM_SERVER_NAME)?)?;
+            let (id, _) = self.send_receive(AshmemRequest::Hello(Some(self.id)))?;
+            self.id = id;
+        }
+        Ok(())
     }
 
     fn release_map(&mut self, map: &mut Self::Mem) {
-        let (refcount, _) = self.send_receive(AshmemRequest::Deregister(map.server_fd));
+        let (refcount, _) = self
+            .send_receive(AshmemRequest::Deregister(map.server_fd))
+            .expect("Could not communicate to AshMem server!");
         if refcount == 0 {
             unsafe {
                 ManuallyDrop::drop(&mut map.inner);

libafl/src/bolts/os/mod.rs

@@ -7,7 +7,7 @@ pub mod ashmem_server;
 pub mod unix_signals;
 
 #[cfg(unix)]
-mod pipes;
+pub mod pipes;
 
 #[cfg(all(windows, feature = "std"))]
 pub mod windows_exceptions;

libafl/src/bolts/os/pipes.rs

@@ -1,4 +1,8 @@
+//! Unix `pipe` wrapper for `LibAFL`
+use crate::Error;
 use nix::unistd::{close, pipe, read, write};
+use std::io::{self, ErrorKind, Read, Write};
+use std::os::unix::io::RawFd;
 
 #[derive(Debug, Clone)]
 pub struct Pipe {
@@ -7,60 +11,72 @@ pub struct Pipe {
 }
 
 impl Pipe {
-    fn new() -> Self {
-        let mut fds = [-1 as c_int, -1 as c_int];
-        let ret = unsafe { libc::pipe(fds.as_mut_ptr()) };
-        if ret < 0 {
-            panic!("pipe() failed");
-        }
-        Self {
-            read_end: fds[0],
-            write_end: fds[1],
-        }
+    pub fn new() -> Result<Self, Error> {
+        let (read_end, write_end) = pipe()?;
+        Ok(Self {
+            read_end: Some(read_end),
+            write_end: Some(write_end),
+        })
     }
 
-    fn close_read_end() {
+    pub fn close_read_end(&mut self) {
         if let Some(read_end) = self.read_end {
-            close(read_end);
+            let _ = close(read_end);
             self.read_end = None;
         }
     }
 
-    fn close_write_end() {
+    pub fn close_write_end(&mut self) {
         if let Some(write_end) = self.write_end {
-            close(write_end);
+            let _ = close(write_end);
             self.write_end = None;
         }
     }
 }
 
 impl Read for Pipe {
     /// Reads a few bytes
-    fn read(&self, buf: &mut [u8]) -> Result<usize, Error> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
         match self.read_end {
-            Some(read_end) => Ok(read(self.read_end, buf)?),
-            None => Err(Error::IllegalState("Read pipe was already closed")),
+            Some(read_end) => match read(read_end, buf) {
+                Ok(res) => Ok(res),
+                Err(e) => Err(io::Error::from_raw_os_error(e.as_errno().unwrap() as i32)),
+            },
+            None => Err(io::Error::new(
+                ErrorKind::BrokenPipe,
+                "Read pipe end was already closed",
+            )),
         }
     }
 }
 
 impl Write for Pipe {
     /// Writes a few bytes
-    fn write(&self, buf: &[u8]) -> Result<usize, Error> {
-        match self.read_end {
-            Some(read_end) => Ok(write(self.write_end, buf)?),
-            None => Err(Error::IllegalState("Write pipe was already closed")),
+    fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
+        match self.write_end {
+            Some(write_end) => match write(write_end, buf) {
+                Ok(res) => Ok(res),
+                Err(e) => Err(io::Error::from_raw_os_error(e.as_errno().unwrap() as i32)),
+            },
+            None => Err(io::Error::new(
+                ErrorKind::BrokenPipe,
+                "Write pipe end was already closed",
+            )),
         }
     }
+
+    fn flush(&mut self) -> Result<(), io::Error> {
+        Ok(())
+    }
 }
 
 impl Drop for Pipe {
     fn drop(&mut self) {
         if let Some(read_end) = self.read_end {
-            let _ = close(self.read_end);
+            let _ = close(read_end);
         }
         if let Some(write_end) = self.write_end {
-            let _ = close(self.write_end);
+            let _ = close(write_end);
         }
     }
 }