Simplify API by combining Matter, Transport and TransportRunner; simplify Mdns and Psm runners

Author: ivmarkov

.github/workflows/test-linux.yml

@@ -15,11 +15,11 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        crypto-backend: ['crypto_openssl', 'crypto_rustcrypto', 'crypto_mbedtls']
+        crypto-backend: ['rustcrypto', 'mbedtls', 'openssl']
 
     steps:
     - uses: actions/checkout@v2
     - name: Build
-      run: cd matter; cargo build --verbose --no-default-features --features ${{matrix.crypto-backend}}
+      run: cd matter; cargo build --no-default-features --features ${{matrix.crypto-backend}}
     - name: Run tests
-      run: cd matter; cargo test --verbose --no-default-features --features ${{matrix.crypto-backend}} -- --test-threads=1
+      run: cd matter; cargo test --no-default-features --features os,${{matrix.crypto-backend}} -- --test-threads=1

Cargo.toml

@@ -1,7 +1,8 @@
 [workspace]
+resolver = "2"
 members = ["matter", "matter_macro_derive"]
 
-exclude = ["examples/*"]
+exclude = ["examples/*", "tools/tlv_tool"]
 
 # For compatibility with ESP IDF
 [patch.crates-io]

README.md

@@ -41,23 +41,24 @@ The `async` metaphor however comes with a bit higher memory usage, due to not en
 
 ## Build
 
-Building the library:
+### Building the library
 
 ```
 $ cargo build
 ```
 
-Building and running the example (Linux, MacOS X):
+### Building and running the example (Linux, MacOS X)
 
 ```
 $ cargo run --example onoff_light
 ```
 
-Building the example (Espressif's ESP-IDF):
+### Building the example (Espressif's ESP-IDF)
+
 * Install all build prerequisites described [here](https://github.com/esp-rs/esp-idf-template#prerequisites)
 * Build with the following command line:
 ```
-export MCU=esp32; export CARGO_TARGET_XTENSA_ESP32_ESPIDF_LINKER=ldproxy; export RUSTFLAGS="-C default-linker-libraries"; export WIFI_SSID=ssid;export WIFI_PASS=pass; cargo build --example onoff_light --no-default-features --features std,crypto_rustcrypto --target xtensa-esp32-espidf -Zbuild-std=std,panic_abort
+export MCU=esp32; export CARGO_TARGET_XTENSA_ESP32_ESPIDF_LINKER=ldproxy; export RUSTFLAGS="-C default-linker-libraries"; export WIFI_SSID=ssid;export WIFI_PASS=pass; cargo build --example onoff_light --no-default-features --features esp-idf --target xtensa-esp32-espidf -Zbuild-std=std,panic_abort
 ```
 * If you are building for a different Espressif MCU, change the `MCU` variable, the `xtensa-esp32-espidf` target and the name of the `CARGO_TARGET_<esp-idf-target-uppercase>_LINKER` variable to match your MCU and its Rust target. Available Espressif MCUs and targets are:
   * esp32 / xtensa-esp32-espidf
@@ -69,6 +70,10 @@ export MCU=esp32; export CARGO_TARGET_XTENSA_ESP32_ESPIDF_LINKER=ldproxy; export
 * Put in `WIFI_SSID` / `WIFI_PASS` the SSID & password for your wireless router
 * Flash using the `espflash` utility described in the build prerequsites' link above
 
+### Building the example (ESP32-XX baremetal or RP2040)
+
+Coming soon!
+
 ## Test
 
 With the `chip-tool` (the current tool for testing Matter) use the Ethernet commissioning mechanism:

examples/onoff_light/src/main.rs

@@ -18,6 +18,7 @@
 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;
@@ -27,18 +28,18 @@ 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::MdnsService;
-use matter::persist::FilePsm;
+use matter::mdns::{MdnsRunBuffers, MdnsService};
 use matter::secure_channel::spake2p::VerifierData;
+use matter::transport::core::RunBuffers;
 use matter::transport::network::{Ipv4Addr, Ipv6Addr, NetworkStack};
-use matter::transport::runner::{AllUdpBuffers, TransportRunner};
+use matter::utils::select::EitherUnwrap;
 
 mod dev_att;
 
 #[cfg(feature = "std")]
 fn main() -> Result<(), Error> {
     let thread = std::thread::Builder::new()
-        .stack_size(140 * 1024)
+        .stack_size(150 * 1024)
         .spawn(run)
         .unwrap();
 
@@ -56,11 +57,11 @@ fn run() -> Result<(), Error> {
     initialize_logger();
 
     info!(
-        "Matter memory: mDNS={}, Matter={}, TransportRunner={}, UdpBuffers={}",
+        "Matter memory: mDNS={}, Matter={}, MdnsBuffers={}, RunBuffers={}",
         core::mem::size_of::<MdnsService>(),
         core::mem::size_of::<Matter>(),
-        core::mem::size_of::<TransportRunner>(),
-        core::mem::size_of::<AllUdpBuffers>(),
+        core::mem::size_of::<MdnsRunBuffers>(),
+        core::mem::size_of::<RunBuffers>(),
     );
 
     let dev_det = BasicInfoConfig {
@@ -73,12 +74,6 @@ fn run() -> Result<(), Error> {
         device_name: "OnOff Light",
     };
 
-    let psm_path = std::env::temp_dir().join("matter-iot");
-    info!("Persisting from/to {}", psm_path.display());
-
-    #[cfg(all(feature = "std", not(target_os = "espidf")))]
-    let psm = matter::persist::FilePsm::new(psm_path)?;
-
     let (ipv4_addr, ipv6_addr, interface) = initialize_network()?;
 
     let dev_att = dev_att::HardCodedDevAtt::new();
@@ -106,7 +101,7 @@ fn run() -> Result<(), Error> {
         matter::MATTER_PORT,
     );
 
-    info!("mDNS initialized: {:p}", &mdns);
+    info!("mDNS initialized");
 
     let matter = Matter::new(
         // vid/pid should match those in the DAC
@@ -118,53 +113,59 @@ fn run() -> Result<(), Error> {
         matter::MATTER_PORT,
     );
 
-    info!("Matter initialized: {:p}", &matter);
+    info!("Matter initialized");
 
     #[cfg(all(feature = "std", not(target_os = "espidf")))]
-    {
-        let mut buf = [0; 4096];
-        let buf = &mut buf;
-        if let Some(data) = psm.load("acls", buf)? {
-            matter.load_acls(data)?;
-        }
-
-        if let Some(data) = psm.load("fabrics", buf)? {
-            matter.load_fabrics(data)?;
-        }
-    }
-
-    let mut runner = TransportRunner::new(&matter);
-
-    info!("Transport runner initialized: {:p}", &runner);
+    let mut psm = matter::persist::Psm::new(&matter, std::env::temp_dir().join("matter-iot"))?;
 
     let handler = HandlerCompat(handler(&matter));
 
-    // 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
+    // When using a custom UDP stack, remove the network stack initialization below
+    // and call `Matter::run_piped()` instead, by utilizing the TX & RX `Pipe` structs
+    // to push/pull your UDP packets from/to the Matter stack.
+    // Ditto for `MdnsService`.
+    //
+    // When using the `embassy-net` feature (as opposed to the Rust Standard Library network stack),
+    // this initialization would be more complex.
     let stack = NetworkStack::new();
 
-    let mut buffers = AllUdpBuffers::new();
+    let mut mdns_buffers = MdnsRunBuffers::new();
+    let mut mdns_runner = pin!(mdns.run(&stack, &mut mdns_buffers));
 
-    let mut fut = pin!(runner.run_udp_all(
+    let mut buffers = RunBuffers::new();
+    let mut runner = matter.run(
         &stack,
-        &mdns,
         &mut buffers,
         CommissioningData {
             // TODO: Hard-coded for now
             verifier: VerifierData::new_with_pw(123456, *matter.borrow()),
             discriminator: 250,
         },
         &handler,
-    ));
+    );
+
+    info!(
+        "Matter transport runner memory: {}",
+        core::mem::size_of_val(&runner)
+    );
+
+    let mut runner = pin!(runner);
+
+    #[cfg(all(feature = "std", not(target_os = "espidf")))]
+    let mut psm_runner = pin!(psm.run());
+
+    #[cfg(not(all(feature = "std", not(target_os = "espidf"))))]
+    let mut psm_runner = pin!(core::future::pending());
+
+    let mut runner = select3(&mut runner, &mut mdns_runner, &mut psm_runner);
 
-    // NOTE: For no_std, replace with your own no_std way of polling the future
     #[cfg(feature = "std")]
-    async_io::block_on(&mut fut)?;
+    async_io::block_on(&mut runner).unwrap()?;
 
     // 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
     #[cfg(not(feature = "std"))]
-    embassy_futures::block_on(&mut fut)?;
+    embassy_futures::block_on(&mut runner).unwrap()?;
 
     Ok(())
 }
@@ -268,26 +269,6 @@ fn initialize_network() -> Result<(Ipv4Addr, Ipv6Addr, u32), Error> {
     Ok((ip, ipv6, 0 as _))
 }
 
-#[cfg(all(feature = "std", not(target_os = "espidf")))]
-#[inline(never)]
-async fn save(matter: &Matter<'_>, psm: &FilePsm) -> Result<(), Error> {
-    let mut buf = [0; 4096];
-    let buf = &mut buf;
-
-    loop {
-        matter.wait_changed().await;
-        if matter.is_changed() {
-            if let Some(data) = matter.store_acls(buf)? {
-                psm.store("acls", data)?;
-            }
-
-            if let Some(data) = matter.store_fabrics(buf)? {
-                psm.store("fabrics", data)?;
-            }
-        }
-    }
-}
-
 #[cfg(target_os = "espidf")]
 #[inline(never)]
 fn initialize_logger() {

matter/Cargo.toml

@@ -8,23 +8,23 @@ repository = "https://github.com/kedars/matter-rs"
 readme = "README.md"
 keywords = ["matter", "smart", "smart-home", "IoT", "ESP32"]
 categories = ["embedded", "network-programming"]
-license = "MIT"
+license = "Apache-2.0"
 
 [lib]
 name = "matter"
 path = "src/lib.rs"
 
 [features]
-default = ["os", "crypto_rustcrypto"]
+default = ["os", "mbedtls"]
 os = ["std", "backtrace", "env_logger", "nix", "critical-section/std", "embassy-sync/std", "embassy-time/std"]
-esp-idf = ["std", "crypto_rustcrypto", "esp-idf-sys", "esp-idf-hal", "esp-idf-svc"]
+esp-idf = ["std", "rustcrypto", "esp-idf-sys"]
 std = ["alloc", "rand", "qrcode", "async-io", "esp-idf-sys?/std", "embassy-time/generic-queue-16"]
 backtrace = []
 alloc = []
 nightly = []
-crypto_openssl = ["alloc", "openssl", "foreign-types", "hmac", "sha2"]
-crypto_mbedtls = ["alloc", "mbedtls"]
-crypto_rustcrypto = ["alloc", "sha2", "hmac", "pbkdf2", "hkdf", "aes", "ccm", "p256", "elliptic-curve", "crypto-bigint", "x509-cert", "rand_core"]
+openssl = ["alloc", "dep:openssl", "foreign-types", "hmac", "sha2"]
+mbedtls = ["alloc", "dep:mbedtls"]
+rustcrypto = ["alloc", "sha2", "hmac", "pbkdf2", "hkdf", "aes", "ccm", "p256", "elliptic-curve", "crypto-bigint", "x509-cert", "rand_core"]
 embassy-net = ["dep:embassy-net", "dep:embassy-net-driver", "smoltcp"]
 
 [dependencies]
@@ -58,10 +58,10 @@ 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
-async-io = { version = "=1.12", optional = true } # =1.2 for compatibility with ESP IDF
+async-io = { version = "=1.12", optional = true } # =1.12 for compatibility with ESP IDF
 
 # crypto
-openssl = { git = "https://github.com/sfackler/rust-openssl", optional = true }
+openssl = { version = "0.10.55", optional = true }
 foreign-types = { version = "0.3.2", optional = true }
 
 # rust-crypto
@@ -81,18 +81,22 @@ x509-cert = { version = "0.2.0", default-features = false, features = ["pem"], o
 astro-dnssd = { version = "0.3" }
 
 [target.'cfg(not(target_os = "espidf"))'.dependencies]
-mbedtls = { git = "https://github.com/fortanix/rust-mbedtls", optional = true }
+mbedtls = { version = "0.9", optional = true }
 env_logger = { version = "0.10.0", optional = true }
 nix = { version = "0.26", features = ["net"], optional = true }
 
 [target.'cfg(target_os = "espidf")'.dependencies]
-esp-idf-sys = { version = "0.33", optional = true, default-features = false, features = ["native", "binstart"] }
-esp-idf-hal = { version = "0.41", optional = true, features = ["embassy-sync", "critical-section"] } # TODO: Only necessary for the examples
-esp-idf-svc = { version = "0.46", optional = true, features = ["embassy-time-driver"] } # TODO: Only necessary for the examples
+esp-idf-sys = { version = "0.33", optional = true, default-features = false, features = ["native"] }
 
 [build-dependencies]
 embuild = "0.31.2"
 
+[target.'cfg(target_os = "espidf")'.dev-dependencies]
+esp-idf-sys = { version = "0.33", default-features = false, features = ["binstart"] }
+esp-idf-hal = { version = "0.41", features = ["embassy-sync", "critical-section"] }
+esp-idf-svc = { version = "0.46", features = ["embassy-time-driver"] }
+embedded-svc = { version = "0.25" }
+
 [[example]]
 name = "onoff_light"
 path = "../examples/onoff_light/src/main.rs"

matter/src/core.rs

@@ -28,8 +28,11 @@ use crate::{
     mdns::Mdns,
     pairing::{print_pairing_code_and_qr, DiscoveryCapabilities},
     secure_channel::{pake::PaseMgr, spake2p::VerifierData},
-    transport::exchange::Notification,
-    utils::{epoch::Epoch, rand::Rand},
+    transport::{
+        exchange::{ExchangeCtx, MAX_EXCHANGES},
+        session::SessionMgr,
+    },
+    utils::{epoch::Epoch, rand::Rand, select::Notification},
 };
 
 /* The Matter Port */
@@ -45,17 +48,20 @@ pub struct CommissioningData {
 
 /// The primary Matter Object
 pub struct Matter<'a> {
-    pub fabric_mgr: RefCell<FabricMgr>,
-    pub acl_mgr: RefCell<AclMgr>,
-    pub pase_mgr: RefCell<PaseMgr>,
-    pub failsafe: RefCell<FailSafe>,
-    pub persist_notification: Notification,
-    pub mdns: &'a dyn Mdns,
-    pub epoch: Epoch,
-    pub rand: Rand,
-    pub dev_det: &'a BasicInfoConfig<'a>,
-    pub dev_att: &'a dyn DevAttDataFetcher,
-    pub port: u16,
+    fabric_mgr: RefCell<FabricMgr>,
+    pub acl_mgr: RefCell<AclMgr>, // Public for tests
+    pase_mgr: RefCell<PaseMgr>,
+    failsafe: RefCell<FailSafe>,
+    persist_notification: Notification,
+    pub(crate) send_notification: Notification,
+    mdns: &'a dyn Mdns,
+    pub(crate) epoch: Epoch,
+    pub(crate) rand: Rand,
+    dev_det: &'a BasicInfoConfig<'a>,
+    dev_att: &'a dyn DevAttDataFetcher,
+    pub(crate) port: u16,
+    pub(crate) exchanges: RefCell<heapless::Vec<ExchangeCtx, MAX_EXCHANGES>>,
+    pub session_mgr: RefCell<SessionMgr>, // Public for tests
 }
 
 impl<'a> Matter<'a> {
@@ -94,12 +100,15 @@ impl<'a> Matter<'a> {
             pase_mgr: RefCell::new(PaseMgr::new(epoch, rand)),
             failsafe: RefCell::new(FailSafe::new()),
             persist_notification: Notification::new(),
+            send_notification: Notification::new(),
             mdns,
             epoch,
             rand,
             dev_det,
             dev_att,
             port,
+            exchanges: RefCell::new(heapless::Vec::new()),
+            session_mgr: RefCell::new(SessionMgr::new(epoch, rand)),
         }
     }
 
@@ -160,6 +169,7 @@ impl<'a> Matter<'a> {
             Ok(false)
         }
     }
+
     pub fn notify_changed(&self) {
         if self.is_changed() {
             self.persist_notification.signal(());