Some improvements to parsing the version string + updated changelog.

Author: danieltrick

CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
+## [0.9.0] - 2026-01-20
+
+### Added
+
+- Added the `FapiContext::set_callbacks()` function, which can be used to set or replace all callback functions at once.
+- Added the `FapiContext::clear_callbacks()` function, which can be used to unset all callback functions.
+- Added the `FapiCallbacks` trait, which represents the set of application-defined callback functions that the FAPI invokes.
+
+### Changed
+
+- Function `get_version()` now returns a `FapiVersion` struct.
+- Functions `FapiContext::set_callbacks()` and `FapiContext::clear_callbacks()` now return the previous callbacks.
+
+### Removed
+
+- Removed the `FapiContext::set_auth_callback` function; superseded by `set_callbacks()`.
+- Removed the `FapiContext::set_sign_callback` function; superseded by `set_callbacks()`.
+- Removed the `FapiContext::set_branch_callback` function; superseded by `set_callbacks()`.
+- Removed the `FapiContext::set_policy_action_callback` function; superseded by `set_callbacks()`.
+
 ## [0.8.1] - 2026-01-15
 
 ### Added

build.rs

@@ -25,7 +25,7 @@ const LIBRARY_NAME: &str = "tss2-fapi";
 const LIBRARY_MIN_VERSION: &str = "3.2.0";
 
 /// Regex to parse the version string, assuming the `<major>.<minor>.<patch>` format
-static REGEX_VERSION: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^(\d+)\.(\d+)\.(\d+)").unwrap());
+static REGEX_VERSION: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^(\d+)\.(\d+)\.(\d+)([-+._]\S+)?").unwrap());
 
 /// This build scripts is required to detect and link the "native" FAPI library
 fn main() {
@@ -111,13 +111,10 @@ fn detect_tss2_library() -> Result<LibraryConfig, Error> {
 fn write_version_string(path: &Path, version_string: &str) -> Result<(), IoError> {
     // Parse the version string
     let captures = REGEX_VERSION.captures(version_string.trim_ascii()).expect("Invalid version string!");
-    let vers_major = captures.get(1).unwrap().as_str().parse::<u16>().expect("Failed to parse version string!");
-    let vers_minor = captures.get(2).unwrap().as_str().parse::<u16>().expect("Failed to parse version string!");
-    let vers_patch = captures.get(3).unwrap().as_str().parse::<u16>().expect("Failed to parse version string!");
 
     // Try to write the version string to the output file
     let mut file = File::create(path).expect("Failed to create output file for version!");
-    writeln!(file, r#"pub const TSS2_FAPI_VERSION: &str = "{}.{}.{}";"#, vers_major, vers_minor, vers_patch)
+    writeln!(file, r#"pub const TSS2_FAPI_VERSION: &str = "{}";"#, captures.get(0).unwrap().as_str())
 }
 
 /// Parse the given 'flag' string as a boolean value

examples/1_get_random.rs

@@ -28,8 +28,8 @@ fn main() {
     info!("TSS2 FAPI Wrapper - Example #1");
 
     // Print library version
-    let version_info = tss2_fapi_rs::get_version();
-    info!("Using tss2-fapi-rs package version: {}, built with native FAPI library version: {}", version_info.package, version_info.native);
+    let version = tss2_fapi_rs::get_version();
+    info!("Using tss2-fapi-rs package version: {}, built with native FAPI library version: {}", version.package, version.library);
 
     // Create a new FAPI context
     info!("Creating FAPI context, please wait...");

src/callback.rs

@@ -213,7 +213,7 @@ pub struct CallbackManager {
 }
 
 impl CallbackManager {
-    pub fn new(callbacks: impl FapiCallbacks + 'static) -> Self {
+    pub fn new(callbacks: impl FapiCallbacks) -> Self {
         Self { inner: Box::new(callbacks), auth_value: None, sign_data: None }
     }
 

src/lib.rs

@@ -456,7 +456,7 @@ pub use context::FapiContext;
 pub use error::{BaseErrorCode, ErrorCode, InternalError, Tpm2ErrFmt0, Tpm2ErrFmt1, Tpm2ErrorCode, Tpm2Warning};
 pub use flags::{BlobType, KeyFlags, NvFlags, PaddingFlags, QuoteFlags, SealFlags};
 pub use types::{ImportData, QuoteResult, SignResult, TpmBlobs};
-pub use version::{VersionInfo, get_version};
+pub use version::{FapiVersion, VersionInfo, get_version};
 
 // Re-export JSON module
 pub use ::json;

src/version.rs

@@ -10,7 +10,7 @@ static VERSION_INFO_PKG: OnceLock<VersionInfo> = OnceLock::new();
 static VERSION_INFO_SYS: OnceLock<VersionInfo> = OnceLock::new();
 
 /// Contains version information.
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 #[non_exhaustive]
 pub struct VersionInfo {
     /// The *major* version of the software.
@@ -19,37 +19,49 @@ pub struct VersionInfo {
     pub minor: u16,
     /// The *patch* level of the software.
     pub patch: u16,
+    /// Additional version identifier (e.g. "beta-2")
+    pub ident: Option<String>,
 }
 
-/// Contains version information.
-#[derive(Copy, Clone)]
+/// Contains the FAPI version.
+#[derive(Clone)]
 #[non_exhaustive]
 pub struct FapiVersion {
-    /// Version of the `tss2-fapi-rs` package
+    /// Version of the `tss2-fapi-rs` package (Rust wrapper)
     pub package: VersionInfo,
     /// Versin of the "native" FAPI library that was used to build `tss2-fapi-rs`
-    pub native: VersionInfo,
+    pub library: VersionInfo,
 }
 
 /// Returns the package version of the **`tss2-fapi-rs`** library.
 ///
 /// Additionally, the version of the "native" FAPI library that was used to build `tss2-fapi-rs` is returned.
 pub fn get_version() -> FapiVersion {
+    const PACKAGE_VERSION: &str = env!("CARGO_PKG_VERSION", "Package version is not defined!");
     FapiVersion {
-        package: *VERSION_INFO_PKG.get_or_init(|| parse_version(env!("CARGO_PKG_VERSION", "Package version not defined!"))),
-        native: *VERSION_INFO_SYS.get_or_init(|| parse_version(crate::fapi_sys::TSS2_FAPI_VERSION)),
+        package: VERSION_INFO_PKG.get_or_init(|| parse_version(PACKAGE_VERSION)).clone(),
+        library: VERSION_INFO_SYS.get_or_init(|| parse_version(crate::fapi_sys::TSS2_FAPI_VERSION)).clone(),
     }
 }
 
 /// Parse a version string that is in the `"major.minor.patch"` format into a [`VersionInfo`] struct.
 fn parse_version(version_string: &str) -> VersionInfo {
-    let mut tokens = version_string.split('.').map(|str| str.parse::<u16>().unwrap_or_default());
-    VersionInfo { major: tokens.next().unwrap_or_default(), minor: tokens.next().unwrap_or_default(), patch: tokens.next().unwrap_or_default() }
+    let mut tokens = version_string.splitn(4usize, ['.', '+', '-', '_']).map(str::trim_ascii);
+    VersionInfo {
+        major: tokens.next().and_then(|str| str.parse::<u16>().ok()).unwrap_or_default(),
+        minor: tokens.next().and_then(|str| str.parse::<u16>().ok()).unwrap_or_default(),
+        patch: tokens.next().and_then(|str| str.parse::<u16>().ok()).unwrap_or_default(),
+        ident: tokens.next().filter(|str| !str.is_empty()).map(str::to_owned),
+    }
 }
 
 /// Convert the `VersionInfo` struct to a string in the `"major.minor.patch"` format
 impl Display for VersionInfo {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}.{}.{}", self.major, self.minor, self.patch)
+        if let Some(ident_str) = self.ident.as_ref() {
+            write!(f, "{}.{}.{}-{}", self.major, self.minor, self.patch, ident_str)
+        } else {
+            write!(f, "{}.{}.{}", self.major, self.minor, self.patch)
+        }
     }
 }

tests/01_version_test.rs

@@ -25,13 +25,15 @@ fn test_version() {
     repeat_test!(|_i| {
         let version_info = get_version();
         debug!("tss2-fapi-rs package version: {}", version_info.package);
-        debug!("Native FAPI version: {}", version_info.native);
+        debug!("TSS 2.0 FAPI library version: {}", version_info.library);
+
+        let package = black_box(version_info.package);
+        let library = black_box(version_info.library);
 
         // Verify the package version
-        assert_eq!(CURRENT_PKG_VERSION, format!("{}", version_info.package));
+        assert_eq!(CURRENT_PKG_VERSION, format!("{}", package));
 
         // Verify the FAPI version
-        let native_ver = &black_box(version_info.native);
-        assert!((native_ver.major > 3u16) || ((native_ver.major == 3u16) && ((native_ver.minor > 0u16) || (native_ver.patch >= 3u16))));
+        assert!((library.major > 3u16) || ((library.major == 3u16) && ((library.minor > 0u16) || (library.patch >= 3u16))));
     });
 }