refactor: bunch of optimizations

Author: asmie

CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.1] - 2026-02-08
+
+### Changed
+
+- Multiple optimizations and refactorings.
+
 ## [0.3.0] - 2026-02-08
 
 ### Added

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 authors = ['Piotr Olszewski <asmie@asmie.pl>']
 name = "stamp-suite"
-version = "0.3.0"
+version = "0.3.1"
 edition = "2021"
 rust-version = "1.93.0"
 
@@ -34,14 +34,15 @@ thiserror = "2.0"
 hmac = "0.12"
 sha2 = "0.10"
 hex = "0.4"
+subtle = "2.5"
 
 # TTL backend dependencies (all optional, selected by features)
 nix = { version = "0.31", optional = true, default-features = false, features = ["socket", "uio", "net"] }
 pnet = { version = "0.35", optional = true }
 
 [dependencies.tokio]
 version = "1.49"
-features = ["full"]
+features = ["rt-multi-thread", "net", "time", "macros"]
 
 # Platform-specific default backends
 # Note: These provide defaults when no explicit ttl-* feature is used.

Cargo.toml

@@ -118,8 +118,6 @@ Options:
   -d, --send-delay <SEND_DELAY>    Delay between packets in milliseconds [default: 1000]
   -c, --count <COUNT>              Number of packets to send [default: 1000]
   -L, --timeout <TIMEOUT>          Timeout for lost packets in seconds [default: 5]
-  -4                               Force IPv4 addresses
-  -6                               Force IPv6 addresses
   -A, --auth-mode <AUTH_MODE>      Work mode: A=authenticated, O=open [default: O]
   -R                               Print individual statistics for each packet
   -i, --is-reflector               Run as Session Reflector instead of Sender

README.md

@@ -1,38 +1,22 @@
-use std::{fmt, str::FromStr};
+use std::fmt;
 
-use thiserror::Error;
+use clap::ValueEnum;
 
 /// This enum represents the clock format used in the application.
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Default, ValueEnum)]
 pub enum ClockFormat {
     /// Network Time Protocol timestamp format (RFC 5905).
+    #[default]
+    #[value(name = "NTP")]
     NTP,
     /// Precision Time Protocol timestamp format (IEEE 1588).
+    #[value(name = "PTP")]
     PTP,
 }
 
-/// Represents the error that can occur when parsing the clock format.
-#[derive(Error, Debug)]
-pub enum ClockFormatError {
-    #[error("Invalid clock source")]
-    InvalidClockSource,
-}
-
-impl FromStr for ClockFormat {
-    type Err = ClockFormatError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "NTP" => Ok(ClockFormat::NTP),
-            "PTP" => Ok(ClockFormat::PTP),
-            _ => Err(ClockFormatError::InvalidClockSource),
-        }
-    }
-}
-
 impl fmt::Display for ClockFormat {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
+        match self {
             ClockFormat::NTP => write!(f, "NTP"),
             ClockFormat::PTP => write!(f, "PTP"),
         }
@@ -45,9 +29,15 @@ mod tests {
 
     #[test]
     fn test_clock_format_parsing() {
-        assert_eq!("NTP".parse::<ClockFormat>().unwrap(), ClockFormat::NTP);
-        assert_eq!("PTP".parse::<ClockFormat>().unwrap(), ClockFormat::PTP);
-        assert!("INVALID".parse::<ClockFormat>().is_err());
+        assert_eq!(
+            ClockFormat::from_str("NTP", false).unwrap(),
+            ClockFormat::NTP
+        );
+        assert_eq!(
+            ClockFormat::from_str("PTP", false).unwrap(),
+            ClockFormat::PTP
+        );
+        assert!(ClockFormat::from_str("INVALID", false).is_err());
     }
 
     #[test]
@@ -56,38 +46,49 @@ mod tests {
         assert_eq!(ClockFormat::PTP.to_string(), "PTP");
     }
 
+    #[test]
+    fn test_clock_format_case_insensitive() {
+        // ValueEnum supports case-insensitive parsing with ignore_case=true
+        assert_eq!(
+            ClockFormat::from_str("ntp", true).unwrap(),
+            ClockFormat::NTP
+        );
+        assert_eq!(
+            ClockFormat::from_str("ptp", true).unwrap(),
+            ClockFormat::PTP
+        );
+    }
+
     #[test]
     fn test_clock_format_case_sensitive() {
-        // Lowercase should fail
-        assert!("ntp".parse::<ClockFormat>().is_err());
-        assert!("ptp".parse::<ClockFormat>().is_err());
-        assert!("Ntp".parse::<ClockFormat>().is_err());
-        assert!("Ptp".parse::<ClockFormat>().is_err());
+        // With ignore_case=false, only exact match works
+        assert!(ClockFormat::from_str("ntp", false).is_err());
+        assert!(ClockFormat::from_str("ptp", false).is_err());
+        assert!(ClockFormat::from_str("Ntp", false).is_err());
     }
 
     #[test]
     fn test_clock_format_empty_string() {
-        assert!("".parse::<ClockFormat>().is_err());
+        assert!(ClockFormat::from_str("", false).is_err());
     }
 
     #[test]
     fn test_clock_format_whitespace() {
-        assert!(" NTP".parse::<ClockFormat>().is_err());
-        assert!("NTP ".parse::<ClockFormat>().is_err());
-        assert!(" NTP ".parse::<ClockFormat>().is_err());
+        assert!(ClockFormat::from_str(" NTP", false).is_err());
+        assert!(ClockFormat::from_str("NTP ", false).is_err());
     }
 
     #[test]
     fn test_clock_format_roundtrip() {
         // Parse -> Display -> Parse should give same result
-        let ntp = "NTP".parse::<ClockFormat>().unwrap();
+        let ntp = ClockFormat::from_str("NTP", false).unwrap();
         let ntp_str = ntp.to_string();
-        let ntp_again = ntp_str.parse::<ClockFormat>().unwrap();
+        let ntp_again = ClockFormat::from_str(&ntp_str, false).unwrap();
         assert_eq!(ntp, ntp_again);
 
-        let ptp = "PTP".parse::<ClockFormat>().unwrap();
+        let ptp = ClockFormat::from_str("PTP", false).unwrap();
         let ptp_str = ptp.to_string();
-        let ptp_again = ptp_str.parse::<ClockFormat>().unwrap();
+        let ptp_again = ClockFormat::from_str(&ptp_str, false).unwrap();
         assert_eq!(ptp, ptp_again);
     }
 }