Add CommandTag

Adding a native implementation of `TPMI_ST_COMMAND_TAG`.

Signed-off-by: Ionut Mihalcea <ionut.mihalcea@arm.com>

Author: ionut-arm

tss-esapi/src/interface_types/structure_tags.rs

@@ -1,8 +1,16 @@
 // Copyright 2021 Contributors to the Parsec project.
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{constants::StructureTag, tss2_esys::TPMI_ST_ATTEST, Error, Result, WrapperErrorKind};
-use std::convert::TryFrom;
+use log::error;
+use tss_esapi_sys::TPMI_ST_COMMAND_TAG;
+
+use crate::{
+    constants::StructureTag,
+    traits::{Marshall, UnMarshall},
+    tss2_esys::TPMI_ST_ATTEST,
+    Error, Result, ReturnCode, WrapperErrorKind,
+};
+use std::convert::{TryFrom, TryInto};
 
 /// Type of attestation.
 ///
@@ -66,3 +74,182 @@ impl TryFrom<TPMI_ST_ATTEST> for AttestationType {
         AttestationType::try_from(StructureTag::try_from(tpmi_st_attest)?)
     }
 }
+
+impl Marshall for AttestationType {
+    const BUFFER_SIZE: usize = std::mem::size_of::<TPMI_ST_ATTEST>();
+
+    /// Produce a marshalled [`TPMI_ST_ATTEST`]
+    fn marshall(&self) -> Result<Vec<u8>> {
+        let mut buffer = vec![0; Self::BUFFER_SIZE];
+        let mut offset = 0;
+
+        ReturnCode::ensure_success(
+            unsafe {
+                crate::tss2_esys::Tss2_MU_TPM2_ST_Marshal(
+                    (*self).into(),
+                    buffer.as_mut_ptr(),
+                    Self::BUFFER_SIZE.try_into().map_err(|e| {
+                        error!("Failed to convert size of buffer to TSS size_t type: {}", e);
+                        Error::local_error(WrapperErrorKind::InvalidParam)
+                    })?,
+                    &mut offset,
+                )
+            },
+            |ret| {
+                error!("Failed to marshal AttestationType: {}", ret);
+            },
+        )?;
+
+        let checked_offset = usize::try_from(offset).map_err(|e| {
+            error!("Failed to parse offset as usize: {}", e);
+            Error::local_error(WrapperErrorKind::InvalidParam)
+        })?;
+
+        buffer.truncate(checked_offset);
+
+        Ok(buffer)
+    }
+}
+
+impl UnMarshall for AttestationType {
+    /// Unmarshall the structure from [`TPMI_ST_ATTEST`]
+    fn unmarshall(marshalled_data: &[u8]) -> Result<Self> {
+        AttestationType::unmarshall_offset(marshalled_data, &mut 0)
+    }
+
+    fn unmarshall_offset(
+        marshalled_data: &[u8],
+        offset: &mut std::os::raw::c_ulong,
+    ) -> Result<Self> {
+        let mut dest = TPMI_ST_ATTEST::default();
+
+        ReturnCode::ensure_success(
+            unsafe {
+                crate::tss2_esys::Tss2_MU_TPM2_ST_Unmarshal(
+                    marshalled_data.as_ptr(),
+                    marshalled_data.len().try_into().map_err(|e| {
+                        error!("Failed to convert length of marshalled data: {}", e);
+                        Error::local_error(WrapperErrorKind::InvalidParam)
+                    })?,
+                    offset,
+                    &mut dest,
+                )
+            },
+            |ret| error!("Failed to unmarshal AttestationType: {}", ret),
+        )?;
+
+        AttestationType::try_from(dest)
+    }
+}
+
+/// Type of command tag.
+///
+/// # Details
+/// Corresponds to `TPMI_ST_COMMAND_TAG`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CommandTag {
+    Sessions,
+    NoSessions,
+}
+
+impl From<CommandTag> for StructureTag {
+    fn from(value: CommandTag) -> Self {
+        match value {
+            CommandTag::Sessions => StructureTag::Sessions,
+            CommandTag::NoSessions => StructureTag::NoSessions,
+        }
+    }
+}
+
+impl TryFrom<StructureTag> for CommandTag {
+    type Error = Error;
+
+    fn try_from(value: StructureTag) -> std::result::Result<Self, Self::Error> {
+        match value {
+            StructureTag::Sessions => Ok(CommandTag::Sessions),
+            StructureTag::NoSessions => Ok(CommandTag::NoSessions),
+            _ => Err(Error::local_error(WrapperErrorKind::InvalidParam)),
+        }
+    }
+}
+
+impl From<CommandTag> for TPMI_ST_COMMAND_TAG {
+    fn from(command_tag: CommandTag) -> Self {
+        StructureTag::from(command_tag).into()
+    }
+}
+
+impl TryFrom<TPMI_ST_COMMAND_TAG> for CommandTag {
+    type Error = Error;
+
+    fn try_from(tpmi_st_command_tag: TPMI_ST_COMMAND_TAG) -> Result<Self> {
+        CommandTag::try_from(StructureTag::try_from(tpmi_st_command_tag)?)
+    }
+}
+
+impl Marshall for CommandTag {
+    const BUFFER_SIZE: usize = std::mem::size_of::<TPMI_ST_COMMAND_TAG>();
+
+    /// Produce a marshalled [`TPMI_ST_COMMAND_TAG`]
+    fn marshall(&self) -> Result<Vec<u8>> {
+        let mut buffer = vec![0; Self::BUFFER_SIZE];
+        let mut offset = 0;
+
+        ReturnCode::ensure_success(
+            unsafe {
+                crate::tss2_esys::Tss2_MU_TPM2_ST_Marshal(
+                    (*self).into(),
+                    buffer.as_mut_ptr(),
+                    Self::BUFFER_SIZE.try_into().map_err(|e| {
+                        error!("Failed to convert size of buffer to TSS size_t type: {}", e);
+                        Error::local_error(WrapperErrorKind::InvalidParam)
+                    })?,
+                    &mut offset,
+                )
+            },
+            |ret| {
+                error!("Failed to marshal CommandTag: {}", ret);
+            },
+        )?;
+
+        let checked_offset = usize::try_from(offset).map_err(|e| {
+            error!("Failed to parse offset as usize: {}", e);
+            Error::local_error(WrapperErrorKind::InvalidParam)
+        })?;
+
+        buffer.truncate(checked_offset);
+
+        Ok(buffer)
+    }
+}
+
+impl UnMarshall for CommandTag {
+    /// Unmarshall the structure from [`TPMI_ST_COMMAND_TAG`]
+    fn unmarshall(marshalled_data: &[u8]) -> Result<Self> {
+        CommandTag::unmarshall_offset(marshalled_data, &mut 0)
+    }
+
+    fn unmarshall_offset(
+        marshalled_data: &[u8],
+        offset: &mut std::os::raw::c_ulong,
+    ) -> Result<Self> {
+        let mut dest = TPMI_ST_COMMAND_TAG::default();
+
+        ReturnCode::ensure_success(
+            unsafe {
+                crate::tss2_esys::Tss2_MU_TPM2_ST_Unmarshal(
+                    marshalled_data.as_ptr(),
+                    marshalled_data.len().try_into().map_err(|e| {
+                        error!("Failed to convert length of marshalled data: {}", e);
+                        Error::local_error(WrapperErrorKind::InvalidParam)
+                    })?,
+                    offset,
+                    &mut dest,
+                )
+            },
+            |ret| error!("Failed to unmarshal CommandTag: {}", ret),
+        )?;
+
+        CommandTag::try_from(dest)
+    }
+}

tss-esapi/tests/integration_tests/interface_types_tests/structure_tags_tests.rs

@@ -22,6 +22,27 @@ macro_rules! test_valid_conversions {
             stringify!($strucutre_tag_item),
         );
     };
+
+    (CommandTag::$attestation_type_item:ident, StructureTag::$strucutre_tag_item:ident) => {
+        assert_eq!(
+            CommandTag::$attestation_type_item,
+            CommandTag::try_from(StructureTag::$strucutre_tag_item).expect(&format!(
+                "Could not convert StructureTag {}",
+                stringify!($attestation_type_item)
+            )),
+            "StructureTag {} did not convert to the correct CommandTag {}",
+            stringify!($strucutre_tag_item),
+            stringify!($attestation_type_item),
+        );
+
+        assert_eq!(
+            StructureTag::$strucutre_tag_item,
+            StructureTag::from(CommandTag::$attestation_type_item),
+            "CommandTag {} did not convert to the correct StructureTag {}",
+            stringify!($attestation_type_item),
+            stringify!($strucutre_tag_item),
+        );
+    };
 }
 
 mod attestation_type_tests {
@@ -57,4 +78,41 @@ mod attestation_type_tests {
             "Expected an error when converting StructureTag FuManifest into AttestationType",
         )
     }
+
+    #[test]
+    fn test_marshall_unmarshall() {
+        let val = AttestationType::SessionAudit;
+        crate::common::check_marshall_unmarshall(&val);
+        crate::common::check_marshall_unmarshall_offset(&val);
+    }
+}
+
+mod command_tag_tests {
+    use std::convert::TryFrom;
+    use tss_esapi::{
+        constants::StructureTag, interface_types::structure_tags::CommandTag, Error,
+        WrapperErrorKind,
+    };
+
+    #[test]
+    fn test_conversions() {
+        test_valid_conversions!(CommandTag::Sessions, StructureTag::Sessions);
+        test_valid_conversions!(CommandTag::NoSessions, StructureTag::NoSessions);
+    }
+
+    #[test]
+    fn test_invalid_conversions() {
+        assert_eq!(
+            Err(Error::WrapperError(WrapperErrorKind::InvalidParam)),
+            CommandTag::try_from(StructureTag::FuManifest),
+            "Expected an error when converting StructureTag FuManifest into CommandTag",
+        )
+    }
+
+    #[test]
+    fn test_marshall_unmarshall() {
+        let val = CommandTag::Sessions;
+        crate::common::check_marshall_unmarshall(&val);
+        crate::common::check_marshall_unmarshall_offset(&val);
+    }
 }