LFG

src/virtual_device.rs

@@ -1,42 +1,45 @@
+use std::collections::VecDeque;
+
 use smoltcp::phy::{ChecksumCapabilities, Device, DeviceCapabilities, Medium};
 use smoltcp::time::Instant;
 use smoltcp::wire::{Ipv4Packet, Ipv4Repr};
-use std::collections::VecDeque;
 
 pub struct VirtualIpDevice {
-    queue: VecDeque<Vec<u8>>,
-    /// Sends IP packets
+    /// Channel for packets sent by the interface.
     ip_tx: crossbeam_channel::Sender<Vec<u8>>,
+    ip_rx: crossbeam_channel::Receiver<Vec<u8>>,
 }
 
 impl VirtualIpDevice {
-    pub fn new(ip_tx: crossbeam_channel::Sender<Vec<u8>>) -> Self {
-        Self {
-            queue: VecDeque::new(),
-            ip_tx,
-        }
+    pub fn new(
+        ip_tx: crossbeam_channel::Sender<Vec<u8>>,
+        ip_rx: crossbeam_channel::Receiver<Vec<u8>>,
+    ) -> Self {
+        Self { ip_tx, ip_rx }
     }
 }
 
 impl<'a> Device<'a> for VirtualIpDevice {
     type RxToken = RxToken;
-    type TxToken = TxToken<'a>;
+    type TxToken = TxToken;
 
     fn receive(&'a mut self) -> Option<(Self::RxToken, Self::TxToken)> {
-        self.queue.pop_front().map(move |buffer| {
-            let rx = RxToken { buffer };
-            let tx = TxToken {
-                queue: &mut self.queue,
-                tx: Some(self.ip_tx.clone()),
-            };
-            (rx, tx)
-        })
+        if !self.ip_rx.is_empty() {
+            let buffer = self.ip_rx.recv().expect("failed to read ip_rx");
+            Some((
+                RxToken { buffer },
+                TxToken {
+                    ip_tx: self.ip_tx.clone(),
+                },
+            ))
+        } else {
+            None
+        }
     }
 
     fn transmit(&'a mut self) -> Option<Self::TxToken> {
         Some(TxToken {
-            queue: &mut self.queue,
-            tx: Some(self.ip_tx.clone()),
+            ip_tx: self.ip_tx.clone(),
         })
     }
 
@@ -63,12 +66,11 @@ impl smoltcp::phy::RxToken for RxToken {
 }
 
 #[doc(hidden)]
-pub struct TxToken<'a> {
-    queue: &'a mut VecDeque<Vec<u8>>,
-    tx: Option<crossbeam_channel::Sender<Vec<u8>>>,
+pub struct TxToken {
+    ip_tx: crossbeam_channel::Sender<Vec<u8>>,
 }
 
-impl<'a> smoltcp::phy::TxToken for TxToken<'a> {
+impl<'a> smoltcp::phy::TxToken for TxToken {
     fn consume<R, F>(self, _timestamp: Instant, len: usize, f: F) -> smoltcp::Result<R>
     where
         F: FnOnce(&mut [u8]) -> smoltcp::Result<R>,
@@ -76,8 +78,9 @@ impl<'a> smoltcp::phy::TxToken for TxToken<'a> {
         let mut buffer = Vec::new();
         buffer.resize(len, 0);
         let result = f(&mut buffer);
-        self.tx.map(|tx| tx.send(buffer.clone()));
-        self.queue.push_back(buffer);
+        self.ip_tx
+            .send(buffer.clone())
+            .expect("failed to send to ip_tx");
         result
     }
 }