pldm-file: use cumulative crc for multipart transfers

Regarding the part checksum field, DSP0240 says:

  32-bit cumulative CRC for the entirety of data received so far for this
  section (all parts concatenated together, excluding checksums). Shall be
  included with all part transfers.

So, we need to keep the checksum Digest around, and use the cumulative
value in responses & response checks.

We also shift the comment on restarting from a FIRST_PART, as it was
incorrectly placed in the non-restart case.

Signed-off-by: Jeremy Kerr <[email protected]>

Author: jk-ozlabs

pldm-file/src/client.rs

@@ -167,6 +167,8 @@ where
         req_offset,
         req_length,
     };
+    let crc32 = crc::Crc::<u32>::new(&crc::CRC_32_ISO_HDLC);
+    let mut digest = crc32.digest();
     loop {
         let mut tx_buf = [0; 18];
         let l = req.to_slice(&mut tx_buf).map_err(|_| PldmError::NoSpace)?;
@@ -196,12 +198,11 @@ where
 
         let (resp_data, resp_cs) = rest.split_at(resp_data_len);
 
-        let crc32 = crc::Crc::<u32>::new(&crc::CRC_32_ISO_HDLC);
-        let calc_cs = crc32.checksum(resp_data);
+        digest.update(resp_data);
         // unwrap: we have asserted the lengths above
         let cs = u32::from_le_bytes(resp_cs.try_into().unwrap());
 
-        if calc_cs != cs {
+        if digest.clone().finalize() != cs {
             return Err(proto_error!("data checksum mismatch"));
         }
 

pldm-file/src/host.rs

@@ -23,6 +23,9 @@ pub trait Host {
     fn read(&self, buf: &mut [u8], offset: usize) -> std::io::Result<usize>;
 }
 
+const CRC32: crc::Crc<u32, crc::Table<16>> =
+    crc::Crc::<u32, crc::Table<16>>::new(&crc::CRC_32_ISO_HDLC);
+
 // Created at the first stage (XFER_FIRST_PART) of a MultpartReceive,
 // where we have the offset and size.
 struct FileTransferContext {
@@ -31,6 +34,23 @@ struct FileTransferContext {
     len: usize,
     // Current transfer 0..len
     offset: usize,
+    digest: crc::Digest<'static, u32, crc::Table<16>>,
+}
+
+impl FileTransferContext {
+    fn new(start: usize, len: usize) -> Self {
+        Self {
+            start,
+            len,
+            offset: 0,
+            digest: CRC32.digest(),
+        }
+    }
+
+    fn reset(&mut self) {
+        self.offset = 0;
+        self.digest = CRC32.digest();
+    }
 }
 
 // Created on DfOpen
@@ -80,9 +100,6 @@ impl std::fmt::Display for PldmFileError {
     }
 }
 
-const CRC32: crc::Crc<u32, crc::Table<16>> =
-    crc::Crc::<u32, crc::Table<16>>::new(&crc::CRC_32_ISO_HDLC);
-
 type Result<T> = std::result::Result<T, PldmFileError>;
 
 impl<const N: usize> Responder<N> {
@@ -349,10 +366,10 @@ impl<const N: usize> Responder<N> {
         // Set new transfer context
         if cmd.xfer_op == pldm::control::xfer_op::FIRST_PART {
             if let Some(ctx) = file_ctx.xfer_ctx.as_mut() {
-                ctx.offset = 0;
+                // a repeated FIRST_PART is valid, and restarts the transfer
+                ctx.reset();
             } else {
                 let new_ctx = Self::init_read(&cmd)?;
-                // a repeated FIRST_PART is valid, and restarts the transfer
                 file_ctx.xfer_ctx.replace(new_ctx);
             };
         }
@@ -406,7 +423,8 @@ impl<const N: usize> Responder<N> {
         host.read(data, xfer_ctx.start + offset)
             .map_err(|_| CCode::ERROR)?;
 
-        let cs = CRC32.checksum(data);
+        xfer_ctx.digest.update(data);
+        let cs = xfer_ctx.digest.clone().finalize();
         resp_data.extend_from_slice(&cs.to_le_bytes());
 
         xfer_ctx.offset = offset;
@@ -421,11 +439,7 @@ impl<const N: usize> Responder<N> {
         trace!("init_read {req:?}");
         let start = req.req_offset as usize;
         let len = req.req_length as usize;
-        Ok(FileTransferContext {
-            start,
-            len,
-            offset: 0,
-        })
+        Ok(FileTransferContext::new(start, len))
     }
 }