Update smoltcp to version 0.9

Cargo.toml

@@ -9,4 +9,4 @@ clap = { version = "4.1", features = ["derive"] }
 env_logger = "0.10"
 log = "0.4"
 mio = { version = "0.8", features = ["os-poll", "net", "os-ext"] }
-smoltcp = { version = "0.8", features = ["std"] }
+smoltcp = { version = "0.9", features = ["std"] }

src/tun2proxy.rs

@@ -4,17 +4,17 @@ use mio::event::Event;
 use mio::net::TcpStream;
 use mio::unix::SourceFd;
 use mio::{Events, Interest, Poll, Token};
-use smoltcp::iface::{Interface, InterfaceBuilder, Routes, SocketHandle};
+use smoltcp::iface::{Config, Interface, SocketHandle, SocketSet};
 use smoltcp::phy::{Device, Medium, RxToken, TunTapInterface, TxToken};
-use smoltcp::socket::{TcpSocket, TcpSocketBuffer};
 use smoltcp::time::Instant;
 use smoltcp::wire::{IpAddress, IpCidr, Ipv4Address, Ipv4Packet, Ipv6Packet, TcpPacket, UdpPacket};
-use std::collections::{BTreeMap, HashMap};
+use std::collections::{HashMap};
 use std::convert::From;
 use std::io::{Read, Write};
 use std::net::Shutdown::Both;
 use std::net::{IpAddr, Shutdown, SocketAddr};
 use std::os::unix::io::AsRawFd;
+use smoltcp::socket::tcp;
 
 pub struct ProxyError {
     message: String,
@@ -101,7 +101,7 @@ fn get_transport_info(
 
 fn connection_tuple(frame: &[u8]) -> Option<(Connection, bool, usize, usize)> {
     if let Ok(packet) = Ipv4Packet::new_checked(frame) {
-        let proto: u8 = packet.protocol().into();
+        let proto: u8 = packet.next_header().into();
 
         let mut a: [u8; 4] = Default::default();
         a.copy_from_slice(packet.src_addr().as_bytes());
@@ -179,11 +179,13 @@ pub(crate) struct TunToProxy<'a> {
     poll: Poll,
     tun_token: Token,
     udp_token: Token,
-    iface: Interface<'a, VirtualTunDevice>,
+    iface: Interface,
     connections: HashMap<Connection, ConnectionState>,
     connection_managers: Vec<std::boxed::Box<dyn ConnectionManager>>,
     next_token: usize,
     token_to_connection: HashMap<Token, Connection>,
+    sockets: SocketSet<'a>,
+    device: VirtualTunDevice,
 }
 
 impl<'a> TunToProxy<'a> {
@@ -199,20 +201,14 @@ impl<'a> TunToProxy<'a> {
             )
             .unwrap();
 
-        let virt = VirtualTunDevice::new(tun.capabilities());
+        let config = Config::new();
-        let builder = InterfaceBuilder::new(virt, vec![]);
+        let mut virt = VirtualTunDevice::new(tun.capabilities());
-        let ip_addrs = [IpCidr::new(IpAddress::v4(0, 0, 0, 1), 0)];
+        let mut iface = Interface::new(config, &mut virt);
-
+        iface.update_ip_addrs(|ip_addrs| {
-        let mut routes = Routes::new(BTreeMap::new());
+            ip_addrs.push(IpCidr::new(IpAddress::v4(0, 0, 0, 1), 0)).unwrap()
-        routes
+        });
-            .add_default_ipv4_route(Ipv4Address::new(0, 0, 0, 1))
+        iface.routes_mut().add_default_ipv4_route(Ipv4Address::new(0, 0, 0, 1)).unwrap();
-            .unwrap();
+        iface.set_any_ip(true);
-
-        let iface = builder
-            .any_ip(true)
-            .ip_addrs(ip_addrs)
-            .routes(routes)
-            .finalize();
 
         Self {
             tun,
@@ -224,6 +220,8 @@ impl<'a> TunToProxy<'a> {
             next_token: 2,
             token_to_connection: Default::default(),
             connection_managers: Default::default(),
+            sockets: SocketSet::new([]),
+            device: virt,
         }
     }
 
@@ -232,20 +230,19 @@ impl<'a> TunToProxy<'a> {
     }
 
     fn expect_smoltcp_send(&mut self) {
-        self.iface.poll(Instant::now()).unwrap();
+        self.iface.poll(Instant::now(), &mut self.device, &mut self.sockets);
 
-        while let Some(vec) = self.iface.device_mut().exfiltrate_packet() {
+        while let Some(vec) = self.device.exfiltrate_packet() {
             let slice = vec.as_slice();
 
             // TODO: Actual write. Replace.
             self.tun
-                .transmit()
+                .transmit(Instant::now())
                 .unwrap()
-                .consume(Instant::now(), slice.len(), |buf| {
+                .consume(slice.len(), |buf| {
                     buf[..].clone_from_slice(slice);
-                    Ok(())
+                    ()
-                })
+                });
-                .unwrap();
         }
     }
 
@@ -275,7 +272,8 @@ impl<'a> TunToProxy<'a> {
     fn tunsocket_read_and_forward(&mut self, connection: &Connection) {
         if let Some(state) = self.connections.get_mut(connection) {
             let closed = {
-                let socket = self.iface.get_socket::<TcpSocket>(state.smoltcp_handle);
+                // let socket = self.iface.get_socket::<TcpSocket>(state.smoltcp_handle);
+                let socket = self.sockets.get_mut::<tcp::Socket>(state.smoltcp_handle);
                 let mut error = Ok(());
                 while socket.can_recv() && error.is_ok() {
                     socket
@@ -292,7 +290,7 @@ impl<'a> TunToProxy<'a> {
                 }
 
                 match error {
-                    Ok(_) => socket.state() == smoltcp::socket::TcpState::CloseWait,
+                    Ok(_) => socket.state() == smoltcp::socket::tcp::State::CloseWait,
                     Err(e) => {
                         Self::print_error(e);
                         true
@@ -324,13 +322,13 @@ impl<'a> TunToProxy<'a> {
                 if first_packet {
                     for manager in self.connection_managers.iter_mut() {
                         if let Some(handler) = manager.new_connection(&connection) {
-                            let mut socket = TcpSocket::new(
+                            let mut socket = smoltcp::socket::tcp::Socket::new(
-                                TcpSocketBuffer::new(vec![0; 4096]),
+                                smoltcp::socket::tcp::SocketBuffer::new(vec![0; 4096]),
-                                TcpSocketBuffer::new(vec![0; 4096]),
+                                smoltcp::socket::tcp::SocketBuffer::new(vec![0; 4096]),
                             );
                             socket.set_ack_delay(None);
                             socket.listen(connection.dst).unwrap();
-                            let handle = self.iface.add_socket(socket);
+                            let handle = self.sockets.add(socket);
 
                             let client = TcpStream::connect(server).unwrap();
 
@@ -365,7 +363,7 @@ impl<'a> TunToProxy<'a> {
                 }
 
                 // Inject the packet to advance the smoltcp socket state
-                self.iface.device_mut().inject_packet(frame);
+                self.device.inject_packet(frame);
 
                 // Having advanced the socket state, we expect the socket to ACK
                 // Exfiltrate the response packets generated by the socket and inject them
@@ -415,7 +413,7 @@ impl<'a> TunToProxy<'a> {
     fn write_to_client(&mut self, connection: &Connection) {
         if let Some(state) = self.connections.get_mut(connection) {
             let event = state.handler.peek_data(OutgoingDirection::ToClient);
-            let socket = &mut self.iface.get_socket::<TcpSocket>(state.smoltcp_handle);
+            let socket = self.sockets.get_mut::<tcp::Socket>(state.smoltcp_handle);
             if socket.may_send() {
                 let consumed = socket.send_slice(event.buffer).unwrap();
                 state
@@ -427,13 +425,11 @@ impl<'a> TunToProxy<'a> {
 
     fn tun_event(&mut self, event: &Event) {
         if event.is_readable() {
-            while let Some((rx_token, _)) = self.tun.receive() {
+            while let Some((rx_token, _)) = self.tun.receive(Instant::now()) {
-                if let Err(err) = rx_token.consume(Instant::now(), |frame| {
+                rx_token.consume(|frame| {
                     self.receive_tun(frame);
-                    Ok(())
+                    ()
-                }) {
+                });
-                    panic!("Error: {}", err);
-                }
             }
         }
     }
@@ -456,7 +452,7 @@ impl<'a> TunToProxy<'a> {
 
                     if read == 0 {
                         {
-                            let socket = self.iface.get_socket::<TcpSocket>(
+                            let socket = self.sockets.get_mut::<tcp::Socket>(
                                 self.connections.get(&connection).unwrap().smoltcp_handle,
                             );
                             socket.close();
@@ -473,7 +469,7 @@ impl<'a> TunToProxy<'a> {
                     if let Err(error) = state.handler.push_data(event) {
                         state.mio_stream.shutdown(Both).unwrap();
                         {
-                            let socket = self.iface.get_socket::<TcpSocket>(
+                            let socket = self.sockets.get_mut::<tcp::Socket>(
                                 self.connections.get(&connection).unwrap().smoltcp_handle,
                             );
                             socket.close();

src/virtdevice.rs

@@ -6,7 +6,7 @@ use smoltcp::time::Instant;
 pub struct VirtualTunDevice {
     capabilities: DeviceCapabilities,
     inbuf: Vec<Vec<u8>>,
-    outbuf: Vec<Vec<u8>>,
+    outbuf: Vec<Vec<u8>>
 }
 
 impl VirtualTunDevice {
@@ -24,10 +24,10 @@ pub struct VirtRxToken {
     buffer: Vec<u8>,
 }
 
-impl phy::RxToken for VirtRxToken {
+impl<'a> phy::RxToken for VirtRxToken {
-    fn consume<R, F>(mut self, _timestamp: Instant, f: F) -> smoltcp::Result<R>
+    fn consume<R, F>(mut self, f: F) -> R
     where
-        F: FnOnce(&mut [u8]) -> smoltcp::Result<R>,
+        F: FnOnce(&mut [u8]) -> R,
     {
         f(&mut self.buffer[..])
     }
@@ -36,9 +36,9 @@ impl phy::RxToken for VirtRxToken {
 pub struct VirtTxToken<'a>(&'a mut VirtualTunDevice);
 
 impl<'a> phy::TxToken for VirtTxToken<'a> {
-    fn consume<R, F>(self, _timestamp: Instant, len: usize, f: F) -> smoltcp::Result<R>
+    fn consume<R, F>(self, len: usize, f: F) -> R
     where
-        F: FnOnce(&mut [u8]) -> smoltcp::Result<R>,
+        F: FnOnce(&mut [u8]) -> R,
     {
         let mut buffer = vec![0; len];
         let result = f(&mut buffer);
@@ -47,11 +47,11 @@ impl<'a> phy::TxToken for VirtTxToken<'a> {
     }
 }
 
-impl<'a> Device<'a> for VirtualTunDevice {
+impl Device for VirtualTunDevice {
-    type RxToken = VirtRxToken;
+    type RxToken<'a> = VirtRxToken;
-    type TxToken = VirtTxToken<'a>;
+    type TxToken<'a> = VirtTxToken<'a>;
 
-    fn receive(&'a mut self) -> Option<(Self::RxToken, Self::TxToken)> {
+    fn receive(&mut self,  _timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
         if let Some(buffer) = self.inbuf.pop() {
             let rx = Self::RxToken { buffer };
             let tx = VirtTxToken(self);
@@ -60,7 +60,7 @@ impl<'a> Device<'a> for VirtualTunDevice {
         None
     }
 
-    fn transmit(&'a mut self) -> Option<Self::TxToken> {
+    fn transmit(&mut self,  _timestamp: Instant) -> Option<Self::TxToken<'_>> {
         return Some(VirtTxToken(self));
     }
 
@@ -69,7 +69,7 @@ impl<'a> Device<'a> for VirtualTunDevice {
     }
 }
 
-impl VirtualTunDevice {
+impl<'a> VirtualTunDevice {
     pub fn new(capabilities: DeviceCapabilities) -> Self {
         Self {
             capabilities,