NetStack

Author: ivmarkov

src/eth.rs

@@ -1,7 +1,5 @@
 use core::pin::pin;
 
-use edge_nal::UdpBind;
-
 use embassy_futures::select::{select, select3};
 
 use rs_matter::dm::clusters::gen_comm::CommPolicy;
@@ -16,6 +14,7 @@ use rs_matter::transport::network::NoNetwork;
 use rs_matter::utils::init::{init, Init};
 use rs_matter::utils::select::Coalesce;
 
+use crate::nal::NetStack;
 use crate::network::{Embedding, Network};
 use crate::persist::{KvBlobStore, SharedKvBlobStore};
 use crate::private::Sealed;
@@ -63,25 +62,25 @@ where
 pub type EthMatterStack<'a, E = ()> = MatterStack<'a, Eth<E>>;
 
 /// A trait representing a task that needs access to the operational Ethernet interface
-/// (Netif and UDP stack) to perform its work.
+/// (Network stack and Netif) to perform its work.
 pub trait EthernetTask {
-    /// Run the task with the given network interface and UDP stack
-    async fn run<U, N>(&mut self, udp: U, netif: N) -> Result<(), Error>
+    /// Run the task with the given network stack and network interface
+    async fn run<S, N>(&mut self, net_stack: S, netif: N) -> Result<(), Error>
     where
-        U: UdpBind,
+        S: NetStack,
         N: NetifDiag + NetChangeNotif;
 }
 
 impl<T> EthernetTask for &mut T
 where
     T: EthernetTask,
 {
-    async fn run<U, N>(&mut self, udp: U, netif: N) -> Result<(), Error>
+    async fn run<S, N>(&mut self, net_stack: S, netif: N) -> Result<(), Error>
     where
-        U: UdpBind,
+        S: NetStack,
         N: NetifDiag + NetChangeNotif,
     {
-        (*self).run(udp, netif).await
+        (*self).run(net_stack, netif).await
     }
 }
 
@@ -107,28 +106,28 @@ where
 
 /// A utility type for running an ethernet task with a pre-existing ethernet interface
 /// rather than bringing up / tearing down the ethernet interface for the task.
-pub struct PreexistingEthernet<U, N> {
-    udp: U,
+pub struct PreexistingEthernet<S, N> {
+    stack: S,
     netif: N,
 }
 
-impl<N, U> PreexistingEthernet<U, N> {
+impl<S, N> PreexistingEthernet<S, N> {
     /// Create a new `PreexistingEthernet` instance with the given network interface and UDP stack.
-    pub const fn new(udp: U, netif: N) -> Self {
-        Self { udp, netif }
+    pub const fn new(stack: S, netif: N) -> Self {
+        Self { stack, netif }
     }
 }
 
-impl<U, N> Ethernet for PreexistingEthernet<U, N>
+impl<S, N> Ethernet for PreexistingEthernet<S, N>
 where
-    U: UdpBind,
+    S: NetStack,
     N: NetifDiag + NetChangeNotif,
 {
     async fn run<T>(&mut self, mut task: T) -> Result<(), Error>
     where
         T: EthernetTask,
     {
-        task.run(&mut self.udp, &self.netif).await
+        task.run(&self.stack, &self.netif).await
     }
 }
 
@@ -172,27 +171,32 @@ where
     ///
     /// Parameters:
     /// - `netif` - a user-provided `Netif` implementation for the Ethernet network
-    /// - `udp` - a user-provided `UdpBind` implementation
+    /// - `net_stack` - a user-provided network stack implementation
     /// - `persist` - a user-provided `Persist` implementation
     /// - `handler` - a user-provided DM handler implementation
     /// - `user` - a user-provided future that will be polled only when the netif interface is up
     pub async fn run_preex<U, N, S, H, X>(
         &self,
-        udp: U,
+        net_stack: U,
         netif: N,
         store: &SharedKvBlobStore<'_, S>,
         handler: H,
         user: X,
     ) -> Result<(), Error>
     where
+        U: NetStack,
         N: NetifDiag + NetChangeNotif,
-        U: UdpBind,
         S: KvBlobStore,
         H: AsyncHandler + AsyncMetadata,
         X: UserTask,
     {
-        self.run(PreexistingEthernet::new(udp, netif), store, handler, user)
-            .await
+        self.run(
+            PreexistingEthernet::new(net_stack, netif),
+            store,
+            handler,
+            user,
+        )
+        .await
     }
 
     /// Run the Matter stack for an Ethernet network.
@@ -257,15 +261,15 @@ where
     H: AsyncMetadata + AsyncHandler,
     X: UserTask,
 {
-    async fn run<U, C>(&mut self, udp: U, netif: C) -> Result<(), Error>
+    async fn run<S, C>(&mut self, net_stack: S, netif: C) -> Result<(), Error>
     where
-        U: UdpBind,
+        S: NetStack,
         C: NetifDiag + NetChangeNotif,
     {
         info!("Ethernet driver started");
 
         let mut net_task = pin!(self.0.run_oper_net(
-            &udp,
+            &net_stack,
             &netif,
             core::future::pending(),
             Option::<(NoNetwork, NoNetwork)>::None,
@@ -274,7 +278,7 @@ where
         let handler = self.0.root_handler(&(), &true, &netif, &self.1);
         let mut handler_task = pin!(self.0.run_handler((&self.1, handler)));
 
-        let mut user_task = pin!(self.2.run(&udp, &netif));
+        let mut user_task = pin!(self.2.run(&net_stack, &netif));
 
         select3(&mut net_task, &mut handler_task, &mut user_task)
             .coalesce()

src/lib.rs

@@ -14,7 +14,6 @@ use core::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV6};
 use core::pin::pin;
 
 use edge_nal::{UdpBind, UdpSplit};
-
 use embassy_futures::select::{select4, Either4};
 use embassy_sync::blocking_mutex::raw::NoopRawMutex;
 
@@ -36,6 +35,7 @@ use rs_matter::utils::rand::Rand;
 use rs_matter::utils::storage::pooled::PooledBuffers;
 use rs_matter::{BasicCommData, Matter, MATTER_PORT};
 
+use crate::nal::NetStack;
 use crate::network::Network;
 use crate::persist::SharedKvBlobStore;
 
@@ -341,20 +341,21 @@ where
     /// the main UDP transport and the mDNS service when the netif goes up/down or changes its IP addresses.
     ///
     /// Parameters:
+    /// - `net_stack` - a user-provided network stack that implements `UdpBind`, `UdpConnect`, `TcpBind`, `TcpConnect`, and `Dns`
     /// - `netif` - a user-provided `Netif` implementation
     /// - `until` - the method will return once this future becomes ready
     /// - `comm` - a tuple of additional and optional `NetworkReceive` and `NetworkSend` transport implementations
     ///   (useful when a second transport needs to run in parallel with the operational Matter transport,
     ///   i.e. when using concurrent commissisoning)
     async fn run_oper_net<U, I, X, R, S>(
         &self,
-        udp: U,
+        net_stack: U,
         netif: I,
         until: X,
         mut comm: Option<(R, S)>,
     ) -> Result<(), Error>
     where
-        U: UdpBind,
+        U: NetStack,
         I: NetifDiag + NetChangeNotif,
         X: Future<Output = Result<(), Error>>,
         R: NetworkReceive,
@@ -446,7 +447,9 @@ where
             let result = if cur_netif.operational {
                 info!("Netif up: {:?}", cur_netif);
 
-                let mut socket = udp
+                let udp_bind = unwrap!(net_stack.udp_bind());
+
+                let mut socket = udp_bind
                     .bind(SocketAddr::V6(SocketAddrV6::new(
                         Ipv6Addr::UNSPECIFIED,
                         MATTER_PORT,
@@ -459,7 +462,7 @@ where
                 let (recv, send) = socket.split();
 
                 let mut mdns_task = pin!(self.run_builtin_mdns(
-                    &udp,
+                    &udp_bind,
                     &cur_netif.mac,
                     cur_netif.ipv4,
                     cur_netif.ipv6,
@@ -682,37 +685,37 @@ where
 }
 
 /// A trait representing a user task that needs access to the operational network interface
-/// (Netif and UDP stack) to perform its work.
+/// (Netif and net stack) to perform its work.
 ///
 /// Note that the task would be started only when `rs-matter`
 /// brings up the operational interface (eth, wifi or thread)
 /// and if the interface goes down, the user task would be stopped.
 /// Upon re-connection, the task would be started again.
 pub trait UserTask {
-    /// Run the task with the given network interface and UDP stack
-    async fn run<U, N>(&mut self, udp: U, netif: N) -> Result<(), Error>
+    /// Run the task with the given network stack and network interface
+    async fn run<S, N>(&mut self, net_stack: S, netif: N) -> Result<(), Error>
     where
-        U: UdpBind,
+        S: NetStack,
         N: NetifDiag + NetChangeNotif;
 }
 
 impl<T> UserTask for &mut T
 where
     T: UserTask,
 {
-    async fn run<U, N>(&mut self, udp: U, netif: N) -> Result<(), Error>
+    async fn run<S, N>(&mut self, net_stack: S, netif: N) -> Result<(), Error>
     where
-        U: UdpBind,
+        S: NetStack,
         N: NetifDiag + NetChangeNotif,
     {
-        (*self).run(udp, netif).await
+        (*self).run(net_stack, netif).await
     }
 }
 
 impl UserTask for () {
-    async fn run<U, N>(&mut self, _udp: U, _netif: N) -> Result<(), Error>
+    async fn run<S, N>(&mut self, _net_stack: S, _netif: N) -> Result<(), Error>
     where
-        U: UdpBind,
+        S: NetStack,
         N: NetifDiag + NetChangeNotif,
     {
         core::future::pending::<()>().await;