Refactor SessionInfo

Signed-off-by: Keith Koskie <[email protected]>

Author: vkkoskie

cryptoki/src/session/mod.rs

@@ -6,13 +6,10 @@ use crate::context::Pkcs11;
 use crate::error::Result;
 use crate::mechanism::Mechanism;
 use crate::object::{Attribute, AttributeInfo, AttributeType, ObjectHandle};
-use crate::slot::Slot;
-use crate::types::Ulong;
 
 use cryptoki_sys::*;
 use log::error;
 use std::collections::HashMap;
-use std::convert::TryInto;
 use std::fmt::Formatter;
 use std::marker::PhantomData;
 use std::ops::Deref;
@@ -23,10 +20,13 @@ mod flags;
 mod key_management;
 mod object_management;
 mod random;
+mod session_info;
 mod session_management;
 mod signing_macing;
 mod slot_token_management;
 
+pub use session_info::SessionInfo;
+
 pub use flags::*;
 
 /// Type that identifies a session
@@ -443,37 +443,3 @@ impl std::fmt::Display for SessionState {
         write!(f, "{}", SessionState::stringify(self.val))
     }
 }
-
-/// Type identifying the session information
-#[derive(Copy, Clone, Debug)]
-pub struct SessionInfo {
-    val: CK_SESSION_INFO,
-}
-
-impl SessionInfo {
-    pub(crate) fn new(val: CK_SESSION_INFO) -> Self {
-        Self { val }
-    }
-
-    /// Returns an error code defined by the cryptographic device
-    pub fn device_error(&self) -> Ulong {
-        self.val.ulDeviceError.into()
-    }
-
-    /// Returns the flags for this session
-    pub fn flags(&self) -> SessionFlags {
-        self.val.flags.into()
-    }
-
-    /// Returns the state of the session
-    pub fn session_state(&self) -> SessionState {
-        self.val.state.into()
-    }
-
-    /// Returns the slot the session is on
-    pub fn slot_id(&self) -> Slot {
-        // The unwrap should not fail as `slotID` is a `CK_SLOT_ID ` which is the same type as
-        // `slot_id` within the `Slot` structure
-        self.val.slotID.try_into().unwrap()
-    }
-}

cryptoki/src/session/session_info.rs

@@ -0,0 +1,71 @@
+// Copyright 2021 Contributors to the Parsec project.
+// SPDX-License-Identifier: Apache-2.0
+//! Session info
+
+use crate::{
+    flag::{CkFlags, FlagBit},
+    slot::Slot,
+};
+use cryptoki_sys::*;
+use std::fmt::{self, Debug, Formatter};
+
+use super::SessionState;
+
+const RW_SESSION: FlagBit<SessionInfo> = FlagBit::new(CKF_RW_SESSION);
+const SERIAL_SESSION: FlagBit<SessionInfo> = FlagBit::new(CKF_SERIAL_SESSION);
+
+impl Debug for CkFlags<SessionInfo> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Flags")
+            .field("rw_session", &(self.contains(RW_SESSION)))
+            .field("serial_session", &(self.contains(SERIAL_SESSION)))
+            .finish()
+    }
+}
+
+/// Provides information about a session
+#[derive(Copy, Clone, Debug)]
+pub struct SessionInfo {
+    slot_id: Slot,
+    state: SessionState,
+    flags: CkFlags<Self>,
+    device_error: u64,
+}
+
+impl SessionInfo {
+    /// ID of the slot that interfaces the token
+    pub fn slot_id(&self) -> Slot {
+        self.slot_id
+    }
+
+    /// The state of the session
+    pub fn session_state(&self) -> SessionState {
+        self.state
+    }
+
+    /// True if the session has R/W access to token objects, and false if access
+    /// is read-only
+    pub fn read_write(&self) -> bool {
+        self.flags.contains(RW_SESSION)
+    }
+
+    /// An error code defined by the cryptographic device (used for errors not
+    /// covered by PKCS#11)
+    pub fn device_error(&self) -> u64 {
+        self.device_error
+    }
+}
+
+#[doc(hidden)]
+impl From<CK_SESSION_INFO> for SessionInfo {
+    fn from(val: CK_SESSION_INFO) -> Self {
+        #[allow(trivial_numeric_casts)]
+        let device_error = val.ulDeviceError as u64;
+        Self {
+            slot_id: Slot::new(val.slotID),
+            state: val.state.into(),
+            flags: CkFlags::from(val.flags),
+            device_error,
+        }
+    }
+}

cryptoki/src/session/session_management.rs

@@ -52,6 +52,6 @@ pub(super) fn get_session_info(session: &Session) -> Result<SessionInfo> {
             &mut session_info,
         ))
         .into_result()?;
-        Ok(SessionInfo::new(session_info))
+        Ok(SessionInfo::from(session_info))
     }
 }

cryptoki/tests/basic.rs

@@ -477,7 +477,7 @@ fn get_session_info_test() -> Result<()> {
     {
         let session = pkcs11.open_session_no_callback(slot, flags)?;
         let session_info = session.get_session_info()?;
-        assert_eq!(session_info.flags(), flags);
+        assert!(!session_info.read_write());
         assert_eq!(session_info.slot_id(), slot);
         assert_eq!(
             session_info.session_state(),
@@ -486,7 +486,7 @@ fn get_session_info_test() -> Result<()> {
 
         session.login(UserType::User, Some(USER_PIN))?;
         let session_info = session.get_session_info()?;
-        assert_eq!(session_info.flags(), flags);
+        assert!(!session_info.read_write());
         assert_eq!(session_info.slot_id(), slot);
         assert_eq!(
             session_info.session_state(),
@@ -506,7 +506,7 @@ fn get_session_info_test() -> Result<()> {
 
     let session = pkcs11.open_session_no_callback(slot, flags)?;
     let session_info = session.get_session_info()?;
-    assert_eq!(session_info.flags(), flags);
+    assert!(session_info.read_write());
     assert_eq!(session_info.slot_id(), slot);
     assert_eq!(
         session_info.session_state(),
@@ -515,7 +515,7 @@ fn get_session_info_test() -> Result<()> {
 
     session.login(UserType::User, Some(USER_PIN))?;
     let session_info = session.get_session_info()?;
-    assert_eq!(session_info.flags(), flags);
+    assert!(session_info.read_write());
     assert_eq!(session_info.slot_id(), slot);
     assert_eq!(
         session_info.session_state(),
@@ -524,7 +524,7 @@ fn get_session_info_test() -> Result<()> {
     session.logout()?;
     session.login(UserType::So, Some(SO_PIN))?;
     let session_info = session.get_session_info()?;
-    assert_eq!(session_info.flags(), flags);
+    assert!(session_info.read_write());
     assert_eq!(session_info.slot_id(), slot);
     assert_eq!(session_info.session_state(), SessionState::RW_SO_FUNCTIONS);