windows: fix resolution with scaling enabled

.github/workflows/cachix.yml

@@ -7,7 +7,7 @@ jobs:
       matrix:
        os: 
         - ubuntu-latest
-        - macos-13
+        - macos-latest
         - macos-14
     name: "Build"
     runs-on: ${{ matrix.os }} 
@@ -31,7 +31,7 @@ jobs:
       run: nix build --print-build-logs --show-trace .#packages.x86_64-linux.lan-mouse
 
     - name: Build lan-mouse (x86_64-darwin)
-      if: matrix.os == 'macos-13'
+      if: matrix.os == 'macos-latest'
       run: nix build --print-build-logs --show-trace .#packages.x86_64-darwin.lan-mouse
 
     - name: Build lan-mouse (aarch64-darwin)

.github/workflows/pre-release.yml

@@ -78,7 +78,7 @@ jobs:
         path: lan-mouse-windows.zip
 
   macos-release-build:
-    runs-on: macos-13
+    runs-on: macos-latest
     steps:
     - uses: actions/checkout@v4
     - name: install dependencies

.github/workflows/rust.yml

@@ -92,7 +92,7 @@ jobs:
           target/debug/*.dll
 
   build-macos:
-    runs-on: macos-13
+    runs-on: macos-latest
     steps:
     - uses: actions/checkout@v4
     - name: install dependencies

.github/workflows/tagged-release.yml

@@ -74,7 +74,7 @@ jobs:
         path: lan-mouse-windows.zip
 
   macos-release-build:
-    runs-on: macos-13
+    runs-on: macos-latest
     steps:
     - uses: actions/checkout@v4
     - name: install dependencies

Cargo.lock

@@ -1284,7 +1284,7 @@ dependencies = [
 
 [[package]]
 name = "lan-mouse"
-version = "0.8.0"
+version = "0.7.3"
 dependencies = [
  "anyhow",
  "ashpd",
@@ -1292,7 +1292,6 @@ dependencies = [
  "async-trait",
  "clap",
  "core-graphics",
- "endi",
  "env_logger",
  "futures",
  "futures-core",

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "lan-mouse"
 description = "Software KVM Switch / mouse & keyboard sharing software for Local Area Networks"
-version = "0.8.0"
+version = "0.7.3"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/ferdinandschober/lan-mouse"
@@ -22,7 +22,7 @@ anyhow = "1.0.71"
 log = "0.4.20"
 env_logger = "0.11.3"
 serde_json = "1.0.107"
-tokio = {version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "process", "rt", "sync", "signal"] }
+tokio = {version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "rt", "sync", "signal"] }
 async-trait = "0.1.73"
 futures-core = "0.3.28"
 futures = "0.3.28"
@@ -35,7 +35,6 @@ once_cell = "1.19.0"
 num_enum = "0.7.2"
 hostname = "0.4.0"
 slab = "0.4.9"
-endi = "1.1.0"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.148"

flake.lock

@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1716293225,
+        "lastModified": 1710806803,
-        "narHash": "sha256-pU9ViBVE3XYb70xZx+jK6SEVphvt7xMTbm6yDIF4xPs=",
+        "narHash": "sha256-qrxvLS888pNJFwJdK+hf1wpRCSQcqA6W5+Ox202NDa0=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "3eaeaeb6b1e08a016380c279f8846e0bd8808916",
+        "rev": "b06025f1533a1e07b6db3e75151caa155d1c7eb3",
         "type": "github"
       },
       "original": {
@@ -48,11 +48,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1716257780,
+        "lastModified": 1710987136,
-        "narHash": "sha256-R+NjvJzKEkTVCmdrKRfPE4liX/KMGVqGUwwS5H8ET8A=",
+        "narHash": "sha256-Q8GRdlAIKZ8tJUXrbcRO1pA33AdoPfTUirsSnmGQnOU=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "4e5e3d2c5c9b2721bd266f9e43c14e96811b89d2",
+        "rev": "97596b54ac34ad8184ca1eef44b1ec2e5c2b5f9e",
         "type": "github"
       },
       "original": {

nix/default.nix

@@ -2,14 +2,10 @@
   rustPlatform,
   lib,
   pkgs,
-}: let
+}:
-  cargoToml = builtins.fromTOML (builtins.readFile ../Cargo.toml);
-  pname = cargoToml.package.name;
-  version = cargoToml.package.version;
-in
 rustPlatform.buildRustPackage {
-  pname = pname;
+  pname = "lan-mouse";
-  version = version;
+  version = "0.7.0";
 
   nativeBuildInputs = with pkgs; [
     pkg-config
@@ -27,7 +23,7 @@ rustPlatform.buildRustPackage {
   ];
 
   src = builtins.path {
-    name = pname;
+    name = "lan-mouse";
     path = lib.cleanSource ../.;
   };
 
@@ -42,7 +38,7 @@ rustPlatform.buildRustPackage {
       Lan Mouse is a mouse and keyboard sharing software similar to universal-control on Apple devices. It allows for using multiple pcs with a single set of mouse and keyboard. This is also known as a Software KVM switch.
       The primary target is Wayland on Linux but Windows and MacOS and Linux on Xorg have partial support as well (see below for more details).
     '';
-    mainProgram = pname;
+    mainProgram = "lan-mouse";
     platforms = platforms.all;
   };
 }

src/capture/wayland.rs

@@ -111,7 +111,6 @@ struct State {
     qh: QueueHandle<Self>,
     pending_events: VecDeque<(ClientHandle, Event)>,
     output_info: Vec<(WlOutput, OutputInfo)>,
-    scroll_discrete_pending: bool,
 }
 
 struct Inner {
@@ -352,7 +351,6 @@ impl WaylandInputCapture {
             read_guard: None,
             pending_events: VecDeque::new(),
             output_info: vec![],
-            scroll_discrete_pending: false,
         };
 
         // dispatch registry to () again, in order to read all wl_outputs
@@ -754,25 +752,17 @@ impl Dispatch<WlPointer, ()> for State {
             }
             wl_pointer::Event::Axis { time, axis, value } => {
                 let (_, client) = app.focused.as_ref().unwrap();
-                if app.scroll_discrete_pending {
+                app.pending_events.push_back((
-                    // each axisvalue120 event is coupled with
+                    *client,
-                    // a corresponding axis event, which needs to
+                    Event::Pointer(PointerEvent::Axis {
-                    // be ignored to not duplicate the scrolling
+                        time,
-                    app.scroll_discrete_pending = false;
+                        axis: u32::from(axis) as u8,
-                } else {
+                        value,
-                    app.pending_events.push_back((
+                    }),
-                        *client,
+                ));
-                        Event::Pointer(PointerEvent::Axis {
-                            time,
-                            axis: u32::from(axis) as u8,
-                            value,
-                        }),
-                    ));
-                }
             }
             wl_pointer::Event::AxisValue120 { axis, value120 } => {
                 let (_, client) = app.focused.as_ref().unwrap();
-                app.scroll_discrete_pending = true;
                 app.pending_events.push_back((
                     *client,
                     Event::Pointer(PointerEvent::AxisDiscrete120 {

src/capture/windows.rs

@@ -141,7 +141,7 @@ fn to_mouse_event(wparam: WPARAM, lparam: LPARAM) -> Option<PointerEvent> {
         },
         WPARAM(p) if p == WM_MOUSEWHEEL as usize => Some(PointerEvent::AxisDiscrete120 {
             axis: 0,
-            value: -(mouse_low_level.mouseData as i32 >> 16),
+            value: -(mouse_low_level.mouseData as i32),
         }),
         WPARAM(p) if p == WM_XBUTTONDOWN as usize || p == WM_XBUTTONUP as usize => {
             let hb = mouse_low_level.mouseData >> 16;

src/client.rs

@@ -102,8 +102,6 @@ pub struct ClientConfig {
     pub port: u16,
     /// position of a client on screen
     pub pos: Position,
-    /// enter hook
-    pub cmd: Option<String>,
 }
 
 impl Default for ClientConfig {
@@ -113,7 +111,6 @@ impl Default for ClientConfig {
             hostname: Default::default(),
             fix_ips: Default::default(),
             pos: Default::default(),
-            cmd: None,
         }
     }
 }

src/config.rs

@@ -31,7 +31,6 @@ pub struct TomlClient {
     pub ips: Option<Vec<IpAddr>>,
     pub port: Option<u16>,
     pub activate_on_startup: Option<bool>,
-    pub enter_hook: Option<String>,
 }
 
 impl ConfigToml {
@@ -93,7 +92,6 @@ pub struct ConfigClient {
     pub port: u16,
     pub pos: Position,
     pub active: bool,
-    pub enter_hook: Option<String>,
 }
 
 const DEFAULT_RELEASE_KEYS: [scancode::Linux; 4] =
@@ -210,14 +208,12 @@ impl Config {
                     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,
                 }
             })
             .collect()

src/emulate/wlroots.rs

@@ -182,8 +182,7 @@ impl VirtualInput {
                     }
                     PointerEvent::AxisDiscrete120 { axis, value } => {
                         let axis: Axis = (axis as u32).try_into()?;
-                        self.pointer
+                        self.pointer.axis(0, axis, (value / 15) as f64);
-                            .axis_discrete(0, axis, value as f64 / 6., value / 120);
                         self.pointer.frame();
                     }
                     PointerEvent::Frame {} => self.pointer.frame(),

src/frontend.rs

@@ -107,18 +107,16 @@ pub enum FrontendRequest {
     UpdatePosition(ClientHandle, Position),
     /// update fix-ips
     UpdateFixIps(ClientHandle, Vec<IpAddr>),
-    /// request the state of the given client
-    GetState(ClientHandle),
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum FrontendEvent {
     /// a client was created
     Created(ClientHandle, ClientConfig, ClientState),
-    /// no such client
+    /// a client was updated
-    NoSuchClient(ClientHandle),
+    Updated(ClientHandle, ClientConfig),
     /// state changed
-    State(ClientHandle, ClientConfig, ClientState),
+    StateChange(ClientHandle, ClientState),
     /// the client was deleted
     Deleted(ClientHandle),
     /// new port, reason of failure (if failed)
@@ -237,7 +235,9 @@ impl FrontendListener {
         let json = serde_json::to_string(&notify).unwrap();
         let payload = json.as_bytes();
         let len = payload.len().to_be_bytes();
-        log::debug!("broadcasting event to streams: {json}");
+        log::debug!("json: {json}, len: {}", payload.len());
+
+        log::debug!("broadcasting event to streams: {:?}", self.tx_streams);
         let mut keep = vec![];
         // TODO do simultaneously
         for tx in self.tx_streams.iter_mut() {

src/frontend/cli.rs

@@ -100,18 +100,6 @@ impl<'a> Cli<'a> {
         }
     }
 
-    async fn update_client(&mut self, handle: ClientHandle) -> Result<()> {
-        self.send_request(FrontendRequest::GetState(handle)).await?;
-        loop {
-            let event = self.await_event().await?;
-            self.handle_event(event.clone());
-            if let FrontendEvent::State(_, _, _) | FrontendEvent::NoSuchClient(_) = event {
-                break;
-            }
-        }
-        Ok(())
-    }
-
     async fn execute(&mut self, cmd: Command) -> Result<()> {
         match cmd {
             Command::None => {}
@@ -137,8 +125,14 @@ impl<'a> Cli<'a> {
                     FrontendRequest::UpdatePosition(handle, pos),
                 ] {
                     self.send_request(request).await?;
+                    loop {
+                        let event = self.await_event().await?;
+                        self.handle_event(event.clone());
+                        if let FrontendEvent::Updated(_, _) = event {
+                            break;
+                        }
+                    }
                 }
-                self.update_client(handle).await?;
             }
             Command::Disconnect(id) => {
                 self.send_request(FrontendRequest::Delete(id)).await?;
@@ -154,12 +148,26 @@ impl<'a> Cli<'a> {
             Command::Activate(id) => {
                 self.send_request(FrontendRequest::Activate(id, true))
                     .await?;
-                self.update_client(id).await?;
+                loop {
+                    let event = self.await_event().await?;
+                    self.handle_event(event.clone());
+                    if let FrontendEvent::StateChange(_, _) = event {
+                        self.handle_event(event);
+                        break;
+                    }
+                }
             }
             Command::Deactivate(id) => {
                 self.send_request(FrontendRequest::Activate(id, false))
                     .await?;
-                self.update_client(id).await?;
+                loop {
+                    let event = self.await_event().await?;
+                    self.handle_event(event.clone());
+                    if let FrontendEvent::StateChange(_, _) = event {
+                        self.handle_event(event);
+                        break;
+                    }
+                }
             }
             Command::List => {
                 self.send_request(FrontendRequest::Enumerate()).await?;
@@ -174,12 +182,25 @@ impl<'a> Cli<'a> {
             Command::SetHost(handle, host) => {
                 let request = FrontendRequest::UpdateHostname(handle, Some(host.clone()));
                 self.send_request(request).await?;
-                self.update_client(handle).await?;
+                loop {
+                    let event = self.await_event().await?;
+                    self.handle_event(event.clone());
+                    if let FrontendEvent::Updated(_, _) = event {
+                        self.handle_event(event);
+                        break;
+                    }
+                }
             }
             Command::SetPort(handle, port) => {
                 let request = FrontendRequest::UpdatePort(handle, port.unwrap_or(DEFAULT_PORT));
                 self.send_request(request).await?;
-                self.update_client(handle).await?;
+                loop {
+                    let event = self.await_event().await?;
+                    self.handle_event(event.clone());
+                    if let FrontendEvent::Updated(_, _) = event {
+                        break;
+                    }
+                }
             }
             Command::Help => {
                 for cmd_type in [
@@ -223,11 +244,8 @@ impl<'a> Cli<'a> {
                 eprintln!();
                 self.clients.push((h, c, s));
             }
-            FrontendEvent::NoSuchClient(h) => {
+            FrontendEvent::Updated(h, c) => {
-                eprintln!("no such client: {h}");
+                if let Some((_, config, _)) = self.find_mut(h) {
-            }
-            FrontendEvent::State(h, c, s) => {
-                if let Some((_, config, state)) = self.find_mut(h) {
                     let old_host = config.hostname.clone().unwrap_or("\"\"".into());
                     let new_host = c.hostname.clone().unwrap_or("\"\"".into());
                     if old_host != new_host {
@@ -243,6 +261,10 @@ impl<'a> Cli<'a> {
                         eprintln!("client {h} ips updated: {:?}", c.fix_ips)
                     }
                     *config = c;
+                }
+            }
+            FrontendEvent::StateChange(h, s) => {
+                if let Some((_, _, state)) = self.find_mut(h) {
                     if state.active ^ s.active {
                         eprintln!(
                             "client {h} {}",

src/frontend/gtk.rs

@@ -11,7 +11,6 @@ use std::{
 use crate::frontend::{gtk::window::Window, FrontendRequest};
 
 use adw::Application;
-use endi::{Endian, ReadBytes};
 use gtk::{
     gdk::Display, glib::clone, prelude::*, subclass::prelude::ObjectSubclassIsExt, IconTheme,
 };
@@ -86,14 +85,16 @@ fn build_ui(app: &Application) {
     gio::spawn_blocking(move || {
         match loop {
             // read length
-            let len = match rx.read_u64(Endian::Big) {
+            let mut len = [0u8; 8];
-                Ok(l) => l,
+            match rx.read_exact(&mut len) {
+                Ok(_) => (),
                 Err(e) if e.kind() == ErrorKind::UnexpectedEof => break Ok(()),
                 Err(e) => break Err(e),
             };
+            let len = usize::from_be_bytes(len);
 
             // read payload
-            let mut buf = vec![0u8; len as usize];
+            let mut buf = vec![0u8; len];
             match rx.read_exact(&mut buf) {
                 Ok(_) => (),
                 Err(e) if e.kind() == ErrorKind::UnexpectedEof => break Ok(()),
@@ -125,11 +126,12 @@ fn build_ui(app: &Application) {
                 FrontendEvent::Deleted(client) => {
                     window.delete_client(client);
                 }
-                FrontendEvent::State(handle, config, state) => {
+                FrontendEvent::Updated(handle, client) => {
-                    window.update_client_config(handle, config);
+                    window.update_client_config(handle, client);
+                }
+                FrontendEvent::StateChange(handle, state) => {
                     window.update_client_state(handle, state);
                 }
-                FrontendEvent::NoSuchClient(_) => { }
                 FrontendEvent::Error(e) => {
                     window.show_toast(e.as_str());
                 },

src/frontend/gtk/window.rs

@@ -10,7 +10,6 @@ use std::net::TcpStream;
 
 use adw::prelude::*;
 use adw::subclass::prelude::*;
-use endi::{Endian, WriteBytes};
 use glib::{clone, Object};
 use gtk::{
     gio,
@@ -52,10 +51,6 @@ impl Window {
             .expect("Could not get clients")
     }
 
-    fn client_by_idx(&self, idx: u32) -> Option<ClientObject> {
-        self.clients().item(idx).map(|o| o.downcast().unwrap())
-    }
-
     fn setup_clients(&self) {
         let model = gio::ListStore::new::<ClientObject>();
         self.imp().clients.replace(Some(model));
@@ -67,24 +62,27 @@ impl Window {
                 let client_object = obj.downcast_ref().expect("Expected object of type `ClientObject`.");
                 let row = window.create_client_row(client_object);
                 row.connect_closure("request-update", false, closure_local!(@strong window => move |row: ClientRow, active: bool| {
-                    if let Some(client) = window.client_by_idx(row.index() as u32) {
+                    let index = row.index() as u32;
-                        window.request_client_activate(&client, active);
+                    let Some(client) = window.clients().item(index) else {
-                        window.request_client_update(&client);
+                        return;
-                        window.request_client_state(&client);
+                    };
-                    }
+                    let client = client.downcast_ref::<ClientObject>().unwrap();
+                    window.request_client_update(client);
+                    window.request_client_activate(client, active)
                 }));
                 row.connect_closure("request-delete", false, closure_local!(@strong window => move |row: ClientRow| {
-                    if let Some(client) = window.client_by_idx(row.index() as u32) {
+                    let index = row.index() as u32;
-                        window.request_client_delete(&client);
+                    window.request_client_delete(index);
-                    }
                 }));
                 row.connect_closure("request-dns", false, closure_local!(@strong window => move
                 |row: ClientRow| {
-                    if let Some(client) = window.client_by_idx(row.index() as u32) {
+                    let index = row.index() as u32;
-                        window.request_client_update(&client);
+                    let Some(client) = window.clients().item(index) else {
-                        window.request_dns(&client);
+                        return;
-                        window.request_client_state(&client);
+                    };
-                    }
+                    let client = client.downcast_ref::<ClientObject>().unwrap();
+                    window.request_client_update(client);
+                    window.request_dns(index);
                 }));
                 row.upcast()
             })
@@ -179,7 +177,7 @@ impl Window {
 
         if state.resolving != data.resolving {
             client_object.set_resolving(state.resolving);
-            log::debug!("resolving {}: {}", data.handle, state.resolving);
+            log::debug!("resolving {}: {}", data.handle, state.active);
         }
 
         self.update_dns_state(handle, !state.ips.is_empty());
@@ -206,6 +204,20 @@ impl Window {
         }
     }
 
+    pub fn request_dns(&self, idx: u32) {
+        let client_object = self.clients().item(idx).unwrap();
+        let client_object: &ClientObject = client_object.downcast_ref().unwrap();
+        let data = client_object.get_data();
+        let event = FrontendRequest::ResolveDns(data.handle);
+        self.request(event);
+    }
+
+    pub fn request_client_create(&self) {
+        let event = FrontendRequest::Create;
+        self.imp().set_port(DEFAULT_PORT);
+        self.request(event);
+    }
+
     pub fn request_port_change(&self) {
         let port = self.imp().port_entry.get().text().to_string();
         if let Ok(port) = port.as_str().parse::<u16>() {
@@ -215,23 +227,6 @@ impl Window {
         }
     }
 
-    pub fn request_client_state(&self, client: &ClientObject) {
-        let handle = client.handle();
-        let event = FrontendRequest::GetState(handle);
-        self.request(event);
-    }
-
-    pub fn request_client_create(&self) {
-        let event = FrontendRequest::Create;
-        self.request(event);
-    }
-
-    pub fn request_dns(&self, client: &ClientObject) {
-        let data = client.get_data();
-        let event = FrontendRequest::ResolveDns(data.handle);
-        self.request(event);
-    }
-
     pub fn request_client_update(&self, client: &ClientObject) {
         let handle = client.handle();
         let data = client.get_data();
@@ -244,29 +239,38 @@ impl Window {
             FrontendRequest::UpdatePosition(handle, position),
             FrontendRequest::UpdatePort(handle, port),
         ] {
+            log::debug!("requesting: {event:?}");
             self.request(event);
         }
     }
 
     pub fn request_client_activate(&self, client: &ClientObject, active: bool) {
         let handle = client.handle();
+
         let event = FrontendRequest::Activate(handle, active);
+        log::debug!("requesting: {event:?}");
         self.request(event);
     }
 
-    pub fn request_client_delete(&self, client: &ClientObject) {
+    pub fn request_client_delete(&self, idx: u32) {
-        let handle = client.handle();
+        if let Some(obj) = self.clients().item(idx) {
-        let event = FrontendRequest::Delete(handle);
+            let client_object: &ClientObject = obj
-        self.request(event);
+                .downcast_ref()
+                .expect("Expected object of type `ClientObject`.");
+            let handle = client_object.handle();
+            let event = FrontendRequest::Delete(handle);
+            self.request(event);
+        }
     }
 
     pub fn request(&self, event: FrontendRequest) {
         let json = serde_json::to_string(&event).unwrap();
-        log::debug!("requesting: {json}");
+        log::debug!("requesting {json}");
         let mut stream = self.imp().stream.borrow_mut();
         let stream = stream.as_mut().unwrap();
         let bytes = json.as_bytes();
-        if let Err(e) = stream.write_u64(Endian::Big, bytes.len() as u64) {
+        let len = bytes.len().to_be_bytes();
+        if let Err(e) = stream.write(&len) {
             log::error!("error sending message: {e}");
         };
         if let Err(e) = stream.write(bytes) {

src/scancode.rs

@@ -3,8 +3,6 @@ use serde::{Deserialize, Serialize};
 
 /*
  * https://learn.microsoft.com/en-us/windows/win32/inputdev/about-keyboard-input
- * https://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/translate.pdf
- * https://kbd-project.org/docs/scancodes/scancodes-1.html
  */
 #[repr(u32)]
 #[derive(Debug, Clone, Copy, TryFromPrimitive)]
@@ -122,15 +120,15 @@ pub enum Windows {
     KeyF21 = 0x006C,
     KeyF22 = 0x006D,
     KeyF23 = 0x006E,
-    KeyF24 = 0x0076, // KeyLANG5
+    KeyF24 = 0x0076,
     KeypadComma = 0x007E,
     KeyInternational1 = 0x0073,
     KeyInternational2 = 0x0070,
-    KeyInternational3 = 0x007D, // typo in doc -> its Int'l 3 not Int'l 2
+    KeyInternational3 = 0x007D,
     #[allow(dead_code)]
-    KeyInternational4 = 0x0079,
+    KeyInternational4 = 0x0079, // FIXME unused
     #[allow(dead_code)]
-    KeyInternational5 = 0x007B,
+    KeyInternational5 = 0x007B, // FIXME unused
     // KeyInternational6 = 0x005C,
     KeyLANG1 = 0x0072,
     KeyLANG2 = 0x0071,
@@ -143,7 +141,6 @@ pub enum Windows {
     KeyLeftGUI = 0xE05B,
     KeyRightCtrl = 0xE01D,
     KeyRightShift = 0x0036,
-    KeyFakeRightShift = 0xE036,
     KeyRightAlt = 0xE038,
     KeyRightGUI = 0xE05C,
     KeyScanNextTrack = 0xE019,
@@ -296,7 +293,7 @@ pub enum Linux {
     KeyPause = 119,
     KeyScale = 120, /* AL Compiz Scale (Expose) */
     KeyKpcomma = 121,
-    KeyHanguel = 122,
+    KeyHangeul = 122,
     // KEY_HANGUEL = KeyHangeul,
     KeyHanja = 123,
     KeyYen = 124,
@@ -521,16 +518,16 @@ impl TryFrom<Linux> for Windows {
             Linux::KeyKp3 => Ok(Self::Keypad3PageDn),
             Linux::KeyKp0 => Ok(Self::Keypad0Insert),
             Linux::KeyKpDot => Ok(Self::KeypadDot),
-            Linux::KeyZenkakuhankaku => Ok(Self::KeyF24), // KeyLANG5
+            Linux::KeyZenkakuhankaku => Ok(Self::KeyLANG1), // TODO unsure
-            Linux::Key102nd => Ok(Self::KeyNonUSSlashBar), // TODO unsure
+            Linux::Key102nd => Ok(Self::KeyNonUSSlashBar),  // TODO unsure
             Linux::KeyF11 => Ok(Self::KeyF11),
             Linux::KeyF12 => Ok(Self::KeyF12),
-            Linux::KeyRo => Ok(Self::KeyInternational1),
+            Linux::KeyRo => Ok(Self::ErrorRollOver), // TODO unsure
-            Linux::KeyKatakana => Ok(Self::KeyLANG3),
+            Linux::KeyKatakana => Ok(Self::KeyLANG1), // TODO unsure
-            Linux::KeyHiragana => Ok(Self::KeyLANG4),
+            Linux::KeyHiragana => Ok(Self::KeyLANG2), // TODO unsure
-            Linux::KeyHenkan => Ok(Self::KeyInternational4),
+            Linux::KeyHenkan => Ok(Self::KeyLANG3),  // TODO unsure
-            Linux::KeyKatakanahiragana => Ok(Self::KeyInternational2),
+            Linux::KeyKatakanahiragana => Ok(Self::KeyLANG4), // TODO unsure
-            Linux::KeyMuhenkan => Ok(Self::KeyInternational5),
+            Linux::KeyMuhenkan => Ok(Self::KeyLANG4), // TODO unsure
             Linux::KeyKpJpComma => Ok(Self::KeypadComma),
             Linux::KeyKpEnter => Ok(Self::KeypadEnter),
             Linux::KeyRightCtrl => Ok(Self::KeyRightCtrl),
@@ -558,9 +555,9 @@ impl TryFrom<Linux> for Windows {
             Linux::KeyPause => Ok(Self::KeyPause),
             Linux::KeyScale => Err(()), // TODO
             Linux::KeyKpcomma => Ok(Self::KeypadComma),
-            Linux::KeyHanguel => Ok(Self::KeyLANG1), // FIXME should be 00F2?
+            Linux::KeyHangeul => Ok(Self::KeyInternational1), // TODO unsure
-            Linux::KeyHanja => Ok(Self::KeyLANG2),   // FIXME should be 00F1?
+            Linux::KeyHanja => Ok(Self::KeyInternational2),   // TODO unsure
-            Linux::KeyYen => Ok(Self::KeyInternational3),
+            Linux::KeyYen => Ok(Self::KeyInternational3),     // TODO unsure
             Linux::KeyLeftMeta => Ok(Self::KeyLeftGUI),
             Linux::KeyRightmeta => Ok(Self::KeyRightGUI),
             Linux::KeyCompose => Ok(Self::KeyApplication),
@@ -810,22 +807,21 @@ impl TryFrom<Windows> for Linux {
             Windows::KeyF23 => Ok(Self::KeyF23),
             Windows::KeyF24 => Ok(Self::KeyF24),
             Windows::KeypadComma => Ok(Self::KeyKpcomma),
-            Windows::KeyInternational1 => Ok(Self::KeyRo),
+            Windows::KeyInternational1 => Ok(Self::KeyHangeul),
-            Windows::KeyInternational2 => Ok(Self::KeyKatakanahiragana),
+            Windows::KeyInternational2 => Ok(Self::KeyHanja),
             Windows::KeyInternational3 => Ok(Self::KeyYen),
-            Windows::KeyInternational4 => Ok(Self::KeyHenkan),
+            Windows::KeyInternational4 => Err(()),
-            Windows::KeyInternational5 => Ok(Self::KeyMuhenkan),
+            Windows::KeyInternational5 => Err(()),
-            Windows::KeyLANG1 => Ok(Self::KeyHanguel),
+            Windows::KeyLANG1 => Ok(Self::KeyKatakana),
-            Windows::KeyLANG2 => Ok(Self::KeyHanja),
+            Windows::KeyLANG2 => Ok(Self::KeyHiragana),
-            Windows::KeyLANG3 => Ok(Self::KeyKatakana),
+            Windows::KeyLANG3 => Ok(Self::KeyHenkan),
-            Windows::KeyLANG4 => Ok(Self::KeyHiragana),
+            Windows::KeyLANG4 => Ok(Self::KeyKatakanahiragana),
             Windows::KeyLeftCtrl => Ok(Self::KeyLeftCtrl),
             Windows::KeyLeftShift => Ok(Self::KeyLeftShift),
             Windows::KeyLeftAlt => Ok(Self::KeyLeftAlt),
             Windows::KeyLeftGUI => Ok(Self::KeyLeftMeta),
             Windows::KeyRightCtrl => Ok(Self::KeyRightCtrl),
             Windows::KeyRightShift => Ok(Self::KeyRightShift),
-            Windows::KeyFakeRightShift => Ok(Self::KeyRightShift),
             Windows::KeyRightAlt => Ok(Self::KeyRightalt),
             Windows::KeyRightGUI => Ok(Self::KeyRightmeta),
             Windows::KeyScanNextTrack => Ok(Self::KeyNextsong),

src/server.rs

@@ -55,7 +55,6 @@ impl Server {
                 fix_ips: config_client.ips.into_iter().collect(),
                 port: config_client.port,
                 pos: config_client.pos,
-                cmd: config_client.enter_hook,
             };
             let state = ClientState {
                 active: config_client.active,

src/server/capture_task.rs

@@ -2,7 +2,7 @@ use anyhow::{anyhow, Result};
 use futures::StreamExt;
 use std::{collections::HashSet, net::SocketAddr};
 
-use tokio::{process::Command, sync::mpsc::Sender, task::JoinHandle};
+use tokio::{sync::mpsc::Sender, task::JoinHandle};
 
 use crate::{
     capture::{self, InputCapture},
@@ -140,9 +140,6 @@ async fn handle_capture_event(
     if start_timer {
         let _ = timer_tx.try_send(());
     }
-    if enter {
-        spawn_hook_command(server, handle);
-    }
     if let Some(addr) = addr {
         if enter {
             let _ = sender_tx.send((Event::Enter(), addr)).await;
@@ -151,34 +148,3 @@ async fn handle_capture_event(
     }
     Ok(())
 }
-
-fn spawn_hook_command(server: &Server, handle: ClientHandle) {
-    let Some(cmd) = server
-        .client_manager
-        .borrow()
-        .get(handle)
-        .and_then(|(c, _)| c.cmd.clone())
-    else {
-        return;
-    };
-    tokio::task::spawn_local(async move {
-        log::info!("spawning command!");
-        let mut child = match Command::new("sh").arg("-c").arg(cmd.as_str()).spawn() {
-            Ok(c) => c,
-            Err(e) => {
-                log::warn!("could not execute cmd: {e}");
-                return;
-            }
-        };
-        match child.wait().await {
-            Ok(s) => {
-                if s.success() {
-                    log::info!("{cmd} exited successfully");
-                } else {
-                    log::warn!("{cmd} exited with {s}");
-                }
-            }
-            Err(e) => log::warn!("{cmd}: {e}"),
-        }
-    });
-}

src/server/frontend_task.rs

@@ -107,22 +107,20 @@ async fn handle_frontend_event(
     log::debug!("frontend: {event:?}");
     match event {
         FrontendRequest::Create => {
-            let handle = add_client(server, frontend).await;
+            add_client(server, frontend).await;
-            resolve_dns(server, resolve_tx, handle).await;
         }
         FrontendRequest::Activate(handle, active) => {
             if active {
-                activate_client(server, capture, emulate, handle).await;
+                activate_client(server, frontend, capture, emulate, handle).await;
             } else {
-                deactivate_client(server, capture, emulate, handle).await;
+                deactivate_client(server, frontend, capture, emulate, handle).await;
             }
         }
         FrontendRequest::ChangePort(port) => {
             let _ = port_tx.send(port).await;
         }
         FrontendRequest::Delete(handle) => {
-            remove_client(server, capture, emulate, handle).await;
+            remove_client(server, frontend, capture, emulate, handle).await;
-            broadcast(frontend, FrontendEvent::Deleted(handle)).await;
         }
         FrontendRequest::Enumerate() => {
             let clients = server
@@ -133,74 +131,65 @@ async fn handle_frontend_event(
                 .collect();
             broadcast(frontend, FrontendEvent::Enumerate(clients)).await;
         }
-        FrontendRequest::GetState(handle) => {
-            broadcast_client(server, frontend, handle).await;
-        }
         FrontendRequest::Terminate() => {
             log::info!("terminating gracefully...");
             return true;
         }
         FrontendRequest::UpdateFixIps(handle, fix_ips) => {
-            update_fix_ips(server, handle, fix_ips).await;
+            update_fix_ips(server, resolve_tx, handle, fix_ips).await;
-            resolve_dns(server, resolve_tx, handle).await;
+            broadcast_client_update(server, frontend, handle).await;
         }
         FrontendRequest::UpdateHostname(handle, hostname) => {
             update_hostname(server, resolve_tx, handle, hostname).await;
-            resolve_dns(server, resolve_tx, handle).await;
+            broadcast_client_update(server, frontend, handle).await;
         }
         FrontendRequest::UpdatePort(handle, port) => {
             update_port(server, handle, port).await;
+            broadcast_client_update(server, frontend, handle).await;
         }
         FrontendRequest::UpdatePosition(handle, pos) => {
             update_pos(server, handle, capture, emulate, pos).await;
+            broadcast_client_update(server, frontend, handle).await;
         }
         FrontendRequest::ResolveDns(handle) => {
-            resolve_dns(server, resolve_tx, handle).await;
+            let hostname = server
+                .client_manager
+                .borrow()
+                .get(handle)
+                .and_then(|(c, _)| c.hostname.clone());
+            if let Some(hostname) = hostname {
+                let _ = resolve_tx.send(DnsRequest { hostname, handle }).await;
+            }
         }
     };
     false
 }
 
-async fn resolve_dns(server: &Server, resolve_tx: &Sender<DnsRequest>, handle: ClientHandle) {
-    let hostname = server
-        .client_manager
-        .borrow()
-        .get(handle)
-        .and_then(|(c, _)| c.hostname.clone());
-    if let Some(hostname) = hostname {
-        let _ = resolve_tx
-            .send(DnsRequest {
-                hostname: hostname.clone(),
-                handle,
-            })
-            .await;
-    }
-}
-
 async fn broadcast(frontend: &mut FrontendListener, event: FrontendEvent) {
     if let Err(e) = frontend.broadcast_event(event).await {
         log::error!("error notifying frontend: {e}");
     }
 }
 
-pub async fn add_client(server: &Server, frontend: &mut FrontendListener) -> ClientHandle {
+pub async fn add_client(server: &Server, frontend: &mut FrontendListener) {
     let handle = server.client_manager.borrow_mut().add_client();
     log::info!("added client {handle}");
 
     let (c, s) = server.client_manager.borrow().get(handle).unwrap().clone();
     broadcast(frontend, FrontendEvent::Created(handle, c, s)).await;
-    handle
 }
 
 pub async fn deactivate_client(
     server: &Server,
+    frontend: &mut FrontendListener,
     capture: &Sender<CaptureEvent>,
     emulate: &Sender<EmulationEvent>,
     handle: ClientHandle,
 ) {
-    match server.client_manager.borrow_mut().get_mut(handle) {
+    let state = match server.client_manager.borrow_mut().get_mut(handle) {
         Some((_, s)) => {
             s.active = false;
+            s.clone()
         }
         None => return,
     };
@@ -208,10 +197,13 @@ pub async fn deactivate_client(
     let event = ClientEvent::Destroy(handle);
     let _ = capture.send(CaptureEvent::ClientEvent(event)).await;
     let _ = emulate.send(EmulationEvent::ClientEvent(event)).await;
+    let event = FrontendEvent::StateChange(handle, state);
+    broadcast(frontend, event).await;
 }
 
 pub async fn activate_client(
     server: &Server,
+    frontend: &mut FrontendListener,
     capture: &Sender<CaptureEvent>,
     emulate: &Sender<EmulationEvent>,
     handle: ClientHandle,
@@ -225,13 +217,14 @@ pub async fn activate_client(
     let other = server.client_manager.borrow_mut().find_client(pos);
     if let Some(other) = other {
         if other != handle {
-            deactivate_client(server, capture, emulate, other).await;
+            deactivate_client(server, frontend, capture, emulate, other).await;
         }
     }
 
     /* activate the client */
-    if let Some((_, s)) = server.client_manager.borrow_mut().get_mut(handle) {
+    let state = if let Some((_, s)) = server.client_manager.borrow_mut().get_mut(handle) {
         s.active = true;
+        s.clone()
     } else {
         return;
     };
@@ -240,10 +233,13 @@ pub async fn activate_client(
     let event = ClientEvent::Create(handle, pos);
     let _ = capture.send(CaptureEvent::ClientEvent(event)).await;
     let _ = emulate.send(EmulationEvent::ClientEvent(event)).await;
+    let event = FrontendEvent::StateChange(handle, state);
+    broadcast(frontend, event).await;
 }
 
 pub async fn remove_client(
     server: &Server,
+    frontend: &mut FrontendListener,
     capture: &Sender<CaptureEvent>,
     emulate: &Sender<EmulationEvent>,
     handle: ClientHandle,
@@ -262,15 +258,30 @@ pub async fn remove_client(
         let _ = capture.send(CaptureEvent::ClientEvent(destroy)).await;
         let _ = emulate.send(EmulationEvent::ClientEvent(destroy)).await;
     }
+
+    let event = FrontendEvent::Deleted(handle);
+    broadcast(frontend, event).await;
 }
 
-async fn update_fix_ips(server: &Server, handle: ClientHandle, fix_ips: Vec<IpAddr>) {
+async fn update_fix_ips(
-    let mut client_manager = server.client_manager.borrow_mut();
+    server: &Server,
-    let Some((c, _)) = client_manager.get_mut(handle) else {
+    resolve_tx: &Sender<DnsRequest>,
-        return;
+    handle: ClientHandle,
+    fix_ips: Vec<IpAddr>,
+) {
+    let hostname = {
+        let mut client_manager = server.client_manager.borrow_mut();
+        let Some((c, _)) = client_manager.get_mut(handle) else {
+            return;
+        };
+
+        c.fix_ips = fix_ips;
+        c.hostname.clone()
     };
 
-    c.fix_ips = fix_ips;
+    if let Some(hostname) = hostname {
+        let _ = resolve_tx.send(DnsRequest { hostname, handle }).await;
+    }
 }
 
 async fn update_hostname(
@@ -345,11 +356,11 @@ async fn update_pos(
     }
 }
 
-async fn broadcast_client(server: &Server, frontend: &mut FrontendListener, handle: ClientHandle) {
+async fn broadcast_client_update(
-    let client = server.client_manager.borrow().get(handle).cloned();
+    server: &Server,
-    if let Some((config, state)) = client {
+    frontend: &mut FrontendListener,
-        broadcast(frontend, FrontendEvent::State(handle, config, state)).await;
+    handle: ClientHandle,
-    } else {
+) {
-        broadcast(frontend, FrontendEvent::NoSuchClient(handle)).await;
+    let (client, _) = server.client_manager.borrow().get(handle).unwrap().clone();
-    }
+    broadcast(frontend, FrontendEvent::Updated(handle, client)).await;
 }

src/server/resolver_task.rs

@@ -35,7 +35,7 @@ pub fn new(
                 Ok(ips) => ips,
                 Err(e) => {
                     log::warn!("could not resolve host '{host}': {e}");
-                    vec![]
+                    continue;
                 }
             };
 
@@ -59,10 +59,14 @@ async fn notify_state_change(
     server: &mut Server,
     handle: ClientHandle,
 ) {
-    let state = server.client_manager.borrow_mut().get_mut(handle).cloned();
+    let state = server
-    if let Some((config, state)) = state {
+        .client_manager
+        .borrow_mut()
+        .get_mut(handle)
+        .map(|(_, s)| s.clone());
+    if let Some(state) = state {
         let _ = frontend
-            .send(FrontendEvent::State(handle, config, state))
+            .send(FrontendEvent::StateChange(handle, state))
             .await;
     }
 }