Update locking to be interior to PeerPcb

tun/src/tokio/mod.rs

@@ -26,21 +26,12 @@ impl TunInterface {
         }
     }
 
-    // #[instrument]
-    pub async fn recv(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+    #[instrument]
+    pub async fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
         loop {
-            // tracing::debug!("TunInterface receiving...");
-            let mut guard = self.inner.readable_mut().await?;
-            // tracing::debug!("Got! readable_mut");
-            match guard.try_io(|inner| {
-                let raw_ref = (*inner).get_mut();
-                let recved = raw_ref.recv(buf);
-                recved
-            }) {
-                Ok(result) => {
-                    tracing::debug!("HORRAY");
-                    return result
-                }
+            let mut guard = self.inner.readable().await?;
+            match guard.try_io(|inner| inner.get_ref().recv(buf)) {
+                Ok(result) => return result,
                 Err(_would_block) => {
                     tracing::debug!("WouldBlock");
                     continue
@@ -48,13 +39,4 @@ impl TunInterface {
             }
         }
     }
-
-    #[instrument]
-    pub async fn try_recv(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let mut guard = self.inner.readable_mut().await?;
-        match guard.try_io(|inner| (*inner).get_mut().recv(buf)) {
-            Ok(result) => Ok(result.unwrap_or_default()),
-            Err(_would_block) => Err(io::Error::new(io::ErrorKind::WouldBlock, "WouldBlock")),
-        }
-    }
 }

tun/src/unix/mod.rs

@@ -1,5 +1,6 @@
 use std::{
     io::{Error, Read},
+    mem::MaybeUninit,
     os::fd::{AsRawFd, FromRawFd, IntoRawFd, RawFd},
 };
 
@@ -38,14 +39,19 @@ impl IntoRawFd for TunInterface {
     }
 }
 
+unsafe fn assume_init(buf: &[MaybeUninit<u8>]) -> &[u8] {
+    &*(buf as *const [MaybeUninit<u8>] as *const [u8])
+}
+
 impl TunInterface {
     #[throws]
     #[instrument]
-    pub fn recv(&mut self, buf: &mut [u8]) -> usize {
-        // there might be a more efficient way to implement this
-        let tmp_buf = &mut [0u8; 1500];
-        let len = self.socket.read(tmp_buf)?;
-        buf[..len - 4].copy_from_slice(&tmp_buf[4..len]);
+    pub fn recv(&self, buf: &mut [u8]) -> usize {
+        // Use IoVec to read directly into target buffer
+        let mut tmp_buf = [MaybeUninit::uninit(); 1500];
+        let len = self.socket.recv(&mut tmp_buf)?;
+        let result_buf = unsafe { assume_init(&tmp_buf[4..len]) };
+        buf[..len - 4].copy_from_slice(&result_buf);
         len - 4
     }