Merge #573

573: Simpler rand r=Dirbaio a=Dirbaio

Requires #571 

Revisits #547, because it turns out the `rand_custom_impl!` macro stuff was less nice than I thought. It's now a simple PRNG owned by Interface. The builder allows setting the random seed.

Co-authored-by: Dario Nieuwenhuis <dirbaio@dirbaio.net>
Co-authored-by: Thibaut Vandervelden <thvdveld@vub.be>
Co-authored-by: bors[bot] <26634292+bors[bot]@users.noreply.github.com>

.github/workflows/test.yml

@@ -48,7 +48,7 @@ jobs:
         include:
           # Test alloc feature which requires nightly.
           - rust: nightly
-            features: alloc rand-custom-impl medium-ethernet proto-ipv4 proto-ipv6 socket-raw socket-udp socket-tcp socket-icmp
+            features: alloc medium-ethernet proto-ipv4 proto-ipv6 socket-raw socket-udp socket-tcp socket-icmp
     steps:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
@@ -73,8 +73,8 @@ jobs:
 
         features:
           # These feature sets cannot run tests, so we only check they build.
-          - rand-custom-impl medium-ip medium-ethernet medium-ieee802154 proto-ipv6 proto-ipv6 proto-igmp proto-dhcpv4 socket-raw socket-udp socket-tcp socket-icmp async
-          - rand-custom-impl defmt medium-ip medium-ethernet proto-ipv6 proto-ipv6 proto-igmp proto-dhcpv4 socket-raw socket-udp socket-tcp socket-icmp async
+          - medium-ip medium-ethernet medium-ieee802154 proto-ipv6 proto-ipv6 proto-igmp proto-dhcpv4 socket-raw socket-udp socket-tcp socket-icmp async
+          - defmt medium-ip medium-ethernet proto-ipv6 proto-ipv6 proto-igmp proto-dhcpv4 socket-raw socket-udp socket-tcp socket-icmp async
 
     steps:
       - uses: actions/checkout@v2

Cargo.toml

@@ -34,7 +34,6 @@ url = "1.0"
 std = ["managed/std", "rand_core/std"]
 alloc = ["managed/alloc"]
 verbose = []
-rand-custom-impl = []
 "medium-ethernet" = ["socket"]
 "medium-ip" = ["socket"]
 "medium-ieee802154" = ["socket", "proto-sixlowpan"]

examples/client.rs

@@ -54,8 +54,8 @@ fn main() {
 
     let tcp_handle = iface.add_socket(tcp_socket);
 
-    let socket = iface.get_socket::<TcpSocket>(tcp_handle);
-    socket.connect((address, port), 49500).unwrap();
+    let (socket, cx) = iface.get_socket_and_context::<TcpSocket>(tcp_handle);
+    socket.connect(cx, (address, port), 49500).unwrap();
 
     let mut tcp_active = false;
     loop {

examples/httpclient.rs

@@ -76,14 +76,14 @@ fn main() {
             }
         }
 
-        let socket = iface.get_socket::<TcpSocket>(tcp_handle);
+        let (socket, cx) = iface.get_socket_and_context::<TcpSocket>(tcp_handle);
 
         state = match state {
             State::Connect if !socket.is_active() => {
                 debug!("connecting");
                 let local_port = 49152 + rand::random::<u16>() % 16384;
                 socket
-                    .connect((address, url.port().unwrap_or(80)), local_port)
+                    .connect(cx, (address, url.port().unwrap_or(80)), local_port)
                     .unwrap();
                 State::Request
             }

examples/loopback.rs

@@ -37,14 +37,6 @@ mod mock {
             self.0.get()
         }
     }
-
-    struct Rand;
-    smoltcp::rand_custom_impl!(Rand);
-    impl smoltcp::Rand for Rand {
-        fn rand_bytes(buf: &mut [u8]) {
-            buf.fill(0x42);
-        }
-    }
 }
 
 #[cfg(feature = "std")]
@@ -153,12 +145,13 @@ fn main() {
             done = true;
         }
 
-        let mut socket = iface.get_socket::<TcpSocket>(client_handle);
+        let (mut socket, cx) = iface.get_socket_and_context::<TcpSocket>(client_handle);
         if !socket.is_open() {
             if !did_connect {
                 debug!("connecting");
                 socket
                     .connect(
+                        cx,
                         (IpAddress::v4(127, 0, 0, 1), 1234),
                         (IpAddress::Unspecified, 65000),
                     )

src/iface/mod.rs

@@ -20,4 +20,4 @@ pub use self::neighbor::Neighbor;
 pub use self::route::{Route, Routes};
 pub use socket_set::{SocketHandle, SocketStorage};
 
-pub use self::interface::{Interface, InterfaceBuilder};
+pub use self::interface::{Interface, InterfaceBuilder, InterfaceInner as Context};

src/lib.rs

@@ -134,10 +134,7 @@ use core::fmt;
 #[macro_use]
 mod macros;
 mod parsers;
-
 mod rand;
-#[cfg(feature = "rand-custom-impl")]
-pub use crate::rand::Rand;
 
 #[cfg(any(
     feature = "medium-ethernet",

src/rand.rs

@@ -1,67 +1,26 @@
 #![allow(unsafe_code)]
 #![allow(unused)]
 
-#[cfg(not(any(test, feature = "std", feature = "rand-custom-impl")))]
-compile_error!("None of the Cargo features `std` or `rand-custom-impl` is enabled. smoltcp needs a `rand` implementation to work. If your target supports `std`, enable the `std` feature to use the OS's RNG. Otherwise, you must enable the `rand-custom-impl` Cargo feature, and supply your own custom implementation using the `smoltcp::rand_custom_impl!()` macro");
-
-pub fn rand_u32() -> u32 {
-    let mut val = [0; 4];
-    rand_bytes(&mut val);
-    u32::from_ne_bytes(val)
+#[derive(Debug)]
+pub(crate) struct Rand {
+    state: u64,
 }
 
-/// Fill `buf` with random bytes.
-pub fn rand_bytes(buf: &mut [u8]) {
-    extern "Rust" {
-        fn _smoltcp_rand(buf: &mut [u8]);
+impl Rand {
+    pub(crate) const fn new(seed: u64) -> Self {
+        Self { state: seed }
     }
 
-    unsafe { _smoltcp_rand(buf) }
-}
+    pub(crate) fn rand_u32(&mut self) -> u32 {
+        // sPCG32 from https://www.pcg-random.org/paper.html
+        // see also https://nullprogram.com/blog/2017/09/21/
+        const M: u64 = 0xbb2efcec3c39611d;
+        const A: u64 = 0x7590ef39;
 
-/// Methods required for a custom rand implementation.
-///
-/// This trait is not intended to be used directly, just to supply a custom rand implementation to smoltcp.
-#[cfg(feature = "rand-custom-impl")]
-pub trait Rand {
-    /// Fill `buf` with random bytes.
-    fn rand_bytes(buf: &mut [u8]);
-}
-
-/// Set the custom rand implementation.
-///
-/// # Example
-///
-/// ```
-/// struct Rand;
-/// smoltcp::rand_custom_impl!(Rand);
-/// impl smoltcp::Rand for Rand {
-///     fn rand_bytes(buf: &mut [u8]) {
-///         // TODO
-///     }
-/// }
-///
-#[macro_export]
-#[cfg(feature = "rand-custom-impl")]
-macro_rules! rand_custom_impl {
-    ($t: ty) => {
-        #[no_mangle]
-        fn _smoltcp_rand(buf: &mut [u8]) {
-            <$t as $crate::Rand>::rand_bytes(buf)
-        }
-    };
-}
+        let s = self.state * M + A;
+        self.state = s;
 
-#[cfg(all(feature = "std", not(feature = "rand-custom-impl"), not(test)))]
-#[no_mangle]
-fn _smoltcp_rand(buf: &mut [u8]) {
-    use rand_core::RngCore;
-
-    rand_core::OsRng.fill_bytes(buf)
-}
-
-#[cfg(test)]
-#[no_mangle]
-fn _smoltcp_rand(buf: &mut [u8]) {
-    panic!("Rand should not be used when testing");
+        let shift = 29 - (s >> 61);
+        (s >> shift) as u32
+    }
 }

src/socket/dhcpv4.rs

@@ -1,4 +1,4 @@
-use crate::socket::Context;
+use crate::iface::Context;
 use crate::time::{Duration, Instant};
 use crate::wire::dhcpv4::field as dhcpv4_field;
 use crate::wire::HardwareAddress;
@@ -181,7 +181,7 @@ impl Dhcpv4Socket {
         self.ignore_naks = ignore_naks;
     }
 
-    pub(crate) fn poll_at(&self, _cx: &Context) -> PollAt {
+    pub(crate) fn poll_at(&self, _cx: &mut Context) -> PollAt {
         let t = match &self.state {
             ClientState::Discovering(state) => state.retry_at,
             ClientState::Requesting(state) => state.retry_at,
@@ -192,7 +192,7 @@ impl Dhcpv4Socket {
 
     pub(crate) fn process(
         &mut self,
-        cx: &Context,
+        cx: &mut Context,
         ip_repr: &Ipv4Repr,
         repr: &UdpRepr,
         payload: &[u8],
@@ -216,7 +216,7 @@ impl Dhcpv4Socket {
                 return Ok(());
             }
         };
-        let hardware_addr = if let Some(HardwareAddress::Ethernet(addr)) = cx.hardware_addr {
+        let hardware_addr = if let Some(HardwareAddress::Ethernet(addr)) = cx.hardware_addr() {
             addr
         } else {
             return Err(Error::Malformed);
@@ -254,7 +254,7 @@ impl Dhcpv4Socket {
                 }
 
                 self.state = ClientState::Requesting(RequestState {
-                    retry_at: cx.now,
+                    retry_at: cx.now(),
                     retry: 0,
                     server: ServerInfo {
                         address: src_ip,
@@ -265,7 +265,7 @@ impl Dhcpv4Socket {
             }
             (ClientState::Requesting(state), DhcpMessageType::Ack) => {
                 if let Some((config, renew_at, expires_at)) =
-                    Self::parse_ack(cx.now, &dhcp_repr, self.max_lease_duration)
+                    Self::parse_ack(cx.now(), &dhcp_repr, self.max_lease_duration)
                 {
                     self.config_changed = true;
                     self.state = ClientState::Renewing(RenewState {
@@ -283,7 +283,7 @@ impl Dhcpv4Socket {
             }
             (ClientState::Renewing(state), DhcpMessageType::Ack) => {
                 if let Some((config, renew_at, expires_at)) =
-                    Self::parse_ack(cx.now, &dhcp_repr, self.max_lease_duration)
+                    Self::parse_ack(cx.now(), &dhcp_repr, self.max_lease_duration)
                 {
                     state.renew_at = renew_at;
                     state.expires_at = expires_at;
@@ -370,22 +370,22 @@ impl Dhcpv4Socket {
     }
 
     #[cfg(not(test))]
-    fn random_transaction_id() -> u32 {
-        crate::rand::rand_u32()
+    fn random_transaction_id(cx: &mut Context) -> u32 {
+        cx.rand().rand_u32()
     }
 
     #[cfg(test)]
-    fn random_transaction_id() -> u32 {
+    fn random_transaction_id(_cx: &mut Context) -> u32 {
         0x12345678
     }
 
-    pub(crate) fn dispatch<F>(&mut self, cx: &Context, emit: F) -> Result<()>
+    pub(crate) fn dispatch<F>(&mut self, cx: &mut Context, emit: F) -> Result<()>
     where
-        F: FnOnce((Ipv4Repr, UdpRepr, DhcpRepr)) -> Result<()>,
+        F: FnOnce(&mut Context, (Ipv4Repr, UdpRepr, DhcpRepr)) -> Result<()>,
     {
         // note: Dhcpv4Socket is only usable in ethernet mediums, so the
         // unwrap can never fail.
-        let ethernet_addr = if let Some(HardwareAddress::Ethernet(addr)) = cx.hardware_addr {
+        let ethernet_addr = if let Some(HardwareAddress::Ethernet(addr)) = cx.hardware_addr() {
             addr
         } else {
             return Err(Error::Malformed);
@@ -397,7 +397,7 @@ impl Dhcpv4Socket {
 
         // We don't directly modify self.transaction_id because sending the packet
         // may fail. We only want to update state after succesfully sending.
-        let next_transaction_id = Self::random_transaction_id();
+        let next_transaction_id = Self::random_transaction_id(cx);
 
         let mut dhcp_repr = DhcpRepr {
             message_type: DhcpMessageType::Discover,
@@ -414,7 +414,7 @@ impl Dhcpv4Socket {
             client_identifier: Some(ethernet_addr),
             server_identifier: None,
             parameter_request_list: Some(PARAMETER_REQUEST_LIST),
-            max_size: Some((cx.caps.ip_mtu() - MAX_IPV4_HEADER_LEN - UDP_HEADER_LEN) as u16),
+            max_size: Some((cx.ip_mtu() - MAX_IPV4_HEADER_LEN - UDP_HEADER_LEN) as u16),
             lease_duration: None,
             dns_servers: None,
         };
@@ -434,7 +434,7 @@ impl Dhcpv4Socket {
 
         match &mut self.state {
             ClientState::Discovering(state) => {
-                if cx.now < state.retry_at {
+                if cx.now() < state.retry_at {
                     return Err(Error::Exhausted);
                 }
 
@@ -445,15 +445,15 @@ impl Dhcpv4Socket {
                     dhcp_repr
                 );
                 ipv4_repr.payload_len = udp_repr.header_len() + dhcp_repr.buffer_len();
-                emit((ipv4_repr, udp_repr, dhcp_repr))?;
+                emit(cx, (ipv4_repr, udp_repr, dhcp_repr))?;
 
                 // Update state AFTER the packet has been successfully sent.
-                state.retry_at = cx.now + DISCOVER_TIMEOUT;
+                state.retry_at = cx.now() + DISCOVER_TIMEOUT;
                 self.transaction_id = next_transaction_id;
                 Ok(())
             }
             ClientState::Requesting(state) => {
-                if cx.now < state.retry_at {
+                if cx.now() < state.retry_at {
                     return Err(Error::Exhausted);
                 }
 
@@ -474,24 +474,24 @@ impl Dhcpv4Socket {
                     dhcp_repr
                 );
                 ipv4_repr.payload_len = udp_repr.header_len() + dhcp_repr.buffer_len();
-                emit((ipv4_repr, udp_repr, dhcp_repr))?;
+                emit(cx, (ipv4_repr, udp_repr, dhcp_repr))?;
 
                 // Exponential backoff: Double every 2 retries.
-                state.retry_at = cx.now + (REQUEST_TIMEOUT << (state.retry as u32 / 2));
+                state.retry_at = cx.now() + (REQUEST_TIMEOUT << (state.retry as u32 / 2));
                 state.retry += 1;
 
                 self.transaction_id = next_transaction_id;
                 Ok(())
             }
             ClientState::Renewing(state) => {
-                if state.expires_at <= cx.now {
+                if state.expires_at <= cx.now() {
                     net_debug!("DHCP lease expired");
                     self.reset();
                     // return Ok so we get polled again
                     return Ok(());
                 }
 
-                if cx.now < state.renew_at {
+                if cx.now() < state.renew_at {
                     return Err(Error::Exhausted);
                 }
 
@@ -502,14 +502,15 @@ impl Dhcpv4Socket {
 
                 net_debug!("DHCP send renew to {}: {:?}", ipv4_repr.dst_addr, dhcp_repr);
                 ipv4_repr.payload_len = udp_repr.header_len() + dhcp_repr.buffer_len();
-                emit((ipv4_repr, udp_repr, dhcp_repr))?;
+                emit(cx, (ipv4_repr, udp_repr, dhcp_repr))?;
 
                 // In both RENEWING and REBINDING states, if the client receives no
                 // response to its DHCPREQUEST message, the client SHOULD wait one-half
                 // of the remaining time until T2 (in RENEWING state) and one-half of
                 // the remaining lease time (in REBINDING state), down to a minimum of
                 // 60 seconds, before retransmitting the DHCPREQUEST message.
-                state.renew_at = cx.now + MIN_RENEW_TIMEOUT.max((state.expires_at - cx.now) / 2);
+                state.renew_at =
+                    cx.now() + MIN_RENEW_TIMEOUT.max((state.expires_at - cx.now()) / 2);
 
                 self.transaction_id = next_transaction_id;
                 Ok(())
@@ -551,17 +552,39 @@ impl Dhcpv4Socket {
 #[cfg(test)]
 mod test {
 
+    use std::ops::{Deref, DerefMut};
+
     use super::*;
     use crate::wire::EthernetAddress;
 
     // =========================================================================================//
     // Helper functions
 
+    struct TestSocket {
+        socket: Dhcpv4Socket,
+        cx: Context<'static>,
+    }
+
+    impl Deref for TestSocket {
+        type Target = Dhcpv4Socket;
+        fn deref(&self) -> &Self::Target {
+            &self.socket
+        }
+    }
+
+    impl DerefMut for TestSocket {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.socket
+        }
+    }
+
     fn send(
-        socket: &mut Dhcpv4Socket,
+        s: &mut TestSocket,
         timestamp: Instant,
         (ip_repr, udp_repr, dhcp_repr): (Ipv4Repr, UdpRepr, DhcpRepr),
     ) -> Result<()> {
+        s.cx.set_now(timestamp);
+
         net_trace!("send: {:?}", ip_repr);
         net_trace!("      {:?}", udp_repr);
         net_trace!("      {:?}", dhcp_repr);
@@ -571,44 +594,39 @@ mod test {
             .emit(&mut DhcpPacket::new_unchecked(&mut payload))
             .unwrap();
 
-        let mut cx = Context::DUMMY.clone();
-        cx.now = timestamp;
-        socket.process(&cx, &ip_repr, &udp_repr, &payload)
+        s.socket.process(&mut s.cx, &ip_repr, &udp_repr, &payload)
     }
 
-    fn recv(
-        socket: &mut Dhcpv4Socket,
-        timestamp: Instant,
-        reprs: &[(Ipv4Repr, UdpRepr, DhcpRepr)],
-    ) {
-        let mut cx = Context::DUMMY.clone();
-        cx.now = timestamp;
+    fn recv(s: &mut TestSocket, timestamp: Instant, reprs: &[(Ipv4Repr, UdpRepr, DhcpRepr)]) {
+        s.cx.set_now(timestamp);
 
         let mut i = 0;
 
-        while socket.poll_at(&cx) <= PollAt::Time(timestamp) {
-            let _ = socket.dispatch(&cx, |(mut ip_repr, udp_repr, dhcp_repr)| {
-                assert_eq!(ip_repr.protocol, IpProtocol::Udp);
-                assert_eq!(
-                    ip_repr.payload_len,
-                    udp_repr.header_len() + dhcp_repr.buffer_len()
-                );
-
-                // We validated the payload len, change it to 0 to make equality testing easier
-                ip_repr.payload_len = 0;
-
-                net_trace!("recv: {:?}", ip_repr);
-                net_trace!("      {:?}", udp_repr);
-                net_trace!("      {:?}", dhcp_repr);
-
-                let got_repr = (ip_repr, udp_repr, dhcp_repr);
-                match reprs.get(i) {
-                    Some(want_repr) => assert_eq!(want_repr, &got_repr),
-                    None => panic!("Too many reprs emitted"),
-                }
-                i += 1;
-                Ok(())
-            });
+        while s.socket.poll_at(&mut s.cx) <= PollAt::Time(timestamp) {
+            let _ = s
+                .socket
+                .dispatch(&mut s.cx, |_, (mut ip_repr, udp_repr, dhcp_repr)| {
+                    assert_eq!(ip_repr.protocol, IpProtocol::Udp);
+                    assert_eq!(
+                        ip_repr.payload_len,
+                        udp_repr.header_len() + dhcp_repr.buffer_len()
+                    );
+
+                    // We validated the payload len, change it to 0 to make equality testing easier
+                    ip_repr.payload_len = 0;
+
+                    net_trace!("recv: {:?}", ip_repr);
+                    net_trace!("      {:?}", udp_repr);
+                    net_trace!("      {:?}", dhcp_repr);
+
+                    let got_repr = (ip_repr, udp_repr, dhcp_repr);
+                    match reprs.get(i) {
+                        Some(want_repr) => assert_eq!(want_repr, &got_repr),
+                        None => panic!("Too many reprs emitted"),
+                    }
+                    i += 1;
+                    Ok(())
+                });
         }
 
         assert_eq!(i, reprs.len());
@@ -780,13 +798,16 @@ mod test {
     // =========================================================================================//
     // Tests
 
-    fn socket() -> Dhcpv4Socket {
+    fn socket() -> TestSocket {
         let mut s = Dhcpv4Socket::new();
         assert_eq!(s.poll(), Some(Event::Deconfigured));
-        s
+        TestSocket {
+            socket: s,
+            cx: Context::mock(),
+        }
     }
 
-    fn socket_bound() -> Dhcpv4Socket {
+    fn socket_bound() -> TestSocket {
         let mut s = socket();
         s.state = ClientState::Renewing(RenewState {
             config: Config {

src/socket/icmp.rs

@@ -323,7 +323,7 @@ impl<'a> IcmpSocket<'a> {
 
     /// Filter determining which packets received by the interface are appended to
     /// the given sockets received buffer.
-    pub(crate) fn accepts(&self, cx: &Context, ip_repr: &IpRepr, icmp_repr: &IcmpRepr) -> bool {
+    pub(crate) fn accepts(&self, cx: &mut Context, ip_repr: &IpRepr, icmp_repr: &IcmpRepr) -> bool {
         match (&self.endpoint, icmp_repr) {
             // If we are bound to ICMP errors associated to a UDP port, only
             // accept Destination Unreachable messages with the data containing
@@ -338,7 +338,7 @@ impl<'a> IcmpSocket<'a> {
                     &packet,
                     &ip_repr.src_addr(),
                     &ip_repr.dst_addr(),
-                    &cx.caps.checksum,
+                    &cx.checksum_caps(),
                 ) {
                     Ok(repr) => endpoint.port == repr.src_port,
                     Err(_) => false,
@@ -354,7 +354,7 @@ impl<'a> IcmpSocket<'a> {
                     &packet,
                     &ip_repr.src_addr(),
                     &ip_repr.dst_addr(),
-                    &cx.caps.checksum,
+                    &cx.checksum_caps(),
                 ) {
                     Ok(repr) => endpoint.port == repr.src_port,
                     Err(_) => false,
@@ -387,7 +387,7 @@ impl<'a> IcmpSocket<'a> {
 
     pub(crate) fn process(
         &mut self,
-        _cx: &Context,
+        _cx: &mut Context,
         ip_repr: &IpRepr,
         icmp_repr: &IcmpRepr,
     ) -> Result<()> {
@@ -434,9 +434,9 @@ impl<'a> IcmpSocket<'a> {
         Ok(())
     }
 
-    pub(crate) fn dispatch<F>(&mut self, _cx: &Context, emit: F) -> Result<()>
+    pub(crate) fn dispatch<F>(&mut self, cx: &mut Context, emit: F) -> Result<()>
     where
-        F: FnOnce((IpRepr, IcmpRepr)) -> Result<()>,
+        F: FnOnce(&mut Context, (IpRepr, IcmpRepr)) -> Result<()>,
     {
         let hop_limit = self.hop_limit.unwrap_or(64);
         self.tx_buffer.dequeue_with(|remote_endpoint, packet_buf| {
@@ -457,7 +457,7 @@ impl<'a> IcmpSocket<'a> {
                         payload_len: repr.buffer_len(),
                         hop_limit: hop_limit,
                     });
-                    emit((ip_repr, IcmpRepr::Ipv4(repr)))
+                    emit(cx, (ip_repr, IcmpRepr::Ipv4(repr)))
                 }
                 #[cfg(feature = "proto-ipv6")]
                 IpAddress::Ipv6(ipv6_addr) => {
@@ -476,7 +476,7 @@ impl<'a> IcmpSocket<'a> {
                         payload_len: repr.buffer_len(),
                         hop_limit: hop_limit,
                     });
-                    emit((ip_repr, IcmpRepr::Ipv6(repr)))
+                    emit(cx, (ip_repr, IcmpRepr::Ipv6(repr)))
                 }
                 _ => Err(Error::Unaddressable),
             }
@@ -488,7 +488,7 @@ impl<'a> IcmpSocket<'a> {
         Ok(())
     }
 
-    pub(crate) fn poll_at(&self, _cx: &Context) -> PollAt {
+    pub(crate) fn poll_at(&self, _cx: &mut Context) -> PollAt {
         if self.tx_buffer.is_empty() {
             PollAt::Ingress
         } else {
@@ -575,10 +575,11 @@ mod test_ipv4 {
     #[test]
     fn test_send_dispatch() {
         let mut socket = socket(buffer(0), buffer(1));
+        let mut cx = Context::mock();
         let checksum = ChecksumCapabilities::default();
 
         assert_eq!(
-            socket.dispatch(&Context::DUMMY, |_| unreachable!()),
+            socket.dispatch(&mut cx, |_, _| unreachable!()),
             Err(Error::Exhausted)
         );
 
@@ -604,7 +605,7 @@ mod test_ipv4 {
         assert!(!socket.can_send());
 
         assert_eq!(
-            socket.dispatch(&Context::DUMMY, |(ip_repr, icmp_repr)| {
+            socket.dispatch(&mut cx, |_, (ip_repr, icmp_repr)| {
                 assert_eq!(ip_repr, LOCAL_IPV4_REPR);
                 assert_eq!(icmp_repr, ECHOV4_REPR.into());
                 Err(Error::Unaddressable)
@@ -615,7 +616,7 @@ mod test_ipv4 {
         assert!(!socket.can_send());
 
         assert_eq!(
-            socket.dispatch(&Context::DUMMY, |(ip_repr, icmp_repr)| {
+            socket.dispatch(&mut cx, |_, (ip_repr, icmp_repr)| {
                 assert_eq!(ip_repr, LOCAL_IPV4_REPR);
                 assert_eq!(icmp_repr, ECHOV4_REPR.into());
                 Ok(())
@@ -629,6 +630,7 @@ mod test_ipv4 {
     #[test]
     fn test_set_hop_limit_v4() {
         let mut s = socket(buffer(0), buffer(1));
+        let mut cx = Context::mock();
         let checksum = ChecksumCapabilities::default();
 
         let mut bytes = [0xff; 24];
@@ -642,7 +644,7 @@ mod test_ipv4 {
             Ok(())
         );
         assert_eq!(
-            s.dispatch(&Context::DUMMY, |(ip_repr, _)| {
+            s.dispatch(&mut cx, |_, (ip_repr, _)| {
                 assert_eq!(
                     ip_repr,
                     IpRepr::Ipv4(Ipv4Repr {
@@ -662,6 +664,7 @@ mod test_ipv4 {
     #[test]
     fn test_recv_process() {
         let mut socket = socket(buffer(1), buffer(1));
+        let mut cx = Context::mock();
         assert_eq!(socket.bind(Endpoint::Ident(0x1234)), Ok(()));
 
         assert!(!socket.can_recv());
@@ -674,16 +677,16 @@ mod test_ipv4 {
         ECHOV4_REPR.emit(&mut packet, &checksum);
         let data = &packet.into_inner()[..];
 
-        assert!(socket.accepts(&Context::DUMMY, &REMOTE_IPV4_REPR, &ECHOV4_REPR.into()));
+        assert!(socket.accepts(&mut cx, &REMOTE_IPV4_REPR, &ECHOV4_REPR.into()));
         assert_eq!(
-            socket.process(&Context::DUMMY, &REMOTE_IPV4_REPR, &ECHOV4_REPR.into()),
+            socket.process(&mut cx, &REMOTE_IPV4_REPR, &ECHOV4_REPR.into()),
             Ok(())
         );
         assert!(socket.can_recv());
 
-        assert!(socket.accepts(&Context::DUMMY, &REMOTE_IPV4_REPR, &ECHOV4_REPR.into()));
+        assert!(socket.accepts(&mut cx, &REMOTE_IPV4_REPR, &ECHOV4_REPR.into()));
         assert_eq!(
-            socket.process(&Context::DUMMY, &REMOTE_IPV4_REPR, &ECHOV4_REPR.into()),
+            socket.process(&mut cx, &REMOTE_IPV4_REPR, &ECHOV4_REPR.into()),
             Err(Error::Exhausted)
         );
 
@@ -694,6 +697,7 @@ mod test_ipv4 {
     #[test]
     fn test_accept_bad_id() {
         let mut socket = socket(buffer(1), buffer(1));
+        let mut cx = Context::mock();
         assert_eq!(socket.bind(Endpoint::Ident(0x1234)), Ok(()));
 
         let checksum = ChecksumCapabilities::default();
@@ -708,12 +712,13 @@ mod test_ipv4 {
 
         // Ensure that a packet with an identifier that isn't the bound
         // ID is not accepted
-        assert!(!socket.accepts(&Context::DUMMY, &REMOTE_IPV4_REPR, &icmp_repr.into()));
+        assert!(!socket.accepts(&mut cx, &REMOTE_IPV4_REPR, &icmp_repr.into()));
     }
 
     #[test]
     fn test_accepts_udp() {
         let mut socket = socket(buffer(1), buffer(1));
+        let mut cx = Context::mock();
         assert_eq!(socket.bind(Endpoint::Udp(LOCAL_END_V4)), Ok(()));
 
         let checksum = ChecksumCapabilities::default();
@@ -754,11 +759,8 @@ mod test_ipv4 {
 
         // Ensure we can accept ICMP error response to the bound
         // UDP port
-        assert!(socket.accepts(&Context::DUMMY, &ip_repr, &icmp_repr.into()));
-        assert_eq!(
-            socket.process(&Context::DUMMY, &ip_repr, &icmp_repr.into()),
-            Ok(())
-        );
+        assert!(socket.accepts(&mut cx, &ip_repr, &icmp_repr.into()));
+        assert_eq!(socket.process(&mut cx, &ip_repr, &icmp_repr.into()), Ok(()));
         assert!(socket.can_recv());
 
         let mut bytes = [0x00; 46];
@@ -821,10 +823,11 @@ mod test_ipv6 {
     #[test]
     fn test_send_dispatch() {
         let mut socket = socket(buffer(0), buffer(1));
+        let mut cx = Context::mock();
         let checksum = ChecksumCapabilities::default();
 
         assert_eq!(
-            socket.dispatch(&Context::DUMMY, |_| unreachable!()),
+            socket.dispatch(&mut cx, |_, _| unreachable!()),
             Err(Error::Exhausted)
         );
 
@@ -855,7 +858,7 @@ mod test_ipv6 {
         assert!(!socket.can_send());
 
         assert_eq!(
-            socket.dispatch(&Context::DUMMY, |(ip_repr, icmp_repr)| {
+            socket.dispatch(&mut cx, |_, (ip_repr, icmp_repr)| {
                 assert_eq!(ip_repr, LOCAL_IPV6_REPR);
                 assert_eq!(icmp_repr, ECHOV6_REPR.into());
                 Err(Error::Unaddressable)
@@ -866,7 +869,7 @@ mod test_ipv6 {
         assert!(!socket.can_send());
 
         assert_eq!(
-            socket.dispatch(&Context::DUMMY, |(ip_repr, icmp_repr)| {
+            socket.dispatch(&mut cx, |_, (ip_repr, icmp_repr)| {
                 assert_eq!(ip_repr, LOCAL_IPV6_REPR);
                 assert_eq!(icmp_repr, ECHOV6_REPR.into());
                 Ok(())
@@ -880,6 +883,7 @@ mod test_ipv6 {
     #[test]
     fn test_set_hop_limit() {
         let mut s = socket(buffer(0), buffer(1));
+        let mut cx = Context::mock();
         let checksum = ChecksumCapabilities::default();
 
         let mut bytes = vec![0xff; 24];
@@ -898,7 +902,7 @@ mod test_ipv6 {
             Ok(())
         );
         assert_eq!(
-            s.dispatch(&Context::DUMMY, |(ip_repr, _)| {
+            s.dispatch(&mut cx, |_, (ip_repr, _)| {
                 assert_eq!(
                     ip_repr,
                     IpRepr::Ipv6(Ipv6Repr {
@@ -918,6 +922,7 @@ mod test_ipv6 {
     #[test]
     fn test_recv_process() {
         let mut socket = socket(buffer(1), buffer(1));
+        let mut cx = Context::mock();
         assert_eq!(socket.bind(Endpoint::Ident(0x1234)), Ok(()));
 
         assert!(!socket.can_recv());
@@ -935,16 +940,16 @@ mod test_ipv6 {
         );
         let data = &packet.into_inner()[..];
 
-        assert!(socket.accepts(&Context::DUMMY, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into()));
+        assert!(socket.accepts(&mut cx, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into()));
         assert_eq!(
-            socket.process(&Context::DUMMY, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into()),
+            socket.process(&mut cx, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into()),
             Ok(())
         );
         assert!(socket.can_recv());
 
-        assert!(socket.accepts(&Context::DUMMY, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into()));
+        assert!(socket.accepts(&mut cx, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into()));
         assert_eq!(
-            socket.process(&Context::DUMMY, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into()),
+            socket.process(&mut cx, &REMOTE_IPV6_REPR, &ECHOV6_REPR.into()),
             Err(Error::Exhausted)
         );
 
@@ -955,6 +960,7 @@ mod test_ipv6 {
     #[test]
     fn test_accept_bad_id() {
         let mut socket = socket(buffer(1), buffer(1));
+        let mut cx = Context::mock();
         assert_eq!(socket.bind(Endpoint::Ident(0x1234)), Ok(()));
 
         let checksum = ChecksumCapabilities::default();
@@ -974,12 +980,13 @@ mod test_ipv6 {
 
         // Ensure that a packet with an identifier that isn't the bound
         // ID is not accepted
-        assert!(!socket.accepts(&Context::DUMMY, &REMOTE_IPV6_REPR, &icmp_repr.into()));
+        assert!(!socket.accepts(&mut cx, &REMOTE_IPV6_REPR, &icmp_repr.into()));
     }
 
     #[test]
     fn test_accepts_udp() {
         let mut socket = socket(buffer(1), buffer(1));
+        let mut cx = Context::mock();
         assert_eq!(socket.bind(Endpoint::Udp(LOCAL_END_V6)), Ok(()));
 
         let checksum = ChecksumCapabilities::default();
@@ -1020,11 +1027,8 @@ mod test_ipv6 {
 
         // Ensure we can accept ICMP error response to the bound
         // UDP port
-        assert!(socket.accepts(&Context::DUMMY, &ip_repr, &icmp_repr.into()));
-        assert_eq!(
-            socket.process(&Context::DUMMY, &ip_repr, &icmp_repr.into()),
-            Ok(())
-        );
+        assert!(socket.accepts(&mut cx, &ip_repr, &icmp_repr.into()));
+        assert_eq!(socket.process(&mut cx, &ip_repr, &icmp_repr.into()), Ok(()));
         assert!(socket.can_recv());
 
         let mut bytes = [0x00; 66];

src/socket/mod.rs

@@ -11,7 +11,7 @@ The interface implemented by this module uses explicit buffering: you decide on
 size for a buffer, allocate it, and let the networking stack use it.
 */
 
-use crate::phy::DeviceCapabilities;
+use crate::iface::Context;
 use crate::time::Instant;
 
 #[cfg(feature = "socket-dhcpv4")]
@@ -79,7 +79,7 @@ pub enum Socket<'a> {
 }
 
 impl<'a> Socket<'a> {
-    pub(crate) fn poll_at(&self, cx: &Context) -> PollAt {
+    pub(crate) fn poll_at(&self, cx: &mut Context) -> PollAt {
         match self {
             #[cfg(feature = "socket-raw")]
             Socket::Raw(s) => s.poll_at(cx),
@@ -129,54 +129,3 @@ from_socket!(UdpSocket<'a>, Udp);
 from_socket!(TcpSocket<'a>, Tcp);
 #[cfg(feature = "socket-dhcpv4")]
 from_socket!(Dhcpv4Socket, Dhcpv4);
-
-/// Data passed to sockets when processing.
-#[derive(Clone, Debug)]
-pub(crate) struct Context {
-    pub now: Instant,
-    #[cfg(all(
-        any(feature = "medium-ethernet", feature = "medium-ieee802154"),
-        feature = "socket-dhcpv4"
-    ))]
-    pub hardware_addr: Option<crate::wire::HardwareAddress>,
-    #[cfg(feature = "medium-ieee802154")]
-    pub pan_id: Option<crate::wire::Ieee802154Pan>,
-    pub caps: DeviceCapabilities,
-}
-
-#[cfg(test)]
-impl Context {
-    pub(crate) const DUMMY: Context = Context {
-        caps: DeviceCapabilities {
-            #[cfg(feature = "medium-ethernet")]
-            medium: crate::phy::Medium::Ethernet,
-            #[cfg(not(feature = "medium-ethernet"))]
-            medium: crate::phy::Medium::Ip,
-            checksum: crate::phy::ChecksumCapabilities {
-                #[cfg(feature = "proto-ipv4")]
-                icmpv4: crate::phy::Checksum::Both,
-                #[cfg(feature = "proto-ipv6")]
-                icmpv6: crate::phy::Checksum::Both,
-                ipv4: crate::phy::Checksum::Both,
-                tcp: crate::phy::Checksum::Both,
-                udp: crate::phy::Checksum::Both,
-            },
-            max_burst_size: None,
-            #[cfg(feature = "medium-ethernet")]
-            max_transmission_unit: 1514,
-            #[cfg(not(feature = "medium-ethernet"))]
-            max_transmission_unit: 1500,
-        },
-        #[cfg(all(
-            any(feature = "medium-ethernet", feature = "medium-ieee802154"),
-            feature = "socket-dhcpv4"
-        ))]
-        hardware_addr: Some(crate::wire::HardwareAddress::Ethernet(
-            crate::wire::EthernetAddress([0x02, 0x02, 0x02, 0x02, 0x02, 0x02]),
-        )),
-        now: Instant::from_millis_const(0),
-
-        #[cfg(feature = "medium-ieee802154")]
-        pan_id: Some(crate::wire::Ieee802154Pan(0xabcd)),
-    };
-}

src/socket/raw.rs

@@ -2,10 +2,11 @@ use core::cmp::min;
 #[cfg(feature = "async")]
 use core::task::Waker;
 
+use crate::iface::Context;
 use crate::phy::ChecksumCapabilities;
+use crate::socket::PollAt;
 #[cfg(feature = "async")]
 use crate::socket::WakerRegistration;
-use crate::socket::{Context, PollAt};
 use crate::storage::{PacketBuffer, PacketMetadata};
 use crate::{Error, Result};
 
@@ -211,13 +212,18 @@ impl<'a> RawSocket<'a> {
         true
     }
 
-    pub(crate) fn process(&mut self, cx: &Context, ip_repr: &IpRepr, payload: &[u8]) -> Result<()> {
+    pub(crate) fn process(
+        &mut self,
+        cx: &mut Context,
+        ip_repr: &IpRepr,
+        payload: &[u8],
+    ) -> Result<()> {
         debug_assert!(self.accepts(ip_repr));
 
         let header_len = ip_repr.buffer_len();
         let total_len = header_len + payload.len();
         let packet_buf = self.rx_buffer.enqueue(total_len, ())?;
-        ip_repr.emit(&mut packet_buf[..header_len], &cx.caps.checksum);
+        ip_repr.emit(&mut packet_buf[..header_len], &cx.checksum_caps());
         packet_buf[header_len..].copy_from_slice(payload);
 
         net_trace!(
@@ -233,9 +239,9 @@ impl<'a> RawSocket<'a> {
         Ok(())
     }
 
-    pub(crate) fn dispatch<F>(&mut self, cx: &Context, emit: F) -> Result<()>
+    pub(crate) fn dispatch<F>(&mut self, cx: &mut Context, emit: F) -> Result<()>
     where
-        F: FnOnce((IpRepr, &[u8])) -> Result<()>,
+        F: FnOnce(&mut Context, (IpRepr, &[u8])) -> Result<()>,
     {
         fn prepare<'a>(
             protocol: IpProtocol,
@@ -278,7 +284,7 @@ impl<'a> RawSocket<'a> {
         let ip_protocol = self.ip_protocol;
         let ip_version = self.ip_version;
         self.tx_buffer.dequeue_with(|&mut (), packet_buf| {
-            match prepare(ip_protocol, packet_buf, &cx.caps.checksum) {
+            match prepare(ip_protocol, packet_buf, &cx.checksum_caps()) {
                 Ok((ip_repr, raw_packet)) => {
                     net_trace!(
                         "raw:{}:{}: sending {} octets",
@@ -286,7 +292,7 @@ impl<'a> RawSocket<'a> {
                         ip_protocol,
                         ip_repr.buffer_len() + raw_packet.len()
                     );
-                    emit((ip_repr, raw_packet))
+                    emit(cx, (ip_repr, raw_packet))
                 }
                 Err(error) => {
                     net_debug!(
@@ -307,7 +313,7 @@ impl<'a> RawSocket<'a> {
         Ok(())
     }
 
-    pub(crate) fn poll_at(&self, _cx: &Context) -> PollAt {
+    pub(crate) fn poll_at(&self, _cx: &mut Context) -> PollAt {
         if self.tx_buffer.is_empty() {
             PollAt::Ingress
         } else {
@@ -418,10 +424,11 @@ mod test {
                 #[test]
                 fn test_send_dispatch() {
                     let mut socket = $socket(buffer(0), buffer(1));
+                    let mut cx = Context::mock();
 
                     assert!(socket.can_send());
                     assert_eq!(
-                        socket.dispatch(&Context::DUMMY, |_| unreachable!()),
+                        socket.dispatch(&mut cx, |_, _| unreachable!()),
                         Err(Error::Exhausted)
                     );
 
@@ -430,7 +437,7 @@ mod test {
                     assert!(!socket.can_send());
 
                     assert_eq!(
-                        socket.dispatch(&Context::DUMMY, |(ip_repr, ip_payload)| {
+                        socket.dispatch(&mut cx, |_, (ip_repr, ip_payload)| {
                             assert_eq!(ip_repr, $hdr);
                             assert_eq!(ip_payload, &$payload);
                             Err(Error::Unaddressable)
@@ -440,7 +447,7 @@ mod test {
                     assert!(!socket.can_send());
 
                     assert_eq!(
-                        socket.dispatch(&Context::DUMMY, |(ip_repr, ip_payload)| {
+                        socket.dispatch(&mut cx, |_, (ip_repr, ip_payload)| {
                             assert_eq!(ip_repr, $hdr);
                             assert_eq!(ip_payload, &$payload);
                             Ok(())
@@ -453,9 +460,10 @@ mod test {
                 #[test]
                 fn test_recv_truncated_slice() {
                     let mut socket = $socket(buffer(1), buffer(0));
+                    let mut cx = Context::mock();
 
                     assert!(socket.accepts(&$hdr));
-                    assert_eq!(socket.process(&Context::DUMMY, &$hdr, &$payload), Ok(()));
+                    assert_eq!(socket.process(&mut cx, &$hdr, &$payload), Ok(()));
 
                     let mut slice = [0; 4];
                     assert_eq!(socket.recv_slice(&mut slice[..]), Ok(4));
@@ -465,13 +473,14 @@ mod test {
                 #[test]
                 fn test_recv_truncated_packet() {
                     let mut socket = $socket(buffer(1), buffer(0));
+                    let mut cx = Context::mock();
 
                     let mut buffer = vec![0; 128];
                     buffer[..$packet.len()].copy_from_slice(&$packet[..]);
 
                     assert!(socket.accepts(&$hdr));
                     assert_eq!(
-                        socket.process(&Context::DUMMY, &$hdr, &buffer),
+                        socket.process(&mut cx, &$hdr, &buffer),
                         Err(Error::Truncated)
                     );
                 }
@@ -503,34 +512,36 @@ mod test {
         #[cfg(feature = "proto-ipv4")]
         {
             let mut socket = ipv4_locals::socket(buffer(0), buffer(2));
+            let mut cx = Context::mock();
 
             let mut wrong_version = ipv4_locals::PACKET_BYTES;
             Ipv4Packet::new_unchecked(&mut wrong_version).set_version(6);
 
             assert_eq!(socket.send_slice(&wrong_version[..]), Ok(()));
-            assert_eq!(socket.dispatch(&Context::DUMMY, |_| unreachable!()), Ok(()));
+            assert_eq!(socket.dispatch(&mut cx, |_, _| unreachable!()), Ok(()));
 
             let mut wrong_protocol = ipv4_locals::PACKET_BYTES;
             Ipv4Packet::new_unchecked(&mut wrong_protocol).set_protocol(IpProtocol::Tcp);
 
             assert_eq!(socket.send_slice(&wrong_protocol[..]), Ok(()));
-            assert_eq!(socket.dispatch(&Context::DUMMY, |_| unreachable!()), Ok(()));
+            assert_eq!(socket.dispatch(&mut cx, |_, _| unreachable!()), Ok(()));
         }
         #[cfg(feature = "proto-ipv6")]
         {
             let mut socket = ipv6_locals::socket(buffer(0), buffer(2));
+            let mut cx = Context::mock();
 
             let mut wrong_version = ipv6_locals::PACKET_BYTES;
             Ipv6Packet::new_unchecked(&mut wrong_version[..]).set_version(4);
 
             assert_eq!(socket.send_slice(&wrong_version[..]), Ok(()));
-            assert_eq!(socket.dispatch(&Context::DUMMY, |_| unreachable!()), Ok(()));
+            assert_eq!(socket.dispatch(&mut cx, |_, _| unreachable!()), Ok(()));
 
             let mut wrong_protocol = ipv6_locals::PACKET_BYTES;
             Ipv6Packet::new_unchecked(&mut wrong_protocol[..]).set_next_header(IpProtocol::Tcp);
 
             assert_eq!(socket.send_slice(&wrong_protocol[..]), Ok(()));
-            assert_eq!(socket.dispatch(&Context::DUMMY, |_| unreachable!()), Ok(()));
+            assert_eq!(socket.dispatch(&mut cx, |_, _| unreachable!()), Ok(()));
         }
     }
 
@@ -540,6 +551,7 @@ mod test {
         {
             let mut socket = ipv4_locals::socket(buffer(1), buffer(0));
             assert!(!socket.can_recv());
+            let mut cx = Context::mock();
 
             let mut cksumd_packet = ipv4_locals::PACKET_BYTES;
             Ipv4Packet::new_unchecked(&mut cksumd_packet).fill_checksum();
@@ -548,7 +560,7 @@ mod test {
             assert!(socket.accepts(&ipv4_locals::HEADER_REPR));
             assert_eq!(
                 socket.process(
-                    &Context::DUMMY,
+                    &mut cx,
                     &ipv4_locals::HEADER_REPR,
                     &ipv4_locals::PACKET_PAYLOAD
                 ),
@@ -559,7 +571,7 @@ mod test {
             assert!(socket.accepts(&ipv4_locals::HEADER_REPR));
             assert_eq!(
                 socket.process(
-                    &Context::DUMMY,
+                    &mut cx,
                     &ipv4_locals::HEADER_REPR,
                     &ipv4_locals::PACKET_PAYLOAD
                 ),
@@ -572,12 +584,13 @@ mod test {
         {
             let mut socket = ipv6_locals::socket(buffer(1), buffer(0));
             assert!(!socket.can_recv());
+            let mut cx = Context::mock();
 
             assert_eq!(socket.recv(), Err(Error::Exhausted));
             assert!(socket.accepts(&ipv6_locals::HEADER_REPR));
             assert_eq!(
                 socket.process(
-                    &Context::DUMMY,
+                    &mut cx,
                     &ipv6_locals::HEADER_REPR,
                     &ipv6_locals::PACKET_PAYLOAD
                 ),
@@ -588,7 +601,7 @@ mod test {
             assert!(socket.accepts(&ipv6_locals::HEADER_REPR));
             assert_eq!(
                 socket.process(
-                    &Context::DUMMY,
+                    &mut cx,
                     &ipv6_locals::HEADER_REPR,
                     &ipv6_locals::PACKET_PAYLOAD
                 ),

src/socket/udp.rs

@@ -2,9 +2,10 @@ use core::cmp::min;
 #[cfg(feature = "async")]
 use core::task::Waker;
 
+use crate::iface::Context;
+use crate::socket::PollAt;
 #[cfg(feature = "async")]
 use crate::socket::WakerRegistration;
-use crate::socket::{Context, PollAt};
 use crate::storage::{PacketBuffer, PacketMetadata};
 use crate::wire::{IpEndpoint, IpProtocol, IpRepr, UdpRepr};
 use crate::{Error, Result};
@@ -291,7 +292,7 @@ impl<'a> UdpSocket<'a> {
         Ok((length, endpoint))
     }
 
-    pub(crate) fn accepts(&self, ip_repr: &IpRepr, repr: &UdpRepr) -> bool {
+    pub(crate) fn accepts(&self, _cx: &mut Context, ip_repr: &IpRepr, repr: &UdpRepr) -> bool {
         if self.endpoint.port != repr.dst_port {
             return false;
         }
@@ -308,12 +309,12 @@ impl<'a> UdpSocket<'a> {
 
     pub(crate) fn process(
         &mut self,
-        _cx: &Context,
+        cx: &mut Context,
         ip_repr: &IpRepr,
         repr: &UdpRepr,
         payload: &[u8],
     ) -> Result<()> {
-        debug_assert!(self.accepts(ip_repr, repr));
+        debug_assert!(self.accepts(cx, ip_repr, repr));
 
         let size = payload.len();
 
@@ -338,9 +339,9 @@ impl<'a> UdpSocket<'a> {
         Ok(())
     }
 
-    pub(crate) fn dispatch<F>(&mut self, _cx: &Context, emit: F) -> Result<()>
+    pub(crate) fn dispatch<F>(&mut self, cx: &mut Context, emit: F) -> Result<()>
     where
-        F: FnOnce((IpRepr, UdpRepr, &[u8])) -> Result<()>,
+        F: FnOnce(&mut Context, (IpRepr, UdpRepr, &[u8])) -> Result<()>,
     {
         let endpoint = self.endpoint;
         let hop_limit = self.hop_limit.unwrap_or(64);
@@ -365,7 +366,7 @@ impl<'a> UdpSocket<'a> {
                     payload_len: repr.header_len() + payload_buf.len(),
                     hop_limit: hop_limit,
                 };
-                emit((ip_repr, repr, payload_buf))
+                emit(cx, (ip_repr, repr, payload_buf))
             })?;
 
         #[cfg(feature = "async")]
@@ -374,7 +375,7 @@ impl<'a> UdpSocket<'a> {
         Ok(())
     }
 
-    pub(crate) fn poll_at(&self, _cx: &Context) -> PollAt {
+    pub(crate) fn poll_at(&self, _cx: &mut Context) -> PollAt {
         if self.tx_buffer.is_empty() {
             PollAt::Ingress
         } else {
@@ -484,6 +485,7 @@ mod test {
     #[test]
     fn test_send_unaddressable() {
         let mut socket = socket(buffer(0), buffer(1));
+
         assert_eq!(
             socket.send_slice(b"abcdef", REMOTE_END),
             Err(Error::Unaddressable)
@@ -515,11 +517,13 @@ mod test {
     #[test]
     fn test_send_dispatch() {
         let mut socket = socket(buffer(0), buffer(1));
+        let mut cx = Context::mock();
+
         assert_eq!(socket.bind(LOCAL_END), Ok(()));
 
         assert!(socket.can_send());
         assert_eq!(
-            socket.dispatch(&Context::DUMMY, |_| unreachable!()),
+            socket.dispatch(&mut cx, |_, _| unreachable!()),
             Err(Error::Exhausted)
         );
 
@@ -531,7 +535,7 @@ mod test {
         assert!(!socket.can_send());
 
         assert_eq!(
-            socket.dispatch(&Context::DUMMY, |(ip_repr, udp_repr, payload)| {
+            socket.dispatch(&mut cx, |_, (ip_repr, udp_repr, payload)| {
                 assert_eq!(ip_repr, LOCAL_IP_REPR);
                 assert_eq!(udp_repr, LOCAL_UDP_REPR);
                 assert_eq!(payload, PAYLOAD);
@@ -542,7 +546,7 @@ mod test {
         assert!(!socket.can_send());
 
         assert_eq!(
-            socket.dispatch(&Context::DUMMY, |(ip_repr, udp_repr, payload)| {
+            socket.dispatch(&mut cx, |_, (ip_repr, udp_repr, payload)| {
                 assert_eq!(ip_repr, LOCAL_IP_REPR);
                 assert_eq!(udp_repr, LOCAL_UDP_REPR);
                 assert_eq!(payload, PAYLOAD);
@@ -556,31 +560,23 @@ mod test {
     #[test]
     fn test_recv_process() {
         let mut socket = socket(buffer(1), buffer(0));
+        let mut cx = Context::mock();
+
         assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
 
         assert!(!socket.can_recv());
         assert_eq!(socket.recv(), Err(Error::Exhausted));
 
-        assert!(socket.accepts(&remote_ip_repr(), &REMOTE_UDP_REPR));
+        assert!(socket.accepts(&mut cx, &remote_ip_repr(), &REMOTE_UDP_REPR));
         assert_eq!(
-            socket.process(
-                &Context::DUMMY,
-                &remote_ip_repr(),
-                &REMOTE_UDP_REPR,
-                PAYLOAD
-            ),
+            socket.process(&mut cx, &remote_ip_repr(), &REMOTE_UDP_REPR, PAYLOAD),
             Ok(())
         );
         assert!(socket.can_recv());
 
-        assert!(socket.accepts(&remote_ip_repr(), &REMOTE_UDP_REPR));
+        assert!(socket.accepts(&mut cx, &remote_ip_repr(), &REMOTE_UDP_REPR));
         assert_eq!(
-            socket.process(
-                &Context::DUMMY,
-                &remote_ip_repr(),
-                &REMOTE_UDP_REPR,
-                PAYLOAD
-            ),
+            socket.process(&mut cx, &remote_ip_repr(), &REMOTE_UDP_REPR, PAYLOAD),
             Err(Error::Exhausted)
         );
         assert_eq!(socket.recv(), Ok((&b"abcdef"[..], REMOTE_END)));
@@ -590,17 +586,14 @@ mod test {
     #[test]
     fn test_peek_process() {
         let mut socket = socket(buffer(1), buffer(0));
+        let mut cx = Context::mock();
+
         assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
 
         assert_eq!(socket.peek(), Err(Error::Exhausted));
 
         assert_eq!(
-            socket.process(
-                &Context::DUMMY,
-                &remote_ip_repr(),
-                &REMOTE_UDP_REPR,
-                PAYLOAD
-            ),
+            socket.process(&mut cx, &remote_ip_repr(), &REMOTE_UDP_REPR, PAYLOAD),
             Ok(())
         );
         assert_eq!(socket.peek(), Ok((&b"abcdef"[..], &REMOTE_END)));
@@ -611,16 +604,13 @@ mod test {
     #[test]
     fn test_recv_truncated_slice() {
         let mut socket = socket(buffer(1), buffer(0));
+        let mut cx = Context::mock();
+
         assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
 
-        assert!(socket.accepts(&remote_ip_repr(), &REMOTE_UDP_REPR));
+        assert!(socket.accepts(&mut cx, &remote_ip_repr(), &REMOTE_UDP_REPR));
         assert_eq!(
-            socket.process(
-                &Context::DUMMY,
-                &remote_ip_repr(),
-                &REMOTE_UDP_REPR,
-                PAYLOAD
-            ),
+            socket.process(&mut cx, &remote_ip_repr(), &REMOTE_UDP_REPR, PAYLOAD),
             Ok(())
         );
 
@@ -632,15 +622,12 @@ mod test {
     #[test]
     fn test_peek_truncated_slice() {
         let mut socket = socket(buffer(1), buffer(0));
+        let mut cx = Context::mock();
+
         assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
 
         assert_eq!(
-            socket.process(
-                &Context::DUMMY,
-                &remote_ip_repr(),
-                &REMOTE_UDP_REPR,
-                PAYLOAD
-            ),
+            socket.process(&mut cx, &remote_ip_repr(), &REMOTE_UDP_REPR, PAYLOAD),
             Ok(())
         );
 
@@ -655,12 +642,14 @@ mod test {
     #[test]
     fn test_set_hop_limit() {
         let mut s = socket(buffer(0), buffer(1));
+        let mut cx = Context::mock();
+
         assert_eq!(s.bind(LOCAL_END), Ok(()));
 
         s.set_hop_limit(Some(0x2a));
         assert_eq!(s.send_slice(b"abcdef", REMOTE_END), Ok(()));
         assert_eq!(
-            s.dispatch(&Context::DUMMY, |(ip_repr, _, _)| {
+            s.dispatch(&mut cx, |_, (ip_repr, _, _)| {
                 assert_eq!(
                     ip_repr,
                     IpRepr::Unspecified {
@@ -680,12 +669,14 @@ mod test {
     #[test]
     fn test_doesnt_accept_wrong_port() {
         let mut socket = socket(buffer(1), buffer(0));
+        let mut cx = Context::mock();
+
         assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
 
         let mut udp_repr = REMOTE_UDP_REPR;
-        assert!(socket.accepts(&remote_ip_repr(), &udp_repr));
+        assert!(socket.accepts(&mut cx, &remote_ip_repr(), &udp_repr));
         udp_repr.dst_port += 1;
-        assert!(!socket.accepts(&remote_ip_repr(), &udp_repr));
+        assert!(!socket.accepts(&mut cx, &remote_ip_repr(), &udp_repr));
     }
 
     #[test]
@@ -712,13 +703,15 @@ mod test {
             }
         }
 
+        let mut cx = Context::mock();
+
         let mut port_bound_socket = socket(buffer(1), buffer(0));
         assert_eq!(port_bound_socket.bind(LOCAL_PORT), Ok(()));
-        assert!(port_bound_socket.accepts(&generate_bad_repr(), &REMOTE_UDP_REPR));
+        assert!(port_bound_socket.accepts(&mut cx, &generate_bad_repr(), &REMOTE_UDP_REPR));
 
         let mut ip_bound_socket = socket(buffer(1), buffer(0));
         assert_eq!(ip_bound_socket.bind(LOCAL_END), Ok(()));
-        assert!(!ip_bound_socket.accepts(&generate_bad_repr(), &REMOTE_UDP_REPR));
+        assert!(!ip_bound_socket.accepts(&mut cx, &generate_bad_repr(), &REMOTE_UDP_REPR));
     }
 
     #[test]
@@ -739,6 +732,8 @@ mod test {
     fn test_process_empty_payload() {
         let recv_buffer = UdpSocketBuffer::new(vec![UdpPacketMetadata::EMPTY; 1], vec![]);
         let mut socket = socket(recv_buffer, buffer(0));
+        let mut cx = Context::mock();
+
         assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
 
         let repr = UdpRepr {
@@ -746,7 +741,7 @@ mod test {
             dst_port: LOCAL_PORT,
         };
         assert_eq!(
-            socket.process(&Context::DUMMY, &remote_ip_repr(), &repr, &[]),
+            socket.process(&mut cx, &remote_ip_repr(), &repr, &[]),
             Ok(())
         );
         assert_eq!(socket.recv(), Ok((&[][..], REMOTE_END)));