Compiles [WIP][CI SKIP]

wg-event-gen/src/controller.rs

@@ -18,35 +18,39 @@ impl WireguardController for Userspace {
         let mut stream = UnixStream::connect(&self.0)?;
         stream.write_all(b"get=1\n")?;
 
-        fn build_peer(builder: &mut PeerBuilder, line: Result<String>) -> Option<Result<Peer>> {
-            let line = match line {
-                Ok(line) => line,
-                Err(e) => return Some(Err(e)),
-            };
-            fn parse_err<O, E>(res: std::error::Result<O, E>) -> Result<O> {
-                res.map_err(|err: String| Error::new(ErrorKind::InvalidData, err.into()))
+        fn build_peer(builder: &mut PeerBuilder, line: Result<String>) -> Result<Option<Peer>> {
+            let line = line?;
+            fn parse_err<O, E: Into<Box<dyn std::error::Error + Sync + Send>>>(
+                res: std::result::Result<O, E>,
+            ) -> Result<O> {
+                res.map_err(|err| Error::new(ErrorKind::InvalidData, err))
             }
             let mut iter = line.chars();
             let key = iter.by_ref().take_while(|c| c != &'=').collect::<String>();
             let value = iter.collect::<String>();
             let value_as_num = || parse_err(value.parse::<u64>());
             let mut peer: Option<Peer> = None;
-            let add_key = |key| {
+            let build_peer = |peer: &mut Option<Peer>, builder: &mut PeerBuilder| -> Result<()> {
+                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<()> {
                 if builder.is_whole() {
-                    peer = Some(parse_err(builder.build())?);
-                    *builder = PeerBuilder::default();
+                    build_peer(peer, builder)?;
                 } else {
-                    peer = None
+                    *peer = None
                 }
                 builder.key(key);
-                Ok(peer)
+                Ok(())
             };
             match key.as_ref() {
                 "public_key" => {
-                    add_key(parse_err(ECCKey::from_base64(value))?)?;
+                    add_key(&mut peer, parse_err(ECCKey::from_base64(value))?)?;
                 }
-                /*"private_key" => {
-                    add_key(ECCKey::from_base64(value)?)?;
+                "private_key" => {
+                    add_key(&mut peer, ECCKey::from_base64(value)?)?;
                 }
                 "endpoint" => {
                     builder.endpoint(Some(parse_err(value.parse::<SocketAddr>())?));
@@ -56,10 +60,10 @@ impl WireguardController for Userspace {
                 }
                 "last_handshake_time_nsec" => {
                     builder.add_last_handshake(Duration::from_nanos(value_as_num()?.into()));
-                },
+                }
                 "persistent_keepalive" => {
                     builder.persistent_keepalive(Some(Duration::from_secs(value_as_num()?.into())));
-                },*/
+                }
                 "allowed_ip" => {
                     let mut parts = value.split("/").into_iter();
                     let net = match (
@@ -75,13 +79,28 @@ impl WireguardController for Userspace {
                         builder.add_allowed_ip(net);
                     }
                 }
+                "errno" => match value_as_num()? {
+                    0 => build_peer(&mut peer, builder)?,
+                    code => Err(Error::new(
+                        ErrorKind::Other,
+                        format!("Returned error code: {}", code),
+                    ))?,
+                },
+                _ => Err(Error::new(ErrorKind::InvalidData, "Unknown key"))?,
             }
-            peer.map(|peer| Ok(peer))
+            Ok(peer)
         }
 
         let peers = BufReader::new(stream)
             .lines()
-            .scan(PeerBuilder::default(), build_peer);
+            .scan(PeerBuilder::default(), |builder, line| {
+                match build_peer(builder, line) {
+                    Ok(Some(value)) => Some(Some(Ok(value))),
+                    Err(err) => None, //TODO: propagate
+                    _ => Some(None),
+                }
+            })
+            .filter_map(|peer| peer);
         Ok(Box::new(peers))
     }
 

wg-event-gen/src/model.rs

@@ -13,15 +13,20 @@ pub enum ECCKey {
 
 impl ECCKey {
     pub fn from_base64<I: AsRef<str>>(key: I) -> io::Result<ECCKey> {
-        let key = decode(key.as_ref()).map_err(|err| {
-            io::Error::new(io::ErrorKind::InvalidData, "Failed to decode base64".into())
-        })?;
-        let bytes = [0; 32];
+        let key = match decode(key.as_ref()) {
+            Ok(key) => key,
+            _ => {
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    "Failed to decode base64",
+                ))
+            }
+        }; /*.map_err(|err| {
+
+           })?;*/
+        let mut bytes = [0; 32];
         if key.len() != 32 {
-            return Err(io::Error::new(
-                io::ErrorKind::Other,
-                "Mismatched key size".into(),
-            ));
+            return Err(io::Error::new(io::ErrorKind::Other, "Mismatched key size"));
         }
         bytes.copy_from_slice(&key);
         Ok(ECCKey::PublicKey(bytes))
@@ -62,10 +67,11 @@ impl PeerBuilder {
     }
 
     pub fn add_allowed_ip(&mut self, ip: (IpAddr, u8)) {
-        if !self.allowed_ips.is_some() {
-            self.allowed_ips = Some(Vec::new());
+        if let Some(ref mut ips) = &mut self.allowed_ips {
+            ips.push(ip);
+        } else {
+            self.allowed_ips = Some(vec![ip]);
         }
-        self.allowed_ips.map(|ips| ips.push(ip));
     }
 
     pub fn add_last_handshake(&mut self, d: Duration) {