iface: borrow the device instead of owning it.

examples/benchmark.rs

@@ -74,7 +74,8 @@ fn main() {
     let mut matches = utils::parse_options(&opts, free);
     let device = utils::parse_tuntap_options(&mut matches);
     let fd = device.as_raw_fd();
-    let device = utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+    let mut device =
+        utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
     let mode = match matches.free[0].as_ref() {
         "reader" => Client::Reader,
         "writer" => Client::Writer,
@@ -96,13 +97,13 @@ fn main() {
     let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]);
     let ip_addrs = [IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24)];
     let medium = device.capabilities().medium;
-    let mut builder = InterfaceBuilder::new(device).ip_addrs(ip_addrs);
+    let mut builder = InterfaceBuilder::new().ip_addrs(ip_addrs);
     if medium == Medium::Ethernet {
         builder = builder
             .hardware_addr(ethernet_addr.into())
             .neighbor_cache(neighbor_cache);
     }
-    let mut iface = builder.finalize();
+    let mut iface = builder.finalize(&mut device);
 
     let mut sockets = SocketSet::new(vec![]);
     let tcp1_handle = sockets.add(tcp1_socket);
@@ -112,7 +113,7 @@ fn main() {
     let mut processed = 0;
     while !CLIENT_DONE.load(Ordering::SeqCst) {
         let timestamp = Instant::now();
-        match iface.poll(timestamp, &mut sockets) {
+        match iface.poll(timestamp, &mut device, &mut sockets) {
             Ok(_) => {}
             Err(e) => {
                 debug!("poll error: {}", e);

examples/client.rs

@@ -24,7 +24,8 @@ fn main() {
     let device = utils::parse_tuntap_options(&mut matches);
 
     let fd = device.as_raw_fd();
-    let device = utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+    let mut device =
+        utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
     let address = IpAddress::from_str(&matches.free[0]).expect("invalid address format");
     let port = u16::from_str(&matches.free[1]).expect("invalid port format");
 
@@ -42,28 +43,24 @@ fn main() {
     routes.add_default_ipv4_route(default_v4_gw).unwrap();
 
     let medium = device.capabilities().medium;
-    let mut builder = InterfaceBuilder::new(device)
-        .ip_addrs(ip_addrs)
-        .routes(routes);
+    let mut builder = InterfaceBuilder::new().ip_addrs(ip_addrs).routes(routes);
     if medium == Medium::Ethernet {
         builder = builder
             .hardware_addr(ethernet_addr.into())
             .neighbor_cache(neighbor_cache);
     }
-    let mut iface = builder.finalize();
+    let mut iface = builder.finalize(&mut device);
 
     let mut sockets = SocketSet::new(vec![]);
     let tcp_handle = sockets.add(tcp_socket);
 
     let socket = sockets.get::<tcp::Socket>(tcp_handle);
-    socket
-        .connect(iface.context(), (address, port), 49500)
-        .unwrap();
+    socket.connect(&mut iface, (address, port), 49500).unwrap();
 
     let mut tcp_active = false;
     loop {
         let timestamp = Instant::now();
-        match iface.poll(timestamp, &mut sockets) {
+        match iface.poll(timestamp, &mut device, &mut sockets) {
             Ok(_) => {}
             Err(e) => {
                 debug!("poll error: {}", e);

examples/dhcp_client.rs

@@ -25,7 +25,8 @@ fn main() {
     let mut matches = utils::parse_options(&opts, free);
     let device = utils::parse_tuntap_options(&mut matches);
     let fd = device.as_raw_fd();
-    let device = utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+    let mut device =
+        utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
 
     let neighbor_cache = NeighborCache::new(BTreeMap::new());
     let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]);
@@ -34,15 +35,13 @@ fn main() {
     let routes = Routes::new(&mut routes_storage[..]);
 
     let medium = device.capabilities().medium;
-    let mut builder = InterfaceBuilder::new(device)
-        .ip_addrs(ip_addrs)
-        .routes(routes);
+    let mut builder = InterfaceBuilder::new().ip_addrs(ip_addrs).routes(routes);
     if medium == Medium::Ethernet {
         builder = builder
             .hardware_addr(ethernet_addr.into())
             .neighbor_cache(neighbor_cache);
     }
-    let mut iface = builder.finalize();
+    let mut iface = builder.finalize(&mut device);
 
     let mut dhcp_socket = dhcpv4::Socket::new();
 
@@ -57,7 +56,7 @@ fn main() {
 
     loop {
         let timestamp = Instant::now();
-        if let Err(e) = iface.poll(timestamp, &mut sockets) {
+        if let Err(e) = iface.poll(timestamp, &mut device, &mut sockets) {
             debug!("poll error: {}", e);
         }
 
@@ -95,10 +94,7 @@ fn main() {
     }
 }
 
-fn set_ipv4_addr<DeviceT>(iface: &mut Interface<'_, DeviceT>, cidr: Ipv4Cidr)
-where
-    DeviceT: for<'d> Device<'d>,
-{
+fn set_ipv4_addr(iface: &mut Interface<'_>, cidr: Ipv4Cidr) {
     iface.update_ip_addrs(|addrs| {
         let dest = addrs.iter_mut().next().unwrap();
         *dest = IpCidr::Ipv4(cidr);

examples/dns.rs

@@ -29,7 +29,8 @@ fn main() {
     let mut matches = utils::parse_options(&opts, free);
     let device = utils::parse_tuntap_options(&mut matches);
     let fd = device.as_raw_fd();
-    let device = utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+    let mut device =
+        utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
     let name = &matches.free[0];
 
     let neighbor_cache = NeighborCache::new(BTreeMap::new());
@@ -55,27 +56,25 @@ fn main() {
     routes.add_default_ipv6_route(default_v6_gw).unwrap();
 
     let medium = device.capabilities().medium;
-    let mut builder = InterfaceBuilder::new(device)
-        .ip_addrs(ip_addrs)
-        .routes(routes);
+    let mut builder = InterfaceBuilder::new().ip_addrs(ip_addrs).routes(routes);
     if medium == Medium::Ethernet {
         builder = builder
             .hardware_addr(HardwareAddress::Ethernet(ethernet_addr))
             .neighbor_cache(neighbor_cache);
     }
-    let mut iface = builder.finalize();
+    let mut iface = builder.finalize(&mut device);
 
     let mut sockets = SocketSet::new(vec![]);
     let dns_handle = sockets.add(dns_socket);
 
     let socket = sockets.get::<dns::Socket>(dns_handle);
-    let query = socket.start_query(iface.context(), name).unwrap();
+    let query = socket.start_query(&mut iface, name).unwrap();
 
     loop {
         let timestamp = Instant::now();
         debug!("timestamp {:?}", timestamp);
 
-        match iface.poll(timestamp, &mut sockets) {
+        match iface.poll(timestamp, &mut device, &mut sockets) {
             Ok(_) => {}
             Err(e) => {
                 debug!("poll error: {}", e);

examples/httpclient.rs

@@ -24,7 +24,8 @@ fn main() {
     let mut matches = utils::parse_options(&opts, free);
     let device = utils::parse_tuntap_options(&mut matches);
     let fd = device.as_raw_fd();
-    let device = utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+    let mut device =
+        utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
     let address = IpAddress::from_str(&matches.free[0]).expect("invalid address format");
     let url = Url::parse(&matches.free[1]).expect("invalid url format");
 
@@ -48,15 +49,13 @@ fn main() {
     routes.add_default_ipv6_route(default_v6_gw).unwrap();
 
     let medium = device.capabilities().medium;
-    let mut builder = InterfaceBuilder::new(device)
-        .ip_addrs(ip_addrs)
-        .routes(routes);
+    let mut builder = InterfaceBuilder::new().ip_addrs(ip_addrs).routes(routes);
     if medium == Medium::Ethernet {
         builder = builder
             .hardware_addr(ethernet_addr.into())
             .neighbor_cache(neighbor_cache);
     }
-    let mut iface = builder.finalize();
+    let mut iface = builder.finalize(&mut device);
 
     let mut sockets = SocketSet::new(vec![]);
     let tcp_handle = sockets.add(tcp_socket);
@@ -70,7 +69,7 @@ fn main() {
 
     loop {
         let timestamp = Instant::now();
-        match iface.poll(timestamp, &mut sockets) {
+        match iface.poll(timestamp, &mut device, &mut sockets) {
             Ok(_) => {}
             Err(e) => {
                 debug!("poll error: {}", e);
@@ -78,7 +77,7 @@ fn main() {
         }
 
         let socket = sockets.get::<tcp::Socket>(tcp_handle);
-        let cx = iface.context();
+        let cx = &mut iface;
 
         state = match state {
             State::Connect if !socket.is_active() => {

examples/loopback.rs

@@ -71,7 +71,7 @@ fn main() {
     let device = Loopback::new(Medium::Ethernet);
 
     #[cfg(feature = "std")]
-    let device = {
+    let mut device = {
         let clock = clock.clone();
         utils::setup_logging_with_clock("", move || clock.elapsed());
 
@@ -86,11 +86,11 @@ fn main() {
     let mut neighbor_cache = NeighborCache::new(&mut neighbor_cache_entries[..]);
 
     let mut ip_addrs = [IpCidr::new(IpAddress::v4(127, 0, 0, 1), 8)];
-    let mut iface = InterfaceBuilder::new(device)
+    let mut iface = InterfaceBuilder::new()
         .hardware_addr(EthernetAddress::default().into())
         .neighbor_cache(neighbor_cache)
         .ip_addrs(ip_addrs)
-        .finalize();
+        .finalize(&mut device);
 
     let server_socket = {
         // It is not strictly necessary to use a `static mut` and unsafe code here, but
@@ -121,7 +121,7 @@ fn main() {
     let mut did_connect = false;
     let mut done = false;
     while !done && clock.elapsed() < Instant::from_millis(10_000) {
-        match iface.poll(clock.elapsed(), &mut sockets) {
+        match iface.poll(clock.elapsed(), &mut device, &mut sockets) {
             Ok(_) => {}
             Err(e) => {
                 debug!("poll error: {}", e);
@@ -147,7 +147,7 @@ fn main() {
         }
 
         let mut socket = sockets.get::<tcp::Socket>(client_handle);
-        let cx = iface.context();
+        let cx = &mut iface;
         if !socket.is_open() {
             if !did_connect {
                 debug!("connecting");

examples/multicast.rs

@@ -26,7 +26,8 @@ fn main() {
     let mut matches = utils::parse_options(&opts, free);
     let device = utils::parse_tuntap_options(&mut matches);
     let fd = device.as_raw_fd();
-    let device = utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+    let mut device =
+        utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
     let neighbor_cache = NeighborCache::new(BTreeMap::new());
 
     let local_addr = Ipv4Address::new(192, 168, 69, 2);
@@ -34,17 +35,17 @@ fn main() {
     let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x02]);
     let ip_addr = IpCidr::new(IpAddress::from(local_addr), 24);
     let mut ipv4_multicast_storage = [None; 1];
-    let mut iface = InterfaceBuilder::new(device)
+    let mut iface = InterfaceBuilder::new()
         .hardware_addr(ethernet_addr.into())
         .neighbor_cache(neighbor_cache)
         .ip_addrs([ip_addr])
         .ipv4_multicast_groups(&mut ipv4_multicast_storage[..])
-        .finalize();
+        .finalize(&mut device);
 
     let now = Instant::now();
     // Join a multicast group to receive mDNS traffic
     iface
-        .join_multicast_group(Ipv4Address::from_bytes(&MDNS_GROUP), now)
+        .join_multicast_group(&mut device, Ipv4Address::from_bytes(&MDNS_GROUP), now)
         .unwrap();
 
     let mut sockets = SocketSet::new(vec![]);
@@ -70,7 +71,7 @@ fn main() {
 
     loop {
         let timestamp = Instant::now();
-        match iface.poll(timestamp, &mut sockets) {
+        match iface.poll(timestamp, &mut device, &mut sockets) {
             Ok(_) => {}
             Err(e) => {
                 debug!("poll error: {}", e);

examples/ping.rs

@@ -87,7 +87,8 @@ fn main() {
     let mut matches = utils::parse_options(&opts, free);
     let device = utils::parse_tuntap_options(&mut matches);
     let fd = device.as_raw_fd();
-    let device = utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+    let mut device =
+        utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
     let device_caps = device.capabilities();
     let address = IpAddress::from_str(&matches.free[0]).expect("invalid address format");
     let count = matches
@@ -128,15 +129,13 @@ fn main() {
     routes.add_default_ipv6_route(default_v6_gw).unwrap();
 
     let medium = device.capabilities().medium;
-    let mut builder = InterfaceBuilder::new(device)
-        .ip_addrs(ip_addrs)
-        .routes(routes);
+    let mut builder = InterfaceBuilder::new().ip_addrs(ip_addrs).routes(routes);
     if medium == Medium::Ethernet {
         builder = builder
             .hardware_addr(ethernet_addr.into())
             .neighbor_cache(neighbor_cache);
     }
-    let mut iface = builder.finalize();
+    let mut iface = builder.finalize(&mut device);
 
     let mut sockets = SocketSet::new(vec![]);
     let icmp_handle = sockets.add(icmp_socket);
@@ -150,7 +149,7 @@ fn main() {
 
     loop {
         let timestamp = Instant::now();
-        match iface.poll(timestamp, &mut sockets) {
+        match iface.poll(timestamp, &mut device, &mut sockets) {
             Ok(_) => {}
             Err(e) => {
                 debug!("poll error: {}", e);

examples/server.rs

@@ -22,7 +22,8 @@ fn main() {
     let mut matches = utils::parse_options(&opts, free);
     let device = utils::parse_tuntap_options(&mut matches);
     let fd = device.as_raw_fd();
-    let device = utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+    let mut device =
+        utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
 
     let neighbor_cache = NeighborCache::new(BTreeMap::new());
 
@@ -54,13 +55,13 @@ fn main() {
     ];
 
     let medium = device.capabilities().medium;
-    let mut builder = InterfaceBuilder::new(device).ip_addrs(ip_addrs);
+    let mut builder = InterfaceBuilder::new().ip_addrs(ip_addrs);
     if medium == Medium::Ethernet {
         builder = builder
             .hardware_addr(ethernet_addr.into())
             .neighbor_cache(neighbor_cache);
     }
-    let mut iface = builder.finalize();
+    let mut iface = builder.finalize(&mut device);
 
     let mut sockets = SocketSet::new(vec![]);
     let udp_handle = sockets.add(udp_socket);
@@ -72,7 +73,7 @@ fn main() {
     let mut tcp_6970_active = false;
     loop {
         let timestamp = Instant::now();
-        match iface.poll(timestamp, &mut sockets) {
+        match iface.poll(timestamp, &mut device, &mut sockets) {
             Ok(_) => {}
             Err(e) => {
                 debug!("poll error: {}", e);

examples/sixlowpan.rs

@@ -64,7 +64,8 @@ fn main() {
     let device = RawSocket::new("wpan1", Medium::Ieee802154).unwrap();
 
     let fd = device.as_raw_fd();
-    let device = utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
+    let mut device =
+        utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
 
     let neighbor_cache = NeighborCache::new(BTreeMap::new());
 
@@ -80,20 +81,20 @@ fn main() {
         64,
     )];
 
-    let mut builder = InterfaceBuilder::new(device)
+    let mut builder = InterfaceBuilder::new()
         .ip_addrs(ip_addrs)
         .pan_id(Ieee802154Pan(0xbeef));
     builder = builder
         .hardware_addr(ieee802154_addr.into())
         .neighbor_cache(neighbor_cache);
-    let mut iface = builder.finalize();
+    let mut iface = builder.finalize(&mut device);
 
     let mut sockets = SocketSet::new(vec![]);
     let udp_handle = sockets.add(udp_socket);
 
     loop {
         let timestamp = Instant::now();
-        match iface.poll(timestamp, &mut sockets) {
+        match iface.poll(timestamp, &mut device, &mut sockets) {
             Ok(_) => {}
             Err(e) => {
                 debug!("poll error: {}", e);

fuzz/fuzz_targets/tcp_headers.rs

@@ -132,11 +132,11 @@ fuzz_target!(|data: &[u8]| {
     let neighbor_cache = NeighborCache::new(&mut neighbor_cache_entries[..]);
 
     let ip_addrs = [IpCidr::new(IpAddress::v4(127, 0, 0, 1), 8)];
-    let mut iface = InterfaceBuilder::new(device)
+    let mut iface = InterfaceBuilder::new()
         .ethernet_addr(EthernetAddress::default())
         .neighbor_cache(neighbor_cache)
         .ip_addrs(ip_addrs)
-        .finalize();
+        .finalize(&mut device);
 
     let server_socket = {
         // It is not strictly necessary to use a `static mut` and unsafe code here, but

src/iface/mod.rs

@@ -25,4 +25,4 @@ pub use socket_set::{SocketHandle, SocketSet, SocketStorage};
 #[cfg(feature = "proto-sixlowpan")]
 pub use self::fragmentation::{PacketAssembler, PacketAssemblerSet as FragmentsCache};
 
-pub use self::interface::{Interface, InterfaceBuilder, InterfaceInner as Context};
+pub use self::interface::{Interface, InterfaceBuilder};

src/socket/dhcpv4.rs

@@ -1,4 +1,4 @@
-use crate::iface::Context;
+use crate::iface::Interface;
 use crate::time::{Duration, Instant};
 use crate::wire::dhcpv4::field as dhcpv4_field;
 use crate::wire::HardwareAddress;
@@ -180,7 +180,7 @@ impl Socket {
         self.ignore_naks = ignore_naks;
     }
 
-    pub(crate) fn poll_at(&self, _cx: &mut Context) -> PollAt {
+    pub(crate) fn poll_at(&self, _iface: &mut Interface) -> PollAt {
         let t = match &self.state {
             ClientState::Discovering(state) => state.retry_at,
             ClientState::Requesting(state) => state.retry_at,
@@ -191,7 +191,7 @@ impl Socket {
 
     pub(crate) fn process(
         &mut self,
-        cx: &mut Context,
+        iface: &mut Interface,
         ip_repr: &Ipv4Repr,
         repr: &UdpRepr,
         payload: &[u8],
@@ -215,8 +215,8 @@ impl Socket {
                 return;
             }
         };
-        let hardware_addr = match cx.hardware_addr() {
-            Some(HardwareAddress::Ethernet(addr)) => addr,
+        let hardware_addr = match iface.hardware_addr() {
+            HardwareAddress::Ethernet(addr) => addr,
             _ => return,
         };
 
@@ -252,7 +252,7 @@ impl Socket {
                 }
 
                 self.state = ClientState::Requesting(RequestState {
-                    retry_at: cx.now(),
+                    retry_at: iface.now(),
                     retry: 0,
                     server: ServerInfo {
                         address: src_ip,
@@ -263,7 +263,7 @@ impl Socket {
             }
             (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(iface.now(), &dhcp_repr, self.max_lease_duration)
                 {
                     self.config_changed = true;
                     self.state = ClientState::Renewing(RenewState {
@@ -281,7 +281,7 @@ impl Socket {
             }
             (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(iface.now(), &dhcp_repr, self.max_lease_duration)
                 {
                     state.renew_at = renew_at;
                     state.expires_at = expires_at;
@@ -366,22 +366,22 @@ impl Socket {
     }
 
     #[cfg(not(test))]
-    fn random_transaction_id(cx: &mut Context) -> u32 {
-        cx.rand().rand_u32()
+    fn random_transaction_id(iface: &mut Interface) -> u32 {
+        iface.rand().rand_u32()
     }
 
     #[cfg(test)]
-    fn random_transaction_id(_cx: &mut Context) -> u32 {
+    fn random_transaction_id(_iface: &mut Interface) -> u32 {
         0x12345678
     }
 
-    pub(crate) fn dispatch<F, E>(&mut self, cx: &mut Context, emit: F) -> Result<(), E>
+    pub(crate) fn dispatch<F, E>(&mut self, iface: &mut Interface, emit: F) -> Result<(), E>
     where
-        F: FnOnce(&mut Context, (Ipv4Repr, UdpRepr, DhcpRepr)) -> Result<(), E>,
+        F: FnOnce(&mut Interface, (Ipv4Repr, UdpRepr, DhcpRepr)) -> Result<(), E>,
     {
         // 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 HardwareAddress::Ethernet(addr) = iface.hardware_addr() {
             addr
         } else {
             panic!("using DHCPv4 socket with a non-ethernet hardware address.");
@@ -393,7 +393,7 @@ impl Socket {
 
         // 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(cx);
+        let next_transaction_id = Self::random_transaction_id(iface);
 
         let mut dhcp_repr = DhcpRepr {
             message_type: DhcpMessageType::Discover,
@@ -410,7 +410,7 @@ impl Socket {
             client_identifier: Some(ethernet_addr),
             server_identifier: None,
             parameter_request_list: Some(PARAMETER_REQUEST_LIST),
-            max_size: Some((cx.ip_mtu() - MAX_IPV4_HEADER_LEN - UDP_HEADER_LEN) as u16),
+            max_size: Some((iface.ip_mtu() - MAX_IPV4_HEADER_LEN - UDP_HEADER_LEN) as u16),
             lease_duration: None,
             dns_servers: None,
         };
@@ -430,7 +430,7 @@ impl Socket {
 
         match &mut self.state {
             ClientState::Discovering(state) => {
-                if cx.now() < state.retry_at {
+                if iface.now() < state.retry_at {
                     return Ok(());
                 }
 
@@ -441,15 +441,15 @@ impl Socket {
                     dhcp_repr
                 );
                 ipv4_repr.payload_len = udp_repr.header_len() + dhcp_repr.buffer_len();
-                emit(cx, (ipv4_repr, udp_repr, dhcp_repr))?;
+                emit(iface, (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 = iface.now() + DISCOVER_TIMEOUT;
                 self.transaction_id = next_transaction_id;
                 Ok(())
             }
             ClientState::Requesting(state) => {
-                if cx.now() < state.retry_at {
+                if iface.now() < state.retry_at {
                     return Ok(());
                 }
 
@@ -469,24 +469,24 @@ impl Socket {
                     dhcp_repr
                 );
                 ipv4_repr.payload_len = udp_repr.header_len() + dhcp_repr.buffer_len();
-                emit(cx, (ipv4_repr, udp_repr, dhcp_repr))?;
+                emit(iface, (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 = iface.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 <= iface.now() {
                     net_debug!("DHCP lease expired");
                     self.reset();
                     // return Ok so we get polled again
                     return Ok(());
                 }
 
-                if cx.now() < state.renew_at {
+                if iface.now() < state.renew_at {
                     return Ok(());
                 }
 
@@ -497,7 +497,7 @@ impl Socket {
 
                 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(cx, (ipv4_repr, udp_repr, dhcp_repr))?;
+                emit(iface, (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
@@ -505,7 +505,7 @@ impl Socket {
                 // 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);
+                    iface.now() + MIN_RENEW_TIMEOUT.max((state.expires_at - iface.now()) / 2);
 
                 self.transaction_id = next_transaction_id;
                 Ok(())
@@ -558,7 +558,7 @@ mod test {
 
     struct TestSocket {
         socket: Socket,
-        cx: Context<'static>,
+        cx: Interface<'static>,
     }
 
     impl Deref for TestSocket {
@@ -795,7 +795,7 @@ mod test {
         assert_eq!(s.poll(), Some(Event::Deconfigured));
         TestSocket {
             socket: s,
-            cx: Context::mock(),
+            cx: Interface::mock(),
         }
     }
 

src/socket/dns.rs

@@ -4,7 +4,7 @@ use core::task::Waker;
 use heapless::Vec;
 use managed::ManagedSlice;
 
-use crate::socket::{Context, PollAt};
+use crate::socket::{Interface, PollAt};
 use crate::time::{Duration, Instant};
 use crate::wire::dns::{Flags, Opcode, Packet, Question, Rcode, Record, RecordData, Repr, Type};
 use crate::wire::{self, IpAddress, IpProtocol, IpRepr, UdpRepr};
@@ -182,7 +182,7 @@ impl<'a> Socket<'a> {
     /// the same (there's no support for DNS search path).
     pub fn start_query(
         &mut self,
-        cx: &mut Context,
+        iface: &mut Interface,
         name: &str,
     ) -> Result<QueryHandle, StartQueryError> {
         let mut name = name.as_bytes();
@@ -223,7 +223,7 @@ impl<'a> Socket<'a> {
             .push(0x00)
             .map_err(|_| StartQueryError::NameTooLong)?;
 
-        self.start_query_raw(cx, &raw_name)
+        self.start_query_raw(iface, &raw_name)
     }
 
     /// Start a query with a raw (wire-format) DNS name.
@@ -232,7 +232,7 @@ impl<'a> Socket<'a> {
     /// You probably want to use [`start_query`] instead.
     pub fn start_query_raw(
         &mut self,
-        cx: &mut Context,
+        iface: &mut Interface,
         raw_name: &[u8],
     ) -> Result<QueryHandle, StartQueryError> {
         let handle = self.find_free_query().ok_or(StartQueryError::NoFreeSlot)?;
@@ -241,8 +241,8 @@ impl<'a> Socket<'a> {
             state: State::Pending(PendingQuery {
                 name: Vec::from_slice(raw_name).map_err(|_| StartQueryError::NameTooLong)?,
                 type_: Type::A,
-                txid: cx.rand().rand_u16(),
-                port: cx.rand().rand_source_port(),
+                txid: iface.rand().rand_u16(),
+                port: iface.rand().rand_source_port(),
                 delay: RETRANSMIT_DELAY,
                 timeout_at: None,
                 retransmit_at: Instant::ZERO,
@@ -321,7 +321,7 @@ impl<'a> Socket<'a> {
 
     pub(crate) fn process(
         &mut self,
-        _cx: &mut Context,
+        _iface: &mut Interface,
         ip_repr: &IpRepr,
         udp_repr: &UdpRepr,
         payload: &[u8],
@@ -473,9 +473,9 @@ impl<'a> Socket<'a> {
         net_trace!("no query matched");
     }
 
-    pub(crate) fn dispatch<F, E>(&mut self, cx: &mut Context, emit: F) -> Result<(), E>
+    pub(crate) fn dispatch<F, E>(&mut self, iface: &mut Interface, emit: F) -> Result<(), E>
     where
-        F: FnOnce(&mut Context, (IpRepr, UdpRepr, &[u8])) -> Result<(), E>,
+        F: FnOnce(&mut Interface, (IpRepr, UdpRepr, &[u8])) -> Result<(), E>,
     {
         let hop_limit = self.hop_limit.unwrap_or(64);
 
@@ -484,15 +484,15 @@ impl<'a> Socket<'a> {
                 let timeout = if let Some(timeout) = pq.timeout_at {
                     timeout
                 } else {
-                    let v = cx.now() + RETRANSMIT_TIMEOUT;
+                    let v = iface.now() + RETRANSMIT_TIMEOUT;
                     pq.timeout_at = Some(v);
                     v
                 };
 
                 // Check timeout
-                if timeout < cx.now() {
+                if timeout < iface.now() {
                     // DNS timeout
-                    pq.timeout_at = Some(cx.now() + RETRANSMIT_TIMEOUT);
+                    pq.timeout_at = Some(iface.now() + RETRANSMIT_TIMEOUT);
                     pq.retransmit_at = Instant::ZERO;
                     pq.delay = RETRANSMIT_DELAY;
 
@@ -514,7 +514,7 @@ impl<'a> Socket<'a> {
                     continue;
                 }
 
-                if pq.retransmit_at > cx.now() {
+                if pq.retransmit_at > iface.now() {
                     // query is waiting for retransmit
                     continue;
                 }
@@ -539,7 +539,7 @@ impl<'a> Socket<'a> {
                 };
 
                 let dst_addr = self.servers[pq.server_idx];
-                let src_addr = cx.get_source_address(dst_addr).unwrap(); // TODO remove unwrap
+                let src_addr = iface.get_source_address(dst_addr).unwrap(); // TODO remove unwrap
                 let ip_repr = IpRepr::new(
                     src_addr,
                     dst_addr,
@@ -555,9 +555,9 @@ impl<'a> Socket<'a> {
                     udp_repr.src_port
                 );
 
-                emit(cx, (ip_repr, udp_repr, payload))?;
+                emit(iface, (ip_repr, udp_repr, payload))?;
 
-                pq.retransmit_at = cx.now() + pq.delay;
+                pq.retransmit_at = iface.now() + pq.delay;
                 pq.delay = MAX_RETRANSMIT_DELAY.min(pq.delay * 2);
 
                 return Ok(());
@@ -568,7 +568,7 @@ impl<'a> Socket<'a> {
         Ok(())
     }
 
-    pub(crate) fn poll_at(&self, _cx: &Context) -> PollAt {
+    pub(crate) fn poll_at(&self, _cx: &Interface) -> PollAt {
         self.queries
             .iter()
             .flatten()

src/socket/icmp.rs

@@ -5,7 +5,7 @@ use core::task::Waker;
 use crate::phy::ChecksumCapabilities;
 #[cfg(feature = "async")]
 use crate::socket::WakerRegistration;
-use crate::socket::{Context, PollAt};
+use crate::socket::{Interface, PollAt};
 
 use crate::storage::Empty;
 use crate::wire::IcmpRepr;
@@ -347,7 +347,12 @@ impl<'a> Socket<'a> {
 
     /// Filter determining which packets received by the interface are appended to
     /// the given sockets received buffer.
-    pub(crate) fn accepts(&self, cx: &mut Context, ip_repr: &IpRepr, icmp_repr: &IcmpRepr) -> bool {
+    pub(crate) fn accepts(
+        &self,
+        iface: &mut Interface,
+        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
@@ -362,7 +367,7 @@ impl<'a> Socket<'a> {
                     &packet,
                     &ip_repr.src_addr(),
                     &ip_repr.dst_addr(),
-                    &cx.checksum_caps(),
+                    &iface.checksum_caps(),
                 ) {
                     Ok(repr) => endpoint.port == repr.src_port,
                     Err(_) => false,
@@ -378,7 +383,7 @@ impl<'a> Socket<'a> {
                     &packet,
                     &ip_repr.src_addr(),
                     &ip_repr.dst_addr(),
-                    &cx.checksum_caps(),
+                    &iface.checksum_caps(),
                 ) {
                     Ok(repr) => endpoint.port == repr.src_port,
                     Err(_) => false,
@@ -409,7 +414,12 @@ impl<'a> Socket<'a> {
         }
     }
 
-    pub(crate) fn process(&mut self, _cx: &mut Context, ip_repr: &IpRepr, icmp_repr: &IcmpRepr) {
+    pub(crate) fn process(
+        &mut self,
+        _iface: &mut Interface,
+        ip_repr: &IpRepr,
+        icmp_repr: &IcmpRepr,
+    ) {
         match *icmp_repr {
             #[cfg(feature = "proto-ipv4")]
             IcmpRepr::Ipv4(ref icmp_repr) => {
@@ -451,9 +461,9 @@ impl<'a> Socket<'a> {
         self.rx_waker.wake();
     }
 
-    pub(crate) fn dispatch<F, E>(&mut self, cx: &mut Context, emit: F) -> Result<(), E>
+    pub(crate) fn dispatch<F, E>(&mut self, iface: &mut Interface, emit: F) -> Result<(), E>
     where
-        F: FnOnce(&mut Context, (IpRepr, IcmpRepr)) -> Result<(), E>,
+        F: FnOnce(&mut Interface, (IpRepr, IcmpRepr)) -> Result<(), E>,
     {
         let hop_limit = self.hop_limit.unwrap_or(64);
         let res = self.tx_buffer.dequeue_with(|remote_endpoint, packet_buf| {
@@ -465,7 +475,7 @@ impl<'a> Socket<'a> {
             match *remote_endpoint {
                 #[cfg(feature = "proto-ipv4")]
                 IpAddress::Ipv4(dst_addr) => {
-                    let src_addr = match cx.get_source_address_ipv4(dst_addr) {
+                    let src_addr = match iface.get_source_address_ipv4(dst_addr) {
                         Some(addr) => addr,
                         None => {
                             net_trace!(
@@ -493,11 +503,11 @@ impl<'a> Socket<'a> {
                         payload_len: repr.buffer_len(),
                         hop_limit: hop_limit,
                     });
-                    emit(cx, (ip_repr, IcmpRepr::Ipv4(repr)))
+                    emit(iface, (ip_repr, IcmpRepr::Ipv4(repr)))
                 }
                 #[cfg(feature = "proto-ipv6")]
                 IpAddress::Ipv6(dst_addr) => {
-                    let src_addr = match cx.get_source_address_ipv6(dst_addr) {
+                    let src_addr = match iface.get_source_address_ipv6(dst_addr) {
                         Some(addr) => addr,
                         None => {
                             net_trace!(
@@ -530,7 +540,7 @@ impl<'a> Socket<'a> {
                         payload_len: repr.buffer_len(),
                         hop_limit: hop_limit,
                     });
-                    emit(cx, (ip_repr, IcmpRepr::Ipv6(repr)))
+                    emit(iface, (ip_repr, IcmpRepr::Ipv6(repr)))
                 }
             }
         });
@@ -545,7 +555,7 @@ impl<'a> Socket<'a> {
         }
     }
 
-    pub(crate) fn poll_at(&self, _cx: &mut Context) -> PollAt {
+    pub(crate) fn poll_at(&self, _iface: &mut Interface) -> PollAt {
         if self.tx_buffer.is_empty() {
             PollAt::Ingress
         } else {
@@ -629,7 +639,7 @@ mod test_ipv4 {
     #[test]
     fn test_send_dispatch() {
         let mut socket = socket(buffer(0), buffer(1));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
         let checksum = ChecksumCapabilities::default();
 
         assert_eq!(
@@ -684,7 +694,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 mut cx = Interface::mock();
         let checksum = ChecksumCapabilities::default();
 
         let mut bytes = [0xff; 24];
@@ -718,7 +728,7 @@ mod test_ipv4 {
     #[test]
     fn test_recv_process() {
         let mut socket = socket(buffer(1), buffer(1));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
         assert_eq!(socket.bind(Endpoint::Ident(0x1234)), Ok(()));
 
         assert!(!socket.can_recv());
@@ -745,7 +755,7 @@ mod test_ipv4 {
     #[test]
     fn test_accept_bad_id() {
         let mut socket = socket(buffer(1), buffer(1));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
         assert_eq!(socket.bind(Endpoint::Ident(0x1234)), Ok(()));
 
         let checksum = ChecksumCapabilities::default();
@@ -766,7 +776,7 @@ mod test_ipv4 {
     #[test]
     fn test_accepts_udp() {
         let mut socket = socket(buffer(1), buffer(1));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
         assert_eq!(socket.bind(Endpoint::Udp(LOCAL_END_V4.into())), Ok(()));
 
         let checksum = ChecksumCapabilities::default();
@@ -872,7 +882,7 @@ mod test_ipv6 {
     #[test]
     fn test_send_dispatch() {
         let mut socket = socket(buffer(0), buffer(1));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
         let checksum = ChecksumCapabilities::default();
 
         assert_eq!(
@@ -932,7 +942,7 @@ mod test_ipv6 {
     #[test]
     fn test_set_hop_limit() {
         let mut s = socket(buffer(0), buffer(1));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
         let checksum = ChecksumCapabilities::default();
 
         let mut bytes = vec![0xff; 24];
@@ -971,7 +981,7 @@ mod test_ipv6 {
     #[test]
     fn test_recv_process() {
         let mut socket = socket(buffer(1), buffer(1));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
         assert_eq!(socket.bind(Endpoint::Ident(0x1234)), Ok(()));
 
         assert!(!socket.can_recv());
@@ -1003,7 +1013,7 @@ mod test_ipv6 {
     #[test]
     fn test_accept_bad_id() {
         let mut socket = socket(buffer(1), buffer(1));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
         assert_eq!(socket.bind(Endpoint::Ident(0x1234)), Ok(()));
 
         let checksum = ChecksumCapabilities::default();
@@ -1029,7 +1039,7 @@ mod test_ipv6 {
     #[test]
     fn test_accepts_udp() {
         let mut socket = socket(buffer(1), buffer(1));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
         assert_eq!(socket.bind(Endpoint::Udp(LOCAL_END_V6.into())), Ok(()));
 
         let checksum = ChecksumCapabilities::default();

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::iface::Context;
+use crate::iface::Interface;
 use crate::time::Instant;
 
 #[cfg(feature = "socket-dhcpv4")]
@@ -72,20 +72,20 @@ pub enum Socket<'a> {
 }
 
 impl<'a> Socket<'a> {
-    pub(crate) fn poll_at(&self, cx: &mut Context) -> PollAt {
+    pub(crate) fn poll_at(&self, iface: &mut Interface) -> PollAt {
         match self {
             #[cfg(feature = "socket-raw")]
-            Socket::Raw(s) => s.poll_at(cx),
+            Socket::Raw(s) => s.poll_at(iface),
             #[cfg(feature = "socket-icmp")]
-            Socket::Icmp(s) => s.poll_at(cx),
+            Socket::Icmp(s) => s.poll_at(iface),
             #[cfg(feature = "socket-udp")]
-            Socket::Udp(s) => s.poll_at(cx),
+            Socket::Udp(s) => s.poll_at(iface),
             #[cfg(feature = "socket-tcp")]
-            Socket::Tcp(s) => s.poll_at(cx),
+            Socket::Tcp(s) => s.poll_at(iface),
             #[cfg(feature = "socket-dhcpv4")]
-            Socket::Dhcpv4(s) => s.poll_at(cx),
+            Socket::Dhcpv4(s) => s.poll_at(iface),
             #[cfg(feature = "socket-dns")]
-            Socket::Dns(s) => s.poll_at(cx),
+            Socket::Dns(s) => s.poll_at(iface),
         }
     }
 }

src/socket/raw.rs

@@ -2,7 +2,7 @@ use core::cmp::min;
 #[cfg(feature = "async")]
 use core::task::Waker;
 
-use crate::iface::Context;
+use crate::iface::Interface;
 use crate::socket::PollAt;
 #[cfg(feature = "async")]
 use crate::socket::WakerRegistration;
@@ -235,7 +235,7 @@ impl<'a> Socket<'a> {
         true
     }
 
-    pub(crate) fn process(&mut self, cx: &mut Context, ip_repr: &IpRepr, payload: &[u8]) {
+    pub(crate) fn process(&mut self, iface: &mut Interface, ip_repr: &IpRepr, payload: &[u8]) {
         debug_assert!(self.accepts(ip_repr));
 
         let header_len = ip_repr.buffer_len();
@@ -250,7 +250,7 @@ impl<'a> Socket<'a> {
 
         match self.rx_buffer.enqueue(total_len, ()) {
             Ok(buf) => {
-                ip_repr.emit(&mut buf[..header_len], &cx.checksum_caps());
+                ip_repr.emit(&mut buf[..header_len], &iface.checksum_caps());
                 buf[header_len..].copy_from_slice(payload);
             }
             Err(_) => net_trace!(
@@ -264,13 +264,13 @@ impl<'a> Socket<'a> {
         self.rx_waker.wake();
     }
 
-    pub(crate) fn dispatch<F, E>(&mut self, cx: &mut Context, emit: F) -> Result<(), E>
+    pub(crate) fn dispatch<F, E>(&mut self, iface: &mut Interface, emit: F) -> Result<(), E>
     where
-        F: FnOnce(&mut Context, (IpRepr, &[u8])) -> Result<(), E>,
+        F: FnOnce(&mut Interface, (IpRepr, &[u8])) -> Result<(), E>,
     {
         let ip_protocol = self.ip_protocol;
         let ip_version = self.ip_version;
-        let _checksum_caps = &cx.checksum_caps();
+        let _checksum_caps = &iface.checksum_caps();
         let res = self.tx_buffer.dequeue_with(|&mut (), buffer| {
             match IpVersion::of_packet(buffer) {
                 #[cfg(feature = "proto-ipv4")]
@@ -303,7 +303,7 @@ impl<'a> Socket<'a> {
                         }
                     };
                     net_trace!("raw:{}:{}: sending", ip_version, ip_protocol);
-                    emit(cx, (IpRepr::Ipv4(ipv4_repr), packet.payload()))
+                    emit(iface, (IpRepr::Ipv4(ipv4_repr), packet.payload()))
                 }
                 #[cfg(feature = "proto-ipv6")]
                 Ok(IpVersion::Ipv6) => {
@@ -328,7 +328,7 @@ impl<'a> Socket<'a> {
                     };
 
                     net_trace!("raw:{}:{}: sending", ip_version, ip_protocol);
-                    emit(cx, (IpRepr::Ipv6(ipv6_repr), packet.payload()))
+                    emit(iface, (IpRepr::Ipv6(ipv6_repr), packet.payload()))
                 }
                 Err(_) => {
                     net_trace!("raw: sent packet with invalid IP version, dropping.");
@@ -347,7 +347,7 @@ impl<'a> Socket<'a> {
         }
     }
 
-    pub(crate) fn poll_at(&self, _cx: &mut Context) -> PollAt {
+    pub(crate) fn poll_at(&self, _iface: &mut Interface) -> PollAt {
         if self.tx_buffer.is_empty() {
             PollAt::Ingress
         } else {
@@ -456,7 +456,7 @@ mod test {
                 #[test]
                 fn test_send_dispatch() {
                     let mut socket = $socket(buffer(0), buffer(1));
-                    let mut cx = Context::mock();
+                    let mut cx = Interface::mock();
 
                     assert!(socket.can_send());
                     assert_eq!(
@@ -492,7 +492,7 @@ mod test {
                 #[test]
                 fn test_recv_truncated_slice() {
                     let mut socket = $socket(buffer(1), buffer(0));
-                    let mut cx = Context::mock();
+                    let mut cx = Interface::mock();
 
                     assert!(socket.accepts(&$hdr));
                     socket.process(&mut cx, &$hdr, &$payload);
@@ -505,7 +505,7 @@ mod test {
                 #[test]
                 fn test_recv_truncated_packet() {
                     let mut socket = $socket(buffer(1), buffer(0));
-                    let mut cx = Context::mock();
+                    let mut cx = Interface::mock();
 
                     let mut buffer = vec![0; 128];
                     buffer[..$packet.len()].copy_from_slice(&$packet[..]);
@@ -541,7 +541,7 @@ mod test {
         #[cfg(feature = "proto-ipv4")]
         {
             let mut socket = ipv4_locals::socket(buffer(0), buffer(2));
-            let mut cx = Context::mock();
+            let mut cx = Interface::mock();
 
             let mut wrong_version = ipv4_locals::PACKET_BYTES;
             Ipv4Packet::new_unchecked(&mut wrong_version).set_version(6);
@@ -564,7 +564,7 @@ mod test {
         #[cfg(feature = "proto-ipv6")]
         {
             let mut socket = ipv6_locals::socket(buffer(0), buffer(2));
-            let mut cx = Context::mock();
+            let mut cx = Interface::mock();
 
             let mut wrong_version = ipv6_locals::PACKET_BYTES;
             Ipv6Packet::new_unchecked(&mut wrong_version[..]).set_version(4);
@@ -592,7 +592,7 @@ mod test {
         {
             let mut socket = ipv4_locals::socket(buffer(1), buffer(0));
             assert!(!socket.can_recv());
-            let mut cx = Context::mock();
+            let mut cx = Interface::mock();
 
             let mut cksumd_packet = ipv4_locals::PACKET_BYTES;
             Ipv4Packet::new_unchecked(&mut cksumd_packet).fill_checksum();
@@ -619,7 +619,7 @@ mod test {
         {
             let mut socket = ipv6_locals::socket(buffer(1), buffer(0));
             assert!(!socket.can_recv());
-            let mut cx = Context::mock();
+            let mut cx = Interface::mock();
 
             assert_eq!(socket.recv(), Err(RecvError::Exhausted));
             assert!(socket.accepts(&ipv6_locals::HEADER_REPR));

src/socket/tcp.rs

@@ -9,7 +9,7 @@ use core::{cmp, fmt, mem};
 
 #[cfg(feature = "async")]
 use crate::socket::WakerRegistration;
-use crate::socket::{Context, PollAt};
+use crate::socket::{Interface, PollAt};
 use crate::storage::{Assembler, RingBuffer};
 use crate::time::{Duration, Instant};
 use crate::wire::{
@@ -742,7 +742,7 @@ impl<'a> Socket<'a> {
     /// is unspecified.
     pub fn connect<T, U>(
         &mut self,
-        cx: &mut Context,
+        iface: &mut Interface,
         remote_endpoint: T,
         local_endpoint: U,
     ) -> Result<(), ConnectError>
@@ -772,7 +772,7 @@ impl<'a> Socket<'a> {
                     }
                     addr
                 }
-                None => cx
+                None => iface
                     .get_source_address(remote_endpoint.addr)
                     .ok_or(ConnectError::Unaddressable)?,
             },
@@ -790,20 +790,20 @@ impl<'a> Socket<'a> {
         });
         self.set_state(State::SynSent);
 
-        let seq = Self::random_seq_no(cx);
+        let seq = Self::random_seq_no(iface);
         self.local_seq_no = seq;
         self.remote_last_seq = seq;
         Ok(())
     }
 
     #[cfg(test)]
-    fn random_seq_no(_cx: &mut Context) -> TcpSeqNumber {
+    fn random_seq_no(_iface: &mut Interface) -> TcpSeqNumber {
         TcpSeqNumber(10000)
     }
 
     #[cfg(not(test))]
-    fn random_seq_no(cx: &mut Context) -> TcpSeqNumber {
-        TcpSeqNumber(cx.rand().rand_u32() as i32)
+    fn random_seq_no(iface: &mut Interface) -> TcpSeqNumber {
+        TcpSeqNumber(iface.rand().rand_u32() as i32)
     }
 
     /// Close the transmit half of the full-duplex connection.
@@ -1245,21 +1245,21 @@ impl<'a> Socket<'a> {
 
     fn challenge_ack_reply(
         &mut self,
-        cx: &mut Context,
+        iface: &mut Interface,
         ip_repr: &IpRepr,
         repr: &TcpRepr,
     ) -> Option<(IpRepr, TcpRepr<'static>)> {
-        if cx.now() < self.challenge_ack_timer {
+        if iface.now() < self.challenge_ack_timer {
             return None;
         }
 
         // Rate-limit to 1 per second max.
-        self.challenge_ack_timer = cx.now() + Duration::from_secs(1);
+        self.challenge_ack_timer = iface.now() + Duration::from_secs(1);
 
         return Some(self.ack_reply(ip_repr, repr));
     }
 
-    pub(crate) fn accepts(&self, _cx: &mut Context, ip_repr: &IpRepr, repr: &TcpRepr) -> bool {
+    pub(crate) fn accepts(&self, _iface: &mut Interface, ip_repr: &IpRepr, repr: &TcpRepr) -> bool {
         if self.state == State::Closed {
             return false;
         }
@@ -1289,11 +1289,11 @@ impl<'a> Socket<'a> {
 
     pub(crate) fn process(
         &mut self,
-        cx: &mut Context,
+        iface: &mut Interface,
         ip_repr: &IpRepr,
         repr: &TcpRepr,
     ) -> Option<(IpRepr, TcpRepr<'static>)> {
-        debug_assert!(self.accepts(cx, ip_repr, repr));
+        debug_assert!(self.accepts(iface, ip_repr, repr));
 
         // Consider how much the sequence number space differs from the transmit buffer space.
         let (sent_syn, sent_fin) = match self.state {
@@ -1399,7 +1399,7 @@ impl<'a> Socket<'a> {
                         ack_min,
                         ack_max
                     );
-                    return self.challenge_ack_reply(cx, ip_repr, repr);
+                    return self.challenge_ack_reply(iface, ip_repr, repr);
                 }
             }
         }
@@ -1448,10 +1448,10 @@ impl<'a> Socket<'a> {
                     // If we're in the TIME-WAIT state, restart the TIME-WAIT timeout, since
                     // the remote end may not have realized we've closed the connection.
                     if self.state == State::TimeWait {
-                        self.timer.set_for_close(cx.now());
+                        self.timer.set_for_close(iface.now());
                     }
 
-                    return self.challenge_ack_reply(cx, ip_repr, repr);
+                    return self.challenge_ack_reply(iface, ip_repr, repr);
                 }
             }
         }
@@ -1479,7 +1479,7 @@ impl<'a> Socket<'a> {
                     }
                 }
 
-                self.rtte.on_ack(cx.now(), ack_number);
+                self.rtte.on_ack(iface.now(), ack_number);
             }
         }
 
@@ -1529,7 +1529,7 @@ impl<'a> Socket<'a> {
                     local: IpEndpoint::new(ip_repr.dst_addr(), repr.dst_port),
                     remote: IpEndpoint::new(ip_repr.src_addr(), repr.src_port),
                 });
-                self.local_seq_no = Self::random_seq_no(cx);
+                self.local_seq_no = Self::random_seq_no(iface);
                 self.remote_seq_no = repr.seq_number + 1;
                 self.remote_last_seq = self.local_seq_no;
                 self.remote_has_sack = repr.sack_permitted;
@@ -1539,13 +1539,13 @@ impl<'a> Socket<'a> {
                     self.remote_win_shift = 0;
                 }
                 self.set_state(State::SynReceived);
-                self.timer.set_for_idle(cx.now(), self.keep_alive);
+                self.timer.set_for_idle(iface.now(), self.keep_alive);
             }
 
             // ACK packets in the SYN-RECEIVED state change it to ESTABLISHED.
             (State::SynReceived, TcpControl::None) => {
                 self.set_state(State::Established);
-                self.timer.set_for_idle(cx.now(), self.keep_alive);
+                self.timer.set_for_idle(iface.now(), self.keep_alive);
             }
 
             // FIN packets in the SYN-RECEIVED state change it to CLOSE-WAIT.
@@ -1555,7 +1555,7 @@ impl<'a> Socket<'a> {
                 self.remote_seq_no += 1;
                 self.rx_fin_received = true;
                 self.set_state(State::CloseWait);
-                self.timer.set_for_idle(cx.now(), self.keep_alive);
+                self.timer.set_for_idle(iface.now(), self.keep_alive);
             }
 
             // SYN|ACK packets in the SYN-SENT state change it to ESTABLISHED.
@@ -1579,14 +1579,14 @@ impl<'a> Socket<'a> {
                 }
 
                 self.set_state(State::Established);
-                self.timer.set_for_idle(cx.now(), self.keep_alive);
+                self.timer.set_for_idle(iface.now(), self.keep_alive);
             }
 
             // ACK packets in ESTABLISHED state reset the retransmit timer,
             // except for duplicate ACK packets which preserve it.
             (State::Established, TcpControl::None) => {
                 if !self.timer.is_retransmit() || ack_len != 0 {
-                    self.timer.set_for_idle(cx.now(), self.keep_alive);
+                    self.timer.set_for_idle(iface.now(), self.keep_alive);
                 }
             }
 
@@ -1595,7 +1595,7 @@ impl<'a> Socket<'a> {
                 self.remote_seq_no += 1;
                 self.rx_fin_received = true;
                 self.set_state(State::CloseWait);
-                self.timer.set_for_idle(cx.now(), self.keep_alive);
+                self.timer.set_for_idle(iface.now(), self.keep_alive);
             }
 
             // ACK packets in FIN-WAIT-1 state change it to FIN-WAIT-2, if we've already
@@ -1604,7 +1604,7 @@ impl<'a> Socket<'a> {
                 if ack_of_fin {
                     self.set_state(State::FinWait2);
                 }
-                self.timer.set_for_idle(cx.now(), self.keep_alive);
+                self.timer.set_for_idle(iface.now(), self.keep_alive);
             }
 
             // FIN packets in FIN-WAIT-1 state change it to CLOSING, or to TIME-WAIT
@@ -1614,16 +1614,16 @@ impl<'a> Socket<'a> {
                 self.rx_fin_received = true;
                 if ack_of_fin {
                     self.set_state(State::TimeWait);
-                    self.timer.set_for_close(cx.now());
+                    self.timer.set_for_close(iface.now());
                 } else {
                     self.set_state(State::Closing);
-                    self.timer.set_for_idle(cx.now(), self.keep_alive);
+                    self.timer.set_for_idle(iface.now(), self.keep_alive);
                 }
             }
 
             // Data packets in FIN-WAIT-2 reset the idle timer.
             (State::FinWait2, TcpControl::None) => {
-                self.timer.set_for_idle(cx.now(), self.keep_alive);
+                self.timer.set_for_idle(iface.now(), self.keep_alive);
             }
 
             // FIN packets in FIN-WAIT-2 state change it to TIME-WAIT.
@@ -1631,22 +1631,22 @@ impl<'a> Socket<'a> {
                 self.remote_seq_no += 1;
                 self.rx_fin_received = true;
                 self.set_state(State::TimeWait);
-                self.timer.set_for_close(cx.now());
+                self.timer.set_for_close(iface.now());
             }
 
             // ACK packets in CLOSING state change it to TIME-WAIT.
             (State::Closing, TcpControl::None) => {
                 if ack_of_fin {
                     self.set_state(State::TimeWait);
-                    self.timer.set_for_close(cx.now());
+                    self.timer.set_for_close(iface.now());
                 } else {
-                    self.timer.set_for_idle(cx.now(), self.keep_alive);
+                    self.timer.set_for_idle(iface.now(), self.keep_alive);
                 }
             }
 
             // ACK packets in CLOSE-WAIT state reset the retransmit timer.
             (State::CloseWait, TcpControl::None) => {
-                self.timer.set_for_idle(cx.now(), self.keep_alive);
+                self.timer.set_for_idle(iface.now(), self.keep_alive);
             }
 
             // ACK packets in LAST-ACK state change it to CLOSED.
@@ -1656,7 +1656,7 @@ impl<'a> Socket<'a> {
                     self.set_state(State::Closed);
                     self.tuple = None;
                 } else {
-                    self.timer.set_for_idle(cx.now(), self.keep_alive);
+                    self.timer.set_for_idle(iface.now(), self.keep_alive);
                 }
             }
 
@@ -1667,7 +1667,7 @@ impl<'a> Socket<'a> {
         }
 
         // Update remote state.
-        self.remote_last_ts = Some(cx.now());
+        self.remote_last_ts = Some(iface.now());
 
         // RFC 1323: The window field (SEG.WND) in the header of every incoming segment, with the
         // exception of SYN segments, is left-shifted by Snd.Wind.Scale bits before updating SND.WND.
@@ -1809,7 +1809,7 @@ impl<'a> Socket<'a> {
                     AckDelayTimer::Idle => {
                         tcp_trace!("starting delayed ack timer");
 
-                        AckDelayTimer::Waiting(cx.now() + ack_delay)
+                        AckDelayTimer::Waiting(iface.now() + ack_delay)
                     }
                     // RFC1122 says "in a stream of full-sized segments there SHOULD be an ACK
                     // for at least every second segment".
@@ -1847,7 +1847,7 @@ impl<'a> Socket<'a> {
         }
     }
 
-    fn seq_to_transmit(&self, cx: &mut Context) -> bool {
+    fn seq_to_transmit(&self, iface: &mut Interface) -> bool {
         let ip_header_len = match self.tuple.unwrap().local.addr {
             #[cfg(feature = "proto-ipv4")]
             IpAddress::Ipv4(_) => crate::wire::IPV4_HEADER_LEN,
@@ -1856,7 +1856,7 @@ impl<'a> Socket<'a> {
         };
 
         // Max segment size we're able to send due to MTU limitations.
-        let local_mss = cx.ip_mtu() - ip_header_len - TCP_HEADER_LEN;
+        let local_mss = iface.ip_mtu() - ip_header_len - TCP_HEADER_LEN;
 
         // The effective max segment size, taking into account our and remote's limits.
         let effective_mss = local_mss.min(self.remote_mss);
@@ -1933,9 +1933,9 @@ impl<'a> Socket<'a> {
         }
     }
 
-    pub(crate) fn dispatch<F, E>(&mut self, cx: &mut Context, emit: F) -> Result<(), E>
+    pub(crate) fn dispatch<F, E>(&mut self, iface: &mut Interface, emit: F) -> Result<(), E>
     where
-        F: FnOnce(&mut Context, (IpRepr, TcpRepr)) -> Result<(), E>,
+        F: FnOnce(&mut Interface, (IpRepr, TcpRepr)) -> Result<(), E>,
     {
         if self.tuple.is_none() {
             return Ok(());
@@ -1949,16 +1949,16 @@ impl<'a> Socket<'a> {
             // period of time, it isn't anymore, and the local endpoint is talking.
             // So, we start counting the timeout not from the last received packet
             // but from the first transmitted one.
-            self.remote_last_ts = Some(cx.now());
+            self.remote_last_ts = Some(iface.now());
         }
 
         // Check if any state needs to be changed because of a timer.
-        if self.timed_out(cx.now()) {
+        if self.timed_out(iface.now()) {
             // If a timeout expires, we should abort the connection.
             net_debug!("timeout exceeded");
             self.set_state(State::Closed);
-        } else if !self.seq_to_transmit(cx) {
-            if let Some(retransmit_delta) = self.timer.should_retransmit(cx.now()) {
+        } else if !self.seq_to_transmit(iface) {
+            if let Some(retransmit_delta) = self.timer.should_retransmit(iface.now()) {
                 // If a retransmit timer expired, we should resend data starting at the last ACK.
                 net_debug!("retransmitting at t+{}", retransmit_delta);
 
@@ -1971,7 +1971,7 @@ impl<'a> Socket<'a> {
                 // now for whatever reason (like zero window), this avoids an
                 // infinite polling loop where `poll_at` returns `Now` but `dispatch`
                 // can't actually do anything.
-                self.timer.set_for_idle(cx.now(), self.keep_alive);
+                self.timer.set_for_idle(iface.now(), self.keep_alive);
 
                 // Inform RTTE, so that it can avoid bogus measurements.
                 self.rtte.on_retransmit();
@@ -1979,22 +1979,22 @@ impl<'a> Socket<'a> {
         }
 
         // Decide whether we're sending a packet.
-        if self.seq_to_transmit(cx) {
+        if self.seq_to_transmit(iface) {
             // If we have data to transmit and it fits into partner's window, do it.
             tcp_trace!("outgoing segment will send data or flags");
-        } else if self.ack_to_transmit() && self.delayed_ack_expired(cx.now()) {
+        } else if self.ack_to_transmit() && self.delayed_ack_expired(iface.now()) {
             // If we have data to acknowledge, do it.
             tcp_trace!("outgoing segment will acknowledge");
-        } else if self.window_to_update() && self.delayed_ack_expired(cx.now()) {
+        } else if self.window_to_update() && self.delayed_ack_expired(iface.now()) {
             // If we have window length increase to advertise, do it.
             tcp_trace!("outgoing segment will update window");
         } else if self.state == State::Closed {
             // If we need to abort the connection, do it.
             tcp_trace!("outgoing segment will abort connection");
-        } else if self.timer.should_keep_alive(cx.now()) {
+        } else if self.timer.should_keep_alive(iface.now()) {
             // If we need to transmit a keep-alive packet, do it.
             tcp_trace!("keep-alive timer expired");
-        } else if self.timer.should_close(cx.now()) {
+        } else if self.timer.should_close(iface.now()) {
             // If we have spent enough time in the TIME-WAIT state, close the socket.
             tcp_trace!("TIME-WAIT timer expired");
             self.reset();
@@ -2089,7 +2089,7 @@ impl<'a> Socket<'a> {
                 // 3. MSS we can send, determined by our MTU.
                 let size = win_limit
                     .min(self.remote_mss)
-                    .min(cx.ip_mtu() - ip_repr.buffer_len() - TCP_HEADER_LEN);
+                    .min(iface.ip_mtu() - ip_repr.buffer_len() - TCP_HEADER_LEN);
 
                 let offset = self.remote_last_seq - self.local_seq_no;
                 repr.payload = self.tx_buffer.get_allocated(offset, size);
@@ -2118,7 +2118,7 @@ impl<'a> Socket<'a> {
         // sequence space will elicit an ACK, we only need to send an explicit packet if we
         // couldn't fill the sequence space with anything.
         let is_keep_alive;
-        if self.timer.should_keep_alive(cx.now()) && repr.is_empty() {
+        if self.timer.should_keep_alive(iface.now()) && repr.is_empty() {
             repr.seq_number = repr.seq_number - 1;
             repr.payload = b"\x00"; // RFC 1122 says we should do this
             is_keep_alive = true;
@@ -2151,7 +2151,7 @@ impl<'a> Socket<'a> {
 
         if repr.control == TcpControl::Syn {
             // Fill the MSS option. See RFC 6691 for an explanation of this calculation.
-            let max_segment_size = cx.ip_mtu() - ip_repr.buffer_len() - TCP_HEADER_LEN;
+            let max_segment_size = iface.ip_mtu() - ip_repr.buffer_len() - TCP_HEADER_LEN;
             repr.max_seg_size = Some(max_segment_size as u16);
         }
 
@@ -2163,11 +2163,11 @@ impl<'a> Socket<'a> {
         // to not waste time waiting for the retransmit timer on packets that we know
         // for sure will not be successfully transmitted.
         ip_repr.set_payload_len(repr.buffer_len());
-        emit(cx, (ip_repr, repr))?;
+        emit(iface, (ip_repr, repr))?;
 
         // We've sent something, whether useful data or a keep-alive packet, so rewind
         // the keep-alive timer.
-        self.timer.rewind_keep_alive(cx.now(), self.keep_alive);
+        self.timer.rewind_keep_alive(iface.now(), self.keep_alive);
 
         // Reset delayed-ack timer
         match self.ack_delay_timer {
@@ -2194,14 +2194,14 @@ impl<'a> Socket<'a> {
 
         if repr.segment_len() > 0 {
             self.rtte
-                .on_send(cx.now(), repr.seq_number + repr.segment_len());
+                .on_send(iface.now(), repr.seq_number + repr.segment_len());
         }
 
-        if !self.seq_to_transmit(cx) && repr.segment_len() > 0 {
+        if !self.seq_to_transmit(iface) && repr.segment_len() > 0 {
             // If we've transmitted all data we could (and there was something at all,
             // data or flag, to transmit, not just an ACK), wind up the retransmit timer.
             self.timer
-                .set_for_retransmit(cx.now(), self.rtte.retransmission_timeout());
+                .set_for_retransmit(iface.now(), self.rtte.retransmission_timeout());
         }
 
         if self.state == State::Closed {
@@ -2213,7 +2213,7 @@ impl<'a> Socket<'a> {
     }
 
     #[allow(clippy::if_same_then_else)]
-    pub(crate) fn poll_at(&self, cx: &mut Context) -> PollAt {
+    pub(crate) fn poll_at(&self, iface: &mut Interface) -> PollAt {
         // The logic here mirrors the beginning of dispatch() closely.
         if self.tuple.is_none() {
             // No one to talk to, nothing to transmit.
@@ -2224,7 +2224,7 @@ impl<'a> Socket<'a> {
         } else if self.state == State::Closed {
             // Socket was aborted, we have an RST packet to transmit.
             PollAt::Now
-        } else if self.seq_to_transmit(cx) {
+        } else if self.seq_to_transmit(iface) {
             // We have a data or flag packet to transmit.
             PollAt::Now
         } else {
@@ -2376,7 +2376,7 @@ mod test {
 
     struct TestSocket {
         socket: Socket<'static>,
-        cx: Context<'static>,
+        cx: Interface<'static>,
     }
 
     impl Deref for TestSocket {
@@ -2497,7 +2497,7 @@ mod test {
         let tx_buffer = SocketBuffer::new(vec![0; tx_len]);
         let mut socket = Socket::new(rx_buffer, tx_buffer);
         socket.set_ack_delay(None);
-        let cx = Context::mock();
+        let cx = Interface::mock();
         TestSocket { socket, cx }
     }
 

src/socket/udp.rs

@@ -2,7 +2,7 @@ use core::cmp::min;
 #[cfg(feature = "async")]
 use core::task::Waker;
 
-use crate::iface::Context;
+use crate::iface::Interface;
 use crate::socket::PollAt;
 #[cfg(feature = "async")]
 use crate::socket::WakerRegistration;
@@ -332,7 +332,7 @@ impl<'a> Socket<'a> {
         Ok((length, endpoint))
     }
 
-    pub(crate) fn accepts(&self, _cx: &mut Context, ip_repr: &IpRepr, repr: &UdpRepr) -> bool {
+    pub(crate) fn accepts(&self, _iface: &mut Interface, ip_repr: &IpRepr, repr: &UdpRepr) -> bool {
         if self.endpoint.port != repr.dst_port {
             return false;
         }
@@ -349,12 +349,12 @@ impl<'a> Socket<'a> {
 
     pub(crate) fn process(
         &mut self,
-        cx: &mut Context,
+        iface: &mut Interface,
         ip_repr: &IpRepr,
         repr: &UdpRepr,
         payload: &[u8],
     ) {
-        debug_assert!(self.accepts(cx, ip_repr, repr));
+        debug_assert!(self.accepts(iface, ip_repr, repr));
 
         let size = payload.len();
 
@@ -383,9 +383,9 @@ impl<'a> Socket<'a> {
         self.rx_waker.wake();
     }
 
-    pub(crate) fn dispatch<F, E>(&mut self, cx: &mut Context, emit: F) -> Result<(), E>
+    pub(crate) fn dispatch<F, E>(&mut self, iface: &mut Interface, emit: F) -> Result<(), E>
     where
-        F: FnOnce(&mut Context, (IpRepr, UdpRepr, &[u8])) -> Result<(), E>,
+        F: FnOnce(&mut Interface, (IpRepr, UdpRepr, &[u8])) -> Result<(), E>,
     {
         let endpoint = self.endpoint;
         let hop_limit = self.hop_limit.unwrap_or(64);
@@ -393,7 +393,7 @@ impl<'a> Socket<'a> {
         let res = self.tx_buffer.dequeue_with(|remote_endpoint, payload_buf| {
             let src_addr = match endpoint.addr {
                 Some(addr) => addr,
-                None => match cx.get_source_address(remote_endpoint.addr) {
+                None => match iface.get_source_address(remote_endpoint.addr) {
                     Some(addr) => addr,
                     None => {
                         net_trace!(
@@ -424,7 +424,7 @@ impl<'a> Socket<'a> {
                 repr.header_len() + payload_buf.len(),
                 hop_limit,
             );
-            emit(cx, (ip_repr, repr, payload_buf))
+            emit(iface, (ip_repr, repr, payload_buf))
         });
         match res {
             Err(Empty) => Ok(()),
@@ -437,7 +437,7 @@ impl<'a> Socket<'a> {
         }
     }
 
-    pub(crate) fn poll_at(&self, _cx: &mut Context) -> PollAt {
+    pub(crate) fn poll_at(&self, _iface: &mut Interface) -> PollAt {
         if self.tx_buffer.is_empty() {
             PollAt::Ingress
         } else {
@@ -592,7 +592,7 @@ mod test {
     #[test]
     fn test_send_dispatch() {
         let mut socket = socket(buffer(0), buffer(1));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
 
         assert_eq!(socket.bind(LOCAL_END), Ok(()));
 
@@ -635,7 +635,7 @@ mod test {
     #[test]
     fn test_recv_process() {
         let mut socket = socket(buffer(1), buffer(0));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
 
         assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
 
@@ -656,7 +656,7 @@ mod test {
     #[test]
     fn test_peek_process() {
         let mut socket = socket(buffer(1), buffer(0));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
 
         assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
 
@@ -671,7 +671,7 @@ mod test {
     #[test]
     fn test_recv_truncated_slice() {
         let mut socket = socket(buffer(1), buffer(0));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
 
         assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
 
@@ -686,7 +686,7 @@ mod test {
     #[test]
     fn test_peek_truncated_slice() {
         let mut socket = socket(buffer(1), buffer(0));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
 
         assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
 
@@ -703,7 +703,7 @@ mod test {
     #[test]
     fn test_set_hop_limit() {
         let mut s = socket(buffer(0), buffer(1));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
 
         assert_eq!(s.bind(LOCAL_END), Ok(()));
 
@@ -730,7 +730,7 @@ mod test {
     #[test]
     fn test_doesnt_accept_wrong_port() {
         let mut socket = socket(buffer(1), buffer(0));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
 
         assert_eq!(socket.bind(LOCAL_PORT), Ok(()));
 
@@ -742,7 +742,7 @@ mod test {
 
     #[test]
     fn test_doesnt_accept_wrong_ip() {
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
 
         let mut port_bound_socket = socket(buffer(1), buffer(0));
         assert_eq!(port_bound_socket.bind(LOCAL_PORT), Ok(()));
@@ -771,7 +771,7 @@ mod test {
     fn test_process_empty_payload() {
         let recv_buffer = PacketBuffer::new(vec![PacketMetadata::EMPTY; 1], vec![]);
         let mut socket = socket(recv_buffer, buffer(0));
-        let mut cx = Context::mock();
+        let mut cx = Interface::mock();
 
         assert_eq!(socket.bind(LOCAL_PORT), Ok(()));