Merge branch 'master' of github.com:smoltcp-rs/smoltcp into pxe_support

Author: Qubasa

.github/workflows/clippy.yml

@@ -1,6 +1,6 @@
 on:
   push:
-    branches: [ staging, trying, master ]
+    branches: [ staging, trying ]
   pull_request_target:
 
 name: Clippy check

.github/workflows/fuzz.yml

@@ -1,6 +1,6 @@
 on:
   push:
-    branches: [ staging, trying, master ]
+    branches: [ staging, trying ]
   pull_request:
 
 name: Fuzz

.github/workflows/rustfmt.yaml

@@ -1,6 +1,6 @@
 on:
   push:
-    branches: [ staging, trying, master ]
+    branches: [ staging, trying ]
   pull_request:
 
 name: Rustfmt check

.github/workflows/test.yml

@@ -1,6 +1,6 @@
 on:
   push:
-    branches: [ staging, trying, master ]
+    branches: [ staging, trying ]
   pull_request:
 
 name: Test
@@ -21,7 +21,7 @@ jobs:
         # Failure is permitted on nightly.
         rust:
           - stable
-          - 1.53.0
+          - 1.56.0
           - nightly
 
         features:
@@ -68,13 +68,13 @@ jobs:
         # Failure is permitted on nightly.
         rust:
           - stable
-          - 1.53.0
+          - 1.56.0
           - nightly
 
         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 defmt-trace medium-ip medium-ethernet 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
 
     steps:
       - uses: actions/checkout@v2

Cargo.toml

@@ -21,7 +21,7 @@ byteorder = { version = "1.0", default-features = false }
 log = { version = "0.4.4", default-features = false, optional = true }
 libc = { version = "0.2.18", optional = true }
 bitflags = { version = "1.0", default-features = false }
-defmt = { version = "0.2.0", optional = true }
+defmt = { version = "0.3", optional = true }
 rand_core = { version = "0.6.3", optional = true, default-features = false }
 
 [dev-dependencies]
@@ -57,12 +57,6 @@ rand-custom-impl = []
 
 "async" = []
 
-defmt-trace = []
-defmt-debug = []
-defmt-info = []
-defmt-warn = []
-defmt-error = []
-
 default = [
   "std", "log", # needed for `cargo test --no-default-features --features default` :/
   "medium-ethernet", "medium-ip", "medium-ieee802154",

examples/benchmark.rs

@@ -13,7 +13,6 @@ use std::thread;
 
 use smoltcp::iface::{InterfaceBuilder, NeighborCache};
 use smoltcp::phy::{wait as phy_wait, Device, Medium};
-use smoltcp::socket::SocketSet;
 use smoltcp::socket::{TcpSocket, TcpSocketBuffer};
 use smoltcp::time::{Duration, Instant};
 use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr};
@@ -97,70 +96,65 @@ 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(device, vec![]).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 sockets = SocketSet::new(vec![]);
-    let tcp1_handle = sockets.add(tcp1_socket);
-    let tcp2_handle = sockets.add(tcp2_socket);
+    let tcp1_handle = iface.add_socket(tcp1_socket);
+    let tcp2_handle = iface.add_socket(tcp2_socket);
     let default_timeout = Some(Duration::from_millis(1000));
 
     let mut processed = 0;
     while !CLIENT_DONE.load(Ordering::SeqCst) {
         let timestamp = Instant::now();
-        match iface.poll(&mut sockets, timestamp) {
+        match iface.poll(timestamp) {
             Ok(_) => {}
             Err(e) => {
                 debug!("poll error: {}", e);
             }
         }
 
         // tcp:1234: emit data
-        {
-            let mut socket = sockets.get::<TcpSocket>(tcp1_handle);
-            if !socket.is_open() {
-                socket.listen(1234).unwrap();
-            }
+        let socket = iface.get_socket::<TcpSocket>(tcp1_handle);
+        if !socket.is_open() {
+            socket.listen(1234).unwrap();
+        }
 
-            if socket.can_send() {
-                if processed < AMOUNT {
-                    let length = socket
-                        .send(|buffer| {
-                            let length = cmp::min(buffer.len(), AMOUNT - processed);
-                            (length, length)
-                        })
-                        .unwrap();
-                    processed += length;
-                }
+        if socket.can_send() {
+            if processed < AMOUNT {
+                let length = socket
+                    .send(|buffer| {
+                        let length = cmp::min(buffer.len(), AMOUNT - processed);
+                        (length, length)
+                    })
+                    .unwrap();
+                processed += length;
             }
         }
 
         // tcp:1235: sink data
-        {
-            let mut socket = sockets.get::<TcpSocket>(tcp2_handle);
-            if !socket.is_open() {
-                socket.listen(1235).unwrap();
-            }
+        let socket = iface.get_socket::<TcpSocket>(tcp2_handle);
+        if !socket.is_open() {
+            socket.listen(1235).unwrap();
+        }
 
-            if socket.can_recv() {
-                if processed < AMOUNT {
-                    let length = socket
-                        .recv(|buffer| {
-                            let length = cmp::min(buffer.len(), AMOUNT - processed);
-                            (length, length)
-                        })
-                        .unwrap();
-                    processed += length;
-                }
+        if socket.can_recv() {
+            if processed < AMOUNT {
+                let length = socket
+                    .recv(|buffer| {
+                        let length = cmp::min(buffer.len(), AMOUNT - processed);
+                        (length, length)
+                    })
+                    .unwrap();
+                processed += length;
             }
         }
 
-        match iface.poll_at(&sockets, timestamp) {
+        match iface.poll_at(timestamp) {
             Some(poll_at) if timestamp < poll_at => {
                 phy_wait(fd, Some(poll_at - timestamp)).expect("wait error");
             }

examples/client.rs

@@ -7,7 +7,7 @@ use std::str::{self, FromStr};
 
 use smoltcp::iface::{InterfaceBuilder, NeighborCache, Routes};
 use smoltcp::phy::{wait as phy_wait, Device, Medium};
-use smoltcp::socket::{SocketSet, TcpSocket, TcpSocketBuffer};
+use smoltcp::socket::{TcpSocket, TcpSocketBuffer};
 use smoltcp::time::Instant;
 use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr, Ipv4Address};
 
@@ -42,7 +42,7 @@ fn main() {
     routes.add_default_ipv4_route(default_v4_gw).unwrap();
 
     let medium = device.capabilities().medium;
-    let mut builder = InterfaceBuilder::new(device)
+    let mut builder = InterfaceBuilder::new(device, vec![])
         .ip_addrs(ip_addrs)
         .routes(routes);
     if medium == Medium::Ethernet {
@@ -52,63 +52,58 @@ fn main() {
     }
     let mut iface = builder.finalize();
 
-    let mut sockets = SocketSet::new(vec![]);
-    let tcp_handle = sockets.add(tcp_socket);
+    let tcp_handle = iface.add_socket(tcp_socket);
 
-    {
-        let mut socket = sockets.get::<TcpSocket>(tcp_handle);
-        socket.connect((address, port), 49500).unwrap();
-    }
+    let socket = iface.get_socket::<TcpSocket>(tcp_handle);
+    socket.connect((address, port), 49500).unwrap();
 
     let mut tcp_active = false;
     loop {
         let timestamp = Instant::now();
-        match iface.poll(&mut sockets, timestamp) {
+        match iface.poll(timestamp) {
             Ok(_) => {}
             Err(e) => {
                 debug!("poll error: {}", e);
             }
         }
 
-        {
-            let mut socket = sockets.get::<TcpSocket>(tcp_handle);
-            if socket.is_active() && !tcp_active {
-                debug!("connected");
-            } else if !socket.is_active() && tcp_active {
-                debug!("disconnected");
-                break;
-            }
-            tcp_active = socket.is_active();
-
-            if socket.may_recv() {
-                let data = socket
-                    .recv(|data| {
-                        let mut data = data.to_owned();
-                        if !data.is_empty() {
-                            debug!(
-                                "recv data: {:?}",
-                                str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
-                            );
-                            data = data.split(|&b| b == b'\n').collect::<Vec<_>>().concat();
-                            data.reverse();
-                            data.extend(b"\n");
-                        }
-                        (data.len(), data)
-                    })
-                    .unwrap();
-                if socket.can_send() && !data.is_empty() {
-                    debug!(
-                        "send data: {:?}",
-                        str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
-                    );
-                    socket.send_slice(&data[..]).unwrap();
-                }
-            } else if socket.may_send() {
-                debug!("close");
-                socket.close();
+        let socket = iface.get_socket::<TcpSocket>(tcp_handle);
+        if socket.is_active() && !tcp_active {
+            debug!("connected");
+        } else if !socket.is_active() && tcp_active {
+            debug!("disconnected");
+            break;
+        }
+        tcp_active = socket.is_active();
+
+        if socket.may_recv() {
+            let data = socket
+                .recv(|data| {
+                    let mut data = data.to_owned();
+                    if !data.is_empty() {
+                        debug!(
+                            "recv data: {:?}",
+                            str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
+                        );
+                        data = data.split(|&b| b == b'\n').collect::<Vec<_>>().concat();
+                        data.reverse();
+                        data.extend(b"\n");
+                    }
+                    (data.len(), data)
+                })
+                .unwrap();
+            if socket.can_send() && !data.is_empty() {
+                debug!(
+                    "send data: {:?}",
+                    str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
+                );
+                socket.send_slice(&data[..]).unwrap();
             }
+        } else if socket.may_send() {
+            debug!("close");
+            socket.close();
         }
 
-        phy_wait(fd, iface.poll_delay(&sockets, timestamp)).expect("wait error");
+        phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error");
     }
 }

examples/dhcp_client.rs

@@ -6,7 +6,7 @@ use std::collections::BTreeMap;
 use std::os::unix::io::AsRawFd;
 
 use smoltcp::iface::{Interface, InterfaceBuilder, NeighborCache, Routes};
-use smoltcp::socket::{Dhcpv4Event, Dhcpv4Socket, SocketSet};
+use smoltcp::socket::{Dhcpv4Event, Dhcpv4Socket};
 use smoltcp::time::Instant;
 use smoltcp::wire::{EthernetAddress, IpCidr, Ipv4Address, Ipv4Cidr};
 use smoltcp::{
@@ -34,7 +34,7 @@ fn main() {
     let routes = Routes::new(&mut routes_storage[..]);
 
     let medium = device.capabilities().medium;
-    let mut builder = InterfaceBuilder::new(device)
+    let mut builder = InterfaceBuilder::new(device, vec![])
         .ip_addrs(ip_addrs)
         .routes(routes);
     if medium == Medium::Ethernet {
@@ -44,7 +44,6 @@ fn main() {
     }
     let mut iface = builder.finalize();
 
-    let mut sockets = SocketSet::new(vec![]);
     let mut dhcp_socket = Dhcpv4Socket::new();
 
     // Set a ridiculously short max lease time to show DHCP renews work properly.
@@ -53,15 +52,16 @@ fn main() {
     // IMPORTANT: This should be removed in production.
     dhcp_socket.set_max_lease_duration(Some(Duration::from_secs(10)));
 
-    let dhcp_handle = sockets.add(dhcp_socket);
+    let dhcp_handle = iface.add_socket(dhcp_socket);
 
     loop {
         let timestamp = Instant::now();
-        if let Err(e) = iface.poll(&mut sockets, timestamp) {
+        if let Err(e) = iface.poll(timestamp) {
             debug!("poll error: {}", e);
         }
 
-        match sockets.get::<Dhcpv4Socket>(dhcp_handle).poll() {
+        let event = iface.get_socket::<Dhcpv4Socket>(dhcp_handle).poll();
+        match event {
             None => {}
             Some(Dhcpv4Event::Configured(config)) => {
                 debug!("DHCP config acquired!");
@@ -90,7 +90,7 @@ fn main() {
             }
         }
 
-        phy_wait(fd, iface.poll_delay(&sockets, timestamp)).expect("wait error");
+        phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error");
     }
 }