implemented listeners for transfered event [CI SKIP]

Dockerfile

@@ -2,36 +2,37 @@ FROM rust:1.33-slim AS rustbuild
 
 FROM rustbuild AS eventbuild
 
-ARG MODE=--release
-
 WORKDIR /build
 
 RUN rustup target add x86_64-unknown-linux-musl
 
 COPY wg-event-gen/Cargo.* /build/
 
-RUN mkdir -p src && echo "fn main() {}" > src/main.rs && cargo build $MODE --target x86_64-unknown-linux-musl
+RUN mkdir -p src && echo "fn main() {}" > src/main.rs && cargo build --release --target x86_64-unknown-linux-musl
 
 COPY wg-event-gen/ /build
 
-RUN cargo build --target x86_64-unknown-linux-musl $MODE
+RUN cargo build --target x86_64-unknown-linux-musl
 
+FROM frolvlad/alpine-glibc AS test
+
+COPY --from=eventbuild /build/target/x86_64-unknown-linux-musl/debug/wg-event-gen /usr/bin/
+
+RUN echo "d41d8cd98f00b204e9800998ecf8427e  -" > test.md5 && wg-event-gen | md5sum -c test.md5
 
 FROM rustbuild AS boringbuild
 
-ARG MODE=--release
-
 WORKDIR /build
 
 RUN rustup target add x86_64-unknown-linux-musl
 
 COPY boringtun/Cargo.* /build/
 
-RUN mkdir -p src && echo "fn main() {}" > src/main.rs && touch src/lib.rs && cargo build $MODE #--target x86_64-unknown-linux-musl #Ring won't compile https://github.com/briansmith/ring/issues/713
+RUN mkdir -p src && echo "fn main() {}" > src/main.rs && touch src/lib.rs && cargo build --release #--target x86_64-unknown-linux-musl #Ring won't compile https://github.com/briansmith/ring/issues/713
 
 COPY boringtun/ /build
 
-RUN cargo build $MODE #--target x86_64-unknown-linux-musl
+RUN cargo build --release #--target x86_64-unknown-linux-musl
 
 
 FROM frolvlad/alpine-glibc
@@ -40,11 +41,9 @@ RUN echo http://nl.alpinelinux.org/alpine/edge/testing >> /etc/apk/repositories
 
 ENV WG_I_PREFER_BUGGY_USERSPACE_TO_POLISHED_KMOD=1
 
-ARG MODE=--release
+COPY --from=eventbuild /build/target/x86_64-unknown-linux-musl/debug/wg-event-gen /usr/bin/
 
-COPY --from=eventbuild /build/target/x86_64-unknown-linux-musl/*/wg-event-gen /usr/bin/
+COPY --from=boringbuild /build/target/release/boringtun /usr/bin/
-
-COPY --from=boringbuild /build/target/*/boringtun /usr/bin/
 
 COPY init.sh /init.sh
 

Makefile

@@ -5,8 +5,3 @@ build:
 	
 push: build
 	docker push ${REPO}     
-
-pull:
-	docker pull ${REPO}
-	docker pull ${REPO}:build-event-gen
-	docker pull ${REPO}:build-boringtun

handler.sh

@@ -24,10 +24,13 @@ case "$EVENT" in
         PREV_ENDPOINT=$8
 ;;
 "added")
+
 ;;
 "removed")
     
 ;;
+"transfered")
+
 *)
 exit 1
 ;;

wg-event-gen/Cargo.lock

@@ -1,3 +1,5 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
 [[package]]
 name = "ansi_term"
 version = "0.11.0"
@@ -130,6 +132,11 @@ name = "libc"
 version = "0.2.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
+[[package]]
+name = "number_prefix"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "proc-macro2"
 version = "0.4.27"
@@ -249,6 +256,7 @@ dependencies = [
  "base64 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "derive_builder 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "hex 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "number_prefix 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "structopt 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
  "structopt-derive 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
  "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -290,6 +298,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum hex 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "805026a5d0141ffc30abb3be3173848ad46a1b1664fe632428479619a3644d77"
 "checksum ident_case 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 "checksum libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)" = "48450664a984b25d5b479554c29cc04e3150c97aa4c01da5604a2d4ed9151476"
+"checksum number_prefix 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "17b02fc0ff9a9e4b35b3342880f48e896ebf69f2967921fe8646bf5b7125956a"
 "checksum proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4d317f9caece796be1980837fd5cb3dfec5613ebdb04ad0956deea83ce168915"
 "checksum quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "53fa22a1994bd0f9372d7a816207d8a2677ad0325b073f5c5332760f0fb62b5c"
 "checksum redox_syscall 0.1.50 (registry+https://github.com/rust-lang/crates.io-index)" = "52ee9a534dc1301776eff45b4fa92d2c39b1d8c3d3357e6eb593e0d795506fc2"

wg-event-gen/Cargo.toml

@@ -11,6 +11,7 @@ time = "0.1.42"
 structopt = "0.2.14"
 structopt-derive = "0.2.14"
 derive_builder = "0.7.1"
+number_prefix = "0.3.0"
 
 [profile.release]
 lto = true

wg-event-gen/src/controller.rs

@@ -1,5 +1,5 @@
 use crate::model::{
-    Base64Backed, ECCKey, Interface, Peer, PeerBuilder, SharedKey, WireguardController,
+    ECCKey, HexBackend, Interface, Peer, PeerBuilder, SharedKey, WireguardController,
 };
 use std::io::{BufRead, BufReader, Error, ErrorKind, Result, Write};
 use std::net::{IpAddr, SocketAddr};
@@ -33,9 +33,12 @@ impl WireguardController for Userspace {
             let value_as_num = || parse_err(value.parse::<u64>());
             let mut peer: Option<Peer> = None;
             let build_peer = |peer: &mut Option<Peer>, builder: &mut PeerBuilder| -> Result<()> {
+                if builder.has_key() {
+                    //Threat as uninitialized otherwise
                     let built: Result<Peer> = parse_err(builder.build());
                     *peer = Some(built?);
                     *builder = PeerBuilder::default();
+                }
                 Ok(())
             };
             let mut add_key = |peer: &mut Option<Peer>, key: ECCKey| -> Result<()> {
@@ -50,16 +53,24 @@ impl WireguardController for Userspace {
             match key.as_ref() {
                 "" => {
                     //Empty line means end of data
-                    build_peer(&mut peer, builder)?; //TODO: handle possible actual error case
+                    build_peer(&mut peer, builder).map_err(|err| {
+                        Error::new(
+                            ErrorKind::InvalidData,
+                            format!(
+                                "Protocol error, wireguard supplied insufficent data: {}",
+                                err
+                            ),
+                        )
+                    })?; //TODO: handle possible actual error case
                 }
                 "public_key" => {
-                    add_key(&mut peer, parse_err(ECCKey::from_base64(value))?)?;
+                    add_key(&mut peer, parse_err(ECCKey::from_hex(value))?)?;
                 }
                 "private_key" => {
-                    add_key(&mut peer, ECCKey::from_base64(value)?)?;
+                    add_key(&mut peer, ECCKey::from_hex(value)?)?;
                 }
                 "preshared_key" => {
-                    builder.shared_key(Some(SharedKey::from_base64(value)?));
+                    builder.shared_key(Some(SharedKey::from_hex(value)?));
                 }
                 "endpoint" => {
                     builder.endpoint(Some(parse_err(value.parse::<SocketAddr>())?));

wg-event-gen/src/gen.rs

@@ -19,35 +19,47 @@ pub(crate) fn gen_events(
             .map(|p| (*p, (prev.get(*p), state.get(*p))))
             .collect::<HashMap<&ECCKey, (Option<&Peer>, Option<&Peer>)>>()
     };
+    let d_zero = Duration::from_secs(0);
+    let h_ms = Duration::from_millis(100);
     for (_id, (prev, cur)) in side_by_side {
         match (prev, cur) {
             (Some(prev), Some(cur)) => {
-                let timedout = |peer: &Peer| {
-                    peer.last_handshake
-                        .map(|shake| {
-                            shake.elapsed().unwrap() > timeout
-                                || shake.elapsed().unwrap() + poll_interval < timeout
-                        })
-                        .unwrap_or(true)
-                };
-
                 if let (Some(prev_addr), Some(cur_addr)) = (prev.endpoint, cur.endpoint) {
                     if prev_addr != cur_addr {
-                        listeners.roaming(&cur, prev_addr);
+                        listeners.fire(Event::Roamed(&cur, prev_addr));
                     }
                 }
 
-                if !timedout(&prev) && timedout(&cur) {
+                let timedout_now = || !cur.last_handshake.is_some();
-                    listeners.disconnected(&cur);
-                    continue;
-                }
 
-                if timedout(&prev) && !timedout(&cur) {
+                let timedout_prev = || !prev.last_handshake.is_some();
-                    listeners.connected(&cur);
+
+                match (
+                    timedout_prev(),
+                    timedout_now(),
+                    prev.last_handshake.and_then(|p_shake| {
+                        cur.last_handshake
+                            .and_then(|c_shake| c_shake.duration_since(p_shake).ok())
+                    }),
+                ) {
+                    (false, true, _) => listeners.fire(Event::Disconnected(&cur)),
+                    (true, false, _) => listeners.fire(Event::Connected(&cur)),
+                    other => {
+                        //dbg!(other);
                     }
                 }
-            (None, Some(cur)) => listeners.added(&cur),
+                if prev.traffic != cur.traffic {
-            (Some(prev), None) => listeners.removed(&prev),
+                    if let ((p_tx, p_rx), (c_tx, c_rx)) = (prev.traffic, cur.traffic) {
+                        listeners.fire(Event::Transfered {
+                            peer: &cur,
+                            tx: c_tx - p_tx,
+                            rx: c_rx - p_rx,
+                        });
+                    }
+                }
+            }
+            (None, Some(cur)) => listeners.fire(Event::Added(&cur)),
+            (Some(prev), None) => listeners.fire(Event::Removed(&prev)),
             fail => {
                 println!("{:?}", fail);
                 unreachable!()
@@ -56,6 +68,7 @@ pub(crate) fn gen_events(
     }
 }
 
+/*
 #[cfg(test)]
 mod test {
     use super::*;
@@ -88,31 +101,31 @@ mod test {
         fn added<'a>(&self, peer: &'a Peer) {
             self.calls
                 .borrow_mut()
-                .push(format!("add {}", peer.public_key));
+                .push(format!("add {}", peer.key));
         }
 
         fn connected<'a>(&self, peer: &'a Peer) {
             self.calls
                 .borrow_mut()
-                .push(format!("con {}", peer.public_key));
+                .push(format!("con {}", peer.key));
         }
 
         fn disconnected<'a>(&self, peer: &'a Peer) {
             self.calls
                 .borrow_mut()
-                .push(format!("dis {}", peer.public_key));
+                .push(format!("dis {}", peer.key));
         }
 
         fn removed<'a>(&self, peer: &'a Peer) {
             self.calls
                 .borrow_mut()
-                .push(format!("rem {}", peer.public_key));
+                .push(format!("rem {}", peer.key));
         }
 
         fn roaming<'a>(&self, peer: &'a Peer, _previous_addr: SocketAddr) {
             self.calls
                 .borrow_mut()
-                .push(format!("rom {}", peer.public_key));
+                .push(format!("rom {}", peer.key));
         }
     }
 
@@ -128,7 +141,7 @@ mod test {
         let peer = peer();
         listeners.connected(&peer);
         assert_eq!(
-            vec![["con", &peer.public_key].join(" ")],
+            vec![["con", &peer.key].join(" ")],
             calls.borrow().clone()
         );
     }
@@ -141,121 +154,121 @@ mod test {
         let bkey = "HhRgEL2xsnEIqThSTUKLGaTXusorM1MFdjSSYvzBynY=";
         let key = b2h(bkey);
         Peer::from_kv(&vec![
-            ("public_key".to_string(), key.clone()),
+            ("key".to_string(), key.clone()),
             /*(
                 "last_handshake_time_nsec".to_string(),
                 (1000 * 1000 * 1).to_string(),
             ),*/
-            ("endpoint".to_string(), "1.1.1.1:22222".to_string()),
+("endpoint".to_string(), "1.1.1.1:22222".to_string()),
-        ])
+])
-        .unwrap()
+.unwrap()
-    }
-
-    #[test]
-    fn connected() {
-        let peer = peer();
-        let mut peer_cur = peer.clone();
-        let mut prev: HashMap<String, Peer> = HashMap::new();
-        let mut cur: HashMap<String, Peer> = HashMap::new();
-        cur.insert(peer_cur.public_key.clone(), peer_cur.clone());
-        let (listener, calls) = listeners();
-        let interval = time::Duration::from_secs(3);
-        gen_events(
-            &cur,
-            &prev,
-            &listener,
-            time::Duration::from_secs(3),
-            interval,
-        );
-        assert_eq!(
-            vec![["add", &peer_cur.public_key].join(" ")],
-            calls.borrow().clone()
-        );
-
-        gen_events(
-            &cur,
-            &cur,
-            &listener,
-            time::Duration::from_secs(3),
-            interval,
-        );
-
-        //Shouldn't gen any new events
-        assert!(calls.borrow().len() == 1);
-
-        let (listener, calls) = listeners();
-        gen_events(
-            &prev,
-            &cur,
-            &listener,
-            time::Duration::from_secs(10),
-            interval,
-        );
-        assert_eq!(
-            vec![["rem", &peer.public_key].join(" ")],
-            calls.borrow().clone()
-        );
-
-        calls.borrow_mut().clear();
-
-        let mut peer_prev = peer.clone();
-
-        peer_prev.endpoint = Some("2.2.2.2:33333".parse::<SocketAddr>().unwrap());
-
-        peer_prev.last_handshake = Some(time::Duration::from_secs(1000));
-
-        prev.insert(peer_prev.public_key.clone(), peer_prev.clone());
-
-        gen_events(
-            &prev,
-            &cur,
-            &listener,
-            time::Duration::from_secs(10),
-            interval,
-        );
-
-        assert!(calls
-            .borrow()
-            .clone()
-            .contains(&["rom", &peer.public_key].join(" ")));
-
-        calls.borrow_mut().clear();
-
-        let peer_prev = peer.clone();
-
-        peer_cur.last_handshake = Some(time::Duration::from_secs(5));
-
-        cur.insert(peer_cur.public_key.clone(), peer_cur.clone());
-        prev.insert(peer_prev.public_key.clone(), peer_prev.clone());
-
-        gen_events(
-            &cur,
-            &prev,
-            &listener,
-            time::Duration::from_secs(10),
-            interval,
-        );
-
-        assert_eq!(
-            vec![["con", &peer.public_key].join(" ")],
-            calls.borrow().clone()
-        );
-
-        calls.borrow_mut().clear();
-
-        //Other way around should be a disconnect
-        gen_events(
-            &prev,
-            &cur,
-            &listener,
-            time::Duration::from_secs(3),
-            interval,
-        );
-
-        assert_eq!(
-            vec![["dis", &peer.public_key].join(" ")],
-            calls.borrow().clone()
-        );
-    }
-
 }
+
+#[test]
+fn connected() {
+let peer = peer();
+let mut peer_cur = peer.clone();
+let mut prev: HashMap<String, Peer> = HashMap::new();
+let mut cur: HashMap<String, Peer> = HashMap::new();
+cur.insert(peer_cur.key.clone(), peer_cur.clone());
+let (listener, calls) = listeners();
+let interval = time::Duration::from_secs(3);
+gen_events(
+&cur,
+&prev,
+&listener,
+time::Duration::from_secs(3),
+interval,
+);
+assert_eq!(
+vec![["add", &peer_cur.key].join(" ")],
+calls.borrow().clone()
+);
+
+gen_events(
+&cur,
+&cur,
+&listener,
+time::Duration::from_secs(3),
+interval,
+);
+
+//Shouldn't gen any new events
+assert!(calls.borrow().len() == 1);
+
+let (listener, calls) = listeners();
+gen_events(
+&prev,
+&cur,
+&listener,
+time::Duration::from_secs(10),
+interval,
+);
+assert_eq!(
+vec![["rem", &peer.key].join(" ")],
+calls.borrow().clone()
+);
+
+calls.borrow_mut().clear();
+
+let mut peer_prev = peer.clone();
+
+peer_prev.endpoint = Some("2.2.2.2:33333".parse::<SocketAddr>().unwrap());
+
+peer_prev.last_handshake = Some(time::Duration::from_secs(1000));
+
+prev.insert(peer_prev.key.clone(), peer_prev.clone());
+
+gen_events(
+&prev,
+&cur,
+&listener,
+time::Duration::from_secs(10),
+interval,
+);
+
+assert!(calls
+.borrow()
+.clone()
+.contains(&["rom", &peer.key].join(" ")));
+
+calls.borrow_mut().clear();
+
+let peer_prev = peer.clone();
+
+peer_cur.last_handshake = Some(time::Duration::from_secs(5));
+
+cur.insert(peer_cur.key.clone(), peer_cur.clone());
+prev.insert(peer_prev.key.clone(), peer_prev.clone());
+
+gen_events(
+&cur,
+&prev,
+&listener,
+time::Duration::from_secs(10),
+interval,
+);
+
+assert_eq!(
+vec![["con", &peer.key].join(" ")],
+calls.borrow().clone()
+);
+
+calls.borrow_mut().clear();
+
+//Other way around should be a disconnect
+gen_events(
+&prev,
+&cur,
+&listener,
+time::Duration::from_secs(3),
+interval,
+);
+
+assert_eq!(
+vec![["dis", &peer.key].join(" ")],
+calls.borrow().clone()
+);
+}
+
+}*/

wg-event-gen/src/listener.rs

@@ -1,79 +1,72 @@
 use crate::Peer;
+use number_prefix::{NumberPrefix, Prefixed, Standalone};
 use std::net::SocketAddr;
 use std::path::PathBuf;
 use std::process::Command;
 use std::thread;
 use std::time::SystemTime;
 
+//#[non_exhaustive]
+#[derive(Debug, Clone)]
+pub enum Event<'a> {
+    Added(&'a Peer),
+    Removed(&'a Peer),
+    Connected(&'a Peer),
+    Disconnected(&'a Peer),
+    Roamed(&'a Peer, SocketAddr),
+    Transfered { peer: &'a Peer, tx: u64, rx: u64 },
+}
+
 pub trait EventListener {
-    fn added<'a>(&self, peer: &'a Peer) {
+    fn name(&self) -> &'static str;
-        self.connected(peer);
-    }
 
-    fn connected<'a>(&self, peer: &'a Peer);
+    fn fire<'a>(&self, event: Event<'a>);
-
-    fn disconnected<'a>(&self, peer: &'a Peer);
-
-    fn removed<'a>(&self, peer: &'a Peer) {
-        self.disconnected(peer)
-    }
-
-    fn roaming<'a>(&self, peer: &'a Peer, previous_addr: SocketAddr);
 }
 
 impl EventListener for Vec<Box<EventListener>> {
-    fn added<'a>(&self, peer: &'a Peer) {
+    fn name(&self) -> &'static str {
-        if cfg!(feature = "addrem") || cfg!(test) {
+        "List of Listeners"
-            self.iter().for_each(|l| l.added(&peer));
     }
-    }
+    fn fire<'a>(&self, event: Event<'a>) {
-
+        self.iter().for_each(|l| l.fire(event.clone()));
-    fn connected<'a>(&self, peer: &'a Peer) {
-        self.iter().for_each(|l| l.connected(&peer));
-    }
-
-    fn disconnected<'a>(&self, peer: &'a Peer) {
-        self.iter().for_each(|l| l.disconnected(&peer));
-    }
-
-    fn removed<'a>(&self, peer: &'a Peer) {
-        if cfg!(feature = "addrem") || cfg!(test) {
-            self.iter().for_each(|l| l.removed(&peer));
-        }
-    }
-
-    fn roaming<'a>(&self, peer: &'a Peer, previous_addr: SocketAddr) {
-        self.iter().for_each(|l| l.roaming(&peer, previous_addr));
     }
 }
 
 pub struct LogListener;
 
 impl EventListener for LogListener {
-    fn connected<'a>(&self, peer: &'a Peer) {
+    fn name(&self) -> &'static str {
-        println!("{} connected!", peer.key);
+        "Log"
     }
 
-    fn disconnected<'a>(&self, peer: &'a Peer) {
+    fn fire<'a>(&self, event: Event<'a>) {
-        println!("{} disconnected!", peer.key);
+        match event {
-    }
+            Event::Connected(peer) => println!("{} connected!", peer.key),
-
+            Event::Disconnected(peer) => println!("{} disconnected!", peer.key),
-    fn added<'a>(&self, peer: &'a Peer) {
+            Event::Added(peer) => println!("{} added!", peer.key),
-        println!("{} added!", peer.key);
+            Event::Removed(peer) => println!("{} removed!", peer.key),
-    }
+            Event::Roamed(peer, previous_addr) => println!(
-
-    fn removed<'a>(&self, peer: &'a Peer) {
-        println!("{} removed!", peer.key);
-    }
-
-    fn roaming<'a>(&self, peer: &'a Peer, previous_addr: SocketAddr) {
-        println!(
                 "{} roamed {} -> {}!",
                 peer.key,
                 previous_addr,
                 peer.endpoint.unwrap()
+            ),
+            Event::Transfered { peer, tx, rx } => {
+                let prefix = |cnt: u64| match NumberPrefix::binary(cnt as f64) {
+                    Standalone(bytes) => format!("{}B", bytes),
+                    Prefixed(prefix, n) => format!("{:.0} {}B", n, prefix),
+                };
+                println!(
+                    "{} transfered {} up, {} down",
+                    peer.key,
+                    prefix(tx),
+                    prefix(rx)
                 );
             }
+
+            _ => unimplemented!(),
+        }
+    }
 }
 
 pub struct ScriptListener {
@@ -134,27 +127,29 @@ impl ScriptListener {
 }
 
 impl EventListener for ScriptListener {
-    fn connected<'a>(&self, peer: &'a Peer) {
+    fn name(&self) -> &'static str {
-        self.call_sub(vec!["connected", &self.peer_props(peer)]);
+        "Script"
     }
-
+    fn fire<'a>(&self, event: Event<'a>) {
-    fn disconnected<'a>(&self, peer: &'a Peer) {
+        match event {
-        self.call_sub(vec!["disconnected", &self.peer_props(peer)]);
+            Event::Connected(peer) => self.call_sub(vec!["connected", &self.peer_props(peer)]),
+            Event::Disconnected(peer) => {
+                self.call_sub(vec!["disconnected", &self.peer_props(peer)])
             }
-
+            Event::Added(peer) => self.call_sub(vec!["added", &self.peer_props(peer)]),
-    fn added<'a>(&self, peer: &'a Peer) {
+            Event::Removed(peer) => self.call_sub(vec!["removed", &self.peer_props(peer)]),
-        self.call_sub(vec!["added", &self.peer_props(peer)]);
+            Event::Roamed(peer, previous_addr) => self.call_sub(vec![
-    }
-
-    fn removed<'a>(&self, peer: &'a Peer) {
-        self.call_sub(vec!["removed", &self.peer_props(peer)]);
-    }
-
-    fn roaming<'a>(&self, peer: &'a Peer, previous_addr: SocketAddr) {
-        self.call_sub(vec![
                 "roaming",
                 &self.peer_props(peer),
                 &previous_addr.to_string(),
-        ]);
+            ]),
+            Event::Transfered { peer, tx, rx } => self.call_sub(vec![
+                "transfered",
+                &self.peer_props(peer),
+                &tx.to_string(),
+                &rx.to_string(),
+            ]),
+            _ => unimplemented!(),
+        }
     }
 }

wg-event-gen/src/main.rs

@@ -17,9 +17,10 @@ use controller::Userspace;
 use model::WireguardController;
 use opts::Opts;
 use std::collections::HashMap;
+use std::error::Error;
 use std::io;
 use std::thread::sleep;
-use std::time::{Duration, Instant};
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 use structopt::StructOpt;
 
 fn listeners(opts: &Opts) -> Vec<Box<EventListener>> {
@@ -30,6 +31,7 @@ fn listeners(opts: &Opts) -> Vec<Box<EventListener>> {
     if opts.log {
         listeners.push(Box::new(LogListener));
     }
+    println!("Enabled handlers: {}", (&listeners.iter().map(|l| l.name()).collect::<Vec<_>>()).join(", "));
     listeners
 }
 
@@ -48,23 +50,22 @@ fn main() -> io::Result<()> {
     let mut peers_last: Option<HashMap<ECCKey, Peer>> = None;
     loop {
         let now = Instant::now();
-        let peers = controller.peers()?;
+        let peers = match controller.peers() {
-        /*println!("Connected peers:");
+            Err(ref err) if opts.ignore_socket_errors => {
-        for peer in peers {
+                eprintln!(
-            let peer = peer?;
+                    "Encountered error while querying Wireguard: {}",
-            if peer
+                    err.description()
-                .last_handshake
+                );
-                .map(|h| h.elapsed().unwrap() < timeout)
+                sleep(interval);
-                .unwrap_or(false)
+                continue;
-            {
-                println!("/\\{:?}  {}",(timeout - peer.last_handshake.unwrap().elapsed().unwrap()), peer);
             }
-        }*/
+            res => res?,
+        };
         let peers = peers
             .map(|peer| peer.map(|peer_ok| (peer_ok.key.clone(), peer_ok)))
             .collect::<io::Result<HashMap<_, _>>>()?;
-        if let Some(ref mut peers_last) = peers_last {
 
+        if let Some(ref mut peers_last) = peers_last {
             gen_events(&peers, &peers_last, &listeners, timeout, interval);
 
             *peers_last = peers;
@@ -72,7 +73,7 @@ fn main() -> io::Result<()> {
             peers_last = Some(peers);
         }
         let pause = interval - now.elapsed();
-        //dbg!(interval - pause);
+
         sleep(if pause > interval / 2 {
             pause
         } else {

wg-event-gen/src/model.rs

@@ -1,4 +1,5 @@
 use base64::{decode, encode};
+use hex;
 use std::error::Error;
 use std::fmt;
 use std::hash::{Hash, Hasher};
@@ -21,6 +22,31 @@ impl fmt::Display for ECCKey {
     }
 }
 
+pub trait HexBackend {
+    fn from_bytes(bytes: Vec<u8>) -> Self;
+    fn bytes(&self) -> &Vec<u8>;
+    fn from_hex<I: AsRef<str>>(key: I) -> io::Result<Self>
+    where
+        Self: Sized,
+    {
+        Ok(Self::from_bytes(hex::decode(key.as_ref()).map_err(
+            |_| io::Error::new(io::ErrorKind::InvalidData, "Failed to decode hexstring"),
+        )?))
+    }
+    fn as_hex(&self) -> io::Result<String> {
+        Ok(hex::encode(&self.bytes()))
+    }
+}
+
+impl<T: Base64Backed> HexBackend for T {
+    fn from_bytes(bytes: Vec<u8>) -> Self {
+        <Self as Base64Backed>::from_bytes(bytes)
+    }
+    fn bytes(&self) -> &Vec<u8> {
+        <Self as Base64Backed>::bytes(self)
+    }
+}
+
 pub trait Base64Backed {
     fn from_bytes(bytes: Vec<u8>) -> Self;
     fn bytes(&self) -> &Vec<u8>;
@@ -34,7 +60,7 @@ pub trait Base64Backed {
                 return Err(io::Error::new(
                     io::ErrorKind::InvalidData,
                     "Failed to decode base64",
-                ))
+                ));
             }
         }; /*.map_err(|err| {
 
@@ -168,6 +194,10 @@ impl PeerBuilder {
         self.validate().is_ok()
     }
 
+    pub fn has_key(&self) -> bool {
+        self.key.is_some()
+    }
+
     pub fn add_allowed_ip(&mut self, ip: (IpAddr, u8)) {
         if let Some(ref mut ips) = &mut self.allowed_ips {
             ips.push(ip);
@@ -203,3 +233,15 @@ pub trait WireguardController {
 
     fn update_peer(&mut self, peer: &Peer) -> io::Result<()>;
 }
+
+#[cfg(test)]
+mod test {
+
+    use super::*;
+    #[test]
+    fn key_encoding() {
+        let key_encoded = "08df3bebd54217eb769d607f8673e1c3c53bb55d6ac689348a9227c8c4dd8857";
+        let key = ECCKey::from_hex(key_encoded).unwrap();
+        assert_eq!(&key.as_hex().unwrap(), key_encoded);
+    }
+}

wg-event-gen/src/opts.rs

@@ -4,14 +4,16 @@ use structopt::StructOpt;
 #[derive(StructOpt, Debug)]
 #[structopt(name = "event-gen")]
 pub struct Opts {
+    ///Time after which a client is considered as offline
     #[structopt(
         short = "t",
         long = "timeout",
-        default_value = "120",
+        default_value = "115",
         env = "WG_EVENT_TIMEOUT"
     )]
     pub timeout: u64,
 
+    ///Interval after which Wireguard will be polled for updates
     #[structopt(
         short = "p",
         long = "poll-interval",
@@ -20,6 +22,7 @@ pub struct Opts {
     )]
     pub poll: u64,
 
+    ///Programm to run when an event has fired
     #[structopt(
         short = "e",
         long = "event-handler",
@@ -28,12 +31,15 @@ pub struct Opts {
     )]
     pub events: Option<PathBuf>,
 
+    ///Don't exit on API errors
     #[structopt(short = "I", long = "ignore-socket-err", env = "WG_IGNORE_SOCKET_ERR")]
     pub ignore_socket_errors: bool,
 
+    ///Log all events to Stdout
     #[structopt(short = "l", long = "log", env = "WG_LOG_EVENTS")]
     pub log: bool,
 
+    ///Socket for the userspace implementation to poll
     #[structopt(name = "SOCKET", parse(from_os_str), env = "WG_EVENT_SOCKET")]
     pub socket: PathBuf,
 }

wg-event-gen/upload.sh

@@ -1 +1 @@
-cargo build --release && cat target/release/wg-event-gen | ssh core@ks1 "sudo bash -c 'cat > /srv/vpn/wireguard/event-gen'"
+cargo +nightly build && cat target/release/wg-event-gen | ssh core@ks1 "sudo bash -c 'rm -f /srv/vpn/wireguard/event-gen; cat > /srv/vpn/wireguard/event-gen; chmod +x /srv/vpn/wireguard/event-gen'"