Implement Wireguard

Implements Wireguard

tun/src/tokio/mod.rs

@@ -1,22 +1,22 @@
 use std::io;
+
 use tokio::io::unix::AsyncFd;
 use tracing::instrument;
 
 #[derive(Debug)]
 pub struct TunInterface {
-    inner: AsyncFd<crate::TunInterface>,
+    pub inner: AsyncFd<crate::TunInterface>,
 }
 
 impl TunInterface {
     #[instrument]
-    pub fn new(tun: crate::TunInterface) -> io::Result<Self> {
-        Ok(Self {
-            inner: AsyncFd::new(tun)?,
-        })
+    pub fn new(mut tun: crate::TunInterface) -> io::Result<Self> {
+        tun.set_nonblocking(true)?;
+        Ok(Self { inner: AsyncFd::new(tun)? })
     }
 
     #[instrument]
-    pub async fn write(&self, buf: &[u8]) -> io::Result<usize> {
+    pub async fn send(&self, buf: &[u8]) -> io::Result<usize> {
         loop {
             let mut guard = self.inner.writable().await?;
             match guard.try_io(|inner| inner.get_ref().send(buf)) {
@@ -27,12 +27,15 @@ impl TunInterface {
     }
 
     #[instrument]
-    pub async fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+    pub async fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
         loop {
-            let mut guard = self.inner.readable_mut().await?;
-            match guard.try_io(|inner| (*inner).get_mut().recv(buf)) {
+            let mut guard = self.inner.readable().await?;
+            match guard.try_io(|inner| inner.get_ref().recv(buf)) {
                 Ok(result) => return result,
-                Err(_would_block) => continue,
+                Err(_would_block) => {
+                    tracing::debug!("WouldBlock");
+                    continue
+                }
             }
         }
     }