supply more info

wg-event-gen/src/listener.rs

@@ -84,6 +84,35 @@ impl ScriptListener {
         ScriptListener { script }
     }
 
+    fn peer_props<'a>(&self,peer: &'a Peer) -> String {
+        format!(
+            "{id} {allowed_ips} {endpoint} {last_handshake} {persistent_keepalive} {traffic}",
+            id = peer.public_key,
+            allowed_ips = peer
+                .allowed_ips
+                .iter()
+                .map(|(addr, mask)| [addr.to_string(), mask.to_string()].join("/"))
+                .collect::<Vec<String>>()
+                .join(","),
+            endpoint = peer
+                .endpoint
+                .map(|e| e.to_string())
+                .unwrap_or("0".to_owned()),
+            last_handshake = peer
+                .last_handshake
+                .map(|s| s.as_secs() as i64)
+                .unwrap_or(-1),
+            persistent_keepalive = peer
+                .persistent_keepalive
+                .map(|k| k.as_secs() as i64)
+                .unwrap_or(-1),
+            traffic = {
+                let (rx, tx) = peer.traffic;
+                [rx.to_string(), tx.to_string()].join(",")
+            }
+        )
+    }
+
     fn mkcmd<'a>(&self, args: Vec<&'a str>) -> Command {
         let mut cmd = Command::new("/bin/sh");
         cmd.arg("-c");
@@ -105,27 +134,26 @@ impl ScriptListener {
 
 impl EventListener for ScriptListener {
     fn connected<'a>(&self, peer: &'a Peer) {
-        self.call_sub(vec!["connected", &peer.public_key]);
+        self.call_sub(vec!["connected", &self.peer_props(peer)]);
     }
 
     fn disconnected<'a>(&self, peer: &'a Peer) {
-        self.call_sub(vec!["disconnected", &peer.public_key]);
+        self.call_sub(vec!["disconnected", &self.peer_props(peer)]);
     }
 
     fn added<'a>(&self, peer: &'a Peer) {
-        self.call_sub(vec!["added", &peer.public_key]);
+        self.call_sub(vec!["added", &self.peer_props(peer)]);
     }
 
     fn removed<'a>(&self, peer: &'a Peer) {
-        self.call_sub(vec!["removed", &peer.public_key]);
+        self.call_sub(vec!["removed", &self.peer_props(peer)]);
     }
 
     fn roaming<'a>(&self, peer: &'a Peer, previous_addr: SocketAddr) {
         self.call_sub(vec![
             "roaming",
-            &peer.public_key,
+            &self.peer_props(peer),
             &previous_addr.to_string(),
-            &peer.endpoint.unwrap().to_string(),
         ]);
     }
 }

wg-event-gen/src/main.rs

@@ -11,7 +11,7 @@ use std::env;
 use std::fmt;
 use std::io::prelude::*;
 use std::io::{BufRead, BufReader, Error, ErrorKind, Result};
-use std::net::SocketAddr;
+use std::net::{IpAddr, SocketAddr};
 use std::os::unix::net::UnixStream;
 use std::path::PathBuf;
 use std::thread;
@@ -30,8 +30,10 @@ enum State {
 pub struct Peer {
     public_key: String,
     endpoint: Option<SocketAddr>,
+    allowed_ips: Vec<(IpAddr, u8)>,
     last_handshake: Option<Duration>,
     persistent_keepalive: Option<Duration>,
+    traffic: (u64, u64),
     parsed: time::Timespec,
 }
 
@@ -53,6 +55,23 @@ impl Peer {
                 .filter(|(key, _)| key == &"endpoint")
                 .map(|(_, value)| value.parse::<SocketAddr>().unwrap())
                 .next(),
+            allowed_ips: entries
+                .iter()
+                .filter(|(key, _)| key == &"allowed_ip")
+                .map(|(_, value)| {
+                    let mut parts = value.split("/").into_iter();
+                    match (
+                        parts.next().and_then(|addr| addr.parse::<IpAddr>().ok()),
+                        parts.next().and_then(|mask| mask.parse::<u8>().ok()),
+                    ) {
+                        (Some(addr), Some(mask)) => Some((addr, mask)),
+                        (Some(addr), None) if addr.is_ipv6() => Some((addr, 128)),
+                        (Some(addr), None) => Some((addr, 32)),
+                        _ => None,
+                    }
+                })
+                .filter_map(|net| net)
+                .collect::<Vec<(IpAddr, u8)>>(),
             last_handshake: entries
                 .iter()
                 .filter_map(|(key, value)| {
@@ -79,6 +98,7 @@ impl Peer {
                 .filter(|(key, _)| key == &"persistent_keepalive")
                 .map(|(_, value)| Duration::from_secs(value.parse::<u64>().unwrap()))
                 .next(),
+            traffic: (0, 0),
             parsed: time::get_time(),
         })
     }