wip: squashme: encode/decode

Signed-off-by: leongross <[email protected]>

Author: leongross

Cargo.lock

@@ -7,3 +7,4 @@ edition = "2024"
 [dependencies]
 zerocopy = {version = "0.8.17", features = ["derive"]}
 bitfield = "0.14.0"
+bytemuck = "1.24.0"

Cargo.toml

@@ -6,6 +6,7 @@ use zerocopy::{FromBytes, Immutable, IntoBytes};
 pub enum PldmCodecError {
     BufferTooShort,
     Unsupported,
+    InvalidData,
 }
 
 /// A trait for encoding and decoding PLDM (Platform Level Data Model) messages.
@@ -67,6 +68,9 @@ pub trait PldmCodecWithLifetime<'a>: core::fmt::Debug + Sized {
 }
 
 // Default implementation of PldmCodec for types that can leverage zerocopy.
+// TODO: can we generalize this to use sub-struct encodes when possible?
+// There are structs like PldmFirmwareString that contain variable-length data
+// that would need special handling.
 impl<T> PldmCodec for T
 where
     T: core::fmt::Debug + Sized + FromBytes + IntoBytes + Immutable,

src/codec.rs

@@ -331,31 +331,34 @@ mod test {
     }
 
     #[test]
-    fn test_get_firmware_parameters_request() {
+    fn test_get_firmware_parameters_request_codec() {
         let request = GetFirmwareParametersRequest::new(0, PldmMsgType::Request);
         let mut buffer = [0u8; PLDM_MSG_HEADER_LEN];
         request.encode(&mut buffer).unwrap();
+
         let decoded_request = GetFirmwareParametersRequest::decode(&buffer).unwrap();
         assert_eq!(request, decoded_request);
     }
 
     #[test]
-    fn test_get_firmware_parameters() {
+    fn test_get_firmware_parameters_codec() {
         let firmware_parameters = construct_firmware_params();
         let mut buffer = [0u8; 1024];
         let size = firmware_parameters.encode(&mut buffer).unwrap();
         assert_eq!(size, firmware_parameters.codec_size_in_bytes());
+
         let decoded_firmware_parameters = FirmwareParameters::decode(&buffer[..size]).unwrap();
         assert_eq!(firmware_parameters, decoded_firmware_parameters);
     }
 
     #[test]
-    fn test_get_firmware_parameters_response() {
+    fn test_get_firmware_parameters_response_codec() {
         let firmware_parameters = construct_firmware_params();
         let response = GetFirmwareParametersResponse::new(0, 0, &firmware_parameters);
         let mut buffer = [0u8; 1024];
         let size = response.encode(&mut buffer).unwrap();
         assert_eq!(size, response.codec_size_in_bytes());
+
         let decoded_response = GetFirmwareParametersResponse::decode(&buffer[..size]).unwrap();
         assert_eq!(response, decoded_response);
     }

src/message/firmware_update/get_fw_params.rs

@@ -283,6 +283,72 @@ impl<'a> GetDeviceMetaDataResponse<'a> {
     }
 }
 
+impl<'a> PldmCodecWithLifetime<'a> for GetDeviceMetaDataResponse<'a> {
+    fn encode(&self, buffer: &mut [u8]) -> Result<usize, PldmCodecError> {
+        let size = core::mem::size_of::<Self>() - core::mem::size_of::<&'a [u8]>();
+        if buffer.len() < size + self.portion_of_device_metadata.len() {
+            return Err(PldmCodecError::BufferTooShort);
+        }
+
+        let mut offset = 0;
+        self.hdr
+            .write_to_prefix(&mut buffer[offset..])
+            .map_err(|_| PldmCodecError::BufferTooShort)?;
+        offset += PLDM_MSG_HEADER_LEN;
+
+        buffer[offset] = self.completion_code;
+        offset += 1;
+
+        buffer[offset..offset + size_of::<u32>()]
+            .copy_from_slice(&self.next_data_transfer_handle.to_le_bytes());
+        offset += size_of::<u32>();
+
+        buffer[offset] = self.transfer_flag;
+        offset += size_of::<u8>();
+
+        buffer[offset..offset + self.portion_of_device_metadata.len()]
+            .copy_from_slice(self.portion_of_device_metadata);
+
+        Ok(size)
+    }
+
+    fn decode(buffer: &'a [u8]) -> Result<Self, PldmCodecError> {
+        let size = core::mem::size_of::<Self>() - core::mem::size_of::<&'a [u8]>();
+        if buffer.len() < size {
+            return Err(PldmCodecError::BufferTooShort);
+        }
+
+        let mut offset = 0;
+        let hdr = PldmMsgHeader::read_from_prefix(&buffer[offset..])
+            .map_err(|_| PldmCodecError::BufferTooShort)?
+            .0;
+        offset += PLDM_MSG_HEADER_LEN;
+
+        let completion_code = buffer[offset];
+        offset += size_of::<u8>();
+
+        let next_data_transfer_handle = u32::from_le_bytes(
+            buffer[offset..offset + 4]
+                .try_into()
+                .map_err(|_| PldmCodecError::BufferTooShort)?,
+        );
+        offset += size_of::<u32>();
+
+        let transfer_flag = buffer[offset];
+        offset += size_of::<u8>();
+
+        let portion_of_device_metadata = &buffer[offset..];
+
+        Ok(Self {
+            hdr,
+            completion_code,
+            next_data_transfer_handle,
+            transfer_flag,
+            portion_of_device_metadata,
+        })
+    }
+}
+
 /// The FD sends this command to transfer the data that was originally obtained by the UA through the
 /// [GetDeviceMetaData] command. This command shall only be used if the FD indicated in the
 /// [RequestUpdate] response that it had device metadata that needed to be obtained by the UA. The FD can
@@ -438,7 +504,7 @@ mod tests {
     use crate::codec::PldmCodec;
 
     #[test]
-    fn test_get_package_data_request() {
+    fn test_get_package_data_request_codec() {
         let instance_id: InstanceId = 0x01;
         let data_transfer_handle: u32 = 0x12345678;
         let transfer_operation_flag = TransferOperationFlag::GetFirstPart;
@@ -454,7 +520,7 @@ mod tests {
     }
 
     #[test]
-    fn test_get_package_data_response() {
+    fn test_get_package_data_response_codec() {
         const PORTION_LEN: usize = 10;
 
         let instance_id: InstanceId = 0x01;
@@ -475,15 +541,13 @@ mod tests {
             - core::mem::size_of::<usize>()
             + PORTION_LEN];
 
-        dbg!(&buffer_fitted.len());
-
         resp.encode(&mut buffer_fitted).unwrap();
         let decoded = GetPackageDataResponse::decode(&buffer_fitted).unwrap();
         assert_eq!(resp, decoded);
     }
 
     #[test]
-    fn test_get_device_metadata_request() {
+    fn test_get_metadata_request_codec() {
         let instance_id: InstanceId = 0x01;
         let data_transfer_handle = 0x12345678;
         let req = GetMetaDataRequest::new(
@@ -500,7 +564,7 @@ mod tests {
     }
 
     #[test]
-    fn test_get_device_metadata_response() {
+    fn test_get_meta_data_response_codec() {
         let instance_id: InstanceId = 0x01;
         let data_transfer_handle = 0x12345678;
         let payload = [11u8; 20];
@@ -513,10 +577,52 @@ mod tests {
             &payload,
         );
 
-        let mut buffer = [0u8; 9 + 20];
+        let mut buffer =
+            [0u8; core::mem::size_of::<GetMetaDataResponse>() - core::mem::size_of::<&[u8]>() + 20];
         resp.encode(&mut buffer).unwrap();
 
         let decoded = GetMetaDataResponse::decode(&mut buffer).unwrap();
         assert_eq!(resp, decoded);
     }
+
+    #[test]
+    fn test_get_device_meta_data_request_codec() {
+        let instance_id: InstanceId = 0x01;
+        let data_transfer_handle = 0x12345678;
+        let req = GetDeviceMetaDataRequest::new(
+            instance_id,
+            data_transfer_handle,
+            TransferOperationFlag::GetFirstPart,
+        );
+
+        let mut buffer = [0u8; core::mem::size_of::<GetDeviceMetaDataRequest>()];
+        req.encode(&mut buffer).unwrap();
+
+        let decoded = GetDeviceMetaDataRequest::decode(&buffer).unwrap();
+        assert_eq!(req, decoded);
+    }
+
+    #[test]
+    fn test_get_device_meta_data_response_codec() {
+        let instance_id: InstanceId = 0x01;
+        let data_transfer_handle = 0x12345678;
+        const TEST_PAYLOAD_LEN: usize = 20;
+        let payload = [11u8; TEST_PAYLOAD_LEN];
+
+        let resp = GetDeviceMetaDataResponse::new(
+            instance_id,
+            GetDeviceMetaDataCodes::BaseCodes(PldmBaseCompletionCode::Success),
+            data_transfer_handle,
+            TransferOperationFlag::GetFirstPart,
+            &payload,
+        );
+
+        let mut buffer = [0u8; core::mem::size_of::<GetDeviceMetaDataResponse>()
+            - core::mem::size_of::<&[u8]>()
+            + TEST_PAYLOAD_LEN];
+        resp.encode(&mut buffer).unwrap();
+
+        let decoded = GetDeviceMetaDataResponse::decode(&mut buffer).unwrap();
+        assert_eq!(resp, decoded);
+    }
 }

src/message/firmware_update/get_package_data.rs

@@ -189,7 +189,7 @@ mod test {
     use crate::codec::PldmCodec;
 
     #[test]
-    fn test_get_status_request() {
+    fn test_get_status_request_codec() {
         let instance_id = 1;
         let msg_type = PldmMsgType::Request;
         let request = GetStatusRequest::new(instance_id, msg_type);
@@ -202,7 +202,7 @@ mod test {
     }
 
     #[test]
-    fn test_get_status_response() {
+    fn test_get_status_response_codec() {
         let response = GetStatusResponse::new(
             1,
             0,

src/message/firmware_update/get_status.rs

@@ -154,7 +154,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_pass_component_table_request() {
+    fn test_pass_component_table_request_codec() {
         let request = PassComponentTableRequest::new(
             1,
             PldmMsgType::Request,
@@ -173,7 +173,7 @@ mod tests {
     }
 
     #[test]
-    fn test_pass_component_table_response() {
+    fn test_pass_component_table_response_codec() {
         let response = PassComponentTableResponse::new(
             0,
             0,

src/message/firmware_update/pass_component.rs

@@ -214,7 +214,7 @@ mod test {
     use crate::protocol::firmware_update::{Descriptor, DescriptorType};
 
     #[test]
-    fn test_query_device_identifiers_resp() {
+    fn test_query_device_identifiers_resp_codec() {
         let instance_id = 0;
         let completion_code = 0;