UDP stack based on embassy-net

Author: ivmarkov

Cargo.toml

@@ -5,7 +5,6 @@ exclude = ["examples/*"]
 
 # For compatibility with ESP IDF
 [patch.crates-io]
-smol = { git = "https://github.com/esp-rs-compat/smol" }
 polling = { git = "https://github.com/esp-rs-compat/polling" }
 socket2 = { git = "https://github.com/esp-rs-compat/socket2" }
 

examples/onoff_light/src/main.rs

@@ -18,7 +18,6 @@
 use core::borrow::Borrow;
 use core::pin::pin;
 
-use embassy_futures::select::select3;
 use log::info;
 use matter::core::{CommissioningData, Matter};
 use matter::data_model::cluster_basic_information::BasicInfoConfig;
@@ -28,13 +27,11 @@ use matter::data_model::objects::*;
 use matter::data_model::root_endpoint;
 use matter::data_model::system_model::descriptor;
 use matter::error::Error;
-use matter::mdns::{DefaultMdns, DefaultMdnsRunner};
+use matter::mdns::MdnsService;
 use matter::persist::FilePsm;
 use matter::secure_channel::spake2p::VerifierData;
 use matter::transport::network::{Ipv4Addr, Ipv6Addr, NetworkStack};
-use matter::transport::runner::{RxBuf, TransportRunner, TxBuf};
-use matter::transport::udp::UdpBuffers;
-use matter::utils::select::EitherUnwrap;
+use matter::transport::runner::{AllUdpBuffers, TransportRunner};
 
 mod dev_att;
 
@@ -59,10 +56,11 @@ fn run() -> Result<(), Error> {
     initialize_logger();
 
     info!(
-        "Matter memory: mDNS={}, Matter={}, TransportRunner={}",
-        core::mem::size_of::<DefaultMdns>(),
+        "Matter memory: mDNS={}, Matter={}, TransportRunner={}, UdpBuffers={}",
+        core::mem::size_of::<MdnsService>(),
         core::mem::size_of::<Matter>(),
         core::mem::size_of::<TransportRunner>(),
+        core::mem::size_of::<AllUdpBuffers>(),
     );
 
     let dev_det = BasicInfoConfig {
@@ -83,20 +81,6 @@ fn run() -> Result<(), Error> {
 
     let (ipv4_addr, ipv6_addr, interface) = initialize_network()?;
 
-    let mdns = DefaultMdns::new(
-        0,
-        "matter-demo",
-        ipv4_addr.octets(),
-        Some(ipv6_addr.octets()),
-        interface,
-        &dev_det,
-        matter::MATTER_PORT,
-    );
-
-    let mut mdns_runner = DefaultMdnsRunner::new(&mdns);
-
-    info!("mDNS initialized: {:p}, {:p}", &mdns, &mdns_runner);
-
     let dev_att = dev_att::HardCodedDevAtt::new();
 
     #[cfg(feature = "std")]
@@ -113,6 +97,18 @@ fn run() -> Result<(), Error> {
     #[cfg(not(feature = "std"))]
     let rand = matter::utils::rand::dummy_rand;
 
+    let mdns = MdnsService::new(
+        0,
+        "matter-demo",
+        ipv4_addr.octets(),
+        Some(ipv6_addr.octets()),
+        interface,
+        &dev_det,
+        matter::MATTER_PORT,
+    );
+
+    info!("mDNS initialized: {:p}", &mdns);
+
     let matter = Matter::new(
         // vid/pid should match those in the DAC
         &dev_det,
@@ -125,20 +121,6 @@ fn run() -> Result<(), Error> {
 
     info!("Matter initialized: {:p}", &matter);
 
-    let mut runner = TransportRunner::new(&matter);
-
-    info!("Transport Runner initialized: {:p}", &runner);
-
-    let mut tx_buf = TxBuf::uninit();
-    let mut rx_buf = RxBuf::uninit();
-
-    // NOTE (no_std): If using the `embassy-net` UDP implementation, replace this dummy stack with the `embassy-net` one
-    // When using a custom UDP stack, remove this
-    let stack = NetworkStack::new();
-
-    let mut mdns_udp_buffers = UdpBuffers::new();
-    let mut trans_udp_buffers = UdpBuffers::new();
-
     #[cfg(all(feature = "std", not(target_os = "espidf")))]
     {
         let mut buf = [0; 4096];
@@ -152,62 +134,33 @@ fn run() -> Result<(), Error> {
         }
     }
 
-    let node = Node {
-        id: 0,
-        endpoints: &[
-            root_endpoint::endpoint(0),
-            Endpoint {
-                id: 1,
-                device_type: DEV_TYPE_ON_OFF_LIGHT,
-                clusters: &[descriptor::CLUSTER, cluster_on_off::CLUSTER],
-            },
-        ],
-    };
+    let mut runner = TransportRunner::new(&matter);
+
+    info!("Transport runner initialized: {:p}", &runner);
 
     let handler = HandlerCompat(handler(&matter));
 
-    let matter = &matter;
-    let node = &node;
-    let handler = &handler;
-    let runner = &mut runner;
-    let tx_buf = &mut tx_buf;
-    let rx_buf = &mut rx_buf;
-    let stack = &stack;
-    let mdns_udp_buffers = &mut mdns_udp_buffers;
-    let trans_udp_buffers = &mut trans_udp_buffers;
+    // NOTE (no_std): If using the `embassy-net` UDP implementation, replace this dummy stack with the `embassy-net` one
+    // When using a custom UDP stack, remove this
+    let stack = NetworkStack::new();
 
-    info!(
-        "About to run wth node {:p}, handler {:p}, transport runner {:p}, mdns_runner {:p}",
-        node, handler, runner, &mdns_runner
-    );
+    let mut buffers = AllUdpBuffers::new();
 
-    let mut fut = pin!(async move {
-        // NOTE: If using a custom UDP stack, replace `run_udp` with `run`
-        // and connect the pipes of the `run` method with the custom UDP stack
-        let mut transport = pin!(runner.run_udp(
-            stack,
-            trans_udp_buffers,
-            tx_buf,
-            rx_buf,
-            CommissioningData {
-                // TODO: Hard-coded for now
-                verifier: VerifierData::new_with_pw(123456, *matter.borrow()),
-                discriminator: 250,
-            },
-            &handler,
-        ));
-
-        // NOTE: If using a custom UDP stack, replace `run_udp` with `run`
-        // and connect the pipes of the `run` method with the custom UDP stack
-        let mut mdns = pin!(mdns_runner.run_udp(stack, mdns_udp_buffers));
-
-        let mut save = pin!(save(matter, &psm));
-        select3(&mut transport, &mut mdns, &mut save).await.unwrap()
-    });
+    let mut fut = pin!(runner.run_udp_all(
+        &stack,
+        &mdns,
+        &mut buffers,
+        CommissioningData {
+            // TODO: Hard-coded for now
+            verifier: VerifierData::new_with_pw(123456, *matter.borrow()),
+            discriminator: 250,
+        },
+        &handler,
+    ));
 
     // NOTE: For no_std, replace with your own no_std way of polling the future
     #[cfg(feature = "std")]
-    smol::block_on(&mut fut)?;
+    async_io::block_on(&mut fut)?;
 
     // NOTE (no_std): For no_std, replace with your own more efficient no_std executor,
     // because the executor used below is a simple busy-loop poller

matter/Cargo.toml

@@ -17,7 +17,7 @@ path = "src/lib.rs"
 [features]
 default = ["os", "crypto_rustcrypto"]
 os = ["std", "backtrace", "env_logger", "nix", "critical-section/std", "embassy-sync/std", "embassy-time/std"]
-std = ["alloc", "rand", "qrcode", "async-io", "smol", "esp-idf-sys/std"]
+std = ["alloc", "rand", "qrcode", "async-io", "esp-idf-sys/std"]
 backtrace = []
 alloc = []
 nightly = []
@@ -47,14 +47,15 @@ embassy-time = { version = "0.1.1", features = ["generic-queue-8"] }
 embassy-sync = "0.2"
 critical-section = "1.1.1"
 domain = { version = "0.7.2", default_features = false, features = ["heapless"] }
+
+# embassy-net dependencies
 embassy-net = { version = "0.1", features = ["udp", "igmp", "proto-ipv6", "medium-ethernet", "medium-ip"], optional = true }
 embassy-net-driver = { version = "0.1", optional = true }
 smoltcp = { version = "0.10", default-features = false, optional = true }
 
 # STD-only dependencies
 rand = { version = "0.8.5", optional = true }
 qrcode = { version = "0.12", default-features = false, optional = true } # Print QR code
-smol = { version = "1.2", optional = true } # =1.2 for compatibility with ESP IDF
 async-io = { version = "=1.12", optional = true } # =1.2 for compatibility with ESP IDF
 
 # crypto

matter/src/mdns.rs

@@ -56,16 +56,18 @@ where
 }
 
 #[cfg(all(feature = "std", target_os = "macos"))]
-pub type DefaultMdns<'a> = astro::Mdns<'a>;
-
+pub use astro::MdnsRunner;
+#[cfg(all(feature = "std", target_os = "macos"))]
+pub use astro::MdnsService;
 #[cfg(all(feature = "std", target_os = "macos"))]
-pub type DefaultMdnsRunner<'a> = astro::MdnsRunner<'a>;
+pub use astro::MdnsUdpBuffers;
 
 #[cfg(not(all(feature = "std", target_os = "macos")))]
-pub type DefaultMdns<'a> = builtin::Mdns<'a>;
-
+pub use builtin::MdnsRunner;
+#[cfg(not(all(feature = "std", target_os = "macos")))]
+pub use builtin::MdnsService;
 #[cfg(not(all(feature = "std", target_os = "macos")))]
-pub type DefaultMdnsRunner<'a> = builtin::MdnsRunner<'a>;
+pub use builtin::MdnsUdpBuffers;
 
 pub struct DummyMdns;
 

matter/src/mdns/astro.rs

@@ -11,13 +11,14 @@ use log::info;
 
 use super::ServiceMode;
 
-pub struct Mdns<'a> {
+pub struct MdnsService<'a> {
     dev_det: &'a BasicInfoConfig<'a>,
     matter_port: u16,
     services: RefCell<HashMap<String, RegisteredDnsService>>,
 }
 
-impl<'a> Mdns<'a> {
+impl<'a> MdnsService<'a> {
+    /// This constructor takes extra parameters for API-compatibility with builtin::MdnsRunner
     pub fn new(
         _id: u16,
         _hostname: &str,
@@ -80,28 +81,41 @@ impl<'a> Mdns<'a> {
     }
 }
 
-pub struct MdnsRunner<'a>(&'a Mdns<'a>);
+/// Only for API-compatibility with builtin::MdnsRunner
+pub struct MdnsUdpBuffers(());
 
-impl<'a> MdnsRunner<'a> {
-    pub const fn new(mdns: &'a Mdns<'a>) -> Self {
-        Self(mdns)
+/// Only for API-compatibility with builtin::MdnsRunner
+impl MdnsUdpBuffers {
+    #[inline(always)]
+    pub const fn new() -> Self {
+        Self(())
     }
+}
 
-    pub async fn run_udp(&mut self) -> Result<(), Error> {
-        core::future::pending::<Result<(), Error>>().await
+impl<'a> super::Mdns for MdnsService<'a> {
+    fn add(&self, service: &str, mode: ServiceMode) -> Result<(), Error> {
+        MdnsService::add(self, service, mode)
     }
 
-    pub async fn run(&self, _tx_pipe: &Pipe<'_>, _rx_pipe: &Pipe<'_>) -> Result<(), Error> {
-        core::future::pending::<Result<(), Error>>().await
+    fn remove(&self, service: &str) -> Result<(), Error> {
+        MdnsService::remove(self, service)
     }
 }
 
-impl<'a> super::Mdns for Mdns<'a> {
-    fn add(&self, service: &str, mode: ServiceMode) -> Result<(), Error> {
-        Mdns::add(self, service, mode)
+/// Only for API-compatibility with builtin::MdnsRunner
+pub struct MdnsRunner<'a>(&'a MdnsService<'a>);
+
+/// Only for API-compatibility with builtin::MdnsRunner
+impl<'a> MdnsRunner<'a> {
+    pub const fn new(mdns: &'a MdnsService<'a>) -> Self {
+        Self(mdns)
     }
 
-    fn remove(&self, service: &str) -> Result<(), Error> {
-        Mdns::remove(self, service)
+    pub async fn run_udp(&mut self, buffers: &mut MdnsUdpBuffers) -> Result<(), Error> {
+        core::future::pending::<Result<(), Error>>().await
+    }
+
+    pub async fn run(&self, _tx_pipe: &Pipe<'_>, _rx_pipe: &Pipe<'_>) -> Result<(), Error> {
+        core::future::pending::<Result<(), Error>>().await
     }
 }