Merge pull request #1821 from embassy-rs/net-ppp

Add embassy-net-ppp driver.

embassy-net-driver-channel/src/lib.rs

@@ -8,6 +8,7 @@ use core::cell::RefCell;
 use core::mem::MaybeUninit;
 use core::task::{Context, Poll};
 
+use driver::HardwareAddress;
 pub use embassy_net_driver as driver;
 use embassy_net_driver::{Capabilities, LinkState, Medium};
 use embassy_sync::blocking_mutex::raw::NoopRawMutex;
@@ -73,6 +74,18 @@ impl<'d, const MTU: usize> Runner<'d, MTU> {
         )
     }
 
+    pub fn borrow_split(&mut self) -> (StateRunner<'_>, RxRunner<'_, MTU>, TxRunner<'_, MTU>) {
+        (
+            StateRunner { shared: self.shared },
+            RxRunner {
+                rx_chan: self.rx_chan.borrow(),
+            },
+            TxRunner {
+                tx_chan: self.tx_chan.borrow(),
+            },
+        )
+    }
+
     pub fn state_runner(&self) -> StateRunner<'d> {
         StateRunner { shared: self.shared }
     }
@@ -218,7 +231,11 @@ pub fn new<'d, const MTU: usize, const N_RX: usize, const N_TX: usize>(
 ) -> (Runner<'d, MTU>, Device<'d, MTU>) {
     let mut caps = Capabilities::default();
     caps.max_transmission_unit = MTU;
-    caps.medium = Medium::Ethernet;
+    caps.medium = match &hardware_address {
+        HardwareAddress::Ethernet(_) => Medium::Ethernet,
+        HardwareAddress::Ieee802154(_) => Medium::Ieee802154,
+        HardwareAddress::Ip => Medium::Ip,
+    };
 
     // safety: this is a self-referential struct, however:
     // - it can't move while the `'d` borrow is active.

embassy-net-ppp/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "embassy-net-ppp"
+version = "0.1.0"
+description = "embassy-net driver for PPP over Serial"
+keywords = ["embedded", "ppp", "embassy-net", "embedded-hal-async", "ethernet", "async"]
+categories = ["embedded", "hardware-support", "no-std", "network-programming", "async"]
+license = "MIT OR Apache-2.0"
+edition = "2021"
+
+[features]
+defmt = ["dep:defmt", "ppproto/defmt"]
+log = ["dep:log", "ppproto/log"]
+
+[dependencies]
+defmt = { version = "0.3", optional = true }
+log = { version = "0.4.14", optional = true }
+
+embedded-io-async = { version = "0.5.0" }
+embassy-net-driver-channel = { version = "0.1.0", path = "../embassy-net-driver-channel" }
+embassy-futures = { version = "0.1.0", path = "../embassy-futures" }
+ppproto = { version = "0.1.1"}
+embassy-sync = { version = "0.2.0", path = "../embassy-sync" }
+
+[package.metadata.embassy_docs]
+src_base = "https://github.com/embassy-rs/embassy/blob/embassy-net-ppp-v$VERSION/embassy-net-ppp/src/"
+src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-net-ppp/src/"
+target = "thumbv7em-none-eabi"
+features = ["defmt"]

embassy-net-ppp/README.md

@@ -0,0 +1,19 @@
+# `embassy-net-ppp`
+
+[`embassy-net`](https://crates.io/crates/embassy-net) integration for PPP over Serial.
+
+## Interoperability
+
+This crate can run on any executor.
+
+It supports any serial port implementing [`embedded-io-async`](https://crates.io/crates/embedded-io-async).
+
+## License
+
+This work is licensed under either of
+
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or
+  http://www.apache.org/licenses/LICENSE-2.0)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.

embassy-net-ppp/src/fmt.rs

@@ -0,0 +1,257 @@
+#![macro_use]
+#![allow(unused_macros)]
+
+use core::fmt::{Debug, Display, LowerHex};
+
+#[cfg(all(feature = "defmt", feature = "log"))]
+compile_error!("You may not enable both `defmt` and `log` features.");
+
+macro_rules! assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::debug_assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::debug_assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::debug_assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::debug_assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::debug_assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::debug_assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! todo {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::todo!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::todo!($($x)*);
+        }
+    };
+}
+
+#[cfg(not(feature = "defmt"))]
+macro_rules! unreachable {
+    ($($x:tt)*) => {
+        ::core::unreachable!($($x)*)
+    };
+}
+
+#[cfg(feature = "defmt")]
+macro_rules! unreachable {
+    ($($x:tt)*) => {
+        ::defmt::unreachable!($($x)*);
+    };
+}
+
+macro_rules! panic {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::panic!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::panic!($($x)*);
+        }
+    };
+}
+
+macro_rules! trace {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            #[cfg(feature = "log")]
+            ::log::trace!($s $(, $x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::trace!($s $(, $x)*);
+            #[cfg(not(any(feature = "log", feature="defmt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+macro_rules! debug {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            #[cfg(feature = "log")]
+            ::log::debug!($s $(, $x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::debug!($s $(, $x)*);
+            #[cfg(not(any(feature = "log", feature="defmt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+macro_rules! info {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            #[cfg(feature = "log")]
+            ::log::info!($s $(, $x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::info!($s $(, $x)*);
+            #[cfg(not(any(feature = "log", feature="defmt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+macro_rules! warn {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            #[cfg(feature = "log")]
+            ::log::warn!($s $(, $x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::warn!($s $(, $x)*);
+            #[cfg(not(any(feature = "log", feature="defmt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+macro_rules! error {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            #[cfg(feature = "log")]
+            ::log::error!($s $(, $x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::error!($s $(, $x)*);
+            #[cfg(not(any(feature = "log", feature="defmt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+#[cfg(feature = "defmt")]
+macro_rules! unwrap {
+    ($($x:tt)*) => {
+        ::defmt::unwrap!($($x)*)
+    };
+}
+
+#[cfg(not(feature = "defmt"))]
+macro_rules! unwrap {
+    ($arg:expr) => {
+        match $crate::fmt::Try::into_result($arg) {
+            ::core::result::Result::Ok(t) => t,
+            ::core::result::Result::Err(e) => {
+                ::core::panic!("unwrap of `{}` failed: {:?}", ::core::stringify!($arg), e);
+            }
+        }
+    };
+    ($arg:expr, $($msg:expr),+ $(,)? ) => {
+        match $crate::fmt::Try::into_result($arg) {
+            ::core::result::Result::Ok(t) => t,
+            ::core::result::Result::Err(e) => {
+                ::core::panic!("unwrap of `{}` failed: {}: {:?}", ::core::stringify!($arg), ::core::format_args!($($msg,)*), e);
+            }
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub struct NoneError;
+
+pub trait Try {
+    type Ok;
+    type Error;
+    fn into_result(self) -> Result<Self::Ok, Self::Error>;
+}
+
+impl<T> Try for Option<T> {
+    type Ok = T;
+    type Error = NoneError;
+
+    #[inline]
+    fn into_result(self) -> Result<T, NoneError> {
+        self.ok_or(NoneError)
+    }
+}
+
+impl<T, E> Try for Result<T, E> {
+    type Ok = T;
+    type Error = E;
+
+    #[inline]
+    fn into_result(self) -> Self {
+        self
+    }
+}
+
+pub struct Bytes<'a>(pub &'a [u8]);
+
+impl<'a> Debug for Bytes<'a> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{:#02x?}", self.0)
+    }
+}
+
+impl<'a> Display for Bytes<'a> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{:#02x?}", self.0)
+    }
+}
+
+impl<'a> LowerHex for Bytes<'a> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{:#02x?}", self.0)
+    }
+}
+
+#[cfg(feature = "defmt")]
+impl<'a> defmt::Format for Bytes<'a> {
+    fn format(&self, fmt: defmt::Formatter) {
+        defmt::write!(fmt, "{:02x}", self.0)
+    }
+}

embassy-net-ppp/src/lib.rs

@@ -0,0 +1,180 @@
+#![no_std]
+#![warn(missing_docs)]
+#![doc = include_str!("../README.md")]
+
+// must be first
+mod fmt;
+
+use core::convert::Infallible;
+use core::mem::MaybeUninit;
+
+use embassy_futures::select::{select, Either};
+use embassy_net_driver_channel as ch;
+use embassy_net_driver_channel::driver::LinkState;
+use embedded_io_async::{BufRead, Write, WriteAllError};
+use ppproto::pppos::{BufferFullError, PPPoS, PPPoSAction};
+pub use ppproto::{Config, Ipv4Status};
+
+const MTU: usize = 1500;
+
+/// Type alias for the embassy-net driver.
+pub type Device<'d> = embassy_net_driver_channel::Device<'d, MTU>;
+
+/// Internal state for the embassy-net integration.
+pub struct State<const N_RX: usize, const N_TX: usize> {
+    ch_state: ch::State<MTU, N_RX, N_TX>,
+}
+
+impl<const N_RX: usize, const N_TX: usize> State<N_RX, N_TX> {
+    /// Create a new `State`.
+    pub const fn new() -> Self {
+        Self {
+            ch_state: ch::State::new(),
+        }
+    }
+}
+
+/// Background runner for the driver.
+///
+/// You must call `.run()` in a background task for the driver to operate.
+pub struct Runner<'d> {
+    ch: ch::Runner<'d, MTU>,
+}
+
+/// Error returned by [`Runner::run`].
+#[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum RunError<E> {
+    /// Reading from the serial port failed.
+    Read(E),
+    /// Writing to the serial port failed.
+    Write(E),
+    /// Writing to the serial port wrote zero bytes, indicating it can't accept more data.
+    WriteZero,
+    /// Writing to the serial got EOF.
+    Eof,
+}
+
+impl<E> From<WriteAllError<E>> for RunError<E> {
+    fn from(value: WriteAllError<E>) -> Self {
+        match value {
+            WriteAllError::Other(e) => Self::Write(e),
+            WriteAllError::WriteZero => Self::WriteZero,
+        }
+    }
+}
+
+impl<'d> Runner<'d> {
+    /// You must call this in a background task for the driver to operate.
+    ///
+    /// If reading/writing to the underlying serial port fails, the link state
+    /// is set to Down and the error is returned.
+    ///
+    /// It is allowed to cancel this function's future (i.e. drop it). This will terminate
+    /// the PPP connection and set the link state to Down.
+    ///
+    /// After this function returns or is canceled, you can call it again to establish
+    /// a new PPP connection.
+    pub async fn run<RW: BufRead + Write>(
+        &mut self,
+        mut rw: RW,
+        config: ppproto::Config<'_>,
+        mut on_ipv4_up: impl FnMut(Ipv4Status),
+    ) -> Result<Infallible, RunError<RW::Error>> {
+        let mut ppp = PPPoS::new(config);
+        ppp.open().unwrap();
+
+        let (state_chan, mut rx_chan, mut tx_chan) = self.ch.borrow_split();
+        state_chan.set_link_state(LinkState::Down);
+        let _ondrop = OnDrop::new(|| state_chan.set_link_state(LinkState::Down));
+
+        let mut rx_buf = [0; 2048];
+        let mut tx_buf = [0; 2048];
+
+        let mut needs_poll = true;
+        let mut was_up = false;
+
+        loop {
+            let rx_fut = async {
+                let buf = rx_chan.rx_buf().await;
+                let rx_data = match needs_poll {
+                    true => &[][..],
+                    false => match rw.fill_buf().await {
+                        Ok(rx_data) if rx_data.len() == 0 => return Err(RunError::Eof),
+                        Ok(rx_data) => rx_data,
+                        Err(e) => return Err(RunError::Read(e)),
+                    },
+                };
+                Ok((buf, rx_data))
+            };
+            let tx_fut = tx_chan.tx_buf();
+            match select(rx_fut, tx_fut).await {
+                Either::First(r) => {
+                    needs_poll = false;
+
+                    let (buf, rx_data) = r?;
+                    let n = ppp.consume(rx_data, &mut rx_buf);
+                    rw.consume(n);
+
+                    match ppp.poll(&mut tx_buf, &mut rx_buf) {
+                        PPPoSAction::None => {}
+                        PPPoSAction::Received(rg) => {
+                            let pkt = &rx_buf[rg];
+                            buf[..pkt.len()].copy_from_slice(pkt);
+                            rx_chan.rx_done(pkt.len());
+                        }
+                        PPPoSAction::Transmit(n) => rw.write_all(&tx_buf[..n]).await?,
+                    }
+
+                    let status = ppp.status();
+                    match status.phase {
+                        ppproto::Phase::Open => {
+                            if !was_up {
+                                on_ipv4_up(status.ipv4.unwrap());
+                            }
+                            was_up = true;
+                            state_chan.set_link_state(LinkState::Up);
+                        }
+                        _ => {
+                            was_up = false;
+                            state_chan.set_link_state(LinkState::Down);
+                        }
+                    }
+                }
+                Either::Second(pkt) => {
+                    match ppp.send(pkt, &mut tx_buf) {
+                        Ok(n) => rw.write_all(&tx_buf[..n]).await?,
+                        Err(BufferFullError) => unreachable!(),
+                    }
+                    tx_chan.tx_done();
+                }
+            }
+        }
+    }
+}
+
+/// Create a PPP embassy-net driver instance.
+///
+/// This returns two structs:
+/// - a `Device` that you must pass to the `embassy-net` stack.
+/// - a `Runner`. You must call `.run()` on it in a background task.
+pub fn new<'a, const N_RX: usize, const N_TX: usize>(state: &'a mut State<N_RX, N_TX>) -> (Device<'a>, Runner<'a>) {
+    let (runner, device) = ch::new(&mut state.ch_state, ch::driver::HardwareAddress::Ip);
+    (device, Runner { ch: runner })
+}
+
+struct OnDrop<F: FnOnce()> {
+    f: MaybeUninit<F>,
+}
+
+impl<F: FnOnce()> OnDrop<F> {
+    fn new(f: F) -> Self {
+        Self { f: MaybeUninit::new(f) }
+    }
+}
+
+impl<F: FnOnce()> Drop for OnDrop<F> {
+    fn drop(&mut self) {
+        unsafe { self.f.as_ptr().read()() }
+    }
+}

embassy-net/Cargo.toml

@@ -9,6 +9,7 @@ categories = [
     "embedded",
     "no-std",
     "asynchronous",
+    "network-programming",
 ]
 
 [package.metadata.embassy_docs]

embassy-net/src/lib.rs

@@ -249,7 +249,10 @@ fn to_smoltcp_hardware_address(addr: driver::HardwareAddress) -> HardwareAddress
         driver::HardwareAddress::Ip => HardwareAddress::Ip,
 
         #[allow(unreachable_patterns)]
-        _ => panic!("Unsupported address {:?}. Make sure to enable medium-ethernet or medium-ieee802154 in embassy-net's Cargo features.", addr),
+        _ => panic!(
+            "Unsupported medium {:?}. Make sure to enable the right medium feature in embassy-net's Cargo features.",
+            addr
+        ),
     }
 }
 

examples/std/Cargo.toml

@@ -8,11 +8,13 @@ license = "MIT OR Apache-2.0"
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["log"] }
 embassy-executor = { version = "0.3.0", path = "../../embassy-executor", features = ["arch-std", "executor-thread", "log", "nightly", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["log", "std", "nightly"] }
-embassy-net = { version = "0.1.0", path = "../../embassy-net", features=[ "std", "nightly", "log", "medium-ethernet", "tcp", "udp", "dns", "dhcpv4", "proto-ipv6"] }
+embassy-net = { version = "0.1.0", path = "../../embassy-net", features=[ "std", "nightly", "log", "medium-ethernet", "medium-ip", "tcp", "udp", "dns", "dhcpv4", "proto-ipv6"] }
 embassy-net-tuntap = { version = "0.1.0", path = "../../embassy-net-tuntap" }
+embassy-net-ppp = { version = "0.1.0", path = "../../embassy-net-ppp", features = ["log"]}
 embedded-io-async = { version = "0.5.0" }
 embedded-io-adapters = { version = "0.5.0", features = ["futures-03"] }
 critical-section = { version = "1.1", features = ["std"] }
+smoltcp = { version = "0.10.0", features = ["dns-max-server-count-4"] }
 
 async-io = "1.6.0"
 env_logger = "0.9.0"

examples/std/src/bin/net_ppp.rs

@@ -0,0 +1,218 @@
+//! Testing against pppd:
+//!
+//!     echo myuser $(hostname) mypass 192.168.7.10 >> /etc/ppp/pap-secrets
+//!     socat -v -x PTY,link=pty1,rawer PTY,link=pty2,rawer
+//!     sudo pppd $PWD/pty1 115200 192.168.7.1: ms-dns 8.8.4.4 ms-dns 8.8.8.8 nodetach debug local persist silent noproxyarp
+//!     RUST_LOG=trace cargo run --bin net_ppp -- --device pty2
+//!     ping 192.168.7.10
+//!     nc 192.168.7.10 1234
+
+#![feature(type_alias_impl_trait)]
+#![feature(async_fn_in_trait, impl_trait_projections)]
+
+#[path = "../serial_port.rs"]
+mod serial_port;
+
+use async_io::Async;
+use clap::Parser;
+use embassy_executor::{Executor, Spawner};
+use embassy_net::tcp::TcpSocket;
+use embassy_net::{Config, ConfigV4, Ipv4Address, Ipv4Cidr, Stack, StackResources};
+use embassy_net_ppp::Runner;
+use embedded_io_async::Write;
+use futures::io::BufReader;
+use heapless::Vec;
+use log::*;
+use nix::sys::termios;
+use rand_core::{OsRng, RngCore};
+use static_cell::{make_static, StaticCell};
+
+use crate::serial_port::SerialPort;
+
+#[derive(Parser)]
+#[clap(version = "1.0")]
+struct Opts {
+    /// Serial port device name
+    #[clap(short, long)]
+    device: String,
+}
+
+#[embassy_executor::task]
+async fn net_task(stack: &'static Stack<embassy_net_ppp::Device<'static>>) -> ! {
+    stack.run().await
+}
+
+#[embassy_executor::task]
+async fn ppp_task(
+    stack: &'static Stack<embassy_net_ppp::Device<'static>>,
+    mut runner: Runner<'static>,
+    port: SerialPort,
+) -> ! {
+    let port = Async::new(port).unwrap();
+    let port = BufReader::new(port);
+    let port = adapter::FromFutures::new(port);
+
+    let config = embassy_net_ppp::Config {
+        username: b"myuser",
+        password: b"mypass",
+    };
+
+    runner
+        .run(port, config, |ipv4| {
+            let Some(addr) = ipv4.address else {
+                warn!("PPP did not provide an IP address.");
+                return;
+            };
+            let mut dns_servers = Vec::new();
+            for s in ipv4.dns_servers.iter().flatten() {
+                let _ = dns_servers.push(Ipv4Address::from_bytes(&s.0));
+            }
+            let config = ConfigV4::Static(embassy_net::StaticConfigV4 {
+                address: Ipv4Cidr::new(Ipv4Address::from_bytes(&addr.0), 0),
+                gateway: None,
+                dns_servers,
+            });
+            stack.set_config_v4(config);
+        })
+        .await
+        .unwrap();
+    unreachable!()
+}
+
+#[embassy_executor::task]
+async fn main_task(spawner: Spawner) {
+    let opts: Opts = Opts::parse();
+
+    // Open serial port
+    let baudrate = termios::BaudRate::B115200;
+    let port = SerialPort::new(opts.device.as_str(), baudrate).unwrap();
+
+    // Init network device
+    let state = make_static!(embassy_net_ppp::State::<4, 4>::new());
+    let (device, runner) = embassy_net_ppp::new(state);
+
+    // Generate random seed
+    let mut seed = [0; 8];
+    OsRng.fill_bytes(&mut seed);
+    let seed = u64::from_le_bytes(seed);
+
+    // Init network stack
+    let stack = &*make_static!(Stack::new(
+        device,
+        Config::default(), // don't configure IP yet
+        make_static!(StackResources::<3>::new()),
+        seed
+    ));
+
+    // Launch network task
+    spawner.spawn(net_task(stack)).unwrap();
+    spawner.spawn(ppp_task(stack, runner, port)).unwrap();
+
+    // Then we can use it!
+    let mut rx_buffer = [0; 4096];
+    let mut tx_buffer = [0; 4096];
+    let mut buf = [0; 4096];
+
+    loop {
+        let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
+        socket.set_timeout(Some(embassy_time::Duration::from_secs(10)));
+
+        info!("Listening on TCP:1234...");
+        if let Err(e) = socket.accept(1234).await {
+            warn!("accept error: {:?}", e);
+            continue;
+        }
+
+        info!("Received connection from {:?}", socket.remote_endpoint());
+
+        loop {
+            let n = match socket.read(&mut buf).await {
+                Ok(0) => {
+                    warn!("read EOF");
+                    break;
+                }
+                Ok(n) => n,
+                Err(e) => {
+                    warn!("read error: {:?}", e);
+                    break;
+                }
+            };
+
+            info!("rxd {:02x?}", &buf[..n]);
+
+            match socket.write_all(&buf[..n]).await {
+                Ok(()) => {}
+                Err(e) => {
+                    warn!("write error: {:?}", e);
+                    break;
+                }
+            };
+        }
+    }
+}
+
+static EXECUTOR: StaticCell<Executor> = StaticCell::new();
+
+fn main() {
+    env_logger::builder()
+        .filter_level(log::LevelFilter::Trace)
+        .filter_module("polling", log::LevelFilter::Info)
+        .filter_module("async_io", log::LevelFilter::Info)
+        .format_timestamp_nanos()
+        .init();
+
+    let executor = EXECUTOR.init(Executor::new());
+    executor.run(|spawner| {
+        spawner.spawn(main_task(spawner)).unwrap();
+    });
+}
+
+mod adapter {
+    use core::future::poll_fn;
+    use core::pin::Pin;
+
+    use futures::AsyncBufReadExt;
+
+    /// Adapter from `futures::io` traits.
+    #[derive(Clone)]
+    pub struct FromFutures<T: ?Sized> {
+        inner: T,
+    }
+
+    impl<T> FromFutures<T> {
+        /// Create a new adapter.
+        pub fn new(inner: T) -> Self {
+            Self { inner }
+        }
+    }
+
+    impl<T: ?Sized> embedded_io_async::ErrorType for FromFutures<T> {
+        type Error = std::io::Error;
+    }
+
+    impl<T: futures::io::AsyncRead + Unpin + ?Sized> embedded_io_async::Read for FromFutures<T> {
+        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+            poll_fn(|cx| Pin::new(&mut self.inner).poll_read(cx, buf)).await
+        }
+    }
+
+    impl<T: futures::io::AsyncBufRead + Unpin + ?Sized> embedded_io_async::BufRead for FromFutures<T> {
+        async fn fill_buf(&mut self) -> Result<&[u8], Self::Error> {
+            self.inner.fill_buf().await
+        }
+
+        fn consume(&mut self, amt: usize) {
+            Pin::new(&mut self.inner).consume(amt)
+        }
+    }
+
+    impl<T: futures::io::AsyncWrite + Unpin + ?Sized> embedded_io_async::Write for FromFutures<T> {
+        async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+            poll_fn(|cx| Pin::new(&mut self.inner).poll_write(cx, buf)).await
+        }
+
+        async fn flush(&mut self) -> Result<(), Self::Error> {
+            poll_fn(|cx| Pin::new(&mut self.inner).poll_flush(cx)).await
+        }
+    }
+}