smoltcp-rs · Jul 23, 2017 · Jul 23, 2017 · Jul 23, 2017
diff --git a/examples/loopback.rs b/examples/loopback.rs
@@ -77,7 +77,7 @@ fn main() {
     }
 
     let mut device = Loopback::new();
-    let mut device = EthernetTracer::new(device, |printer| trace!("{}", printer));
+    let mut device = EthernetTracer::new(device, |printer, _timestamp| trace!("{}", printer));
 
     let mut arp_cache_entries: [_; 8] = Default::default();
     let mut arp_cache = SliceArpCache::new(&mut arp_cache_entries[..]);

diff --git a/examples/tcpdump.rs b/examples/tcpdump.rs
@@ -8,7 +8,7 @@ fn main() {
     let ifname = env::args().nth(1).unwrap();
     let mut socket = RawSocket::new(ifname.as_ref()).unwrap();
     loop {
-        let buffer = socket.receive().unwrap();
+        let buffer = socket.receive(/*timestamp=*/0).unwrap();
         print!("{}", PrettyPrinter::<EthernetFrame<&[u8]>>::new("", &buffer))
     }
 }
diff --git a/examples/utils.rs b/examples/utils.rs
@@ -78,7 +78,7 @@ pub fn setup_device(more_args: &[&str])
     let seed = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().subsec_nanos();
 
     let device = TapInterface::new(&matches.free[0]).unwrap();
-    let device = EthernetTracer::new(device, |printer| trace!("{}", printer));
+    let device = EthernetTracer::new(device, |printer, _timestamp| trace!("{}", printer));
     let mut device = FaultInjector::new(device, seed);
     device.set_drop_chance(drop_chance);
     device.set_corrupt_chance(corrupt_chance);

diff --git a/src/iface/ethernet.rs b/src/iface/ethernet.rs
@@ -116,7 +116,7 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
         }
 
         // Now, receive any incoming packets.
-        let rx_buffer = self.device.receive()?;
+        let rx_buffer = self.device.receive(timestamp)?;
         let eth_frame = EthernetFrame::new_checked(&rx_buffer)?;
 
         // Ignore any packets not directed to our hardware address.
@@ -134,7 +134,7 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
             _ => return Err(Error::Unrecognized),
         };
 
-        self.send_response(response)
+        self.send_response(timestamp, response)
     }
 
     // Snoop all ARP traffic, and respond to ARP packets directed at us.
@@ -360,7 +360,7 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
         Ok(Response::Icmpv4(ipv4_reply_repr, icmp_reply_repr))
     }
 
-    fn send_response(&mut self, response: Response) -> Result<(), Error> {
+    fn send_response(&mut self, timestamp: u64, response: Response) -> Result<(), Error> {
         macro_rules! ip_response {
             ($tx_buffer:ident, $frame:ident, $ip_repr:ident) => ({
                 let dst_hardware_addr =
@@ -371,7 +371,7 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
 
                 let frame_len = EthernetFrame::<&[u8]>::buffer_len($ip_repr.buffer_len() +
                                                                    $ip_repr.payload_len);
-                $tx_buffer = self.device.transmit(frame_len)?;
+                $tx_buffer = self.device.transmit(timestamp, frame_len)?;
                 $frame = EthernetFrame::new_checked(&mut $tx_buffer)
                                        .expect("transmit frame too small");
                 $frame.set_src_addr(self.hardware_addr);
@@ -387,7 +387,7 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
         match response {
             Response::Arp(repr) => {
                 let tx_len = EthernetFrame::<&[u8]>::buffer_len(repr.buffer_len());
-                let mut tx_buffer = self.device.transmit(tx_len)?;
+                let mut tx_buffer = self.device.transmit(timestamp, tx_len)?;
                 let mut frame = EthernetFrame::new_checked(&mut tx_buffer)
                                               .expect("transmit frame too small");
                 frame.set_src_addr(self.hardware_addr);
@@ -449,7 +449,7 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
                     Some(dst_hardware_addr) => {
                         let tx_len = EthernetFrame::<&[u8]>::buffer_len(repr.buffer_len() +
                                                                         payload.buffer_len());
-                        let mut tx_buffer = device.transmit(tx_len)?;
+                        let mut tx_buffer = device.transmit(timestamp, tx_len)?;
                         let mut frame = EthernetFrame::new_checked(&mut tx_buffer)
                                                       .expect("transmit frame too small");
                         frame.set_src_addr(src_hardware_addr);
@@ -480,7 +480,7 @@ impl<'a, 'b, 'c, DeviceT: Device + 'a> Interface<'a, 'b, 'c, DeviceT> {
                         };
 
                         let tx_len = EthernetFrame::<&[u8]>::buffer_len(payload.buffer_len());
-                        let mut tx_buffer = device.transmit(tx_len)?;
+                        let mut tx_buffer = device.transmit(timestamp, tx_len)?;
                         let mut frame = EthernetFrame::new_checked(&mut tx_buffer)
                                                       .expect("transmit frame too small");
                         frame.set_src_addr(src_hardware_addr);

diff --git a/src/lib.rs b/src/lib.rs
@@ -84,35 +84,18 @@ extern crate collections;
 #[macro_use(trace, log, log_enabled)]
 extern crate log;
 
-macro_rules! net_trace {
-    ($($arg:expr),*) => {
-        #[cfg(feature = "log")]
-        trace!($($arg),*);
-        #[cfg(not(feature = "log"))]
-        $( let _ = $arg );*; // suppress unused variable warnings
-    }
-}
-
-macro_rules! net_trace_enabled {
-    () => ({
-        #[cfg(feature = "log")]
-        fn enabled() -> bool { log_enabled!($crate::log::LogLevel::Trace) }
-        #[cfg(not(feature = "log"))]
-        fn enabled() -> bool { false }
-        enabled()
-    })
-}
-
 use core::fmt;
 
+#[macro_use]
+mod macros;
+mod parsing;
+
 pub mod storage;
 pub mod phy;
 pub mod wire;
 pub mod iface;
 pub mod socket;
 
-mod parsing;
-
 /// The error type for the networking stack.
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum Error {

diff --git a/src/macros.rs b/src/macros.rs
@@ -0,0 +1,71 @@
+macro_rules! net_trace {
+    ($($arg:expr),*) => {
+        #[cfg(feature = "log")]
+        trace!($($arg),*);
+        #[cfg(not(feature = "log"))]
+        $( let _ = $arg );*; // suppress unused variable warnings
+    }
+}
+
+macro_rules! net_trace_enabled {
+    () => ({
+        #[cfg(feature = "log")]
+        fn enabled() -> bool { log_enabled!($crate::log::LogLevel::Trace) }
+        #[cfg(not(feature = "log"))]
+        fn enabled() -> bool { false }
+        enabled()
+    })
+}
+
+macro_rules! enum_with_unknown {
+    (
+        $( #[$enum_attr:meta] )*
+        pub enum $name:ident($ty:ty) {
+            $( $variant:ident = $value:expr ),+
+        }
+    ) => {
+        enum_with_unknown! {
+            $( #[$enum_attr] )*
+            pub doc enum $name($ty) {
+                $( #[doc(shown)] $variant = $value ),+
+            }
+        }
+    };
+    (
+        $( #[$enum_attr:meta] )*
+        pub doc enum $name:ident($ty:ty) {
+            $(
+              $( #[$variant_attr:meta] )+
+              $variant:ident = $value:expr
+            ),+
+        }
+    ) => {
+        #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+        $( #[$enum_attr] )*
+        pub enum $name {
+            $(
+              $( #[$variant_attr] )*
+              $variant
+            ),*,
+            Unknown($ty)
+        }
+
+        impl ::core::convert::From<$ty> for $name {
+            fn from(value: $ty) -> Self {
+                match value {
+                    $( $value => $name::$variant ),*,
+                    other => $name::Unknown(other)
+                }
+            }
+        }
+
+        impl ::core::convert::From<$name> for $ty {
+            fn from(value: $name) -> Self {
+                match value {
+                    $( $name::$variant => $value ),*,
+                    $name::Unknown(other) => other
+                }
+            }
+        }
+    }
+}
diff --git a/src/phy/fault_injector.rs b/src/phy/fault_injector.rs
@@ -108,15 +108,15 @@ impl State {
 /// adverse network conditions (such as random packet loss or corruption), or software
 /// or hardware limitations (such as a limited number or size of usable network buffers).
 #[derive(Debug)]
-pub struct FaultInjector<T: Device> {
-    lower:  T,
+pub struct FaultInjector<D: Device> {
+    lower:  D,
     state:  State,
     config: Config
 }
 
-impl<T: Device> FaultInjector<T> {
+impl<D: Device> FaultInjector<D> {
     /// Create a fault injector device, using the given random number generator seed.
-    pub fn new(lower: T, seed: u32) -> FaultInjector<T> {
+    pub fn new(lower: D, seed: u32) -> FaultInjector<D> {
         #[cfg(feature = "std")]
         let state = State {
             rng_seed:    seed,
@@ -136,7 +136,7 @@ impl<T: Device> FaultInjector<T> {
     }
 
     /// Return the underlying device, consuming the fault injector.
-    pub fn into_lower(self) -> T {
+    pub fn into_lower(self) -> D {
         self.lower
     }
 
@@ -216,10 +216,10 @@ impl<T: Device> FaultInjector<T> {
     }
 }
 
-impl<T: Device> Device for FaultInjector<T>
-        where T::RxBuffer: AsMut<[u8]> {
-    type RxBuffer = T::RxBuffer;
-    type TxBuffer = TxBuffer<T::TxBuffer>;
+impl<D: Device> Device for FaultInjector<D>
+        where D::RxBuffer: AsMut<[u8]> {
+    type RxBuffer = D::RxBuffer;
+    type TxBuffer = TxBuffer<D::TxBuffer>;
 
     fn limits(&self) -> DeviceLimits {
         let mut limits = self.lower.limits();
@@ -229,8 +229,8 @@ impl<T: Device> Device for FaultInjector<T>
         limits
     }
 
-    fn receive(&mut self) -> Result<Self::RxBuffer, Error> {
-        let mut buffer = self.lower.receive()?;
+    fn receive(&mut self, timestamp: u64) -> Result<Self::RxBuffer, Error> {
+        let mut buffer = self.lower.receive(timestamp)?;
         if self.state.maybe(self.config.drop_pct) {
             net_trace!("rx: randomly dropping a packet");
             return Err(Error::Exhausted)
@@ -250,7 +250,7 @@ impl<T: Device> Device for FaultInjector<T>
         Ok(buffer)
     }
 
-    fn transmit(&mut self, length: usize) -> Result<Self::TxBuffer, Error> {
+    fn transmit(&mut self, timestamp: u64, length: usize) -> Result<Self::TxBuffer, Error> {
         let buffer;
         if self.state.maybe(self.config.drop_pct) {
             net_trace!("tx: randomly dropping a packet");
@@ -262,7 +262,7 @@ impl<T: Device> Device for FaultInjector<T>
             net_trace!("tx: dropping a packet because of rate limiting");
             buffer = None;
         } else {
-            buffer = Some(self.lower.transmit(length)?);
+            buffer = Some(self.lower.transmit(timestamp, length)?);
         }
         Ok(TxBuffer {
             buffer: buffer,
@@ -275,16 +275,15 @@ impl<T: Device> Device for FaultInjector<T>
 }
 
 #[doc(hidden)]
-pub struct TxBuffer<T: AsRef<[u8]> + AsMut<[u8]>> {
+pub struct TxBuffer<B: AsRef<[u8]> + AsMut<[u8]>> {
     state:  State,
     config: Config,
-    buffer: Option<T>,
+    buffer: Option<B>,
     junk:   [u8; MTU],
     length: usize
 }
 
-impl<T: AsRef<[u8]> + AsMut<[u8]>> AsRef<[u8]>
-        for TxBuffer<T> {
+impl<B: AsRef<[u8]> + AsMut<[u8]>> AsRef<[u8]> for TxBuffer<B> {
     fn as_ref(&self) -> &[u8] {
         match self.buffer {
             Some(ref buf) => buf.as_ref(),
@@ -293,8 +292,7 @@ impl<T: AsRef<[u8]> + AsMut<[u8]>> AsRef<[u8]>
     }
 }
 
-impl<T: AsRef<[u8]> + AsMut<[u8]>> AsMut<[u8]>
-        for TxBuffer<T> {
+impl<B: AsRef<[u8]> + AsMut<[u8]>> AsMut<[u8]> for TxBuffer<B> {
     fn as_mut(&mut self) -> &mut [u8] {
         match self.buffer {
             Some(ref mut buf) => buf.as_mut(),
@@ -303,7 +301,7 @@ impl<T: AsRef<[u8]> + AsMut<[u8]>> AsMut<[u8]>
     }
 }
 
-impl<T: AsRef<[u8]> + AsMut<[u8]>> Drop for TxBuffer<T> {
+impl<B: AsRef<[u8]> + AsMut<[u8]>> Drop for TxBuffer<B> {
     fn drop(&mut self) {
         match self.buffer {
             Some(ref mut buf) => {

diff --git a/src/phy/loopback.rs b/src/phy/loopback.rs
@@ -39,14 +39,14 @@ impl Device for Loopback {
         }
     }
 
-    fn receive(&mut self) -> Result<Self::RxBuffer, Error> {
+    fn receive(&mut self, _timestamp: u64) -> Result<Self::RxBuffer, Error> {
         match self.0.borrow_mut().pop_front() {
             Some(packet) => Ok(packet),
             None => Err(Error::Exhausted)
         }
     }
 
-    fn transmit(&mut self, length: usize) -> Result<Self::TxBuffer, Error> {
+    fn transmit(&mut self, _timestamp: u64, length: usize) -> Result<Self::TxBuffer, Error> {
         let mut buffer = Vec::new();
         buffer.resize(length, 0);
         Ok(TxBuffer {

diff --git a/src/phy/mod.rs b/src/phy/mod.rs
@@ -61,7 +61,7 @@ impl Device for EthernetDevice {
         limits
     }
 
-    fn receive(&mut self) -> Result<Self::RxBuffer, Error> {
+    fn receive(&mut self, _timestamp: u64) -> Result<Self::RxBuffer, Error> {
         if rx_full() {
             let index = self.rx_next;
             self.rx_next = (self.rx_next + 1) % RX_BUFFERS.len();
@@ -75,7 +75,7 @@ impl Device for EthernetDevice {
         }
     }
 
-    fn transmit(&mut self, length: usize) -> Result<Self::TxBuffer, Error> {
+    fn transmit(&mut self, _timestamp: u64, length: usize) -> Result<Self::TxBuffer, Error> {
         if tx_empty() {
             let index = self.tx_next;
             self.tx_next = (self.tx_next + 1) % TX_BUFFERS.len();
@@ -175,12 +175,12 @@ pub trait Device {
     /// It is expected that a `receive` implementation, once a packet is written to memory
     /// through DMA, would gain ownership of the underlying buffer, provide it for parsing,
     /// and return it to the network device once it is dropped.
-    fn receive(&mut self) -> Result<Self::RxBuffer, Error>;
+    fn receive(&mut self, timestamp: u64) -> Result<Self::RxBuffer, Error>;
 
     /// Transmit a frame.
     ///
     /// It is expected that a `transmit` implementation would gain ownership of a buffer with
     /// the requested length, provide it for emission, and schedule it to be read from
     /// memory by the network device once it is dropped.
-    fn transmit(&mut self, length: usize) -> Result<Self::TxBuffer, Error>;
+    fn transmit(&mut self, timestamp: u64, length: usize) -> Result<Self::TxBuffer, Error>;
 }
diff --git a/src/phy/raw_socket.rs b/src/phy/raw_socket.rs
@@ -40,15 +40,15 @@ impl Device for RawSocket {
         }
     }
 
-    fn receive(&mut self) -> Result<Self::RxBuffer, Error> {
+    fn receive(&mut self, _timestamp: u64) -> Result<Self::RxBuffer, Error> {
         let mut lower = self.lower.borrow_mut();
         let mut buffer = vec![0; self.mtu];
         let size = lower.recv(&mut buffer[..]).unwrap();
         buffer.resize(size, 0);
         Ok(buffer)
     }
 
-    fn transmit(&mut self, length: usize) -> Result<Self::TxBuffer, Error> {
+    fn transmit(&mut self, _timestamp: u64, length: usize) -> Result<Self::TxBuffer, Error> {
         Ok(TxBuffer {
             lower:  self.lower.clone(),
             buffer: vec![0; length]

diff --git a/src/phy/tap_interface.rs b/src/phy/tap_interface.rs
@@ -41,7 +41,7 @@ impl Device for TapInterface {
         }
     }
 
-    fn receive(&mut self) -> Result<Self::RxBuffer, Error> {
+    fn receive(&mut self, _timestamp: u64) -> Result<Self::RxBuffer, Error> {
         let mut lower = self.lower.borrow_mut();
         let mut buffer = vec![0; self.mtu];
         match lower.recv(&mut buffer[..]) {
@@ -56,7 +56,7 @@ impl Device for TapInterface {
         }
     }
 
-    fn transmit(&mut self, length: usize) -> Result<Self::TxBuffer, Error> {
+    fn transmit(&mut self, _timestamp: u64, length: usize) -> Result<Self::TxBuffer, Error> {
         Ok(TxBuffer {
             lower:  self.lower.clone(),
             buffer: vec![0; length]