produce events in dummy capture-backend

2026-03-08 04:20:01 +03:00 · 2024-09-02 17:27:03 +02:00
43 changed files with 893 additions and 1170 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1313,17 +1313,21 @@ dependencies = [
 name = "lan-mouse"
 version = "0.9.1"
 dependencies = [
+ "anyhow",
+ "async-channel",
 "clap",
+ "endi",
 "env_logger",
 "futures",
+ "glib-build-tools",
+ "gtk4",
 "hickory-resolver",
+ "hostname 0.4.0",
 "input-capture",
 "input-emulation",
 "input-event",
- "lan-mouse-cli",
- "lan-mouse-gtk",
- "lan-mouse-ipc",
 "lan-mouse-proto",
+ "libadwaita",
 "libc",
 "local-channel",
 "log",
@@ -1336,41 +1340,6 @@ dependencies = [
 "toml",
 ]

-[[package]]
-name = "lan-mouse-cli"
-version = "0.1.0"
-dependencies = [
- "futures",
- "lan-mouse-ipc",
- "tokio",
-]
-
-[[package]]
-name = "lan-mouse-gtk"
-version = "0.1.0"
-dependencies = [
- "async-channel",
- "glib-build-tools",
- "gtk4",
- "hostname 0.4.0",
- "lan-mouse-ipc",
- "libadwaita",
- "log",
-]
-
-[[package]]
-name = "lan-mouse-ipc"
-version = "0.1.0"
-dependencies = [
- "futures",
- "log",
- "serde",
- "serde_json",
- "thiserror",
- "tokio",
- "tokio-stream",
-]
-
 [[package]]
 name = "lan-mouse-proto"
 version = "0.1.0"
@@ -2121,17 +2090,6 @@ dependencies = [
 "syn",
 ]

-[[package]]
-name = "tokio-stream"
-version = "0.1.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af"
-dependencies = [
- "futures-core",
- "pin-project-lite",
- "tokio",
-]
-
 [[package]]
 name = "tokio-util"
 version = "0.7.11"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,13 +1,5 @@
 [workspace]
-members = [
-    "input-capture",
-    "input-emulation",
-    "input-event",
-    "lan-mouse-ipc",
-    "lan-mouse-cli",
-    "lan-mouse-gtk",
-    "lan-mouse-proto",
-]
+members = ["input-capture", "input-emulation", "input-event", "lan-mouse-proto"]

 [package]
 name = "lan-mouse"
@@ -25,14 +17,12 @@ lto = "fat"
 input-event = { path = "input-event", version = "0.2.1" }
 input-emulation = { path = "input-emulation", version = "0.2.1", default-features = false }
 input-capture = { path = "input-capture", version = "0.2.0", default-features = false }
-lan-mouse-cli = { path = "lan-mouse-cli", version = "0.1.0" }
-lan-mouse-gtk = { path = "lan-mouse-gtk", version = "0.1.0", optional = true }
-lan-mouse-ipc = { path = "lan-mouse-ipc", version = "0.1.0" }
 lan-mouse-proto = { path = "lan-mouse-proto", version = "0.1.0" }

 hickory-resolver = "0.24.1"
 toml = "0.8"
 serde = { version = "1.0", features = ["derive"] }
+anyhow = "1.0.71"
 log = "0.4.20"
 env_logger = "0.11.3"
 serde_json = "1.0.107"
@@ -48,7 +38,16 @@ tokio = { version = "1.32.0", features = [
 ] }
 futures = "0.3.28"
 clap = { version = "4.4.11", features = ["derive"] }
+gtk = { package = "gtk4", version = "0.9.0", features = [
+    "v4_2",
+], optional = true }
+adw = { package = "libadwaita", version = "0.7.0", features = [
+    "v1_1",
+], optional = true }
+async-channel = { version = "2.1.1", optional = true }
+hostname = "0.4.0"
 slab = "0.4.9"
+endi = "1.1.0"
 thiserror = "1.0.61"
 tokio-util = "0.7.11"
 local-channel = "0.1.5"
@@ -56,10 +55,13 @@ local-channel = "0.1.5"
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.148"

+[build-dependencies]
+glib-build-tools = { version = "0.20.0", optional = true }
+
 [features]
 default = ["wayland", "x11", "xdg_desktop_portal", "libei", "gtk"]
 wayland = ["input-capture/wayland", "input-emulation/wayland"]
 x11 = ["input-capture/x11", "input-emulation/x11"]
 xdg_desktop_portal = ["input-emulation/xdg_desktop_portal"]
 libei = ["input-event/libei", "input-capture/libei", "input-emulation/libei"]
-gtk = ["dep:lan-mouse-gtk"]
+gtk = ["dep:gtk", "dep:adw", "dep:async-channel", "dep:glib-build-tools"]
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@ Focus lies on performance and a clean, manageable implementation that can easily

 ***blazingly fast™*** because it's written in rust.

-For an alternative (with slightly different goals) you may check out [Synergy 1 Community Edition](https://github.com/symless/synergy) or [Input Leap](https://github.com/input-leap) (Synergy fork).
+For an alternative (with slightly different goals) you may check out [Input Leap](https://github.com/input-leap).


 > [!WARNING]
@@ -116,7 +116,7 @@ sudo cp target/release/lan-mouse /usr/local/bin/

 # install app icon
 sudo mkdir -p /usr/local/share/icons/hicolor/scalable/apps
-sudo cp lan-mouse-gtk/resources/de.feschber.LanMouse.svg /usr/local/share/icons/hicolor/scalable/apps
+sudo cp resources/de.feschber.LanMouse.svg /usr/local/share/icons/hicolor/scalable/apps

 # update icon cache
 gtk-update-icon-cache /usr/local/share/icons/hicolor/
--- a/build.rs
+++ b/build.rs
@@ -1,15 +1,9 @@
-use std::process::Command;
-
 fn main() {
-    // commit hash
-    let git_describe = Command::new("git")
-        .arg("describe")
-        .arg("--always")
-        .arg("--dirty")
-        .arg("--tags")
-        .output()
-        .unwrap();
-
-    let git_describe = String::from_utf8(git_describe.stdout).unwrap();
-    println!("cargo::rustc-env=GIT_DESCRIBE={git_describe}");
+    // composite_templates
+    #[cfg(feature = "gtk")]
+    glib_build_tools::compile_resources(
+        &["resources"],
+        "resources/resources.gresource.xml",
+        "lan-mouse.gresource",
+    );
 }
--- a/flake.nix
+++ b/flake.nix
@@ -53,7 +53,7 @@
          libadwaita
          librsvg
          xorg.libXtst
-        ] ++ lib.optionals stdenv.isDarwin
+        ] ++ lib.optionals stdenv.isDarwin 
        (with darwin.apple_sdk_11_0.frameworks; [
          CoreGraphics
          ApplicationServices
--- a/input-capture/src/lib.rs
+++ b/input-capture/src/lib.rs
@@ -160,7 +160,6 @@ impl InputCapture {
                _ => self.pressed_keys.remove(&scancode),
            };
        }
-        log::info!("pressed keys: {:?}", self.pressed_keys);
    }
 }

--- a/input-capture/src/wayland.rs
+++ b/input-capture/src/wayland.rs
@@ -71,7 +71,7 @@ struct Globals {
    compositor: wl_compositor::WlCompositor,
    pointer_constraints: ZwpPointerConstraintsV1,
    relative_pointer_manager: ZwpRelativePointerManagerV1,
-    shortcut_inhibit_manager: Option<ZwpKeyboardShortcutsInhibitManagerV1>,
+    shortcut_inhibit_manager: ZwpKeyboardShortcutsInhibitManagerV1,
    seat: wl_seat::WlSeat,
    shm: wl_shm::WlShm,
    layer_shell: ZwlrLayerShellV1,
@@ -285,18 +285,9 @@ impl WaylandInputCapture {
        let relative_pointer_manager: ZwpRelativePointerManagerV1 = g
            .bind(&qh, 1..=1, ())
            .map_err(|e| WaylandBindError::new(e, "zwp_relative_pointer_manager_v1"))?;
-        let shortcut_inhibit_manager: Result<
-            ZwpKeyboardShortcutsInhibitManagerV1,
-            WaylandBindError,
-        > = g
+        let shortcut_inhibit_manager: ZwpKeyboardShortcutsInhibitManagerV1 = g
            .bind(&qh, 1..=1, ())
-            .map_err(|e| WaylandBindError::new(e, "zwp_keyboard_shortcuts_inhibit_manager_v1"));
-        // layer-shell backend still works without this protocol so we make it an optional dependency
-        if let Err(e) = &shortcut_inhibit_manager {
-            log::warn!("shortcut_inhibit_manager not supported: {e}\nkeybinds handled by the compositor will not be passed
-                to the client");
-        }
-        let shortcut_inhibit_manager = shortcut_inhibit_manager.ok();
+            .map_err(|e| WaylandBindError::new(e, "zwp_keyboard_shortcuts_inhibit_manager_v1"))?;
        let outputs = vec![];

        let g = Globals {
@@ -433,11 +424,13 @@ impl State {
        }

        // capture modifier keys
-        if let Some(shortcut_inhibit_manager) = &self.g.shortcut_inhibit_manager {
-            if self.shortcut_inhibitor.is_none() {
-                self.shortcut_inhibitor =
-                    Some(shortcut_inhibit_manager.inhibit_shortcuts(surface, &self.g.seat, qh, ()));
-            }
+        if self.shortcut_inhibitor.is_none() {
+            self.shortcut_inhibitor = Some(self.g.shortcut_inhibit_manager.inhibit_shortcuts(
+                surface,
+                &self.g.seat,
+                qh,
+                (),
+            ));
        }
    }

--- a/input-emulation/src/lib.rs
+++ b/input-emulation/src/lib.rs
@@ -217,15 +217,13 @@ impl InputEmulation {
            return false;
        };

-        let ret = if state == 0 {
+        if state == 0 {
            // currently pressed => can release
            pressed_keys.remove(&key)
        } else {
            // currently not pressed => can press
            pressed_keys.insert(key)
-        };
-        log::info!("client {handle}: pressed keys: {:?}", pressed_keys);
-        ret
+        }
    }
 }

--- a/input-emulation/src/macos.rs
+++ b/input-emulation/src/macos.rs
@@ -1,9 +1,6 @@
 use super::{error::EmulationError, Emulation, EmulationHandle};
 use async_trait::async_trait;
-use core_graphics::base::CGFloat;
-use core_graphics::display::{
-    CGDirectDisplayID, CGDisplayBounds, CGGetDisplaysWithRect, CGPoint, CGRect, CGSize,
-};
+use core_graphics::display::{CGDisplayBounds, CGMainDisplayID, CGPoint};
 use core_graphics::event::{
    CGEvent, CGEventTapLocation, CGEventType, CGKeyCode, CGMouseButton, EventField, ScrollEventUnit,
 };
@@ -108,77 +105,6 @@ fn key_event(event_source: CGEventSource, key: u16, state: u8) {
    event.post(CGEventTapLocation::HID);
 }

-fn get_display_at_point(x: CGFloat, y: CGFloat) -> Option<CGDirectDisplayID> {
-    let mut displays: [CGDirectDisplayID; 16] = [0; 16];
-    let mut display_count: u32 = 0;
-    let rect = CGRect::new(&CGPoint::new(x, y), &CGSize::new(0.0, 0.0));
-
-    let error = unsafe {
-        CGGetDisplaysWithRect(
-            rect,
-            1,
-            displays.as_mut_ptr(),
-            &mut display_count as *mut u32,
-        )
-    };
-
-    if error != 0 {
-        log::warn!("error getting displays at point ({}, {}): {}", x, y, error);
-        return Option::None;
-    }
-
-    if display_count == 0 {
-        log::debug!("no displays found at point ({}, {})", x, y);
-        return Option::None;
-    }
-
-    return displays.first().copied();
-}
-
-fn get_display_bounds(display: CGDirectDisplayID) -> (CGFloat, CGFloat, CGFloat, CGFloat) {
-    unsafe {
-        let bounds = CGDisplayBounds(display);
-        let min_x = bounds.origin.x;
-        let max_x = bounds.origin.x + bounds.size.width;
-        let min_y = bounds.origin.y;
-        let max_y = bounds.origin.y + bounds.size.height;
-        (min_x as f64, min_y as f64, max_x as f64, max_y as f64)
-    }
-}
-
-fn clamp_to_screen_space(
-    current_x: CGFloat,
-    current_y: CGFloat,
-    dx: CGFloat,
-    dy: CGFloat,
-) -> (CGFloat, CGFloat) {
-    // Check which display the mouse is currently on
-    // Determine what the location of the mouse would be after applying the move
-    // Get the display at the new location
-    // If the point is not on a display
-    //   Clamp the mouse to the current display
-    // Else If the point is on a display
-    //   Clamp the mouse to the new display
-    let current_display = match get_display_at_point(current_x, current_y) {
-        Some(display) => display,
-        None => {
-            log::warn!("could not get current display!");
-            return (current_x, current_y);
-        }
-    };
-
-    let new_x = current_x + dx;
-    let new_y = current_y + dy;
-
-    let final_display = get_display_at_point(new_x, new_y).unwrap_or(current_display);
-    let (min_x, min_y, max_x, max_y) = get_display_bounds(final_display);
-
-    (
-        new_x.clamp(min_x, max_x - 1.),
-        new_y.clamp(min_y, max_y - 1.),
-    )
-}
-
 #[async_trait]
 impl Emulation for MacOSEmulation {
    async fn consume(
@@ -189,6 +115,16 @@ impl Emulation for MacOSEmulation {
        match event {
            Event::Pointer(pointer_event) => match pointer_event {
                PointerEvent::Motion { time: _, dx, dy } => {
+                    // FIXME secondary displays?
+                    let (min_x, min_y, max_x, max_y) = unsafe {
+                        let display = CGMainDisplayID();
+                        let bounds = CGDisplayBounds(display);
+                        let min_x = bounds.origin.x;
+                        let max_x = bounds.origin.x + bounds.size.width;
+                        let min_y = bounds.origin.y;
+                        let max_y = bounds.origin.y + bounds.size.height;
+                        (min_x as f64, min_y as f64, max_x as f64, max_y as f64)
+                    };
                    let mut mouse_location = match self.get_mouse_location() {
                        Some(l) => l,
                        None => {
@@ -197,11 +133,8 @@ impl Emulation for MacOSEmulation {
                        }
                    };

-                    let (new_mouse_x, new_mouse_y) =
-                        clamp_to_screen_space(mouse_location.x, mouse_location.y, dx, dy);
-
-                    mouse_location.x = new_mouse_x;
-                    mouse_location.y = new_mouse_y;
+                    mouse_location.x = (mouse_location.x + dx).clamp(min_x, max_x - 1.);
+                    mouse_location.y = (mouse_location.y + dy).clamp(min_y, max_y - 1.);

                    let mut event_type = CGEventType::MouseMoved;
                    if self.button_state.left {
--- a/lan-mouse-cli/Cargo.toml
+++ b/lan-mouse-cli/Cargo.toml
@@ -1,18 +0,0 @@
-[package]
-name = "lan-mouse-cli"
-description = "CLI Frontend for lan-mouse"
-version = "0.1.0"
-edition = "2021"
-license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
-
-[dependencies]
-futures = "0.3.30"
-lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.1.0" }
-tokio = { version = "1.32.0", features = [
-    "io-util",
-    "io-std",
-    "macros",
-    "net",
-    "rt",
-] }
--- a/lan-mouse-gtk/Cargo.toml
+++ b/lan-mouse-gtk/Cargo.toml
@@ -1,18 +0,0 @@
-[package]
-name = "lan-mouse-gtk"
-description = "GTK4 / Libadwaita Frontend for lan-mouse"
-version = "0.1.0"
-edition = "2021"
-license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
-
-[dependencies]
-gtk = { package = "gtk4", version = "0.9.0", features = ["v4_2"] }
-adw = { package = "libadwaita", version = "0.7.0", features = ["v1_1"] }
-async-channel = { version = "2.1.1" }
-hostname = "0.4.0"
-log = "0.4.20"
-lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.1.0" }
-
-[build-dependencies]
-glib-build-tools = { version = "0.20.0" }
--- a/lan-mouse-gtk/build.rs
+++ b/lan-mouse-gtk/build.rs
@@ -1,8 +0,0 @@
-fn main() {
-    // composite_templates
-    glib_build_tools::compile_resources(
-        &["resources"],
-        "resources/resources.gresource.xml",
-        "lan-mouse.gresource",
-    );
-}
--- a/lan-mouse-ipc/Cargo.toml
+++ b/lan-mouse-ipc/Cargo.toml
@@ -1,16 +0,0 @@
-[package]
-name = "lan-mouse-ipc"
-description = "library for communication between lan-mouse service and frontends"
-version = "0.1.0"
-edition = "2021"
-license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
-
-[dependencies]
-futures = "0.3.30"
-log = "0.4.22"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0.107"
-thiserror = "1.0.63"
-tokio = { version = "1.32.0", features = ["net", "io-util", "time"] }
-tokio-stream = { version = "0.1.15", features = ["io-util"] }
--- a/lan-mouse-ipc/src/connect.rs
+++ b/lan-mouse-ipc/src/connect.rs
@@ -1,89 +0,0 @@
-use crate::{ConnectionError, FrontendEvent, FrontendRequest, IpcError};
-use std::{
-    cmp::min,
-    io::{self, prelude::*, BufReader, LineWriter, Lines},
-    thread,
-    time::Duration,
-};
-
-#[cfg(unix)]
-use std::os::unix::net::UnixStream;
-
-#[cfg(windows)]
-use std::net::TcpStream;
-
-pub struct FrontendEventReader {
-    #[cfg(unix)]
-    lines: Lines<BufReader<UnixStream>>,
-    #[cfg(windows)]
-    lines: Lines<BufReader<TcpStream>>,
-}
-
-pub struct FrontendRequestWriter {
-    #[cfg(unix)]
-    line_writer: LineWriter<UnixStream>,
-    #[cfg(windows)]
-    line_writer: LineWriter<TcpStream>,
-}
-
-impl FrontendEventReader {
-    pub fn next_event(&mut self) -> Option<Result<FrontendEvent, IpcError>> {
-        match self.lines.next()? {
-            Err(e) => Some(Err(e.into())),
-            Ok(l) => Some(serde_json::from_str(l.as_str()).map_err(|e| e.into())),
-        }
-    }
-}
-
-impl FrontendRequestWriter {
-    pub fn request(&mut self, request: FrontendRequest) -> Result<(), io::Error> {
-        let mut json = serde_json::to_string(&request).unwrap();
-        log::debug!("requesting: {json}");
-        json.push('\n');
-        self.line_writer.write_all(json.as_bytes())?;
-        Ok(())
-    }
-}
-
-pub fn connect() -> Result<(FrontendEventReader, FrontendRequestWriter), ConnectionError> {
-    let rx = wait_for_service()?;
-    let tx = rx.try_clone()?;
-    let buf_reader = BufReader::new(rx);
-    let lines = buf_reader.lines();
-    let line_writer = LineWriter::new(tx);
-    let reader = FrontendEventReader { lines };
-    let writer = FrontendRequestWriter { line_writer };
-    Ok((reader, writer))
-}
-
-/// wait for the lan-mouse socket to come online
-#[cfg(unix)]
-fn wait_for_service() -> Result<UnixStream, ConnectionError> {
-    let socket_path = crate::default_socket_path()?;
-    let mut duration = Duration::from_millis(10);
-    loop {
-        if let Ok(stream) = UnixStream::connect(&socket_path) {
-            break Ok(stream);
-        }
-        // a signaling mechanism or inotify could be used to
-        // improve this
-        thread::sleep(exponential_back_off(&mut duration));
-    }
-}
-
-#[cfg(windows)]
-fn wait_for_service() -> Result<TcpStream, ConnectionError> {
-    let mut duration = Duration::from_millis(10);
-    loop {
-        if let Ok(stream) = TcpStream::connect("127.0.0.1:5252") {
-            break Ok(stream);
-        }
-        thread::sleep(exponential_back_off(&mut duration));
-    }
-}
-
-fn exponential_back_off(duration: &mut Duration) -> Duration {
-    let new = duration.saturating_mul(2);
-    *duration = min(new, Duration::from_secs(1));
-    *duration
-}
--- a/lan-mouse-ipc/src/connect_async.rs
+++ b/lan-mouse-ipc/src/connect_async.rs
@@ -1,104 +0,0 @@
-use crate::{ConnectionError, FrontendEvent, FrontendRequest, IpcError};
-use std::{
-    cmp::min,
-    io,
-    task::{ready, Poll},
-    time::Duration,
-};
-
-use futures::{Stream, StreamExt};
-use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader, ReadHalf, WriteHalf};
-use tokio_stream::wrappers::LinesStream;
-
-#[cfg(unix)]
-use tokio::net::UnixStream;
-
-#[cfg(windows)]
-use tokio::net::TcpStream;
-
-pub struct AsyncFrontendEventReader {
-    #[cfg(unix)]
-    lines_stream: LinesStream<BufReader<ReadHalf<UnixStream>>>,
-    #[cfg(windows)]
-    lines_stream: LinesStream<BufReader<ReadHalf<TcpStream>>>,
-}
-
-pub struct AsyncFrontendRequestWriter {
-    #[cfg(unix)]
-    tx: WriteHalf<UnixStream>,
-    #[cfg(windows)]
-    tx: WriteHalf<TcpStream>,
-}
-
-impl Stream for AsyncFrontendEventReader {
-    type Item = Result<FrontendEvent, IpcError>;
-
-    fn poll_next(
-        mut self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Option<Self::Item>> {
-        let line = ready!(self.lines_stream.poll_next_unpin(cx));
-        let event = line.map(|l| {
-            l.map_err(Into::<IpcError>::into)
-                .and_then(|l| serde_json::from_str(l.as_str()).map_err(|e| e.into()))
-        });
-        Poll::Ready(event)
-    }
-}
-
-impl AsyncFrontendRequestWriter {
-    pub async fn request(&mut self, request: FrontendRequest) -> Result<(), io::Error> {
-        let mut json = serde_json::to_string(&request).unwrap();
-        log::debug!("requesting: {json}");
-        json.push('\n');
-        self.tx.write_all(json.as_bytes()).await?;
-        Ok(())
-    }
-}
-
-pub async fn connect_async(
-) -> Result<(AsyncFrontendEventReader, AsyncFrontendRequestWriter), ConnectionError> {
-    let stream = wait_for_service().await?;
-    #[cfg(unix)]
-    let (rx, tx): (ReadHalf<UnixStream>, WriteHalf<UnixStream>) = tokio::io::split(stream);
-    #[cfg(windows)]
-    let (rx, tx): (ReadHalf<TcpStream>, WriteHalf<TcpStream>) = tokio::io::split(stream);
-    let buf_reader = BufReader::new(rx);
-    let lines = buf_reader.lines();
-    let lines_stream = LinesStream::new(lines);
-    let reader = AsyncFrontendEventReader { lines_stream };
-    let writer = AsyncFrontendRequestWriter { tx };
-    Ok((reader, writer))
-}
-
-/// wait for the lan-mouse socket to come online
-#[cfg(unix)]
-async fn wait_for_service() -> Result<UnixStream, ConnectionError> {
-    let socket_path = crate::default_socket_path()?;
-    let mut duration = Duration::from_millis(10);
-    loop {
-        if let Ok(stream) = UnixStream::connect(&socket_path).await {
-            break Ok(stream);
-        }
-        // a signaling mechanism or inotify could be used to
-        // improve this
-        tokio::time::sleep(exponential_back_off(&mut duration)).await;
-    }
-}
-
-#[cfg(windows)]
-async fn wait_for_service() -> Result<TcpStream, ConnectionError> {
-    let mut duration = Duration::from_millis(10);
-    loop {
-        if let Ok(stream) = TcpStream::connect("127.0.0.1:5252").await {
-            break Ok(stream);
-        }
-        tokio::time::sleep(exponential_back_off(&mut duration)).await;
-    }
-}
-
-fn exponential_back_off(duration: &mut Duration) -> Duration {
-    let new = duration.saturating_mul(2);
-    *duration = min(new, Duration::from_secs(1));
-    *duration
-}
--- a/lan-mouse-ipc/src/lib.rs
+++ b/lan-mouse-ipc/src/lib.rs
@@ -1,264 +0,0 @@
-use std::{
-    collections::HashSet,
-    env::VarError,
-    fmt::Display,
-    io,
-    net::{IpAddr, SocketAddr},
-    str::FromStr,
-};
-use thiserror::Error;
-
-#[cfg(unix)]
-use std::{
-    env,
-    path::{Path, PathBuf},
-};
-
-use serde::{Deserialize, Serialize};
-
-mod connect;
-mod connect_async;
-mod listen;
-
-pub use connect::{connect, FrontendEventReader, FrontendRequestWriter};
-pub use connect_async::{connect_async, AsyncFrontendEventReader, AsyncFrontendRequestWriter};
-pub use listen::AsyncFrontendListener;
-
-#[derive(Debug, Error)]
-pub enum ConnectionError {
-    #[error(transparent)]
-    SocketPath(#[from] SocketPathError),
-    #[error(transparent)]
-    Io(#[from] io::Error),
-}
-
-#[derive(Debug, Error)]
-pub enum ListenerCreationError {
-    #[error("could not determine socket-path: `{0}`")]
-    SocketPath(#[from] SocketPathError),
-    #[error("service already running!")]
-    AlreadyRunning,
-    #[error("failed to bind lan-mouse socket: `{0}`")]
-    Bind(io::Error),
-}
-
-#[derive(Debug, Error)]
-pub enum IpcError {
-    #[error("io error occured: `{0}`")]
-    Io(#[from] io::Error),
-    #[error("invalid json: `{0}`")]
-    Json(#[from] serde_json::Error),
-    #[error(transparent)]
-    Connection(#[from] ConnectionError),
-    #[error(transparent)]
-    Listen(#[from] ListenerCreationError),
-}
-
-pub const DEFAULT_PORT: u16 = 4242;
-
-#[derive(Debug, Default, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
-pub enum Position {
-    #[default]
-    Left,
-    Right,
-    Top,
-    Bottom,
-}
-
-#[derive(Debug, Error)]
-#[error("not a valid position: {pos}")]
-pub struct PositionParseError {
-    pos: String,
-}
-
-impl FromStr for Position {
-    type Err = PositionParseError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "left" => Ok(Self::Left),
-            "right" => Ok(Self::Right),
-            "top" => Ok(Self::Top),
-            "bottom" => Ok(Self::Bottom),
-            _ => Err(PositionParseError { pos: s.into() }),
-        }
-    }
-}
-
-impl Display for Position {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}",
-            match self {
-                Position::Left => "left",
-                Position::Right => "right",
-                Position::Top => "top",
-                Position::Bottom => "bottom",
-            }
-        )
-    }
-}
-
-impl TryFrom<&str> for Position {
-    type Error = ();
-
-    fn try_from(s: &str) -> Result<Self, Self::Error> {
-        match s {
-            "left" => Ok(Position::Left),
-            "right" => Ok(Position::Right),
-            "top" => Ok(Position::Top),
-            "bottom" => Ok(Position::Bottom),
-            _ => Err(()),
-        }
-    }
-}
-
-#[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
-pub struct ClientConfig {
-    /// hostname of this client
-    pub hostname: Option<String>,
-    /// fix ips, determined by the user
-    pub fix_ips: Vec<IpAddr>,
-    /// both active_addr and addrs can be None / empty so port needs to be stored seperately
-    pub port: u16,
-    /// position of a client on screen
-    pub pos: Position,
-    /// enter hook
-    pub cmd: Option<String>,
-}
-
-impl Default for ClientConfig {
-    fn default() -> Self {
-        Self {
-            port: DEFAULT_PORT,
-            hostname: Default::default(),
-            fix_ips: Default::default(),
-            pos: Default::default(),
-            cmd: None,
-        }
-    }
-}
-
-pub type ClientHandle = u64;
-
-#[derive(Debug, Default, Clone, Serialize, Deserialize)]
-pub struct ClientState {
-    /// events should be sent to and received from the client
-    pub active: bool,
-    /// `active` address of the client, used to send data to.
-    /// This should generally be the socket address where data
-    /// was last received from.
-    pub active_addr: Option<SocketAddr>,
-    /// tracks whether or not the client is responding to pings
-    pub alive: bool,
-    /// ips from dns
-    pub dns_ips: Vec<IpAddr>,
-    /// all ip addresses associated with a particular client
-    /// e.g. Laptops usually have at least an ethernet and a wifi port
-    /// which have different ip addresses
-    pub ips: HashSet<IpAddr>,
-    /// client has pressed keys
-    pub has_pressed_keys: bool,
-    /// dns resolving in progress
-    pub resolving: bool,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum FrontendEvent {
-    /// client state has changed, new state must be requested via [`FrontendRequest::GetState`]
-    Changed(ClientHandle),
-    /// a client was created
-    Created(ClientHandle, ClientConfig, ClientState),
-    /// no such client
-    NoSuchClient(ClientHandle),
-    /// state changed
-    State(ClientHandle, ClientConfig, ClientState),
-    /// the client was deleted
-    Deleted(ClientHandle),
-    /// new port, reason of failure (if failed)
-    PortChanged(u16, Option<String>),
-    /// list of all clients, used for initial state synchronization
-    Enumerate(Vec<(ClientHandle, ClientConfig, ClientState)>),
-    /// an error occured
-    Error(String),
-    /// capture status
-    CaptureStatus(Status),
-    /// emulation status
-    EmulationStatus(Status),
-}
-
-#[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
-pub enum FrontendRequest {
-    /// activate/deactivate client
-    Activate(ClientHandle, bool),
-    /// add a new client
-    Create,
-    /// change the listen port (recreate udp listener)
-    ChangePort(u16),
-    /// remove a client
-    Delete(ClientHandle),
-    /// request an enumeration of all clients
-    Enumerate(),
-    /// resolve dns
-    ResolveDns(ClientHandle),
-    /// update hostname
-    UpdateHostname(ClientHandle, Option<String>),
-    /// update port
-    UpdatePort(ClientHandle, u16),
-    /// update position
-    UpdatePosition(ClientHandle, Position),
-    /// update fix-ips
-    UpdateFixIps(ClientHandle, Vec<IpAddr>),
-    /// request the state of the given client
-    GetState(ClientHandle),
-    /// request reenabling input capture
-    EnableCapture,
-    /// request reenabling input emulation
-    EnableEmulation,
-    /// synchronize all state
-    Sync,
-}
-
-#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]
-pub enum Status {
-    #[default]
-    Disabled,
-    Enabled,
-}
-
-impl From<Status> for bool {
-    fn from(status: Status) -> Self {
-        match status {
-            Status::Enabled => true,
-            Status::Disabled => false,
-        }
-    }
-}
-
-#[cfg(unix)]
-const LAN_MOUSE_SOCKET_NAME: &str = "lan-mouse-socket.sock";
-
-#[derive(Debug, Error)]
-pub enum SocketPathError {
-    #[error("could not determine $XDG_RUNTIME_DIR: `{0}`")]
-    XdgRuntimeDirNotFound(VarError),
-    #[error("could not determine $HOME: `{0}`")]
-    HomeDirNotFound(VarError),
-}
-
-#[cfg(all(unix, not(target_os = "macos")))]
-pub fn default_socket_path() -> Result<PathBuf, SocketPathError> {
-    let xdg_runtime_dir =
-        env::var("XDG_RUNTIME_DIR").map_err(SocketPathError::XdgRuntimeDirNotFound)?;
-    Ok(Path::new(xdg_runtime_dir.as_str()).join(LAN_MOUSE_SOCKET_NAME))
-}
-
-#[cfg(all(unix, target_os = "macos"))]
-pub fn default_socket_path() -> Result<PathBuf, SocketPathError> {
-    let home = env::var("HOME").map_err(SocketPathError::HomeDirNotFound)?;
-    Ok(Path::new(home.as_str())
-        .join("Library")
-        .join("Caches")
-        .join(LAN_MOUSE_SOCKET_NAME))
-}
--- a/lan-mouse-ipc/src/listen.rs
+++ b/lan-mouse-ipc/src/listen.rs
@@ -1,147 +0,0 @@
-use futures::{stream::SelectAll, Stream, StreamExt};
-#[cfg(unix)]
-use std::path::PathBuf;
-use std::{
-    io::ErrorKind,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader, ReadHalf, WriteHalf};
-use tokio_stream::wrappers::LinesStream;
-
-#[cfg(unix)]
-use tokio::net::UnixListener;
-#[cfg(unix)]
-use tokio::net::UnixStream;
-
-#[cfg(windows)]
-use tokio::net::TcpListener;
-#[cfg(windows)]
-use tokio::net::TcpStream;
-
-use crate::{FrontendEvent, FrontendRequest, IpcError, ListenerCreationError};
-
-pub struct AsyncFrontendListener {
-    #[cfg(windows)]
-    listener: TcpListener,
-    #[cfg(unix)]
-    listener: UnixListener,
-    #[cfg(unix)]
-    socket_path: PathBuf,
-    #[cfg(unix)]
-    line_streams: SelectAll<LinesStream<BufReader<ReadHalf<UnixStream>>>>,
-    #[cfg(windows)]
-    line_streams: SelectAll<LinesStream<BufReader<ReadHalf<TcpStream>>>>,
-    #[cfg(unix)]
-    tx_streams: Vec<WriteHalf<UnixStream>>,
-    #[cfg(windows)]
-    tx_streams: Vec<WriteHalf<TcpStream>>,
-}
-
-impl AsyncFrontendListener {
-    pub async fn new() -> Result<Self, ListenerCreationError> {
-        #[cfg(unix)]
-        let (socket_path, listener) = {
-            let socket_path = crate::default_socket_path()?;
-
-            log::debug!("remove socket: {:?}", socket_path);
-            if socket_path.exists() {
-                // try to connect to see if some other instance
-                // of lan-mouse is already running
-                match UnixStream::connect(&socket_path).await {
-                    // connected -> lan-mouse is already running
-                    Ok(_) => return Err(ListenerCreationError::AlreadyRunning),
-                    // lan-mouse is not running but a socket was left behind
-                    Err(e) => {
-                        log::debug!("{socket_path:?}: {e} - removing left behind socket");
-                        let _ = std::fs::remove_file(&socket_path);
-                    }
-                }
-            }
-            let listener = match UnixListener::bind(&socket_path) {
-                Ok(ls) => ls,
-                // some other lan-mouse instance has bound the socket in the meantime
-                Err(e) if e.kind() == ErrorKind::AddrInUse => {
-                    return Err(ListenerCreationError::AlreadyRunning)
-                }
-                Err(e) => return Err(ListenerCreationError::Bind(e)),
-            };
-            (socket_path, listener)
-        };
-
-        #[cfg(windows)]
-        let listener = match TcpListener::bind("127.0.0.1:5252").await {
-            Ok(ls) => ls,
-            // some other lan-mouse instance has bound the socket in the meantime
-            Err(e) if e.kind() == ErrorKind::AddrInUse => {
-                return Err(ListenerCreationError::AlreadyRunning)
-            }
-            Err(e) => return Err(ListenerCreationError::Bind(e)),
-        };
-
-        let adapter = Self {
-            listener,
-            #[cfg(unix)]
-            socket_path,
-            line_streams: SelectAll::new(),
-            tx_streams: vec![],
-        };
-
-        Ok(adapter)
-    }
-
-    pub async fn broadcast(&mut self, notify: FrontendEvent) {
-        // encode event
-        let mut json = serde_json::to_string(&notify).unwrap();
-        json.push('\n');
-
-        let mut keep = vec![];
-        // TODO do simultaneously
-        for tx in self.tx_streams.iter_mut() {
-            // write len + payload
-            if tx.write(json.as_bytes()).await.is_err() {
-                keep.push(false);
-                continue;
-            }
-            keep.push(true);
-        }
-
-        // could not find a better solution because async
-        let mut keep = keep.into_iter();
-        self.tx_streams.retain(|_| keep.next().unwrap());
-    }
-}
-
-#[cfg(unix)]
-impl Drop for AsyncFrontendListener {
-    fn drop(&mut self) {
-        log::debug!("remove socket: {:?}", self.socket_path);
-        let _ = std::fs::remove_file(&self.socket_path);
-    }
-}
-
-impl Stream for AsyncFrontendListener {
-    type Item = Result<FrontendRequest, IpcError>;
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        if let Poll::Ready(Some(Ok(l))) = self.line_streams.poll_next_unpin(cx) {
-            let request = serde_json::from_str(l.as_str()).map_err(|e| e.into());
-            return Poll::Ready(Some(request));
-        }
-        let mut sync = false;
-        while let Poll::Ready(Ok((stream, _))) = self.listener.poll_accept(cx) {
-            let (rx, tx) = tokio::io::split(stream);
-            let buf_reader = BufReader::new(rx);
-            let lines = buf_reader.lines();
-            let lines = LinesStream::new(lines);
-            self.line_streams.push(lines);
-            self.tx_streams.push(tx);
-            sync = true;
-        }
-        if sync {
-            Poll::Ready(Some(Ok(FrontendRequest::Sync)))
-        } else {
-            Poll::Pending
-        }
-    }
-}
--- a/nix/default.nix
+++ b/nix/default.nix
@@ -12,7 +12,6 @@ rustPlatform.buildRustPackage {
  version = version;

  nativeBuildInputs = with pkgs; [
-    git
    pkg-config
    cmake
    makeWrapper
--- a/lan-mouse-gtk/resources/client_row.ui
+++ b/lan-mouse-gtk/resources/client_row.ui
--- a/lan-mouse-gtk/resources/de.feschber.LanMouse.svg
+++ b/lan-mouse-gtk/resources/de.feschber.LanMouse.svg
--- a/lan-mouse-gtk/resources/resources.gresource.xml
+++ b/lan-mouse-gtk/resources/resources.gresource.xml
--- a/lan-mouse-gtk/resources/window.ui
+++ b/lan-mouse-gtk/resources/window.ui
--- a/src/capture_test.rs
+++ b/src/capture_test.rs
@@ -2,9 +2,21 @@ use crate::config::Config;
 use futures::StreamExt;
 use input_capture::{self, CaptureError, CaptureEvent, InputCapture, InputCaptureError, Position};
 use input_event::{Event, KeyboardEvent};
+use tokio::task::LocalSet;

-pub async fn run(config: Config) -> Result<(), InputCaptureError> {
+pub fn run() -> anyhow::Result<()> {
    log::info!("running input capture test");
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_io()
+        .enable_time()
+        .build()?;
+
+    let config = Config::new()?;
+
+    Ok(runtime.block_on(LocalSet::new().run_until(input_capture_test(config)))?)
+}
+
+async fn input_capture_test(config: Config) -> Result<(), InputCaptureError> {
    log::info!("creating input capture");
    let backend = config.capture_backend.map(|b| b.into());
    loop {
--- a/src/client.rs
+++ b/src/client.rs
@@ -1,8 +1,135 @@
-use std::net::SocketAddr;
+use std::{
+    collections::HashSet,
+    fmt::Display,
+    net::{IpAddr, SocketAddr},
+    str::FromStr,
+};

+use serde::{Deserialize, Serialize};
 use slab::Slab;
+use thiserror::Error;

-use lan_mouse_ipc::{ClientConfig, ClientHandle, ClientState, Position};
+use crate::config::DEFAULT_PORT;
+use input_capture;
+
+#[derive(Debug, Default, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
+pub enum Position {
+    #[default]
+    Left,
+    Right,
+    Top,
+    Bottom,
+}
+
+impl From<Position> for input_capture::Position {
+    fn from(position: Position) -> input_capture::Position {
+        match position {
+            Position::Left => input_capture::Position::Left,
+            Position::Right => input_capture::Position::Right,
+            Position::Top => input_capture::Position::Top,
+            Position::Bottom => input_capture::Position::Bottom,
+        }
+    }
+}
+
+#[derive(Debug, Error)]
+#[error("not a valid position: {pos}")]
+pub struct PositionParseError {
+    pos: String,
+}
+
+impl FromStr for Position {
+    type Err = PositionParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "left" => Ok(Self::Left),
+            "right" => Ok(Self::Right),
+            "top" => Ok(Self::Top),
+            "bottom" => Ok(Self::Bottom),
+            _ => Err(PositionParseError { pos: s.into() }),
+        }
+    }
+}
+
+impl Display for Position {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Position::Left => "left",
+                Position::Right => "right",
+                Position::Top => "top",
+                Position::Bottom => "bottom",
+            }
+        )
+    }
+}
+
+impl TryFrom<&str> for Position {
+    type Error = ();
+
+    fn try_from(s: &str) -> Result<Self, Self::Error> {
+        match s {
+            "left" => Ok(Position::Left),
+            "right" => Ok(Position::Right),
+            "top" => Ok(Position::Top),
+            "bottom" => Ok(Position::Bottom),
+            _ => Err(()),
+        }
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
+pub struct ClientConfig {
+    /// hostname of this client
+    pub hostname: Option<String>,
+    /// fix ips, determined by the user
+    pub fix_ips: Vec<IpAddr>,
+    /// both active_addr and addrs can be None / empty so port needs to be stored seperately
+    pub port: u16,
+    /// position of a client on screen
+    pub pos: Position,
+    /// enter hook
+    pub cmd: Option<String>,
+}
+
+impl Default for ClientConfig {
+    fn default() -> Self {
+        Self {
+            port: DEFAULT_PORT,
+            hostname: Default::default(),
+            fix_ips: Default::default(),
+            pos: Default::default(),
+            cmd: None,
+        }
+    }
+}
+
+pub type ClientHandle = u64;
+
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct ClientState {
+    /// events should be sent to and received from the client
+    pub active: bool,
+    /// `active` address of the client, used to send data to.
+    /// This should generally be the socket address where data
+    /// was last received from.
+    pub active_addr: Option<SocketAddr>,
+    /// tracks whether or not the client is responding to pings
+    pub alive: bool,
+    /// ips from dns
+    pub dns_ips: Vec<IpAddr>,
+    /// all ip addresses associated with a particular client
+    /// e.g. Laptops usually have at least an ethernet and a wifi port
+    /// which have different ip addresses
+    pub ips: HashSet<IpAddr>,
+    /// client has pressed keys
+    pub has_pressed_keys: bool,
+    /// dns resolving in progress
+    pub resolving: bool,
+}

 #[derive(Default)]
 pub struct ClientManager {
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,20 +1,22 @@
+use anyhow::Result;
 use clap::{Parser, ValueEnum};
 use serde::{Deserialize, Serialize};
-use std::env::{self, VarError};
+use std::collections::HashSet;
+use std::env;
 use std::fmt::Display;
-use std::fs;
 use std::net::IpAddr;
-use std::{collections::HashSet, io};
-use thiserror::Error;
+use std::{error::Error, fs};
 use toml;

-use lan_mouse_ipc::{Position, DEFAULT_PORT};
+use crate::client::Position;

 use input_event::scancode::{
    self,
    Linux::{KeyLeftAlt, KeyLeftCtrl, KeyLeftMeta, KeyLeftShift},
 };

+pub const DEFAULT_PORT: u16 = 4242;
+
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ConfigToml {
    pub capture_backend: Option<CaptureBackend>,
@@ -40,7 +42,7 @@ pub struct TomlClient {
 }

 impl ConfigToml {
-    pub fn new(path: &str) -> Result<ConfigToml, ConfigError> {
+    pub fn new(path: &str) -> Result<ConfigToml, Box<dyn Error>> {
        let config = fs::read_to_string(path)?;
        log::info!("using config: \"{path}\"");
        Ok(toml::from_str::<_>(&config)?)
@@ -48,7 +50,7 @@ impl ConfigToml {
 }

 #[derive(Parser, Debug)]
-#[command(author, version=env!("GIT_DESCRIBE"), about, long_about = None)]
+#[command(author, version, about, long_about = None)]
 struct CliArgs {
    /// the listen port for lan-mouse
    #[arg(short, long)]
@@ -229,21 +231,11 @@ pub struct ConfigClient {
    pub enter_hook: Option<String>,
 }

-#[derive(Debug, Error)]
-pub enum ConfigError {
-    #[error(transparent)]
-    Toml(#[from] toml::de::Error),
-    #[error(transparent)]
-    Io(#[from] io::Error),
-    #[error(transparent)]
-    Var(#[from] VarError),
-}
-
 const DEFAULT_RELEASE_KEYS: [scancode::Linux; 4] =
    [KeyLeftCtrl, KeyLeftShift, KeyLeftMeta, KeyLeftAlt];

 impl Config {
-    pub fn new() -> Result<Self, ConfigError> {
+    pub fn new() -> Result<Self> {
        let args = CliArgs::parse();
        let config_file = "config.toml";
        #[cfg(unix)]
--- a/src/dns.rs
+++ b/src/dns.rs
@@ -3,8 +3,7 @@ use std::net::IpAddr;

 use hickory_resolver::{error::ResolveError, TokioAsyncResolver};

-use crate::server::Server;
-use lan_mouse_ipc::ClientHandle;
+use crate::{client::ClientHandle, server::Server};

 pub(crate) struct DnsResolver {
    resolver: TokioAsyncResolver,
--- a/src/emulation_test.rs
+++ b/src/emulation_test.rs
@@ -1,19 +1,30 @@
 use crate::config::Config;
-use input_emulation::{InputEmulation, InputEmulationError};
+use anyhow::Result;
+use input_emulation::InputEmulation;
 use input_event::{Event, PointerEvent};
 use std::f64::consts::PI;
 use std::time::{Duration, Instant};
+use tokio::task::LocalSet;
+
+pub fn run() -> Result<()> {
+    log::info!("running input emulation test");
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_io()
+        .enable_time()
+        .build()?;
+
+    let config = Config::new()?;
+
+    runtime.block_on(LocalSet::new().run_until(input_emulation_test(config)))
+}

 const FREQUENCY_HZ: f64 = 1.0;
 const RADIUS: f64 = 100.0;

-pub async fn run(config: Config) -> Result<(), InputEmulationError> {
-    log::info!("running input emulation test");
-
+async fn input_emulation_test(config: Config) -> Result<()> {
    let backend = config.emulation_backend.map(|b| b.into());
    let mut emulation = InputEmulation::new(backend).await?;
    emulation.create(0).await;
-
    let start = Instant::now();
    let mut offset = (0, 0);
    loop {
--- a/src/frontend.rs
+++ b/src/frontend.rs
@@ -0,0 +1,307 @@
+use anyhow::{anyhow, Result};
+use std::{cmp::min, io::ErrorKind, net::IpAddr, str, time::Duration};
+
+#[cfg(unix)]
+use std::{
+    env,
+    path::{Path, PathBuf},
+};
+
+use tokio::io::ReadHalf;
+use tokio::io::{AsyncReadExt, AsyncWriteExt, WriteHalf};
+
+#[cfg(unix)]
+use tokio::net::UnixListener;
+#[cfg(unix)]
+use tokio::net::UnixStream;
+
+#[cfg(windows)]
+use tokio::net::TcpListener;
+#[cfg(windows)]
+use tokio::net::TcpStream;
+
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    client::{ClientConfig, ClientHandle, ClientState, Position},
+    config::{Config, Frontend},
+};
+
+/// cli frontend
+pub mod cli;
+
+/// gtk frontend
+#[cfg(feature = "gtk")]
+pub mod gtk;
+
+pub fn run_frontend(config: &Config) -> Result<()> {
+    match config.frontend {
+        #[cfg(feature = "gtk")]
+        Frontend::Gtk => {
+            gtk::run();
+        }
+        #[cfg(not(feature = "gtk"))]
+        Frontend::Gtk => panic!("gtk frontend requested but feature not enabled!"),
+        Frontend::Cli => {
+            cli::run()?;
+        }
+    };
+    Ok(())
+}
+
+fn exponential_back_off(duration: &mut Duration) -> &Duration {
+    let new = duration.saturating_mul(2);
+    *duration = min(new, Duration::from_secs(1));
+    duration
+}
+
+/// wait for the lan-mouse socket to come online
+#[cfg(unix)]
+pub fn wait_for_service() -> Result<std::os::unix::net::UnixStream> {
+    let socket_path = FrontendListener::socket_path()?;
+    let mut duration = Duration::from_millis(1);
+    loop {
+        use std::os::unix::net::UnixStream;
+        if let Ok(stream) = UnixStream::connect(&socket_path) {
+            break Ok(stream);
+        }
+        // a signaling mechanism or inotify could be used to
+        // improve this
+        std::thread::sleep(*exponential_back_off(&mut duration));
+    }
+}
+
+#[cfg(windows)]
+pub fn wait_for_service() -> Result<std::net::TcpStream> {
+    let mut duration = Duration::from_millis(1);
+    loop {
+        use std::net::TcpStream;
+        if let Ok(stream) = TcpStream::connect("127.0.0.1:5252") {
+            break Ok(stream);
+        }
+        std::thread::sleep(*exponential_back_off(&mut duration));
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
+pub enum FrontendRequest {
+    /// activate/deactivate client
+    Activate(ClientHandle, bool),
+    /// add a new client
+    Create,
+    /// change the listen port (recreate udp listener)
+    ChangePort(u16),
+    /// remove a client
+    Delete(ClientHandle),
+    /// request an enumeration of all clients
+    Enumerate(),
+    /// resolve dns
+    ResolveDns(ClientHandle),
+    /// update hostname
+    UpdateHostname(ClientHandle, Option<String>),
+    /// update port
+    UpdatePort(ClientHandle, u16),
+    /// update position
+    UpdatePosition(ClientHandle, Position),
+    /// update fix-ips
+    UpdateFixIps(ClientHandle, Vec<IpAddr>),
+    /// request the state of the given client
+    GetState(ClientHandle),
+    /// request reenabling input capture
+    EnableCapture,
+    /// request reenabling input emulation
+    EnableEmulation,
+}
+
+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]
+pub enum Status {
+    #[default]
+    Disabled,
+    Enabled,
+}
+
+impl From<Status> for bool {
+    fn from(status: Status) -> Self {
+        match status {
+            Status::Enabled => true,
+            Status::Disabled => false,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum FrontendEvent {
+    /// a client was created
+    Created(ClientHandle, ClientConfig, ClientState),
+    /// no such client
+    NoSuchClient(ClientHandle),
+    /// state changed
+    State(ClientHandle, ClientConfig, ClientState),
+    /// the client was deleted
+    Deleted(ClientHandle),
+    /// new port, reason of failure (if failed)
+    PortChanged(u16, Option<String>),
+    /// list of all clients, used for initial state synchronization
+    Enumerate(Vec<(ClientHandle, ClientConfig, ClientState)>),
+    /// an error occured
+    Error(String),
+    /// capture status
+    CaptureStatus(Status),
+    /// emulation status
+    EmulationStatus(Status),
+}
+
+pub struct FrontendListener {
+    #[cfg(windows)]
+    listener: TcpListener,
+    #[cfg(unix)]
+    listener: UnixListener,
+    #[cfg(unix)]
+    socket_path: PathBuf,
+    #[cfg(unix)]
+    tx_streams: Vec<WriteHalf<UnixStream>>,
+    #[cfg(windows)]
+    tx_streams: Vec<WriteHalf<TcpStream>>,
+}
+
+impl FrontendListener {
+    #[cfg(all(unix, not(target_os = "macos")))]
+    pub fn socket_path() -> Result<PathBuf> {
+        let xdg_runtime_dir = match env::var("XDG_RUNTIME_DIR") {
+            Ok(d) => d,
+            Err(e) => return Err(anyhow!("could not find XDG_RUNTIME_DIR: {e}")),
+        };
+        let xdg_runtime_dir = Path::new(xdg_runtime_dir.as_str());
+        Ok(xdg_runtime_dir.join("lan-mouse-socket.sock"))
+    }
+
+    #[cfg(all(unix, target_os = "macos"))]
+    pub fn socket_path() -> Result<PathBuf> {
+        let home = match env::var("HOME") {
+            Ok(d) => d,
+            Err(e) => return Err(anyhow!("could not find HOME: {e}")),
+        };
+        let home = Path::new(home.as_str());
+        let path = home
+            .join("Library")
+            .join("Caches")
+            .join("lan-mouse-socket.sock");
+        Ok(path)
+    }
+
+    pub async fn new() -> Option<Result<Self>> {
+        #[cfg(unix)]
+        let (socket_path, listener) = {
+            let socket_path = match Self::socket_path() {
+                Ok(path) => path,
+                Err(e) => return Some(Err(e)),
+            };
+
+            log::debug!("remove socket: {:?}", socket_path);
+            if socket_path.exists() {
+                // try to connect to see if some other instance
+                // of lan-mouse is already running
+                match UnixStream::connect(&socket_path).await {
+                    // connected -> lan-mouse is already running
+                    Ok(_) => return None,
+                    // lan-mouse is not running but a socket was left behind
+                    Err(e) => {
+                        log::debug!("{socket_path:?}: {e} - removing left behind socket");
+                        let _ = std::fs::remove_file(&socket_path);
+                    }
+                }
+            }
+            let listener = match UnixListener::bind(&socket_path) {
+                Ok(ls) => ls,
+                // some other lan-mouse instance has bound the socket in the meantime
+                Err(e) if e.kind() == ErrorKind::AddrInUse => return None,
+                Err(e) => return Some(Err(anyhow!("failed to bind lan-mouse-socket: {e}"))),
+            };
+            (socket_path, listener)
+        };
+
+        #[cfg(windows)]
+        let listener = match TcpListener::bind("127.0.0.1:5252").await {
+            Ok(ls) => ls,
+            // some other lan-mouse instance has bound the socket in the meantime
+            Err(e) if e.kind() == ErrorKind::AddrInUse => return None,
+            Err(e) => return Some(Err(anyhow!("failed to bind lan-mouse-socket: {e}"))),
+        };
+
+        let adapter = Self {
+            listener,
+            #[cfg(unix)]
+            socket_path,
+            tx_streams: vec![],
+        };
+
+        Some(Ok(adapter))
+    }
+
+    #[cfg(unix)]
+    pub async fn accept(&mut self) -> Result<ReadHalf<UnixStream>> {
+        let stream = self.listener.accept().await?.0;
+        let (rx, tx) = tokio::io::split(stream);
+        self.tx_streams.push(tx);
+        Ok(rx)
+    }
+
+    #[cfg(windows)]
+    pub async fn accept(&mut self) -> Result<ReadHalf<TcpStream>> {
+        let stream = self.listener.accept().await?.0;
+        let (rx, tx) = tokio::io::split(stream);
+        self.tx_streams.push(tx);
+        Ok(rx)
+    }
+
+    pub(crate) async fn broadcast(&mut self, notify: FrontendEvent) {
+        // encode event
+        let json = serde_json::to_string(&notify).unwrap();
+        let payload = json.as_bytes();
+        let len = payload.len().to_be_bytes();
+        log::debug!("broadcasting event to streams: {json}");
+        let mut keep = vec![];
+        // TODO do simultaneously
+        for tx in self.tx_streams.iter_mut() {
+            // write len + payload
+            if tx.write(&len).await.is_err() {
+                keep.push(false);
+                continue;
+            }
+            if tx.write(payload).await.is_err() {
+                keep.push(false);
+                continue;
+            }
+            keep.push(true);
+        }
+
+        // could not find a better solution because async
+        let mut keep = keep.into_iter();
+        self.tx_streams.retain(|_| keep.next().unwrap());
+    }
+}
+
+#[cfg(unix)]
+impl Drop for FrontendListener {
+    fn drop(&mut self) {
+        log::debug!("remove socket: {:?}", self.socket_path);
+        let _ = std::fs::remove_file(&self.socket_path);
+    }
+}
+
+#[cfg(unix)]
+pub async fn wait_for_request(stream: &mut ReadHalf<UnixStream>) -> Result<FrontendRequest> {
+    let len = stream.read_u64().await?;
+    assert!(len <= 256);
+    let mut buf = [0u8; 256];
+    stream.read_exact(&mut buf[..len as usize]).await?;
+    Ok(serde_json::from_slice(&buf[..len as usize])?)
+}
+
+#[cfg(windows)]
+pub async fn wait_for_request(stream: &mut ReadHalf<TcpStream>) -> Result<FrontendRequest> {
+    let len = stream.read_u64().await?;
+    let mut buf = [0u8; 256];
+    stream.read_exact(&mut buf[..len as usize]).await?;
+    Ok(serde_json::from_slice(&buf[..len as usize])?)
+}
--- a/lan-mouse-cli/src/lib.rs
+++ b/lan-mouse-cli/src/lib.rs
@@ -1,65 +1,78 @@
-use futures::StreamExt;
+use anyhow::{anyhow, Result};
 use tokio::{
-    io::{AsyncBufReadExt, BufReader},
+    io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader},
    task::LocalSet,
 };

+#[cfg(windows)]
+use tokio::net::tcp::{ReadHalf, WriteHalf};
+#[cfg(unix)]
+use tokio::net::unix::{ReadHalf, WriteHalf};
+
 use std::io::{self, Write};

+use crate::{
+    client::{ClientConfig, ClientHandle, ClientState},
+    config::DEFAULT_PORT,
+};
+
 use self::command::{Command, CommandType};

-use lan_mouse_ipc::{
-    AsyncFrontendEventReader, AsyncFrontendRequestWriter, ClientConfig, ClientHandle, ClientState,
-    FrontendEvent, FrontendRequest, IpcError, DEFAULT_PORT,
-};
+use super::{FrontendEvent, FrontendRequest};

 mod command;

-pub fn run() -> Result<(), IpcError> {
+pub fn run() -> Result<()> {
+    let Ok(stream) = super::wait_for_service() else {
+        return Err(anyhow!("Could not connect to lan-mouse-socket"));
+    };
+
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_io()
        .enable_time()
        .build()?;
    runtime.block_on(LocalSet::new().run_until(async move {
-        let (rx, tx) = lan_mouse_ipc::connect_async().await?;
+        stream.set_nonblocking(true)?;
+        #[cfg(unix)]
+        let mut stream = tokio::net::UnixStream::from_std(stream)?;
+        #[cfg(windows)]
+        let mut stream = tokio::net::TcpStream::from_std(stream)?;
+        let (rx, tx) = stream.split();
+
        let mut cli = Cli::new(rx, tx);
        cli.run().await
    }))?;
    Ok(())
 }

-struct Cli {
+struct Cli<'a> {
    clients: Vec<(ClientHandle, ClientConfig, ClientState)>,
-    changed: Option<ClientHandle>,
-    rx: AsyncFrontendEventReader,
-    tx: AsyncFrontendRequestWriter,
+    rx: ReadHalf<'a>,
+    tx: WriteHalf<'a>,
 }

-impl Cli {
-    fn new(rx: AsyncFrontendEventReader, tx: AsyncFrontendRequestWriter) -> Cli {
+impl<'a> Cli<'a> {
+    fn new(rx: ReadHalf<'a>, tx: WriteHalf<'a>) -> Cli<'a> {
        Self {
            clients: vec![],
-            changed: None,
            rx,
            tx,
        }
    }

-    async fn run(&mut self) -> Result<(), IpcError> {
+    async fn run(&mut self) -> Result<()> {
        let stdin = tokio::io::stdin();
        let stdin = BufReader::new(stdin);
        let mut stdin = stdin.lines();

        /* initial state sync */
+        let request = FrontendRequest::Enumerate();
+        self.send_request(request).await?;
+
        self.clients = loop {
-            match self.rx.next().await {
-                Some(Ok(e)) => {
-                    if let FrontendEvent::Enumerate(clients) = e {
-                        break clients;
-                    }
-                }
-                Some(Err(e)) => return Err(e),
-                None => return Ok(()),
+            let event = self.await_event().await?;
+            if let FrontendEvent::Enumerate(clients) = event {
+                break clients;
            }
        };

@@ -79,23 +92,18 @@ impl Cli {
                    };
                    self.execute(cmd).await?;
                }
-                event = self.rx.next() => {
-                    if let Some(event) = event {
-                        self.handle_event(event?);
-                    } else {
-                        break Ok(());
-                    }
+                event = self.await_event() => {
+                    let event = event?;
+                    self.handle_event(event);
                }
            }
-            if let Some(handle) = self.changed.take() {
-                self.update_client(handle).await?;
-            }
        }
    }

-    async fn update_client(&mut self, handle: ClientHandle) -> Result<(), IpcError> {
-        self.tx.request(FrontendRequest::GetState(handle)).await?;
-        while let Some(Ok(event)) = self.rx.next().await {
+    async fn update_client(&mut self, handle: ClientHandle) -> Result<()> {
+        self.send_request(FrontendRequest::GetState(handle)).await?;
+        loop {
+            let event = self.await_event().await?;
            self.handle_event(event.clone());
            if let FrontendEvent::State(_, _, _) | FrontendEvent::NoSuchClient(_) = event {
                break;
@@ -104,23 +112,22 @@ impl Cli {
        Ok(())
    }

-    async fn execute(&mut self, cmd: Command) -> Result<(), IpcError> {
+    async fn execute(&mut self, cmd: Command) -> Result<()> {
        match cmd {
            Command::None => {}
            Command::Connect(pos, host, port) => {
                let request = FrontendRequest::Create;
-                self.tx.request(request).await?;
+                self.send_request(request).await?;
                let handle = loop {
-                    if let Some(Ok(event)) = self.rx.next().await {
-                        match event {
-                            FrontendEvent::Created(h, c, s) => {
-                                self.clients.push((h, c, s));
-                                break h;
-                            }
-                            _ => {
-                                self.handle_event(event);
-                                continue;
-                            }
+                    let event = self.await_event().await?;
+                    match event {
+                        FrontendEvent::Created(h, c, s) => {
+                            self.clients.push((h, c, s));
+                            break h;
+                        }
+                        _ => {
+                            self.handle_event(event);
+                            continue;
                        }
                    }
                };
@@ -129,36 +136,35 @@ impl Cli {
                    FrontendRequest::UpdatePort(handle, port.unwrap_or(DEFAULT_PORT)),
                    FrontendRequest::UpdatePosition(handle, pos),
                ] {
-                    self.tx.request(request).await?;
+                    self.send_request(request).await?;
                }
                self.update_client(handle).await?;
            }
            Command::Disconnect(id) => {
-                self.tx.request(FrontendRequest::Delete(id)).await?;
+                self.send_request(FrontendRequest::Delete(id)).await?;
                loop {
-                    if let Some(Ok(event)) = self.rx.next().await {
-                        self.handle_event(event.clone());
-                        if let FrontendEvent::Deleted(_) = event {
-                            self.handle_event(event);
-                            break;
-                        }
+                    let event = self.await_event().await?;
+                    self.handle_event(event.clone());
+                    if let FrontendEvent::Deleted(_) = event {
+                        self.handle_event(event);
+                        break;
                    }
                }
            }
            Command::Activate(id) => {
-                self.tx.request(FrontendRequest::Activate(id, true)).await?;
+                self.send_request(FrontendRequest::Activate(id, true))
+                    .await?;
                self.update_client(id).await?;
            }
            Command::Deactivate(id) => {
-                self.tx
-                    .request(FrontendRequest::Activate(id, false))
+                self.send_request(FrontendRequest::Activate(id, false))
                    .await?;
                self.update_client(id).await?;
            }
            Command::List => {
-                self.tx.request(FrontendRequest::Enumerate()).await?;
-                while let Some(e) = self.rx.next().await {
-                    let event = e?;
+                self.send_request(FrontendRequest::Enumerate()).await?;
+                loop {
+                    let event = self.await_event().await?;
                    self.handle_event(event.clone());
                    if let FrontendEvent::Enumerate(_) = event {
                        break;
@@ -167,12 +173,12 @@ impl Cli {
            }
            Command::SetHost(handle, host) => {
                let request = FrontendRequest::UpdateHostname(handle, Some(host.clone()));
-                self.tx.request(request).await?;
+                self.send_request(request).await?;
                self.update_client(handle).await?;
            }
            Command::SetPort(handle, port) => {
                let request = FrontendRequest::UpdatePort(handle, port.unwrap_or(DEFAULT_PORT));
-                self.tx.request(request).await?;
+                self.send_request(request).await?;
                self.update_client(handle).await?;
            }
            Command::Help => {
@@ -209,7 +215,6 @@ impl Cli {

    fn handle_event(&mut self, event: FrontendEvent) {
        match event {
-            FrontendEvent::Changed(h) => self.changed = Some(h),
            FrontendEvent::Created(h, c, s) => {
                eprint!("client added ({h}): ");
                print_config(&c);
@@ -286,6 +291,23 @@ impl Cli {
            eprintln!();
        }
    }
+
+    async fn send_request(&mut self, request: FrontendRequest) -> io::Result<()> {
+        let json = serde_json::to_string(&request).unwrap();
+        let bytes = json.as_bytes();
+        let len = bytes.len();
+        self.tx.write_u64(len as u64).await?;
+        self.tx.write_all(bytes).await?;
+        Ok(())
+    }
+
+    async fn await_event(&mut self) -> Result<FrontendEvent> {
+        let len = self.rx.read_u64().await?;
+        let mut buf = vec![0u8; len as usize];
+        self.rx.read_exact(&mut buf).await?;
+        let event: FrontendEvent = serde_json::from_slice(&buf)?;
+        Ok(event)
+    }
 }

 fn prompt() -> io::Result<()> {
--- a/lan-mouse-cli/src/command.rs
+++ b/lan-mouse-cli/src/command.rs
@@ -3,7 +3,7 @@ use std::{
    str::{FromStr, SplitWhitespace},
 };

-use lan_mouse_ipc::{ClientHandle, Position};
+use crate::client::{ClientHandle, Position};

 pub(super) enum CommandType {
    NoCommand,
--- a/lan-mouse-gtk/src/lib.rs
+++ b/lan-mouse-gtk/src/lib.rs
@@ -2,13 +2,16 @@ mod client_object;
 mod client_row;
 mod window;

-use std::{env, process, str};
+use std::{
+    env,
+    io::{ErrorKind, Read},
+    process, str,
+};

-use window::Window;
-
-use lan_mouse_ipc::{FrontendEvent, FrontendRequest};
+use crate::frontend::gtk::window::Window;

 use adw::Application;
+use endi::{Endian, ReadBytes};
 use gtk::{
    gdk::Display, glib::clone, prelude::*, subclass::prelude::ObjectSubclassIsExt, IconTheme,
 };
@@ -16,6 +19,8 @@ use gtk::{gio, glib, prelude::ApplicationExt};

 use self::client_object::ClientObject;

+use super::FrontendEvent;
+
 pub fn run() -> glib::ExitCode {
    log::debug!("running gtk frontend");
    #[cfg(windows)]
@@ -60,8 +65,15 @@ fn load_icons() {

 fn build_ui(app: &Application) {
    log::debug!("connecting to lan-mouse-socket");
-    let (mut frontend_rx, frontend_tx) = match lan_mouse_ipc::connect() {
-        Ok(conn) => conn,
+    let mut rx = match super::wait_for_service() {
+        Ok(stream) => stream,
+        Err(e) => {
+            log::error!("could not connect to lan-mouse-socket: {e}");
+            process::exit(1);
+        }
+    };
+    let tx = match rx.try_clone() {
+        Ok(sock) => sock,
        Err(e) => {
            log::error!("{e}");
            process::exit(1);
@@ -72,18 +84,35 @@ fn build_ui(app: &Application) {
    let (sender, receiver) = async_channel::bounded(10);

    gio::spawn_blocking(move || {
-        while let Some(e) = frontend_rx.next_event() {
-            match e {
-                Ok(e) => sender.send_blocking(e).unwrap(),
-                Err(e) => {
-                    log::error!("{e}");
-                    break;
-                }
+        match loop {
+            // read length
+            let len = match rx.read_u64(Endian::Big) {
+                Ok(l) => l,
+                Err(e) if e.kind() == ErrorKind::UnexpectedEof => break Ok(()),
+                Err(e) => break Err(e),
+            };
+
+            // read payload
+            let mut buf = vec![0u8; len as usize];
+            match rx.read_exact(&mut buf) {
+                Ok(_) => (),
+                Err(e) if e.kind() == ErrorKind::UnexpectedEof => break Ok(()),
+                Err(e) => break Err(e),
+            };
+
+            // parse json
+            let json = str::from_utf8(&buf).unwrap();
+            match serde_json::from_str(json) {
+                Ok(notify) => sender.send_blocking(notify).unwrap(),
+                Err(e) => log::error!("{e}"),
            }
+        } {
+            Ok(()) => {}
+            Err(e) => log::error!("{e}"),
        }
    });

-    let window = Window::new(app, frontend_tx);
+    let window = Window::new(app, tx);

    glib::spawn_future_local(clone!(
        #[weak]
@@ -92,9 +121,6 @@ fn build_ui(app: &Application) {
            loop {
                let notify = receiver.recv().await.unwrap_or_else(|_| process::exit(1));
                match notify {
-                    FrontendEvent::Changed(handle) => {
-                        window.request(FrontendRequest::GetState(handle));
-                    }
                    FrontendEvent::Created(handle, client, state) => {
                        window.new_client(handle, client, state);
                    }
--- a/lan-mouse-gtk/src/client_object.rs
+++ b/lan-mouse-gtk/src/client_object.rs
@@ -3,7 +3,7 @@ mod imp;
 use adw::subclass::prelude::*;
 use gtk::glib::{self, Object};

-use lan_mouse_ipc::{ClientConfig, ClientHandle, ClientState};
+use crate::client::{ClientConfig, ClientHandle, ClientState};

 glib::wrapper! {
    pub struct ClientObject(ObjectSubclass<imp::ClientObject>);
--- a/lan-mouse-gtk/src/client_object/imp.rs
+++ b/lan-mouse-gtk/src/client_object/imp.rs
@@ -5,7 +5,7 @@ use gtk::glib;
 use gtk::prelude::*;
 use gtk::subclass::prelude::*;

-use lan_mouse_ipc::ClientHandle;
+use crate::client::ClientHandle;

 use super::ClientData;

--- a/lan-mouse-gtk/src/client_row.rs
+++ b/lan-mouse-gtk/src/client_row.rs
@@ -4,7 +4,7 @@ use adw::prelude::*;
 use adw::subclass::prelude::*;
 use gtk::glib::{self, Object};

-use lan_mouse_ipc::DEFAULT_PORT;
+use crate::config::DEFAULT_PORT;

 use super::ClientObject;

--- a/lan-mouse-gtk/src/client_row/imp.rs
+++ b/lan-mouse-gtk/src/client_row/imp.rs
--- a/lan-mouse-gtk/src/window.rs
+++ b/lan-mouse-gtk/src/window.rs
@@ -1,7 +1,16 @@
 mod imp;

+use std::io::Write;
+
+#[cfg(unix)]
+use std::os::unix::net::UnixStream;
+
+#[cfg(windows)]
+use std::net::TcpStream;
+
 use adw::prelude::*;
 use adw::subclass::prelude::*;
+use endi::{Endian, WriteBytes};
 use glib::{clone, Object};
 use gtk::{
    gio,
@@ -9,12 +18,13 @@ use gtk::{
    ListBox, NoSelection,
 };

-use lan_mouse_ipc::{
-    ClientConfig, ClientHandle, ClientState, FrontendRequest, FrontendRequestWriter, Position,
-    DEFAULT_PORT,
+use crate::{
+    client::{ClientConfig, ClientHandle, ClientState, Position},
+    config::DEFAULT_PORT,
+    frontend::{gtk::client_object::ClientObject, FrontendRequest},
 };

-use super::{client_object::ClientObject, client_row::ClientRow};
+use super::client_row::ClientRow;

 glib::wrapper! {
    pub struct Window(ObjectSubclass<imp::Window>)
@@ -24,13 +34,13 @@ glib::wrapper! {
 }

 impl Window {
-    pub(crate) fn new(app: &adw::Application, conn: FrontendRequestWriter) -> Self {
+    pub(crate) fn new(
+        app: &adw::Application,
+        #[cfg(unix)] tx: UnixStream,
+        #[cfg(windows)] tx: TcpStream,
+    ) -> Self {
        let window: Self = Object::builder().property("application", app).build();
-        window
-            .imp()
-            .frontend_request_writer
-            .borrow_mut()
-            .replace(conn);
+        window.imp().stream.borrow_mut().replace(tx);
        window
    }

@@ -247,11 +257,7 @@ impl Window {
    }

    pub fn request_client_state(&self, client: &ClientObject) {
-        self.request_client_state_for(client.handle());
-    }
-
-    pub fn request_client_state_for(&self, handle: ClientHandle) {
-        self.request(FrontendRequest::GetState(handle));
+        self.request(FrontendRequest::GetState(client.handle()));
    }

    pub fn request_client_create(&self) {
@@ -286,10 +292,16 @@ impl Window {
        self.request(FrontendRequest::Delete(client.handle()));
    }

-    pub fn request(&self, request: FrontendRequest) {
-        let mut requester = self.imp().frontend_request_writer.borrow_mut();
-        let requester = requester.as_mut().unwrap();
-        if let Err(e) = requester.request(request) {
+    pub fn request(&self, event: FrontendRequest) {
+        let json = serde_json::to_string(&event).unwrap();
+        log::debug!("requesting: {json}");
+        let mut stream = self.imp().stream.borrow_mut();
+        let stream = stream.as_mut().unwrap();
+        let bytes = json.as_bytes();
+        if let Err(e) = stream.write_u64(Endian::Big, bytes.len() as u64) {
+            log::error!("error sending message: {e}");
+        };
+        if let Err(e) = stream.write(bytes) {
            log::error!("error sending message: {e}");
        };
    }
--- a/lan-mouse-gtk/src/window/imp.rs
+++ b/lan-mouse-gtk/src/window/imp.rs
@@ -1,12 +1,17 @@
 use std::cell::{Cell, RefCell};

+#[cfg(windows)]
+use std::net::TcpStream;
+#[cfg(unix)]
+use std::os::unix::net::UnixStream;
+
 use adw::subclass::prelude::*;
 use adw::{prelude::*, ActionRow, PreferencesGroup, ToastOverlay};
 use glib::subclass::InitializingObject;
 use gtk::glib::clone;
 use gtk::{gdk, gio, glib, Button, CompositeTemplate, Entry, Label, ListBox};

-use lan_mouse_ipc::{FrontendRequestWriter, DEFAULT_PORT};
+use crate::config::DEFAULT_PORT;

 #[derive(CompositeTemplate, Default)]
 #[template(resource = "/de/feschber/LanMouse/window.ui")]
@@ -36,7 +41,10 @@ pub struct Window {
    #[template_child]
    pub input_capture_button: TemplateChild<Button>,
    pub clients: RefCell<Option<gio::ListStore>>,
-    pub frontend_request_writer: RefCell<Option<FrontendRequestWriter>>,
+    #[cfg(unix)]
+    pub stream: RefCell<Option<UnixStream>>,
+    #[cfg(windows)]
+    pub stream: RefCell<Option<TcpStream>>,
    pub port: Cell<u16>,
    pub capture_active: Cell<bool>,
    pub emulation_active: Cell<bool>,
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,3 +5,4 @@ pub mod server;

 pub mod capture_test;
 pub mod emulation_test;
+pub mod frontend;
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,36 +1,10 @@
-use env_logger::Env;
-use input_capture::InputCaptureError;
-use input_emulation::InputEmulationError;
-use lan_mouse::{
-    capture_test,
-    config::{Config, ConfigError, Frontend},
-    emulation_test,
-    server::{Server, ServiceError},
-};
-use lan_mouse_ipc::IpcError;
-use std::{
-    future::Future,
-    io,
-    process::{self, Child, Command},
-};
-use thiserror::Error;
-use tokio::task::LocalSet;
+use anyhow::Result;
+use std::process::{self, Child, Command};

-#[derive(Debug, Error)]
-enum LanMouseError {
-    #[error(transparent)]
-    Service(#[from] ServiceError),
-    #[error(transparent)]
-    IpcError(#[from] IpcError),
-    #[error(transparent)]
-    Config(#[from] ConfigError),
-    #[error(transparent)]
-    Io(#[from] io::Error),
-    #[error(transparent)]
-    Capture(#[from] InputCaptureError),
-    #[error(transparent)]
-    Emulation(#[from] InputEmulationError),
-}
+use env_logger::Env;
+use lan_mouse::{capture_test, config::Config, emulation_test, frontend, server::Server};
+
+use tokio::task::LocalSet;

 pub fn main() {
    // init logging
@@ -43,24 +17,32 @@ pub fn main() {
    }
 }

-fn run() -> Result<(), LanMouseError> {
+pub fn start_service() -> Result<Child> {
+    let child = Command::new(std::env::current_exe()?)
+        .args(std::env::args().skip(1))
+        .arg("--daemon")
+        .spawn()?;
+    Ok(child)
+}
+
+pub fn run() -> Result<()> {
    // parse config file + cli args
    let config = Config::new()?;
    log::debug!("{config:?}");
    log::info!("release bind: {:?}", config.release_bind);

    if config.test_capture {
-        run_async(capture_test::run(config))?;
+        capture_test::run()?;
    } else if config.test_emulation {
-        run_async(emulation_test::run(config))?;
+        emulation_test::run()?;
    } else if config.daemon {
        // if daemon is specified we run the service
-        run_async(run_service(config))?;
+        run_service(config)?;
    } else {
        //  otherwise start the service as a child process and
        //  run a frontend
        let mut service = start_service()?;
-        run_frontend(&config)?;
+        frontend::run_frontend(&config)?;
        #[cfg(unix)]
        {
            // on unix we give the service a chance to terminate gracefully
@@ -73,14 +55,10 @@ fn run() -> Result<(), LanMouseError> {
        service.kill()?;
    }

-    Ok(())
+    anyhow::Ok(())
 }

-fn run_async<F, E>(f: F) -> Result<(), LanMouseError>
-where
-    F: Future<Output = Result<(), E>>,
-    LanMouseError: From<E>,
-{
+fn run_service(config: Config) -> Result<()> {
    // create single threaded tokio runtime
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_io()
@@ -88,35 +66,15 @@ where
        .build()?;

    // run async event loop
-    Ok(runtime.block_on(LocalSet::new().run_until(f))?)
-}
+    runtime.block_on(LocalSet::new().run_until(async {
+        // run main loop
+        log::info!("Press {:?} to release the mouse", config.release_bind);

-fn start_service() -> Result<Child, io::Error> {
-    let child = Command::new(std::env::current_exe()?)
-        .args(std::env::args().skip(1))
-        .arg("--daemon")
-        .spawn()?;
-    Ok(child)
-}
+        let mut server = Server::new(config);
+        server.run().await?;

-async fn run_service(config: Config) -> Result<(), ServiceError> {
-    log::info!("Press {:?} to release the mouse", config.release_bind);
-    Server::new(config).run().await?;
-    log::info!("service exited!");
-    Ok(())
-}
-
-fn run_frontend(config: &Config) -> Result<(), IpcError> {
-    match config.frontend {
-        #[cfg(feature = "gtk")]
-        Frontend::Gtk => {
-            lan_mouse_gtk::run();
-        }
-        #[cfg(not(feature = "gtk"))]
-        Frontend::Gtk => panic!("gtk frontend requested but feature not enabled!"),
-        Frontend::Cli => {
-            lan_mouse_cli::run()?;
-        }
-    };
+        log::debug!("service exiting");
+        anyhow::Ok(())
+    }))?;
    Ok(())
 }
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,27 +1,30 @@
 use capture_task::CaptureRequest;
 use emulation_task::EmulationRequest;
-use futures::StreamExt;
-use hickory_resolver::error::ResolveError;
 use local_channel::mpsc::{channel, Sender};
 use log;
 use std::{
    cell::{Cell, RefCell},
    collections::{HashSet, VecDeque},
-    io,
+    io::ErrorKind,
    net::{IpAddr, SocketAddr},
    rc::Rc,
 };
-use thiserror::Error;
-use tokio::{join, signal, sync::Notify};
+use tokio::{io::ReadHalf, join, signal, sync::Notify, task::JoinHandle};
 use tokio_util::sync::CancellationToken;

-use crate::{client::ClientManager, config::Config, dns::DnsResolver};
-
-use lan_mouse_ipc::{
-    AsyncFrontendListener, ClientConfig, ClientHandle, ClientState, FrontendEvent, FrontendRequest,
-    ListenerCreationError, Position, Status,
+use crate::{
+    client::{ClientConfig, ClientHandle, ClientManager, ClientState, Position},
+    config::Config,
+    dns::DnsResolver,
+    frontend::{self, FrontendEvent, FrontendListener, FrontendRequest, Status},
 };

+#[cfg(unix)]
+use tokio::net::UnixStream;
+
+#[cfg(windows)]
+use tokio::net::TcpStream;
+
 mod capture_task;
 mod emulation_task;
 mod network_task;
@@ -38,16 +41,6 @@ enum State {
    AwaitAck,
 }

-#[derive(Debug, Error)]
-pub enum ServiceError {
-    #[error(transparent)]
-    Dns(#[from] ResolveError),
-    #[error(transparent)]
-    Listen(#[from] ListenerCreationError),
-    #[error(transparent)]
-    Io(#[from] io::Error),
-}
-
 #[derive(Clone)]
 pub struct Server {
    active_client: Rc<Cell<Option<ClientHandle>>>,
@@ -58,6 +51,7 @@ pub struct Server {
    notifies: Rc<Notifies>,
    config: Rc<Config>,
    pending_frontend_events: Rc<RefCell<VecDeque<FrontendEvent>>>,
+    pending_dns_requests: Rc<RefCell<VecDeque<ClientHandle>>>,
    capture_status: Rc<Cell<Status>>,
    emulation_status: Rc<Cell<Status>>,
 }
@@ -69,6 +63,7 @@ struct Notifies {
    ping: Notify,
    port_changed: Notify,
    frontend_event_pending: Notify,
+    dns_request_pending: Notify,
    cancel: CancellationToken,
 }

@@ -112,32 +107,40 @@ impl Server {
            release_bind,
            notifies,
            pending_frontend_events: Rc::new(RefCell::new(VecDeque::new())),
+            pending_dns_requests: Rc::new(RefCell::new(VecDeque::new())),
            capture_status: Default::default(),
            emulation_status: Default::default(),
        }
    }

-    pub async fn run(&mut self) -> Result<(), ServiceError> {
+    pub async fn run(&mut self) -> anyhow::Result<()> {
        // create frontend communication adapter, exit if already running
-        let mut frontend = match AsyncFrontendListener::new().await {
-            Ok(f) => f,
-            Err(ListenerCreationError::AlreadyRunning) => {
+        let mut frontend = match FrontendListener::new().await {
+            Some(f) => f?,
+            None => {
                log::info!("service already running, exiting");
                return Ok(());
            }
-            e => e?,
        };

        let (capture_tx, capture_rx) = channel(); /* requests for input capture */
        let (emulation_tx, emulation_rx) = channel(); /* emulation requests */
        let (udp_recv_tx, udp_recv_rx) = channel(); /* udp receiver */
        let (udp_send_tx, udp_send_rx) = channel(); /* udp sender */
+        let (request_tx, mut request_rx) = channel(); /* frontend requests */
        let (dns_tx, dns_rx) = channel(); /* dns requests */

+        // udp task
        let network = network_task::new(self.clone(), udp_recv_tx.clone(), udp_send_rx).await?;
+
+        // input capture
        let capture = capture_task::new(self.clone(), capture_rx, udp_send_tx.clone());
+
+        // input emulation
        let emulation =
            emulation_task::new(self.clone(), emulation_rx, udp_recv_rx, udp_send_tx.clone());
+
+        // create dns resolver
        let resolver = DnsResolver::new(dns_rx)?;
        let dns_task = tokio::task::spawn_local(resolver.run(self.clone()));

@@ -150,22 +153,30 @@ impl Server {
        );

        for handle in self.active_clients() {
-            dns_tx.send(handle).expect("channel closed");
+            self.request_dns(handle);
        }

+        log::info!("running service");
+
+        let mut join_handles = vec![];
+
        loop {
            tokio::select! {
-                request = frontend.next() => {
-                    let request = match request {
-                        Some(Ok(r)) => r,
-                        Some(Err(e)) => {
-                            log::error!("error receiving request: {e}");
-                            continue;
-                        }
-                        None => break,
+                stream = frontend.accept() => {
+                    match stream {
+                        Ok(s) => join_handles.push(handle_frontend_stream(self.notifies.cancel.clone(), s, request_tx.clone())),
+                        Err(e) => log::warn!("error accepting frontend connection: {e}"),
                    };
-                    log::debug!("handle frontend request: {request:?}");
-                    self.handle_request(&capture_tx.clone(), &emulation_tx.clone(), request, &dns_tx);
+                    self.enumerate();
+                    self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status.get()));
+                    self.notify_frontend(FrontendEvent::CaptureStatus(self.capture_status.get()));
+                    self.notify_frontend(FrontendEvent::PortChanged(self.port.get(), None));
+                }
+                request = request_rx.recv() => {
+                    let request = request.expect("channel closed");
+                    log::debug!("received frontend request: {request:?}");
+                    self.handle_request(&capture_tx.clone(), &emulation_tx.clone(), request).await;
+                    log::debug!("handled frontend request");
                }
                _ = self.notifies.frontend_event_pending.notified() => {
                    while let Some(event) = {
@@ -176,6 +187,15 @@ impl Server {
                        frontend.broadcast(event).await;
                    }
                },
+                _ = self.notifies.dns_request_pending.notified() => {
+                    while let Some(request) = {
+                        /* need to drop borrow before next iteration! */
+                        let request = self.pending_dns_requests.borrow_mut().pop_front();
+                        request
+                    } {
+                        dns_tx.send(request).expect("channel closed");
+                    }
+                }
                _ = self.cancelled() => break,
                r = signal::ctrl_c() => {
                    r.expect("failed to wait for CTRL+C");
@@ -187,6 +207,7 @@ impl Server {
        log::info!("terminating service");

        self.cancel();
+        futures::future::join_all(join_handles).await;
        let _ = join!(capture, dns_task, emulation, network, ping);

        Ok(())
@@ -210,7 +231,6 @@ impl Server {
    }

    fn notify_capture(&self) {
-        log::info!("received capture enable request");
        self.notifies.capture.notify_waiters()
    }

@@ -219,7 +239,6 @@ impl Server {
    }

    fn notify_emulation(&self) {
-        log::info!("received emulation enable request");
        self.notifies.emulation.notify_waiters()
    }

@@ -246,7 +265,10 @@ impl Server {
    }

    pub(crate) fn client_updated(&self, handle: ClientHandle) {
-        self.notify_frontend(FrontendEvent::Changed(handle));
+        let state = self.client_manager.borrow().get(handle).cloned();
+        if let Some((config, state)) = state {
+            self.notify_frontend(FrontendEvent::State(handle, config, state));
+        }
    }

    fn active_clients(&self) -> Vec<ClientHandle> {
@@ -258,49 +280,55 @@ impl Server {
            .collect()
    }

-    fn handle_request(
+    fn request_dns(&self, handle: ClientHandle) {
+        self.pending_dns_requests.borrow_mut().push_back(handle);
+        self.notifies.dns_request_pending.notify_one();
+    }
+
+    async fn handle_request(
        &self,
        capture: &Sender<CaptureRequest>,
        emulate: &Sender<EmulationRequest>,
        event: FrontendRequest,
-        dns: &Sender<ClientHandle>,
    ) -> bool {
        log::debug!("frontend: {event:?}");
        match event {
-            FrontendRequest::EnableCapture => self.notify_capture(),
-            FrontendRequest::EnableEmulation => self.notify_emulation(),
+            FrontendRequest::EnableCapture => {
+                log::info!("received capture enable request");
+                self.notify_capture();
+            }
+            FrontendRequest::EnableEmulation => {
+                log::info!("received emulation enable request");
+                self.notify_emulation();
+            }
            FrontendRequest::Create => {
-                self.add_client();
+                let handle = self.add_client().await;
+                self.request_dns(handle);
            }
            FrontendRequest::Activate(handle, active) => {
                if active {
-                    self.activate_client(capture, emulate, handle);
+                    self.activate_client(capture, emulate, handle).await;
                } else {
-                    self.deactivate_client(capture, emulate, handle);
+                    self.deactivate_client(capture, emulate, handle).await;
                }
            }
            FrontendRequest::ChangePort(port) => self.request_port_change(port),
            FrontendRequest::Delete(handle) => {
-                self.remove_client(capture, emulate, handle);
+                self.remove_client(capture, emulate, handle).await;
                self.notify_frontend(FrontendEvent::Deleted(handle));
            }
            FrontendRequest::Enumerate() => self.enumerate(),
            FrontendRequest::GetState(handle) => self.broadcast_client(handle),
-            FrontendRequest::UpdateFixIps(handle, fix_ips) => self.update_fix_ips(handle, fix_ips),
-            FrontendRequest::UpdateHostname(handle, host) => {
-                self.update_hostname(handle, host, dns)
+            FrontendRequest::UpdateFixIps(handle, fix_ips) => {
+                self.update_fix_ips(handle, fix_ips);
+                self.request_dns(handle);
            }
+            FrontendRequest::UpdateHostname(handle, host) => self.update_hostname(handle, host),
            FrontendRequest::UpdatePort(handle, port) => self.update_port(handle, port),
            FrontendRequest::UpdatePosition(handle, pos) => {
-                self.update_pos(handle, capture, emulate, pos)
-            }
-            FrontendRequest::ResolveDns(handle) => dns.send(handle).expect("channel closed"),
-            FrontendRequest::Sync => {
-                self.enumerate();
-                self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status.get()));
-                self.notify_frontend(FrontendEvent::CaptureStatus(self.capture_status.get()));
-                self.notify_frontend(FrontendEvent::PortChanged(self.port.get(), None));
+                self.update_pos(handle, capture, emulate, pos).await;
            }
+            FrontendRequest::ResolveDns(handle) => self.request_dns(handle),
        };
        false
    }
@@ -315,7 +343,7 @@ impl Server {
        self.notify_frontend(FrontendEvent::Enumerate(clients));
    }

-    fn add_client(&self) -> ClientHandle {
+    async fn add_client(&self) -> ClientHandle {
        let handle = self.client_manager.borrow_mut().add_client();
        log::info!("added client {handle}");
        let (c, s) = self.client_manager.borrow().get(handle).unwrap().clone();
@@ -323,40 +351,41 @@ impl Server {
        handle
    }

-    fn deactivate_client(
+    async fn deactivate_client(
        &self,
        capture: &Sender<CaptureRequest>,
        emulate: &Sender<EmulationRequest>,
        handle: ClientHandle,
    ) {
+        log::debug!("deactivating client {handle}");
        match self.client_manager.borrow_mut().get_mut(handle) {
-            None => return,
-            Some((_, s)) if !s.active => return,
            Some((_, s)) => s.active = false,
+            None => return,
        };

        let _ = capture.send(CaptureRequest::Destroy(handle));
        let _ = emulate.send(EmulationRequest::Destroy(handle));
-        self.client_updated(handle);
-        log::info!("deactivated client {handle}");
+        log::debug!("deactivating client {handle} done");
    }

-    fn activate_client(
+    async fn activate_client(
        &self,
        capture: &Sender<CaptureRequest>,
        emulate: &Sender<EmulationRequest>,
        handle: ClientHandle,
    ) {
+        log::debug!("activating client");
        /* deactivate potential other client at this position */
        let pos = match self.client_manager.borrow().get(handle) {
-            None => return,
-            Some((_, s)) if s.active => return,
            Some((client, _)) => client.pos,
+            None => return,
        };

        let other = self.client_manager.borrow_mut().find_client(pos);
        if let Some(other) = other {
-            self.deactivate_client(capture, emulate, other);
+            if other != handle {
+                self.deactivate_client(capture, emulate, other).await;
+            }
        }

        /* activate the client */
@@ -367,15 +396,12 @@ impl Server {
        };

        /* notify emulation, capture and frontends */
-        let _ = capture.send(CaptureRequest::Create(handle, to_capture_pos(pos)));
+        let _ = capture.send(CaptureRequest::Create(handle, pos.into()));
        let _ = emulate.send(EmulationRequest::Create(handle));
-
-        self.client_updated(handle);
-
-        log::info!("activated client {handle} ({pos})");
+        log::debug!("activating client {handle} done");
    }

-    fn remove_client(
+    async fn remove_client(
        &self,
        capture: &Sender<CaptureRequest>,
        emulate: &Sender<EmulationRequest>,
@@ -407,7 +433,6 @@ impl Server {
            c.fix_ips = fix_ips;
        };
        self.update_ips(handle);
-        self.client_updated(handle);
    }

    pub(crate) fn update_dns_ips(&self, handle: ClientHandle, dns_ips: Vec<IpAddr>) {
@@ -415,7 +440,6 @@ impl Server {
            s.dns_ips = dns_ips;
        };
        self.update_ips(handle);
-        self.client_updated(handle);
    }

    fn update_ips(&self, handle: ClientHandle) {
@@ -429,12 +453,7 @@ impl Server {
        }
    }

-    fn update_hostname(
-        &self,
-        handle: ClientHandle,
-        hostname: Option<String>,
-        dns: &Sender<ClientHandle>,
-    ) {
+    fn update_hostname(&self, handle: ClientHandle, hostname: Option<String>) {
        let mut client_manager = self.client_manager.borrow_mut();
        let Some((c, s)) = client_manager.get_mut(handle) else {
            return;
@@ -443,13 +462,10 @@ impl Server {
        // hostname changed
        if c.hostname != hostname {
            c.hostname = hostname;
+            s.ips = HashSet::from_iter(c.fix_ips.iter().cloned());
            s.active_addr = None;
-            s.dns_ips.clear();
-            drop(client_manager);
-            self.update_ips(handle);
-            dns.send(handle).expect("channel closed");
+            self.request_dns(handle);
        }
-        self.client_updated(handle);
    }

    fn update_port(&self, handle: ClientHandle, port: u16) {
@@ -464,7 +480,7 @@ impl Server {
        }
    }

-    fn update_pos(
+    async fn update_pos(
        &self,
        handle: ClientHandle,
        capture: &Sender<CaptureRequest>,
@@ -478,19 +494,18 @@ impl Server {
            };

            let changed = c.pos != pos;
-            if changed {
-                log::info!("update pos {handle} {} -> {}", c.pos, pos);
-            }
            c.pos = pos;
            (changed, s.active)
        };

        // update state in event input emulator & input capture
        if changed {
-            self.deactivate_client(capture, emulate, handle);
            if active {
-                self.activate_client(capture, emulate, handle);
+                let _ = capture.send(CaptureRequest::Destroy(handle));
+                let _ = emulate.send(EmulationRequest::Destroy(handle));
            }
+            let _ = capture.send(CaptureRequest::Create(handle, pos.into()));
+            let _ = emulate.send(EmulationRequest::Create(handle));
        }
    }

@@ -523,7 +538,7 @@ impl Server {
        self.client_updated(handle);
    }

-    pub(crate) fn get_hostname(&self, handle: ClientHandle) -> Option<String> {
+    pub(crate) fn get_hostname(&self, handle: u64) -> Option<String> {
        self.client_manager
            .borrow_mut()
            .get_mut(handle)
@@ -539,12 +554,12 @@ impl Server {
        self.state.replace(state);
    }

-    fn set_active(&self, handle: Option<ClientHandle>) {
+    fn set_active(&self, handle: Option<u64>) {
        log::debug!("active client => {handle:?}");
        self.active_client.replace(handle);
    }

-    fn active_addr(&self, handle: ClientHandle) -> Option<SocketAddr> {
+    fn active_addr(&self, handle: u64) -> Option<SocketAddr> {
        self.client_manager
            .borrow()
            .get(handle)
@@ -552,11 +567,41 @@ impl Server {
    }
 }

-fn to_capture_pos(pos: Position) -> input_capture::Position {
-    match pos {
-        Position::Left => input_capture::Position::Left,
-        Position::Right => input_capture::Position::Right,
-        Position::Top => input_capture::Position::Top,
-        Position::Bottom => input_capture::Position::Bottom,
+async fn listen_frontend(
+    request_tx: Sender<FrontendRequest>,
+    #[cfg(unix)] mut stream: ReadHalf<UnixStream>,
+    #[cfg(windows)] mut stream: ReadHalf<TcpStream>,
+) {
+    use std::io;
+    loop {
+        let request = frontend::wait_for_request(&mut stream).await;
+        match request {
+            Ok(request) => {
+                let _ = request_tx.send(request);
+            }
+            Err(e) => {
+                if let Some(e) = e.downcast_ref::<io::Error>() {
+                    if e.kind() == ErrorKind::UnexpectedEof {
+                        return;
+                    }
+                }
+                log::error!("error reading frontend event: {e}");
+                return;
+            }
+        }
    }
 }
+
+fn handle_frontend_stream(
+    cancel: CancellationToken,
+    #[cfg(unix)] stream: ReadHalf<UnixStream>,
+    #[cfg(windows)] stream: ReadHalf<TcpStream>,
+    request_tx: Sender<FrontendRequest>,
+) -> JoinHandle<()> {
+    tokio::task::spawn_local(async move {
+        tokio::select! {
+            _ = listen_frontend(request_tx, stream) => {},
+            _ = cancel.cancelled() => {},
+        }
+    })
+}
--- a/src/server/capture_task.rs
+++ b/src/server/capture_task.rs
@@ -9,8 +9,7 @@ use input_capture::{
    self, CaptureError, CaptureEvent, CaptureHandle, InputCapture, InputCaptureError, Position,
 };

-use crate::server::State;
-use lan_mouse_ipc::{ClientHandle, Status};
+use crate::{client::ClientHandle, frontend::Status, server::State};

 use super::Server;

@@ -86,7 +85,7 @@ async fn do_capture(
        )
    });
    for (handle, pos) in clients {
-        capture.create(handle, to_capture_pos(pos)).await?;
+        capture.create(handle, pos.into()).await?;
    }

    loop {
@@ -195,12 +194,3 @@ fn spawn_hook_command(server: &Server, handle: ClientHandle) {
        }
    });
 }
-
-fn to_capture_pos(pos: lan_mouse_ipc::Position) -> input_capture::Position {
-    match pos {
-        lan_mouse_ipc::Position::Left => input_capture::Position::Left,
-        lan_mouse_ipc::Position::Right => input_capture::Position::Right,
-        lan_mouse_ipc::Position::Top => input_capture::Position::Top,
-        lan_mouse_ipc::Position::Bottom => input_capture::Position::Bottom,
-    }
-}
--- a/src/server/emulation_task.rs
+++ b/src/server/emulation_task.rs
@@ -4,11 +4,12 @@ use std::net::SocketAddr;
 use lan_mouse_proto::ProtoEvent;
 use tokio::task::JoinHandle;

-use lan_mouse_ipc::ClientHandle;
-
-use crate::{client::ClientManager, server::State};
+use crate::{
+    client::{ClientHandle, ClientManager},
+    frontend::Status,
+    server::State,
+};
 use input_emulation::{self, EmulationError, EmulationHandle, InputEmulation, InputEmulationError};
-use lan_mouse_ipc::Status;

 use super::{network_task::NetworkError, Server};

--- a/src/server/ping_task.rs
+++ b/src/server/ping_task.rs
@@ -4,7 +4,7 @@ use lan_mouse_proto::ProtoEvent;
 use local_channel::mpsc::Sender;
 use tokio::task::JoinHandle;

-use lan_mouse_ipc::ClientHandle;
+use crate::client::ClientHandle;

 use super::{capture_task::CaptureRequest, emulation_task::EmulationRequest, Server, State};