upgrade smoltcp to 0.12

Cargo.toml

@@ -23,7 +23,7 @@ etherparse = "0.16"
 futures = "0.3"
 rand = "0.8"
 spin = "0.9"
-smoltcp = { version = "0.11", default-features = false, features = [
+smoltcp = { version = "0.12", default-features = false, features = [
     "std",
     "log",
     "medium-ip",

examples/forward.rs

@@ -299,15 +299,15 @@ fn get_device_broadcast(device: &tun2::AsyncDevice) -> Option<std::net::Ipv4Addr
         Err(_) => return None,
     };
 
-    match smoltcp::wire::Ipv4Cidr::from_netmask(address.into(), netmask.into()) {
+    match smoltcp::wire::Ipv4Cidr::from_netmask(address, netmask) {
         Ok(address_net) => match address_net.broadcast() {
             Some(broadcast) => {
                 info!(
                     "tun device network: {} (address: {}, netmask: {}, broadcast: {}, mtu: {})",
                     address_net, address, netmask, broadcast, mtu,
                 );
 
-                Some(broadcast.into())
+                Some(broadcast)
             }
             None => {
                 error!("invalid tun address {}, netmask {}", address, netmask);

src/device.rs

@@ -73,11 +73,11 @@ pub(super) struct VirtualRxToken {
 }
 
 impl RxToken for VirtualRxToken {
-    fn consume<R, F>(mut self, f: F) -> R
+    fn consume<R, F>(self, f: F) -> R
     where
-        F: FnOnce(&mut [u8]) -> R,
+        F: FnOnce(&[u8]) -> R,
     {
-        f(&mut self.buffer[..])
+        f(&self.buffer[..])
     }
 }
 

src/packet.rs

@@ -1,4 +1,4 @@
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+use std::net::IpAddr;
 
 use smoltcp::wire::{IpProtocol, IpVersion, Ipv4Packet, Ipv6Packet};
 
@@ -21,15 +21,15 @@ impl<T: AsRef<[u8]> + Copy> IpPacket<T> {
 
     pub fn src_addr(&self) -> IpAddr {
         match *self {
-            IpPacket::Ipv4(ref packet) => IpAddr::from(Ipv4Addr::from(packet.src_addr())),
-            IpPacket::Ipv6(ref packet) => IpAddr::from(Ipv6Addr::from(packet.src_addr())),
+            IpPacket::Ipv4(ref packet) => IpAddr::from(packet.src_addr()),
+            IpPacket::Ipv6(ref packet) => IpAddr::from(packet.src_addr()),
         }
     }
 
     pub fn dst_addr(&self) -> IpAddr {
         match *self {
-            IpPacket::Ipv4(ref packet) => IpAddr::from(Ipv4Addr::from(packet.dst_addr())),
-            IpPacket::Ipv6(ref packet) => IpAddr::from(Ipv6Addr::from(packet.dst_addr())),
+            IpPacket::Ipv4(ref packet) => IpAddr::from(packet.dst_addr()),
+            IpPacket::Ipv6(ref packet) => IpAddr::from(packet.dst_addr()),
         }
     }
 

src/stack.rs

@@ -227,7 +227,7 @@ impl Sink<AnyIpPktFrame> for Stack {
 
         use std::io::{Error, ErrorKind::InvalidInput};
         let packet = IpPacket::new_checked(item.as_slice())
-            .map_err(|err| Error::new(InvalidInput, format!("invalid IP packet: {}", err)))?;
+            .map_err(|err| Error::new(InvalidInput, format!("invalid IP packet: {err}")))?;
 
         let src_ip = packet.src_addr();
         let dst_ip = packet.dst_addr();

src/tcp.rs

@@ -200,7 +200,10 @@ impl TcpListenerRunner {
 
             let before_poll = Instant::now();
             let updated_sockets = iface.poll(before_poll, &mut device, &mut socket_set);
-            if updated_sockets {
+            if matches!(
+                updated_sockets,
+                smoltcp::iface::PollResult::SocketStateChanged
+            ) {
                 trace!("VirtDevice::poll costed {}", Instant::now() - before_poll);
             }
 

src/udp.rs

@@ -97,12 +97,12 @@ impl Sink<UdpMsg> for WriteHalf {
     fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         match ready!(self.stack_tx.poll_ready_unpin(cx)) {
             Ok(()) => Poll::Ready(Ok(())),
-            Err(err) => Poll::Ready(Err(std::io::Error::new(std::io::ErrorKind::Other, err))),
+            Err(err) => Poll::Ready(Err(std::io::Error::other(err))),
         }
     }
 
     fn start_send(mut self: Pin<&mut Self>, item: UdpMsg) -> Result<(), Self::Error> {
-        use std::io::{Error, ErrorKind::InvalidData, ErrorKind::Other};
+        use std::io::{Error, ErrorKind::InvalidData};
         let (data, src_addr, dst_addr) = item;
 
         if data.is_empty() {
@@ -126,27 +126,27 @@ impl Sink<UdpMsg> for WriteHalf {
         let mut ip_packet_writer = Vec::with_capacity(builder.size(data.len()));
         builder
             .write(&mut ip_packet_writer, &data)
-            .map_err(|err| Error::new(Other, format!("PacketBuilder::write: {}", err)))?;
+            .map_err(|err| Error::other(format!("PacketBuilder::write: {err}")))?;
 
         match self.stack_tx.start_send_unpin(ip_packet_writer.clone()) {
             Ok(()) => Ok(()),
-            Err(err) => Err(Error::new(Other, format!("send error: {}", err))),
+            Err(err) => Err(Error::other(format!("send error: {err}"))),
         }
     }
 
     fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        use std::io::{Error, ErrorKind::Other};
+        use std::io::Error;
         match ready!(self.stack_tx.poll_flush_unpin(cx)) {
             Ok(()) => Poll::Ready(Ok(())),
-            Err(err) => Poll::Ready(Err(Error::new(Other, format!("flush error: {}", err)))),
+            Err(err) => Poll::Ready(Err(Error::other(format!("flush error: {err}")))),
         }
     }
 
     fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        use std::io::{Error, ErrorKind::Other};
+        use std::io::Error;
         match ready!(self.stack_tx.poll_close_unpin(cx)) {
             Ok(()) => Poll::Ready(Ok(())),
-            Err(err) => Poll::Ready(Err(Error::new(Other, format!("close error: {}", err)))),
+            Err(err) => Poll::Ready(Err(Error::other(format!("close error: {err}")))),
         }
     }
 }