Implemented CSPTP server functionality.

Author: davidv1992

statime-csptp/src/lib.rs

@@ -138,16 +138,41 @@ use statime_wire::{ClockIdentity, ClockQuality};
 #[cfg(feature = "std")]
 extern crate std;
 
+mod manager;
 mod messages;
+mod platform;
+mod server;
 
-// TODO: Figure out how to actually deal with the state.
-struct CsptpState {
-    grandmaster_identity: ClockIdentity,
-    grandmaster_priority_1: u8,
-    grandmaster_priority_2: u8,
-    grandmaster_clock_quality: ClockQuality,
-    steps_removed: u16,
-    ptp_timescale: bool,
-    time_traceable: bool,
-    frequency_traceable: bool,
+pub use manager::{CsptpConfig, CsptpManager};
+pub use platform::{InternalState, StateMutex};
+pub use server::{ServerRecvResult, ServerSocket, serve};
+
+/// Observable CSPTP state
+#[derive(Debug, Copy, Clone)]
+pub struct CsptpState {
+    /// Clock identity of grandmaster currently in use. This will be the local
+    /// clock identity if there is no upstream time source or the if the
+    /// upstream time source does not use CSPTP
+    pub grandmaster_identity: ClockIdentity,
+    /// Priority 1 for the grandmaster currently in use. This will be the local
+    /// value if there is no upstream time source or the if the upstream time
+    /// source does not use CSPTP
+    pub grandmaster_priority_1: u8,
+    /// Priority 2 for the grandmaster currently in use. This will be the local
+    /// value if there is no upstream time source or the if the upstream time
+    /// source does not use CSPTP
+    pub grandmaster_priority_2: u8,
+    /// Clock quality for the grandmaster currently in use. This will be the
+    /// local value if there is no upstream time source or the if the upstream
+    /// time source does not use CSPTP
+    pub grandmaster_clock_quality: ClockQuality,
+    /// Steps removed from the current grandmaster. Will be 0 if there is no
+    /// upstream time source or the upstream time source does not use CSPTP.
+    pub steps_removed: u16,
+    /// Whether the ptp timescale is in use.
+    pub ptp_timescale: bool,
+    /// Whether the current time is traceable.
+    pub time_traceable: bool,
+    /// Whether the current frequency is traceable.
+    pub frequency_traceable: bool,
 }

statime-csptp/src/manager.rs

@@ -0,0 +1,93 @@
+use ntp_proto::{ClockId, SourceType, TimeSnapshot};
+use statime_wire::{ClockIdentity, ClockQuality};
+
+use crate::{
+    CsptpState,
+    platform::{InternalState, StateMutex},
+};
+
+/// General configuration for the CSPTP protocol
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct CsptpConfig {
+    /// Identity of the local instance.
+    pub identity: ClockIdentity,
+    /// Priority 1 value to use for the local clock.
+    pub priority_1: u8,
+    /// Priority 2 value to use for the local clock.
+    pub priority_2: u8,
+    /// Quality of the local clock.
+    pub clock_quality: ClockQuality,
+    /// Whether the local time uses the ptp timescale.
+    pub ptp_timescale: bool,
+    /// Whether the local time is traceable.
+    pub time_traceable: bool,
+    /// Whether the local frequency is traceable.
+    pub frequency_traceable: bool,
+}
+
+impl Default for CsptpConfig {
+    fn default() -> Self {
+        Self {
+            identity: ClockIdentity::default(),
+            priority_1: 255,
+            priority_2: 255,
+            clock_quality: ClockQuality::default(),
+            ptp_timescale: true,
+            time_traceable: false,
+            frequency_traceable: false,
+        }
+    }
+}
+
+/// Manager for the CSPTP general protocol state.
+pub struct CsptpManager<Mutex> {
+    pub(crate) config: CsptpConfig,
+    pub(crate) state: Mutex,
+}
+
+impl<Mutex: StateMutex> CsptpManager<Mutex> {
+    /// Create a new CSPTP protocol manager.
+    #[must_use]
+    pub fn new(config: CsptpConfig) -> Self {
+        Self {
+            config,
+            state: Mutex::new(InternalState {
+                csptp_state: CsptpState {
+                    grandmaster_identity: config.identity,
+                    grandmaster_priority_1: config.priority_1,
+                    grandmaster_priority_2: config.priority_2,
+                    grandmaster_clock_quality: config.clock_quality,
+                    steps_removed: 0,
+                    ptp_timescale: config.ptp_timescale,
+                    time_traceable: config.time_traceable,
+                    frequency_traceable: config.frequency_traceable,
+                },
+                time_snapshot: TimeSnapshot::default(),
+                active_source: None,
+            }),
+        }
+    }
+
+    /// Update which sources are used for time synchronization.
+    pub fn update_used_sources(&self, mut sources: impl Iterator<Item = (ClockId, SourceType)>) {
+        let active_source = sources.next().map(|(clock_id, _)| clock_id);
+        self.state.with_mut(move |state| {
+            if state.active_source != active_source {
+                state.active_source = active_source;
+                state.csptp_state.grandmaster_identity = self.config.identity;
+                state.csptp_state.grandmaster_priority_1 = self.config.priority_1;
+                state.csptp_state.grandmaster_priority_2 = self.config.priority_2;
+                state.csptp_state.grandmaster_clock_quality = self.config.clock_quality;
+                state.csptp_state.ptp_timescale = self.config.ptp_timescale;
+                state.csptp_state.time_traceable = self.config.time_traceable;
+                state.csptp_state.frequency_traceable = self.config.frequency_traceable;
+            }
+        });
+    }
+
+    /// Observe the system state.
+    #[must_use]
+    pub fn observe(&self) -> CsptpState {
+        self.state.with_ref(|state| state.csptp_state)
+    }
+}

statime-csptp/src/messages.rs

@@ -13,6 +13,8 @@ use crate::{
 
 mod tlvs;
 
+pub(crate) const MAX_MESSAGE_SIZE: usize = 512;
+
 /// A message with additional restrictions to ensure it is a valid CSPTP Message.
 pub(crate) struct CsptpMessage<'a> {
     message: Message<'a>,
@@ -51,7 +53,6 @@ impl<'a> CsptpMessage<'a> {
     /// # Errors
     /// This returns an error when the provided buffer does not contain a valid
     /// PTP message, or when the provided message is incomplete.
-    #[expect(unused)]
     pub(crate) fn deserialize(buffer: &'a [u8]) -> Result<Self, statime_wire::Error> {
         let message = Message::deserialize(buffer)?;
         if message.header.sdo_id != SdoId::try_from(0x300).unwrap()
@@ -96,7 +97,6 @@ impl<'a> CsptpMessage<'a> {
         Ok(CsptpMessage { message })
     }
 
-    #[expect(unused)]
     pub(crate) fn is_request(&self) -> bool {
         matches!(self.message.body, MessageBody::Sync(_))
             && self
@@ -141,7 +141,6 @@ impl<'a> CsptpMessage<'a> {
     }
 
     /// Generate a response to a request. A buffer of 30 bytes will always be able to contain the response
-    #[expect(unused)]
     pub(crate) fn new_response(
         buffer: &'a mut [u8],
         request: &CsptpMessage<'_>,
@@ -202,7 +201,6 @@ impl<'a> CsptpMessage<'a> {
         })
     }
 
-    #[expect(unused)]
     pub(crate) fn new_follow_up(
         response: &CsptpMessage<'_>,
         send_timestamp: Timestamp,

statime-csptp/src/platform.rs

@@ -0,0 +1,61 @@
+use core::cell::RefCell;
+
+use ntp_proto::{ClockId, TimeSnapshot};
+
+use crate::CsptpState;
+
+/// Internal state used by CSPTP.
+///
+/// This is publicly nameable and visible to make [`StateMutex`] implementable
+/// outside of this crate.
+#[derive(Clone, Copy)]
+pub struct InternalState {
+    pub(crate) csptp_state: CsptpState,
+    pub(crate) time_snapshot: TimeSnapshot,
+    pub(crate) active_source: Option<ClockId>,
+}
+
+/// A mutex over a [`InternalState`]
+///
+/// This provides an abstraction for locking state in various environments.
+/// Implementations are provided for [`core::cell::RefCell`] and
+/// [`std::sync::RwLock`].
+pub trait StateMutex {
+    /// Creates a new instance of the mutex
+    fn new(state: InternalState) -> Self;
+
+    /// Takes a shared reference to the contained state and calls `f` with it
+    fn with_ref<R, F: FnOnce(&InternalState) -> R>(&self, f: F) -> R;
+
+    /// Takes a mutable reference to the contained state and calls `f` with it
+    fn with_mut<R, F: FnOnce(&mut InternalState) -> R>(&self, f: F) -> R;
+}
+
+impl StateMutex for RefCell<InternalState> {
+    fn new(state: InternalState) -> Self {
+        RefCell::new(state)
+    }
+
+    fn with_ref<R, F: FnOnce(&InternalState) -> R>(&self, f: F) -> R {
+        f(&RefCell::borrow(self))
+    }
+
+    fn with_mut<R, F: FnOnce(&mut InternalState) -> R>(&self, f: F) -> R {
+        f(&mut RefCell::borrow_mut(self))
+    }
+}
+
+#[cfg(feature = "std")]
+impl StateMutex for std::sync::RwLock<InternalState> {
+    fn new(state: InternalState) -> Self {
+        std::sync::RwLock::new(state)
+    }
+
+    fn with_ref<R, F: FnOnce(&InternalState) -> R>(&self, f: F) -> R {
+        f(&self.read().unwrap())
+    }
+
+    fn with_mut<R, F: FnOnce(&mut InternalState) -> R>(&self, f: F) -> R {
+        f(&mut self.write().unwrap())
+    }
+}