| #![cfg_attr(not(feature = "std"), no_std)] |
| #![allow(unused_mut)] |
| #![allow(clippy::collapsible_if)] |
| |
| #[cfg(feature = "std")] |
| #[allow(dead_code)] |
| mod utils; |
| |
| use core::str; |
| use log::{debug, error, info}; |
| |
| use smoltcp::iface::{Config, Interface, SocketSet}; |
| use smoltcp::phy::{Device, Loopback, Medium}; |
| use smoltcp::socket::tcp; |
| use smoltcp::time::{Duration, Instant}; |
| use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr}; |
| |
| #[cfg(not(feature = "std"))] |
| mod mock { |
| use core::cell::Cell; |
| use smoltcp::time::{Duration, Instant}; |
| |
| #[derive(Debug)] |
| #[cfg_attr(feature = "defmt", derive(defmt::Format))] |
| pub struct Clock(Cell<Instant>); |
| |
| impl Clock { |
| pub fn new() -> Clock { |
| Clock(Cell::new(Instant::from_millis(0))) |
| } |
| |
| pub fn advance(&self, duration: Duration) { |
| self.0.set(self.0.get() + duration) |
| } |
| |
| pub fn elapsed(&self) -> Instant { |
| self.0.get() |
| } |
| } |
| } |
| |
| #[cfg(feature = "std")] |
| mod mock { |
| use smoltcp::time::{Duration, Instant}; |
| use std::sync::atomic::{AtomicUsize, Ordering}; |
| use std::sync::Arc; |
| |
| // should be AtomicU64 but that's unstable |
| #[derive(Debug, Clone)] |
| #[cfg_attr(feature = "defmt", derive(defmt::Format))] |
| pub struct Clock(Arc<AtomicUsize>); |
| |
| impl Clock { |
| pub fn new() -> Clock { |
| Clock(Arc::new(AtomicUsize::new(0))) |
| } |
| |
| pub fn advance(&self, duration: Duration) { |
| self.0 |
| .fetch_add(duration.total_millis() as usize, Ordering::SeqCst); |
| } |
| |
| pub fn elapsed(&self) -> Instant { |
| Instant::from_millis(self.0.load(Ordering::SeqCst) as i64) |
| } |
| } |
| } |
| |
| fn main() { |
| let clock = mock::Clock::new(); |
| let device = Loopback::new(Medium::Ethernet); |
| |
| #[cfg(feature = "std")] |
| let mut device = { |
| let clock = clock.clone(); |
| utils::setup_logging_with_clock("", move || clock.elapsed()); |
| |
| let (mut opts, mut free) = utils::create_options(); |
| utils::add_middleware_options(&mut opts, &mut free); |
| |
| let mut matches = utils::parse_options(&opts, free); |
| utils::parse_middleware_options(&mut matches, device, /*loopback=*/ true) |
| }; |
| |
| // Create interface |
| let mut config = match device.capabilities().medium { |
| Medium::Ethernet => { |
| Config::new(EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]).into()) |
| } |
| Medium::Ip => Config::new(smoltcp::wire::HardwareAddress::Ip), |
| Medium::Ieee802154 => todo!(), |
| }; |
| |
| let mut iface = Interface::new(config, &mut device, Instant::now()); |
| iface.update_ip_addrs(|ip_addrs| { |
| ip_addrs |
| .push(IpCidr::new(IpAddress::v4(127, 0, 0, 1), 8)) |
| .unwrap(); |
| }); |
| |
| // Create sockets |
| let server_socket = { |
| // It is not strictly necessary to use a `static mut` and unsafe code here, but |
| // on embedded systems that smoltcp targets it is far better to allocate the data |
| // statically to verify that it fits into RAM rather than get undefined behavior |
| // when stack overflows. |
| static mut TCP_SERVER_RX_DATA: [u8; 1024] = [0; 1024]; |
| static mut TCP_SERVER_TX_DATA: [u8; 1024] = [0; 1024]; |
| let tcp_rx_buffer = tcp::SocketBuffer::new(unsafe { &mut TCP_SERVER_RX_DATA[..] }); |
| let tcp_tx_buffer = tcp::SocketBuffer::new(unsafe { &mut TCP_SERVER_TX_DATA[..] }); |
| tcp::Socket::new(tcp_rx_buffer, tcp_tx_buffer) |
| }; |
| |
| let client_socket = { |
| static mut TCP_CLIENT_RX_DATA: [u8; 1024] = [0; 1024]; |
| static mut TCP_CLIENT_TX_DATA: [u8; 1024] = [0; 1024]; |
| let tcp_rx_buffer = tcp::SocketBuffer::new(unsafe { &mut TCP_CLIENT_RX_DATA[..] }); |
| let tcp_tx_buffer = tcp::SocketBuffer::new(unsafe { &mut TCP_CLIENT_TX_DATA[..] }); |
| tcp::Socket::new(tcp_rx_buffer, tcp_tx_buffer) |
| }; |
| |
| let mut sockets: [_; 2] = Default::default(); |
| let mut sockets = SocketSet::new(&mut sockets[..]); |
| let server_handle = sockets.add(server_socket); |
| let client_handle = sockets.add(client_socket); |
| |
| let mut did_listen = false; |
| let mut did_connect = false; |
| let mut done = false; |
| while !done && clock.elapsed() < Instant::from_millis(10_000) { |
| iface.poll(clock.elapsed(), &mut device, &mut sockets); |
| |
| let mut socket = sockets.get_mut::<tcp::Socket>(server_handle); |
| if !socket.is_active() && !socket.is_listening() { |
| if !did_listen { |
| debug!("listening"); |
| socket.listen(1234).unwrap(); |
| did_listen = true; |
| } |
| } |
| |
| if socket.can_recv() { |
| debug!( |
| "got {:?}", |
| socket.recv(|buffer| { (buffer.len(), str::from_utf8(buffer).unwrap()) }) |
| ); |
| socket.close(); |
| done = true; |
| } |
| |
| let mut socket = sockets.get_mut::<tcp::Socket>(client_handle); |
| let cx = iface.context(); |
| if !socket.is_open() { |
| if !did_connect { |
| debug!("connecting"); |
| socket |
| .connect(cx, (IpAddress::v4(127, 0, 0, 1), 1234), 65000) |
| .unwrap(); |
| did_connect = true; |
| } |
| } |
| |
| if socket.can_send() { |
| debug!("sending"); |
| socket.send_slice(b"0123456789abcdef").unwrap(); |
| socket.close(); |
| } |
| |
| match iface.poll_delay(clock.elapsed(), &sockets) { |
| Some(Duration::ZERO) => debug!("resuming"), |
| Some(delay) => { |
| debug!("sleeping for {} ms", delay); |
| clock.advance(delay) |
| } |
| None => clock.advance(Duration::from_millis(1)), |
| } |
| } |
| |
| if done { |
| info!("done") |
| } else { |
| error!("this is taking too long, bailing out") |
| } |
| } |