Reverting phy changes

src/iface/interface.rs

@@ -635,6 +635,8 @@ impl<'a, DeviceT> Interface<'a, DeviceT>
                         }
                     }
                 }
+
+                Ok(())
             }) {
                 Err(err) => net_debug!("Failed to consume RX token: {}", err),
                 Ok(_) => {},
@@ -1601,6 +1603,7 @@ impl<'a> InterfaceInner<'a> {
             frame.set_src_addr(self.ethernet_addr.unwrap());
 
             f(frame);
+            Ok(())
         }) {
             Err(err) => net_debug!("Failed to consume TX token: {}", err),
             Ok(_) => {},
@@ -1776,6 +1779,7 @@ impl<'a> InterfaceInner<'a> {
 
                     let payload = &mut tx_buffer[ip_repr.buffer_len()..];
                     packet.emit_payload(ip_repr, payload, &caps);
+                    Ok(())
                 })
             }
         }

src/phy/fault_injector.rs

@@ -242,7 +242,7 @@ pub struct RxToken<'a, Rx: phy::RxToken> {
 
 impl<'a, Rx: phy::RxToken> phy::RxToken for RxToken<'a, Rx> {
     fn consume<R, F>(self, timestamp: Instant, f: F) -> Result<R>
-        where F: FnOnce(&mut [u8]) -> R
+        where F: FnOnce(&mut [u8]) -> Result<R>
     {
         if self.state.borrow_mut().maybe(self.config.drop_pct) {
             net_trace!("rx: randomly dropping a packet");
@@ -254,11 +254,10 @@ impl<'a, Rx: phy::RxToken> phy::RxToken for RxToken<'a, Rx> {
         }
         let Self { token, config, state, mut corrupt } = self;
         token.consume(timestamp, |buffer| {
-            // TODO: Implement this in a new mechanism. Token consumption is infallible.
-            //if config.max_size > 0 && buffer.as_ref().len() > config.max_size {
-            //    net_trace!("rx: dropping a packet that is too large");
-            //    return Error::Exhausted
-            //}
+            if config.max_size > 0 && buffer.as_ref().len() > config.max_size {
+                net_trace!("rx: dropping a packet that is too large");
+                return Err(Error::Exhausted)
+            }
             if state.borrow_mut().maybe(config.corrupt_pct) {
                 net_trace!("rx: randomly corrupting a packet");
                 let mut corrupt = &mut corrupt[..buffer.len()];
@@ -282,7 +281,7 @@ pub struct TxToken<'a, Tx: phy::TxToken> {
 
 impl<'a, Tx: phy::TxToken> phy::TxToken for TxToken<'a, Tx> {
     fn consume<R, F>(mut self, timestamp: Instant, len: usize, f: F) -> Result<R>
-        where F: FnOnce(&mut [u8]) -> R
+        where F: FnOnce(&mut [u8]) -> Result<R>
     {
         let drop = if self.state.borrow_mut().maybe(self.config.drop_pct) {
             net_trace!("tx: randomly dropping a packet");
@@ -298,7 +297,7 @@ impl<'a, Tx: phy::TxToken> phy::TxToken for TxToken<'a, Tx> {
         };
 
         if drop {
-            return Ok(f(&mut self.junk[..len]));
+            return f(&mut self.junk[..len]);
         }
 
         let Self { token, state, config, .. } = self;

src/phy/fuzz_injector.rs

@@ -86,7 +86,7 @@ pub struct RxToken<'a, Rx: phy::RxToken, F: Fuzzer + 'a>{
 
 impl<'a, Rx: phy::RxToken, FRx: Fuzzer> phy::RxToken for RxToken<'a, Rx, FRx> {
     fn consume<R, F>(self, timestamp: Instant, f: F) -> Result<R>
-        where F: FnOnce(&mut [u8]) -> R
+        where F: FnOnce(&mut [u8]) -> Result<R>
     {
         let Self { fuzzer, token } = self;
         token.consume(timestamp, |buffer| {
@@ -104,7 +104,7 @@ pub struct TxToken<'a, Tx: phy::TxToken, F: Fuzzer + 'a> {
 
 impl<'a, Tx: phy::TxToken, FTx: Fuzzer> phy::TxToken for TxToken<'a, Tx, FTx> {
     fn consume<R, F>(self, timestamp: Instant, len: usize, f: F) -> Result<R>
-        where F: FnOnce(&mut [u8]) -> R
+        where F: FnOnce(&mut [u8]) -> Result<R>
     {
         let Self { fuzzer, token } = self;
         token.consume(timestamp, len, |mut buf| {

src/phy/loopback.rs

@@ -68,9 +68,9 @@ pub struct RxToken {
 
 impl phy::RxToken for RxToken {
     fn consume<R, F>(mut self, _timestamp: Instant, f: F) -> Result<R>
-        where F: FnOnce(&mut [u8]) -> R
+        where F: FnOnce(&mut [u8]) -> Result<R>
     {
-        Ok(f(&mut self.buffer))
+        f(&mut self.buffer)
     }
 }
 
@@ -81,12 +81,12 @@ pub struct TxToken<'a> {
 
 impl<'a> phy::TxToken for TxToken<'a> {
     fn consume<R, F>(self, _timestamp: Instant, len: usize, f: F) -> Result<R>
-        where F: FnOnce(&mut [u8]) -> R
+        where F: FnOnce(&mut [u8]) -> Result<R>
     {
         let mut buffer = Vec::new();
         buffer.resize(len, 0);
         let result = f(&mut buffer);
         self.queue.push_back(buffer);
-        Ok(result)
+        result
     }
 }

src/phy/mod.rs

@@ -295,7 +295,7 @@ pub trait RxToken {
     /// The timestamp must be a number of milliseconds, monotonically increasing since an
     /// arbitrary moment in time, such as system startup.
     fn consume<R, F>(self, timestamp: Instant, f: F) -> Result<R>
-        where F: FnOnce(&mut [u8]) -> R;
+        where F: FnOnce(&mut [u8]) -> Result<R>;
 }
 
 /// A token to transmit a single network packet.
@@ -310,5 +310,5 @@ pub trait TxToken {
     /// The timestamp must be a number of milliseconds, monotonically increasing since an
     /// arbitrary moment in time, such as system startup.
     fn consume<R, F>(self, timestamp: Instant, len: usize, f: F) -> Result<R>
-        where F: FnOnce(&mut [u8]) -> R;
+        where F: FnOnce(&mut [u8]) -> Result<R>;
 }

src/phy/pcap_writer.rs

@@ -178,7 +178,7 @@ pub struct RxToken<Rx: phy::RxToken, S: PcapSink> {
 }
 
 impl<Rx: phy::RxToken, S: PcapSink> phy::RxToken for RxToken<Rx, S> {
-    fn consume<R, F: FnOnce(&mut [u8]) -> R>(self, timestamp: Instant, f: F) -> Result<R> {
+    fn consume<R, F: FnOnce(&mut [u8]) -> Result<R>>(self, timestamp: Instant, f: F) -> Result<R> {
         let Self { token, sink, mode } = self;
         token.consume(timestamp, |buffer| {
             match mode {
@@ -200,7 +200,7 @@ pub struct TxToken<Tx: phy::TxToken, S: PcapSink> {
 
 impl<Tx: phy::TxToken, S: PcapSink> phy::TxToken for TxToken<Tx, S> {
     fn consume<R, F>(self, timestamp: Instant, len: usize, f: F) -> Result<R>
-        where F: FnOnce(&mut [u8]) -> R
+        where F: FnOnce(&mut [u8]) -> Result<R>
     {
         let Self { token, sink, mode } = self;
         token.consume(timestamp, len, |buffer| {

src/phy/raw_socket.rs

@@ -80,9 +80,9 @@ pub struct RxToken {
 
 impl phy::RxToken for RxToken {
     fn consume<R, F>(mut self, _timestamp: Instant, f: F) -> Result<R>
-        where F: FnOnce(&mut [u8]) -> R
+        where F: FnOnce(&mut [u8]) -> Result<R>
     {
-        Ok(f(&mut self.buffer[..]))
+        f(&mut self.buffer[..])
     }
 }
 
@@ -93,12 +93,12 @@ pub struct TxToken {
 
 impl phy::TxToken for TxToken {
     fn consume<R, F>(self, _timestamp: Instant, len: usize, f: F) -> Result<R>
-        where F: FnOnce(&mut [u8]) -> R
+        where F: FnOnce(&mut [u8]) -> Result<R>
     {
         let mut lower = self.lower.borrow_mut();
         let mut buffer = vec![0; len];
         let result = f(&mut buffer);
         lower.send(&buffer[..]).unwrap();
-        Ok(result)
+        result
     }
 }

src/phy/tracer.rs

@@ -77,7 +77,7 @@ pub struct RxToken<Rx: phy::RxToken> {
 
 impl<Rx: phy::RxToken> phy::RxToken for RxToken<Rx> {
     fn consume<R, F>(self, timestamp: Instant, f: F) -> Result<R>
-        where F: FnOnce(&mut [u8]) -> R
+        where F: FnOnce(&mut [u8]) -> Result<R>
     {
         let Self { token, writer, medium } = self;
         token.consume(timestamp, |buffer| {
@@ -100,7 +100,7 @@ pub struct TxToken<Tx: phy::TxToken> {
 
 impl<Tx: phy::TxToken> phy::TxToken for TxToken<Tx> {
     fn consume<R, F>(self, timestamp: Instant, len: usize, f: F) -> Result<R>
-        where F: FnOnce(&mut [u8]) -> R
+        where F: FnOnce(&mut [u8]) -> Result<R>
     {
         let Self { token, writer, medium } = self;
         token.consume(timestamp, len, |buffer| {
@@ -137,4 +137,4 @@ impl<'a> fmt::Display for Packet<'a> {
             }
         }
     }
-}
+}

src/phy/tuntap_interface.rs

@@ -83,9 +83,9 @@ pub struct RxToken {
 
 impl phy::RxToken for RxToken {
     fn consume<R, F>(mut self, _timestamp: Instant, f: F) -> Result<R>
-        where F: FnOnce(&mut [u8]) -> R
+        where F: FnOnce(&mut [u8]) -> Result<R>
     {
-        Ok(f(&mut self.buffer[..]))
+        f(&mut self.buffer[..])
     }
 }
 
@@ -96,12 +96,12 @@ pub struct TxToken {
 
 impl phy::TxToken for TxToken {
     fn consume<R, F>(self, _timestamp: Instant, len: usize, f: F) -> Result<R>
-        where F: FnOnce(&mut [u8]) -> R
+        where F: FnOnce(&mut [u8]) -> Result<R>
     {
         let mut lower = self.lower.borrow_mut();
         let mut buffer = vec![0; len];
         let result = f(&mut buffer);
         lower.send(&buffer[..]).unwrap();
-        Ok(result)
+        result
     }
 }