Make Matter covariant over its lifetime

Author: ivmarkov

examples/onoff_light/src/main.rs

@@ -30,7 +30,7 @@ use matter::data_model::root_endpoint;
 use matter::data_model::system_model::descriptor;
 use matter::error::Error;
 use matter::interaction_model::core::InteractionModel;
-use matter::mdns::builtin::Mdns;
+use matter::mdns::builtin::{Mdns, MdnsRxBuf, MdnsTxBuf};
 use matter::persist;
 use matter::secure_channel::spake2p::VerifierData;
 use matter::transport::network::{Address, IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
@@ -46,7 +46,7 @@ mod dev_att;
 fn main() -> Result<(), Error> {
     let thread = std::thread::Builder::new()
         .stack_size(120 * 1024)
-        .spawn(move || run())
+        .spawn(run)
         .unwrap();
 
     thread.join().unwrap()
@@ -63,10 +63,10 @@ fn run() -> Result<(), Error> {
     initialize_logger();
 
     info!(
-        "Matter memory: mDNS={}, Transport={} (of which Matter={})",
+        "Matter memory: mDNS={}, Matter={}, Transport={}",
         core::mem::size_of::<Mdns>(),
-        core::mem::size_of::<Transport>(),
         core::mem::size_of::<Matter>(),
+        core::mem::size_of::<Transport>(),
     );
 
     let (ipv4_addr, ipv6_addr) = initialize_network()?;
@@ -78,15 +78,15 @@ fn run() -> Result<(), Error> {
         Some(ipv6_addr.octets()),
     );
 
-    let (mut mdns, mut mdns_runner) = mdns.split();
+    let (mdns, mut mdns_runner) = mdns.split();
     //let (mut mdns, mdns_runner) = (matter::mdns::astro::AstroMdns::new()?, core::future::pending::pending());
     //let (mut mdns, mdns_runner) = (matter::mdns::DummyMdns {}, core::future::pending::pending());
 
     let dev_att = dev_att::HardCodedDevAtt::new();
 
     let matter = Matter::new_default(
         // vid/pid should match those in the DAC
-        BasicInfoConfig {
+        &BasicInfoConfig {
             vid: 0xFFF1,
             pid: 0x8000,
             hw_ver: 2,
@@ -96,7 +96,7 @@ fn run() -> Result<(), Error> {
             device_name: "OnOff Light",
         },
         &dev_att,
-        &mut mdns,
+        &mdns,
         matter::MATTER_PORT,
     );
 
@@ -106,12 +106,13 @@ fn run() -> Result<(), Error> {
     let psm = persist::FilePsm::new(psm_path)?;
 
     let mut buf = [0; 4096];
+    let buf = &mut buf;
 
-    if let Some(data) = psm.load("acls", &mut buf)? {
+    if let Some(data) = psm.load("acls", buf)? {
         matter.load_acls(data)?;
     }
 
-    if let Some(data) = psm.load("fabrics", &mut buf)? {
+    if let Some(data) = psm.load("fabrics", buf)? {
         matter.load_fabrics(data)?;
     }
 
@@ -123,12 +124,33 @@ fn run() -> Result<(), Error> {
             verifier: VerifierData::new_with_pw(123456, *matter.borrow()),
             discriminator: 250,
         },
-        &mut buf,
+        buf,
     )?;
 
-    let matter = &matter;
+    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 handler = handler(&matter);
+
+    let mut im = InteractionModel(DataModel::new(matter.borrow(), &node, &mut handler));
+
+    let mut rx_buf = [0; MAX_RX_BUF_SIZE];
+    let mut tx_buf = [0; MAX_TX_BUF_SIZE];
+
+    let im = &mut im;
     let mdns_runner = &mut mdns_runner;
     let transport = &mut transport;
+    let rx_buf = &mut rx_buf;
+    let tx_buf = &mut tx_buf;
 
     let mut io_fut = pin!(async move {
         let udp = UdpListener::new(SocketAddr::new(
@@ -138,52 +160,29 @@ fn run() -> Result<(), Error> {
         .await?;
 
         loop {
-            let mut rx_buf = [0; MAX_RX_BUF_SIZE];
-            let mut tx_buf = [0; MAX_TX_BUF_SIZE];
+            let (len, addr) = udp.recv(rx_buf).await?;
 
-            let (len, addr) = udp.recv(&mut rx_buf).await?;
-
-            let mut completion =
-                transport.recv(Address::Udp(addr), &mut rx_buf[..len], &mut tx_buf);
+            let mut completion = transport.recv(Address::Udp(addr), &mut rx_buf[..len], tx_buf);
 
             while let Some(action) = completion.next_action()? {
                 match action {
                     RecvAction::Send(addr, buf) => {
                         udp.send(addr.unwrap_udp(), buf).await?;
                     }
                     RecvAction::Interact(mut ctx) => {
-                        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 handler = handler(matter);
-
-                        let mut im =
-                            InteractionModel(DataModel::new(matter.borrow(), &node, &mut handler));
-
-                        if im.handle(&mut ctx)? {
-                            if ctx.send()? {
-                                udp.send(ctx.tx.peer.unwrap_udp(), ctx.tx.as_slice())
-                                    .await?;
-                            }
+                        if im.handle(&mut ctx)? && ctx.send()? {
+                            udp.send(ctx.tx.peer.unwrap_udp(), ctx.tx.as_slice())
+                                .await?;
                         }
                     }
                 }
             }
 
-            if let Some(data) = transport.matter().store_fabrics(&mut buf)? {
+            if let Some(data) = transport.matter().store_fabrics(buf)? {
                 psm.store("fabrics", data)?;
             }
 
-            if let Some(data) = transport.matter().store_acls(&mut buf)? {
+            if let Some(data) = transport.matter().store_acls(buf)? {
                 psm.store("acls", data)?;
             }
         }
@@ -192,7 +191,12 @@ fn run() -> Result<(), Error> {
         Ok::<_, matter::error::Error>(())
     });
 
-    let mut mdns_fut = pin!(async move { mdns_runner.run().await });
+    let mut tx_buf = MdnsTxBuf::uninit();
+    let mut rx_buf = MdnsRxBuf::uninit();
+    let tx_buf = &mut tx_buf;
+    let rx_buf = &mut rx_buf;
+
+    let mut mdns_fut = pin!(async move { mdns_runner.run_udp(tx_buf, rx_buf).await });
 
     let mut fut = pin!(async move { select(&mut io_fut, &mut mdns_fut,).await.unwrap() });
 

matter/src/core.rs

@@ -48,10 +48,10 @@ pub struct Matter<'a> {
     pub acl_mgr: RefCell<AclMgr>,
     pub pase_mgr: RefCell<PaseMgr>,
     pub failsafe: RefCell<FailSafe>,
-    pub mdns_mgr: RefCell<MdnsMgr<'a>>,
+    pub mdns_mgr: MdnsMgr<'a>,
     pub epoch: Epoch,
     pub rand: Rand,
-    pub dev_det: BasicInfoConfig<'a>,
+    pub dev_det: &'a BasicInfoConfig<'a>,
     pub dev_att: &'a dyn DevAttDataFetcher,
     pub port: u16,
 }
@@ -60,9 +60,9 @@ impl<'a> Matter<'a> {
     #[cfg(feature = "std")]
     #[inline(always)]
     pub fn new_default(
-        dev_det: BasicInfoConfig<'a>,
+        dev_det: &'a BasicInfoConfig<'a>,
         dev_att: &'a dyn DevAttDataFetcher,
-        mdns: &'a mut dyn Mdns,
+        mdns: &'a dyn Mdns,
         port: u16,
     ) -> Self {
         use crate::utils::epoch::sys_epoch;
@@ -79,9 +79,9 @@ impl<'a> Matter<'a> {
     /// this object to return the device attestation details when queried upon.
     #[inline(always)]
     pub fn new(
-        dev_det: BasicInfoConfig<'a>,
+        dev_det: &'a BasicInfoConfig<'a>,
         dev_att: &'a dyn DevAttDataFetcher,
-        mdns: &'a mut dyn Mdns,
+        mdns: &'a dyn Mdns,
         epoch: Epoch,
         rand: Rand,
         port: u16,
@@ -91,13 +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: RefCell::new(MdnsMgr::new(
-                dev_det.vid,
-                dev_det.pid,
-                dev_det.device_name,
-                port,
-                mdns,
-            )),
+            mdns_mgr: MdnsMgr::new(dev_det.vid, dev_det.pid, dev_det.device_name, port, mdns),
             epoch,
             rand,
             dev_det,
@@ -107,7 +101,7 @@ impl<'a> Matter<'a> {
     }
 
     pub fn dev_det(&self) -> &BasicInfoConfig<'_> {
-        &self.dev_det
+        self.dev_det
     }
 
     pub fn dev_att(&self) -> &dyn DevAttDataFetcher {
@@ -119,9 +113,7 @@ impl<'a> Matter<'a> {
     }
 
     pub fn load_fabrics(&self, data: &[u8]) -> Result<(), Error> {
-        self.fabric_mgr
-            .borrow_mut()
-            .load(data, &mut self.mdns_mgr.borrow_mut())
+        self.fabric_mgr.borrow_mut().load(data, &self.mdns_mgr)
     }
 
     pub fn load_acls(&self, data: &[u8]) -> Result<(), Error> {
@@ -148,7 +140,7 @@ impl<'a> Matter<'a> {
         if !self.pase_mgr.borrow().is_pase_session_enabled() && self.fabric_mgr.borrow().is_empty()
         {
             print_pairing_code_and_qr(
-                &self.dev_det,
+                self.dev_det,
                 &dev_comm,
                 DiscoveryCapabilities::default(),
                 buf,
@@ -157,7 +149,7 @@ impl<'a> Matter<'a> {
             self.pase_mgr.borrow_mut().enable_pase_session(
                 dev_comm.verifier,
                 dev_comm.discriminator,
-                &mut self.mdns_mgr.borrow_mut(),
+                &self.mdns_mgr,
             )?;
 
             Ok(true)
@@ -191,12 +183,30 @@ impl<'a> Borrow<RefCell<FailSafe>> for Matter<'a> {
     }
 }
 
-impl<'a> Borrow<RefCell<MdnsMgr<'a>>> for Matter<'a> {
-    fn borrow(&self) -> &RefCell<MdnsMgr<'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
+    }
+}
+
+impl<'a> Borrow<dyn DevAttDataFetcher + 'a> for Matter<'a> {
+    fn borrow(&self) -> &(dyn DevAttDataFetcher + 'a) {
+        self.dev_att
+    }
+}
+
+impl<'a> Borrow<dyn Mdns + 'a> for Matter<'a> {
+    fn borrow(&self) -> &(dyn Mdns + 'a) {
+        self.mdns_mgr.mdns
+    }
+}
+
 impl<'a> Borrow<Epoch> for Matter<'a> {
     fn borrow(&self) -> &Epoch {
         &self.epoch

matter/src/data_model/root_endpoint.rs

@@ -7,7 +7,6 @@ use crate::{
     mdns::MdnsMgr,
     secure_channel::pake::PaseMgr,
     utils::{epoch::Epoch, rand::Rand},
-    Matter,
 };
 
 use super::{
@@ -55,11 +54,23 @@ pub fn endpoint(id: EndptId) -> Endpoint<'static> {
     }
 }
 
-pub fn handler<'a>(endpoint_id: u16, matter: &'a Matter<'a>) -> RootEndpointHandler<'a> {
+pub fn handler<'a, T>(endpoint_id: u16, matter: &'a T) -> RootEndpointHandler<'a>
+where
+    T: Borrow<BasicInfoConfig<'a>>
+        + Borrow<dyn DevAttDataFetcher + 'a>
+        + Borrow<RefCell<PaseMgr>>
+        + Borrow<RefCell<FabricMgr>>
+        + Borrow<RefCell<AclMgr>>
+        + Borrow<RefCell<FailSafe>>
+        + Borrow<MdnsMgr<'a>>
+        + Borrow<Epoch>
+        + Borrow<Rand>
+        + 'a,
+{
     wrap(
         endpoint_id,
-        matter.dev_det(),
-        matter.dev_att(),
+        matter.borrow(),
+        matter.borrow(),
         matter.borrow(),
         matter.borrow(),
         matter.borrow(),
@@ -79,7 +90,7 @@ pub fn wrap<'a>(
     fabric: &'a RefCell<FabricMgr>,
     acl: &'a RefCell<AclMgr>,
     failsafe: &'a RefCell<FailSafe>,
-    mdns_mgr: &'a RefCell<MdnsMgr<'a>>,
+    mdns_mgr: &'a MdnsMgr<'a>,
     epoch: Epoch,
     rand: Rand,
 ) -> RootEndpointHandler<'a> {

matter/src/data_model/sdm/admin_commissioning.rs

@@ -102,15 +102,11 @@ pub struct OpenCommWindowReq<'a> {
 pub struct AdminCommCluster<'a> {
     data_ver: Dataver,
     pase_mgr: &'a RefCell<PaseMgr>,
-    mdns_mgr: &'a RefCell<MdnsMgr<'a>>,
+    mdns_mgr: &'a MdnsMgr<'a>,
 }
 
 impl<'a> AdminCommCluster<'a> {
-    pub fn new(
-        pase_mgr: &'a RefCell<PaseMgr>,
-        mdns_mgr: &'a RefCell<MdnsMgr<'a>>,
-        rand: Rand,
-    ) -> Self {
+    pub fn new(pase_mgr: &'a RefCell<PaseMgr>, mdns_mgr: &'a MdnsMgr<'a>, rand: Rand) -> Self {
         Self {
             data_ver: Dataver::new(rand),
             pase_mgr,
@@ -159,7 +155,7 @@ impl<'a> AdminCommCluster<'a> {
         self.pase_mgr.borrow_mut().enable_pase_session(
             verifier,
             req.discriminator,
-            &mut self.mdns_mgr.borrow_mut(),
+            self.mdns_mgr,
         )?;
 
         Ok(())