Alias types for unit and duration

Author: SimonIT

boringtun/src/device/api.rs

@@ -6,10 +6,9 @@ use super::drop_privileges::get_saved_ids;
 use super::{AllowedIP, Device, Error, SocketAddr};
 use crate::device::Action;
 use crate::serialization::KeyBytes;
-use crate::sleepyinstant::ClockImpl;
+use crate::sleepyinstant::ClockUnit;
 use crate::x25519;
 use embedded_time::duration::{Nanoseconds, Seconds};
-use embedded_time::Clock;
 use hex::encode as encode_hex;
 use libc::*;
 use std::convert::TryFrom;
@@ -193,10 +192,9 @@ fn api_get(writer: &mut BufWriter<&UnixStream>, d: &Device) -> i32 {
         }
 
         if let Some(time) = p.time_since_last_handshake() {
-            let secs = Seconds::<<ClockImpl as Clock>::T>::try_from(time).unwrap();
+            let secs = Seconds::<ClockUnit>::try_from(time).unwrap();
             writeln!(writer, "last_handshake_time_sec={secs}");
-            let sub =
-                Nanoseconds::<<ClockImpl as Clock>::T>::try_from(time).unwrap() % Seconds(1u32);
+            let sub = Nanoseconds::<ClockUnit>::try_from(time).unwrap() % Seconds(1u32);
             writeln!(writer, "last_handshake_time_nsec={sub}");
         }
 

boringtun/src/device/peer.rs

@@ -1,14 +1,12 @@
 // Copyright (c) 2019 Cloudflare, Inc. All rights reserved.
 // SPDX-License-Identifier: BSD-3-Clause
 
-use embedded_time::duration::Generic;
 use parking_lot::RwLock;
 use socket2::{Domain, Protocol, Type};
 
 use crate::device::{AllowedIps, Error};
 use crate::noise::{Tunn, TunnResult};
-use crate::sleepyinstant::ClockImpl;
-use embedded_time::Clock;
+use crate::sleepyinstant::ClockDuration;
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, SocketAddrV4, SocketAddrV6};
 use std::str::FromStr;
 
@@ -154,7 +152,7 @@ impl Peer {
         self.allowed_ips.iter().map(|(_, ip, cidr)| (ip, cidr))
     }
 
-    pub fn time_since_last_handshake(&self) -> Option<Generic<<ClockImpl as Clock>::T>> {
+    pub fn time_since_last_handshake(&self) -> Option<ClockDuration> {
         self.tunnel.time_since_last_handshake()
     }
 

boringtun/src/ffi/mod.rs

@@ -395,11 +395,7 @@ pub unsafe extern "C" fn wireguard_stats(tunnel: *const Mutex<RawMutex, Tunn>) -
     let (time, tx_bytes, rx_bytes, estimated_loss, estimated_rtt) = tunnel.stats();
     stats {
         time_since_last_handshake: time
-            .map(|t| {
-                Seconds::<<ClockImpl as Clock>::T>::try_from(t)
-                    .unwrap()
-                    .integer() as i64
-            })
+            .map(|t| Seconds::<ClockUnit>::try_from(t).unwrap().integer() as i64)
             .unwrap_or(-1),
         tx_bytes,
         rx_bytes,

boringtun/src/noise/handshake.rs

@@ -4,7 +4,7 @@
 use super::{HandshakeInit, HandshakeResponse, PacketCookieReply};
 use crate::noise::errors::WireGuardError;
 use crate::noise::session::Session;
-use crate::sleepyinstant::{ClockImpl, Instant};
+use crate::sleepyinstant::{ClockDuration, ClockImpl, ClockUnit, Instant};
 use crate::x25519;
 use aead::{Aead, Payload};
 use alloc::borrow::ToOwned;
@@ -14,7 +14,7 @@ use blake2::{Blake2s256, Blake2sMac, Digest};
 use chacha20poly1305::XChaCha20Poly1305;
 use core::convert::TryFrom;
 use core::convert::TryInto;
-use embedded_time::duration::{Generic, Milliseconds, Nanoseconds, Seconds};
+use embedded_time::duration::{Milliseconds, Nanoseconds, Seconds};
 use embedded_time::fixed_point::FixedPoint;
 use embedded_time::Clock;
 use ring::aead::{Aad, LessSafeKey, Nonce, UnboundKey, CHACHA20_POLY1305};
@@ -168,7 +168,7 @@ struct Tai64N {
 #[derive(Debug)]
 /// This struct computes a [Tai64N](https://cr.yp.to/libtai/tai64.html) timestamp from current system time
 struct TimeStamper {
-    duration_at_start: Generic<<ClockImpl as Clock>::T>,
+    duration_at_start: ClockDuration,
     instant_at_start: Instant,
 }
 
@@ -189,9 +189,9 @@ impl TimeStamper {
         const TAI64_BASE: u64 = (1u64 << 62) + 37;
         let mut ext_stamp = [0u8; 12];
         let stamp = Instant::now().duration_since(self.instant_at_start) + self.duration_at_start;
-        let secs = Seconds::<<ClockImpl as Clock>::T>::try_from(stamp).unwrap();
+        let secs = Seconds::<ClockUnit>::try_from(stamp).unwrap();
         ext_stamp[0..8].copy_from_slice(&(secs.integer() + TAI64_BASE).to_be_bytes());
-        let sub = Nanoseconds::<<ClockImpl as Clock>::T>::try_from(stamp).unwrap() % Seconds(1u32);
+        let sub = Nanoseconds::<ClockUnit>::try_from(stamp).unwrap() % Seconds(1u32);
         ext_stamp[8..12].copy_from_slice(&(sub.integer() as u32).to_be_bytes());
         ext_stamp
     }

boringtun/src/noise/mod.rs

@@ -14,14 +14,12 @@ use crate::noise::rate_limiter::RateLimiter;
 use crate::noise::timers::{TimerName, Timers};
 use crate::x25519;
 
-use crate::sleepyinstant::ClockImpl;
+use crate::sleepyinstant::ClockDuration;
 use alloc::collections::VecDeque;
 use alloc::sync::Arc;
 use alloc::vec::Vec;
 use core::convert::{TryFrom, TryInto};
 use core::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-use embedded_time::duration::Generic;
-use embedded_time::Clock;
 
 /// The default value to use for rate limiting, when no other rate limiter is defined
 const PEER_HANDSHAKE_RATE_LIMIT: u64 = 10;
@@ -577,15 +575,7 @@ impl Tunn {
     /// * Time since last handshake in seconds
     /// * Data bytes sent
     /// * Data bytes received
-    pub fn stats(
-        &self,
-    ) -> (
-        Option<Generic<<ClockImpl as Clock>::T>>,
-        usize,
-        usize,
-        f32,
-        Option<u32>,
-    ) {
+    pub fn stats(&self) -> (Option<ClockDuration>, usize, usize, f32, Option<u32>) {
         let time = self.time_since_last_handshake();
         let tx_bytes = self.tx_bytes;
         let rx_bytes = self.rx_bytes;

boringtun/src/noise/rate_limiter.rs

@@ -6,17 +6,15 @@ use core::convert::TryFrom;
 use core::net::IpAddr;
 use core::sync::atomic::{AtomicUsize, Ordering};
 
-use crate::sleepyinstant::Instant;
+use crate::sleepyinstant::{ClockUnit, Instant};
 
-use crate::sleepyinstant::ClockImpl;
 use aead::array::Array;
 use aead::{AeadInOut, KeyInit};
 #[cfg(feature = "ariel-os")]
 use ariel_os_lock::RawMutex;
 use chacha20poly1305::{Key, XChaCha20Poly1305};
 use embedded_time::duration::Seconds;
 use embedded_time::fixed_point::FixedPoint;
-use embedded_time::Clock;
 use lock_api::Mutex;
 #[cfg(feature = "std")]
 use parking_lot::RawMutex;
@@ -102,11 +100,9 @@ impl RateLimiter {
 
         // The current cookie for a given IP is the MAC(responder.changing_secret_every_two_minutes, initiator.ip_address)
         // First we derive the secret from the current time, the value of cur_counter would change with time.
-        let cur_counter = Seconds::<<ClockImpl as Clock>::T>::try_from(
-            Instant::now().duration_since(self.start_time),
-        )
-        .unwrap()
-            / COOKIE_REFRESH.integer() as <ClockImpl as Clock>::T;
+        let cur_counter =
+            Seconds::<ClockUnit>::try_from(Instant::now().duration_since(self.start_time)).unwrap()
+                / COOKIE_REFRESH.integer() as ClockUnit;
 
         // Next we derive the cookie
         b2s_keyed_mac_16_2(

boringtun/src/noise/timers.rs

@@ -3,12 +3,11 @@
 
 use super::errors::WireGuardError;
 use crate::noise::{Tunn, TunnResult};
-use crate::sleepyinstant::ClockImpl;
 use crate::sleepyinstant::Instant;
+use crate::sleepyinstant::{ClockDuration, ClockUnit};
 use core::mem;
 use core::ops::{Index, IndexMut};
-use embedded_time::duration::{Generic, Seconds};
-use embedded_time::Clock;
+use embedded_time::duration::Seconds;
 
 // Some constants, represent time in seconds
 // https://www.wireguard.com/papers/wireguard.pdf#page=14
@@ -50,8 +49,8 @@ pub struct Timers {
     is_initiator: bool,
     /// Start time of the tunnel
     time_started: Instant,
-    timers: [Generic<<ClockImpl as Clock>::T>; TimerName::Top as usize],
-    pub(super) session_timers: [Generic<<ClockImpl as Clock>::T>; super::N_SESSIONS],
+    timers: [ClockDuration; TimerName::Top as usize],
+    pub(super) session_timers: [ClockDuration; super::N_SESSIONS],
     /// Did we receive data without sending anything back?
     want_keepalive: bool,
     /// Did we send data without hearing back?
@@ -92,14 +91,14 @@ impl Timers {
 }
 
 impl Index<TimerName> for Timers {
-    type Output = Generic<<ClockImpl as Clock>::T>;
-    fn index(&self, index: TimerName) -> &Generic<<ClockImpl as Clock>::T> {
+    type Output = ClockDuration;
+    fn index(&self, index: TimerName) -> &ClockDuration {
         &self.timers[index as usize]
     }
 }
 
 impl IndexMut<TimerName> for Timers {
-    fn index_mut(&mut self, index: TimerName) -> &mut Generic<<ClockImpl as Clock>::T> {
+    fn index_mut(&mut self, index: TimerName) -> &mut ClockDuration {
         &mut self.timers[index as usize]
     }
 }
@@ -145,7 +144,7 @@ impl Tunn {
         self.timers.clear();
     }
 
-    fn update_session_timers(&mut self, time_now: Generic<<ClockImpl as Clock>::T>) {
+    fn update_session_timers(&mut self, time_now: ClockDuration) {
         let timers = &mut self.timers;
 
         for (i, t) in timers.session_timers.iter_mut().enumerate() {
@@ -286,7 +285,7 @@ impl Tunn {
                     // Persistent KEEPALIVE
                     if persistent_keepalive > 0
                         && (now - self.timers[TimePersistentKeepalive]
-                            >= Seconds::<<ClockImpl as Clock>::T>(persistent_keepalive as _))
+                            >= Seconds::<ClockUnit>(persistent_keepalive as _))
                     {
                         tracing::debug!("KEEPALIVE(PERSISTENT_KEEPALIVE)");
                         self.timer_tick(TimePersistentKeepalive);
@@ -307,7 +306,7 @@ impl Tunn {
         TunnResult::Done
     }
 
-    pub fn time_since_last_handshake(&self) -> Option<Generic<<ClockImpl as Clock>::T>> {
+    pub fn time_since_last_handshake(&self) -> Option<ClockDuration> {
         let current_session = self.current;
         if self.sessions[current_session % super::N_SESSIONS].is_some() {
             let duration_since_tun_start = Instant::now().duration_since(self.timers.time_started);

boringtun/src/sleepyinstant/mod.rs

@@ -43,6 +43,12 @@ pub struct Instant {
     t: embedded_time::Instant<ClockImpl>,
 }
 
+/// The underlying unit of time for the clock.
+pub type ClockUnit = <ClockImpl as Clock>::T;
+
+/// A span of time between two instants of the clock.
+pub type ClockDuration = Generic<ClockUnit>;
+
 impl Instant {
     /// Returns an instant corresponding to "now".
     pub fn now() -> Self {
@@ -57,12 +63,12 @@ impl Instant {
     /// # Panics
     ///
     /// panics when `earlier` was later than `self`.
-    pub fn duration_since(&self, earlier: Instant) -> Generic<<ClockImpl as Clock>::T> {
+    pub fn duration_since(&self, earlier: Instant) -> ClockDuration {
         self.t.checked_duration_since(&earlier.t).unwrap()
     }
 
     /// Returns the amount of time elapsed since this instant was created.
-    pub fn elapsed(&self) -> Generic<<ClockImpl as Clock>::T> {
+    pub fn elapsed(&self) -> ClockDuration {
         Self::now().duration_since(*self)
     }
 }