fix ashpd?!

closes #294

Cargo.toml

@@ -24,7 +24,7 @@ strip = true
 panic = "abort"
 
 [build-dependencies]
-shadow-rs = "0.38.0"
+shadow-rs = "1.2.0"
 
 [dependencies]
 input-event = { path = "input-event", version = "0.3.0" }
@@ -34,9 +34,9 @@ lan-mouse-cli = { path = "lan-mouse-cli", version = "0.2.0" }
 lan-mouse-gtk = { path = "lan-mouse-gtk", version = "0.2.0", optional = true }
 lan-mouse-ipc = { path = "lan-mouse-ipc", version = "0.2.0" }
 lan-mouse-proto = { path = "lan-mouse-proto", version = "0.2.0" }
-shadow-rs = { version = "0.38.0", features = ["metadata"] }
+shadow-rs = { version = "1.2.0", features = ["metadata"] }
 
-hickory-resolver = "0.24.1"
+hickory-resolver = "0.25.2"
 toml = "0.8"
 serde = { version = "1.0", features = ["derive"] }
 log = "0.4.20"
@@ -58,8 +58,8 @@ slab = "0.4.9"
 thiserror = "2.0.0"
 tokio-util = "0.7.11"
 local-channel = "0.1.5"
-webrtc-dtls = { version = "0.10.0", features = ["pem"] }
-webrtc-util = "0.9.0"
+webrtc-dtls = { version = "0.12.0", features = ["pem"] }
+webrtc-util = "0.11.0"
 rustls = { version = "0.23.12", default-features = false, features = [
     "std",
     "ring",

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1740560979,
-        "narHash": "sha256-Vr3Qi346M+8CjedtbyUevIGDZW8LcA1fTG0ugPY/Hic=",
+        "lastModified": 1752687322,
+        "narHash": "sha256-RKwfXA4OZROjBTQAl9WOZQFm7L8Bo93FQwSJpAiSRvo=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "5135c59491985879812717f4c9fea69604e7f26f",
+        "rev": "6e987485eb2c77e5dcc5af4e3c70843711ef9251",
         "type": "github"
       },
       "original": {
@@ -29,11 +29,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1740623427,
-        "narHash": "sha256-3SdPQrZoa4odlScFDUHd4CUPQ/R1gtH4Mq9u8CBiK8M=",
+        "lastModified": 1752806774,
+        "narHash": "sha256-4cHeoR2roN7d/3J6gT+l6o7J2hTrBIUiCwVdDNMeXzE=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "d342e8b5fd88421ff982f383c853f0fc78a847ab",
+        "rev": "3c90219b3ba1c9790c45a078eae121de48a39c55",
         "type": "github"
       },
       "original": {

input-capture/Cargo.toml

@@ -40,21 +40,21 @@ wayland-protocols-wlr = { version = "0.3.1", features = [
     "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.10", default-features = false, features = [
+ashpd = { version = "0.11.0", default-features = false, features = [
     "tokio",
 ], optional = true }
-reis = { version = "0.4", features = ["tokio"], optional = true }
+reis = { version = "0.5.0", features = ["tokio"], optional = true }
 
 [target.'cfg(target_os="macos")'.dependencies]
-core-graphics = { version = "0.24.0", features = ["highsierra"] }
+core-graphics = { version = "0.25.0", features = ["highsierra"] }
 core-foundation = "0.10.0"
 core-foundation-sys = "0.8.6"
 libc = "0.2.155"
-keycode = "0.4.0"
+keycode = "1.0.0"
 bitflags = "2.6.0"
 
 [target.'cfg(windows)'.dependencies]
-windows = { version = "0.58.0", features = [
+windows = { version = "0.61.2", features = [
     "Win32_System_LibraryLoader",
     "Win32_System_Threading",
     "Win32_Foundation",

input-capture/src/layer_shell.rs

@@ -535,7 +535,7 @@ impl State {
     fn update_windows(&mut self) {
         log::info!("active outputs: ");
         for output in self.outputs.iter().filter(|o| o.info.is_some()) {
-            log::info!(" * {}", output);
+            log::info!(" * {output}");
         }
 
         self.active_windows.clear();
@@ -582,17 +582,17 @@ impl Inner {
         match self.queue.dispatch_pending(&mut self.state) {
             Ok(_) => {}
             Err(DispatchError::Backend(WaylandError::Io(e))) => {
-                log::error!("Wayland Error: {}", e);
+                log::error!("Wayland Error: {e}");
             }
             Err(DispatchError::Backend(e)) => {
-                panic!("backend error: {}", e);
+                panic!("backend error: {e}");
             }
             Err(DispatchError::BadMessage {
                 sender_id,
                 interface,
                 opcode,
             }) => {
-                panic!("bad message {}, {} , {}", sender_id, interface, opcode);
+                panic!("bad message {sender_id}, {interface} , {opcode}");
             }
         }
     }
@@ -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
@@ -974,7 +974,7 @@ impl Dispatch<ZxdgOutputV1, u32> for State {
             .find(|o| o.global.name == *name)
             .expect("output");
 
-        log::debug!("xdg_output {name} - {:?}", event);
+        log::debug!("xdg_output {name} - {event:?}");
         match event {
             zxdg_output_v1::Event::LogicalPosition { x, y } => {
                 output.pending_info.position = (x, y);
@@ -1010,7 +1010,7 @@ impl Dispatch<WlOutput, u32> for State {
         _conn: &Connection,
         _qhandle: &QueueHandle<Self>,
     ) {
-        log::debug!("wl_output {name} - {:?}", event);
+        log::debug!("wl_output {name} - {event:?}");
         if let wl_output::Event::Done = event {
             state.update_output_info(*name);
         }

input-capture/src/lib.rs

@@ -79,7 +79,7 @@ impl Display for Position {
             Position::Top => "top",
             Position::Bottom => "bottom",
         };
-        write!(f, "{}", pos)
+        write!(f, "{pos}")
     }
 }
 

input-capture/src/libei.rs

@@ -587,9 +587,13 @@ impl LanMouseInputCapture for LibeiInputCapture<'_> {
         self.cancellation_token.cancel();
         let task = &mut self.capture_task;
         log::debug!("waiting for capture to terminate...");
-        let res = task.await.expect("libei task panic");
-        log::debug!("done!");
+        let res = if !task.is_finished() {
+            task.await.expect("libei task panic")
+        } else {
+            Ok(())
+        };
         self.terminated = true;
+        log::debug!("done!");
         res
     }
 }

input-capture/src/macos.rs

@@ -10,7 +10,7 @@ use core_graphics::base::{kCGErrorSuccess, CGError};
 use core_graphics::display::{CGDisplay, CGPoint};
 use core_graphics::event::{
     CGEvent, CGEventFlags, CGEventTap, CGEventTapLocation, CGEventTapOptions, CGEventTapPlacement,
-    CGEventTapProxy, CGEventType, EventField,
+    CGEventTapProxy, CGEventType, CallbackResult, EventField,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
 use futures_core::Stream;
@@ -390,15 +390,15 @@ 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
+                // Returning Drop should stop the event from being processed
                 // but core fundation still returns the event
                 cg_ev.set_type(CGEventType::Null);
             }
-            Some(cg_ev.to_owned())
+            CallbackResult::Replace(cg_ev.to_owned())
         };
 
     let tap = CGEventTap::new(
@@ -411,7 +411,7 @@ fn create_event_tap<'a>(
     .map_err(|_| MacosCaptureCreationError::EventTapCreation)?;
 
     let tap_source: CFRunLoopSource = tap
-        .mach_port
+        .mach_port()
         .create_runloop_source(0)
         .expect("Failed creating loop source");
 
@@ -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

@@ -9,7 +9,7 @@ use std::thread;
 use tokio::sync::mpsc::error::TrySendError;
 use tokio::sync::mpsc::Sender;
 use windows::core::{w, PCWSTR};
-use windows::Win32::Foundation::{FALSE, HINSTANCE, HWND, LPARAM, LRESULT, RECT, WPARAM};
+use windows::Win32::Foundation::{FALSE, HWND, LPARAM, LRESULT, RECT, WPARAM};
 use windows::Win32::Graphics::Gdi::{
     EnumDisplayDevicesW, EnumDisplaySettingsW, DEVMODEW, DISPLAY_DEVICEW,
     DISPLAY_DEVICE_ATTACHED_TO_DESKTOP, ENUM_CURRENT_SETTINGS,
@@ -19,10 +19,10 @@ use windows::Win32::System::Threading::GetCurrentThreadId;
 
 use windows::Win32::UI::WindowsAndMessaging::{
     CallNextHookEx, CreateWindowExW, DispatchMessageW, GetMessageW, PostThreadMessageW,
-    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,
+    RegisterClassW, SetWindowsHookExW, TranslateMessage, EDD_GET_DEVICE_INTERFACE_NAME, 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_MOUSEHWHEEL, WM_MOUSEMOVE, WM_MOUSEWHEEL, WM_RBUTTONDOWN,
     WM_RBUTTONUP, WM_SYSKEYDOWN, WM_SYSKEYUP, WM_USER, WM_XBUTTONDOWN, WM_XBUTTONUP, WNDCLASSW,
     WNDPROC,
 };
@@ -128,7 +128,7 @@ thread_local! {
 fn get_msg() -> Option<MSG> {
     unsafe {
         let mut msg = std::mem::zeroed();
-        let ret = GetMessageW(addr_of_mut!(msg), HWND::default(), 0, 0);
+        let ret = GetMessageW(addr_of_mut!(msg), None, 0, 0);
         match ret.0 {
             0 => None,
             x if x > 0 => Some(msg),
@@ -176,14 +176,15 @@ fn start_routine(
 
     /* register hooks */
     unsafe {
-        let _ = SetWindowsHookExW(WH_MOUSE_LL, mouse_proc, HINSTANCE::default(), 0).unwrap();
-        let _ = SetWindowsHookExW(WH_KEYBOARD_LL, kybrd_proc, HINSTANCE::default(), 0).unwrap();
+        let _ = SetWindowsHookExW(WH_MOUSE_LL, mouse_proc, None, 0).unwrap();
+        let _ = SetWindowsHookExW(WH_KEYBOARD_LL, kybrd_proc, None, 0).unwrap();
     }
 
     let instance = unsafe { GetModuleHandleW(None).unwrap() };
+    let instance = instance.into();
     let window_class: WNDCLASSW = WNDCLASSW {
         lpfnWndProc: window_proc,
-        hInstance: instance.into(),
+        hInstance: instance,
         lpszClassName: w!("lan-mouse-message-window-class"),
         ..Default::default()
     };
@@ -213,9 +214,9 @@ fn start_routine(
             0,
             0,
             0,
-            HWND::default(),
-            HMENU::default(),
-            instance,
+            None,
+            None,
+            Some(instance),
             None,
         )
         .expect("CreateWindowExW");
@@ -312,7 +313,7 @@ unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
 
     /* no client was active */
     if !active {
-        return CallNextHookEx(HHOOK::default(), ncode, wparam, lparam);
+        return CallNextHookEx(None, ncode, wparam, lparam);
     }
 
     /* get active client if any */
@@ -337,7 +338,7 @@ unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
 unsafe extern "system" fn kybrd_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
     /* get active client if any */
     let Some(client) = ACTIVE_CLIENT.get() else {
-        return CallNextHookEx(HHOOK::default(), ncode, wparam, lparam);
+        return CallNextHookEx(None, ncode, wparam, lparam);
     };
 
     /* convert to key event */
@@ -388,7 +389,10 @@ fn enumerate_displays(display_rects: &mut Vec<RECT>) {
             if ret == FALSE {
                 break;
             }
-            if device.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP != 0 {
+            if device
+                .StateFlags
+                .contains(DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)
+            {
                 devices.push(device.DeviceName);
             }
         }
@@ -537,6 +541,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/Cargo.toml

@@ -39,18 +39,18 @@ wayland-protocols-misc = { version = "0.3.1", features = [
     "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.10", default-features = false, features = [
+ashpd = { version = "0.11.0", default-features = false, features = [
     "tokio",
 ], optional = true }
-reis = { version = "0.4", features = ["tokio"], optional = true }
+reis = { version = "0.5.0", features = ["tokio"], optional = true }
 
 [target.'cfg(target_os="macos")'.dependencies]
 bitflags = "2.6.0"
-core-graphics = { version = "0.24.0", features = ["highsierra"] }
-keycode = "0.4.0"
+core-graphics = { version = "0.25.0", features = ["highsierra"] }
+keycode = "1.0.0"
 
 [target.'cfg(windows)'.dependencies]
-windows = { version = "0.58.0", features = [
+windows = { version = "0.61.2", features = [
     "Win32_System_LibraryLoader",
     "Win32_System_Threading",
     "Win32_Foundation",

input-emulation/src/macos.rs

@@ -161,12 +161,12 @@ fn get_display_at_point(x: CGFloat, y: CGFloat) -> Option<CGDirectDisplayID> {
     };
 
     if error != 0 {
-        log::warn!("error getting displays at point ({}, {}): {}", x, y, error);
+        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);
+        log::debug!("no displays found at point ({x}, {y})");
         return Option::None;
     }
 

input-emulation/src/wlroots.rs

@@ -163,13 +163,13 @@ impl Emulation for WlrootsEmulation {
     async fn create(&mut self, handle: EmulationHandle) {
         self.state.add_client(handle);
         if let Err(e) = self.queue.flush() {
-            log::error!("{}", e);
+            log::error!("{e}");
         }
     }
     async fn destroy(&mut self, handle: EmulationHandle) {
         self.state.destroy_client(handle);
         if let Err(e) = self.queue.flush() {
-            log::error!("{}", e);
+            log::error!("{e}");
         }
     }
     async fn terminate(&mut self) {
@@ -221,7 +221,7 @@ impl VirtualInput {
                     self.keyboard.key(time, key, state as u32);
                     if let Ok(mut mods) = self.modifiers.lock() {
                         if mods.update_by_key_event(key, state) {
-                            log::trace!("Key triggers modifier change: {:?}", mods);
+                            log::trace!("Key triggers modifier change: {mods:?}");
                             self.keyboard.modifiers(
                                 mods.mask_pressed().bits(),
                                 0,
@@ -330,7 +330,7 @@ impl XMods {
 
     fn update_by_key_event(&mut self, key: u32, state: u8) -> bool {
         if let Ok(key) = scancode::Linux::try_from(key) {
-            log::trace!("Attempting to process modifier from: {:#?}", key);
+            log::trace!("Attempting to process modifier from: {key:#?}");
             let pressed_mask = match key {
                 scancode::Linux::KeyLeftShift | scancode::Linux::KeyRightShift => XMods::ShiftMask,
                 scancode::Linux::KeyLeftCtrl | scancode::Linux::KeyRightCtrl => XMods::ControlMask,
@@ -348,7 +348,7 @@ impl XMods {
 
             // unchanged
             if pressed_mask.is_empty() && locked_mask.is_empty() {
-                log::trace!("{:#?} is not a modifier key", key);
+                log::trace!("{key:#?} is not a modifier key");
                 return false;
             }
             match state {

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,

input-event/Cargo.toml

@@ -14,7 +14,7 @@ serde = { version = "1.0", features = ["derive"] }
 thiserror = "2.0.0"
 
 [target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
-reis = { version = "0.4", optional = true }
+reis = { version = "0.5.0", optional = true }
 
 [features]
 default = ["libei"]

input-event/src/lib.rs

@@ -112,8 +112,8 @@ impl Display for KeyboardEvent {
 impl Display for Event {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Event::Pointer(p) => write!(f, "{}", p),
-            Event::Keyboard(k) => write!(f, "{}", k),
+            Event::Pointer(p) => write!(f, "{p}"),
+            Event::Keyboard(k) => write!(f, "{k}"),
         }
     }
 }

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;
@@ -146,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};
 
@@ -321,7 +324,7 @@ impl Window {
 
     pub(super) fn update_client_config(&self, handle: ClientHandle, client: ClientConfig) {
         let Some(row) = self.row_for_handle(handle) else {
-            log::warn!("could not find row for handle {}", handle);
+            log::warn!("could not find row for handle {handle}");
             return;
         };
         row.set_hostname(client.hostname);
@@ -331,11 +334,11 @@ impl Window {
 
     pub(super) fn update_client_state(&self, handle: ClientHandle, state: ClientState) {
         let Some(row) = self.row_for_handle(handle) else {
-            log::warn!("could not find row for handle {}", handle);
+            log::warn!("could not find row for handle {handle}");
             return;
         };
         let Some(client_object) = self.client_object_for_handle(handle) else {
-            log::warn!("could not find row for handle {}", handle);
+            log::warn!("could not find row for handle {handle}");
             return;
         };
 
@@ -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

@@ -202,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)]

lan-mouse-ipc/src/listen.rs

@@ -45,7 +45,7 @@ impl AsyncFrontendListener {
         let (socket_path, listener) = {
             let socket_path = crate::default_socket_path()?;
 
-            log::debug!("remove socket: {:?}", 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

src/config.rs

@@ -51,7 +51,7 @@ struct ConfigToml {
     port: Option<u16>,
     release_bind: Option<Vec<scancode::Linux>>,
     cert_path: Option<PathBuf>,
-    clients: Vec<TomlClient>,
+    clients: Option<Vec<TomlClient>>,
     authorized_fingerprints: Option<HashMap<String, String>>,
 }
 
@@ -370,6 +370,7 @@ impl Config {
         self.config_toml
             .as_ref()
             .map(|c| c.clients.clone())
+            .unwrap_or_default()
             .into_iter()
             .flatten()
             .map(From::<TomlClient>::from)

src/dns.rs

@@ -3,7 +3,7 @@ use std::{collections::HashMap, net::IpAddr};
 use local_channel::mpsc::{channel, Receiver, Sender};
 use tokio::task::{spawn_local, JoinHandle};
 
-use hickory_resolver::{error::ResolveError, TokioAsyncResolver};
+use hickory_resolver::{ResolveError, TokioResolver};
 use tokio_util::sync::CancellationToken;
 
 use lan_mouse_ipc::ClientHandle;
@@ -26,7 +26,7 @@ pub(crate) enum DnsEvent {
 }
 
 struct DnsTask {
-    resolver: TokioAsyncResolver,
+    resolver: TokioResolver,
     request_rx: Receiver<DnsRequest>,
     event_tx: Sender<DnsEvent>,
     cancellation_token: CancellationToken,
@@ -35,7 +35,7 @@ struct DnsTask {
 
 impl DnsResolver {
     pub(crate) fn new() -> Result<Self, ResolveError> {
-        let resolver = TokioAsyncResolver::tokio_from_system_conf()?;
+        let resolver = TokioResolver::builder_tokio()?.build();
         let (request_tx, request_rx) = channel();
         let (event_tx, event_rx) = channel();
         let cancellation_token = CancellationToken::new();

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/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,23 +246,25 @@ 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;
             }
         }
     }
-    log::info!("dtls client disconnected {:?}", addr);
+    log::info!("dtls client disconnected {addr:?}");
     let mut conns = conns.lock().await;
     let index = conns
         .iter()

src/service.rs

@@ -9,7 +9,7 @@ use crate::{
     listen::{LanMouseListener, ListenerCreationError},
 };
 use futures::StreamExt;
-use hickory_resolver::error::ResolveError;
+use hickory_resolver::ResolveError;
 use lan_mouse_ipc::{
     AsyncFrontendListener, ClientConfig, ClientHandle, ClientState, FrontendEvent, FrontendRequest,
     IpcError, IpcListenerCreationError, Position, Status,
@@ -211,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,
@@ -219,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);
                 }
@@ -246,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 });
+            }
         }
     }
 
@@ -347,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,
+            });
         }
     }