From 56ac8740b79e291eabe6427d722921533b3a9837 Mon Sep 17 00:00:00 2001
From: diogo464 <diogo464@d464.sh>
Date: Sun, 15 Feb 2026 22:05:57 +0000
Subject: updated dependencies

---
 src/view.rs | 59 ++++++++++++++++++++++++++++++++---------------------------
 1 file changed, 32 insertions(+), 27 deletions(-)

(limited to 'src/view.rs')

diff --git a/src/view.rs b/src/view.rs
index 2858811..69f718a 100644
--- a/src/view.rs
+++ b/src/view.rs
@@ -1,9 +1,12 @@
-use std::{net::SocketAddr, time::SystemTime};
+use std::{
+    net::SocketAddr,
+    time::{Duration, SystemTime},
+};
 
 use ipnet::IpNet;
 use netlink_packet_wireguard::{
-    nlas::{WgAllowedIp, WgAllowedIpAttrs, WgDeviceAttrs, WgPeer, WgPeerAttrs},
-    Wireguard,
+    WireguardAllowedIp, WireguardAllowedIpAttr, WireguardAttribute, WireguardMessage,
+    WireguardPeer, WireguardPeerAttribute,
 };
 
 use super::{Error, Key, Result};
@@ -31,7 +34,7 @@ pub struct PeerView {
     pub allowed_ips: Vec<IpNet>,
 }
 
-pub(super) fn device_view_from_payload(wg: Wireguard) -> Result<DeviceView> {
+pub(super) fn device_view_from_payload(wg: WireguardMessage) -> Result<DeviceView> {
     let mut if_index = None;
     let mut if_name = None;
     let mut private_key = None;
@@ -40,15 +43,15 @@ pub(super) fn device_view_from_payload(wg: Wireguard) -> Result<DeviceView> {
     let mut fwmark = None;
     let mut peers = None;
 
-    for nla in wg.nlas {
-        match nla {
-            WgDeviceAttrs::IfIndex(v) => if_index = Some(v),
-            WgDeviceAttrs::IfName(v) => if_name = Some(v),
-            WgDeviceAttrs::PrivateKey(v) => private_key = Some(Key::from(v)),
-            WgDeviceAttrs::PublicKey(v) => public_key = Some(Key::from(v)),
-            WgDeviceAttrs::ListenPort(v) => listen_port = Some(v),
-            WgDeviceAttrs::Fwmark(v) => fwmark = Some(v),
-            WgDeviceAttrs::Peers(v) => peers = Some(peers_from_wg_peers(v)?),
+    for attr in wg.attributes {
+        match attr {
+            WireguardAttribute::IfIndex(v) => if_index = Some(v),
+            WireguardAttribute::IfName(v) => if_name = Some(v),
+            WireguardAttribute::PrivateKey(v) => private_key = Some(Key::from(v)),
+            WireguardAttribute::PublicKey(v) => public_key = Some(Key::from(v)),
+            WireguardAttribute::ListenPort(v) => listen_port = Some(v),
+            WireguardAttribute::Fwmark(v) => fwmark = Some(v),
+            WireguardAttribute::Peers(v) => peers = Some(peers_from_wg_peers(v)?),
             _ => {}
         }
     }
@@ -64,7 +67,7 @@ pub(super) fn device_view_from_payload(wg: Wireguard) -> Result<DeviceView> {
     })
 }
 
-fn peers_from_wg_peers(wg_peers: Vec<WgPeer>) -> Result<Vec<PeerView>> {
+fn peers_from_wg_peers(wg_peers: Vec<WireguardPeer>) -> Result<Vec<PeerView>> {
     let mut peers = Vec::with_capacity(wg_peers.len());
     for wg_peer in wg_peers {
         peers.push(peer_from_wg_peer(wg_peer)?);
@@ -72,7 +75,7 @@ fn peers_from_wg_peers(wg_peers: Vec<WgPeer>) -> Result<Vec<PeerView>> {
     Ok(peers)
 }
 
-fn peer_from_wg_peer(wg_peer: WgPeer) -> Result<PeerView> {
+fn peer_from_wg_peer(wg_peer: WireguardPeer) -> Result<PeerView> {
     let mut public_key = None;
     let mut preshared_key = None;
     let mut endpoint = None;
@@ -84,14 +87,14 @@ fn peer_from_wg_peer(wg_peer: WgPeer) -> Result<PeerView> {
 
     for attr in wg_peer.iter() {
         match attr {
-            WgPeerAttrs::PublicKey(v) => public_key = Some(Key::from(v)),
-            WgPeerAttrs::PresharedKey(v) => preshared_key = Some(Key::from(v)),
-            WgPeerAttrs::Endpoint(v) => endpoint = Some(*v),
-            WgPeerAttrs::PersistentKeepalive(v) => persistent_keepalive = Some(*v),
-            WgPeerAttrs::LastHandshake(v) => last_handshake = Some(*v),
-            WgPeerAttrs::RxBytes(v) => rx_bytes = Some(*v),
-            WgPeerAttrs::TxBytes(v) => tx_bytes = Some(*v),
-            WgPeerAttrs::AllowedIps(v) => {
+            WireguardPeerAttribute::PublicKey(v) => public_key = Some(Key::from(v)),
+            WireguardPeerAttribute::PresharedKey(v) => preshared_key = Some(Key::from(v)),
+            WireguardPeerAttribute::Endpoint(v) => endpoint = Some(*v),
+            WireguardPeerAttribute::PersistentKeepalive(v) => persistent_keepalive = Some(*v),
+            WireguardPeerAttribute::LastHandshake(v) => last_handshake = Some(*v),
+            WireguardPeerAttribute::RxBytes(v) => rx_bytes = Some(*v),
+            WireguardPeerAttribute::TxBytes(v) => tx_bytes = Some(*v),
+            WireguardPeerAttribute::AllowedIps(v) => {
                 for ip in v {
                     allowed_ips.push(ipnet_from_wg(ip)?);
                 }
@@ -105,20 +108,22 @@ fn peer_from_wg_peer(wg_peer: WgPeer) -> Result<PeerView> {
         preshared_key,
         endpoint,
         persistent_keepalive,
-        last_handshake: last_handshake.ok_or_else(|| Error::message("missing last_handshake"))?,
+        last_handshake: last_handshake
+            .map(|ts| SystemTime::now() - Duration::new(ts.seconds as u64, ts.nano_seconds as u32))
+            .ok_or_else(|| Error::message("missing last_handshake"))?,
         rx_bytes: rx_bytes.ok_or_else(|| Error::message("missing rx_bytes"))?,
         tx_bytes: tx_bytes.ok_or_else(|| Error::message("missing tx_bytes"))?,
         allowed_ips,
     })
 }
 
-fn ipnet_from_wg(wg: &WgAllowedIp) -> Result<IpNet> {
+fn ipnet_from_wg(wg: &WireguardAllowedIp) -> Result<IpNet> {
     let mut ip = None;
     let mut prefix = None;
     for attr in wg.iter() {
         match attr {
-            WgAllowedIpAttrs::IpAddr(v) => ip = Some(*v),
-            WgAllowedIpAttrs::Cidr(v) => prefix = Some(*v),
+            WireguardAllowedIpAttr::IpAddr(v) => ip = Some(*v),
+            WireguardAllowedIpAttr::Cidr(v) => prefix = Some(*v),
             _ => {}
         }
     }
-- 
cgit