Get rid of the Epoch for most use cases

Author: ivmarkov

rs-matter/src/dm.rs

@@ -18,7 +18,6 @@
 use core::future::Future;
 use core::num::NonZeroU8;
 use core::pin::pin;
-use core::time::Duration;
 
 use embassy_futures::select::select3;
 use embassy_time::{Instant, Timer};
@@ -375,7 +374,7 @@ where
     async fn write(
         &self,
         exchange: &mut Exchange<'_>,
-        timeout_instant: Option<Duration>,
+        timeout_instant: Option<Instant>,
         is_groupcast: bool,
     ) -> Result<(), Error> {
         while exchange.rx().is_ok() {
@@ -418,7 +417,7 @@ where
     async fn invoke(
         &self,
         exchange: &mut Exchange<'_>,
-        timeout_instant: Option<Duration>,
+        timeout_instant: Option<Instant>,
         is_groupcast: bool,
     ) -> Result<(), Error> {
         let Some((mut tx, rx)) = self.buffers(exchange).await? else {
@@ -725,11 +724,11 @@ where
     }
 
     /// Process a `TimedReq` request, which is used to set a timeout for the following Write/Invoke request.
-    async fn timed(&self, exchange: &mut Exchange<'_>) -> Result<Duration, Error> {
+    async fn timed(&self, exchange: &mut Exchange<'_>) -> Result<Instant, Error> {
         let req = TimedReq::from_tlv(&get_root_node_struct(exchange.rx()?.payload())?)?;
         debug!("IM: Timed request: {:?}", req);
 
-        let timeout_instant = req.timeout_instant(exchange.matter().epoch());
+        let timeout_instant = req.timeout_instant();
 
         Self::send_status(exchange, IMStatusCode::Success).await?;
 
@@ -740,14 +739,14 @@ where
     async fn timed_out(
         &self,
         exchange: &mut Exchange<'_>,
-        timeout_instant: Option<Duration>,
+        timeout_instant: Option<Instant>,
         timed_req: bool,
     ) -> Result<bool, Error> {
         let status = {
             if timed_req != timeout_instant.is_some() {
                 Some(IMStatusCode::TimedRequestMisMatch)
             } else if timeout_instant
-                .map(|timeout_instant| (exchange.matter().epoch())() > timeout_instant)
+                .map(|timeout_instant| Instant::now() > timeout_instant)
                 .unwrap_or(false)
             {
                 Some(IMStatusCode::Timeout)

rs-matter/src/failsafe.rs

@@ -16,7 +16,8 @@
  */
 
 use core::num::NonZeroU8;
-use core::time::Duration;
+
+use embassy_time::{Duration, Instant};
 
 use crate::cert::{CertRef, MAX_CERT_TLV_LEN};
 use crate::crypto::{
@@ -34,7 +35,6 @@ use crate::sc::pase::Pase;
 use crate::tlv::TLVElement;
 use crate::transport::session::SessionMode;
 use crate::utils::bitflags::bitflags;
-use crate::utils::epoch::Epoch;
 use crate::utils::init::{init, Init};
 use crate::utils::storage::Vec;
 
@@ -53,7 +53,7 @@ bitflags! {
 
 #[derive(PartialEq)]
 pub struct ArmedCtx {
-    armed_at: Duration,
+    armed_at: Instant,
     timeout_secs: u16,
     fab_idx: u8,
     flags: NocFlags,
@@ -91,28 +91,25 @@ pub struct FailSafe {
     state: State,
     secret_key: CanonPkcSecretKey,
     root_ca: Vec<u8, { MAX_CERT_TLV_LEN }>,
-    epoch: Epoch,
     breadcrumb: u64,
 }
 
 impl FailSafe {
     #[inline(always)]
-    pub const fn new(epoch: Epoch) -> Self {
+    pub const fn new() -> Self {
         Self {
             state: State::Idle,
             secret_key: PKC_SECRET_KEY_ZEROED,
             root_ca: Vec::new(),
-            epoch,
             breadcrumb: 0,
         }
     }
 
-    pub fn init(epoch: Epoch) -> impl Init<Self> {
+    pub fn init() -> impl Init<Self> {
         init!(Self {
             state: State::Idle,
             secret_key <- CanonPkcSecretKey::init(),
             root_ca <- Vec::init(),
-            epoch,
             breadcrumb: 0
         })
     }
@@ -136,8 +133,12 @@ impl FailSafe {
         N: NetworksAccess,
     {
         if let State::Armed(ctx) = &self.state {
-            let now = (self.epoch)();
-            if now >= ctx.armed_at + Duration::from_secs(ctx.timeout_secs as u64) {
+            let now = Instant::now();
+            if now
+                >= ctx
+                    .armed_at
+                    .saturating_add(Duration::from_secs(ctx.timeout_secs as u64))
+            {
                 // Timeout path: no caller exchange to preserve, so wipe
                 // every PASE session along with the fabric / networks
                 // rollback.
@@ -270,7 +271,7 @@ impl FailSafe {
             // }
 
             self.state = State::Armed(ArmedCtx {
-                armed_at: (self.epoch)(),
+                armed_at: Instant::now(),
                 timeout_secs,
                 fab_idx: session_mode.fab_idx(),
                 flags: NocFlags::empty(),
@@ -295,7 +296,7 @@ impl FailSafe {
         };
 
         if timeout_secs > 0 {
-            ctx.armed_at = (self.epoch)();
+            ctx.armed_at = Instant::now();
             ctx.timeout_secs = timeout_secs;
             self.breadcrumb = breadcrumb;
         } else {
@@ -802,3 +803,9 @@ impl FailSafe {
         }
     }
 }
+
+impl Default for FailSafe {
+    fn default() -> Self {
+        Self::new()
+    }
+}

rs-matter/src/im/timed.rs

@@ -17,12 +17,11 @@
 
 //! This module contains types related to the Timed Request feature in the Matter Interaction Model.
 
-use core::time::Duration;
+use embassy_time::{Duration, Instant};
 
 use crate::dm::GlobalElements;
 use crate::im::IM_REVISION;
 use crate::tlv::{FromTLV, ToTLV};
-use crate::utils::epoch::Epoch;
 
 /// A structure representing a timed request in the Interaction Model.
 ///
@@ -48,9 +47,11 @@ impl TimedReq {
         }
     }
 
-    /// Returns the moment in time - since the system epoch - when the request
-    /// following this timed request should be considered expired.
-    pub fn timeout_instant(&self, epoch: Epoch) -> Duration {
-        unwrap!(epoch().checked_add(Duration::from_millis(self.timeout as _)))
+    /// Returns the monotonic [`Instant`] at which the request following this
+    /// timed request should be considered expired.
+    ///
+    /// Saturates to [`Instant::MAX`] if the addition would overflow.
+    pub fn timeout_instant(&self) -> Instant {
+        Instant::now().saturating_add(Duration::from_millis(self.timeout as _))
     }
 }

rs-matter/src/lib.rs

@@ -204,7 +204,7 @@ impl<'a> Matter<'a> {
         port: u16,
     ) -> Self {
         Self {
-            state: Mutex::new(RefCell::new(MatterState::new(epoch))),
+            state: Mutex::new(RefCell::new(MatterState::new())),
             transport: Transport::new(dev_det),
             mdns_changed: Notification::new(),
             session_removed: Notification::new(),
@@ -261,7 +261,7 @@ impl<'a> Matter<'a> {
     ) -> impl Init<Self> {
         init!(
             Self {
-                state <- Mutex::init(RefCell::init(MatterState::init(epoch))),
+                state <- Mutex::init(RefCell::init(MatterState::init())),
                 transport <- Transport::init(dev_det),
                 mdns_changed: Notification::new(),
                 session_removed: Notification::new(),
@@ -704,23 +704,23 @@ pub struct MatterState {
 impl MatterState {
     /// Create a new instance of MatterState
     #[inline(always)]
-    const fn new(epoch: Epoch) -> Self {
+    const fn new() -> Self {
         Self {
             fabrics: Fabrics::new(),
-            sessions: Sessions::new(epoch),
-            pase: Pase::new(epoch),
-            failsafe: FailSafe::new(epoch),
+            sessions: Sessions::new(),
+            pase: Pase::new(),
+            failsafe: FailSafe::new(),
             basic_info_settings: BasicInfoSettings::new(),
         }
     }
 
     /// Return an in-place initializer for MatterState
-    fn init(epoch: Epoch) -> impl Init<Self> {
+    fn init() -> impl Init<Self> {
         init!(Self {
             fabrics <- Fabrics::init(),
-            sessions <- Sessions::init(epoch),
-            pase <- Pase::init(epoch),
-            failsafe <- FailSafe::init(epoch),
+            sessions <- Sessions::init(),
+            pase <- Pase::init(),
+            failsafe <- FailSafe::init(),
             basic_info_settings <- BasicInfoSettings::init(),
         })
     }

rs-matter/src/sc/pase.rs

@@ -21,8 +21,8 @@
 //! of the PASE protocol for establishing secure sessions using a shared passcode.
 
 use core::num::NonZeroU8;
-use core::ops::Add;
-use core::time::Duration;
+
+use embassy_time::{Duration, Instant};
 
 use crate::dm::clusters::adm_comm::{self};
 use crate::dm::endpoints::ROOT_ENDPOINT_ID;
@@ -34,7 +34,6 @@ use crate::sc::pase::spake2p::{
 use crate::sc::SessionParameters;
 use crate::tlv::{FromTLV, OctetStr, ToTLV};
 use crate::transport::exchange::{Exchange, ExchangeId};
-use crate::utils::epoch::Epoch;
 use crate::utils::init::{init, Init};
 use crate::utils::maybe::Maybe;
 use crate::MatterService;
@@ -95,7 +94,7 @@ pub struct CommWindow {
     /// The opener info
     opener: Option<CommWindowOpener>,
     /// The window expiry instant
-    window_expiry: Duration,
+    window_expiry: Instant,
     /// Number of failed PAKE handshake attempts within this window.
     /// Per Matter Core spec section 11.18.6.1.5, the window SHALL be
     /// revoked after 20 unsuccessful handshakes.
@@ -118,7 +117,7 @@ impl CommWindow {
         salt: Spake2pVerifierSaltRef<'a>,
         discriminator: u16,
         opener: Option<CommWindowOpener>,
-        window_expiry: Duration,
+        window_expiry: Instant,
     ) -> impl Init<Self> + 'a {
         init!(Self {
             mdns_id,
@@ -146,7 +145,7 @@ impl CommWindow {
         count: u32,
         discriminator: u16,
         opener: Option<CommWindowOpener>,
-        window_expiry: Duration,
+        window_expiry: Instant,
     ) -> impl Init<Self> + 'a {
         init!(Self {
             mdns_id,
@@ -189,34 +188,23 @@ pub struct Pase {
     /// The (one and only) PASE session timeout tracker
     /// If there is no active PASE session, this is `None`
     pub(crate) session_timeout: Option<SessionEstTimeout>,
-    /// The epoch function
-    pub(crate) epoch: Epoch,
 }
 
 impl Pase {
     /// Create a new PASE state
-    ///
-    /// # Arguments
-    /// - `epoch` - The epoch function
     #[inline(always)]
-    pub const fn new(epoch: Epoch) -> Self {
+    pub const fn new() -> Self {
         Self {
             comm_window: Maybe::none(),
             session_timeout: None,
-            epoch,
         }
     }
 
     /// Return an in-place initializer for the PASE manager
-    ///
-    /// # Arguments
-    /// - `epoch` - The epoch function
-    /// - `rand` - The random number generator
-    pub fn init(epoch: Epoch) -> impl Init<Self> {
+    pub fn init() -> impl Init<Self> {
         init!(Self {
             comm_window <- Maybe::init_none(),
             session_timeout: None,
-            epoch,
         })
     }
 
@@ -232,7 +220,7 @@ impl Pase {
         let expired = self
             .comm_window
             .as_opt_ref()
-            .map(|comm_window| (self.epoch)() > comm_window.window_expiry)
+            .map(|comm_window| Instant::now() > comm_window.window_expiry)
             .unwrap_or(false);
 
         if expired {
@@ -285,7 +273,7 @@ impl Pase {
             Err(ErrorCode::InvalidCommand)?;
         }
 
-        let window_expiry = (self.epoch)().add(Duration::from_secs(timeout_secs as _));
+        let window_expiry = Instant::now().saturating_add(Duration::from_secs(timeout_secs as _));
 
         self.comm_window
             .reinit(Maybe::init_some(CommWindow::init_with_pw(
@@ -342,7 +330,7 @@ impl Pase {
             Err(ErrorCode::InvalidCommand)?;
         }
 
-        let window_expiry = (self.epoch)().add(Duration::from_secs(timeout_secs as _));
+        let window_expiry = Instant::now().saturating_add(Duration::from_secs(timeout_secs as _));
 
         self.comm_window.reinit(Maybe::init_some(CommWindow::init(
             mdns_id,
@@ -433,6 +421,12 @@ impl Pase {
     }
 }
 
+impl Default for Pase {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 /// The timeout tracker for a PASE session establishment
 const PASE_SESSION_EST_TIMEOUT_SECS: Duration = Duration::from_secs(60);
 
@@ -442,30 +436,23 @@ pub(crate) const SPAKE2_SESSION_KEYS_INFO: &[u8] = b"SessionKeys";
 /// The PASE session establishment timeout tracker
 pub(crate) struct SessionEstTimeout {
     /// The session expiry instant
-    session_est_expiry: Duration,
+    session_est_expiry: Instant,
     /// The exchange identifier
     pub(crate) exch_id: ExchangeId,
 }
 
 impl SessionEstTimeout {
-    /// Create a new session establishment timeout tracker
-    ///
-    /// # Arguments
-    /// - `exchange` - The exchange
-    /// - `epoch` - The epoch function
-    pub(crate) fn new(exchange: &Exchange, epoch: Epoch) -> Self {
+    /// Create a new session establishment timeout tracker.
+    pub(crate) fn new(exchange: &Exchange) -> Self {
         Self {
-            session_est_expiry: epoch().add(PASE_SESSION_EST_TIMEOUT_SECS),
+            session_est_expiry: Instant::now().saturating_add(PASE_SESSION_EST_TIMEOUT_SECS),
             exch_id: exchange.id(),
         }
     }
 
-    /// Check if the session establishment has expired
-    ///
-    /// # Arguments
-    /// - `epoch` - The current epoch
-    pub(crate) fn is_sess_expired(&self, epoch: Epoch) -> bool {
-        epoch() > self.session_est_expiry
+    /// Check if the session establishment has expired.
+    pub(crate) fn is_sess_expired(&self) -> bool {
+        Instant::now() > self.session_est_expiry
     }
 }