init

1 files changed, 130 insertions, 0 deletions

diff --git a/src/view.rs b/src/view.rs
new file mode 100644
index 0000000..2858811
--- /dev/null
+++ b/src/view.rs
@@ -0,0 +1,130 @@
+use std::{net::SocketAddr, time::SystemTime};
+
+use ipnet::IpNet;
+use netlink_packet_wireguard::{
+    nlas::{WgAllowedIp, WgAllowedIpAttrs, WgDeviceAttrs, WgPeer, WgPeerAttrs},
+    Wireguard,
+};
+
+use super::{Error, Key, Result};
+
+#[derive(Debug, Clone)]
+pub struct DeviceView {
+    pub name: String,
+    pub ifindex: u32,
+    pub private_key: Option<Key>,
+    pub public_key: Option<Key>,
+    pub listen_port: u16,
+    pub fwmark: u32,
+    pub peers: Vec<PeerView>,
+}
+
+#[derive(Debug, Clone)]
+pub struct PeerView {
+    pub public_key: Key,
+    pub preshared_key: Option<Key>,
+    pub endpoint: Option<SocketAddr>,
+    pub persistent_keepalive: Option<u16>,
+    pub last_handshake: SystemTime,
+    pub rx_bytes: u64,
+    pub tx_bytes: u64,
+    pub allowed_ips: Vec<IpNet>,
+}
+
+pub(super) fn device_view_from_payload(wg: Wireguard) -> Result<DeviceView> {
+    let mut if_index = None;
+    let mut if_name = None;
+    let mut private_key = None;
+    let mut public_key = None;
+    let mut listen_port = None;
+    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)?),
+            _ => {}
+        }
+    }
+
+    Ok(DeviceView {
+        name: if_name.ok_or_else(|| Error::message("missing if_name"))?,
+        ifindex: if_index.ok_or_else(|| Error::message("missing if_index"))?,
+        private_key,
+        public_key,
+        listen_port: listen_port.ok_or_else(|| Error::message("missing listen_port"))?,
+        fwmark: fwmark.ok_or_else(|| Error::message("missing fwmark"))?,
+        peers: peers.unwrap_or_default(),
+    })
+}
+
+fn peers_from_wg_peers(wg_peers: Vec<WgPeer>) -> 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)?);
+    }
+    Ok(peers)
+}
+
+fn peer_from_wg_peer(wg_peer: WgPeer) -> Result<PeerView> {
+    let mut public_key = None;
+    let mut preshared_key = None;
+    let mut endpoint = None;
+    let mut persistent_keepalive = None;
+    let mut last_handshake = None;
+    let mut rx_bytes = None;
+    let mut tx_bytes = None;
+    let mut allowed_ips = Vec::default();
+
+    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) => {
+                for ip in v {
+                    allowed_ips.push(ipnet_from_wg(ip)?);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    Ok(PeerView {
+        public_key: public_key.ok_or_else(|| Error::message("missing public_key"))?,
+        preshared_key,
+        endpoint,
+        persistent_keepalive,
+        last_handshake: last_handshake.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> {
+    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),
+            _ => {}
+        }
+    }
+    Ok(IpNet::new(
+        ip.ok_or_else(|| Error::message("missing ip"))?,
+        prefix.ok_or_else(|| Error::message("missing prefix"))?,
+    )
+    .map_err(|e| Error::with_message(e, "invalid ipnet"))?)
+}