Add Definition for vdm errors and propagate the vdm upward in responder

Author: IntelCaisui

spdmlib/src/error.rs

@@ -244,6 +244,23 @@ impl Default for StatusCodeRNG {
     }
 }
 
+#[allow(dead_code)]
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
+pub struct StatusCodeVdmError {
+    pub vdm_error_code: u16,
+}
+
+impl TryFrom<u16> for StatusCodeVdmError {
+    type Error = ();
+
+    fn try_from(value: u16) -> core::result::Result<Self, Self::Error> {
+        Ok(Self {
+            vdm_error_code: value,
+        })
+    }
+}
+
 #[allow(dead_code)]
 #[allow(non_camel_case_types)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
@@ -255,6 +272,7 @@ pub enum StatusCode {
     TRANSPORT(StatusCodeTransport),
     MEAS_COLLECT(StatusCodeMeasCollect),
     RNG(StatusCodeRNG),
+    VDM(StatusCodeVdmError),
 }
 
 impl Default for StatusCode {
@@ -279,6 +297,7 @@ impl TryFrom<u24> for StatusCode {
                 code,
             )?)),
             6 => Ok(StatusCode::RNG(StatusCodeRNG::try_from(code)?)),
+            7 => Ok(StatusCode::VDM(StatusCodeVdmError::try_from(code)?)),
             _ => Err(()),
         }
     }
@@ -296,6 +315,7 @@ impl TryInto<u24> for StatusCode {
             StatusCode::TRANSPORT(t) => Ok(u24::new((4 << 16) as u32 + (t as u16) as u32)),
             StatusCode::MEAS_COLLECT(m) => Ok(u24::new((5 << 16) as u32 + (m as u16) as u32)),
             StatusCode::RNG(r) => Ok(u24::new((6 << 16) as u32 + (r as u16) as u32)),
+            StatusCode::VDM(v) => Ok(u24::new((7 << 16) as u32 + (v.vdm_error_code) as u32)),
         }
     }
 }
@@ -643,4 +663,17 @@ pub const SPDM_STATUS_LOW_ENTROPY: SpdmStatus = spdm_return_status!(
     StatusCode::RNG(StatusCodeRNG::LOW_ENTROPY)
 );
 
+#[macro_export]
+macro_rules! SPDM_STATUS_VDM_DEFINED_ERROR {
+    ($vdm_error_code:expr) => {
+        SpdmStatus {
+            severity: StatusSeverity::ERROR,
+            status_code: StatusCode::VDM(StatusCodeVdmError {
+                vdm_error_code: $vdm_error_code,
+            }),
+            error_data: None,
+        };
+    };
+}
+
 pub type SpdmResult<T = ()> = core::result::Result<T, SpdmStatus>;

spdmlib/src/requester/context.rs

@@ -2,21 +2,17 @@
 //
 // SPDX-License-Identifier: Apache-2.0 or MIT
 
-#[allow(unused_imports)]
+#[cfg(feature = "chunk-cap")]
 use crate::common::SpdmCodec;
 use crate::common::{self, SpdmDeviceIo, SpdmTransportEncap};
 use crate::common::{ManagedBufferA, ST1};
 use crate::config;
-use crate::error::{SpdmResult, SPDM_STATUS_RECEIVE_FAIL, SPDM_STATUS_SEND_FAIL};
-#[allow(unused_imports)]
-use crate::error::{
-    SPDM_STATUS_ERROR_PEER, SPDM_STATUS_INVALID_MSG_FIELD, SPDM_STATUS_INVALID_MSG_SIZE,
-};
-#[allow(unused_imports)]
+use crate::error::*;
+#[cfg(any(feature = "chunk-cap", feature = "mut-auth"))]
 use crate::message::*;
 use crate::protocol::*;
 
-#[allow(unused_imports)]
+#[cfg(feature = "chunk-cap")]
 use codec::{Codec, Reader, Writer};
 use spin::Mutex;
 extern crate alloc;

spdmlib/src/responder/context.rs

@@ -3,23 +3,20 @@
 // SPDX-License-Identifier: Apache-2.0 or MIT
 
 use super::app_message_handler::dispatch_secured_app_message_cb;
-#[allow(unused_imports)]
+#[cfg(feature = "chunk-cap")]
 use crate::common::{self, SpdmCodec};
 use crate::common::{session::SpdmSessionState, SpdmDeviceIo, SpdmTransportEncap};
 use crate::common::{SpdmConnectionState, ST1};
 use crate::config::{self, MAX_SPDM_MSG_SIZE, RECEIVER_BUFFER_SIZE};
-use crate::error::{SpdmResult, SPDM_STATUS_INVALID_STATE_LOCAL, SPDM_STATUS_UNSUPPORTED_CAP};
-#[allow(unused_imports)]
-use crate::error::{SPDM_STATUS_INVALID_MSG_FIELD, SPDM_STATUS_INVALID_STATE_PEER};
-
+use crate::error::*;
 use crate::message::*;
 use crate::protocol::{SpdmRequestCapabilityFlags, SpdmResponseCapabilityFlags};
 use crate::watchdog::{reset_watchdog, start_watchdog};
 use codec::{Codec, Reader, Writer};
 extern crate alloc;
 use core::ops::DerefMut;
 
-#[allow(unused_imports)]
+#[cfg(feature = "chunk-cap")]
 use crate::protocol::SpdmVersion;
 
 use alloc::sync::Arc;
@@ -808,8 +805,16 @@ impl ResponderContext {
             self.common.chunk_context.chunk_status = common::SpdmChunkStatus::Idle;
         }
 
-        // Error Response contained in rsp_slice, remap error to Ok(()) for dispatcher.
-        (Ok(()), rsp_slice)
+        // Propagate the error upward if it is VDM defined error, otherwise remap to Ok.
+        let result = result.or_else(|e| {
+            if e.severity == StatusSeverity::ERROR && matches!(e.status_code, StatusCode::VDM(_)) {
+                Err(e)
+            } else {
+                Ok(())
+            }
+        });
+
+        (result, rsp_slice)
     }
 
     #[cfg(feature = "chunk-cap")]
@@ -964,7 +969,7 @@ impl ResponderContext {
                 );
             }
 
-            let response_to_large_request_size = if chunk_send_request
+            let (response_status, response_to_large_request_size) = if chunk_send_request
                 .chunk_sender_attributes
                 .contains(SpdmChunkSenderAttributes::LAST_CHUNK)
             {
@@ -1021,13 +1026,13 @@ impl ResponderContext {
                         self.common.chunk_context.chunk_message_data[..send_buffer.len()]
                             .copy_from_slice(send_buffer);
                         self.common.chunk_context.transferred_size = send_buffer.len();
-                        send_buffer.len()
+                        (status, send_buffer.len())
                     }
                 } else {
                     return (status, None);
                 }
             } else {
-                0
+                (Ok(()), 0)
             };
 
             let response = SpdmMessage {
@@ -1053,7 +1058,7 @@ impl ResponderContext {
                 );
             }
 
-            (Ok(()), Some(writer.used_slice()))
+            (response_status, Some(writer.used_slice()))
         } else {
             error!("!!! chunk_send : invalid chunk send request !!!\n");
             self.write_spdm_error(SpdmErrorCode::SpdmErrorInvalidRequest, 0, writer);

spdmlib/src/responder/vendor_rsp.rs

@@ -3,9 +3,9 @@
 // SPDX-License-Identifier: Apache-2.0 or MIT
 
 use crate::common::SpdmCodec;
-use crate::error::SpdmResult;
 use crate::error::SPDM_STATUS_INVALID_MSG_FIELD;
 use crate::error::SPDM_STATUS_INVALID_STATE_LOCAL;
+use crate::error::{SpdmResult, StatusCode, StatusSeverity};
 use crate::message::*;
 use crate::responder::*;
 
@@ -16,8 +16,18 @@ impl ResponderContext {
         bytes: &[u8],
         writer: &'a mut Writer,
     ) -> (SpdmResult, Option<&'a [u8]>) {
-        let (_, rsp_slice) = self.write_spdm_vendor_defined_response(session_id, bytes, writer);
-        (Ok(()), rsp_slice)
+        let (spdm_status, rsp_slice) =
+            self.write_spdm_vendor_defined_response(session_id, bytes, writer);
+
+        // Propagate the error upward if it is VDM defined error, otherwise convert to Ok.
+        let result = spdm_status.or_else(|e| {
+            if e.severity == StatusSeverity::ERROR && matches!(e.status_code, StatusCode::VDM(_)) {
+                Err(e)
+            } else {
+                Ok(())
+            }
+        });
+        (result, rsp_slice)
     }
 
     pub fn write_spdm_vendor_defined_response<'a>(