macos: cleanup event tap thread on exit

closes #294

Cargo.lock

@@ -2023,6 +2023,7 @@ dependencies = [
  "lan-mouse-ipc",
  "libadwaita",
  "log",
+ "thiserror 2.0.0",
 ]
 
 [[package]]

README.md

@@ -268,19 +268,17 @@ If the device still can not be entered, make sure you have UDP port `4242` (or t
 <details>
     <summary>Command Line Interface</summary>
 
-The cli interface can be enabled using `--frontend cli` as commandline arguments.
-Type `help` to list the available commands.
-
-E.g.:
+The cli interface can be accessed by passing `cli` as a commandline argument.
+Use
 ```sh
-$ cargo run --release -- --frontend cli
-(...)
-> connect <host> left|right|top|bottom
-(...)
-> list
-(...)
-> activate 0
+lan-mouse cli help
 ```
+ to list the available commands and
+```sh
+lan-mouse cli <cmd> help
+```
+for information on how to use a specific command.
+
 </details>
 
 <details>
@@ -326,9 +324,6 @@ release_bind = [ "KeyA", "KeyS", "KeyD", "KeyF" ]
 
 # optional port (defaults to 4242)
 port = 4242
-# # optional frontend -> defaults to gtk if available
-# # possible values are "cli" and "gtk"
-# frontend = "gtk"
 
 # list of authorized tls certificate fingerprints that
 # are accepted for incoming traffic
@@ -336,7 +331,9 @@ port = 4242
 "bc:05:ab:7a:a4:de:88:8c:2f:92:ac:bc:b8:49:b8:24:0d:44:b3:e6:a4:ef:d7:0b:6c:69:6d:77:53:0b:14:80" = "iridium"
 
 # define a client on the right side with host name "iridium"
-[right]
+[[clients]]
+# position (left | right | top | bottom)
+position = "right"
 # hostname
 hostname = "iridium"
 # activate this client immediately when lan-mouse is started
@@ -345,7 +342,8 @@ activate_on_startup = true
 ips = ["192.168.178.156"]
 
 # define a client on the left side with IP address 192.168.178.189
-[left]
+[[clients]]
+position = "left"
 # The hostname is optional: When no hostname is specified,
 # at least one ip address needs to be specified.
 hostname = "thorium"

config.toml

@@ -1,14 +1,10 @@
 # example configuration
 
-# capture_backend = "LayerShell"
-
-# release bind
-release_bind = ["KeyA", "KeyS", "KeyD", "KeyF"]
+# configure release bind
+release_bind = [ "KeyA", "KeyS", "KeyD", "KeyF" ]
 
 # optional port (defaults to 4242)
 port = 4242
-# optional frontend -> defaults to gtk if available
-# frontend = "gtk"
 
 # list of authorized tls certificate fingerprints that
 # are accepted for incoming traffic
@@ -16,14 +12,19 @@ port = 4242
 "bc:05:ab:7a:a4:de:88:8c:2f:92:ac:bc:b8:49:b8:24:0d:44:b3:e6:a4:ef:d7:0b:6c:69:6d:77:53:0b:14:80" = "iridium"
 
 # define a client on the right side with host name "iridium"
-[right]
+[[clients]]
+# position (left | right | top | bottom)
+position = "right"
 # hostname
 hostname = "iridium"
+# activate this client immediately when lan-mouse is started
+activate_on_startup = true
 # optional list of (known) ip addresses
 ips = ["192.168.178.156"]
 
 # define a client on the left side with IP address 192.168.178.189
-[left]
+[[clients]]
+position = "left"
 # The hostname is optional: When no hostname is specified,
 # at least one ip address needs to be specified.
 hostname = "thorium"

input-capture/src/layer_shell.rs

@@ -813,7 +813,7 @@ impl Dispatch<WlPointer, ()> for State {
                     })),
                 ));
             }
-            wl_pointer::Event::Frame {} => {
+            wl_pointer::Event::Frame => {
                 // TODO properly handle frame events
                 // we simply insert a frame event on the client side
                 // after each event for now

input-capture/src/macos.rs

@@ -390,9 +390,9 @@ fn create_event_tap<'a>(
 
             if let Some(pos) = pos {
                 res_events.iter().for_each(|e| {
-                    event_tx
-                        .blocking_send((pos, *e))
-                        .expect("Failed to send event");
+                    // error must be ignored, since the event channel
+                    // may already be closed when the InputCapture instance is dropped.
+                    let _ = event_tx.blocking_send((pos, *e));
                 });
                 // Returning None should stop the event from being processed
                 // but core fundation still returns the event
@@ -426,8 +426,8 @@ fn event_tap_thread(
     client_state: Arc<Mutex<InputCaptureState>>,
     event_tx: Sender<(Position, CaptureEvent)>,
     notify_tx: Sender<ProducerEvent>,
-    ready: std::sync::mpsc::Sender<Result<(), MacosCaptureCreationError>>,
-    exit: oneshot::Sender<Result<(), &'static str>>,
+    ready: std::sync::mpsc::Sender<Result<CFRunLoop, MacosCaptureCreationError>>,
+    exit: oneshot::Sender<()>,
 ) {
     let _tap = match create_event_tap(client_state, notify_tx, event_tx) {
         Err(e) => {
@@ -435,18 +435,22 @@ fn event_tap_thread(
             return;
         }
         Ok(tap) => {
-            ready.send(Ok(())).expect("channel closed");
+            let run_loop = CFRunLoop::get_current();
+            ready.send(Ok(run_loop)).expect("channel closed");
             tap
         }
     };
+    log::debug!("running CFRunLoop...");
     CFRunLoop::run_current();
+    log::debug!("event tap thread exiting!...");
 
-    let _ = exit.send(Err("tap thread exited"));
+    let _ = exit.send(());
 }
 
 pub struct MacOSInputCapture {
     event_rx: Receiver<(Position, CaptureEvent)>,
     notify_tx: Sender<ProducerEvent>,
+    run_loop: CFRunLoop,
 }
 
 impl MacOSInputCapture {
@@ -475,36 +479,44 @@ impl MacOSInputCapture {
         });
 
         // wait for event tap creation result
-        ready_rx.recv().expect("channel closed")?;
+        let run_loop = ready_rx.recv().expect("channel closed")?;
 
         let _tap_task: tokio::task::JoinHandle<()> = tokio::task::spawn_local(async move {
             loop {
                 tokio::select! {
                     producer_event = notify_rx.recv() => {
-                        let producer_event = producer_event.expect("channel closed");
+                        let Some(producer_event) = producer_event else {
+                            break;
+                        };
                         let mut state = state.lock().await;
                         state.handle_producer_event(producer_event).await.unwrap_or_else(|e| {
                             log::error!("Failed to handle producer event: {e}");
                         })
                     }
 
-                    res = &mut tap_exit_rx => {
-                        if let Err(e) = res.expect("channel closed") {
-                            log::error!("Tap thread failed: {:?}", e);
-                            break;
-                        }
+                    _ = &mut tap_exit_rx => {
+                        break;
                     }
                 }
             }
+            // show cursor
+            let _ = CGDisplay::show_cursor(&CGDisplay::main());
         });
 
         Ok(Self {
             event_rx,
             notify_tx,
+            run_loop,
         })
     }
 }
 
+impl Drop for MacOSInputCapture {
+    fn drop(&mut self) {
+        self.run_loop.stop();
+    }
+}
+
 #[async_trait]
 impl Capture for MacOSInputCapture {
     async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {

input-capture/src/windows/event_thread.rs

@@ -22,9 +22,9 @@ use windows::Win32::UI::WindowsAndMessaging::{
     RegisterClassW, SetWindowsHookExW, TranslateMessage, EDD_GET_DEVICE_INTERFACE_NAME, HHOOK,
     HMENU, HOOKPROC, KBDLLHOOKSTRUCT, LLKHF_EXTENDED, MSG, MSLLHOOKSTRUCT, WH_KEYBOARD_LL,
     WH_MOUSE_LL, WINDOW_STYLE, WM_DISPLAYCHANGE, WM_KEYDOWN, WM_KEYUP, WM_LBUTTONDOWN,
-    WM_LBUTTONUP, WM_MBUTTONDOWN, WM_MBUTTONUP, WM_MOUSEMOVE, WM_MOUSEWHEEL, WM_RBUTTONDOWN,
-    WM_RBUTTONUP, WM_SYSKEYDOWN, WM_SYSKEYUP, WM_USER, WM_XBUTTONDOWN, WM_XBUTTONUP, WNDCLASSW,
-    WNDPROC,
+    WM_LBUTTONUP, WM_MBUTTONDOWN, WM_MBUTTONUP, WM_MOUSEHWHEEL, WM_MOUSEMOVE, WM_MOUSEWHEEL,
+    WM_RBUTTONDOWN, WM_RBUTTONUP, WM_SYSKEYDOWN, WM_SYSKEYUP, WM_USER, WM_XBUTTONDOWN,
+    WM_XBUTTONUP, WNDCLASSW, WNDPROC,
 };
 
 use input_event::{
@@ -537,6 +537,10 @@ fn to_mouse_event(wparam: WPARAM, lparam: LPARAM) -> Option<PointerEvent> {
                 state: if p == WM_XBUTTONDOWN as usize { 1 } else { 0 },
             })
         }
+        WPARAM(p) if p == WM_MOUSEHWHEEL as usize => Some(PointerEvent::AxisDiscrete120 {
+            axis: 1, // Horizontal
+            value: mouse_low_level.mouseData as i32 >> 16,
+        }),
         w => {
             log::warn!("unknown mouse event: {w:?}");
             None

input-emulation/src/x11.rs

@@ -23,7 +23,7 @@ impl X11Emulation {
     pub(crate) fn new() -> Result<Self, X11EmulationCreationError> {
         let display = unsafe {
             match xlib::XOpenDisplay(ptr::null()) {
-                d if d == ptr::null::<xlib::Display>() as *mut xlib::Display => {
+                d if std::ptr::eq(d, ptr::null_mut::<xlib::Display>()) => {
                     Err(X11EmulationCreationError::OpenDisplay)
                 }
                 display => Ok(display),

input-emulation/src/xdg_desktop_portal.rs

@@ -143,7 +143,6 @@ impl Emulation for DesktopPortalEmulation<'_> {
 
 impl AsyncDrop for DesktopPortalEmulation<'_> {
     #[doc = r" Perform the async cleanup."]
-    #[must_use]
     #[allow(clippy::type_complexity, clippy::type_repetition_in_bounds)]
     fn async_drop<'async_trait>(
         self,

lan-mouse-cli/src/lib.rs

@@ -18,7 +18,7 @@ pub enum CliError {
     Ipc(#[from] IpcError),
 }
 
-#[derive(Parser, Debug, PartialEq, Eq)]
+#[derive(Parser, Clone, Debug, PartialEq, Eq)]
 #[command(name = "lan-mouse-cli", about = "LanMouse CLI interface")]
 pub struct CliArgs {
     #[command(subcommand)]
@@ -37,7 +37,7 @@ struct Client {
     enter_hook: Option<String>,
 }
 
-#[derive(Subcommand, Debug, PartialEq, Eq)]
+#[derive(Clone, Subcommand, Debug, PartialEq, Eq)]
 enum CliSubcommand {
     /// add a new client
     AddClient(Client),

lan-mouse-gtk/Cargo.toml

@@ -13,6 +13,7 @@ async-channel = { version = "2.1.1" }
 hostname = "0.4.0"
 log = "0.4.20"
 lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.2.0" }
+thiserror = "2.0.0"
 
 [build-dependencies]
 glib-build-tools = { version = "0.20.0" }

lan-mouse-gtk/resources/authorization_window.ui

@@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <requires lib="gtk" version="4.0"/>
+  <requires lib="libadwaita" version="1.0"/>
+  <template class="AuthorizationWindow" parent="AdwWindow">
+    <property name="modal">True</property>
+    <property name="width-request">180</property>
+    <property name="default-width">180</property>
+    <property name="height-request">180</property>
+    <property name="default-height">180</property>
+    <property name="title" translatable="yes">Unauthorized Device</property>
+    <property name="content">
+      <object class="GtkBox">
+        <property name="orientation">vertical</property>
+        <property name="vexpand">True</property>
+        <child type="top">
+          <object class="AdwHeaderBar">
+            <style>
+              <class name="flat"/>
+            </style>
+          </object>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="orientation">vertical</property>
+            <property name="spacing">30</property>
+            <property name="margin-start">30</property>
+            <property name="margin-end">30</property>
+            <property name="margin-top">30</property>
+            <property name="margin-bottom">30</property>
+            <child>
+              <object class="GtkLabel">
+                <property name="label">An unauthorized Device is trying to connect. Do you want to authorize this Device?</property>
+                <property name="width-request">100</property>
+                <property name="wrap">word-wrap</property>
+              </object>
+            </child>
+            <child>
+              <object class="AdwPreferencesGroup">
+                <property name="title">sha256 fingerprint</property>
+                <child>
+                  <object class="AdwActionRow">
+                    <property name="child">
+                      <object class="GtkLabel" id="fingerprint">
+                        <property name="ellipsize">PANGO_ELLIPSIZE_NONE</property>
+                        <property name="vexpand">True</property>
+                        <property name="hexpand">False</property>
+                        <property name="wrap">True</property>
+                        <property name="wrap-mode">word-char</property>
+                        <property name="justify">center</property>
+                        <property name="xalign">0.5</property>
+                        <property name="margin-top">10</property>
+                        <property name="margin-bottom">10</property>
+                        <property name="margin-start">10</property>
+                        <property name="margin-end">10</property>
+                        <property name="width-chars">64</property>
+                      </object>
+                    </property>
+                  </object>
+                </child>
+              </object>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="margin-start">30</property>
+            <property name="margin-end">30</property>
+            <property name="margin-top">30</property>
+            <property name="margin-bottom">30</property>
+            <property name="orientation">horizontal</property>
+            <property name="spacing">30</property>
+            <property name="hexpand">True</property>
+            <property name="vexpand">True</property>
+            <property name="valign">end</property>
+            <child>
+              <object class="GtkButton" id="cancel_button">
+                <signal name="clicked" handler="handle_cancel" swapped="true"/>
+                <property name="label" translatable="yes">Cancel</property>
+                <property name="can-shrink">True</property>
+                <property name="height-request">50</property>
+                <property name="hexpand">True</property>
+              </object>
+            </child>
+            <child>
+              <object class="GtkButton" id="confirm_button">
+                <signal name="clicked" handler="handle_confirm" swapped="true"/>
+                <property name="label" translatable="yes">Authorize</property>
+                <property name="can-shrink">True</property>
+                <property name="height-request">50</property>
+                <property name="hexpand">True</property>
+                <style>
+                  <class name="destructive-action"/>
+                </style>
+              </object>
+            </child>
+          </object>
+        </child>
+      </object>
+    </property>
+  </template>
+</interface>

lan-mouse-gtk/resources/resources.gresource.xml

@@ -2,6 +2,7 @@
 <gresources>
   <gresource prefix="/de/feschber/LanMouse">
     <file compressed="true" preprocess="xml-stripblanks">window.ui</file>
+    <file compressed="true" preprocess="xml-stripblanks">authorization_window.ui</file>
     <file compressed="true" preprocess="xml-stripblanks">fingerprint_window.ui</file>
     <file compressed="true" preprocess="xml-stripblanks">client_row.ui</file>
     <file compressed="true" preprocess="xml-stripblanks">key_row.ui</file>

lan-mouse-gtk/src/authorization_window.rs

@@ -0,0 +1,19 @@
+mod imp;
+
+use glib::Object;
+use gtk::{gio, glib, subclass::prelude::ObjectSubclassIsExt};
+
+glib::wrapper! {
+    pub struct AuthorizationWindow(ObjectSubclass<imp::AuthorizationWindow>)
+    @extends adw::Window, gtk::Window, gtk::Widget,
+    @implements gio::ActionGroup, gio::ActionMap, gtk::Accessible, gtk::Buildable,
+                gtk::ConstraintTarget, gtk::Native, gtk::Root, gtk::ShortcutManager;
+}
+
+impl AuthorizationWindow {
+    pub(crate) fn new(fingerprint: &str) -> Self {
+        let window: Self = Object::builder().build();
+        window.imp().set_fingerprint(fingerprint);
+        window
+    }
+}

lan-mouse-gtk/src/authorization_window/imp.rs

@@ -0,0 +1,75 @@
+use std::sync::OnceLock;
+
+use adw::prelude::*;
+use adw::subclass::prelude::*;
+use glib::subclass::InitializingObject;
+use gtk::{
+    glib::{self, subclass::Signal},
+    template_callbacks, Button, CompositeTemplate, Label,
+};
+
+#[derive(CompositeTemplate, Default)]
+#[template(resource = "/de/feschber/LanMouse/authorization_window.ui")]
+pub struct AuthorizationWindow {
+    #[template_child]
+    pub fingerprint: TemplateChild<Label>,
+    #[template_child]
+    pub cancel_button: TemplateChild<Button>,
+    #[template_child]
+    pub confirm_button: TemplateChild<Button>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for AuthorizationWindow {
+    const NAME: &'static str = "AuthorizationWindow";
+    const ABSTRACT: bool = false;
+
+    type Type = super::AuthorizationWindow;
+    type ParentType = adw::Window;
+
+    fn class_init(klass: &mut Self::Class) {
+        klass.bind_template();
+        klass.bind_template_callbacks();
+    }
+
+    fn instance_init(obj: &InitializingObject<Self>) {
+        obj.init_template();
+    }
+}
+
+#[template_callbacks]
+impl AuthorizationWindow {
+    #[template_callback]
+    fn handle_confirm(&self, _button: Button) {
+        let fp = self.fingerprint.text().as_str().trim().to_owned();
+        self.obj().emit_by_name("confirm-clicked", &[&fp])
+    }
+
+    #[template_callback]
+    fn handle_cancel(&self, _: Button) {
+        self.obj().emit_by_name("cancel-clicked", &[])
+    }
+
+    pub(super) fn set_fingerprint(&self, fingerprint: &str) {
+        self.fingerprint.set_text(fingerprint);
+    }
+}
+
+impl ObjectImpl for AuthorizationWindow {
+    fn signals() -> &'static [Signal] {
+        static SIGNALS: OnceLock<Vec<Signal>> = OnceLock::new();
+        SIGNALS.get_or_init(|| {
+            vec![
+                Signal::builder("confirm-clicked")
+                    .param_types([String::static_type()])
+                    .build(),
+                Signal::builder("cancel-clicked").build(),
+            ]
+        })
+    }
+}
+
+impl WidgetImpl for AuthorizationWindow {}
+impl WindowImpl for AuthorizationWindow {}
+impl ApplicationWindowImpl for AuthorizationWindow {}
+impl AdwWindowImpl for AuthorizationWindow {}

lan-mouse-gtk/src/fingerprint_window.rs

@@ -1,7 +1,7 @@
 mod imp;
 
 use glib::Object;
-use gtk::{gio, glib};
+use gtk::{gio, glib, prelude::ObjectExt, subclass::prelude::ObjectSubclassIsExt};
 
 glib::wrapper! {
     pub struct FingerprintWindow(ObjectSubclass<imp::FingerprintWindow>)
@@ -11,8 +11,12 @@ glib::wrapper! {
 }
 
 impl FingerprintWindow {
-    pub(crate) fn new() -> Self {
+    pub(crate) fn new(fingerprint: Option<String>) -> Self {
         let window: Self = Object::builder().build();
+        if let Some(fp) = fingerprint {
+            window.imp().fingerprint.set_property("text", fp);
+            window.imp().fingerprint.set_property("editable", false);
+        }
         window
     }
 }

lan-mouse-gtk/src/key_row.rs

@@ -8,7 +8,7 @@ use super::KeyObject;
 
 glib::wrapper! {
     pub struct KeyRow(ObjectSubclass<imp::KeyRow>)
-    @extends gtk::ListBoxRow, gtk::Widget, adw::PreferencesRow, adw::ExpanderRow,
+    @extends gtk::ListBoxRow, gtk::Widget, adw::PreferencesRow, adw::ActionRow,
     @implements gtk::Accessible, gtk::Actionable, gtk::Buildable, gtk::ConstraintTarget;
 }
 

lan-mouse-gtk/src/lib.rs

@@ -1,3 +1,4 @@
+mod authorization_window;
 mod client_object;
 mod client_row;
 mod fingerprint_window;
@@ -18,7 +19,15 @@ use gtk::{gio, glib, prelude::ApplicationExt};
 use self::client_object::ClientObject;
 use self::key_object::KeyObject;
 
-pub fn run() -> glib::ExitCode {
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum GtkError {
+    #[error("gtk frontend exited with non zero exit code: {0}")]
+    NonZeroExitCode(i32),
+}
+
+pub fn run() -> Result<(), GtkError> {
     log::debug!("running gtk frontend");
     #[cfg(windows)]
     let ret = std::thread::Builder::new()
@@ -31,13 +40,10 @@ pub fn run() -> glib::ExitCode {
     #[cfg(not(windows))]
     let ret = gtk_main();
 
-    if ret == glib::ExitCode::FAILURE {
-        log::error!("frontend exited with failure");
-    } else {
-        log::info!("frontend exited successfully");
+    match ret {
+        glib::ExitCode::SUCCESS => Ok(()),
+        e => Err(GtkError::NonZeroExitCode(e.value())),
     }
-
-    ret
 }
 
 fn gtk_main() -> glib::ExitCode {
@@ -141,8 +147,21 @@ fn build_ui(app: &Application) {
                     FrontendEvent::EmulationStatus(s) => window.set_emulation(s.into()),
                     FrontendEvent::AuthorizedUpdated(keys) => window.set_authorized_keys(keys),
                     FrontendEvent::PublicKeyFingerprint(fp) => window.set_pk_fp(&fp),
-                    FrontendEvent::IncomingConnected(_fingerprint, addr, pos) => {
-                        window.show_toast(format!("device connected: {addr} ({pos})").as_str());
+                    FrontendEvent::ConnectionAttempt { fingerprint } => {
+                        window.request_authorization(&fingerprint);
+                    }
+                    FrontendEvent::DeviceConnected {
+                        fingerprint: _,
+                        addr,
+                    } => {
+                        window.show_toast(format!("device connected: {addr}").as_str());
+                    }
+                    FrontendEvent::DeviceEntered {
+                        fingerprint: _,
+                        addr,
+                        pos,
+                    } => {
+                        window.show_toast(format!("device entered: {addr} ({pos})").as_str());
                     }
                     FrontendEvent::IncomingDisconnected(addr) => {
                         window.show_toast(format!("{addr} disconnected").as_str());

lan-mouse-gtk/src/window.rs

@@ -16,7 +16,10 @@ use lan_mouse_ipc::{
     DEFAULT_PORT,
 };
 
-use crate::{fingerprint_window::FingerprintWindow, key_object::KeyObject, key_row::KeyRow};
+use crate::{
+    authorization_window::AuthorizationWindow, fingerprint_window::FingerprintWindow,
+    key_object::KeyObject, key_row::KeyRow,
+};
 
 use super::{client_object::ClientObject, client_row::ClientRow};
 
@@ -126,7 +129,7 @@ impl Window {
                             #[strong]
                             window,
                             move |row: ClientRow, hostname: String| {
-                                log::info!("request-hostname-change");
+                                log::debug!("request-hostname-change");
                                 if let Some(client) = window.client_by_idx(row.index() as u32) {
                                     let hostname = Some(hostname).filter(|s| !s.is_empty());
                                     /* changed in response to FrontendEvent
@@ -163,7 +166,7 @@ impl Window {
                             window,
                             move |row: ClientRow, active: bool| {
                                 if let Some(client) = window.client_by_idx(row.index() as u32) {
-                                    log::info!(
+                                    log::debug!(
                                         "request: {} client",
                                         if active { "activating" } else { "deactivating" }
                                     );
@@ -394,8 +397,8 @@ impl Window {
         self.request(FrontendRequest::Create);
     }
 
-    fn open_fingerprint_dialog(&self) {
-        let window = FingerprintWindow::new();
+    fn open_fingerprint_dialog(&self, fp: Option<String>) {
+        let window = FingerprintWindow::new(fp);
         window.set_transient_for(Some(self));
         window.connect_closure(
             "confirm-clicked",
@@ -469,4 +472,29 @@ impl Window {
     pub(super) fn set_pk_fp(&self, fingerprint: &str) {
         self.imp().fingerprint_row.set_subtitle(fingerprint);
     }
+
+    pub(super) fn request_authorization(&self, fingerprint: &str) {
+        let window = AuthorizationWindow::new(fingerprint);
+        window.set_transient_for(Some(self));
+        window.connect_closure(
+            "confirm-clicked",
+            false,
+            closure_local!(
+                #[strong(rename_to = parent)]
+                self,
+                move |w: AuthorizationWindow, fp: String| {
+                    w.close();
+                    parent.open_fingerprint_dialog(Some(fp));
+                }
+            ),
+        );
+        window.connect_closure(
+            "cancel-clicked",
+            false,
+            closure_local!(move |w: AuthorizationWindow| {
+                w.close();
+            }),
+        );
+        window.present();
+    }
 }

lan-mouse-gtk/src/window/imp.rs

@@ -149,7 +149,7 @@ impl Window {
 
     #[template_callback]
     fn handle_add_cert_fingerprint(&self, _button: &Button) {
-        self.obj().open_fingerprint_dialog();
+        self.obj().open_fingerprint_dialog(None);
     }
 
     pub fn set_port(&self, port: u16) {

lan-mouse-ipc/src/lib.rs

@@ -59,6 +59,7 @@ pub enum IpcError {
 pub const DEFAULT_PORT: u16 = 4242;
 
 #[derive(Debug, Default, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
 pub enum Position {
     #[default]
     Left,
@@ -201,10 +202,21 @@ pub enum FrontendEvent {
     AuthorizedUpdated(HashMap<String, String>),
     /// public key fingerprint of this device
     PublicKeyFingerprint(String),
-    /// incoming connected
-    IncomingConnected(String, SocketAddr, Position),
+    /// new device connected
+    DeviceConnected {
+        addr: SocketAddr,
+        fingerprint: String,
+    },
+    /// incoming device entered the screen
+    DeviceEntered {
+        fingerprint: String,
+        addr: SocketAddr,
+        pos: Position,
+    },
     /// incoming disconnected
     IncomingDisconnected(SocketAddr),
+    /// failed connection attempt (approval for fingerprint required)
+    ConnectionAttempt { fingerprint: String },
 }
 
 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]

src/capture_test.rs

@@ -4,13 +4,13 @@ use futures::StreamExt;
 use input_capture::{self, CaptureError, CaptureEvent, InputCapture, InputCaptureError, Position};
 use input_event::{Event, KeyboardEvent};
 
-#[derive(Args, Debug, Eq, PartialEq)]
+#[derive(Args, Clone, Debug, Eq, PartialEq)]
 pub struct TestCaptureArgs {}
 
 pub async fn run(config: Config, _args: TestCaptureArgs) -> Result<(), InputCaptureError> {
     log::info!("running input capture test");
     log::info!("creating input capture");
-    let backend = config.capture_backend.map(|b| b.into());
+    let backend = config.capture_backend().map(|b| b.into());
     loop {
         let mut input_capture = InputCapture::new(backend).await?;
         log::info!("creating clients");

src/config.rs

@@ -24,33 +24,50 @@ use shadow_rs::shadow;
 
 shadow!(build);
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct ConfigToml {
-    pub capture_backend: Option<CaptureBackend>,
-    pub emulation_backend: Option<EmulationBackend>,
-    pub port: Option<u16>,
-    pub frontend: Option<Frontend>,
-    pub release_bind: Option<Vec<scancode::Linux>>,
-    pub cert_path: Option<PathBuf>,
-    pub left: Option<TomlClient>,
-    pub right: Option<TomlClient>,
-    pub top: Option<TomlClient>,
-    pub bottom: Option<TomlClient>,
-    pub authorized_fingerprints: Option<HashMap<String, String>>,
+const CONFIG_FILE_NAME: &str = "config.toml";
+const CERT_FILE_NAME: &str = "lan-mouse.pem";
+
+fn default_path() -> Result<PathBuf, VarError> {
+    #[cfg(unix)]
+    let default_path = {
+        let xdg_config_home =
+            env::var("XDG_CONFIG_HOME").unwrap_or(format!("{}/.config", env::var("HOME")?));
+        format!("{xdg_config_home}/lan-mouse/")
+    };
+
+    #[cfg(not(unix))]
+    let default_path = {
+        let app_data =
+            env::var("LOCALAPPDATA").unwrap_or(format!("{}/.config", env::var("USERPROFILE")?));
+        format!("{app_data}\\lan-mouse\\")
+    };
+    Ok(PathBuf::from(default_path))
 }
 
-#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
-pub struct TomlClient {
-    pub hostname: Option<String>,
-    pub host_name: Option<String>,
-    pub ips: Option<Vec<IpAddr>>,
-    pub port: Option<u16>,
-    pub activate_on_startup: Option<bool>,
-    pub enter_hook: Option<String>,
+#[derive(Serialize, Deserialize, Debug)]
+struct ConfigToml {
+    capture_backend: Option<CaptureBackend>,
+    emulation_backend: Option<EmulationBackend>,
+    port: Option<u16>,
+    release_bind: Option<Vec<scancode::Linux>>,
+    cert_path: Option<PathBuf>,
+    clients: Option<Vec<TomlClient>>,
+    authorized_fingerprints: Option<HashMap<String, String>>,
+}
+
+#[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq)]
+struct TomlClient {
+    hostname: Option<String>,
+    host_name: Option<String>,
+    ips: Option<Vec<IpAddr>>,
+    port: Option<u16>,
+    position: Option<Position>,
+    activate_on_startup: Option<bool>,
+    enter_hook: Option<String>,
 }
 
 impl ConfigToml {
-    pub fn new(path: &Path) -> Result<ConfigToml, ConfigError> {
+    fn new(path: &Path) -> Result<ConfigToml, ConfigError> {
         let config = fs::read_to_string(path)?;
         Ok(toml::from_str::<_>(&config)?)
     }
@@ -58,36 +75,33 @@ impl ConfigToml {
 
 #[derive(Parser, Debug)]
 #[command(author, version=build::CLAP_LONG_VERSION, about, long_about = None)]
-pub struct Args {
+struct Args {
     /// the listen port for lan-mouse
     #[arg(short, long)]
     port: Option<u16>,
 
-    /// the frontend to use [cli | gtk]
-    #[arg(short, long)]
-    frontend: Option<Frontend>,
-
     /// non-default config file location
     #[arg(short, long)]
-    pub config: Option<PathBuf>,
-
-    #[command(subcommand)]
-    pub command: Option<Command>,
+    config: Option<PathBuf>,
 
     /// capture backend override
     #[arg(long)]
-    pub capture_backend: Option<CaptureBackend>,
+    capture_backend: Option<CaptureBackend>,
 
     /// emulation backend override
     #[arg(long)]
-    pub emulation_backend: Option<EmulationBackend>,
+    emulation_backend: Option<EmulationBackend>,
 
     /// path to non-default certificate location
     #[arg(long)]
-    pub cert_path: Option<PathBuf>,
+    cert_path: Option<PathBuf>,
+
+    /// subcommands
+    #[command(subcommand)]
+    command: Option<Command>,
 }
 
-#[derive(Subcommand, Debug, Eq, PartialEq)]
+#[derive(Subcommand, Clone, Debug, Eq, PartialEq)]
 pub enum Command {
     /// test input emulation
     TestEmulation(TestEmulationArgs),
@@ -220,48 +234,16 @@ impl Display for EmulationBackend {
     }
 }
 
-#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, Serialize, ValueEnum)]
-pub enum Frontend {
-    #[serde(rename = "gtk")]
-    Gtk,
-    #[serde(rename = "none")]
-    None,
-}
-
-impl Default for Frontend {
-    fn default() -> Self {
-        if cfg!(feature = "gtk") {
-            Self::Gtk
-        } else {
-            Self::None
-        }
-    }
-}
-
 #[derive(Debug)]
 pub struct Config {
-    /// the path to the configuration file used
-    pub path: PathBuf,
-    /// public key fingerprints authorized for connection
-    pub authorized_fingerprints: HashMap<String, String>,
-    /// optional input-capture backend override
-    pub capture_backend: Option<CaptureBackend>,
-    /// optional input-emulation backend override
-    pub emulation_backend: Option<EmulationBackend>,
-    /// the frontend to use
-    pub frontend: Frontend,
-    /// the port to use (initially)
-    pub port: u16,
-    /// list of clients
-    pub clients: Vec<(TomlClient, Position)>,
-    /// configured release bind
-    pub release_bind: Vec<scancode::Linux>,
-    /// test capture instead of running the app
-    pub test_capture: bool,
-    /// test emulation instead of running the app
-    pub test_emulation: bool,
-    /// path to the tls certificate to use
-    pub cert_path: PathBuf,
+    /// command line arguments
+    args: Args,
+    /// path to the certificate file used
+    cert_path: PathBuf,
+    /// path to the config file used
+    config_path: PathBuf,
+    /// the (optional) toml config and it's path
+    config_toml: Option<ConfigToml>,
 }
 
 pub struct ConfigClient {
@@ -273,6 +255,25 @@ pub struct ConfigClient {
     pub enter_hook: Option<String>,
 }
 
+impl From<TomlClient> for ConfigClient {
+    fn from(toml: TomlClient) -> Self {
+        let active = toml.activate_on_startup.unwrap_or(false);
+        let enter_hook = toml.enter_hook;
+        let hostname = toml.hostname;
+        let ips = HashSet::from_iter(toml.ips.into_iter().flatten());
+        let port = toml.port.unwrap_or(DEFAULT_PORT);
+        let pos = toml.position.unwrap_or_default();
+        Self {
+            ips,
+            hostname,
+            port,
+            pos,
+            active,
+            enter_hook,
+        }
+    }
+}
+
 #[derive(Debug, Error)]
 pub enum ConfigError {
     #[error(transparent)]
@@ -287,133 +288,100 @@ const DEFAULT_RELEASE_KEYS: [scancode::Linux; 4] =
     [KeyLeftCtrl, KeyLeftShift, KeyLeftMeta, KeyLeftAlt];
 
 impl Config {
-    pub fn new(args: &Args) -> Result<Self, ConfigError> {
-        const CONFIG_FILE_NAME: &str = "config.toml";
-        const CERT_FILE_NAME: &str = "lan-mouse.pem";
-
-        #[cfg(unix)]
-        let config_path = {
-            let xdg_config_home =
-                env::var("XDG_CONFIG_HOME").unwrap_or(format!("{}/.config", env::var("HOME")?));
-            format!("{xdg_config_home}/lan-mouse/")
-        };
-
-        #[cfg(not(unix))]
-        let config_path = {
-            let app_data =
-                env::var("LOCALAPPDATA").unwrap_or(format!("{}/.config", env::var("USERPROFILE")?));
-            format!("{app_data}\\lan-mouse\\")
-        };
-
-        let config_path = PathBuf::from(config_path);
-        let config_file = config_path.join(CONFIG_FILE_NAME);
+    pub fn new() -> Result<Self, ConfigError> {
+        let args = Args::parse();
 
         // --config <file> overrules default location
-        let config_file = args.config.clone().unwrap_or(config_file);
+        let config_path = args
+            .config
+            .clone()
+            .unwrap_or(default_path()?.join(CONFIG_FILE_NAME));
 
-        let mut config_toml = match ConfigToml::new(&config_file) {
+        let config_toml = match ConfigToml::new(&config_path) {
             Err(e) => {
-                log::warn!("{config_file:?}: {e}");
+                log::warn!("{config_path:?}: {e}");
                 log::warn!("Continuing without config file ...");
                 None
             }
             Ok(c) => Some(c),
         };
 
-        let frontend_arg = args.frontend;
-        let frontend_cfg = config_toml.as_ref().and_then(|c| c.frontend);
-        let frontend = frontend_arg.or(frontend_cfg).unwrap_or_default();
-
-        let port = args
-            .port
-            .or(config_toml.as_ref().and_then(|c| c.port))
-            .unwrap_or(DEFAULT_PORT);
-
-        log::debug!("{config_toml:?}");
-        let release_bind = config_toml
-            .as_ref()
-            .and_then(|c| c.release_bind.clone())
-            .unwrap_or(Vec::from_iter(DEFAULT_RELEASE_KEYS.iter().cloned()));
-
-        let capture_backend = args
-            .capture_backend
-            .or(config_toml.as_ref().and_then(|c| c.capture_backend));
-
-        let emulation_backend = args
-            .emulation_backend
-            .or(config_toml.as_ref().and_then(|c| c.emulation_backend));
-
+        // --cert-path <file> overrules default location
         let cert_path = args
             .cert_path
             .clone()
             .or(config_toml.as_ref().and_then(|c| c.cert_path.clone()))
-            .unwrap_or(config_path.join(CERT_FILE_NAME));
-
-        let authorized_fingerprints = config_toml
-            .as_mut()
-            .and_then(|c| std::mem::take(&mut c.authorized_fingerprints))
-            .unwrap_or_default();
-
-        let mut clients: Vec<(TomlClient, Position)> = vec![];
-
-        if let Some(config_toml) = config_toml {
-            if let Some(c) = config_toml.right {
-                clients.push((c, Position::Right))
-            }
-            if let Some(c) = config_toml.left {
-                clients.push((c, Position::Left))
-            }
-            if let Some(c) = config_toml.top {
-                clients.push((c, Position::Top))
-            }
-            if let Some(c) = config_toml.bottom {
-                clients.push((c, Position::Bottom))
-            }
-        }
-
-        let test_capture = matches!(args.command, Some(Command::TestCapture(_)));
-        let test_emulation = matches!(args.command, Some(Command::TestEmulation(_)));
+            .unwrap_or(default_path()?.join(CERT_FILE_NAME));
 
         Ok(Config {
-            path: config_path,
-            authorized_fingerprints,
-            capture_backend,
-            emulation_backend,
-            frontend,
-            clients,
-            port,
-            release_bind,
-            test_capture,
-            test_emulation,
+            args,
             cert_path,
+            config_path,
+            config_toml,
         })
     }
 
-    pub fn get_clients(&self) -> Vec<ConfigClient> {
-        self.clients
-            .iter()
-            .map(|(c, pos)| {
-                let port = c.port.unwrap_or(DEFAULT_PORT);
-                let ips: HashSet<IpAddr> = if let Some(ips) = c.ips.as_ref() {
-                    HashSet::from_iter(ips.iter().cloned())
-                } else {
-                    HashSet::new()
-                };
-                let hostname = match &c.hostname {
-                    Some(h) => Some(h.clone()),
-                    None => c.host_name.clone(),
-                };
-                let active = c.activate_on_startup.unwrap_or(false);
-                let enter_hook = c.enter_hook.clone();
-                ConfigClient {
-                    ips,
-                    hostname,
-                    port,
-                    pos: *pos,
-                    active,
-                    enter_hook,
-                }
-            })
+    /// the command to run
+    pub fn command(&self) -> Option<Command> {
+        self.args.command.clone()
+    }
+
+    pub fn config_path(&self) -> &Path {
+        &self.config_path
+    }
+
+    /// public key fingerprints authorized for connection
+    pub fn authorized_fingerprints(&self) -> HashMap<String, String> {
+        self.config_toml
+            .as_ref()
+            .and_then(|c| c.authorized_fingerprints.clone())
+            .unwrap_or_default()
+    }
+
+    /// path to certificate
+    pub fn cert_path(&self) -> &Path {
+        &self.cert_path
+    }
+
+    /// optional input-capture backend override
+    pub fn capture_backend(&self) -> Option<CaptureBackend> {
+        self.args
+            .capture_backend
+            .or(self.config_toml.as_ref().and_then(|c| c.capture_backend))
+    }
+
+    /// optional input-emulation backend override
+    pub fn emulation_backend(&self) -> Option<EmulationBackend> {
+        self.args
+            .emulation_backend
+            .or(self.config_toml.as_ref().and_then(|c| c.emulation_backend))
+    }
+
+    /// the port to use (initially)
+    pub fn port(&self) -> u16 {
+        self.args
+            .port
+            .or(self.config_toml.as_ref().and_then(|c| c.port))
+            .unwrap_or(DEFAULT_PORT)
+    }
+
+    /// list of configured clients
+    pub fn clients(&self) -> Vec<ConfigClient> {
+        self.config_toml
+            .as_ref()
+            .map(|c| c.clients.clone())
+            .unwrap_or_default()
+            .into_iter()
+            .flatten()
+            .map(From::<TomlClient>::from)
             .collect()
     }
+
+    /// release bind for returning control to the host
+    pub fn release_bind(&self) -> Vec<scancode::Linux> {
+        self.config_toml
+            .as_ref()
+            .and_then(|c| c.release_bind.clone())
+            .unwrap_or(Vec::from_iter(DEFAULT_RELEASE_KEYS.iter().cloned()))
+    }
 }

src/emulation.rs

@@ -1,4 +1,4 @@
-use crate::listen::{LanMouseListener, ListenerCreationError};
+use crate::listen::{LanMouseListener, ListenEvent, ListenerCreationError};
 use futures::StreamExt;
 use input_emulation::{EmulationHandle, InputEmulation, InputEmulationError};
 use input_event::Event;
@@ -24,8 +24,15 @@ pub(crate) struct Emulation {
 }
 
 pub(crate) enum EmulationEvent {
-    /// new connection
     Connected {
+        addr: SocketAddr,
+        fingerprint: String,
+    },
+    ConnectionAttempt {
+        fingerprint: String,
+    },
+    /// new connection
+    Entered {
         /// address of the connection
         addr: SocketAddr,
         /// position of the connection
@@ -34,7 +41,9 @@ pub(crate) enum EmulationEvent {
         fingerprint: String,
     },
     /// connection closed
-    Disconnected { addr: SocketAddr },
+    Disconnected {
+        addr: SocketAddr,
+    },
     /// the port of the listener has changed
     PortChanged(Result<u16, ListenerCreationError>),
     /// emulation was disabled
@@ -121,31 +130,36 @@ impl ListenTask {
         let mut last_response = HashMap::new();
         loop {
             select! {
-                e = self.listener.next() =>  {
-                    let (event, addr) = match e {
-                        Some(e) => e,
-                        None => break,
-                    };
-                    log::trace!("{event} <-<-<-<-<- {addr}");
-                    last_response.insert(addr, Instant::now());
-                    match event {
-                        ProtoEvent::Enter(pos) => {
-                            if let Some(fingerprint) = self.listener.get_certificate_fingerprint(addr).await {
-                                log::info!("releasing capture: {addr} entered this device");
-                                self.event_tx.send(EmulationEvent::ReleaseNotify).expect("channel closed");
-                                self.listener.reply(addr, ProtoEvent::Ack(0)).await;
-                                self.event_tx.send(EmulationEvent::Connected{addr, pos: to_ipc_pos(pos), fingerprint}).expect("channel closed");
+                e = self.listener.next() => {match e {
+                    Some(ListenEvent::Msg { event, addr }) => {
+                        log::trace!("{event} <-<-<-<-<- {addr}");
+                        last_response.insert(addr, Instant::now());
+                        match event {
+                            ProtoEvent::Enter(pos) => {
+                                if let Some(fingerprint) = self.listener.get_certificate_fingerprint(addr).await {
+                                    log::info!("releasing capture: {addr} entered this device");
+                                    self.event_tx.send(EmulationEvent::ReleaseNotify).expect("channel closed");
+                                    self.listener.reply(addr, ProtoEvent::Ack(0)).await;
+                                    self.event_tx.send(EmulationEvent::Entered{addr, pos: to_ipc_pos(pos), fingerprint}).expect("channel closed");
+                                }
                             }
+                            ProtoEvent::Leave(_) => {
+                                self.emulation_proxy.remove(addr);
+                                self.listener.reply(addr, ProtoEvent::Ack(0)).await;
+                            }
+                            ProtoEvent::Input(event) => self.emulation_proxy.consume(event, addr),
+                            ProtoEvent::Ping => self.listener.reply(addr, ProtoEvent::Pong(self.emulation_proxy.emulation_active.get())).await,
+                            _ => {}
                         }
-                        ProtoEvent::Leave(_) => {
-                            self.emulation_proxy.remove(addr);
-                            self.listener.reply(addr, ProtoEvent::Ack(0)).await;
-                        }
-                        ProtoEvent::Input(event) => self.emulation_proxy.consume(event, addr),
-                        ProtoEvent::Ping => self.listener.reply(addr, ProtoEvent::Pong(self.emulation_proxy.emulation_active.get())).await,
-                        _ => {}
                     }
-                }
+                    Some(ListenEvent::Accept { addr, fingerprint }) => {
+                        self.event_tx.send(EmulationEvent::Connected { addr, fingerprint }).expect("channel closed");
+                    }
+                    Some(ListenEvent::Rejected { fingerprint }) => {
+                        self.event_tx.send(EmulationEvent::ConnectionAttempt { fingerprint }).expect("channel closed");
+                    }
+                    None => break
+                }}
                 event = self.emulation_proxy.event() => {
                     self.event_tx.send(event).expect("channel closed");
                 }

src/emulation_test.rs

@@ -8,7 +8,7 @@ use std::time::{Duration, Instant};
 const FREQUENCY_HZ: f64 = 1.0;
 const RADIUS: f64 = 100.0;
 
-#[derive(Args, Debug, Eq, PartialEq)]
+#[derive(Args, Clone, Debug, Eq, PartialEq)]
 pub struct TestEmulationArgs {
     #[arg(long)]
     mouse: bool,
@@ -21,7 +21,7 @@ pub struct TestEmulationArgs {
 pub async fn run(config: Config, _args: TestEmulationArgs) -> Result<(), InputEmulationError> {
     log::info!("running input emulation test");
 
-    let backend = config.emulation_backend.map(|b| b.into());
+    let backend = config.emulation_backend().map(|b| b.into());
     let mut emulation = InputEmulation::new(backend).await?;
     emulation.create(0).await;
 

src/listen.rs

@@ -3,15 +3,15 @@ use lan_mouse_proto::{ProtoEvent, MAX_EVENT_SIZE};
 use local_channel::mpsc::{channel, Receiver, Sender};
 use rustls::pki_types::CertificateDer;
 use std::{
-    collections::HashMap,
+    collections::{HashMap, VecDeque},
     net::SocketAddr,
     rc::Rc,
-    sync::{Arc, RwLock},
+    sync::{Arc, Mutex, RwLock},
     time::Duration,
 };
 use thiserror::Error;
 use tokio::{
-    sync::Mutex,
+    sync::Mutex as AsyncMutex,
     task::{spawn_local, JoinHandle},
 };
 use webrtc_dtls::{
@@ -34,11 +34,25 @@ pub enum ListenerCreationError {
 
 type ArcConn = Arc<dyn Conn + Send + Sync>;
 
+pub(crate) enum ListenEvent {
+    Msg {
+        event: ProtoEvent,
+        addr: SocketAddr,
+    },
+    Accept {
+        addr: SocketAddr,
+        fingerprint: String,
+    },
+    Rejected {
+        fingerprint: String,
+    },
+}
+
 pub(crate) struct LanMouseListener {
-    listen_rx: Receiver<(ProtoEvent, SocketAddr)>,
-    listen_tx: Sender<(ProtoEvent, SocketAddr)>,
+    listen_rx: Receiver<ListenEvent>,
+    listen_tx: Sender<ListenEvent>,
     listen_task: JoinHandle<()>,
-    conns: Rc<Mutex<Vec<(SocketAddr, ArcConn)>>>,
+    conns: Rc<AsyncMutex<Vec<(SocketAddr, ArcConn)>>>,
     request_port_change: Sender<u16>,
     port_changed: Receiver<Result<u16, ListenerCreationError>>,
 }
@@ -58,26 +72,35 @@ impl LanMouseListener {
         let (listen_tx, listen_rx) = channel();
         let (request_port_change, mut request_port_change_rx) = channel();
         let (port_changed_tx, port_changed) = channel();
+        let connection_attempts: Arc<Mutex<VecDeque<String>>> = Default::default();
 
         let authorized = authorized_keys.clone();
-        let verify_peer_certificate: Option<VerifyPeerCertificateFn> = Some(Arc::new(
-            move |certs: &[Vec<u8>], _chains: &[CertificateDer<'static>]| {
-                assert!(certs.len() == 1);
-                let fingerprints = certs
-                    .iter()
-                    .map(|c| crypto::generate_fingerprint(c))
-                    .collect::<Vec<_>>();
-                if authorized
-                    .read()
-                    .expect("lock")
-                    .contains_key(&fingerprints[0])
-                {
-                    Ok(())
-                } else {
-                    Err(webrtc_dtls::Error::ErrVerifyDataMismatch)
-                }
-            },
-        ));
+        let verify_peer_certificate: Option<VerifyPeerCertificateFn> = {
+            let connection_attempts = connection_attempts.clone();
+            Some(Arc::new(
+                move |certs: &[Vec<u8>], _chains: &[CertificateDer<'static>]| {
+                    assert!(certs.len() == 1);
+                    let fingerprints = certs
+                        .iter()
+                        .map(|c| crypto::generate_fingerprint(c))
+                        .collect::<Vec<_>>();
+                    if authorized
+                        .read()
+                        .expect("lock")
+                        .contains_key(&fingerprints[0])
+                    {
+                        Ok(())
+                    } else {
+                        let fingerprint = fingerprints.into_iter().next().expect("fingerprint");
+                        connection_attempts
+                            .lock()
+                            .expect("lock")
+                            .push_back(fingerprint);
+                        Err(webrtc_dtls::Error::ErrVerifyDataMismatch)
+                    }
+                },
+            ))
+        };
         let cfg = Config {
             certificates: vec![cert.clone()],
             extended_master_secret: ExtendedMasterSecretType::Require,
@@ -89,43 +112,69 @@ impl LanMouseListener {
         let listen_addr = SocketAddr::new("0.0.0.0".parse().expect("invalid ip"), port);
         let mut listener = listen(listen_addr, cfg.clone()).await?;
 
-        let conns: Rc<Mutex<Vec<(SocketAddr, ArcConn)>>> = Rc::new(Mutex::new(Vec::new()));
+        let conns: Rc<AsyncMutex<Vec<(SocketAddr, ArcConn)>>> =
+            Rc::new(AsyncMutex::new(Vec::new()));
 
         let conns_clone = conns.clone();
-        let tx = listen_tx.clone();
-        let listen_task: JoinHandle<()> = spawn_local(async move {
-            loop {
-                let sleep = tokio::time::sleep(Duration::from_secs(2));
-                tokio::select! {
-                    /* workaround for https://github.com/webrtc-rs/webrtc/issues/614 */
-                    _ = sleep => continue,
-                    c = listener.accept() => match c {
-                        Ok((conn, addr)) => {
-                            log::info!("dtls client connected, ip: {addr}");
-                            let mut conns = conns_clone.lock().await;
-                            conns.push((addr, conn.clone()));
-                            spawn_local(read_loop(conns_clone.clone(), addr, conn, tx.clone()));
-                        },
-                        Err(e) => log::warn!("accept: {e}"),
-                    },
-                    port = request_port_change_rx.recv() => {
-                        let port = port.expect("channel closed");
-                        let listen_addr = SocketAddr::new("0.0.0.0".parse().expect("invalid ip"), port);
-                        match listen(listen_addr, cfg.clone()).await {
-                            Ok(new_listener) => {
-                                let _ = listener.close().await;
-                                listener = new_listener;
-                                port_changed_tx.send(Ok(port)).expect("channel closed");
-                            }
+        let listen_task: JoinHandle<()> = {
+            let listen_tx = listen_tx.clone();
+            let connection_attempts = connection_attempts.clone();
+            spawn_local(async move {
+                loop {
+                    let sleep = tokio::time::sleep(Duration::from_secs(2));
+                    tokio::select! {
+                        /* workaround for https://github.com/webrtc-rs/webrtc/issues/614 */
+                        _ = sleep => continue,
+                        c = listener.accept() => match c {
+                            Ok((conn, addr)) => {
+                                log::info!("dtls client connected, ip: {addr}");
+                                let mut conns = conns_clone.lock().await;
+                                conns.push((addr, conn.clone()));
+                                let dtls_conn: &DTLSConn = conn.as_any().downcast_ref().expect("dtls conn");
+                                let certs = dtls_conn.connection_state().await.peer_certificates;
+                                let cert = certs.first().expect("cert");
+                                let fingerprint = crypto::generate_fingerprint(cert);
+                                listen_tx.send(ListenEvent::Accept { addr, fingerprint }).expect("channel closed");
+                                spawn_local(read_loop(conns_clone.clone(), addr, conn, listen_tx.clone()));
+                            },
                             Err(e) => {
-                                log::warn!("unable to change port: {e}");
-                                port_changed_tx.send(Err(e.into())).expect("channel closed");
+                                if let Error::Std(ref e) = e {
+                                    if let Some(e) = e.0.downcast_ref::<webrtc_dtls::Error>() {
+                                        match e {
+                                            webrtc_dtls::Error::ErrVerifyDataMismatch => {
+                                                if let Some(fingerprint) = connection_attempts.lock().expect("lock").pop_front() {
+                                                    listen_tx.send(ListenEvent::Rejected { fingerprint }).expect("channel closed");
+                                                }
+                                            }
+                                            _ => log::warn!("accept: {e}"),
+                                        }
+                                    } else {
+                                        log::warn!("accept: {e:?}");
+                                    }
+                                } else {
+                                    log::warn!("accept: {e:?}");
+                                }
                             }
-                        };
-                    },
-                };
-            }
-        });
+                        },
+                        port = request_port_change_rx.recv() => {
+                            let port = port.expect("channel closed");
+                            let listen_addr = SocketAddr::new("0.0.0.0".parse().expect("invalid ip"), port);
+                            match listen(listen_addr, cfg.clone()).await {
+                                Ok(new_listener) => {
+                                    let _ = listener.close().await;
+                                    listener = new_listener;
+                                    port_changed_tx.send(Ok(port)).expect("channel closed");
+                                }
+                                Err(e) => {
+                                    log::warn!("unable to change port: {e}");
+                                    port_changed_tx.send(Err(e.into())).expect("channel closed");
+                                }
+                            };
+                        },
+                    };
+                }
+            })
+        };
 
         Ok(Self {
             conns,
@@ -186,7 +235,7 @@ impl LanMouseListener {
 }
 
 impl Stream for LanMouseListener {
-    type Item = (ProtoEvent, SocketAddr);
+    type Item = ListenEvent;
 
     fn poll_next(
         mut self: std::pin::Pin<&mut Self>,
@@ -197,16 +246,18 @@ impl Stream for LanMouseListener {
 }
 
 async fn read_loop(
-    conns: Rc<Mutex<Vec<(SocketAddr, ArcConn)>>>,
+    conns: Rc<AsyncMutex<Vec<(SocketAddr, ArcConn)>>>,
     addr: SocketAddr,
     conn: ArcConn,
-    dtls_tx: Sender<(ProtoEvent, SocketAddr)>,
+    dtls_tx: Sender<ListenEvent>,
 ) -> Result<(), Error> {
     let mut b = [0u8; MAX_EVENT_SIZE];
 
     while conn.recv(&mut b).await.is_ok() {
         match b.try_into() {
-            Ok(event) => dtls_tx.send((event, addr)).expect("channel closed"),
+            Ok(event) => dtls_tx
+                .send(ListenEvent::Msg { event, addr })
+                .expect("channel closed"),
             Err(e) => {
                 log::warn!("error receiving event: {e}");
                 break;

src/main.rs

@@ -1,19 +1,20 @@
-use clap::Parser;
 use env_logger::Env;
 use input_capture::InputCaptureError;
 use input_emulation::InputEmulationError;
 use lan_mouse::{
     capture_test,
-    config::{self, Config, ConfigError, Frontend},
+    config::{self, Command, Config, ConfigError},
     emulation_test,
     service::{Service, ServiceError},
 };
 use lan_mouse_cli::CliError;
+#[cfg(feature = "gtk")]
+use lan_mouse_gtk::GtkError;
 use lan_mouse_ipc::{IpcError, IpcListenerCreationError};
 use std::{
     future::Future,
     io,
-    process::{self, Child, Command},
+    process::{self, Child},
 };
 use thiserror::Error;
 use tokio::task::LocalSet;
@@ -32,6 +33,9 @@ enum LanMouseError {
     Capture(#[from] InputCaptureError),
     #[error(transparent)]
     Emulation(#[from] InputEmulationError),
+    #[cfg(feature = "gtk")]
+    #[error(transparent)]
+    Gtk(#[from] GtkError),
     #[error(transparent)]
     Cli(#[from] CliError),
 }
@@ -48,15 +52,13 @@ fn main() {
 }
 
 fn run() -> Result<(), LanMouseError> {
-    // parse config file + cli args
-    let args = config::Args::parse();
-    let config = config::Config::new(&args)?;
-    match args.command {
+    let config = config::Config::new()?;
+    match config.command() {
         Some(command) => match command {
-            config::Command::TestEmulation(args) => run_async(emulation_test::run(config, args))?,
-            config::Command::TestCapture(args) => run_async(capture_test::run(config, args))?,
-            config::Command::Cli(cli_args) => run_async(lan_mouse_cli::run(cli_args))?,
-            config::Command::Daemon => {
+            Command::TestEmulation(args) => run_async(emulation_test::run(config, args))?,
+            Command::TestCapture(args) => run_async(capture_test::run(config, args))?,
+            Command::Cli(cli_args) => run_async(lan_mouse_cli::run(cli_args))?,
+            Command::Daemon => {
                 // if daemon is specified we run the service
                 match run_async(run_service(config)) {
                     Err(LanMouseError::Service(ServiceError::IpcListen(
@@ -69,18 +71,32 @@ fn run() -> Result<(), LanMouseError> {
         None => {
             //  otherwise start the service as a child process and
             //  run a frontend
-            let mut service = start_service()?;
-            run_frontend(&config)?;
-            #[cfg(unix)]
+            #[cfg(feature = "gtk")]
             {
-                // on unix we give the service a chance to terminate gracefully
-                let pid = service.id() as libc::pid_t;
-                unsafe {
-                    libc::kill(pid, libc::SIGINT);
+                let mut service = start_service()?;
+                let res = lan_mouse_gtk::run();
+                #[cfg(unix)]
+                {
+                    // on unix we give the service a chance to terminate gracefully
+                    let pid = service.id() as libc::pid_t;
+                    unsafe {
+                        libc::kill(pid, libc::SIGINT);
+                    }
+                    service.wait()?;
+                }
+                service.kill()?;
+                res?;
+            }
+            #[cfg(not(feature = "gtk"))]
+            {
+                // run daemon if gtk is diabled
+                match run_async(run_service(config)) {
+                    Err(LanMouseError::Service(ServiceError::IpcListen(
+                        IpcListenerCreationError::AlreadyRunning,
+                    ))) => log::info!("service already running!"),
+                    r => r?,
                 }
-                service.wait()?;
             }
-            service.kill()?;
         }
     }
 
@@ -103,7 +119,7 @@ where
 }
 
 fn start_service() -> Result<Child, io::Error> {
-    let child = Command::new(std::env::current_exe()?)
+    let child = process::Command::new(std::env::current_exe()?)
         .args(std::env::args().skip(1))
         .arg("daemon")
         .spawn()?;
@@ -111,25 +127,12 @@ fn start_service() -> Result<Child, io::Error> {
 }
 
 async fn run_service(config: Config) -> Result<(), ServiceError> {
-    log::info!("using config: {:?}", config.path);
-    log::info!("Press {:?} to release the mouse", config.release_bind);
+    let release_bind = config.release_bind();
+    let config_path = config.config_path().to_owned();
     let mut service = Service::new(config).await?;
+    log::info!("using config: {config_path:?}");
+    log::info!("Press {release_bind:?} to release the mouse");
     service.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::None => {
-            log::warn!("no frontend available!");
-        }
-    };
-    Ok(())
-}

src/service.rs

@@ -80,7 +80,7 @@ struct Incoming {
 impl Service {
     pub async fn new(config: Config) -> Result<Self, ServiceError> {
         let client_manager = ClientManager::default();
-        for client in config.get_clients() {
+        for client in config.clients() {
             let config = ClientConfig {
                 hostname: client.hostname,
                 fix_ips: client.ips.into_iter().collect(),
@@ -99,28 +99,28 @@ impl Service {
         }
 
         // load certificate
-        let cert = crypto::load_or_generate_key_and_cert(&config.cert_path)?;
+        let cert = crypto::load_or_generate_key_and_cert(config.cert_path())?;
         let public_key_fingerprint = crypto::certificate_fingerprint(&cert);
 
         // create frontend communication adapter, exit if already running
         let frontend_listener = AsyncFrontendListener::new().await?;
 
-        let authorized_keys = Arc::new(RwLock::new(config.authorized_fingerprints.clone()));
+        let authorized_keys = Arc::new(RwLock::new(config.authorized_fingerprints()));
         // listener + connection
         let listener =
-            LanMouseListener::new(config.port, cert.clone(), authorized_keys.clone()).await?;
+            LanMouseListener::new(config.port(), cert.clone(), authorized_keys.clone()).await?;
         let conn = LanMouseConnection::new(cert.clone(), client_manager.clone());
 
         // input capture + emulation
-        let capture_backend = config.capture_backend.map(|b| b.into());
-        let capture = Capture::new(capture_backend, conn, config.release_bind.clone());
-        let emulation_backend = config.emulation_backend.map(|b| b.into());
+        let capture_backend = config.capture_backend().map(|b| b.into());
+        let capture = Capture::new(capture_backend, conn, config.release_bind());
+        let emulation_backend = config.emulation_backend().map(|b| b.into());
         let emulation = Emulation::new(emulation_backend, listener);
 
         // create dns resolver
         let resolver = DnsResolver::new()?;
 
-        let port = config.port;
+        let port = config.port();
         let service = Self {
             capture,
             emulation,
@@ -142,11 +142,15 @@ impl Service {
     }
 
     pub async fn run(&mut self) -> Result<(), ServiceError> {
-        for handle in self.client_manager.active_clients() {
+        let active = self.client_manager.active_clients();
+        for handle in active.iter() {
             // small hack: `activate_client()` checks, if the client
             // is already active in client_manager and does not create a
             // capture barrier in that case so we have to deactivate it first
-            self.client_manager.deactivate_client(handle);
+            self.client_manager.deactivate_client(*handle);
+        }
+
+        for handle in active {
             self.activate_client(handle);
         }
 
@@ -207,7 +211,10 @@ impl Service {
 
     fn handle_emulation_event(&mut self, event: EmulationEvent) {
         match event {
-            EmulationEvent::Connected {
+            EmulationEvent::ConnectionAttempt { fingerprint } => {
+                self.notify_frontend(FrontendEvent::ConnectionAttempt { fingerprint });
+            }
+            EmulationEvent::Entered {
                 addr,
                 pos,
                 fingerprint,
@@ -215,7 +222,11 @@ impl Service {
                 // check if already registered
                 if !self.incoming_conns.contains(&addr) {
                     self.add_incoming(addr, pos, fingerprint.clone());
-                    self.notify_frontend(FrontendEvent::IncomingConnected(fingerprint, addr, pos));
+                    self.notify_frontend(FrontendEvent::DeviceEntered {
+                        fingerprint,
+                        addr,
+                        pos,
+                    });
                 } else {
                     self.update_incoming(addr, pos, fingerprint);
                 }
@@ -242,6 +253,9 @@ impl Service {
                 self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status));
             }
             EmulationEvent::ReleaseNotify => self.capture.release(),
+            EmulationEvent::Connected { addr, fingerprint } => {
+                self.notify_frontend(FrontendEvent::DeviceConnected { addr, fingerprint });
+            }
         }
     }
 
@@ -343,7 +357,11 @@ impl Service {
             self.remove_incoming(addr);
             self.add_incoming(addr, pos, fingerprint.clone());
             self.notify_frontend(FrontendEvent::IncomingDisconnected(addr));
-            self.notify_frontend(FrontendEvent::IncomingConnected(fingerprint, addr, pos));
+            self.notify_frontend(FrontendEvent::DeviceEntered {
+                fingerprint,
+                addr,
+                pos,
+            });
         }
     }