pldm-platform: Add chrono conversion for Timestamp104

The PLDM file host example now sets updateTime to the local time
for testing purposes.

Signed-off-by: Matt Johnston <[email protected]>

Author: mkj

Cargo.lock

@@ -19,6 +19,7 @@ pldm = { workspace = true }
 
 [dev-dependencies]
 anyhow = "1.0"
+chrono = { workspace = true }
 mctp-linux = { workspace = true }
 pldm-platform = { workspace = true, features = ["alloc"] }
 smol = "2.0"

pldm-file/Cargo.toml

@@ -105,12 +105,16 @@ async fn handle_platform<R: AsyncRespChannel>(
 
     let mut resp = req.response();
 
+    let update_time =
+        Timestamp104::try_from(&chrono::Local::now().fixed_offset())
+            .unwrap_or_default();
+
     resp.cc = match Cmd::try_from(req.cmd)? {
         Cmd::GetPDRRepositoryInfo => {
             let pdrinfo = GetPDRRepositoryInfoResp {
                 state: PDRRepositoryState::Available,
-                update_time: [0u8; 13],
-                oem_update_time: [0u8; 13],
+                update_time,
+                oem_update_time: Default::default(),
                 record_count: 1,
                 // TODO. "An implementation is allowed to round this number up to the nearest kilobyte (1024 bytes)."
                 repository_size: 1024,

pldm-file/examples/host.rs

@@ -8,6 +8,7 @@ repository.workspace = true
 categories = ["network-programming", "embedded", "hardware-support"]
 
 [dependencies]
+chrono = { workspace = true }
 deku = { workspace = true }
 heapless = { workspace = true }
 log = { workspace = true }

pldm-platform/Cargo.toml

@@ -13,6 +13,8 @@ use deku::{
     DekuReader, DekuUpdate, DekuWrite, DekuWriter,
 };
 
+use chrono::{DateTime, Datelike, FixedOffset, TimeDelta, TimeZone, Timelike};
+
 use pldm::control::xfer_flag;
 use pldm::{proto_error, PldmError, PldmResult};
 
@@ -531,7 +533,77 @@ pub enum PDRRepositoryState {
 }
 
 // TODO
-pub type Timestamp104 = [u8; 13];
+#[deku_derive(DekuRead, DekuWrite)]
+#[derive(Clone, PartialEq, Eq, Default)]
+pub struct Timestamp104(pub [u8; 13]);
+
+impl core::fmt::Debug for Timestamp104 {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        if let Ok(dt) = DateTime::<FixedOffset>::try_from(self) {
+            write!(f, "Timestamp104({dt:?})")
+        } else {
+            write!(f, "Timestamp104(invalid {:?})", self.0)
+        }
+    }
+}
+
+impl TryFrom<&Timestamp104> for DateTime<FixedOffset> {
+    type Error = ();
+
+    fn try_from(t: &Timestamp104) -> Result<Self, Self::Error> {
+        let t = &t.0;
+        let tz = i16::from_le_bytes(t[..=1].try_into().unwrap());
+        let tz = FixedOffset::east_opt(tz as i32 * 60).ok_or_else(|| {
+            trace!("Bad timezone {tz}");
+        })?;
+        let year = u16::from_le_bytes(t[10..=11].try_into().unwrap());
+        let dt = tz
+            .with_ymd_and_hms(
+                year as i32,
+                t[9] as u32,
+                t[8] as u32,
+                t[7] as u32,
+                t[6] as u32,
+                t[5] as u32,
+            )
+            .earliest()
+            .ok_or_else(|| {
+                trace!("Bad timestamp");
+            })?;
+        // read a u32 and mask to 24 bit
+        let micros =
+            u32::from_le_bytes(t[2..=5].try_into().unwrap()) & 0xffffff;
+        let dt = dt + TimeDelta::microseconds(micros as i64);
+        Ok(dt)
+    }
+}
+
+impl TryFrom<&DateTime<FixedOffset>> for Timestamp104 {
+    type Error = ();
+
+    fn try_from(dt: &DateTime<FixedOffset>) -> Result<Self, Self::Error> {
+        let mut t = [0; 13];
+        let off = dt.offset().local_minus_utc() as u16;
+        t[0..=1].copy_from_slice(&off.to_le_bytes());
+
+        let date = dt.date_naive();
+        let time = dt.time();
+        // can be > 1e9 for leap seconds, discard that.
+        let micros = (time.nanosecond() % 1_000_000_000) / 1000;
+        t[2..=4].copy_from_slice(&micros.to_le_bytes()[..3]);
+        t[5] = time.second() as u8;
+        t[6] = time.minute() as u8;
+        t[7] = time.hour() as u8;
+        t[8] = date.day() as u8;
+        t[9] = date.month() as u8;
+        let year: u16 = date.year().try_into().map_err(|_| {
+            trace!("Year out of range");
+        })?;
+        t[10..=11].copy_from_slice(&year.to_le_bytes());
+
+        Ok(Timestamp104(t))
+    }
+}
 
 #[deku_derive(DekuRead, DekuWrite)]
 #[derive(Debug, Clone, PartialEq, Eq)]