Epoll (#20)

major update:
- remove threading overhead by resorting to an event driven design with mio as a backend for epoll
- Clients can now have an arbitrary amount of ip adresses and lan-mouse will automatically choose the correct one
- -> seemless switching between ethernet and wifi
- cli frontend + frontend adapter for future frontends

src/frontend/cli.rs

@@ -0,0 +1,85 @@
+use anyhow::Result;
+use std::{thread, io::Write, net::SocketAddr};
+#[cfg(windows)]
+use std::net::SocketAddrV4;
+
+#[cfg(unix)]
+use std::{os::unix::net::UnixStream, path::Path, env};
+#[cfg(windows)]
+use std::net::TcpStream;
+
+use crate::client::Position;
+
+use super::{FrontendEvent, Frontend};
+
+pub struct CliFrontend;
+
+impl Frontend for CliFrontend {}
+
+impl CliFrontend {
+    pub fn new() -> Result<CliFrontend> {
+        #[cfg(unix)]
+        let socket_path = Path::new(env::var("XDG_RUNTIME_DIR")?.as_str()).join("lan-mouse-socket.sock");
+        thread::Builder::new()
+            .name("cli-frontend".to_string())
+            .spawn(move || {
+            loop {
+                eprint!("lan-mouse > ");
+                std::io::stderr().flush().unwrap();
+                let mut buf = String::new();
+                match std::io::stdin().read_line(&mut buf) {
+                    Ok(len) => {
+                        if let Some(event) = parse_event(buf, len) {
+                            #[cfg(unix)]
+                            let Ok(mut stream) = UnixStream::connect(&socket_path) else {
+                                log::error!("Could not connect to lan-mouse-socket");
+                                continue;
+                            };
+                            #[cfg(windows)]
+                            let Ok(mut stream) = TcpStream::connect("127.0.0.1:5252".parse::<SocketAddrV4>().unwrap()) else {
+                                log::error!("Could not connect to lan-mouse-server");
+                                continue;
+                            };
+                            let json = serde_json::to_string(&event).unwrap();
+                            if let Err(e) = stream.write(json.as_bytes()) {
+                                log::error!("error sending message: {e}");
+                            };
+                            if event == FrontendEvent::RequestShutdown() {
+                                break;
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        log::error!("{e:?}");
+                        break
+                    }
+                }
+            }
+        }).unwrap();
+        Ok(Self {})
+    }
+}
+
+fn parse_event(s: String, len: usize) -> Option<FrontendEvent> {
+    if len == 0 {
+        return Some(FrontendEvent::RequestShutdown())
+    }
+    let mut l = s.split_whitespace();
+    let cmd = l.next()?;
+    match cmd {
+        "connect" => {
+            let addr = match l.next()?.parse() {
+                Ok(addr) => SocketAddr::V4(addr),
+                Err(e) => {
+                    log::error!("parse error: {e}");
+                    return None;
+                }
+            };
+            Some(FrontendEvent::RequestClientAdd(addr, Position::Left ))
+        }
+        _ => {
+            log::error!("unknown command: {s}");
+            None
+        }
+    }
+}