tcp sockets dynamic

client/src/tun/device.rs

@@ -15,43 +15,86 @@ use smoltcp::{
 };
 use tokio::sync::mpsc;
 
+// --- TokenBuffer (без изменений, он у тебя отличный) ---
+const TOKEN_BUFFER_LIST_MAX_SIZE: usize = 64;
+static TOKEN_BUFFER_LIST: LazyLock<Mutex<Vec<BytesMut>>> = LazyLock::new(|| Mutex::new(Vec::new()));
+
+pub struct TokenBuffer {
+    buffer: BytesMut,
+}
+
+impl Drop for TokenBuffer {
+    fn drop(&mut self) {
+        let mut list = TOKEN_BUFFER_LIST.lock().unwrap();
+        if list.len() >= TOKEN_BUFFER_LIST_MAX_SIZE {
+            return;
+        }
+        let empty_buffer = BytesMut::new();
+        let mut buffer = mem::replace(&mut self.buffer, empty_buffer);
+        buffer.clear();
+        list.push(buffer);
+    }
+}
+
+impl TokenBuffer {
+    pub fn with_capacity(cap: usize) -> Self {
+        let mut list = TOKEN_BUFFER_LIST.lock().unwrap();
+        if let Some(mut buffer) = list.pop() {
+            buffer.reserve(cap);
+            return Self { buffer };
+        }
+        Self {
+            buffer: BytesMut::with_capacity(cap),
+        }
+    }
+}
+
+impl Deref for TokenBuffer {
+    type Target = BytesMut;
+    fn deref(&self) -> &Self::Target {
+        &self.buffer
+    }
+}
+impl DerefMut for TokenBuffer {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.buffer
+    }
+}
+
+// --- VirtTunDevice ---
 pub struct VirtTunDevice {
     capabilities: DeviceCapabilities,
-    in_buf: mpsc::UnboundedReceiver<TokenBuffer>,
-    out_buf: mpsc::UnboundedSender<TokenBuffer>,
-    in_buf_avail: Arc<AtomicBool>,
+    rx_queue: mpsc::UnboundedReceiver<TokenBuffer>, // smoltcp читает отсюда
+    tx_queue: mpsc::UnboundedSender<TokenBuffer>,   // smoltcp пишет сюда
+    rx_avail: Arc<AtomicBool>,
 }
 
 impl VirtTunDevice {
-    #[allow(clippy::type_complexity)]
     pub fn new(
         capabilities: DeviceCapabilities,
     ) -> (
         Self,
-        mpsc::UnboundedReceiver<TokenBuffer>,
-        mpsc::UnboundedSender<TokenBuffer>,
+        mpsc::UnboundedSender<TokenBuffer>, // Канал, чтобы закидывать пакеты в smoltcp
+        mpsc::UnboundedReceiver<TokenBuffer>, // Канал, чтобы забирать готовые пакеты из smoltcp
         Arc<AtomicBool>,
     ) {
-        let (iface_tx, iface_output) = mpsc::unbounded_channel();
-        let (iface_input, iface_rx) = mpsc::unbounded_channel();
-        let in_buf_avail = Arc::new(AtomicBool::new(false));
+        let (to_smoltcp_tx, to_smoltcp_rx) = mpsc::unbounded_channel();
+        let (from_smoltcp_tx, from_smoltcp_rx) = mpsc::unbounded_channel();
+        let rx_avail = Arc::new(AtomicBool::new(false));
 
-        (
-            Self {
-                capabilities,
-                in_buf: iface_rx,
-                out_buf: iface_tx,
-                in_buf_avail: in_buf_avail.clone(),
-            },
-            iface_output,
-            iface_input,
-            in_buf_avail,
-        )
+        let device = Self {
+            capabilities,
+            rx_queue: to_smoltcp_rx,
+            tx_queue: from_smoltcp_tx,
+            rx_avail: rx_avail.clone(),
+        };
+
+        (device, to_smoltcp_tx, from_smoltcp_rx, rx_avail)
     }
 
     #[inline]
-    pub fn recv_available(&self) -> bool {
-        self.in_buf_avail.load(Ordering::Acquire)
+    pub fn mark_rx_available(&self) {
+        self.rx_avail.store(true, Ordering::Release);
     }
 }
 
@@ -60,7 +103,7 @@ impl Device for VirtTunDevice {
     type TxToken<'a> = VirtTxToken<'a>;
 
     fn receive(&mut self, _timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
-        if let Ok(buffer) = self.in_buf.try_recv() {
+        if let Ok(buffer) = self.rx_queue.try_recv() {
             let rx = Self::RxToken {
                 buffer,
                 phantom_device: PhantomData,
@@ -68,7 +111,7 @@ impl Device for VirtTunDevice {
             let tx = VirtTxToken(self);
             return Some((rx, tx));
         }
-        self.in_buf_avail.store(false, Ordering::Release);
+        self.rx_avail.store(false, Ordering::Release);
         None
     }
 
@@ -106,61 +149,8 @@ impl phy::TxToken for VirtTxToken<'_> {
         unsafe {
             buffer.set_len(len);
         }
-
         let result = f(&mut buffer);
-        self.0
-            .out_buf
-            .send(buffer)
-            .expect("channel closed unexpectedly");
+        let _ = self.0.tx_queue.send(buffer);
         result
     }
 }
-
-const TOKEN_BUFFER_LIST_MAX_SIZE: usize = 64;
-static TOKEN_BUFFER_LIST: LazyLock<Mutex<Vec<BytesMut>>> = LazyLock::new(|| Mutex::new(Vec::new()));
-
-pub struct TokenBuffer {
-    buffer: BytesMut,
-}
-
-impl Drop for TokenBuffer {
-    fn drop(&mut self) {
-        let mut list = TOKEN_BUFFER_LIST.lock().unwrap();
-        if list.len() >= TOKEN_BUFFER_LIST_MAX_SIZE {
-            return;
-        }
-
-        let empty_buffer = BytesMut::new();
-        let mut buffer = mem::replace(&mut self.buffer, empty_buffer);
-        buffer.clear();
-
-        list.push(buffer);
-    }
-}
-
-impl TokenBuffer {
-    pub fn with_capacity(cap: usize) -> Self {
-        let mut list = TOKEN_BUFFER_LIST.lock().unwrap();
-        if let Some(mut buffer) = list.pop() {
-            buffer.reserve(cap);
-            return Self { buffer };
-        }
-        Self {
-            buffer: BytesMut::with_capacity(cap),
-        }
-    }
-}
-
-impl Deref for TokenBuffer {
-    type Target = BytesMut;
-
-    fn deref(&self) -> &Self::Target {
-        &self.buffer
-    }
-}
-
-impl DerefMut for TokenBuffer {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.buffer
-    }
-}