Proper mDNS responder

Author: ivmarkov

examples/onoff_light/src/main.rs

@@ -69,13 +69,25 @@ fn run() -> Result<(), Error> {
         core::mem::size_of::<Transport>(),
     );
 
+    let dev_det = BasicInfoConfig {
+        vid: 0xFFF1,
+        pid: 0x8000,
+        hw_ver: 2,
+        sw_ver: 1,
+        sw_ver_str: "1",
+        serial_no: "aabbccdd",
+        device_name: "OnOff Light",
+    };
+
     let (ipv4_addr, ipv6_addr) = initialize_network()?;
 
     let mdns = DefaultMdns::new(
         0,
         "matter-demo",
         ipv4_addr.octets(),
         Some(ipv6_addr.octets()),
+        &dev_det,
+        matter::MATTER_PORT,
     );
 
     let mut mdns_runner = DefaultMdnsRunner::new(&mdns);
@@ -84,15 +96,7 @@ fn run() -> Result<(), Error> {
 
     let matter = Matter::new_default(
         // vid/pid should match those in the DAC
-        &BasicInfoConfig {
-            vid: 0xFFF1,
-            pid: 0x8000,
-            hw_ver: 2,
-            sw_ver: 1,
-            sw_ver_str: "1",
-            serial_no: "aabbccdd",
-            device_name: "OnOff Light",
-        },
+        &dev_det,
         &dev_att,
         &mdns,
         matter::MATTER_PORT,

matter/Cargo.toml

@@ -46,7 +46,7 @@ embassy-futures = "0.1"
 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 }
+domain = { version = "0.7.2", default_features = false, features = ["heapless"] }
 
 # STD-only dependencies
 rand = { version = "0.8.5", optional = true }

matter/src/core.rs

@@ -25,7 +25,7 @@ use crate::{
     },
     error::*,
     fabric::FabricMgr,
-    mdns::{Mdns, MdnsMgr},
+    mdns::Mdns,
     pairing::{print_pairing_code_and_qr, DiscoveryCapabilities},
     secure_channel::{pake::PaseMgr, spake2p::VerifierData},
     utils::{epoch::Epoch, rand::Rand},
@@ -48,7 +48,7 @@ pub struct Matter<'a> {
     pub acl_mgr: RefCell<AclMgr>,
     pub pase_mgr: RefCell<PaseMgr>,
     pub failsafe: RefCell<FailSafe>,
-    pub mdns_mgr: MdnsMgr<'a>,
+    pub mdns: &'a dyn Mdns,
     pub epoch: Epoch,
     pub rand: Rand,
     pub dev_det: &'a BasicInfoConfig<'a>,
@@ -91,7 +91,7 @@ impl<'a> Matter<'a> {
             acl_mgr: RefCell::new(AclMgr::new()),
             pase_mgr: RefCell::new(PaseMgr::new(epoch, rand)),
             failsafe: RefCell::new(FailSafe::new()),
-            mdns_mgr: MdnsMgr::new(dev_det.vid, dev_det.pid, dev_det.device_name, port, mdns),
+            mdns,
             epoch,
             rand,
             dev_det,
@@ -113,7 +113,7 @@ impl<'a> Matter<'a> {
     }
 
     pub fn load_fabrics(&self, data: &[u8]) -> Result<(), Error> {
-        self.fabric_mgr.borrow_mut().load(data, &self.mdns_mgr)
+        self.fabric_mgr.borrow_mut().load(data, self.mdns)
     }
 
     pub fn load_acls(&self, data: &[u8]) -> Result<(), Error> {
@@ -149,7 +149,7 @@ impl<'a> Matter<'a> {
             self.pase_mgr.borrow_mut().enable_pase_session(
                 dev_comm.verifier,
                 dev_comm.discriminator,
-                &self.mdns_mgr,
+                self.mdns,
             )?;
 
             Ok(true)
@@ -183,12 +183,6 @@ impl<'a> Borrow<RefCell<FailSafe>> for Matter<'a> {
     }
 }
 
-impl<'a> Borrow<MdnsMgr<'a>> for Matter<'a> {
-    fn borrow(&self) -> &MdnsMgr<'a> {
-        &self.mdns_mgr
-    }
-}
-
 impl<'a> Borrow<BasicInfoConfig<'a>> for Matter<'a> {
     fn borrow(&self) -> &BasicInfoConfig<'a> {
         self.dev_det
@@ -203,7 +197,7 @@ impl<'a> Borrow<dyn DevAttDataFetcher + 'a> for Matter<'a> {
 
 impl<'a> Borrow<dyn Mdns + 'a> for Matter<'a> {
     fn borrow(&self) -> &(dyn Mdns + 'a) {
-        self.mdns_mgr.mdns
+        self.mdns
     }
 }
 

matter/src/data_model/root_endpoint.rs

@@ -4,7 +4,7 @@ use crate::{
     acl::AclMgr,
     fabric::FabricMgr,
     handler_chain_type,
-    mdns::MdnsMgr,
+    mdns::Mdns,
     secure_channel::pake::PaseMgr,
     utils::{epoch::Epoch, rand::Rand},
 };
@@ -62,7 +62,7 @@ where
         + Borrow<RefCell<FabricMgr>>
         + Borrow<RefCell<AclMgr>>
         + Borrow<RefCell<FailSafe>>
-        + Borrow<MdnsMgr<'a>>
+        + Borrow<dyn Mdns + 'a>
         + Borrow<Epoch>
         + Borrow<Rand>
         + 'a,
@@ -90,7 +90,7 @@ pub fn wrap<'a>(
     fabric: &'a RefCell<FabricMgr>,
     acl: &'a RefCell<AclMgr>,
     failsafe: &'a RefCell<FailSafe>,
-    mdns_mgr: &'a MdnsMgr<'a>,
+    mdns: &'a dyn Mdns,
     epoch: Epoch,
     rand: Rand,
 ) -> RootEndpointHandler<'a> {
@@ -103,12 +103,12 @@ pub fn wrap<'a>(
         .chain(
             endpoint_id,
             noc::ID,
-            NocCluster::new(dev_att, fabric, acl, failsafe, mdns_mgr, epoch, rand),
+            NocCluster::new(dev_att, fabric, acl, failsafe, mdns, epoch, rand),
         )
         .chain(
             endpoint_id,
             admin_commissioning::ID,
-            AdminCommCluster::new(pase, mdns_mgr, rand),
+            AdminCommCluster::new(pase, mdns, rand),
         )
         .chain(endpoint_id, nw_commissioning::ID, NwCommCluster::new(rand))
         .chain(

matter/src/data_model/sdm/admin_commissioning.rs

@@ -20,7 +20,7 @@ use core::convert::TryInto;
 
 use crate::data_model::objects::*;
 use crate::interaction_model::core::Transaction;
-use crate::mdns::MdnsMgr;
+use crate::mdns::Mdns;
 use crate::secure_channel::pake::PaseMgr;
 use crate::secure_channel::spake2p::VerifierData;
 use crate::tlv::{FromTLV, Nullable, OctetStr, TLVElement};
@@ -102,15 +102,15 @@ pub struct OpenCommWindowReq<'a> {
 pub struct AdminCommCluster<'a> {
     data_ver: Dataver,
     pase_mgr: &'a RefCell<PaseMgr>,
-    mdns_mgr: &'a MdnsMgr<'a>,
+    mdns: &'a dyn Mdns,
 }
 
 impl<'a> AdminCommCluster<'a> {
-    pub fn new(pase_mgr: &'a RefCell<PaseMgr>, mdns_mgr: &'a MdnsMgr<'a>, rand: Rand) -> Self {
+    pub fn new(pase_mgr: &'a RefCell<PaseMgr>, mdns: &'a dyn Mdns, rand: Rand) -> Self {
         Self {
             data_ver: Dataver::new(rand),
             pase_mgr,
-            mdns_mgr,
+            mdns,
         }
     }
 
@@ -152,11 +152,9 @@ impl<'a> AdminCommCluster<'a> {
         cmd_enter!("Open Commissioning Window");
         let req = OpenCommWindowReq::from_tlv(data)?;
         let verifier = VerifierData::new(req.verifier.0, req.iterations, req.salt.0);
-        self.pase_mgr.borrow_mut().enable_pase_session(
-            verifier,
-            req.discriminator,
-            self.mdns_mgr,
-        )?;
+        self.pase_mgr
+            .borrow_mut()
+            .enable_pase_session(verifier, req.discriminator, self.mdns)?;
 
         Ok(())
     }

matter/src/data_model/sdm/noc.rs

@@ -25,7 +25,7 @@ use crate::data_model::objects::*;
 use crate::data_model::sdm::dev_att;
 use crate::fabric::{Fabric, FabricMgr, MAX_SUPPORTED_FABRICS};
 use crate::interaction_model::core::Transaction;
-use crate::mdns::MdnsMgr;
+use crate::mdns::Mdns;
 use crate::tlv::{FromTLV, OctetStr, TLVElement, TLVWriter, TagType, ToTLV, UtfStr};
 use crate::transport::session::SessionMode;
 use crate::utils::epoch::Epoch;
@@ -222,7 +222,7 @@ pub struct NocCluster<'a> {
     fabric_mgr: &'a RefCell<FabricMgr>,
     acl_mgr: &'a RefCell<AclMgr>,
     failsafe: &'a RefCell<FailSafe>,
-    mdns_mgr: &'a MdnsMgr<'a>,
+    mdns: &'a dyn Mdns,
 }
 
 impl<'a> NocCluster<'a> {
@@ -231,7 +231,7 @@ impl<'a> NocCluster<'a> {
         fabric_mgr: &'a RefCell<FabricMgr>,
         acl_mgr: &'a RefCell<AclMgr>,
         failsafe: &'a RefCell<FailSafe>,
-        mdns_mgr: &'a MdnsMgr<'a>,
+        mdns: &'a dyn Mdns,
         epoch: Epoch,
         rand: Rand,
     ) -> Self {
@@ -243,7 +243,7 @@ impl<'a> NocCluster<'a> {
             fabric_mgr,
             acl_mgr,
             failsafe,
-            mdns_mgr,
+            mdns,
         }
     }
 
@@ -383,7 +383,7 @@ impl<'a> NocCluster<'a> {
         let fab_idx = self
             .fabric_mgr
             .borrow_mut()
-            .add(fabric, self.mdns_mgr)
+            .add(fabric, self.mdns)
             .map_err(|_| NocStatus::TableFull)?;
 
         self.add_acl(fab_idx, r.case_admin_subject)?;
@@ -455,7 +455,7 @@ impl<'a> NocCluster<'a> {
         if self
             .fabric_mgr
             .borrow_mut()
-            .remove(req.fab_idx, self.mdns_mgr)
+            .remove(req.fab_idx, self.mdns)
             .is_ok()
         {
             let _ = self.acl_mgr.borrow_mut().delete_for_fabric(req.fab_idx);

matter/src/fabric.rs

@@ -26,7 +26,7 @@ use crate::{
     crypto::{self, hkdf_sha256, HmacSha256, KeyPair},
     error::{Error, ErrorCode},
     group_keys::KeySet,
-    mdns::{MdnsMgr, ServiceMode},
+    mdns::{Mdns, ServiceMode},
     tlv::{self, FromTLV, OctetStr, TLVList, TLVWriter, TagType, ToTLV, UtfStr},
     utils::writebuf::WriteBuf,
 };
@@ -200,17 +200,17 @@ impl FabricMgr {
         }
     }
 
-    pub fn load(&mut self, data: &[u8], mdns_mgr: &MdnsMgr) -> Result<(), Error> {
+    pub fn load(&mut self, data: &[u8], mdns: &dyn Mdns) -> Result<(), Error> {
         for fabric in self.fabrics.iter().flatten() {
-            mdns_mgr.unpublish_service(&fabric.mdns_service_name, ServiceMode::Commissioned)?;
+            mdns.remove(&fabric.mdns_service_name)?;
         }
 
         let root = TLVList::new(data).iter().next().ok_or(ErrorCode::Invalid)?;
 
         tlv::from_tlv(&mut self.fabrics, &root)?;
 
         for fabric in self.fabrics.iter().flatten() {
-            mdns_mgr.publish_service(&fabric.mdns_service_name, ServiceMode::Commissioned)?;
+            mdns.add(&fabric.mdns_service_name, ServiceMode::Commissioned)?;
         }
 
         self.changed = false;
@@ -241,11 +241,11 @@ impl FabricMgr {
         self.changed
     }
 
-    pub fn add(&mut self, f: Fabric, mdns_mgr: &MdnsMgr) -> Result<u8, Error> {
+    pub fn add(&mut self, f: Fabric, mdns: &dyn Mdns) -> Result<u8, Error> {
         let slot = self.fabrics.iter().position(|x| x.is_none());
 
         if slot.is_some() || self.fabrics.len() < MAX_SUPPORTED_FABRICS {
-            mdns_mgr.publish_service(&f.mdns_service_name, ServiceMode::Commissioned)?;
+            mdns.add(&f.mdns_service_name, ServiceMode::Commissioned)?;
             self.changed = true;
 
             if let Some(index) = slot {
@@ -265,10 +265,10 @@ impl FabricMgr {
         }
     }
 
-    pub fn remove(&mut self, fab_idx: u8, mdns_mgr: &MdnsMgr) -> Result<(), Error> {
+    pub fn remove(&mut self, fab_idx: u8, mdns: &dyn Mdns) -> Result<(), Error> {
         if fab_idx > 0 && fab_idx as usize <= self.fabrics.len() {
             if let Some(f) = self.fabrics[(fab_idx - 1) as usize].take() {
-                mdns_mgr.unpublish_service(&f.mdns_service_name, ServiceMode::Commissioned)?;
+                mdns.remove(&f.mdns_service_name)?;
                 self.changed = true;
                 Ok(())
             } else {