fix drop impl for desktop-portal

adjust error handling
remove dispatch workaround
2026-03-09 22:31:07 +03:00 · 2024-07-05 00:31:16 +02:00 · 2024-07-04 23:44:32 +02:00 · 2024-07-04 22:40:05 +02:00
49 changed files with 2589 additions and 3152 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -98,9 +98,9 @@ dependencies = [
 [[package]]
 name = "ashpd"
-version = "0.9.1"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfe7e0dd0ac5a401dc116ed9f9119cf9decc625600474cb41f0fc0a0050abc9a"
+checksum = "dd884d7c72877a94102c3715f3b1cd09ff4fac28221add3e57cfbe25c236d093"
 dependencies = [
 "enumflags2",
 "futures-channel",
@@ -200,9 +200,9 @@ dependencies = [
 [[package]]
 name = "async-signal"
-version = "0.2.9"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfb3634b73397aa844481f814fad23bbf07fdb0eabec10f2eb95e58944b1ec32"
+checksum = "794f185324c2f00e771cd9f1ae8b5ac68be2ca7abb129a87afd6e86d228bc54d"
 dependencies = [
 "async-io",
 "async-lock",
@@ -224,9 +224,9 @@ checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
 [[package]]
 name = "async-trait"
-version = "0.1.81"
+version = "0.1.80"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e0c28dcc82d7c8ead5cb13beb15405b57b8546e93215673ff8ca0349a028107"
+checksum = "c6fa2087f2753a7da8cc1c0dbfcf89579dd57458e36769de5ac750b4671737ca"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -296,15 +296,15 @@ dependencies = [
 [[package]]
 name = "bytes"
-version = "1.6.1"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a12916984aab3fa6e39d655a33e09c0071eb36d6ab3aea5c2d78551f1df6d952"
+checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"
 [[package]]
 name = "cairo-rs"
-version = "0.20.0"
+version = "0.19.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "797fd5a634dcb0ad0d7d583df794deb0a236d88e759cd34b7da20198c6c9d145"
+checksum = "b2ac2a4d0e69036cf0062976f6efcba1aaee3e448594e6514bb2ddf87acce562"
 dependencies = [
 "bitflags 2.6.0",
 "cairo-sys-rs",
@@ -315,9 +315,9 @@ dependencies = [
 [[package]]
 name = "cairo-sys-rs"
-version = "0.20.0"
+version = "0.19.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "428290f914b9b86089f60f5d8a9f6e440508e1bcff23b25afd51502b0a2da88f"
+checksum = "fd3bb3119664efbd78b5e6c93957447944f16bdbced84c17a9f41c7829b81e64"
 dependencies = [
 "glib-sys",
 "libc",
@@ -326,9 +326,9 @@ dependencies = [
 [[package]]
 name = "cc"
-version = "1.1.6"
+version = "1.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2aba8f4e9906c7ce3c73463f62a7f0c65183ada1a2d47e397cc8810827f9694f"
+checksum = "74b6a57f98764a267ff415d50a25e6e166f3831a5071af4995296ea97d210490"
 [[package]]
 name = "cfg-expr"
@@ -354,9 +354,9 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 [[package]]
 name = "clap"
-version = "4.5.9"
+version = "4.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64acc1846d54c1fe936a78dc189c34e28d3f5afc348403f28ecf53660b9b8462"
+checksum = "84b3edb18336f4df585bc9aa31dd99c036dfa5dc5e9a2939a722a188f3a8970d"
 dependencies = [
 "clap_builder",
 "clap_derive",
@@ -364,9 +364,9 @@ dependencies = [
 [[package]]
 name = "clap_builder"
-version = "4.5.9"
+version = "4.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fb8393d67ba2e7bfaf28a23458e4e2b543cc73a99595511eb207fdb8aede942"
+checksum = "c1c09dd5ada6c6c78075d6fd0da3f90d8080651e2d6cc8eb2f1aaa4034ced708"
 dependencies = [
 "anstream",
 "anstyle",
@@ -758,9 +758,9 @@ dependencies = [
 [[package]]
 name = "gdk-pixbuf"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28bb53ecb56857c683c9ec859908e076dd3969c7d67598bd8b1ce095d211304a"
+checksum = "624eaba126021103c7339b2e179ae4ee8cdab842daab419040710f38ed9f8699"
 dependencies = [
 "gdk-pixbuf-sys",
 "gio",
@@ -770,9 +770,9 @@ dependencies = [
 [[package]]
 name = "gdk-pixbuf-sys"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f6681a0c1330d1d3968bec1529f7172d62819ef0bdbb0d18022320654158b03"
+checksum = "4efa05a4f83c8cc50eb4d883787b919b85e5f1d8dd10b5a1df53bf5689782379"
 dependencies = [
 "gio-sys",
 "glib-sys",
@@ -783,9 +783,9 @@ dependencies = [
 [[package]]
 name = "gdk4"
-version = "0.9.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b7d7237c1487ed4b300aac7744efcbf1319e12d60d7afcd6f505414bd5b5dea"
+checksum = "db265c9dd42d6a371e09e52deab3a84808427198b86ac792d75fd35c07990a07"
 dependencies = [
 "cairo-rs",
 "gdk-pixbuf",
@@ -798,9 +798,9 @@ dependencies = [
 [[package]]
 name = "gdk4-sys"
-version = "0.9.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a67576c8ec012156d7f680e201a807b4432a77babb3157e0555e990ab6bcd878"
+checksum = "c9418fb4e8a67074919fe7604429c45aa74eb9df82e7ca529767c6d4e9dc66dd"
 dependencies = [
 "cairo-sys-rs",
 "gdk-pixbuf-sys",
@@ -842,9 +842,9 @@ checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
 [[package]]
 name = "gio"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "398e3da68749fdc32783cbf7521ec3f65c9cf946db8c7774f8460af49e52c6e2"
+checksum = "4c49f117d373ffcc98a35d114db5478bc223341cff53e39a5d6feced9e2ddffe"
 dependencies = [
 "futures-channel",
 "futures-core",
@@ -860,9 +860,9 @@ dependencies = [
 [[package]]
 name = "gio-sys"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4feb96b31c32730ea3e1e89aecd2e4e37ecb1c473ad8f685e3430a159419f63"
+checksum = "2cd743ba4714d671ad6b6234e8ab2a13b42304d0e13ab7eba1dcdd78a7d6d4ef"
 dependencies = [
 "glib-sys",
 "gobject-sys",
@@ -873,9 +873,9 @@ dependencies = [
 [[package]]
 name = "glib"
-version = "0.20.0"
+version = "0.19.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fee90a615ce05be7a32932cfb8adf2c4bbb4700e80d37713c981fb24c0c56238"
+checksum = "39650279f135469465018daae0ba53357942a5212137515777d5fdca74984a44"
 dependencies = [
 "bitflags 2.6.0",
 "futures-channel",
@@ -895,18 +895,18 @@ dependencies = [
 [[package]]
 name = "glib-build-tools"
-version = "0.20.0"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7029c2651d9b5d5a3eea93ec8a1995665c6d3a69ce9bf6042ad9064d134736d8"
+checksum = "108f374fff60efd14b0d70d8916e7213aed18d7dd071ba3e9334ed2dac1dc86a"
 dependencies = [
 "gio",
 ]
 [[package]]
 name = "glib-macros"
-version = "0.20.0"
+version = "0.19.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4da558d8177c0c8c54368818b508a4244e1286fce2858cef4e547023f0cfa5ef"
+checksum = "4429b0277a14ae9751350ad9b658b1be0abb5b54faa5bcdf6e74a3372582fad7"
 dependencies = [
 "heck 0.5.0",
 "proc-macro-crate",
@@ -917,9 +917,9 @@ dependencies = [
 [[package]]
 name = "glib-sys"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4958c26e5a01c9af00dea669a97369eccbec29a8e6d125c24ea2d85ee7467b60"
+checksum = "5c2dc18d3a82b0006d470b13304fbbb3e0a9bd4884cf985a60a7ed733ac2c4a5"
 dependencies = [
 "libc",
 "system-deps",
@@ -927,9 +927,9 @@ dependencies = [
 [[package]]
 name = "gobject-sys"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6908864f5ffff15b56df7e90346863904f49b949337ed0456b9287af61903b8"
+checksum = "2e697e252d6e0416fd1d9e169bda51c0f1c926026c39ca21fbe8b1bb5c3b8b9e"
 dependencies = [
 "glib-sys",
 "libc",
@@ -938,9 +938,9 @@ dependencies = [
 [[package]]
 name = "graphene-rs"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "630e940ad5824f90221d6579043a9cd1f8bec86b4a17faaf7827d58eb16e8c1f"
+checksum = "f5fb86031d24d9ec0a2a15978fc7a65d545a2549642cf1eb7c3dda358da42bcf"
 dependencies = [
 "glib",
 "graphene-sys",
@@ -949,9 +949,9 @@ dependencies = [
 [[package]]
 name = "graphene-sys"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fb8fade7b754982f47ebbed241fd2680816fdd4598321784da10b9e1168836a"
+checksum = "2f530e0944bccba4b55065e9c69f4975ad691609191ebac16e13ab8e1f27af05"
 dependencies = [
 "glib-sys",
 "libc",
@@ -961,9 +961,9 @@ dependencies = [
 [[package]]
 name = "gsk4"
-version = "0.9.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f3cf2091e1af185b347b3450817d93dea6fe435df7abd4c2cd7fb5bcb4cfda8"
+checksum = "7563884bf6939f4468e5d94654945bdd9afcaf8c3ba4c5dd17b5342b747221be"
 dependencies = [
 "cairo-rs",
 "gdk4",
@@ -976,9 +976,9 @@ dependencies = [
 [[package]]
 name = "gsk4-sys"
-version = "0.9.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6aa69614a26d8760c186c3690f1b0fbb917572ca23ef83137445770ceddf8cde"
+checksum = "23024bf2636c38bbd1f822f58acc9d1c25b28da896ff0f291a1a232d4272b3dc"
 dependencies = [
 "cairo-sys-rs",
 "gdk4-sys",
@@ -992,9 +992,9 @@ dependencies = [
 [[package]]
 name = "gtk4"
-version = "0.9.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eaffc6c743c9160514cc9b67eace364e5dc5798369fa809cdb04e035c21c5c5d"
+checksum = "b04e11319b08af11358ab543105a9e49b0c491faca35e2b8e7e36bfba8b671ab"
 dependencies = [
 "cairo-rs",
 "field-offset",
@@ -1013,9 +1013,9 @@ dependencies = [
 [[package]]
 name = "gtk4-macros"
-version = "0.9.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "188211f546ce5801f6d0245c37b6249143a2cb4fa040e54829ca1e76796e9f09"
+checksum = "ec655a7ef88d8ce9592899deb8b2d0fa50bab1e6dd69182deb764e643c522408"
 dependencies = [
 "proc-macro-crate",
 "proc-macro2",
@@ -1025,9 +1025,9 @@ dependencies = [
 [[package]]
 name = "gtk4-sys"
-version = "0.9.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1114a207af8ada02cf4658a76692f4190f06f093380d5be07e3ca8b43aa7c666"
+checksum = "8c8aa86b7f85ea71d66ea88c1d4bae1cfacf51ca4856274565133838d77e57b5"
 dependencies = [
 "cairo-sys-rs",
 "gdk-pixbuf-sys",
@@ -1194,8 +1194,8 @@ dependencies = [
 name = "input-capture"
 version = "0.1.0"
 dependencies = [
 "anyhow",
 "ashpd",
 "async-trait",
 "core-graphics",
 "futures",
 "futures-core",
@@ -1207,11 +1207,10 @@ dependencies = [
 "tempfile",
 "thiserror",
 "tokio",
 "tokio-util",
 "wayland-client",
 "wayland-protocols",
 "wayland-protocols-wlr",
- "windows 0.58.0",
+ "windows 0.57.0",
 "x11",
 ]
@@ -1219,6 +1218,7 @@ dependencies = [
 name = "input-emulation"
 version = "0.1.0"
 dependencies = [
 "anyhow",
 "ashpd",
 "async-trait",
 "core-graphics",
@@ -1234,20 +1234,19 @@ dependencies = [
 "wayland-protocols",
 "wayland-protocols-misc",
 "wayland-protocols-wlr",
- "windows 0.58.0",
+ "windows 0.57.0",
 "x11",
 ]
 [[package]]
 name = "input-event"
-version = "0.2.1"
+version = "0.1.0"
 dependencies = [
 "anyhow",
 "futures-core",
 "log",
 "num_enum",
 "reis",
 "serde",
 "thiserror",
 ]
 [[package]]
@@ -1329,16 +1328,16 @@ dependencies = [
 "slab",
 "thiserror",
 "tokio",
 "tokio-util",
 "toml",
 ]
 [[package]]
 name = "libadwaita"
-version = "0.7.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ff9c222b5c783729de45185f07b2fec2d43a7f9c63961e777d3667e20443878"
+checksum = "91b4990248b9e1ec5e72094a2ccaea70ec3809f88f6fd52192f2af306b87c5d9"
 dependencies = [
 "gdk-pixbuf",
 "gdk4",
 "gio",
 "glib",
@@ -1350,9 +1349,9 @@ dependencies = [
 [[package]]
 name = "libadwaita-sys"
-version = "0.7.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c44d8bdbad31d6639e1f20cc9c1424f1a8e02d751fc28d44659bf743fb9eca6"
+checksum = "23a748e4e92be1265cd9e93d569c0b5dfc7814107985aa6743d670ab281ea1a8"
 dependencies = [
 "gdk4-sys",
 "gio-sys",
@@ -1377,7 +1376,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e310b3a6b5907f99202fcdb4960ff45b93735d7c7d96b760fcff8db2dc0e103d"
 dependencies = [
 "cfg-if",
- "windows-targets 0.52.6",
+ "windows-targets 0.52.5",
 ]
 [[package]]
@@ -1545,9 +1544,9 @@ dependencies = [
 [[package]]
 name = "pango"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54768854025df6903061d0084fd9702a253ddfd60db7d9b751d43b76689a7f0a"
+checksum = "3f0d328648058085cfd6897c9ae4272884098a926f3a833cd50c8c73e6eccecd"
 dependencies = [
 "gio",
 "glib",
@@ -1557,9 +1556,9 @@ dependencies = [
 [[package]]
 name = "pango-sys"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b07cc57d10cee4ec661f718a6902cee18c2f4cfae08e87e5a390525946913390"
+checksum = "ff03da4fa086c0b244d4a4587d3e20622a3ecdb21daea9edf66597224c634ba0"
 dependencies = [
 "glib-sys",
 "gobject-sys",
@@ -1593,7 +1592,7 @@ dependencies = [
 "libc",
 "redox_syscall",
 "smallvec",
- "windows-targets 0.52.6",
+ "windows-targets 0.52.5",
 ]
 [[package]]
@@ -1678,9 +1677,9 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
 [[package]]
 name = "quick-xml"
-version = "0.34.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f24d770aeca0eacb81ac29dfbc55ebcc09312fdd1f8bbecdc7e4a84e000e3b4"
+checksum = "1004a344b30a54e2ee58d66a71b32d2db2feb0a31f9a2d302bf0536f15de2a33"
 dependencies = [
 "memchr",
 ]
@@ -1726,9 +1725,9 @@ dependencies = [
 [[package]]
 name = "redox_syscall"
-version = "0.5.3"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4"
+checksum = "c82cf8cff14456045f55ec4241383baeff27af886adb72ffb2162f99911de0fd"
 dependencies = [
 "bitflags 2.6.0",
 ]
@@ -1837,18 +1836,18 @@ checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
 [[package]]
 name = "serde"
-version = "1.0.204"
+version = "1.0.203"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12"
+checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
 dependencies = [
 "serde_derive",
 ]
 [[package]]
 name = "serde_derive"
-version = "1.0.204"
+version = "1.0.203"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222"
+checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1945,9 +1944,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 [[package]]
 name = "syn"
-version = "2.0.71"
+version = "2.0.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b146dcf730474b4bcd16c311627b31ede9ab149045db4d6088b3becaea046462"
+checksum = "901fa70d88b9d6c98022e23b4136f9f3e54e4662c3bc1bd1d84a42a9a0f0c1e9"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1956,9 +1955,9 @@ dependencies = [
 [[package]]
 name = "system-deps"
-version = "7.0.1"
+version = "6.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c81f13d9a334a6c242465140bd262fae382b752ff2011c4f7419919a9c97922"
+checksum = "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349"
 dependencies = [
 "cfg-expr",
 "heck 0.5.0",
@@ -1969,9 +1968,9 @@ dependencies = [
 [[package]]
 name = "target-lexicon"
-version = "0.12.15"
+version = "0.12.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4873307b7c257eddcb50c9bedf158eb669578359fb28428bef438fec8e6ba7c2"
+checksum = "e1fc403891a21bcfb7c37834ba66a547a8f402146eba7265b5a6d88059c9ff2f"
 [[package]]
 name = "tempfile"
@@ -1987,18 +1986,18 @@ dependencies = [
 [[package]]
 name = "thiserror"
-version = "1.0.63"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724"
+checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
 dependencies = [
 "thiserror-impl",
 ]
 [[package]]
 name = "thiserror-impl"
-version = "1.0.63"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
+checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2007,9 +2006,9 @@ dependencies = [
 [[package]]
 name = "tinyvec"
-version = "1.8.0"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938"
+checksum = "c55115c6fbe2d2bef26eb09ad74bde02d8255476fc0c7b515ef09fbb35742d82"
 dependencies = [
 "tinyvec_macros",
 ]
@@ -2022,9 +2021,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 [[package]]
 name = "tokio"
-version = "1.38.1"
+version = "1.38.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb2caba9f80616f438e09748d5acda951967e1ea58508ef53d9c6402485a46df"
+checksum = "ba4f4a02a7a80d6f274636f0aa95c7e383b912d41fe721a31f29e29698585a4a"
 dependencies = [
 "backtrace",
 "bytes",
@@ -2050,29 +2049,16 @@ dependencies = [
 "syn",
 ]
 [[package]]
 name = "tokio-util"
 version = "0.7.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9cf6b47b3771c49ac75ad09a6162f53ad4b8088b76ac60e8ec1455b31a189fe1"
 dependencies = [
 "bytes",
 "futures-core",
 "futures-sink",
 "pin-project-lite",
 "tokio",
 ]
 [[package]]
 name = "toml"
-version = "0.8.15"
+version = "0.8.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac2caab0bf757388c6c0ae23b3293fdb463fee59434529014f85e3263b995c28"
+checksum = "6f49eb2ab21d2f26bd6db7bf383edc527a7ebaee412d17af4d40fdccd442f335"
 dependencies = [
 "serde",
 "serde_spanned",
 "toml_datetime",
- "toml_edit 0.22.16",
+ "toml_edit 0.22.14",
 ]
 [[package]]
@@ -2097,9 +2083,9 @@ dependencies = [
 [[package]]
 name = "toml_edit"
-version = "0.22.16"
+version = "0.22.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "278f3d518e152219c994ce877758516bca5e118eaed6996192a774fb9fbf0788"
+checksum = "f21c7aaf97f1bd9ca9d4f9e73b0a6c74bd5afef56f2bc931943a6e1c37e04e38"
 dependencies = [
 "indexmap",
 "serde",
@@ -2221,9 +2207,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 [[package]]
 name = "wayland-backend"
-version = "0.3.6"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f90e11ce2ca99c97b940ee83edbae9da2d56a08f9ea8158550fd77fa31722993"
+checksum = "34e9e6b6d4a2bb4e7e69433e0b35c7923b95d4dc8503a84d25ec917a4bbfdf07"
 dependencies = [
 "cc",
 "downcast-rs",
@@ -2235,9 +2221,9 @@ dependencies = [
 [[package]]
 name = "wayland-client"
-version = "0.31.5"
+version = "0.31.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e321577a0a165911bdcfb39cf029302479d7527b517ee58ab0f6ad09edf0943"
+checksum = "1e63801c85358a431f986cffa74ba9599ff571fc5774ac113ed3b490c19a1133"
 dependencies = [
 "bitflags 2.6.0",
 "rustix",
@@ -2247,9 +2233,9 @@ dependencies = [
 [[package]]
 name = "wayland-protocols"
-version = "0.32.3"
+version = "0.32.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62989625a776e827cc0f15d41444a3cea5205b963c3a25be48ae1b52d6b4daaa"
+checksum = "83d0f1056570486e26a3773ec633885124d79ae03827de05ba6c85f79904026c"
 dependencies = [
 "bitflags 2.6.0",
 "wayland-backend",
@@ -2259,9 +2245,9 @@ dependencies = [
 [[package]]
 name = "wayland-protocols-misc"
-version = "0.3.3"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfe44d48a0e51909c89da297f6b43bb814b881c78b69e254a4558a5fa8752887"
+checksum = "e76311e1866c955afbbc46ae97e57542acda1dc9b0298358263a8550b5247331"
 dependencies = [
 "bitflags 2.6.0",
 "wayland-backend",
@@ -2272,9 +2258,9 @@ dependencies = [
 [[package]]
 name = "wayland-protocols-wlr"
-version = "0.3.3"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd993de54a40a40fbe5601d9f1fbcaef0aebcc5fda447d7dc8f6dcbaae4f8953"
+checksum = "a7dab47671043d9f5397035975fe1cac639e5bca5cc0b3c32d09f01612e34d24"
 dependencies = [
 "bitflags 2.6.0",
 "wayland-backend",
@@ -2285,9 +2271,9 @@ dependencies = [
 [[package]]
 name = "wayland-scanner"
-version = "0.31.4"
+version = "0.31.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7b56f89937f1cf2ee1f1259cf2936a17a1f45d8f0aa1019fae6d470d304cfa6"
+checksum = "67da50b9f80159dec0ea4c11c13e24ef9e7574bd6ce24b01860a175010cea565"
 dependencies = [
 "proc-macro2",
 "quick-xml",
@@ -2296,9 +2282,9 @@ dependencies = [
 [[package]]
 name = "wayland-sys"
-version = "0.31.4"
+version = "0.31.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43676fe2daf68754ecf1d72026e4e6c15483198b5d24e888b74d3f22f887a148"
+checksum = "105b1842da6554f91526c14a2a2172897b7f745a805d62af4ce698706be79c12"
 dependencies = [
 "dlib",
 "log",
@@ -2340,17 +2326,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
 dependencies = [
 "windows-core 0.52.0",
- "windows-targets 0.52.6",
+ "windows-targets 0.52.5",
 ]
 [[package]]
 name = "windows"
-version = "0.58.0"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6"
+checksum = "12342cb4d8e3b046f3d80effd474a7a02447231330ef77d71daa6fbc40681143"
 dependencies = [
- "windows-core 0.58.0",
+ "windows-core 0.57.0",
- "windows-targets 0.52.6",
+ "windows-targets 0.52.5",
 ]
 [[package]]
@@ -2359,27 +2345,26 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
 dependencies = [
- "windows-targets 0.52.6",
+ "windows-targets 0.52.5",
 ]
 [[package]]
 name = "windows-core"
-version = "0.58.0"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"
+checksum = "d2ed2439a290666cd67ecce2b0ffaad89c2a56b976b736e6ece670297897832d"
 dependencies = [
 "windows-implement",
 "windows-interface",
 "windows-result",
- "windows-strings",
+ "windows-targets 0.52.5",
 "windows-targets 0.52.6",
 ]
 [[package]]
 name = "windows-implement"
-version = "0.58.0"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
+checksum = "9107ddc059d5b6fbfbffdfa7a7fe3e22a226def0b2608f72e9d552763d3e1ad7"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2388,9 +2373,9 @@ dependencies = [
 [[package]]
 name = "windows-interface"
-version = "0.58.0"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
+checksum = "29bee4b38ea3cde66011baa44dba677c432a78593e202392d1e9070cf2a7fca7"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2399,21 +2384,11 @@ dependencies = [
 [[package]]
 name = "windows-result"
-version = "0.2.0"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
+checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"
 dependencies = [
- "windows-targets 0.52.6",
+ "windows-targets 0.52.5",
 ]
 [[package]]
 name = "windows-strings"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
 dependencies = [
 "windows-result",
 "windows-targets 0.52.6",
 ]
 [[package]]
@@ -2431,7 +2406,7 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets 0.52.6",
+ "windows-targets 0.52.5",
 ]
 [[package]]
@@ -2451,18 +2426,18 @@ dependencies = [
 [[package]]
 name = "windows-targets"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_gnullvm 0.52.5",
- "windows_aarch64_msvc 0.52.6",
+ "windows_aarch64_msvc 0.52.5",
- "windows_i686_gnu 0.52.6",
+ "windows_i686_gnu 0.52.5",
 "windows_i686_gnullvm",
- "windows_i686_msvc 0.52.6",
+ "windows_i686_msvc 0.52.5",
- "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnu 0.52.5",
- "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_gnullvm 0.52.5",
- "windows_x86_64_msvc 0.52.6",
+ "windows_x86_64_msvc 0.52.5",
 ]
 [[package]]
@@ -2473,9 +2448,9 @@ checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"
 [[package]]
 name = "windows_aarch64_msvc"
@@ -2485,9 +2460,9 @@ checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"
 [[package]]
 name = "windows_i686_gnu"
@@ -2497,15 +2472,15 @@ checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
 [[package]]
 name = "windows_i686_gnu"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"
 [[package]]
 name = "windows_i686_gnullvm"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"
 [[package]]
 name = "windows_i686_msvc"
@@ -2515,9 +2490,9 @@ checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
 [[package]]
 name = "windows_i686_msvc"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"
 [[package]]
 name = "windows_x86_64_gnu"
@@ -2527,9 +2502,9 @@ checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"
 [[package]]
 name = "windows_x86_64_gnullvm"
@@ -2539,9 +2514,9 @@ checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"
 [[package]]
 name = "windows_x86_64_msvc"
@@ -2551,9 +2526,9 @@ checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"
 [[package]]
 name = "winnow"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,9 @@
 [workspace]
-members = ["input-capture", "input-emulation", "input-event"]
+members = [
    "input-capture",
    "input-emulation",
    "input-event",
 ]
 [package]
 name = "lan-mouse"
@@ -7,14 +11,14 @@ description = "Software KVM Switch / mouse & keyboard sharing software for Local
 version = "0.8.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
+repository = "https://github.com/ferdinandschober/lan-mouse"
 [profile.release]
 strip = true
 lto = "fat"
 [dependencies]
-input-event = { path = "input-event", version = "0.2.1" }
+input-event = { path = "input-event", version = "0.1.0" }
 input-emulation = { path = "input-emulation", version = "0.1.0", default-features = false }
 input-capture = { path = "input-capture", version = "0.1.0", default-features = false }
@@ -25,41 +29,27 @@ anyhow = "1.0.71"
 log = "0.4.20"
 env_logger = "0.11.3"
 serde_json = "1.0.107"
-tokio = { version = "1.32.0", features = [
+tokio = {version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "process", "rt", "sync", "signal"] }
    "io-util",
    "io-std",
    "macros",
    "net",
    "process",
    "rt",
    "sync",
    "signal",
 ] }
 futures = "0.3.28"
-clap = { version = "4.4.11", features = ["derive"] }
+clap = { version="4.4.11", features = ["derive"] }
-gtk = { package = "gtk4", version = "0.9.0", features = [
+gtk = { package = "gtk4", version = "0.8.1", features = ["v4_2"], optional = true }
-    "v4_2",
+adw = { package = "libadwaita", version = "0.6.0", features = ["v1_1"], optional = true }
 ], optional = true }
 adw = { package = "libadwaita", version = "0.7.0", features = [
    "v1_1",
 ], optional = true }
 async-channel = { version = "2.1.1", optional = true }
 hostname = "0.4.0"
 slab = "0.4.9"
 endi = "1.1.0"
 thiserror = "1.0.61"
 tokio-util = "0.7.11"
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.148"
 [build-dependencies]
-glib-build-tools = { version = "0.20.0", optional = true }
+glib-build-tools = { version = "0.19.0", optional = true }
 [features]
-default = ["wayland", "x11", "xdg_desktop_portal", "libei", "gtk"]
+default = [ "wayland", "x11", "xdg_desktop_portal", "libei", "gtk" ]
-wayland = ["input-capture/wayland", "input-emulation/wayland"]
+wayland = [ "input-capture/wayland", "input-emulation/wayland" ]
-x11 = ["input-capture/x11", "input-emulation/x11"]
+x11 = [ "input-capture/x11", "input-emulation/x11" ]
-xdg_desktop_portal = ["input-emulation/xdg_desktop_portal"]
+xdg_desktop_portal = [ "input-emulation/xdg_desktop_portal" ]
-libei = ["input-event/libei", "input-capture/libei", "input-emulation/libei"]
+libei = [ "input-capture/libei", "input-emulation/libei" ]
 gtk = ["dep:gtk", "dep:adw", "dep:async-channel", "dep:glib-build-tools"]
--- a/README.md
+++ b/README.md
@@ -57,10 +57,6 @@ input capture (to send events *to* other clients) on different operating systems
 > If you are using [Wayfire](https://github.com/WayfireWM/wayfire), make sure to use a recent version (must be newer than October 23rd) and **add `shortcuts-inhibit` to the list of plugins in your wayfire config!**
 > Otherwise input capture will not work.
 > [!Important]
 > The mouse cursor will be invisible when sending input to a Windows system if
 > there is no real mouse connected to the machine.
 ## Installation
 ### Install via cargo
 ```sh
--- a/flake.nix
+++ b/flake.nix
@@ -16,7 +16,6 @@
    inherit (nixpkgs) lib;
    genSystems = lib.genAttrs [
      "aarch64-darwin"
      "aarch64-linux"
      "x86_64-darwin"
      "x86_64-linux"
    ];
@@ -51,7 +50,6 @@
          xorg.libX11
          gtk4
          libadwaita
          librsvg
          xorg.libXtst
        ] ++ lib.optionals stdenv.isDarwin [
          darwin.apple_sdk_11_0.frameworks.CoreGraphics
--- a/input-capture/Cargo.toml
+++ b/input-capture/Cargo.toml
@@ -4,52 +4,34 @@ description = "cross-platform input-capture library used by lan-mouse"
 version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
+repository = "https://github.com/ferdinandschober/lan-mouse"
 [dependencies]
 anyhow = "1.0.86"
 futures = "0.3.28"
 futures-core = "0.3.30"
 log = "0.4.22"
-input-event = { path = "../input-event", version = "0.2.1" }
+input-event = { path = "../input-event", version = "0.1.0" }
 memmap = "0.7"
 tempfile = "3.8"
 thiserror = "1.0.61"
-tokio = { version = "1.32.0", features = [
+tokio = { version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "process", "rt", "sync", "signal"] }
    "io-util",
    "io-std",
    "macros",
    "net",
    "process",
    "rt",
    "sync",
    "signal",
 ] }
 once_cell = "1.19.0"
 async-trait = "0.1.81"
 tokio-util = "0.7.11"
 [target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
-wayland-client = { version = "0.31.1", optional = true }
+wayland-client = { version="0.31.1", optional = true }
-wayland-protocols = { version = "0.32.1", features = [
+wayland-protocols = { version="0.32.1", features=["client", "staging", "unstable"], optional = true }
-    "client",
+wayland-protocols-wlr = { version="0.3.1", features=["client"], optional = true }
    "staging",
    "unstable",
 ], optional = true }
 wayland-protocols-wlr = { version = "0.3.1", features = [
    "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.9", default-features = false, features = [
+ashpd = { version = "0.8", default-features = false, features = ["tokio"], optional = true }
-    "tokio",
+reis = { version = "0.2", features = [ "tokio" ], optional = true }
 ], optional = true }
 reis = { version = "0.2", features = ["tokio"], optional = true }
 [target.'cfg(target_os="macos")'.dependencies]
 core-graphics = { version = "0.23", features = ["highsierra"] }
 [target.'cfg(windows)'.dependencies]
-windows = { version = "0.58.0", features = [
+windows = {  version = "0.57.0", features = [
    "Win32_System_LibraryLoader",
    "Win32_System_Threading",
    "Win32_Foundation",
@@ -61,10 +43,6 @@ windows = { version = "0.58.0", features = [
 [features]
 default = ["wayland", "x11", "libei"]
-wayland = [
+wayland = ["dep:wayland-client", "dep:wayland-protocols", "dep:wayland-protocols-wlr" ]
    "dep:wayland-client",
    "dep:wayland-protocols",
    "dep:wayland-protocols-wlr",
 ]
 x11 = ["dep:x11"]
 libei = ["dep:reis", "dep:ashpd"]
--- a/input-capture/src/dummy.rs
+++ b/input-capture/src/dummy.rs
@@ -1,13 +1,11 @@
 use std::io;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use async_trait::async_trait;
 use futures_core::Stream;
 use input_event::Event;
 use crate::CaptureError;
 use super::{CaptureHandle, InputCapture, Position};
 pub struct DummyInputCapture {}
@@ -24,27 +22,22 @@ impl Default for DummyInputCapture {
    }
 }
 #[async_trait]
 impl InputCapture for DummyInputCapture {
-    async fn create(&mut self, _handle: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
+    fn create(&mut self, _handle: CaptureHandle, _pos: Position) -> io::Result<()> {
        Ok(())
    }
-    async fn destroy(&mut self, _handle: CaptureHandle) -> Result<(), CaptureError> {
+    fn destroy(&mut self, _handle: CaptureHandle) -> io::Result<()> {
        Ok(())
    }
-    async fn release(&mut self) -> Result<(), CaptureError> {
+    fn release(&mut self) -> io::Result<()> {
        Ok(())
    }
    async fn terminate(&mut self) -> Result<(), CaptureError> {
        Ok(())
    }
 }
 impl Stream for DummyInputCapture {
-    type Item = Result<(CaptureHandle, Event), CaptureError>;
+    type Item = io::Result<(CaptureHandle, Event)>;
    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        Poll::Pending
--- a/input-capture/src/error.rs
+++ b/input-capture/src/error.rs
@@ -1,13 +1,6 @@
 use std::fmt::Display;
 use thiserror::Error;
 #[derive(Debug, Error)]
 pub enum InputCaptureError {
    #[error("error creating input-capture: `{0}`")]
    Create(#[from] CaptureCreationError),
    #[error("error while capturing input: `{0}`")]
    Capture(#[from] CaptureError),
 }
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 use std::io;
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
@@ -17,100 +10,65 @@ use wayland_client::{
    ConnectError, DispatchError,
 };
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use ashpd::desktop::ResponseError;
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use reis::tokio::{EiConvertEventStreamError, HandshakeError};
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 #[error("error in libei stream: {inner:?}")]
 pub struct ReisConvertEventStreamError {
    inner: EiConvertEventStreamError,
 }
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 impl From<EiConvertEventStreamError> for ReisConvertEventStreamError {
    fn from(e: EiConvertEventStreamError) -> Self {
        Self { inner: e }
    }
 }
 #[derive(Debug, Error)]
 pub enum CaptureError {
    #[error("activation stream closed unexpectedly")]
    ActivationClosed,
    #[error("libei stream was closed")]
    EndOfStream,
    #[error("io error: `{0}`")]
    Io(#[from] std::io::Error),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error("error in libei stream: `{0}`")]
    Reis(#[from] ReisConvertEventStreamError),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error("libei handshake failed: `{0}`")]
    Handshake(#[from] HandshakeError),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error(transparent)]
    Portal(#[from] ashpd::Error),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error("libei disconnected - reason: `{0}`")]
    Disconnected(String),
 }
 #[derive(Debug, Error)]
 pub enum CaptureCreationError {
    #[error("no backend available")]
    NoAvailableBackend,
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error("error creating input-capture-portal backend: `{0}`")]
    Libei(#[from] LibeiCaptureCreationError),
    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    #[error("error creating layer-shell capture backend: `{0}`")]
    LayerShell(#[from] LayerShellCaptureCreationError),
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
    #[error("error creating x11 capture backend: `{0}`")]
    X11(#[from] X11InputCaptureCreationError),
    #[cfg(target_os = "macos")]
    #[error("error creating macos capture backend: `{0}`")]
    Macos(#[from] MacOSInputCaptureCreationError),
    #[cfg(windows)]
    #[error("error creating windows capture backend")]
    Windows,
 }
-impl CaptureCreationError {
+impl Display for CaptureCreationError {
-    /// request was intentionally denied by the user
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        let reason = match self {
-    pub(crate) fn cancelled_by_user(&self) -> bool {
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-        matches!(
+            CaptureCreationError::Libei(reason) => {
-            self,
+                format!("error creating portal backend: {reason}")
-            CaptureCreationError::Libei(LibeiCaptureCreationError::Ashpd(ashpd::Error::Response(
+            }
-                ResponseError::Cancelled
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-            )))
+            CaptureCreationError::LayerShell(reason) => {
-        )
+                format!("error creating layer-shell backend: {reason}")
-    }
+            }
-    #[cfg(not(all(unix, feature = "libei", not(target_os = "macos"))))]
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-    pub(crate) fn cancelled_by_user(&self) -> bool {
+            CaptureCreationError::X11(e) => format!("{e}"),
-        false
+            #[cfg(target_os = "macos")]
            CaptureCreationError::Macos(e) => format!("{e}"),
            #[cfg(windows)]
            CaptureCreationError::Windows => String::new(),
            CaptureCreationError::NoAvailableBackend => "no available backend".to_string(),
        };
        write!(f, "could not create input capture: {reason}")
    }
 }
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum LibeiCaptureCreationError {
    #[error("xdg-desktop-portal: `{0}`")]
    Ashpd(#[from] ashpd::Error),
 }
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 impl Display for LibeiCaptureCreationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            LibeiCaptureCreationError::Ashpd(portal_error) => write!(f, "{portal_error}"),
        }
    }
 }
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 #[error("{protocol} protocol not supported: {inner}")]
 pub struct WaylandBindError {
    inner: BindError,
    protocol: &'static str,
 }
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 impl WaylandBindError {
    pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
@@ -118,33 +76,67 @@ impl WaylandBindError {
    }
 }
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 impl Display for WaylandBindError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{} protocol not supported: {}",
            self.protocol, self.inner
        )
    }
 }
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum LayerShellCaptureCreationError {
    #[error(transparent)]
    Connect(#[from] ConnectError),
    #[error(transparent)]
    Global(#[from] GlobalError),
    #[error(transparent)]
    Wayland(#[from] WaylandError),
    #[error(transparent)]
    Bind(#[from] WaylandBindError),
    #[error(transparent)]
    Dispatch(#[from] DispatchError),
    #[error(transparent)]
    Io(#[from] io::Error),
 }
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 impl Display for LayerShellCaptureCreationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            LayerShellCaptureCreationError::Bind(e) => write!(f, "{e}"),
            LayerShellCaptureCreationError::Connect(e) => {
                write!(f, "could not connect to wayland compositor: {e}")
            }
            LayerShellCaptureCreationError::Global(e) => write!(f, "wayland error: {e}"),
            LayerShellCaptureCreationError::Wayland(e) => write!(f, "wayland error: {e}"),
            LayerShellCaptureCreationError::Dispatch(e) => {
                write!(f, "error dispatching wayland events: {e}")
            }
            LayerShellCaptureCreationError::Io(e) => write!(f, "io error: {e}"),
        }
    }
 }
 #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum X11InputCaptureCreationError {
-    #[error("X11 input capture is not yet implemented :(")]
+    NotImplemented,
 }
 #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
 impl Display for X11InputCaptureCreationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "X11 input capture is not yet implemented :(")
    }
 }
 #[cfg(target_os = "macos")]
 #[derive(Debug, Error)]
 pub enum MacOSInputCaptureCreationError {
    NotImplemented,
 }
 #[cfg(target_os = "macos")]
-#[derive(Debug, Error)]
+impl Display for MacOSInputCaptureCreationError {
-pub enum MacOSInputCaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    #[error("MacOS input capture is not yet implemented :(")]
+        write!(f, "macos input capture is not yet implemented :(")
-    NotImplemented,
+    }
 }
--- a/input-capture/src/lib.rs
+++ b/input-capture/src/lib.rs
@@ -1,11 +1,10 @@
-use std::fmt::Display;
+use std::{fmt::Display, io};
 use async_trait::async_trait;
 use futures_core::Stream;
 use input_event::Event;
-pub use error::{CaptureCreationError, CaptureError, InputCaptureError};
+use self::error::CaptureCreationError;
 pub mod error;
@@ -93,29 +92,21 @@ impl Display for Backend {
    }
 }
-#[async_trait]
+pub trait InputCapture: Stream<Item = io::Result<(CaptureHandle, Event)>> + Unpin {
 pub trait InputCapture:
    Stream<Item = Result<(CaptureHandle, Event), CaptureError>> + Unpin
 {
    /// create a new client with the given id
-    async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError>;
+    fn create(&mut self, id: CaptureHandle, pos: Position) -> io::Result<()>;
    /// destroy the client with the given id, if it exists
-    async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError>;
+    fn destroy(&mut self, id: CaptureHandle) -> io::Result<()>;
    /// release mouse
-    async fn release(&mut self) -> Result<(), CaptureError>;
+    fn release(&mut self) -> io::Result<()>;
    /// destroy the input capture
    async fn terminate(&mut self) -> Result<(), CaptureError>;
 }
 pub async fn create_backend(
    backend: Backend,
-) -> Result<
+) -> Result<Box<dyn InputCapture<Item = io::Result<(CaptureHandle, Event)>>>, CaptureCreationError>
-    Box<dyn InputCapture<Item = Result<(CaptureHandle, Event), CaptureError>>>,
+{
    CaptureCreationError,
 > {
    match backend {
        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
        Backend::InputCapturePortal => Ok(Box::new(libei::LibeiInputCapture::new().await?)),
@@ -133,10 +124,8 @@ pub async fn create_backend(
 pub async fn create(
    backend: Option<Backend>,
-) -> Result<
+) -> Result<Box<dyn InputCapture<Item = io::Result<(CaptureHandle, Event)>>>, CaptureCreationError>
-    Box<dyn InputCapture<Item = Result<(CaptureHandle, Event), CaptureError>>>,
+{
    CaptureCreationError,
 > {
    if let Some(backend) = backend {
        let b = create_backend(backend).await;
        if b.is_ok() {
@@ -156,13 +145,13 @@ pub async fn create(
        Backend::Windows,
        #[cfg(target_os = "macos")]
        Backend::MacOs,
        Backend::Dummy,
    ] {
        match create_backend(backend).await {
            Ok(b) => {
                log::info!("using capture backend: {backend}");
                return Ok(b);
            }
            Err(e) if e.cancelled_by_user() => return Err(e),
            Err(e) => log::warn!("{backend} input capture backend unavailable: {e}"),
        }
    }
--- a/input-capture/src/libei.rs
+++ b/input-capture/src/libei.rs
@@ -1,14 +1,15 @@
 use anyhow::{anyhow, Result};
 use ashpd::{
    desktop::{
        input_capture::{Activated, Barrier, BarrierID, Capabilities, InputCapture, Region, Zones},
-        Session,
+        ResponseError, Session,
    },
    enumflags2::BitFlags,
 };
-use async_trait::async_trait;
+use futures::StreamExt;
 use futures::{FutureExt, StreamExt};
 use reis::{
-    ei,
+    ei::{self, keyboard::KeyState},
    eis::button::ButtonState,
    event::{DeviceCapability, EiEvent},
    tokio::{EiConvertEventStream, EiEventStream},
 };
@@ -19,35 +20,25 @@ use std::{
    os::unix::net::UnixStream,
    pin::Pin,
    rc::Rc,
-    sync::Arc,
+    task::{ready, Context, Poll},
    task::{Context, Poll},
 };
 use tokio::{
-    sync::{
+    sync::mpsc::{Receiver, Sender},
        mpsc::{self, Receiver, Sender},
        Notify,
    },
    task::JoinHandle,
 };
 use tokio_util::sync::CancellationToken;
 use futures_core::Stream;
 use once_cell::sync::Lazy;
-use input_event::Event;
+use input_event::{Event, KeyboardEvent, PointerEvent};
 use super::{
-    error::{CaptureError, LibeiCaptureCreationError, ReisConvertEventStreamError},
+    error::LibeiCaptureCreationError, CaptureHandle, InputCapture as LanMouseInputCapture, Position,
    CaptureHandle, InputCapture as LanMouseInputCapture, Position,
 };
-/* there is a bug in xdg-remote-desktop-portal-gnome / mutter that
+#[derive(Debug)]
- * prevents receiving further events after a session has been disabled once.
+enum ProducerEvent {
- * Therefore the session needs to be recreated when the barriers are updated */
+    Release,
 /// events that necessitate restarting the capture session
 #[derive(Clone, Copy, Debug)]
 enum LibeiNotifyEvent {
    Create(CaptureHandle, Position),
    Destroy(CaptureHandle),
 }
@@ -55,12 +46,9 @@ enum LibeiNotifyEvent {
 #[allow(dead_code)]
 pub struct LibeiInputCapture<'a> {
    input_capture: Pin<Box<InputCapture<'a>>>,
-    capture_task: JoinHandle<Result<(), CaptureError>>,
+    libei_task: JoinHandle<Result<()>>,
-    event_rx: Receiver<(CaptureHandle, Event)>,
+    event_rx: tokio::sync::mpsc::Receiver<(CaptureHandle, Event)>,
-    notify_capture: Sender<LibeiNotifyEvent>,
+    notify_tx: tokio::sync::mpsc::Sender<ProducerEvent>,
    notify_release: Arc<Notify>,
    cancellation_token: CancellationToken,
    terminated: bool,
 }
 static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
@@ -79,47 +67,24 @@ static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
    m
 });
 /// returns (start pos, end pos), inclusive
 fn pos_to_barrier(r: &Region, pos: Position) -> (i32, i32, i32, i32) {
    let (x, y) = (r.x_offset(), r.y_offset());
-    let (w, h) = (r.width() as i32, r.height() as i32);
+    let (width, height) = (r.width() as i32, r.height() as i32);
    match pos {
-        Position::Left => (x, y, x, y + h - 1),
+        Position::Left => (x, y, x, y + height - 1), // start pos, end pos, inclusive
-        Position::Right => (x + w, y, x + w, y + h - 1),
+        Position::Right => (x + width, y, x + width, y + height - 1),
-        Position::Top => (x, y, x + w - 1, y),
+        Position::Top => (x, y, x + width - 1, y),
-        Position::Bottom => (x, y + h, x + w - 1, y + h),
+        Position::Bottom => (x, y + height, x + width - 1, y + height),
    }
 }
 /// Ashpd does not expose fields
 #[derive(Clone, Copy, Debug)]
 struct ICBarrier {
    barrier_id: BarrierID,
    position: (i32, i32, i32, i32),
 }
 impl ICBarrier {
    fn new(barrier_id: BarrierID, position: (i32, i32, i32, i32)) -> Self {
        Self {
            barrier_id,
            position,
        }
    }
 }
 impl From<ICBarrier> for Barrier {
    fn from(barrier: ICBarrier) -> Self {
        Barrier::new(barrier.barrier_id, barrier.position)
    }
 }
 fn select_barriers(
    zones: &Zones,
-    clients: &[(CaptureHandle, Position)],
+    clients: &Vec<(CaptureHandle, Position)>,
    next_barrier_id: &mut u32,
-) -> (Vec<ICBarrier>, HashMap<BarrierID, CaptureHandle>) {
+) -> (Vec<Barrier>, HashMap<BarrierID, CaptureHandle>) {
    let mut client_for_barrier = HashMap::new();
-    let mut barriers: Vec<ICBarrier> = vec![];
+    let mut barriers: Vec<Barrier> = vec![];
    for (handle, pos) in clients {
        let mut client_barriers = zones
@@ -130,7 +95,7 @@ fn select_barriers(
                *next_barrier_id = id + 1;
                let position = pos_to_barrier(r, *pos);
                client_for_barrier.insert(id, *handle);
-                ICBarrier::new(id, position)
+                Barrier::new(id, position)
            })
            .collect();
        barriers.append(&mut client_barriers);
@@ -140,10 +105,10 @@ fn select_barriers(
 async fn update_barriers(
    input_capture: &InputCapture<'_>,
-    session: &Session<'_, InputCapture<'_>>,
+    session: &Session<'_>,
-    active_clients: &[(CaptureHandle, Position)],
+    active_clients: &Vec<(CaptureHandle, Position)>,
    next_barrier_id: &mut u32,
-) -> Result<(Vec<ICBarrier>, HashMap<BarrierID, CaptureHandle>), ashpd::Error> {
+) -> Result<HashMap<BarrierID, CaptureHandle>> {
    let zones = input_capture.zones(session).await?.response()?;
    log::debug!("zones: {zones:?}");
@@ -151,31 +116,45 @@ async fn update_barriers(
    log::debug!("barriers: {barriers:?}");
    log::debug!("client for barrier id: {id_map:?}");
    let ashpd_barriers: Vec<Barrier> = barriers.iter().copied().map(|b| b.into()).collect();
    let response = input_capture
-        .set_pointer_barriers(session, &ashpd_barriers, zones.zone_set())
+        .set_pointer_barriers(session, &barriers, zones.zone_set())
        .await?;
    let response = response.response()?;
    log::debug!("{response:?}");
-    Ok((barriers, id_map))
+    Ok(id_map)
 }
 impl<'a> Drop for LibeiInputCapture<'a> {
    fn drop(&mut self) {
        self.libei_task.abort();
    }
 }
 async fn create_session<'a>(
    input_capture: &'a InputCapture<'a>,
-) -> std::result::Result<(Session<'_, InputCapture<'_>>, BitFlags<Capabilities>), ashpd::Error> {
+) -> std::result::Result<(Session<'a>, BitFlags<Capabilities>), ashpd::Error> {
    log::debug!("creating input capture session");
-    input_capture
+    let (session, capabilities) = loop {
-        .create_session(
+        match input_capture
-            &ashpd::WindowIdentifier::default(),
+            .create_session(
-            Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
+                &ashpd::WindowIdentifier::default(),
-        )
+                Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
-        .await
+            )
            .await
        {
            Ok(s) => break s,
            Err(ashpd::Error::Response(ResponseError::Cancelled)) => continue,
            o => o?,
        };
    };
    log::debug!("capabilities: {capabilities:?}");
    Ok((session, capabilities))
 }
 async fn connect_to_eis(
    input_capture: &InputCapture<'_>,
-    session: &Session<'_, InputCapture<'_>>,
+    session: &Session<'_>,
-) -> Result<(ei::Context, EiConvertEventStream), CaptureError> {
+) -> Result<(ei::Context, EiConvertEventStream)> {
    log::debug!("connect_to_eis");
    let fd = input_capture.connect_to_eis(session).await?;
@@ -186,13 +165,17 @@ async fn connect_to_eis(
    // create ei context
    let context = ei::Context::new(stream)?;
    let mut event_stream = EiEventStream::new(context.clone())?;
-    let response = reis::tokio::ei_handshake(
+    let response = match reis::tokio::ei_handshake(
        &mut event_stream,
        "de.feschber.LanMouse",
        ei::handshake::ContextType::Receiver,
        &INTERFACES,
    )
-    .await?;
+    .await
    {
        Ok(res) => res,
        Err(e) => return Err(anyhow!("ei handshake failed: {e:?}")),
    };
    let event_stream = EiConvertEventStream::new(event_stream, response.serial);
    Ok((context, event_stream))
@@ -202,296 +185,174 @@ async fn libei_event_handler(
    mut ei_event_stream: EiConvertEventStream,
    context: ei::Context,
    event_tx: Sender<(CaptureHandle, Event)>,
    release_session: Arc<Notify>,
    current_client: Rc<Cell<Option<CaptureHandle>>>,
-) -> Result<(), CaptureError> {
+) -> Result<()> {
    loop {
-        let ei_event = ei_event_stream
+        let ei_event = match ei_event_stream.next().await {
-            .next()
+            Some(Ok(event)) => event,
-            .await
+            Some(Err(e)) => return Err(anyhow!("libei connection closed: {e:?}")),
-            .ok_or(CaptureError::EndOfStream)?
+            None => return Err(anyhow!("libei connection closed")),
-            .map_err(ReisConvertEventStreamError::from)?;
+        };
        log::trace!("from ei: {ei_event:?}");
        let client = current_client.get();
-        handle_ei_event(ei_event, client, &context, &event_tx, &release_session).await?;
+        handle_ei_event(ei_event, client, &context, &event_tx).await;
    }
 }
 async fn wait_for_active_client(
    notify_rx: &mut Receiver<ProducerEvent>,
    active_clients: &mut Vec<(CaptureHandle, Position)>,
 ) -> Result<()> {
    // wait for a client update
    while let Some(producer_event) = notify_rx.recv().await {
        if let ProducerEvent::Create(c, p) = producer_event {
            handle_producer_event(ProducerEvent::Create(c, p), active_clients)?;
            break;
        }
    }
    Ok(())
 }
 impl<'a> LibeiInputCapture<'a> {
    pub async fn new() -> std::result::Result<Self, LibeiCaptureCreationError> {
        let input_capture = Box::pin(InputCapture::new().await?);
        let input_capture_ptr = input_capture.as_ref().get_ref() as *const InputCapture<'static>;
-        let first_session = Some(create_session(unsafe { &*input_capture_ptr }).await?);
+        let mut first_session = Some(create_session(unsafe { &*input_capture_ptr }).await?);
-        let (event_tx, event_rx) = mpsc::channel(1);
+        let (event_tx, event_rx) = tokio::sync::mpsc::channel(32);
-        let (notify_capture, notify_rx) = mpsc::channel(1);
+        let (notify_tx, mut notify_rx) = tokio::sync::mpsc::channel(32);
-        let notify_release = Arc::new(Notify::new());
+        let libei_task = tokio::task::spawn_local(async move {
            /* safety: libei_task does not outlive Self */
            let input_capture = unsafe { &*input_capture_ptr };
-        let cancellation_token = CancellationToken::new();
+            let mut active_clients: Vec<(CaptureHandle, Position)> = vec![];
            let mut next_barrier_id = 1u32;
-        let capture = do_capture(
+            /* there is a bug in xdg-remote-desktop-portal-gnome / mutter that
-            input_capture_ptr,
+             * prevents receiving further events after a session has been disabled once.
-            notify_rx,
+             * Therefore the session needs to recreated when the barriers are updated */
-            notify_release.clone(),
+
-            first_session,
+            loop {
-            event_tx,
+                // otherwise it asks to capture input even with no active clients
-            cancellation_token.clone(),
+                if active_clients.is_empty() {
-        );
+                    wait_for_active_client(&mut notify_rx, &mut active_clients).await?;
-        let capture_task = tokio::task::spawn_local(capture);
+                    continue;
                }
                let current_client = Rc::new(Cell::new(None));
                // create session
                let (session, _) = match first_session.take() {
                    Some(s) => s,
                    _ => create_session(input_capture).await?,
                };
                // connect to eis server
                let (context, ei_event_stream) = connect_to_eis(input_capture, &session).await?;
                // async event task
                let mut ei_task: JoinHandle<Result<(), anyhow::Error>> =
                    tokio::task::spawn_local(libei_event_handler(
                        ei_event_stream,
                        context,
                        event_tx.clone(),
                        current_client.clone(),
                    ));
                let mut activated = input_capture.receive_activated().await?;
                let mut zones_changed = input_capture.receive_zones_changed().await?;
                // set barriers
                let client_for_barrier_id = update_barriers(
                    input_capture,
                    &session,
                    &active_clients,
                    &mut next_barrier_id,
                )
                .await?;
                log::debug!("enabling session");
                input_capture.enable(&session).await?;
                loop {
                    tokio::select! {
                        activated = activated.next() => {
                            let activated = activated.ok_or(anyhow!("error receiving activation token"))?;
                            log::debug!("activated: {activated:?}");
                            let client = *client_for_barrier_id
                                .get(&activated.barrier_id())
                                .expect("invalid barrier id");
                            current_client.replace(Some(client));
                            event_tx.send((client, Event::Enter())).await?;
                            tokio::select! {
                                producer_event = notify_rx.recv() => {
                                    let producer_event = producer_event.expect("channel closed");
                                    if handle_producer_event(producer_event, &mut active_clients)? {
                                        break; /* clients updated */
                                    }
                                }
                                zones_changed = zones_changed.next() => {
                                    log::debug!("zones changed: {zones_changed:?}");
                                    break;
                                }
                                res = &mut ei_task => {
                                    if let Err(e) = res.expect("ei task paniced") {
                                        log::warn!("libei task exited: {e}");
                                    }
                                    break;
                                }
                            }
                            release_capture(
                                input_capture,
                                &session,
                                activated,
                                client,
                                &active_clients,
                            ).await?;
                        }
                        producer_event = notify_rx.recv() => {
                            let producer_event = producer_event.expect("channel closed");
                            if handle_producer_event(producer_event, &mut active_clients)? {
                                /* clients updated */
                                break;
                            }
                        },
                        res = &mut ei_task => {
                            if let Err(e) = res.expect("ei task paniced") {
                                log::warn!("libei task exited: {e}");
                            }
                            break;
                        }
                    }
                }
                ei_task.abort();
                input_capture.disable(&session).await?;
            }
        });
        let producer = Self {
            input_capture,
            event_rx,
-            capture_task,
+            libei_task,
-            notify_capture,
+            notify_tx,
            notify_release,
            cancellation_token,
            terminated: false,
        };
        Ok(producer)
    }
 }
-async fn do_capture(
+async fn release_capture(
    input_capture: *const InputCapture<'static>,
    mut capture_event: Receiver<LibeiNotifyEvent>,
    notify_release: Arc<Notify>,
    session: Option<(Session<'_, InputCapture<'_>>, BitFlags<Capabilities>)>,
    event_tx: Sender<(CaptureHandle, Event)>,
    cancellation_token: CancellationToken,
 ) -> Result<(), CaptureError> {
    let mut session = session.map(|s| s.0);
    /* safety: libei_task does not outlive Self */
    let input_capture = unsafe { &*input_capture };
    let mut active_clients: Vec<(CaptureHandle, Position)> = vec![];
    let mut next_barrier_id = 1u32;
    let mut zones_changed = input_capture.receive_zones_changed().await?;
    loop {
        // do capture session
        let cancel_session = CancellationToken::new();
        let cancel_update = CancellationToken::new();
        let mut capture_event_occured: Option<LibeiNotifyEvent> = None;
        let mut zones_have_changed = false;
        // kill session if clients need to be updated
        let handle_session_update_request = async {
            tokio::select! {
                _ = cancellation_token.cancelled() => {
                    log::debug!("cancelled")
                }, /* exit requested */
                _ = cancel_update.cancelled() => {
                    log::debug!("update task cancelled");
                }, /* session exited */
                _ = zones_changed.next() => {
                    log::debug!("zones changed!");
                    zones_have_changed = true
                }, /* zones have changed */
                e = capture_event.recv() => if let Some(e) = e { /* clients changed */
                    log::debug!("capture event: {e:?}");
                    capture_event_occured.replace(e);
                },
            }
            // kill session (might already be dead!)
            log::debug!("=> cancelling session");
            cancel_session.cancel();
        };
        if !active_clients.is_empty() {
            // create session
            let mut session = match session.take() {
                Some(s) => s,
                None => create_session(input_capture).await?.0,
            };
            let capture_session = do_capture_session(
                input_capture,
                &mut session,
                &event_tx,
                &active_clients,
                &mut next_barrier_id,
                &notify_release,
                (cancel_session.clone(), cancel_update.clone()),
            );
            let (capture_result, ()) = tokio::join!(capture_session, handle_session_update_request);
            log::debug!("capture session + session_update task done!");
            // disable capture
            log::debug!("disabling input capture");
            if let Err(e) = input_capture.disable(&session).await {
                log::warn!("input_capture.disable(&session) {e}");
            }
            if let Err(e) = session.close().await {
                log::warn!("session.close(): {e}");
            }
            // propagate error from capture session
            capture_result?;
        } else {
            handle_session_update_request.await;
        }
        // update clients if requested
        if let Some(event) = capture_event_occured.take() {
            match event {
                LibeiNotifyEvent::Create(c, p) => active_clients.push((c, p)),
                LibeiNotifyEvent::Destroy(c) => active_clients.retain(|(h, _)| *h != c),
            }
        }
        // break
        if cancellation_token.is_cancelled() {
            break Ok(());
        }
    }
 }
 async fn do_capture_session(
    input_capture: &InputCapture<'_>,
-    session: &mut Session<'_, InputCapture<'_>>,
+    session: &Session<'_>,
    event_tx: &Sender<(CaptureHandle, Event)>,
    active_clients: &[(CaptureHandle, Position)],
    next_barrier_id: &mut u32,
    notify_release: &Notify,
    cancel: (CancellationToken, CancellationToken),
 ) -> Result<(), CaptureError> {
    let (cancel_session, cancel_update) = cancel;
    // current client
    let current_client = Rc::new(Cell::new(None));
    // connect to eis server
    let (context, ei_event_stream) = connect_to_eis(input_capture, session).await?;
    // set barriers
    let (barriers, client_for_barrier_id) =
        update_barriers(input_capture, session, active_clients, next_barrier_id).await?;
    log::debug!("enabling session");
    input_capture.enable(session).await?;
    // cancellation token to release session
    let release_session = Arc::new(Notify::new());
    // async event task
    let cancel_ei_handler = CancellationToken::new();
    let event_chan = event_tx.clone();
    let client = current_client.clone();
    let cancel_session_clone = cancel_session.clone();
    let release_session_clone = release_session.clone();
    let cancel_ei_handler_clone = cancel_ei_handler.clone();
    let ei_task = async move {
        tokio::select! {
            r = libei_event_handler(
                ei_event_stream,
                context,
                event_chan,
                release_session_clone,
                client,
            ) => {
                log::debug!("libei exited: {r:?} cancelling session task");
                cancel_session_clone.cancel();
            }
            _ = cancel_ei_handler_clone.cancelled() => {},
        }
        Ok::<(), CaptureError>(())
    };
    let capture_session_task = async {
        // receiver for activation tokens
        let mut activated = input_capture.receive_activated().await?;
        let mut ei_devices_changed = false;
        loop {
            tokio::select! {
                activated = activated.next() => {
                    let activated = activated.ok_or(CaptureError::ActivationClosed)?;
                    log::debug!("activated: {activated:?}");
                    // get barrier id from activation
                    let barrier_id = match activated.barrier_id() {
                        Some(bid) => bid,
                        // workaround for KDE plasma not reporting barrier ids
                        None => find_corresponding_client(&barriers, activated.cursor_position().expect("no cursor position reported by compositor")),
                    };
                    // find client corresponding to barrier
                    let client = *client_for_barrier_id.get(&barrier_id).expect("invalid barrier id");
                    current_client.replace(Some(client));
                    // client entered => send event
                    event_tx.send((client, Event::Enter())).await.expect("no channel");
                    tokio::select! {
                        _ = notify_release.notified() => { /* capture release */
                            log::debug!("release session requested");
                        },
                        _ = release_session.notified() => { /* release session */
                            log::debug!("ei devices changed");
                            ei_devices_changed = true;
                        },
                        _ = cancel_session.cancelled() => { /* kill session notify */
                            log::debug!("session cancel requested");
                            break
                        },
                    }
                    release_capture(input_capture, session, activated, client, active_clients).await?;
                }
                _ = notify_release.notified() => { /* capture release -> we are not capturing anyway, so ignore */
                    log::debug!("release session requested");
                },
                _ = release_session.notified() => { /* release session */
                    log::debug!("ei devices changed");
                    ei_devices_changed = true;
                },
                _ = cancel_session.cancelled() => { /* kill session notify */
                    log::debug!("session cancel requested");
                    break
                },
            }
            if ei_devices_changed {
                /* for whatever reason, GNOME seems to kill the session
                 * as soon as devices are added or removed, so we need
                 * to cancel */
                break;
            }
        }
        // cancel libei task
        log::debug!("session exited: killing libei task");
        cancel_ei_handler.cancel();
        Ok::<(), CaptureError>(())
    };
    let (a, b) = tokio::join!(ei_task, capture_session_task);
    cancel_update.cancel();
    log::debug!("both session and ei task finished!");
    a?;
    b?;
    Ok(())
 }
 async fn release_capture<'a>(
    input_capture: &InputCapture<'a>,
    session: &Session<'a, InputCapture<'a>>,
    activated: Activated,
    current_client: CaptureHandle,
    active_clients: &[(CaptureHandle, Position)],
-) -> Result<(), CaptureError> {
+) -> Result<()> {
-    if let Some(activation_id) = activated.activation_id() {
+    log::debug!("releasing input capture {}", activated.activation_id());
-        log::debug!("releasing input capture {activation_id}");
+    let (x, y) = activated.cursor_position();
    }
    let (x, y) = activated
        .cursor_position()
        .expect("compositor did not report cursor position!");
    log::debug!("client entered @ ({x}, {y})");
    let pos = active_clients
        .iter()
        .filter(|(c, _)| *c == current_client)
@@ -508,134 +369,215 @@ async fn release_capture<'a>(
    // release 1px to the right of the entered zone
    let cursor_position = (x as f64 + dx, y as f64 + dy);
    input_capture
-        .release(session, activated.activation_id(), Some(cursor_position))
+        .release(session, activated.activation_id(), cursor_position)
        .await?;
    Ok(())
 }
-fn find_corresponding_client(barriers: &[ICBarrier], pos: (f32, f32)) -> BarrierID {
+fn handle_producer_event(
-    barriers
+    producer_event: ProducerEvent,
-        .iter()
+    active_clients: &mut Vec<(CaptureHandle, Position)>,
-        .copied()
+) -> Result<bool> {
-        .min_by_key(|b| {
+    log::debug!("handling event: {producer_event:?}");
-            let (x1, y1, x2, y2) = b.position;
+    let updated = match producer_event {
-            let (x1, y1, x2, y2) = (x1 as f32, y1 as f32, x2 as f32, y2 as f32);
+        ProducerEvent::Release => false,
-            distance_to_line(((x1, y1), (x2, y2)), pos) as i32
+        ProducerEvent::Create(c, p) => {
-        })
+            active_clients.push((c, p));
-        .expect("could not find barrier corresponding to client")
+            true
-        .barrier_id
+        }
        ProducerEvent::Destroy(c) => {
            active_clients.retain(|(h, _)| *h != c);
            true
        }
    };
    Ok(updated)
 }
 fn distance_to_line(line: ((f32, f32), (f32, f32)), p: (f32, f32)) -> f32 {
    let ((x1, y1), (x2, y2)) = line;
    let (x0, y0) = p;
    /*
     * we use the fact that for the triangle spanned by the line and p,
     * the height of the triangle is the desired distance and can be calculated by
     * h = 2A / b with b being the line_length and
     */
    let double_triangle_area = ((y2 - y1) * x0 - (x2 - x1) * y0 + x2 * y1 - y2 * x1).abs();
    let line_length = ((y2 - y1).powf(2.0) + (x2 - x1).powf(2.0)).sqrt();
    let distance = double_triangle_area / line_length;
    log::debug!("distance to line({line:?}, {p:?}) = {distance}");
    distance
 }
 static ALL_CAPABILITIES: &[DeviceCapability] = &[
    DeviceCapability::Pointer,
    DeviceCapability::PointerAbsolute,
    DeviceCapability::Keyboard,
    DeviceCapability::Touch,
    DeviceCapability::Scroll,
    DeviceCapability::Button,
 ];
 async fn handle_ei_event(
    ei_event: EiEvent,
    current_client: Option<CaptureHandle>,
    context: &ei::Context,
    event_tx: &Sender<(CaptureHandle, Event)>,
-    release_session: &Notify,
+) {
 ) -> Result<(), CaptureError> {
    match ei_event {
        EiEvent::SeatAdded(s) => {
-            s.seat.bind_capabilities(ALL_CAPABILITIES);
+            s.seat.bind_capabilities(&[
-            context.flush().map_err(|e| io::Error::new(e.kind(), e))?;
+                DeviceCapability::Pointer,
                DeviceCapability::PointerAbsolute,
                DeviceCapability::Keyboard,
                DeviceCapability::Touch,
                DeviceCapability::Scroll,
                DeviceCapability::Button,
            ]);
            context.flush().unwrap();
        }
-        EiEvent::SeatRemoved(_) | /* EiEvent::DeviceAdded(_) | */ EiEvent::DeviceRemoved(_) => {
+        EiEvent::SeatRemoved(_) => {}
-            log::debug!("releasing session: {ei_event:?}");
+        EiEvent::DeviceAdded(_) => {}
-            release_session.notify_waiters();
+        EiEvent::DeviceRemoved(_) => {}
        EiEvent::DevicePaused(_) => {}
        EiEvent::DeviceResumed(_) => {}
        EiEvent::KeyboardModifiers(mods) => {
            let modifier_event = KeyboardEvent::Modifiers {
                mods_depressed: mods.depressed,
                mods_latched: mods.latched,
                mods_locked: mods.locked,
                group: mods.group,
            };
            if let Some(current_client) = current_client {
                event_tx
                    .send((current_client, Event::Keyboard(modifier_event)))
                    .await
                    .unwrap();
            }
        }
-        EiEvent::DevicePaused(_) | EiEvent::DeviceResumed(_) => {}
+        EiEvent::Frame(_) => {}
-        EiEvent::DeviceStartEmulating(_) => log::debug!("START EMULATING"),
+        EiEvent::DeviceStartEmulating(_) => {
-        EiEvent::DeviceStopEmulating(_) => log::debug!("STOP EMULATING"),
+            log::debug!("START EMULATING =============>");
        EiEvent::Disconnected(d) => {
            return Err(CaptureError::Disconnected(format!("{:?}", d.reason)))
        }
-        _ => {
+        EiEvent::DeviceStopEmulating(_) => {
            log::debug!("==================> STOP EMULATING");
        }
        EiEvent::PointerMotion(motion) => {
            let motion_event = PointerEvent::Motion {
                time: motion.time as u32,
                relative_x: motion.dx as f64,
                relative_y: motion.dy as f64,
            };
            if let Some(current_client) = current_client {
                event_tx
                    .send((current_client, Event::Pointer(motion_event)))
                    .await
                    .unwrap();
            }
        }
        EiEvent::PointerMotionAbsolute(_) => {}
        EiEvent::Button(button) => {
            let button_event = PointerEvent::Button {
                time: button.time as u32,
                button: button.button,
                state: match button.state {
                    ButtonState::Released => 0,
                    ButtonState::Press => 1,
                },
            };
            if let Some(current_client) = current_client {
                event_tx
                    .send((current_client, Event::Pointer(button_event)))
                    .await
                    .unwrap();
            }
        }
        EiEvent::ScrollDelta(delta) => {
            if let Some(handle) = current_client {
-                for event in Event::from_ei_event(ei_event) {
+                let mut events = vec![];
-                    event_tx.send((handle, event)).await.expect("no channel");
+                if delta.dy != 0. {
                    events.push(PointerEvent::Axis {
                        time: 0,
                        axis: 0,
                        value: delta.dy as f64,
                    });
                }
                if delta.dx != 0. {
                    events.push(PointerEvent::Axis {
                        time: 0,
                        axis: 1,
                        value: delta.dx as f64,
                    });
                }
                for event in events {
                    event_tx
                        .send((handle, Event::Pointer(event)))
                        .await
                        .unwrap();
                }
            }
        }
-    }
+        EiEvent::ScrollStop(_) => {}
-    Ok(())
+        EiEvent::ScrollCancel(_) => {}
-}
+        EiEvent::ScrollDiscrete(scroll) => {
-
+            if scroll.discrete_dy != 0 {
-#[async_trait]
+                let event = PointerEvent::AxisDiscrete120 {
-impl<'a> LanMouseInputCapture for LibeiInputCapture<'a> {
+                    axis: 0,
-    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+                    value: scroll.discrete_dy,
-        let _ = self
+                };
-            .notify_capture
+                if let Some(current_client) = current_client {
-            .send(LibeiNotifyEvent::Create(handle, pos))
+                    event_tx
-            .await;
+                        .send((current_client, Event::Pointer(event)))
-        Ok(())
+                        .await
-    }
+                        .unwrap();
-
+                }
-    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
+            }
-        let _ = self
+            if scroll.discrete_dx != 0 {
-            .notify_capture
+                let event = PointerEvent::AxisDiscrete120 {
-            .send(LibeiNotifyEvent::Destroy(handle))
+                    axis: 1,
-            .await;
+                    value: scroll.discrete_dx,
-        Ok(())
+                };
-    }
+                if let Some(current_client) = current_client {
-
+                    event_tx
-    async fn release(&mut self) -> Result<(), CaptureError> {
+                        .send((current_client, Event::Pointer(event)))
-        self.notify_release.notify_waiters();
+                        .await
-        Ok(())
+                        .unwrap();
-    }
+                }
-
+            };
    async fn terminate(&mut self) -> Result<(), CaptureError> {
        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!");
        self.terminated = true;
        res
    }
 }
 impl<'a> Drop for LibeiInputCapture<'a> {
    fn drop(&mut self) {
        if !self.terminated {
            /* this workaround is needed until async drop is stabilized */
            panic!("LibeiInputCapture dropped without being terminated!");
        }
        EiEvent::KeyboardKey(key) => {
            let key_event = KeyboardEvent::Key {
                key: key.key,
                state: match key.state {
                    KeyState::Press => 1,
                    KeyState::Released => 0,
                },
                time: key.time as u32,
            };
            if let Some(current_client) = current_client {
                event_tx
                    .send((current_client, Event::Keyboard(key_event)))
                    .await
                    .unwrap();
            }
        }
        EiEvent::TouchDown(_) => {}
        EiEvent::TouchUp(_) => {}
        EiEvent::TouchMotion(_) => {}
        EiEvent::Disconnected(d) => {
            log::error!("disconnect: {d:?}");
        }
    }
 }
 impl<'a> LanMouseInputCapture for LibeiInputCapture<'a> {
    fn create(&mut self, handle: super::CaptureHandle, pos: super::Position) -> io::Result<()> {
        let notify_tx = self.notify_tx.clone();
        tokio::task::spawn_local(async move {
            let _ = notify_tx.send(ProducerEvent::Create(handle, pos)).await;
        });
        Ok(())
    }
    fn destroy(&mut self, handle: super::CaptureHandle) -> io::Result<()> {
        let notify_tx = self.notify_tx.clone();
        tokio::task::spawn_local(async move {
            let _ = notify_tx.send(ProducerEvent::Destroy(handle)).await;
        });
        Ok(())
    }
    fn release(&mut self) -> io::Result<()> {
        let notify_tx = self.notify_tx.clone();
        tokio::task::spawn_local(async move {
            let _ = notify_tx.send(ProducerEvent::Release).await;
        });
        Ok(())
    }
 }
 impl<'a> Stream for LibeiInputCapture<'a> {
-    type Item = Result<(CaptureHandle, Event), CaptureError>;
+    type Item = io::Result<(CaptureHandle, Event)>;
    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        match self.capture_task.poll_unpin(cx) {
+        match ready!(self.event_rx.poll_recv(cx)) {
-            Poll::Ready(r) => match r.expect("failed to join") {
+            None => Poll::Ready(None),
-                Ok(()) => Poll::Ready(None),
+            Some(e) => Poll::Ready(Some(Ok(e))),
                Err(e) => Poll::Ready(Some(Err(e))),
            },
            Poll::Pending => self.event_rx.poll_recv(cx).map(|e| e.map(Result::Ok)),
        }
    }
 }
--- a/input-capture/src/macos.rs
+++ b/input-capture/src/macos.rs
@@ -1,11 +1,8 @@
-use crate::{
+use crate::{error::MacOSInputCaptureCreationError, CaptureHandle, InputCapture, Position};
    error::MacOSInputCaptureCreationError, CaptureError, CaptureHandle, InputCapture, Position,
 };
 use async_trait::async_trait;
 use futures_core::Stream;
 use input_event::Event;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use std::{io, pin::Pin};
 pub struct MacOSInputCapture;
@@ -16,28 +13,23 @@ impl MacOSInputCapture {
 }
 impl Stream for MacOSInputCapture {
-    type Item = Result<(CaptureHandle, Event), CaptureError>;
+    type Item = io::Result<(CaptureHandle, Event)>;
    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        Poll::Pending
    }
 }
 #[async_trait]
 impl InputCapture for MacOSInputCapture {
-    async fn create(&mut self, _id: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
+    fn create(&mut self, _id: CaptureHandle, _pos: Position) -> io::Result<()> {
        Ok(())
    }
-    async fn destroy(&mut self, _id: CaptureHandle) -> Result<(), CaptureError> {
+    fn destroy(&mut self, _id: CaptureHandle) -> io::Result<()> {
        Ok(())
    }
-    async fn release(&mut self) -> Result<(), CaptureError> {
+    fn release(&mut self) -> io::Result<()> {
        Ok(())
    }
    async fn terminate(&mut self) -> Result<(), CaptureError> {
        Ok(())
    }
 }
--- a/input-capture/src/wayland.rs
+++ b/input-capture/src/wayland.rs
@@ -1,4 +1,3 @@
 use async_trait::async_trait;
 use futures_core::Stream;
 use memmap::MmapOptions;
 use std::{
@@ -15,7 +14,7 @@ use std::{
    fs::File,
    io::{BufWriter, Write},
    os::unix::prelude::{AsRawFd, FromRawFd},
-    sync::Arc,
+    rc::Rc,
 };
 use wayland_protocols::{
@@ -63,8 +62,6 @@ use tempfile;
 use input_event::{Event, KeyboardEvent, PointerEvent};
 use crate::CaptureError;
 use super::{
    error::{LayerShellCaptureCreationError, WaylandBindError},
    CaptureHandle, InputCapture, Position,
@@ -105,8 +102,8 @@ struct State {
    pointer_lock: Option<ZwpLockedPointerV1>,
    rel_pointer: Option<ZwpRelativePointerV1>,
    shortcut_inhibitor: Option<ZwpKeyboardShortcutsInhibitorV1>,
-    client_for_window: Vec<(Arc<Window>, CaptureHandle)>,
+    client_for_window: Vec<(Rc<Window>, CaptureHandle)>,
-    focused: Option<(Arc<Window>, CaptureHandle)>,
+    focused: Option<(Rc<Window>, CaptureHandle)>,
    g: Globals,
    wayland_fd: OwnedFd,
    read_guard: Option<ReadEventsGuard>,
@@ -478,7 +475,7 @@ impl State {
        log::debug!("outputs: {outputs:?}");
        outputs.iter().for_each(|(o, i)| {
            let window = Window::new(self, &self.qh, o, pos, i.size);
-            let window = Arc::new(window);
+            let window = Rc::new(window);
            self.client_for_window.push((window, client));
        });
    }
@@ -564,34 +561,28 @@ impl Inner {
    }
 }
 #[async_trait]
 impl InputCapture for WaylandInputCapture {
-    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+    fn create(&mut self, handle: CaptureHandle, pos: Position) -> io::Result<()> {
        self.add_client(handle, pos);
        let inner = self.0.get_mut();
-        Ok(inner.flush_events()?)
+        inner.flush_events()
    }
-
+    fn destroy(&mut self, handle: CaptureHandle) -> io::Result<()> {
    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
        self.delete_client(handle);
        let inner = self.0.get_mut();
-        Ok(inner.flush_events()?)
+        inner.flush_events()
    }
-    async fn release(&mut self) -> Result<(), CaptureError> {
+    fn release(&mut self) -> io::Result<()> {
        log::debug!("releasing pointer");
        let inner = self.0.get_mut();
        inner.state.ungrab();
-        Ok(inner.flush_events()?)
+        inner.flush_events()
    }
    async fn terminate(&mut self) -> Result<(), CaptureError> {
        Ok(())
    }
 }
 impl Stream for WaylandInputCapture {
-    type Item = Result<(CaptureHandle, Event), CaptureError>;
+    type Item = io::Result<(CaptureHandle, Event)>;
    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        if let Some(event) = self.0.get_mut().state.pending_events.pop_front() {
@@ -609,7 +600,7 @@ impl Stream for WaylandInputCapture {
                    // prepare next read
                    match inner.prepare_read() {
                        Ok(_) => {}
-                        Err(e) => return Poll::Ready(Some(Err(e.into()))),
+                        Err(e) => return Poll::Ready(Some(Err(e))),
                    }
                }
@@ -619,14 +610,14 @@ impl Stream for WaylandInputCapture {
                // flush outgoing events
                if let Err(e) = inner.flush_events() {
                    if e.kind() != ErrorKind::WouldBlock {
-                        return Poll::Ready(Some(Err(e.into())));
+                        return Poll::Ready(Some(Err(e)));
                    }
                }
                // prepare for the next read
                match inner.prepare_read() {
                    Ok(_) => {}
-                    Err(e) => return Poll::Ready(Some(Err(e.into()))),
+                    Err(e) => return Poll::Ready(Some(Err(e))),
                }
            }
@@ -846,16 +837,21 @@ impl Dispatch<ZwpRelativePointerV1, ()> for State {
        if let zwp_relative_pointer_v1::Event::RelativeMotion {
            utime_hi,
            utime_lo,
-            dx_unaccel: dx,
+            dx: _,
-            dy_unaccel: dy,
+            dy: _,
-            ..
+            dx_unaccel: surface_x,
            dy_unaccel: surface_y,
        } = event
        {
            if let Some((_window, client)) = &app.focused {
                let time = (((utime_hi as u64) << 32 | utime_lo as u64) / 1000) as u32;
                app.pending_events.push_back((
                    *client,
-                    Event::Pointer(PointerEvent::Motion { time, dx, dy }),
+                    Event::Pointer(PointerEvent::Motion {
                        time,
                        relative_x: surface_x,
                        relative_y: surface_y,
                    }),
                ));
            }
        }
--- a/input-capture/src/windows.rs
+++ b/input-capture/src/windows.rs
@@ -1,4 +1,4 @@
-use async_trait::async_trait;
+use anyhow::Result;
 use core::task::{Context, Poll};
 use futures::Stream;
 use once_cell::unsync::Lazy;
@@ -11,7 +11,7 @@ use std::default::Default;
 use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::{mpsc, Mutex};
 use std::task::ready;
-use std::{pin::Pin, thread};
+use std::{io, pin::Pin, thread};
 use tokio::sync::mpsc::{channel, Receiver, Sender};
 use windows::core::{w, PCWSTR};
 use windows::Win32::Foundation::{FALSE, HINSTANCE, HWND, LPARAM, LRESULT, RECT, WPARAM};
@@ -37,7 +37,7 @@ use input_event::{
    Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
 };
-use super::{CaptureError, CaptureHandle, InputCapture, Position};
+use super::{CaptureHandle, InputCapture, Position};
 enum Request {
    Create(CaptureHandle, Position),
@@ -63,9 +63,8 @@ unsafe fn signal_message_thread(event_type: EventType) {
    }
 }
 #[async_trait]
 impl InputCapture for WindowsInputCapture {
-    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+    fn create(&mut self, handle: CaptureHandle, pos: Position) -> io::Result<()> {
        unsafe {
            {
                let mut requests = REQUEST_BUFFER.lock().unwrap();
@@ -75,8 +74,7 @@ impl InputCapture for WindowsInputCapture {
        }
        Ok(())
    }
-
+    fn destroy(&mut self, handle: CaptureHandle) -> io::Result<()> {
    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
        unsafe {
            {
                let mut requests = REQUEST_BUFFER.lock().unwrap();
@@ -87,14 +85,10 @@ impl InputCapture for WindowsInputCapture {
        Ok(())
    }
-    async fn release(&mut self) -> Result<(), CaptureError> {
+    fn release(&mut self) -> io::Result<()> {
        unsafe { signal_message_thread(EventType::Release) };
        Ok(())
    }
    async fn terminate(&mut self) -> Result<(), CaptureError> {
        Ok(())
    }
 }
 static mut REQUEST_BUFFER: Mutex<Vec<Request>> = Mutex::new(Vec::new());
@@ -151,8 +145,11 @@ fn to_mouse_event(wparam: WPARAM, lparam: LPARAM) -> Option<PointerEvent> {
            let (x, y) = (mouse_low_level.pt.x, mouse_low_level.pt.y);
            let (ex, ey) = ENTRY_POINT;
            let (dx, dy) = (x - ex, y - ey);
-            let (dx, dy) = (dx as f64, dy as f64);
+            Some(PointerEvent::Motion {
-            Some(PointerEvent::Motion { time: 0, dx, dy })
+                time: 0,
                relative_x: dx as f64,
                relative_y: dy as f64,
            })
        },
        WPARAM(p) if p == WM_MOUSEWHEEL as usize => Some(PointerEvent::AxisDiscrete120 {
            axis: 0,
@@ -519,7 +516,7 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {
        }
        /* window is used ro receive WM_DISPLAYCHANGE messages */
-        CreateWindowExW(
+        let ret = CreateWindowExW(
            Default::default(),
            w!("lan-mouse-message-window-class"),
            w!("lan-mouse-msg-window"),
@@ -532,8 +529,10 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {
            HMENU::default(),
            instance,
            None,
-        )
+        );
-        .expect("CreateWindowExW");
+        if ret.0 == 0 {
            panic!("CreateWindowExW");
        }
        /* run message loop */
        loop {
@@ -541,7 +540,7 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {
            let Some(msg) = get_msg() else {
                break;
            };
-            if msg.hwnd.0.is_null() {
+            if msg.hwnd.0 == 0 {
                /* messages sent via PostThreadMessage */
                match msg.wParam.0 {
                    x if x == EventType::Exit as usize => break,
@@ -614,7 +613,7 @@ impl WindowsInputCapture {
 }
 impl Stream for WindowsInputCapture {
-    type Item = Result<(CaptureHandle, Event), CaptureError>;
+    type Item = io::Result<(CaptureHandle, Event)>;
    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        match ready!(self.event_rx.poll_recv(cx)) {
            None => Poll::Ready(None),
--- a/input-capture/src/x11.rs
+++ b/input-capture/src/x11.rs
@@ -1,10 +1,8 @@
 use std::io;
 use std::task::Poll;
 use async_trait::async_trait;
 use futures_core::Stream;
 use crate::CaptureError;
 use super::InputCapture;
 use input_event::Event;
@@ -19,27 +17,22 @@ impl X11InputCapture {
    }
 }
 #[async_trait]
 impl InputCapture for X11InputCapture {
-    async fn create(&mut self, _id: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
+    fn create(&mut self, _id: CaptureHandle, _pos: Position) -> io::Result<()> {
        Ok(())
    }
-    async fn destroy(&mut self, _id: CaptureHandle) -> Result<(), CaptureError> {
+    fn destroy(&mut self, _id: CaptureHandle) -> io::Result<()> {
        Ok(())
    }
-    async fn release(&mut self) -> Result<(), CaptureError> {
+    fn release(&mut self) -> io::Result<()> {
        Ok(())
    }
    async fn terminate(&mut self) -> Result<(), CaptureError> {
        Ok(())
    }
 }
 impl Stream for X11InputCapture {
-    type Item = Result<(CaptureHandle, Event), CaptureError>;
+    type Item = io::Result<(CaptureHandle, Event)>;
    fn poll_next(
        self: std::pin::Pin<&mut Self>,
--- a/input-emulation/Cargo.toml
+++ b/input-emulation/Cargo.toml
@@ -4,51 +4,33 @@ description = "cross-platform input emulation library used by lan-mouse"
 version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
+repository = "https://github.com/ferdinandschober/lan-mouse"
 [dependencies]
 anyhow = "1.0.86"
 async-trait = "0.1.80"
 futures = "0.3.28"
 log = "0.4.22"
-input-event = { path = "../input-event", version = "0.2.1" }
+input-event = { path = "../input-event", version = "0.1.0" }
 thiserror = "1.0.61"
-tokio = { version = "1.32.0", features = [
+tokio = { version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "process", "rt", "sync", "signal"] }
    "io-util",
    "io-std",
    "macros",
    "net",
    "process",
    "rt",
    "sync",
    "signal",
 ] }
 once_cell = "1.19.0"
 [target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
-wayland-client = { version = "0.31.1", optional = true }
+wayland-client = { version="0.31.1", optional = true }
-wayland-protocols = { version = "0.32.1", features = [
+wayland-protocols = { version="0.32.1", features=["client", "staging", "unstable"], optional = true }
-    "client",
+wayland-protocols-wlr = { version="0.3.1", features=["client"], optional = true }
-    "staging",
+wayland-protocols-misc = { version="0.3.1", features=["client"], optional = true }
    "unstable",
 ], optional = true }
 wayland-protocols-wlr = { version = "0.3.1", features = [
    "client",
 ], optional = true }
 wayland-protocols-misc = { version = "0.3.1", features = [
    "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.9", default-features = false, features = [
+ashpd = { version = "0.8", default-features = false, features = ["tokio"], optional = true }
-    "tokio",
+reis = { version = "0.2", features = [ "tokio" ], optional = true }
 ], optional = true }
 reis = { version = "0.2", features = ["tokio"], optional = true }
 [target.'cfg(target_os="macos")'.dependencies]
 core-graphics = { version = "0.23", features = ["highsierra"] }
 keycode = "0.4.0"
 [target.'cfg(windows)'.dependencies]
-windows = { version = "0.58.0", features = [
+windows = {  version = "0.57.0", features = [
    "Win32_System_LibraryLoader",
    "Win32_System_Threading",
    "Win32_Foundation",
@@ -60,12 +42,7 @@ windows = { version = "0.58.0", features = [
 [features]
 default = ["wayland", "x11", "xdg_desktop_portal", "libei"]
-wayland = [
+wayland = ["dep:wayland-client", "dep:wayland-protocols", "dep:wayland-protocols-wlr", "dep:wayland-protocols-misc" ]
    "dep:wayland-client",
    "dep:wayland-protocols",
    "dep:wayland-protocols-wlr",
    "dep:wayland-protocols-misc",
 ]
 x11 = ["dep:x11"]
 xdg_desktop_portal = ["dep:ashpd"]
 libei = ["dep:reis", "dep:ashpd"]
--- a/input-emulation/src/dummy.rs
+++ b/input-emulation/src/dummy.rs
@@ -26,7 +26,4 @@ impl InputEmulation for DummyEmulation {
    }
    async fn create(&mut self, _: EmulationHandle) {}
    async fn destroy(&mut self, _: EmulationHandle) {}
    async fn terminate(&mut self) {
        /* nothing to do */
    }
 }
--- a/input-emulation/src/error.rs
+++ b/input-emulation/src/error.rs
@@ -1,18 +1,6 @@
-#[derive(Debug, Error)]
+use std::{fmt::Display, io};
 pub enum InputEmulationError {
    #[error("error creating input-emulation: `{0}`")]
    Create(#[from] EmulationCreationError),
    #[error("error emulating input: `{0}`")]
    Emulate(#[from] EmulationError),
 }
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use ashpd::{desktop::ResponseError, Error::Response};
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use reis::tokio::EiConvertEventStreamError;
 use std::io;
 use thiserror::Error;
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 use wayland_client::{
    backend::WaylandError,
@@ -23,30 +11,11 @@ use wayland_client::{
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use reis::tokio::HandshakeError;
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 #[error("error in libei stream: {inner:?}")]
 pub struct ReisConvertStreamError {
    inner: EiConvertEventStreamError,
 }
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 impl From<EiConvertEventStreamError> for ReisConvertStreamError {
    fn from(e: EiConvertEventStreamError) -> Self {
        Self { inner: e }
    }
 }
 #[derive(Debug, Error)]
 pub enum EmulationError {
    #[error("event stream closed")]
    EndOfStream,
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error("libei error flushing events: `{0}`")]
    Libei(#[from] reis::event::Error),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error("")]
    LibeiConvertStream(#[from] ReisConvertStreamError),
    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    #[error("wayland error: `{0}`")]
    Wayland(#[from] wayland_client::backend::WaylandError),
@@ -64,77 +33,58 @@ pub enum EmulationError {
 #[derive(Debug, Error)]
 pub enum EmulationCreationError {
    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    #[error("wlroots backend: `{0}`")]
    Wlroots(#[from] WlrootsEmulationCreationError),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error("libei backend: `{0}`")]
    Libei(#[from] LibeiEmulationCreationError),
    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
    #[error("xdg-desktop-portal: `{0}`")]
    Xdp(#[from] XdpEmulationCreationError),
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
    #[error("x11: `{0}`")]
    X11(#[from] X11EmulationCreationError),
    #[cfg(target_os = "macos")]
    #[error("macos: `{0}`")]
    MacOs(#[from] MacOSEmulationCreationError),
    #[cfg(windows)]
    #[error("windows: `{0}`")]
    Windows(#[from] WindowsEmulationCreationError),
    #[error("capture error")]
    NoAvailableBackend,
 }
-impl EmulationCreationError {
+impl Display for EmulationCreationError {
-    /// request was intentionally denied by the user
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    pub(crate) fn cancelled_by_user(&self) -> bool {
+        let reason = match self {
-        #[cfg(feature = "libei")]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-        if matches!(
+            EmulationCreationError::Wlroots(e) => format!("wlroots backend: {e}"),
-            self,
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-            EmulationCreationError::Libei(LibeiEmulationCreationError::Ashpd(Response(
+            EmulationCreationError::Libei(e) => format!("libei backend: {e}"),
-                ResponseError::Cancelled,
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-            )))
+            EmulationCreationError::Xdp(e) => format!("desktop portal backend: {e}"),
-        ) {
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-            return true;
+            EmulationCreationError::X11(e) => format!("x11 backend: {e}"),
-        }
+            #[cfg(target_os = "macos")]
-        #[cfg(feature = "xdg_desktop_portal")]
+            EmulationCreationError::MacOs(e) => format!("macos backend: {e}"),
-        if matches!(
+            #[cfg(windows)]
-            self,
+            EmulationCreationError::Windows(e) => format!("windows backend: {e}"),
-            EmulationCreationError::Xdp(XdpEmulationCreationError::Ashpd(Response(
+            EmulationCreationError::NoAvailableBackend => "no backend available".to_string(),
-                ResponseError::Cancelled,
+        };
-            )))
+        write!(f, "could not create input emulation backend: {reason}")
        ) {
            return true;
        }
        false
    }
 }
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum WlrootsEmulationCreationError {
    #[error(transparent)]
    Connect(#[from] ConnectError),
    #[error(transparent)]
    Global(#[from] GlobalError),
    #[error(transparent)]
    Wayland(#[from] WaylandError),
    #[error(transparent)]
    Bind(#[from] WaylandBindError),
    #[error(transparent)]
    Dispatch(#[from] DispatchError),
    #[error(transparent)]
    Io(#[from] std::io::Error),
 }
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 #[error("wayland protocol \"{protocol}\" not supported: {inner}")]
 pub struct WaylandBindError {
    inner: BindError,
    protocol: &'static str,
 }
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 impl WaylandBindError {
    pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
@@ -142,38 +92,101 @@ impl WaylandBindError {
    }
 }
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 impl Display for WaylandBindError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{} protocol not supported: {}",
            self.protocol, self.inner
        )
    }
 }
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 impl Display for WlrootsEmulationCreationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            WlrootsEmulationCreationError::Bind(e) => write!(f, "{e}"),
            WlrootsEmulationCreationError::Connect(e) => {
                write!(f, "could not connect to wayland compositor: {e}")
            }
            WlrootsEmulationCreationError::Global(e) => write!(f, "wayland error: {e}"),
            WlrootsEmulationCreationError::Wayland(e) => write!(f, "wayland error: {e}"),
            WlrootsEmulationCreationError::Dispatch(e) => {
                write!(f, "error dispatching wayland events: {e}")
            }
            WlrootsEmulationCreationError::Io(e) => write!(f, "io error: {e}"),
        }
    }
 }
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum LibeiEmulationCreationError {
    #[error(transparent)]
    Ashpd(#[from] ashpd::Error),
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
    Handshake(#[from] HandshakeError),
 }
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 impl Display for LibeiEmulationCreationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            LibeiEmulationCreationError::Ashpd(e) => write!(f, "xdg-desktop-portal: {e}"),
            LibeiEmulationCreationError::Io(e) => write!(f, "io error: {e}"),
            LibeiEmulationCreationError::Handshake(e) => write!(f, "error in libei handshake: {e}"),
        }
    }
 }
 #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum XdpEmulationCreationError {
    #[error(transparent)]
    Ashpd(#[from] ashpd::Error),
 }
 #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
 impl Display for XdpEmulationCreationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            XdpEmulationCreationError::Ashpd(e) => write!(f, "portal error: {e}"),
        }
    }
 }
 #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum X11EmulationCreationError {
    #[error("could not open display")]
    OpenDisplay,
 }
 #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
 impl Display for X11EmulationCreationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            X11EmulationCreationError::OpenDisplay => write!(f, "could not open display!"),
        }
    }
 }
 #[cfg(target_os = "macos")]
 #[derive(Debug, Error)]
 pub enum MacOSEmulationCreationError {
    #[error("could not create event source")]
    EventSourceCreation,
 }
 #[cfg(target_os = "macos")]
 impl Display for MacOSEmulationCreationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            MacOSEmulationCreationError::EventSourceCreation => {
                write!(f, "could not create event source")
            }
        }
    }
 }
 #[cfg(windows)]
 #[derive(Debug, Error)]
 pub enum WindowsEmulationCreationError {}
--- a/input-emulation/src/lib.rs
+++ b/input-emulation/src/lib.rs
@@ -1,9 +1,12 @@
 use async_trait::async_trait;
 use error::EmulationError;
 use std::fmt::Display;
 use input_event::Event;
-pub use self::error::{EmulationCreationError, EmulationError, InputEmulationError};
+use anyhow::Result;
 use self::error::EmulationCreationError;
 #[cfg(windows)]
 pub mod windows;
@@ -75,7 +78,6 @@ pub trait InputEmulation: Send {
    ) -> Result<(), EmulationError>;
    async fn create(&mut self, handle: EmulationHandle);
    async fn destroy(&mut self, handle: EmulationHandle);
    async fn terminate(&mut self);
 }
 pub async fn create_backend(
@@ -131,7 +133,6 @@ pub async fn create(
                log::info!("using emulation backend: {backend}");
                return Ok(b);
            }
            Err(e) if e.cancelled_by_user() => return Err(e),
            Err(e) => log::warn!("{e}"),
        }
    }
--- a/input-emulation/src/libei.rs
+++ b/input-emulation/src/libei.rs
@@ -1,12 +1,13 @@
-use futures::{future, StreamExt};
+use anyhow::{anyhow, Result};
 use futures::StreamExt;
 use once_cell::sync::Lazy;
 use std::{
    collections::HashMap,
    io,
    os::{fd::OwnedFd, unix::net::UnixStream},
    sync::{
-        atomic::{AtomicBool, AtomicU32, Ordering},
+        atomic::{AtomicU32, Ordering},
-        Arc, Mutex, RwLock,
+        Arc, RwLock,
    },
    time::{SystemTime, UNIX_EPOCH},
 };
@@ -15,7 +16,7 @@ use tokio::task::JoinHandle;
 use ashpd::{
    desktop::{
        remote_desktop::{DeviceType, RemoteDesktop},
-        PersistMode, Session,
+        ResponseError,
    },
    WindowIdentifier,
 };
@@ -32,7 +33,7 @@ use reis::{
 use input_event::{Event, KeyboardEvent, PointerEvent};
-use crate::error::{EmulationError, ReisConvertStreamError};
+use crate::error::EmulationError;
 use super::{error::LibeiEmulationCreationError, EmulationHandle, InputEmulation};
@@ -60,50 +61,51 @@ struct Devices {
    keyboard: Arc<RwLock<Option<(ei::Device, ei::Keyboard)>>>,
 }
-pub struct LibeiEmulation<'a> {
+pub struct LibeiEmulation {
    context: ei::Context,
    devices: Devices,
    ei_task: JoinHandle<()>,
    error: Arc<Mutex<Option<EmulationError>>>,
    libei_error: Arc<AtomicBool>,
    serial: AtomicU32,
-    _remote_desktop: RemoteDesktop<'a>,
+    ei_task: JoinHandle<Result<()>>,
    session: Session<'a, RemoteDesktop<'a>>,
 }
-async fn get_ei_fd<'a>(
+async fn get_ei_fd() -> Result<OwnedFd, ashpd::Error> {
-) -> Result<(RemoteDesktop<'a>, Session<'a, RemoteDesktop<'a>>, OwnedFd), ashpd::Error> {
+    let proxy = RemoteDesktop::new().await?;
    let remote_desktop = RemoteDesktop::new().await?;
-    log::debug!("creating session ...");
+    // retry when user presses the cancel button
-    let session = remote_desktop.create_session().await?;
+    let (session, _) = loop {
        log::debug!("creating session ...");
        let session = proxy.create_session().await?;
-    log::debug!("selecting devices ...");
+        log::debug!("selecting devices ...");
-    remote_desktop
+        proxy
-        .select_devices(
+            .select_devices(&session, DeviceType::Keyboard | DeviceType::Pointer)
-            &session,
+            .await?;
            DeviceType::Keyboard | DeviceType::Pointer,
            None,
            PersistMode::ExplicitlyRevoked,
        )
        .await?;
-    log::info!("requesting permission for input emulation");
+        log::info!("requesting permission for input emulation");
-    let _devices = remote_desktop
+        match proxy
-        .start(&session, &WindowIdentifier::default())
+            .start(&session, &WindowIdentifier::default())
-        .await?
+            .await?
-        .response()?;
+            .response()
        {
            Ok(d) => break (session, d),
            Err(ashpd::Error::Response(ResponseError::Cancelled)) => {
                log::warn!("request cancelled!");
                continue;
            }
            e => e?,
        };
    };
-    let fd = remote_desktop.connect_to_eis(&session).await?;
+    proxy.connect_to_eis(&session).await
    Ok((remote_desktop, session, fd))
 }
-impl<'a> LibeiEmulation<'a> {
+impl LibeiEmulation {
    pub async fn new() -> Result<Self, LibeiEmulationCreationError> {
-        let (_remote_desktop, session, eifd) = get_ei_fd().await?;
+        let eifd = get_ei_fd().await?;
        let stream = UnixStream::from(eifd);
        stream.set_nonblocking(true)?;
        let context = ei::Context::new(stream)?;
        context.flush().map_err(|e| io::Error::new(e.kind(), e))?;
        let mut events = EiEventStream::new(context.clone())?;
        let handshake = ei_handshake(
            &mut events,
@@ -114,40 +116,28 @@ impl<'a> LibeiEmulation<'a> {
        .await?;
        let events = EiConvertEventStream::new(events, handshake.serial);
        let devices = Devices::default();
-        let libei_error = Arc::new(AtomicBool::default());
+        let ei_task =
-        let error = Arc::new(Mutex::new(None));
+            tokio::task::spawn_local(ei_event_handler(events, context.clone(), devices.clone()));
        let ei_handler = ei_task(
            events,
            context.clone(),
            devices.clone(),
            libei_error.clone(),
            error.clone(),
        );
        let ei_task = tokio::task::spawn_local(ei_handler);
        let serial = AtomicU32::new(handshake.serial);
        Ok(Self {
            context,
            devices,
            ei_task,
            error,
            libei_error,
            serial,
-            _remote_desktop,
+            context,
-            session,
+            ei_task,
            devices,
        })
    }
 }
-impl<'a> Drop for LibeiEmulation<'a> {
+impl Drop for LibeiEmulation {
    fn drop(&mut self) {
        self.ei_task.abort();
    }
 }
 #[async_trait]
-impl<'a> InputEmulation for LibeiEmulation<'a> {
+impl InputEmulation for LibeiEmulation {
    async fn consume(
        &mut self,
        event: Event,
@@ -157,18 +147,16 @@ impl<'a> InputEmulation for LibeiEmulation<'a> {
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_micros() as u64;
        if self.libei_error.load(Ordering::SeqCst) {
            // don't break sending additional events but signal error
            if let Some(e) = self.error.lock().unwrap().take() {
                return Err(e);
            }
        }
        match event {
            Event::Pointer(p) => match p {
-                PointerEvent::Motion { time: _, dx, dy } => {
+                PointerEvent::Motion {
                    time: _,
                    relative_x,
                    relative_y,
                } => {
                    let pointer_device = self.devices.pointer.read().unwrap();
                    if let Some((d, p)) = pointer_device.as_ref() {
-                        p.motion_relative(dx as f32, dy as f32);
+                        p.motion_relative(relative_x as f32, relative_y as f32);
                        d.frame(self.serial.load(Ordering::SeqCst), now);
                    }
                }
@@ -245,44 +233,19 @@ impl<'a> InputEmulation for LibeiEmulation<'a> {
    async fn create(&mut self, _: EmulationHandle) {}
    async fn destroy(&mut self, _: EmulationHandle) {}
    async fn terminate(&mut self) {
        let _ = self.session.close().await;
        self.ei_task.abort();
    }
 }
 async fn ei_task(
    mut events: EiConvertEventStream,
    context: ei::Context,
    devices: Devices,
    libei_error: Arc<AtomicBool>,
    error: Arc<Mutex<Option<EmulationError>>>,
 ) {
    loop {
        match ei_event_handler(&mut events, &context, &devices).await {
            Ok(()) => {}
            Err(e) => {
                libei_error.store(true, Ordering::SeqCst);
                error.lock().unwrap().replace(e);
                // wait for termination -> otherwise we will loop forever
                future::pending::<()>().await;
            }
        }
    }
 }
 async fn ei_event_handler(
-    events: &mut EiConvertEventStream,
+    mut events: EiConvertEventStream,
-    context: &ei::Context,
+    context: ei::Context,
-    devices: &Devices,
+    devices: Devices,
-) -> Result<(), EmulationError> {
+) -> Result<()> {
    loop {
        let event = events
            .next()
            .await
-            .ok_or(EmulationError::EndOfStream)?
+            .ok_or(anyhow!("ei stream closed"))?
-            .map_err(ReisConvertStreamError::from)?;
+            .map_err(|e| anyhow!("libei error: {e:?}"))?;
        const CAPABILITIES: &[DeviceCapability] = &[
            DeviceCapability::Pointer,
            DeviceCapability::PointerAbsolute,
@@ -295,7 +258,7 @@ async fn ei_event_handler(
        match event {
            EiEvent::Disconnected(e) => {
                log::debug!("ei disconnected: {e:?}");
-                return Err(EmulationError::EndOfStream);
+                break;
            }
            EiEvent::SeatAdded(e) => {
                e.seat().bind_capabilities(CAPABILITIES);
@@ -367,6 +330,7 @@ async fn ei_event_handler(
            // EiEvent::TouchMotion(_) => { },
            _ => unreachable!("unexpected ei event"),
        }
-        context.flush().map_err(|e| io::Error::new(e.kind(), e))?;
+        context.flush()?;
    }
    Ok(())
 }
--- a/input-emulation/src/macos.rs
+++ b/input-emulation/src/macos.rs
@@ -114,7 +114,11 @@ impl InputEmulation for MacOSEmulation {
    ) -> Result<(), EmulationError> {
        match event {
            Event::Pointer(pointer_event) => match pointer_event {
-                PointerEvent::Motion { time: _, dx, dy } => {
+                PointerEvent::Motion {
                    time: _,
                    relative_x,
                    relative_y,
                } => {
                    // FIXME secondary displays?
                    let (min_x, min_y, max_x, max_y) = unsafe {
                        let display = CGMainDisplayID();
@@ -133,8 +137,8 @@ impl InputEmulation for MacOSEmulation {
                        }
                    };
-                    mouse_location.x = (mouse_location.x + dx).clamp(min_x, max_x - 1.);
+                    mouse_location.x = (mouse_location.x + relative_x).clamp(min_x, max_x - 1.);
-                    mouse_location.y = (mouse_location.y + dy).clamp(min_y, max_y - 1.);
+                    mouse_location.y = (mouse_location.y + relative_y).clamp(min_y, max_y - 1.);
                    let mut event_type = CGEventType::MouseMoved;
                    if self.button_state.left {
@@ -156,8 +160,14 @@ impl InputEmulation for MacOSEmulation {
                            return Ok(());
                        }
                    };
-                    event.set_integer_value_field(EventField::MOUSE_EVENT_DELTA_X, dx as i64);
+                    event.set_integer_value_field(
-                    event.set_integer_value_field(EventField::MOUSE_EVENT_DELTA_Y, dy as i64);
+                        EventField::MOUSE_EVENT_DELTA_X,
                        relative_x as i64,
                    );
                    event.set_integer_value_field(
                        EventField::MOUSE_EVENT_DELTA_Y,
                        relative_y as i64,
                    );
                    event.post(CGEventTapLocation::HID);
                }
                PointerEvent::Button {
@@ -295,6 +305,4 @@ impl InputEmulation for MacOSEmulation {
    async fn create(&mut self, _handle: EmulationHandle) {}
    async fn destroy(&mut self, _handle: EmulationHandle) {}
    async fn terminate(&mut self) {}
 }
--- a/input-emulation/src/windows.rs
+++ b/input-emulation/src/windows.rs
@@ -39,8 +39,12 @@ impl InputEmulation for WindowsEmulation {
    async fn consume(&mut self, event: Event, _: EmulationHandle) -> Result<(), EmulationError> {
        match event {
            Event::Pointer(pointer_event) => match pointer_event {
-                PointerEvent::Motion { time: _, dx, dy } => {
+                PointerEvent::Motion {
-                    rel_mouse(dx as i32, dy as i32);
+                    time: _,
                    relative_x,
                    relative_y,
                } => {
                    rel_mouse(relative_x as i32, relative_y as i32);
                }
                PointerEvent::Button {
                    time: _,
@@ -80,8 +84,6 @@ impl InputEmulation for WindowsEmulation {
    async fn create(&mut self, _handle: EmulationHandle) {}
    async fn destroy(&mut self, _handle: EmulationHandle) {}
    async fn terminate(&mut self) {}
 }
 impl WindowsEmulation {
--- a/input-emulation/src/wlroots.rs
+++ b/input-emulation/src/wlroots.rs
@@ -165,9 +165,6 @@ impl InputEmulation for WlrootsEmulation {
            log::error!("{}", e);
        }
    }
    async fn terminate(&mut self) {
        /* nothing to do */
    }
 }
 struct VirtualInput {
@@ -180,7 +177,11 @@ impl VirtualInput {
        match event {
            Event::Pointer(e) => {
                match e {
-                    PointerEvent::Motion { time, dx, dy } => self.pointer.motion(time, dx, dy),
+                    PointerEvent::Motion {
                        time,
                        relative_x,
                        relative_y,
                    } => self.pointer.motion(time, relative_x, relative_y),
                    PointerEvent::Button {
                        time,
                        button,
--- a/input-emulation/src/x11.rs
+++ b/input-emulation/src/x11.rs
@@ -103,8 +103,12 @@ impl InputEmulation for X11Emulation {
    async fn consume(&mut self, event: Event, _: EmulationHandle) -> Result<(), EmulationError> {
        match event {
            Event::Pointer(pointer_event) => match pointer_event {
-                PointerEvent::Motion { time: _, dx, dy } => {
+                PointerEvent::Motion {
-                    self.relative_motion(dx as i32, dy as i32);
+                    time: _,
                    relative_x,
                    relative_y,
                } => {
                    self.relative_motion(relative_x as i32, relative_y as i32);
                }
                PointerEvent::Button {
                    time: _,
@@ -148,8 +152,4 @@ impl InputEmulation for X11Emulation {
    async fn destroy(&mut self, _: EmulationHandle) {
        // for our purposes it does not matter what client sent the event
    }
    async fn terminate(&mut self) {
        /* nothing to do */
    }
 }
--- a/input-emulation/src/xdg_desktop_portal.rs
+++ b/input-emulation/src/xdg_desktop_portal.rs
@@ -1,7 +1,8 @@
 use anyhow::Result;
 use ashpd::{
    desktop::{
        remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop},
-        PersistMode, Session,
+        ResponseError, Session,
    },
    zbus::AsyncDrop,
    WindowIdentifier,
@@ -20,7 +21,7 @@ use super::{error::XdpEmulationCreationError, EmulationHandle, InputEmulation};
 pub struct DesktopPortalEmulation<'a> {
    proxy: RemoteDesktop<'a>,
-    session: Session<'a, RemoteDesktop<'a>>,
+    session: Session<'a>,
 }
 impl<'a> DesktopPortalEmulation<'a> {
@@ -29,24 +30,29 @@ impl<'a> DesktopPortalEmulation<'a> {
        let proxy = RemoteDesktop::new().await?;
        // retry when user presses the cancel button
-        log::debug!("creating session ...");
+        let (session, _) = loop {
-        let session = proxy.create_session().await?;
+            log::debug!("creating session ...");
            let session = proxy.create_session().await?;
-        log::debug!("selecting devices ...");
+            log::debug!("selecting devices ...");
-        proxy
+            proxy
-            .select_devices(
+                .select_devices(&session, DeviceType::Keyboard | DeviceType::Pointer)
-                &session,
+                .await?;
                DeviceType::Keyboard | DeviceType::Pointer,
                None,
                PersistMode::ExplicitlyRevoked,
            )
            .await?;
-        log::info!("requesting permission for input emulation");
+            log::info!("requesting permission for input emulation");
-        let _devices = proxy
+            match proxy
-            .start(&session, &WindowIdentifier::default())
+                .start(&session, &WindowIdentifier::default())
-            .await?
+                .await?
-            .response()?;
+                .response()
            {
                Ok(d) => break (session, d),
                Err(ashpd::Error::Response(ResponseError::Cancelled)) => {
                    log::warn!("request cancelled!");
                    continue;
                }
                e => e?,
            };
        };
        log::debug!("started session");
        let session = session;
@@ -64,9 +70,13 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
    ) -> Result<(), EmulationError> {
        match event {
            Pointer(p) => match p {
-                PointerEvent::Motion { time: _, dx, dy } => {
+                PointerEvent::Motion {
                    time: _,
                    relative_x,
                    relative_y,
                } => {
                    self.proxy
-                        .notify_pointer_motion(&self.session, dx, dy)
+                        .notify_pointer_motion(&self.session, relative_x, relative_y)
                        .await?;
                }
                PointerEvent::Button {
@@ -88,7 +98,7 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
                        _ => Axis::Horizontal,
                    };
                    self.proxy
-                        .notify_pointer_axis_discrete(&self.session, axis, value / 120)
+                        .notify_pointer_axis_discrete(&self.session, axis, value)
                        .await?;
                }
                PointerEvent::Axis {
@@ -137,14 +147,6 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
    async fn create(&mut self, _client: EmulationHandle) {}
    async fn destroy(&mut self, _client: EmulationHandle) {}
    async fn terminate(&mut self) {
        if let Err(e) = self.session.close().await {
            log::warn!("session.close(): {e}");
        };
        if let Err(e) = self.session.receive_closed().await {
            log::warn!("session.receive_closed(): {e}");
        };
    }
 }
 impl<'a> AsyncDrop for DesktopPortalEmulation<'a> {
--- a/input-event/Cargo.toml
+++ b/input-event/Cargo.toml
@@ -1,21 +1,14 @@
 [package]
 name = "input-event"
 description = "cross-platform input-event types for input-capture / input-emulation"
-version = "0.2.1"
+version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
+repository = "https://github.com/ferdinandschober/lan-mouse"
 [dependencies]
 anyhow = "1.0.86"
 futures-core = "0.3.30"
 log = "0.4.22"
 num_enum = "0.7.2"
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "1.0.61"
 [target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
 reis = { version = "0.2.0", optional = true }
 [features]
 default = ["libei"]
 libei = ["dep:reis"]
--- a/input-event/src/error.rs
+++ b/input-event/src/error.rs
@@ -1,17 +0,0 @@
 use std::array::TryFromSliceError;
 use thiserror::Error;
 #[derive(Debug, Error)]
 pub enum ProtocolError {
    #[error(transparent)]
    MissingData(#[from] TryFromSliceError),
    #[error("invalid event id: `{0}`")]
    InvalidEventId(u8),
    #[error("invalid pointer event type: `{0}`")]
    InvalidPointerEventId(u8),
    #[error("invalid keyboard event type: `{0}`")]
    InvalidKeyboardEventId(u8),
    #[error("expected data at idx `{0:?}`")]
    Data(String),
 }
--- a/input-event/src/lib.rs
+++ b/input-event/src/lib.rs
@@ -1,13 +1,11 @@
-pub use error::ProtocolError;
+use anyhow::{anyhow, Result};
-use std::fmt::{self, Display};
+use std::{
    error::Error,
    fmt::{self, Display},
 };
 pub mod error;
 pub mod proto;
 pub mod scancode;
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 mod libei;
 // FIXME
 pub const BTN_LEFT: u32 = 0x110;
 pub const BTN_RIGHT: u32 = 0x111;
@@ -17,23 +15,35 @@ pub const BTN_FORWARD: u32 = 0x114;
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub enum PointerEvent {
-    /// relative motion event
+    Motion {
-    Motion { time: u32, dx: f64, dy: f64 },
+        time: u32,
-    /// mouse button event
+        relative_x: f64,
-    Button { time: u32, button: u32, state: u32 },
+        relative_y: f64,
-    /// axis event, scroll event for touchpads
+    },
-    Axis { time: u32, axis: u8, value: f64 },
+    Button {
-    /// discrete axis event, scroll event for mice - 120 = one scroll tick
+        time: u32,
-    AxisDiscrete120 { axis: u8, value: i32 },
+        button: u32,
-    /// frame event
+        state: u32,
    },
    Axis {
        time: u32,
        axis: u8,
        value: f64,
    },
    AxisDiscrete120 {
        axis: u8,
        value: i32,
    },
    Frame {},
 }
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub enum KeyboardEvent {
-    /// a key press / release event
+    Key {
-    Key { time: u32, key: u32, state: u8 },
+        time: u32,
-    /// modifiers changed state
+        key: u32,
        state: u8,
    },
    Modifiers {
        mods_depressed: u32,
        mods_latched: u32,
@@ -70,7 +80,11 @@ pub enum Event {
 impl Display for PointerEvent {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
-            PointerEvent::Motion { time: _, dx, dy } => write!(f, "motion({dx},{dy})"),
+            PointerEvent::Motion {
                time: _,
                relative_x,
                relative_y,
            } => write!(f, "motion({relative_x},{relative_y})"),
            PointerEvent::Button {
                time: _,
                button,
@@ -144,3 +158,430 @@ impl Display for Event {
        }
    }
 }
 impl Event {
    fn event_type(&self) -> EventType {
        match self {
            Self::Pointer(_) => EventType::Pointer,
            Self::Keyboard(_) => EventType::Keyboard,
            Self::Enter() => EventType::Enter,
            Self::Leave() => EventType::Leave,
            Self::Ping() => EventType::Ping,
            Self::Pong() => EventType::Pong,
            Self::Disconnect() => EventType::Disconnect,
        }
    }
 }
 impl PointerEvent {
    fn event_type(&self) -> PointerEventType {
        match self {
            Self::Motion { .. } => PointerEventType::Motion,
            Self::Button { .. } => PointerEventType::Button,
            Self::Axis { .. } => PointerEventType::Axis,
            Self::AxisDiscrete120 { .. } => PointerEventType::AxisDiscrete120,
            Self::Frame { .. } => PointerEventType::Frame,
        }
    }
 }
 impl KeyboardEvent {
    fn event_type(&self) -> KeyboardEventType {
        match self {
            KeyboardEvent::Key { .. } => KeyboardEventType::Key,
            KeyboardEvent::Modifiers { .. } => KeyboardEventType::Modifiers,
        }
    }
 }
 enum PointerEventType {
    Motion,
    Button,
    Axis,
    AxisDiscrete120,
    Frame,
 }
 enum KeyboardEventType {
    Key,
    Modifiers,
 }
 enum EventType {
    Pointer,
    Keyboard,
    Enter,
    Leave,
    Ping,
    Pong,
    Disconnect,
 }
 impl TryFrom<u8> for PointerEventType {
    type Error = anyhow::Error;
    fn try_from(value: u8) -> Result<Self> {
        match value {
            x if x == Self::Motion as u8 => Ok(Self::Motion),
            x if x == Self::Button as u8 => Ok(Self::Button),
            x if x == Self::Axis as u8 => Ok(Self::Axis),
            x if x == Self::AxisDiscrete120 as u8 => Ok(Self::AxisDiscrete120),
            x if x == Self::Frame as u8 => Ok(Self::Frame),
            _ => Err(anyhow!(ProtocolError {
                msg: format!("invalid pointer event type {}", value),
            })),
        }
    }
 }
 impl TryFrom<u8> for KeyboardEventType {
    type Error = anyhow::Error;
    fn try_from(value: u8) -> Result<Self> {
        match value {
            x if x == Self::Key as u8 => Ok(Self::Key),
            x if x == Self::Modifiers as u8 => Ok(Self::Modifiers),
            _ => Err(anyhow!(ProtocolError {
                msg: format!("invalid keyboard event type {}", value),
            })),
        }
    }
 }
 impl From<&Event> for Vec<u8> {
    fn from(event: &Event) -> Self {
        let event_id = vec![event.event_type() as u8];
        let event_data = match event {
            Event::Pointer(p) => p.into(),
            Event::Keyboard(k) => k.into(),
            Event::Enter() => vec![],
            Event::Leave() => vec![],
            Event::Ping() => vec![],
            Event::Pong() => vec![],
            Event::Disconnect() => vec![],
        };
        [event_id, event_data].concat()
    }
 }
 #[derive(Debug)]
 struct ProtocolError {
    msg: String,
 }
 impl fmt::Display for ProtocolError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Protocol violation: {}", self.msg)
    }
 }
 impl Error for ProtocolError {}
 impl TryFrom<Vec<u8>> for Event {
    type Error = anyhow::Error;
    fn try_from(value: Vec<u8>) -> Result<Self> {
        let event_id = u8::from_be_bytes(value[..1].try_into()?);
        match event_id {
            i if i == (EventType::Pointer as u8) => Ok(Event::Pointer(value.try_into()?)),
            i if i == (EventType::Keyboard as u8) => Ok(Event::Keyboard(value.try_into()?)),
            i if i == (EventType::Enter as u8) => Ok(Event::Enter()),
            i if i == (EventType::Leave as u8) => Ok(Event::Leave()),
            i if i == (EventType::Ping as u8) => Ok(Event::Ping()),
            i if i == (EventType::Pong as u8) => Ok(Event::Pong()),
            i if i == (EventType::Disconnect as u8) => Ok(Event::Disconnect()),
            _ => Err(anyhow!(ProtocolError {
                msg: format!("invalid event_id {}", event_id),
            })),
        }
    }
 }
 impl From<&PointerEvent> for Vec<u8> {
    fn from(event: &PointerEvent) -> Self {
        let id = vec![event.event_type() as u8];
        let data = match event {
            PointerEvent::Motion {
                time,
                relative_x,
                relative_y,
            } => {
                let time = time.to_be_bytes();
                let relative_x = relative_x.to_be_bytes();
                let relative_y = relative_y.to_be_bytes();
                [&time[..], &relative_x[..], &relative_y[..]].concat()
            }
            PointerEvent::Button {
                time,
                button,
                state,
            } => {
                let time = time.to_be_bytes();
                let button = button.to_be_bytes();
                let state = state.to_be_bytes();
                [&time[..], &button[..], &state[..]].concat()
            }
            PointerEvent::Axis { time, axis, value } => {
                let time = time.to_be_bytes();
                let axis = axis.to_be_bytes();
                let value = value.to_be_bytes();
                [&time[..], &axis[..], &value[..]].concat()
            }
            PointerEvent::AxisDiscrete120 { axis, value } => {
                let axis = axis.to_be_bytes();
                let value = value.to_be_bytes();
                [&axis[..], &value[..]].concat()
            }
            PointerEvent::Frame {} => {
                vec![]
            }
        };
        [id, data].concat()
    }
 }
 impl TryFrom<Vec<u8>> for PointerEvent {
    type Error = anyhow::Error;
    fn try_from(data: Vec<u8>) -> Result<Self> {
        match data.get(1) {
            Some(id) => {
                let event_type = match id.to_owned().try_into() {
                    Ok(event_type) => event_type,
                    Err(e) => return Err(e),
                };
                match event_type {
                    PointerEventType::Motion => {
                        let time = match data.get(2..6) {
                            Some(d) => u32::from_be_bytes(d.try_into()?),
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 4 Bytes at index 2".into(),
                                }))
                            }
                        };
                        let relative_x = match data.get(6..14) {
                            Some(d) => f64::from_be_bytes(d.try_into()?),
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 8 Bytes at index 6".into(),
                                }))
                            }
                        };
                        let relative_y = match data.get(14..22) {
                            Some(d) => f64::from_be_bytes(d.try_into()?),
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 8 Bytes at index 14".into(),
                                }))
                            }
                        };
                        Ok(Self::Motion {
                            time,
                            relative_x,
                            relative_y,
                        })
                    }
                    PointerEventType::Button => {
                        let time = match data.get(2..6) {
                            Some(d) => u32::from_be_bytes(d.try_into()?),
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 4 Bytes at index 2".into(),
                                }))
                            }
                        };
                        let button = match data.get(6..10) {
                            Some(d) => u32::from_be_bytes(d.try_into()?),
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 4 Bytes at index 10".into(),
                                }))
                            }
                        };
                        let state = match data.get(10..14) {
                            Some(d) => u32::from_be_bytes(d.try_into()?),
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 4 Bytes at index 14".into(),
                                }))
                            }
                        };
                        Ok(Self::Button {
                            time,
                            button,
                            state,
                        })
                    }
                    PointerEventType::Axis => {
                        let time = match data.get(2..6) {
                            Some(d) => u32::from_be_bytes(d.try_into()?),
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 4 Bytes at index 2".into(),
                                }))
                            }
                        };
                        let axis = match data.get(6) {
                            Some(d) => *d,
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 1 Byte at index 6".into(),
                                }));
                            }
                        };
                        let value = match data.get(7..15) {
                            Some(d) => f64::from_be_bytes(d.try_into()?),
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 8 Bytes at index 7".into(),
                                }));
                            }
                        };
                        Ok(Self::Axis { time, axis, value })
                    }
                    PointerEventType::AxisDiscrete120 => {
                        let axis = match data.get(2) {
                            Some(d) => *d,
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 1 Byte at index 2".into(),
                                }));
                            }
                        };
                        let value = match data.get(3..7) {
                            Some(d) => i32::from_be_bytes(d.try_into()?),
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 4 Bytes at index 3".into(),
                                }));
                            }
                        };
                        Ok(Self::AxisDiscrete120 { axis, value })
                    }
                    PointerEventType::Frame => Ok(Self::Frame {}),
                }
            }
            None => Err(anyhow!(ProtocolError {
                msg: "Expected an element at index 0".into(),
            })),
        }
    }
 }
 impl From<&KeyboardEvent> for Vec<u8> {
    fn from(event: &KeyboardEvent) -> Self {
        let id = vec![event.event_type() as u8];
        let data = match event {
            KeyboardEvent::Key { time, key, state } => {
                let time = time.to_be_bytes();
                let key = key.to_be_bytes();
                let state = state.to_be_bytes();
                [&time[..], &key[..], &state[..]].concat()
            }
            KeyboardEvent::Modifiers {
                mods_depressed,
                mods_latched,
                mods_locked,
                group,
            } => {
                let mods_depressed = mods_depressed.to_be_bytes();
                let mods_latched = mods_latched.to_be_bytes();
                let mods_locked = mods_locked.to_be_bytes();
                let group = group.to_be_bytes();
                [
                    &mods_depressed[..],
                    &mods_latched[..],
                    &mods_locked[..],
                    &group[..],
                ]
                .concat()
            }
        };
        [id, data].concat()
    }
 }
 impl TryFrom<Vec<u8>> for KeyboardEvent {
    type Error = anyhow::Error;
    fn try_from(data: Vec<u8>) -> Result<Self> {
        match data.get(1) {
            Some(id) => {
                let event_type = match id.to_owned().try_into() {
                    Ok(event_type) => event_type,
                    Err(e) => return Err(e),
                };
                match event_type {
                    KeyboardEventType::Key => {
                        let time = match data.get(2..6) {
                            Some(d) => u32::from_be_bytes(d.try_into()?),
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 4 Bytes at index 6".into(),
                                }))
                            }
                        };
                        let key = match data.get(6..10) {
                            Some(d) => u32::from_be_bytes(d.try_into()?),
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 4 Bytes at index 10".into(),
                                }))
                            }
                        };
                        let state = match data.get(10) {
                            Some(d) => *d,
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 1 Bytes at index 14".into(),
                                }))
                            }
                        };
                        Ok(KeyboardEvent::Key { time, key, state })
                    }
                    KeyboardEventType::Modifiers => {
                        let mods_depressed = match data.get(2..6) {
                            Some(d) => u32::from_be_bytes(d.try_into()?),
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 4 Bytes at index 6".into(),
                                }))
                            }
                        };
                        let mods_latched = match data.get(6..10) {
                            Some(d) => u32::from_be_bytes(d.try_into()?),
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 4 Bytes at index 10".into(),
                                }))
                            }
                        };
                        let mods_locked = match data.get(10..14) {
                            Some(d) => u32::from_be_bytes(d.try_into()?),
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 4 Bytes at index 14".into(),
                                }))
                            }
                        };
                        let group = match data.get(14..18) {
                            Some(d) => u32::from_be_bytes(d.try_into()?),
                            None => {
                                return Err(anyhow!(ProtocolError {
                                    msg: "Expected 4 Bytes at index 18".into(),
                                }))
                            }
                        };
                        Ok(KeyboardEvent::Modifiers {
                            mods_depressed,
                            mods_latched,
                            mods_locked,
                            group,
                        })
                    }
                }
            }
            None => Err(anyhow!(ProtocolError {
                msg: "Expected an element at index 0".into(),
            })),
        }
    }
 }
--- a/input-event/src/libei.rs
+++ b/input-event/src/libei.rs
@@ -1,146 +0,0 @@
 use reis::{
    ei::{button::ButtonState, keyboard::KeyState},
    event::EiEvent,
 };
 use crate::{Event, KeyboardEvent, PointerEvent};
 impl Event {
    pub fn from_ei_event(ei_event: EiEvent) -> impl Iterator<Item = Self> {
        to_input_events(ei_event).into_iter()
    }
 }
 enum Events {
    None,
    One(Event),
    Two(Event, Event),
 }
 impl Events {
    fn into_iter(self) -> impl Iterator<Item = Event> {
        EventIterator::new(self)
    }
 }
 struct EventIterator {
    events: [Option<Event>; 2],
    pos: usize,
 }
 impl EventIterator {
    fn new(events: Events) -> Self {
        let events = match events {
            Events::None => [None, None],
            Events::One(e) => [Some(e), None],
            Events::Two(e, f) => [Some(e), Some(f)],
        };
        Self { events, pos: 0 }
    }
 }
 impl Iterator for EventIterator {
    type Item = Event;
    fn next(&mut self) -> Option<Self::Item> {
        let res = if self.pos >= self.events.len() {
            None
        } else {
            self.events[self.pos]
        };
        self.pos += 1;
        res
    }
 }
 fn to_input_events(ei_event: EiEvent) -> Events {
    match ei_event {
        EiEvent::KeyboardModifiers(mods) => {
            let modifier_event = KeyboardEvent::Modifiers {
                mods_depressed: mods.depressed,
                mods_latched: mods.latched,
                mods_locked: mods.locked,
                group: mods.group,
            };
            Events::One(Event::Keyboard(modifier_event))
        }
        EiEvent::Frame(_) => Events::None, /* FIXME */
        EiEvent::PointerMotion(motion) => {
            let motion_event = PointerEvent::Motion {
                time: motion.time as u32,
                dx: motion.dx as f64,
                dy: motion.dy as f64,
            };
            Events::One(Event::Pointer(motion_event))
        }
        EiEvent::PointerMotionAbsolute(_) => Events::None,
        EiEvent::Button(button) => {
            let button_event = PointerEvent::Button {
                time: button.time as u32,
                button: button.button,
                state: match button.state {
                    ButtonState::Released => 0,
                    ButtonState::Press => 1,
                },
            };
            Events::One(Event::Pointer(button_event))
        }
        EiEvent::ScrollDelta(delta) => {
            let dy = Event::Pointer(PointerEvent::Axis {
                time: 0,
                axis: 0,
                value: delta.dy as f64,
            });
            let dx = Event::Pointer(PointerEvent::Axis {
                time: 0,
                axis: 1,
                value: delta.dx as f64,
            });
            if delta.dy != 0. && delta.dx != 0. {
                Events::Two(dy, dx)
            } else if delta.dy != 0. {
                Events::One(dy)
            } else if delta.dx != 0. {
                Events::One(dx)
            } else {
                Events::None
            }
        }
        EiEvent::ScrollStop(_) => Events::None,   /* TODO */
        EiEvent::ScrollCancel(_) => Events::None, /* TODO */
        EiEvent::ScrollDiscrete(scroll) => {
            let dy = Event::Pointer(PointerEvent::AxisDiscrete120 {
                axis: 0,
                value: scroll.discrete_dy,
            });
            let dx = Event::Pointer(PointerEvent::AxisDiscrete120 {
                axis: 1,
                value: scroll.discrete_dx,
            });
            if scroll.discrete_dy != 0 && scroll.discrete_dx != 0 {
                Events::Two(dy, dx)
            } else if scroll.discrete_dy != 0 {
                Events::One(dy)
            } else if scroll.discrete_dx != 0 {
                Events::One(dx)
            } else {
                Events::None
            }
        }
        EiEvent::KeyboardKey(key) => {
            let key_event = KeyboardEvent::Key {
                key: key.key,
                state: match key.state {
                    KeyState::Press => 1,
                    KeyState::Released => 0,
                },
                time: key.time as u32,
            };
            Events::One(Event::Keyboard(key_event))
        }
        EiEvent::TouchDown(_) => Events::None,   /* TODO */
        EiEvent::TouchUp(_) => Events::None,     /* TODO */
        EiEvent::TouchMotion(_) => Events::None, /* TODO */
        _ => Events::None,
    }
 }
--- a/input-event/src/proto.rs
+++ b/input-event/src/proto.rs
@@ -1,307 +0,0 @@
 use std::{fmt::Debug, slice::SliceIndex};
 use crate::ProtocolError;
 use super::{Event, KeyboardEvent, PointerEvent};
 enum PointerEventType {
    Motion,
    Button,
    Axis,
    AxisDiscrete120,
    Frame,
 }
 enum KeyboardEventType {
    Key,
    Modifiers,
 }
 enum EventType {
    Pointer,
    Keyboard,
    Enter,
    Leave,
    Ping,
    Pong,
    Disconnect,
 }
 impl Event {
    fn event_type(&self) -> EventType {
        match self {
            Self::Pointer(_) => EventType::Pointer,
            Self::Keyboard(_) => EventType::Keyboard,
            Self::Enter() => EventType::Enter,
            Self::Leave() => EventType::Leave,
            Self::Ping() => EventType::Ping,
            Self::Pong() => EventType::Pong,
            Self::Disconnect() => EventType::Disconnect,
        }
    }
 }
 impl PointerEvent {
    fn event_type(&self) -> PointerEventType {
        match self {
            Self::Motion { .. } => PointerEventType::Motion,
            Self::Button { .. } => PointerEventType::Button,
            Self::Axis { .. } => PointerEventType::Axis,
            Self::AxisDiscrete120 { .. } => PointerEventType::AxisDiscrete120,
            Self::Frame { .. } => PointerEventType::Frame,
        }
    }
 }
 impl KeyboardEvent {
    fn event_type(&self) -> KeyboardEventType {
        match self {
            KeyboardEvent::Key { .. } => KeyboardEventType::Key,
            KeyboardEvent::Modifiers { .. } => KeyboardEventType::Modifiers,
        }
    }
 }
 impl TryFrom<u8> for PointerEventType {
    type Error = ProtocolError;
    fn try_from(value: u8) -> Result<Self, ProtocolError> {
        match value {
            x if x == Self::Motion as u8 => Ok(Self::Motion),
            x if x == Self::Button as u8 => Ok(Self::Button),
            x if x == Self::Axis as u8 => Ok(Self::Axis),
            x if x == Self::AxisDiscrete120 as u8 => Ok(Self::AxisDiscrete120),
            x if x == Self::Frame as u8 => Ok(Self::Frame),
            _ => Err(ProtocolError::InvalidPointerEventId(value)),
        }
    }
 }
 impl TryFrom<u8> for KeyboardEventType {
    type Error = ProtocolError;
    fn try_from(value: u8) -> Result<Self, ProtocolError> {
        match value {
            x if x == Self::Key as u8 => Ok(Self::Key),
            x if x == Self::Modifiers as u8 => Ok(Self::Modifiers),
            _ => Err(ProtocolError::InvalidKeyboardEventId(value)),
        }
    }
 }
 impl From<&Event> for Vec<u8> {
    fn from(event: &Event) -> Self {
        let event_id = vec![event.event_type() as u8];
        let event_data = match event {
            Event::Pointer(p) => p.into(),
            Event::Keyboard(k) => k.into(),
            Event::Enter() => vec![],
            Event::Leave() => vec![],
            Event::Ping() => vec![],
            Event::Pong() => vec![],
            Event::Disconnect() => vec![],
        };
        [event_id, event_data].concat()
    }
 }
 impl TryFrom<Vec<u8>> for Event {
    type Error = ProtocolError;
    fn try_from(value: Vec<u8>) -> Result<Self, ProtocolError> {
        let event_id = u8::from_be_bytes(value[..1].try_into()?);
        match event_id {
            i if i == (EventType::Pointer as u8) => Ok(Event::Pointer(value.try_into()?)),
            i if i == (EventType::Keyboard as u8) => Ok(Event::Keyboard(value.try_into()?)),
            i if i == (EventType::Enter as u8) => Ok(Event::Enter()),
            i if i == (EventType::Leave as u8) => Ok(Event::Leave()),
            i if i == (EventType::Ping as u8) => Ok(Event::Ping()),
            i if i == (EventType::Pong as u8) => Ok(Event::Pong()),
            i if i == (EventType::Disconnect as u8) => Ok(Event::Disconnect()),
            _ => Err(ProtocolError::InvalidEventId(event_id)),
        }
    }
 }
 impl From<&PointerEvent> for Vec<u8> {
    fn from(event: &PointerEvent) -> Self {
        let id = vec![event.event_type() as u8];
        let data = match event {
            PointerEvent::Motion { time, dx, dy } => {
                let time = time.to_be_bytes();
                let dx = dx.to_be_bytes();
                let dy = dy.to_be_bytes();
                [&time[..], &dx[..], &dy[..]].concat()
            }
            PointerEvent::Button {
                time,
                button,
                state,
            } => {
                let time = time.to_be_bytes();
                let button = button.to_be_bytes();
                let state = state.to_be_bytes();
                [&time[..], &button[..], &state[..]].concat()
            }
            PointerEvent::Axis { time, axis, value } => {
                let time = time.to_be_bytes();
                let axis = axis.to_be_bytes();
                let value = value.to_be_bytes();
                [&time[..], &axis[..], &value[..]].concat()
            }
            PointerEvent::AxisDiscrete120 { axis, value } => {
                let axis = axis.to_be_bytes();
                let value = value.to_be_bytes();
                [&axis[..], &value[..]].concat()
            }
            PointerEvent::Frame {} => {
                vec![]
            }
        };
        [id, data].concat()
    }
 }
 fn decode_u8<I>(data: &[u8], idx: I) -> Result<u8, ProtocolError>
 where
    I: SliceIndex<[u8], Output = [u8]> + Debug + Clone,
 {
    let data = data
        .get(idx.clone())
        .ok_or(ProtocolError::Data(format!("{:?}", idx)))?;
    Ok(u8::from_be_bytes(data.try_into()?))
 }
 fn decode_u32<I>(data: &[u8], idx: I) -> Result<u32, ProtocolError>
 where
    I: SliceIndex<[u8], Output = [u8]> + Debug + Clone,
 {
    let data = data
        .get(idx.clone())
        .ok_or(ProtocolError::Data(format!("{:?}", idx)))?;
    Ok(u32::from_be_bytes(data.try_into()?))
 }
 fn decode_i32<I>(data: &[u8], idx: I) -> Result<i32, ProtocolError>
 where
    I: SliceIndex<[u8], Output = [u8]> + Debug + Clone,
 {
    let data = data
        .get(idx.clone())
        .ok_or(ProtocolError::Data(format!("{:?}", idx)))?;
    Ok(i32::from_be_bytes(data.try_into()?))
 }
 fn decode_f64<I>(data: &[u8], idx: I) -> Result<f64, ProtocolError>
 where
    I: SliceIndex<[u8], Output = [u8]> + Debug + Clone,
 {
    let data = data
        .get(idx.clone())
        .ok_or(ProtocolError::Data(format!("{:?}", idx)))?;
    Ok(f64::from_be_bytes(data.try_into()?))
 }
 impl TryFrom<Vec<u8>> for PointerEvent {
    type Error = ProtocolError;
    fn try_from(data: Vec<u8>) -> Result<Self, ProtocolError> {
        match data.get(1) {
            Some(id) => match id.to_owned().try_into()? {
                PointerEventType::Motion => {
                    let time = decode_u32(&data, 2..6)?;
                    let dx = decode_f64(&data, 6..14)?;
                    let dy = decode_f64(&data, 14..22)?;
                    Ok(Self::Motion { time, dx, dy })
                }
                PointerEventType::Button => {
                    let time = decode_u32(&data, 2..6)?;
                    let button = decode_u32(&data, 6..10)?;
                    let state = decode_u32(&data, 10..14)?;
                    Ok(Self::Button {
                        time,
                        button,
                        state,
                    })
                }
                PointerEventType::Axis => {
                    let time = decode_u32(&data, 2..6)?;
                    let axis = decode_u8(&data, 6..7)?;
                    let value = decode_f64(&data, 7..15)?;
                    Ok(Self::Axis { time, axis, value })
                }
                PointerEventType::AxisDiscrete120 => {
                    let axis = decode_u8(&data, 2..3)?;
                    let value = decode_i32(&data, 3..7)?;
                    Ok(Self::AxisDiscrete120 { axis, value })
                }
                PointerEventType::Frame => Ok(Self::Frame {}),
            },
            None => Err(ProtocolError::Data("0".to_string())),
        }
    }
 }
 impl From<&KeyboardEvent> for Vec<u8> {
    fn from(event: &KeyboardEvent) -> Self {
        let id = vec![event.event_type() as u8];
        let data = match event {
            KeyboardEvent::Key { time, key, state } => {
                let time = time.to_be_bytes();
                let key = key.to_be_bytes();
                let state = state.to_be_bytes();
                [&time[..], &key[..], &state[..]].concat()
            }
            KeyboardEvent::Modifiers {
                mods_depressed,
                mods_latched,
                mods_locked,
                group,
            } => {
                let mods_depressed = mods_depressed.to_be_bytes();
                let mods_latched = mods_latched.to_be_bytes();
                let mods_locked = mods_locked.to_be_bytes();
                let group = group.to_be_bytes();
                [
                    &mods_depressed[..],
                    &mods_latched[..],
                    &mods_locked[..],
                    &group[..],
                ]
                .concat()
            }
        };
        [id, data].concat()
    }
 }
 impl TryFrom<Vec<u8>> for KeyboardEvent {
    type Error = ProtocolError;
    fn try_from(data: Vec<u8>) -> Result<Self, ProtocolError> {
        match data.get(1) {
            Some(id) => match id.to_owned().try_into()? {
                KeyboardEventType::Key => {
                    let time = decode_u32(&data, 2..6)?;
                    let key = decode_u32(&data, 6..10)?;
                    let state = decode_u8(&data, 10..11)?;
                    Ok(KeyboardEvent::Key { time, key, state })
                }
                KeyboardEventType::Modifiers => {
                    let mods_depressed = decode_u32(&data, 2..6)?;
                    let mods_latched = decode_u32(&data, 6..10)?;
                    let mods_locked = decode_u32(&data, 10..14)?;
                    let group = decode_u32(&data, 14..18)?;
                    Ok(KeyboardEvent::Modifiers {
                        mods_depressed,
                        mods_latched,
                        mods_locked,
                        group,
                    })
                }
            },
            None => Err(ProtocolError::Data("0".to_string())),
        }
    }
 }
--- a/nix/default.nix
+++ b/nix/default.nix
@@ -14,7 +14,6 @@ rustPlatform.buildRustPackage {
  nativeBuildInputs = with pkgs; [
    pkg-config
    cmake
    makeWrapper
    buildPackages.gtk4
  ];
@@ -37,12 +36,6 @@ rustPlatform.buildRustPackage {
  # Set Environment Variables
  RUST_BACKTRACE = "full";
  # Needed to enable support for SVG icons in GTK
  postInstall = ''
    wrapProgram "$out/bin/lan-mouse" \
      --set GDK_PIXBUF_MODULE_FILE ${pkgs.librsvg.out}/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache
  '';
  meta = with lib; {
    description = "Lan Mouse is a mouse and keyboard sharing software";
    longDescription = ''
--- a/resources/client_row.ui
+++ b/resources/client_row.ui
@@ -44,7 +44,6 @@
 				<child>
 					<object class="GtkEntry" id="port">
 						<!-- <property name="title" translatable="yes">port</property> -->
                        <property name="max-width-chars">5</property>
 						<property name="input_purpose">GTK_INPUT_PURPOSE_NUMBER</property>
 						<property name="xalign">0.5</property>
 						<property name="valign">center</property>
--- a/resources/window.ui
+++ b/resources/window.ui
@@ -1,227 +1,167 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <interface>
-  <requires lib="gtk" version="4.0"/>
+	<requires lib="gtk" version="4.0"/>
-  <requires lib="libadwaita" version="1.0"/>
+	<requires lib="libadwaita" version="1.0"/>
-  <menu id="main-menu">
+	<menu id="main-menu">
-    <item>
+		<item>
-      <attribute name="label" translatable="yes">_Close window</attribute>
+			<attribute name="label" translatable="yes">_Close window</attribute>
-      <attribute name="action">window.close</attribute>
+			<attribute name="action">window.close</attribute>
-    </item>
+		</item>
-  </menu>
+	</menu>
-  <template class="LanMouseWindow" parent="AdwApplicationWindow">
+	<template class="LanMouseWindow" parent="AdwApplicationWindow">
-    <property name="width-request">600</property>
+		<property name="width-request">600</property>
-    <property name="height-request">700</property>
+		<property name="height-request">700</property>
-    <property name="title" translatable="yes">Lan Mouse</property>
+		<property name="title" translatable="yes">Lan Mouse</property>
-    <property name="show-menubar">True</property>
+		<property name="show-menubar">True</property>
-    <property name="content">
+		<property name="content">
-      <object class="GtkBox">
+			<object class="GtkBox">
-        <property name="orientation">vertical</property>
+				<property name="orientation">vertical</property>
-        <child type="top">
+				<child type="top">
-          <object class="AdwHeaderBar">
+					<object class="AdwHeaderBar">
-            <child type ="end">
+						<child type ="end">
-              <object class="GtkMenuButton">
+							<object class="GtkMenuButton">
-                <property name="icon-name">open-menu-symbolic</property>
+								<property name="icon-name">open-menu-symbolic</property>
-                <property name="menu-model">main-menu</property>
+								<property name="menu-model">main-menu</property>
-              </object>
+							</object>
-            </child>
+						</child>
-            <style>
+						<style>
-              <class name="flat"/>
+							<class name="flat"/>
-            </style>
+						</style>
-          </object>
+					</object>
-        </child>
+				</child>
-        <child>
+				<child>
-          <object class="AdwToastOverlay" id="toast_overlay">
+					<object class="AdwToastOverlay" id="toast_overlay">
-            <child>
+						<child>
-              <object class="AdwStatusPage">
+							<object class="AdwStatusPage">
-                <property name="title" translatable="yes">Lan Mouse</property>
+								<property name="title" translatable="yes">Lan Mouse</property>
-                <property name="description" translatable="yes">easily use your mouse and keyboard on multiple computers</property>
+								<property name="description" translatable="yes">easily use your mouse and keyboard on multiple computers</property>
-                <property name="icon-name">de.feschber.LanMouse</property>
+								<property name="icon-name">de.feschber.LanMouse</property>
-                <property name="child">
+								<property name="child">
-                  <object class="AdwClamp">
+								  <object class="AdwClamp">
-                  <property name="maximum-size">600</property>
+									<property name="maximum-size">600</property>
-                  <property name="tightening-threshold">0</property>
+									<property name="tightening-threshold">0</property>
-                  <property name="child">
+									<property name="child">
-                    <object class="GtkBox">
+									  <object class="GtkBox">
-                    <property name="orientation">vertical</property>
+										<property name="orientation">vertical</property>
-                    <property name="spacing">12</property>
+										<property name="spacing">12</property>
-                    <child>
+										<child>
-                      <object class="AdwPreferencesGroup" id="capture_emulation_group">
+											<object class="AdwPreferencesGroup">
-                      <property name="title" translatable="yes">Capture / Emulation Status</property>
+												<property name="title" translatable="yes">General</property>
-                        <child>
+												<!--
-                          <object class="AdwActionRow" id="capture_status_row">
+												<child>
-                            <property name="title">input capture is disabled</property>
+													<object class="AdwActionRow">
-                            <property name="subtitle">required for outgoing and incoming connections</property>
+														<property name="title" translatable="yes">enable</property>
-                            <property name="icon-name">dialog-warning-symbolic</property>
+														<child type="suffix">
-                            <child>
+															<object class="GtkSwitch">
-                              <object class="GtkButton" id="input_capture_button">
+																<property name="valign">center</property>
-                                <property name="child">
+																<property name="tooltip-text" translatable="yes">enable</property>
-                                  <object class="AdwButtonContent">
+															</object>
-                                    <property name="icon-name">object-rotate-right-symbolic</property>
+														</child>
-                                    <property name="label" translatable="yes">Reenable</property>
+													</object>
-                                  </object>
+												</child>
-                                </property>
+												-->
-                                <signal name="clicked" handler="handle_capture" swapped="true"/>
+												<child>
-                                <property name="valign">center</property>
+													<object class="AdwActionRow">
-                                <style>
+														<property name="title">port</property>
-                                  <class name="circular"/>
+														<child>
-                                  <class name="flat"/>
+															<object class="GtkEntry" id="port_entry">
-                                </style>
+																<signal name="activate" handler="handle_port_edit_apply" swapped="true"/>
-                              </object>
+																<signal name="changed" handler="handle_port_changed" swapped="true"/>
-                            </child>
+																<!-- <signal name="delete-text" handler="handle_port_changed" swapped="true"/> -->
-                            <style>
+																<!-- <property name="title" translatable="yes">port</property> -->
-                              <class name="warning"/>
+																<property name="placeholder-text">4242</property>
-                            </style>
+																<property name="width-chars">5</property>
-                          </object>
+																<property name="xalign">0.5</property>
-                        </child>
+																<property name="valign">center</property>
-                        <child>
+																<!-- <property name="show-apply-button">True</property> -->
-                          <object class="AdwActionRow" id="emulation_status_row">
+																<property name="input-purpose">GTK_INPUT_PURPOSE_DIGITS</property>
-                            <property name="title">input emulation is disabled</property>
+															</object>
-                            <property name="subtitle">required for incoming connections</property>
+														</child>
-                            <property name="icon-name">dialog-warning-symbolic</property>
+														<child>
-                            <child>
+															<object class="GtkButton" id="port_edit_apply">
-                              <object class="GtkButton" id="input_emulation_button">
+																<signal name="clicked" handler="handle_port_edit_apply" swapped="true"/>
-                                <property name="child">
+																<property name="icon-name">object-select-symbolic</property>
-                                  <object class="AdwButtonContent">
+																<property name="valign">center</property>
-                                    <property name="icon-name">object-rotate-right-symbolic</property>
+																<property name="visible">false</property>
-                                    <property name="label" translatable="yes">Reenable</property>
+																<property name="name">port-edit-apply</property>
-                                  </object>
+																<style><class name="success"/></style>
-                                </property>
+															</object>
-                                <property name="valign">center</property>
+														</child>
-                                <signal name="clicked" handler="handle_emulation" swapped="true"/>
+														<child>
-                                <style>
+															<object class="GtkButton" id="port_edit_cancel">
-                                  <class name="circular"/>
+																<signal name="clicked" handler="handle_port_edit_cancel" swapped="true"/>
-                                  <class name="flat"/>
+																<property name="icon-name">process-stop-symbolic</property>
-                                </style>
+																<property name="valign">center</property>
-                              </object>
+																<property name="visible">false</property>
-                            </child>
+																<property name="name">port-edit-cancel</property>
-                            <child>
+																<style><class name="error"/></style>
-                            </child>
+															</object>
-                            <style>
+														</child>
-                              <class name="warning"/>
+													</object>
-                            </style>
+												</child>
-                          </object>
+												<child>
-                        </child>
+													<object class="AdwActionRow">
-                      </object>
+														<property name="title">hostname</property>
-                    </child>
+														<child>
-                    <child>
+															<object class="GtkLabel" id="hostname_label">
-                      <object class="AdwPreferencesGroup">
+																<property name="label">&lt;span font_style=&quot;italic&quot; font_weight=&quot;light&quot; foreground=&quot;darkgrey&quot;&gt;could not determine hostname&lt;/span&gt;</property>
-                        <property name="title" translatable="yes">General</property>
+																<property name="use-markup">true</property>
-                        <!--
+																<property name="valign">center</property>
-                        <child>
+															</object>
-                          <object class="AdwActionRow">
+														</child>
-                            <property name="title" translatable="yes">enable</property>
+														<child>
-                            <child type="suffix">
+															<object class="GtkButton" id="copy-hostname-button">
-                              <object class="GtkSwitch">
+																<property name="icon-name">edit-copy-symbolic</property>
-                                <property name="valign">center</property>
+																<property name="valign">center</property>
-                                <property name="tooltip-text" translatable="yes">enable</property>
+																<signal name="clicked" handler="handle_copy_hostname" swapped="true"/>
-                              </object>
+															</object>
-                            </child>
+														</child>
-                          </object>
+													</object>
-                        </child>
+												</child>
-                        -->
+											</object>
-                        <child>
+										</child>
-                          <object class="AdwActionRow">
+										<child>
-                            <property name="title">port</property>
+											<object class="AdwPreferencesGroup">
-                            <child>
+												<property name="title" translatable="yes">Connections</property>
-                              <object class="GtkEntry" id="port_entry">
+												<property name="header-suffix">
-                                <property name="max-width-chars">5</property>
+													<object class="GtkButton">
-                                <signal name="activate" handler="handle_port_edit_apply" swapped="true"/>
+														<signal name="clicked" handler="handle_add_client_pressed" swapped="true"/>
-                                <signal name="changed" handler="handle_port_changed" swapped="true"/>
+														<property name="child">
-                                <!-- <signal name="delete-text" handler="handle_port_changed" swapped="true"/> -->
+															<object class="AdwButtonContent">
-                                <!-- <property name="title" translatable="yes">port</property> -->
+																<property name="icon-name">list-add-symbolic</property>
-                                <property name="placeholder-text">4242</property>
+																<property name="label" translatable="yes">Add</property>
-                                <property name="width-chars">5</property>
+															</object>
-                                <property name="xalign">0.5</property>
+														</property>
-                                <property name="valign">center</property>
+													<style>
-                                <!-- <property name="show-apply-button">True</property> -->
+														<class name="flat"/>
-                                <property name="input-purpose">GTK_INPUT_PURPOSE_DIGITS</property>
+													</style>
-                              </object>
+													</object>
-                            </child>
+												</property>
-                            <child>
+												<child>
-                              <object class="GtkButton" id="port_edit_apply">
+												  <object class="GtkListBox" id="client_list">
-                                <signal name="clicked" handler="handle_port_edit_apply" swapped="true"/>
+														<property name="selection-mode">none</property>
-                                <property name="icon-name">object-select-symbolic</property>
+														<child type="placeholder">
-                                <property name="valign">center</property>
+															<object class="AdwActionRow" id="client_placeholder">
-                                <property name="visible">false</property>
+																<property name="title">No connections!</property>
-                                <property name="name">port-edit-apply</property>
+																<property name="subtitle">add a new client via the + button</property>
-                                <style><class name="success"/></style>
+															</object>
-                              </object>
+														</child>
-                            </child>
+														<style>
-                            <child>
+															<class name="boxed-list" />
-                              <object class="GtkButton" id="port_edit_cancel">
+														</style>
-                                <signal name="clicked" handler="handle_port_edit_cancel" swapped="true"/>
+												  </object>
-                                <property name="icon-name">process-stop-symbolic</property>
+												</child>
-                                <property name="valign">center</property>
+											</object>
-                                <property name="visible">false</property>
+										</child>
-                                <property name="name">port-edit-cancel</property>
+									  </object>
-                                <style><class name="error"/></style>
+									</property>
-                              </object>
+								  </object>
-                            </child>
+							  </property>
-                          </object>
+							</object>
-                        </child>
+						</child>
-                        <child>
+					</object>
-                          <object class="AdwActionRow">
+				</child>
-                            <property name="title">hostname</property>
+			</object>
-                            <child>
+		</property>
-                              <object class="GtkLabel" id="hostname_label">
+	</template>
                                <property name="label">&lt;span font_style=&quot;italic&quot; font_weight=&quot;light&quot; foreground=&quot;darkgrey&quot;&gt;could not determine hostname&lt;/span&gt;</property>
                                <property name="use-markup">true</property>
                                <property name="valign">center</property>
                              </object>
                            </child>
                            <child>
                              <object class="GtkButton" id="copy-hostname-button">
                                <property name="icon-name">edit-copy-symbolic</property>
                                <property name="valign">center</property>
                                <signal name="clicked" handler="handle_copy_hostname" swapped="true"/>
                              </object>
                            </child>
                          </object>
                        </child>
                      </object>
                    </child>
                    <child>
                      <object class="AdwPreferencesGroup">
                        <property name="title" translatable="yes">Connections</property>
                        <property name="header-suffix">
                          <object class="GtkButton">
                            <signal name="clicked" handler="handle_add_client_pressed" swapped="true"/>
                            <property name="child">
                              <object class="AdwButtonContent">
                                <property name="icon-name">list-add-symbolic</property>
                                <property name="label" translatable="yes">Add</property>
                              </object>
                            </property>
                          <style>
                            <class name="flat"/>
                          </style>
                          </object>
                        </property>
                        <child>
                          <object class="GtkListBox" id="client_list">
                            <property name="selection-mode">none</property>
                            <child type="placeholder">
                              <object class="AdwActionRow" id="client_placeholder">
                                <property name="title">No connections!</property>
                                <property name="subtitle">add a new client via the + button</property>
                              </object>
                            </child>
                            <style>
                              <class name="boxed-list" />
                            </style>
                          </object>
                        </child>
                      </object>
                    </child>
                    </object>
                  </property>
                  </object>
                </property>
              </object>
            </child>
          </object>
        </child>
      </object>
    </property>
  </template>
 </interface>
--- a/src/capture_test.rs
+++ b/src/capture_test.rs
@@ -1,10 +1,11 @@
 use crate::config::Config;
 use anyhow::{anyhow, Result};
 use futures::StreamExt;
-use input_capture::{self, CaptureError, InputCapture, InputCaptureError, Position};
+use input_capture::{self, Position};
 use input_event::{Event, KeyboardEvent};
 use tokio::task::LocalSet;
-pub fn run() -> anyhow::Result<()> {
+pub fn run() -> Result<()> {
    log::info!("running input capture test");
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_io()
@@ -13,32 +14,23 @@ pub fn run() -> anyhow::Result<()> {
    let config = Config::new()?;
-    Ok(runtime.block_on(LocalSet::new().run_until(input_capture_test(config)))?)
+    runtime.block_on(LocalSet::new().run_until(input_capture_test(config)))
 }
-async fn input_capture_test(config: Config) -> Result<(), InputCaptureError> {
+async fn input_capture_test(config: Config) -> Result<()> {
    log::info!("creating input capture");
    let backend = config.capture_backend.map(|b| b.into());
-    loop {
+    let mut input_capture = input_capture::create(backend).await?;
-        let mut input_capture = input_capture::create(backend).await?;
+    log::info!("creating clients");
-        log::info!("creating clients");
+    input_capture.create(0, Position::Left)?;
-        input_capture.create(0, Position::Left).await?;
+    input_capture.create(1, Position::Right)?;
-        input_capture.create(1, Position::Right).await?;
+    input_capture.create(2, Position::Top)?;
-        input_capture.create(2, Position::Top).await?;
+    input_capture.create(3, Position::Bottom)?;
        input_capture.create(3, Position::Bottom).await?;
        if let Err(e) = do_capture(&mut input_capture).await {
            log::warn!("{e} - recreating capture");
        }
        let _ = input_capture.terminate().await;
    }
 }
 async fn do_capture(input_capture: &mut Box<dyn InputCapture>) -> Result<(), CaptureError> {
    loop {
        let (client, event) = input_capture
            .next()
            .await
-            .ok_or(CaptureError::EndOfStream)??;
+            .ok_or(anyhow!("capture stream closed"))??;
        let pos = match client {
            0 => Position::Left,
            1 => Position::Right,
@@ -47,8 +39,7 @@ async fn do_capture(input_capture: &mut Box<dyn InputCapture>) -> Result<(), Cap
        };
        log::info!("position: {pos}, event: {event}");
        if let Event::Keyboard(KeyboardEvent::Key { key: 1, .. }) = event {
-            input_capture.release().await?;
+            input_capture.release()?;
            break Ok(());
        }
    }
 }
--- a/src/client.rs
+++ b/src/client.rs
@@ -1,5 +1,6 @@
 use std::{
    collections::HashSet,
    error::Error,
    fmt::Display,
    net::{IpAddr, SocketAddr},
    str::FromStr,
@@ -7,20 +8,24 @@ use std::{
 use serde::{Deserialize, Serialize};
 use slab::Slab;
 use thiserror::Error;
 use crate::config::DEFAULT_PORT;
 use input_capture;
-#[derive(Debug, Default, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
+#[derive(Debug, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
 pub enum Position {
    #[default]
    Left,
    Right,
    Top,
    Bottom,
 }
 impl Default for Position {
    fn default() -> Self {
        Self::Left
    }
 }
 impl From<Position> for input_capture::Position {
    fn from(position: Position) -> input_capture::Position {
        match position {
@@ -32,12 +37,19 @@ impl From<Position> for input_capture::Position {
    }
 }
-#[derive(Debug, Error)]
+#[derive(Debug)]
 #[error("not a valid position: {pos}")]
 pub struct PositionParseError {
-    pos: String,
+    string: String,
 }
 impl Display for PositionParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "not a valid position: {}", self.string)
    }
 }
 impl Error for PositionParseError {}
 impl FromStr for Position {
    type Err = PositionParseError;
@@ -47,7 +59,7 @@ impl FromStr for Position {
            "right" => Ok(Self::Right),
            "top" => Ok(Self::Top),
            "bottom" => Ok(Self::Bottom),
-            _ => Err(PositionParseError { pos: s.into() }),
+            _ => Err(PositionParseError { string: s.into() }),
        }
    }
 }
@@ -119,8 +131,6 @@ pub struct ClientState {
    pub active_addr: Option<SocketAddr>,
    /// tracks whether or not the client is responding to pings
    pub alive: bool,
    /// ips from dns
    pub dns_ips: Vec<IpAddr>,
    /// all ip addresses associated with a particular client
    /// e.g. Laptops usually have at least an ethernet and a wifi port
    /// which have different ip addresses
@@ -131,15 +141,27 @@ pub struct ClientState {
    pub resolving: bool,
 }
 #[derive(Default)]
 pub struct ClientManager {
    clients: Slab<(ClientConfig, ClientState)>,
 }
 impl Default for ClientManager {
    fn default() -> Self {
        Self::new()
    }
 }
 impl ClientManager {
    pub fn new() -> Self {
        let clients = Slab::new();
        Self { clients }
    }
    /// add a new client to this manager
    pub fn add_client(&mut self) -> ClientHandle {
-        self.clients.insert(Default::default()) as ClientHandle
+        let client_config = Default::default();
        let client_state = Default::default();
        self.clients.insert((client_config, client_state)) as ClientHandle
    }
    /// find a client by its address
--- a/src/dns.rs
+++ b/src/dns.rs
@@ -1,62 +1,23 @@
-use std::net::IpAddr;
+use anyhow::Result;
-use tokio::sync::mpsc::Receiver;
+use std::{error::Error, net::IpAddr};
-use hickory_resolver::{error::ResolveError, TokioAsyncResolver};
+use hickory_resolver::TokioAsyncResolver;
-use crate::{client::ClientHandle, server::Server};
+pub struct DnsResolver {
 pub(crate) struct DnsResolver {
    resolver: TokioAsyncResolver,
    dns_request: Receiver<ClientHandle>,
 }
 impl DnsResolver {
-    pub(crate) fn new(dns_request: Receiver<ClientHandle>) -> Result<Self, ResolveError> {
+    pub(crate) async fn new() -> Result<Self> {
        let resolver = TokioAsyncResolver::tokio_from_system_conf()?;
-        Ok(Self {
+        Ok(Self { resolver })
            resolver,
            dns_request,
        })
    }
-    async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, ResolveError> {
+    pub(crate) async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, Box<dyn Error>> {
        log::info!("resolving {host} ...");
        let response = self.resolver.lookup_ip(host).await?;
        for ip in response.iter() {
            log::info!("{host}: adding ip {ip}");
        }
        Ok(response.iter().collect())
    }
    pub(crate) async fn run(mut self, server: Server) {
        tokio::select! {
            _ = server.cancelled() => {},
            _ = self.do_dns(&server) => {},
        }
    }
    async fn do_dns(&mut self, server: &Server) {
        loop {
            let handle = self.dns_request.recv().await.expect("channel closed");
            /* update resolving status */
            let hostname = match server.get_hostname(handle) {
                Some(hostname) => hostname,
                None => continue,
            };
            log::info!("resolving ({handle}) `{hostname}` ...");
            server.set_resolving(handle, true);
            let ips = match self.resolve(&hostname).await {
                Ok(ips) => ips,
                Err(e) => {
                    log::warn!("could not resolve host '{hostname}': {e}");
                    vec![]
                }
            };
            server.update_dns_ips(handle, ips);
            server.set_resolving(handle, false);
        }
    }
 }
--- a/src/emulation_test.rs
+++ b/src/emulation_test.rs
@@ -37,8 +37,12 @@ async fn input_emulation_test(config: Config) -> Result<()> {
        if new_offset != offset {
            let relative_motion = (new_offset.0 - offset.0, new_offset.1 - offset.1);
            offset = new_offset;
-            let (dx, dy) = (relative_motion.0 as f64, relative_motion.1 as f64);
+            let (relative_x, relative_y) = (relative_motion.0 as f64, relative_motion.1 as f64);
-            let event = Event::Pointer(PointerEvent::Motion { time: 0, dx, dy });
+            let event = Event::Pointer(PointerEvent::Motion {
                time: 0,
                relative_x,
                relative_y,
            });
            emulation.consume(event, 0).await?;
        }
    }
--- a/src/frontend.rs
+++ b/src/frontend.rs
@@ -97,6 +97,8 @@ pub enum FrontendRequest {
    Enumerate(),
    /// resolve dns
    ResolveDns(ClientHandle),
    /// service shutdown
    Terminate(),
    /// update hostname
    UpdateHostname(ClientHandle, Option<String>),
    /// update port
@@ -107,26 +109,6 @@ pub enum FrontendRequest {
    UpdateFixIps(ClientHandle, Vec<IpAddr>),
    /// request the state of the given client
    GetState(ClientHandle),
    /// request reenabling input capture
    EnableCapture,
    /// request reenabling input emulation
    EnableEmulation,
 }
 #[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]
 pub enum Status {
    #[default]
    Disabled,
    Enabled,
 }
 impl From<Status> for bool {
    fn from(status: Status) -> Self {
        match status {
            Status::Enabled => true,
            Status::Disabled => false,
        }
    }
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -145,10 +127,6 @@ pub enum FrontendEvent {
    Enumerate(Vec<(ClientHandle, ClientConfig, ClientState)>),
    /// an error occured
    Error(String),
    /// capture status
    CaptureStatus(Status),
    /// emulation status
    EmulationStatus(Status),
 }
 pub struct FrontendListener {
@@ -254,7 +232,7 @@ impl FrontendListener {
        Ok(rx)
    }
-    pub(crate) async fn broadcast(&mut self, notify: FrontendEvent) {
+    pub(crate) async fn broadcast_event(&mut self, notify: FrontendEvent) -> Result<()> {
        // encode event
        let json = serde_json::to_string(&notify).unwrap();
        let payload = json.as_bytes();
@@ -278,6 +256,7 @@ impl FrontendListener {
        // could not find a better solution because async
        let mut keep = keep.into_iter();
        self.tx_streams.retain(|_| keep.next().unwrap());
        Ok(())
    }
 }
--- a/src/frontend/cli.rs
+++ b/src/frontend/cli.rs
@@ -273,12 +273,6 @@ impl<'a> Cli<'a> {
            FrontendEvent::Error(e) => {
                eprintln!("ERROR: {e}");
            }
            FrontendEvent::CaptureStatus(s) => {
                eprintln!("capture status: {s:?}")
            }
            FrontendEvent::EmulationStatus(s) => {
                eprintln!("emulation status: {s:?}")
            }
        }
    }
--- a/src/frontend/gtk.rs
+++ b/src/frontend/gtk.rs
@@ -8,7 +8,7 @@ use std::{
    process, str,
 };
-use crate::frontend::gtk::window::Window;
+use crate::frontend::{gtk::window::Window, FrontendRequest};
 use adw::Application;
 use endi::{Endian, ReadBytes};
@@ -113,55 +113,46 @@ fn build_ui(app: &Application) {
    });
    let window = Window::new(app, tx);
    window.request(FrontendRequest::Enumerate());
-    glib::spawn_future_local(clone!(
+    glib::spawn_future_local(clone!(@weak window => async move {
-        #[weak]
+        loop {
-        window,
+            let notify = receiver.recv().await.unwrap_or_else(|_| process::exit(1));
-        async move {
+            match notify {
-            loop {
+                FrontendEvent::Created(handle, client, state) => {
-                let notify = receiver.recv().await.unwrap_or_else(|_| process::exit(1));
+                    window.new_client(handle, client, state);
-                match notify {
+                },
-                    FrontendEvent::Created(handle, client, state) => {
+                FrontendEvent::Deleted(client) => {
-                        window.new_client(handle, client, state);
+                    window.delete_client(client);
-                    }
+                }
-                    FrontendEvent::Deleted(client) => {
+                FrontendEvent::State(handle, config, state) => {
-                        window.delete_client(client);
+                    window.update_client_config(handle, config);
-                    }
+                    window.update_client_state(handle, state);
-                    FrontendEvent::State(handle, config, state) => {
+                }
-                        window.update_client_config(handle, config);
+                FrontendEvent::NoSuchClient(_) => { }
-                        window.update_client_state(handle, state);
+                FrontendEvent::Error(e) => {
-                    }
+                    window.show_toast(e.as_str());
-                    FrontendEvent::NoSuchClient(_) => {}
+                },
-                    FrontendEvent::Error(e) => {
+                FrontendEvent::Enumerate(clients) => {
-                        window.show_toast(e.as_str());
+                    for (handle, client, state) in clients {
-                    }
+                        if window.client_idx(handle).is_some() {
-                    FrontendEvent::Enumerate(clients) => {
+                            window.update_client_config(handle, client);
-                        for (handle, client, state) in clients {
+                            window.update_client_state(handle, state);
-                            if window.client_idx(handle).is_some() {
+                        } else {
-                                window.update_client_config(handle, client);
+                            window.new_client(handle, client, state);
                                window.update_client_state(handle, state);
                            } else {
                                window.new_client(handle, client, state);
                            }
                        }
                    }
-                    FrontendEvent::PortChanged(port, msg) => {
+                },
-                        match msg {
+                FrontendEvent::PortChanged(port, msg) => {
-                            None => window.show_toast(format!("port changed: {port}").as_str()),
+                    match msg {
-                            Some(msg) => window.show_toast(msg.as_str()),
+                        None => window.show_toast(format!("port changed: {port}").as_str()),
-                        }
+                        Some(msg) => window.show_toast(msg.as_str()),
                        window.imp().set_port(port);
                    }
                    FrontendEvent::CaptureStatus(s) => {
                        window.set_capture(s.into());
                    }
                    FrontendEvent::EmulationStatus(s) => {
                        window.set_emulation(s.into());
                    }
                    window.imp().set_port(port);
                }
            }
        }
-    ));
+    }));
    window.present();
 }
--- a/src/frontend/gtk/client_row/imp.rs
+++ b/src/frontend/gtk/client_row/imp.rs
@@ -52,13 +52,10 @@ impl ObjectSubclass for ClientRow {
 impl ObjectImpl for ClientRow {
    fn constructed(&self) {
        self.parent_constructed();
-        self.delete_button.connect_clicked(clone!(
+        self.delete_button
-            #[weak(rename_to = row)]
+            .connect_clicked(clone!(@weak self as row => move |button| {
            self,
            move |button| {
                row.handle_client_delete(button);
-            }
+            }));
        ));
    }
    fn signals() -> &'static [glib::subclass::Signal] {
--- a/src/frontend/gtk/window.rs
+++ b/src/frontend/gtk/window.rs
@@ -63,61 +63,31 @@ impl Window {
        let selection_model = NoSelection::new(Some(self.clients()));
        self.imp().client_list.bind_model(
            Some(&selection_model),
-            clone!(
+            clone!(@weak self as window => @default-panic, move |obj| {
-                #[weak(rename_to = window)]
+                let client_object = obj.downcast_ref().expect("Expected object of type `ClientObject`.");
-                self,
+                let row = window.create_client_row(client_object);
-                #[upgrade_or_panic]
+                row.connect_closure("request-update", false, closure_local!(@strong window => move |row: ClientRow, active: bool| {
-                move |obj| {
+                    if let Some(client) = window.client_by_idx(row.index() as u32) {
-                    let client_object = obj
+                        window.request_client_activate(&client, active);
-                        .downcast_ref()
+                        window.request_client_update(&client);
-                        .expect("Expected object of type `ClientObject`.");
+                        window.request_client_state(&client);
-                    let row = window.create_client_row(client_object);
+                    }
-                    row.connect_closure(
+                }));
-                        "request-update",
+                row.connect_closure("request-delete", false, closure_local!(@strong window => move |row: ClientRow| {
-                        false,
+                    if let Some(client) = window.client_by_idx(row.index() as u32) {
-                        closure_local!(
+                        window.request_client_delete(&client);
-                            #[strong]
+                    }
-                            window,
+                }));
-                            move |row: ClientRow, active: bool| {
+                row.connect_closure("request-dns", false, closure_local!(@strong window => move
-                                if let Some(client) = window.client_by_idx(row.index() as u32) {
+                |row: ClientRow| {
-                                    window.request_client_activate(&client, active);
+                    if let Some(client) = window.client_by_idx(row.index() as u32) {
-                                    window.request_client_update(&client);
+                        window.request_client_update(&client);
-                                    window.request_client_state(&client);
+                        window.request_dns(&client);
-                                }
+                        window.request_client_state(&client);
-                            }
+                    }
-                        ),
+                }));
-                    );
+                row.upcast()
-                    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) {
                                    window.request_client_delete(&client);
                                }
                            }
                        ),
                    );
                    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) {
                                    window.request_client_update(&client);
                                    window.request_dns(&client);
                                    window.request_client_state(&client);
                                }
                            }
                        ),
                    );
                    row.upcast()
                }
            ),
        );
    }
@@ -237,35 +207,29 @@ impl Window {
    }
    pub fn request_port_change(&self) {
-        let port = self
+        let port = self.imp().port_entry.get().text().to_string();
-            .imp()
+        if let Ok(port) = port.as_str().parse::<u16>() {
-            .port_entry
+            self.request(FrontendRequest::ChangePort(port));
-            .get()
+        } else {
-            .text()
+            self.request(FrontendRequest::ChangePort(DEFAULT_PORT));
-            .as_str()
+        }
            .parse::<u16>()
            .unwrap_or(DEFAULT_PORT);
        self.request(FrontendRequest::ChangePort(port));
    }
    pub fn request_capture(&self) {
        self.request(FrontendRequest::EnableCapture);
    }
    pub fn request_emulation(&self) {
        self.request(FrontendRequest::EnableEmulation);
    }
    pub fn request_client_state(&self, client: &ClientObject) {
-        self.request(FrontendRequest::GetState(client.handle()));
+        let handle = client.handle();
        let event = FrontendRequest::GetState(handle);
        self.request(event);
    }
    pub fn request_client_create(&self) {
-        self.request(FrontendRequest::Create);
+        let event = FrontendRequest::Create;
        self.request(event);
    }
    pub fn request_dns(&self, client: &ClientObject) {
-        self.request(FrontendRequest::ResolveDns(client.get_data().handle));
+        let data = client.get_data();
        let event = FrontendRequest::ResolveDns(data.handle);
        self.request(event);
    }
    pub fn request_client_update(&self, client: &ClientObject) {
@@ -285,11 +249,15 @@ impl Window {
    }
    pub fn request_client_activate(&self, client: &ClientObject, active: bool) {
-        self.request(FrontendRequest::Activate(client.handle(), active));
+        let handle = client.handle();
        let event = FrontendRequest::Activate(handle, active);
        self.request(event);
    }
    pub fn request_client_delete(&self, client: &ClientObject) {
-        self.request(FrontendRequest::Delete(client.handle()));
+        let handle = client.handle();
        let event = FrontendRequest::Delete(handle);
        self.request(event);
    }
    pub fn request(&self, event: FrontendRequest) {
@@ -311,24 +279,4 @@ impl Window {
        let toast_overlay = &self.imp().toast_overlay;
        toast_overlay.add_toast(toast);
    }
    pub fn set_capture(&self, active: bool) {
        self.imp().capture_active.replace(active);
        self.update_capture_emulation_status();
    }
    pub fn set_emulation(&self, active: bool) {
        self.imp().emulation_active.replace(active);
        self.update_capture_emulation_status();
    }
    fn update_capture_emulation_status(&self) {
        let capture = self.imp().capture_active.get();
        let emulation = self.imp().emulation_active.get();
        self.imp().capture_status_row.set_visible(!capture);
        self.imp().emulation_status_row.set_visible(!emulation);
        self.imp()
            .capture_emulation_group
            .set_visible(!capture || !emulation);
    }
 }
--- a/src/frontend/gtk/window/imp.rs
+++ b/src/frontend/gtk/window/imp.rs
@@ -6,7 +6,7 @@ use std::net::TcpStream;
 use std::os::unix::net::UnixStream;
 use adw::subclass::prelude::*;
-use adw::{prelude::*, ActionRow, PreferencesGroup, ToastOverlay};
+use adw::{prelude::*, ActionRow, ToastOverlay};
 use glib::subclass::InitializingObject;
 use gtk::glib::clone;
 use gtk::{gdk, gio, glib, Button, CompositeTemplate, Entry, Label, ListBox};
@@ -30,24 +30,12 @@ pub struct Window {
    pub hostname_label: TemplateChild<Label>,
    #[template_child]
    pub toast_overlay: TemplateChild<ToastOverlay>,
    #[template_child]
    pub capture_emulation_group: TemplateChild<PreferencesGroup>,
    #[template_child]
    pub capture_status_row: TemplateChild<ActionRow>,
    #[template_child]
    pub emulation_status_row: TemplateChild<ActionRow>,
    #[template_child]
    pub input_emulation_button: TemplateChild<Button>,
    #[template_child]
    pub input_capture_button: TemplateChild<Button>,
    pub clients: RefCell<Option<gio::ListStore>>,
    #[cfg(unix)]
    pub stream: RefCell<Option<UnixStream>>,
    #[cfg(windows)]
    pub stream: RefCell<Option<TcpStream>>,
    pub port: Cell<u16>,
    pub capture_active: Cell<bool>,
    pub emulation_active: Cell<bool>,
 }
 #[glib::object_subclass]
@@ -84,15 +72,11 @@ impl Window {
            clipboard.set_text(hostname.to_str().expect("hostname: invalid utf8"));
            button.set_icon_name("emblem-ok-symbolic");
            button.set_css_classes(&["success"]);
-            glib::spawn_future_local(clone!(
+            glib::spawn_future_local(clone!(@weak button => async move {
-                #[weak]
+                glib::timeout_future_seconds(1).await;
-                button,
+                button.set_icon_name("edit-copy-symbolic");
-                async move {
+                button.set_css_classes(&[]);
-                    glib::timeout_future_seconds(1).await;
+            }));
                    button.set_icon_name("edit-copy-symbolic");
                    button.set_css_classes(&[]);
                }
            ));
        }
    }
@@ -116,16 +100,6 @@ impl Window {
        self.port_edit_cancel.set_visible(false);
    }
    #[template_callback]
    fn handle_emulation(&self) {
        self.obj().request_emulation();
    }
    #[template_callback]
    fn handle_capture(&self) {
        self.obj().request_capture();
    }
    pub fn set_port(&self, port: u16) {
        self.port.set(port);
        if port == DEFAULT_PORT {
--- a/src/main.rs
+++ b/src/main.rs
@@ -37,7 +37,7 @@ pub fn run() -> Result<()> {
        emulation_test::run()?;
    } else if config.daemon {
        // if daemon is specified we run the service
-        run_service(config)?;
+        run_service(&config)?;
    } else {
        //  otherwise start the service as a child process and
        //  run a frontend
@@ -58,7 +58,7 @@ pub fn run() -> Result<()> {
    anyhow::Ok(())
 }
-fn run_service(config: Config) -> Result<()> {
+fn run_service(config: &Config) -> Result<()> {
    // create single threaded tokio runtime
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_io()
@@ -70,8 +70,10 @@ fn run_service(config: Config) -> Result<()> {
        // run main loop
        log::info!("Press {:?} to release the mouse", config.release_bind);
-        let mut server = Server::new(config);
+        let server = Server::new(config);
-        server.run().await?;
+        server
            .run(config.capture_backend, config.emulation_backend)
            .await?;
        log::debug!("service exiting");
        anyhow::Ok(())
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,41 +1,27 @@
 use capture_task::CaptureEvent;
 use emulation_task::EmulationEvent;
 use log;
 use std::{
    cell::{Cell, RefCell},
-    collections::{HashSet, VecDeque},
+    collections::HashSet,
    io::ErrorKind,
    net::{IpAddr, SocketAddr},
    rc::Rc,
 };
-use tokio::{
+use tokio::signal;
    io::ReadHalf,
    join, signal,
    sync::{
        mpsc::{channel, Sender},
        Notify,
    },
    task::JoinHandle,
 };
 use tokio_util::sync::CancellationToken;
 use crate::{
-    client::{ClientConfig, ClientHandle, ClientManager, ClientState, Position},
+    client::{ClientConfig, ClientHandle, ClientManager, ClientState},
-    config::Config,
+    config::{CaptureBackend, Config, EmulationBackend},
-    dns::DnsResolver,
+    dns,
-    frontend::{self, FrontendEvent, FrontendListener, FrontendRequest, Status},
+    frontend::{FrontendListener, FrontendRequest},
    server::capture_task::CaptureEvent,
 };
-#[cfg(unix)]
+use self::{emulation_task::EmulationEvent, resolver_task::DnsRequest};
 use tokio::net::UnixStream;
 #[cfg(windows)]
 use tokio::net::TcpStream;
 mod capture_task;
 mod emulation_task;
 mod frontend_task;
 mod network_task;
 mod ping_task;
 mod resolver_task;
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum State {
@@ -51,33 +37,16 @@ enum State {
 #[derive(Clone)]
 pub struct Server {
    active_client: Rc<Cell<Option<ClientHandle>>>,
-    pub(crate) client_manager: Rc<RefCell<ClientManager>>,
+    client_manager: Rc<RefCell<ClientManager>>,
    port: Rc<Cell<u16>>,
    state: Rc<Cell<State>>,
    release_bind: Vec<input_event::scancode::Linux>,
    notifies: Rc<Notifies>,
    config: Rc<Config>,
    pending_frontend_events: Rc<RefCell<VecDeque<FrontendEvent>>>,
    pending_dns_requests: Rc<RefCell<VecDeque<ClientHandle>>>,
    capture_status: Rc<Cell<Status>>,
    emulation_status: Rc<Cell<Status>>,
 }
 #[derive(Default)]
 struct Notifies {
    capture: Notify,
    emulation: Notify,
    ping: Notify,
    port_changed: Notify,
    frontend_event_pending: Notify,
    dns_request_pending: Notify,
    cancel: CancellationToken,
 }
 impl Server {
-    pub fn new(config: Config) -> Self {
+    pub fn new(config: &Config) -> Self {
        let active_client = Rc::new(Cell::new(None));
-        let client_manager = Rc::new(RefCell::new(ClientManager::default()));
+        let client_manager = Rc::new(RefCell::new(ClientManager::new()));
        let state = Rc::new(Cell::new(State::Receiving));
        let port = Rc::new(Cell::new(config.port));
        for config_client in config.get_clients() {
@@ -98,502 +67,153 @@ impl Server {
            let c = client_manager.get_mut(handle).expect("invalid handle");
            *c = (client, state);
        }
        // task notification tokens
        let notifies = Rc::new(Notifies::default());
        let release_bind = config.release_bind.clone();
        let config = Rc::new(config);
        Self {
            config,
            active_client,
            client_manager,
            port,
            state,
            release_bind,
            notifies,
            pending_frontend_events: Rc::new(RefCell::new(VecDeque::new())),
            pending_dns_requests: Rc::new(RefCell::new(VecDeque::new())),
            capture_status: Default::default(),
            emulation_status: Default::default(),
        }
    }
-    pub async fn run(&mut self) -> anyhow::Result<()> {
+    pub async fn run(
-        // create frontend communication adapter, exit if already running
+        &self,
-        let mut frontend = match FrontendListener::new().await {
+        capture_backend: Option<CaptureBackend>,
        emulation_backend: Option<EmulationBackend>,
    ) -> anyhow::Result<()> {
        // create frontend communication adapter
        let frontend = match FrontendListener::new().await {
            Some(f) => f?,
            None => {
                // none means some other instance is already running
                log::info!("service already running, exiting");
-                return Ok(());
+                return anyhow::Ok(());
            }
        };
-        let (capture_tx, capture_rx) = channel(1); /* requests for input capture */
+        let (timer_tx, timer_rx) = tokio::sync::mpsc::channel(1);
-        let (emulation_tx, emulation_rx) = channel(1); /* emulation requests */
+        let (frontend_notify_tx, frontend_notify_rx) = tokio::sync::mpsc::channel(1);
        let (udp_recv_tx, udp_recv_rx) = channel(1); /* udp receiver */
        let (udp_send_tx, udp_send_rx) = channel(1); /* udp sender */
        let (request_tx, mut request_rx) = channel(1); /* frontend requests */
        let (dns_tx, dns_rx) = channel(1); /* dns requests */
        // udp task
-        let network = network_task::new(self.clone(), udp_recv_tx.clone(), udp_send_rx).await?;
+        let (mut udp_task, sender_tx, receiver_rx, port_tx) =
            network_task::new(self.clone(), frontend_notify_tx.clone()).await?;
        // input capture
-        let capture = capture_task::new(self.clone(), capture_rx, udp_send_tx.clone());
+        let (mut capture_task, capture_channel) = capture_task::new(
            capture_backend,
            self.clone(),
            sender_tx.clone(),
            timer_tx.clone(),
            self.release_bind.clone(),
        )?;
        // input emulation
-        let emulation = emulation_task::new(
+        let (mut emulation_task, emulate_channel) = emulation_task::new(
            emulation_backend,
            self.clone(),
-            emulation_rx,
+            receiver_rx,
-            udp_recv_rx,
+            sender_tx.clone(),
-            udp_send_tx.clone(),
+            capture_channel.clone(),
-            capture_tx.clone(),
+            timer_tx,
-        );
+        )?;
        // create dns resolver
-        let resolver = DnsResolver::new(dns_rx)?;
+        let resolver = dns::DnsResolver::new().await?;
-        let dns_task = tokio::task::spawn_local(resolver.run(self.clone()));
+        let (mut resolver_task, resolve_tx) =
            resolver_task::new(resolver, self.clone(), frontend_notify_tx);
-        // task that pings clients to see if they are responding
+        // frontend listener
-        let ping = ping_task::new(
+        let (mut frontend_task, frontend_tx) = frontend_task::new(
            frontend,
            frontend_notify_rx,
            self.clone(),
-            udp_send_tx.clone(),
+            capture_channel.clone(),
-            emulation_tx.clone(),
+            emulate_channel.clone(),
-            capture_tx.clone(),
+            resolve_tx.clone(),
            port_tx,
        );
-        for handle in self.active_clients() {
+        // task that pings clients to see if they are responding
-            self.request_dns(handle);
+        let mut ping_task = ping_task::new(
-        }
+            self.clone(),
            sender_tx.clone(),
            emulate_channel.clone(),
            capture_channel.clone(),
            timer_rx,
        );
        let active = self
            .client_manager
            .borrow()
            .get_client_states()
            .filter_map(|(h, (c, s))| {
                if s.active {
                    Some((h, c.hostname.clone()))
                } else {
                    None
                }
            })
            .collect::<Vec<_>>();
        for (handle, hostname) in active {
            frontend_tx
                .send(FrontendRequest::Activate(handle, true))
                .await?;
            if let Some(hostname) = hostname {
                let _ = resolve_tx.send(DnsRequest { hostname, handle }).await;
            }
        }
        log::info!("running service");
-        let mut join_handles = vec![];
+        tokio::select! {
            _ = signal::ctrl_c() => {
                log::info!("terminating service");
            }
            e = &mut capture_task => {
                if let Ok(Err(e)) = e {
                    log::error!("error in input capture task: {e}");
                }
            }
            e = &mut emulation_task => {
                if let Ok(Err(e)) = e {
                    log::error!("error in input emulation task: {e}");
                }
            }
            e = &mut frontend_task => {
                if let Ok(Err(e)) = e {
                    log::error!("error in frontend listener: {e}");
                }
            }
            _ = &mut resolver_task => { }
            _ = &mut udp_task => { }
            _ = &mut ping_task => { }
        }
-        loop {
+        let _ = emulate_channel.send(EmulationEvent::Terminate).await;
-            tokio::select! {
+        let _ = capture_channel.send(CaptureEvent::Terminate).await;
-                stream = frontend.accept() => {
+        let _ = frontend_tx.send(FrontendRequest::Terminate()).await;
-                    match stream {
+
-                        Ok(s) => join_handles.push(handle_frontend_stream(self.notifies.cancel.clone(), s, request_tx.clone())),
+        if !capture_task.is_finished() {
-                        Err(e) => log::warn!("error accepting frontend connection: {e}"),
+            if let Err(e) = capture_task.await {
-                    };
+                log::error!("error in input capture task: {e}");
-                    self.enumerate();
+            }
-                    self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status.get()));
+        }
-                    self.notify_frontend(FrontendEvent::CaptureStatus(self.capture_status.get()));
+        if !emulation_task.is_finished() {
-                    self.notify_frontend(FrontendEvent::PortChanged(self.port.get(), None));
+            if let Err(e) = emulation_task.await {
-                }
+                log::error!("error in input emulation task: {e}");
                request = request_rx.recv() => {
                    let request = request.expect("channel closed");
                    log::debug!("received frontend request: {request:?}");
                    self.handle_request(&capture_tx.clone(), &emulation_tx.clone(), request).await;
                    log::debug!("handled frontend request");
                }
                _ = self.notifies.frontend_event_pending.notified() => {
                    while let Some(event) = {
                        /* need to drop borrow before next iteration! */
                        let event = self.pending_frontend_events.borrow_mut().pop_front();
                        event
                    } {
                        frontend.broadcast(event).await;
                    }
                },
                _ = self.notifies.dns_request_pending.notified() => {
                    while let Some(request) = {
                        /* need to drop borrow before next iteration! */
                        let request = self.pending_dns_requests.borrow_mut().pop_front();
                        request
                    } {
                        dns_tx.send(request).await.expect("channel closed");
                    }
                }
                _ = self.cancelled() => break,
                r = signal::ctrl_c() => {
                    r.expect("failed to wait for CTRL+C");
                    break;
                }
            }
        }
-        log::info!("terminating service");
+        if !frontend_task.is_finished() {
            if let Err(e) = frontend_task.await {
                log::error!("error in frontend listener: {e}");
            }
        }
-        assert!(!capture_tx.is_closed());
+        resolver_task.abort();
-        assert!(!emulation_tx.is_closed());
+        udp_task.abort();
-        assert!(!udp_recv_tx.is_closed());
+        ping_task.abort();
        assert!(!udp_send_tx.is_closed());
        assert!(!request_tx.is_closed());
        assert!(!dns_tx.is_closed());
        self.cancel();
        futures::future::join_all(join_handles).await;
        let _ = join!(capture, dns_task, emulation, network, ping);
        Ok(())
    }
    fn notify_frontend(&self, event: FrontendEvent) {
        self.pending_frontend_events.borrow_mut().push_back(event);
        self.notifies.frontend_event_pending.notify_one();
    }
    fn cancel(&self) {
        self.notifies.cancel.cancel();
    }
    pub(crate) async fn cancelled(&self) {
        self.notifies.cancel.cancelled().await
    }
    fn is_cancelled(&self) -> bool {
        self.notifies.cancel.is_cancelled()
    }
    fn notify_capture(&self) {
        self.notifies.capture.notify_waiters()
    }
    async fn capture_notified(&self) {
        self.notifies.capture.notified().await
    }
    fn notify_emulation(&self) {
        self.notifies.emulation.notify_waiters()
    }
    async fn emulation_notified(&self) {
        self.notifies.emulation.notified().await
    }
    fn restart_ping_timer(&self) {
        self.notifies.ping.notify_waiters()
    }
    async fn ping_timer_notified(&self) {
        self.notifies.ping.notified().await
    }
    fn request_port_change(&self, port: u16) {
        self.port.replace(port);
        self.notifies.port_changed.notify_one();
    }
    fn notify_port_changed(&self, port: u16, msg: Option<String>) {
        self.port.replace(port);
        self.notify_frontend(FrontendEvent::PortChanged(port, msg));
    }
    pub(crate) fn client_updated(&self, handle: ClientHandle) {
        let state = self.client_manager.borrow().get(handle).cloned();
        if let Some((config, state)) = state {
            self.notify_frontend(FrontendEvent::State(handle, config, state));
        }
    }
    fn active_clients(&self) -> Vec<ClientHandle> {
        self.client_manager
            .borrow()
            .get_client_states()
            .filter(|(_, (_, s))| s.active)
            .map(|(h, _)| h)
            .collect()
    }
    fn request_dns(&self, handle: ClientHandle) {
        self.pending_dns_requests.borrow_mut().push_back(handle);
        self.notifies.dns_request_pending.notify_one();
    }
    async fn handle_request(
        &self,
        capture: &Sender<CaptureEvent>,
        emulate: &Sender<EmulationEvent>,
        event: FrontendRequest,
    ) -> bool {
        log::debug!("frontend: {event:?}");
        match event {
            FrontendRequest::EnableCapture => {
                log::info!("received capture enable request");
                self.notify_capture();
            }
            FrontendRequest::EnableEmulation => {
                log::info!("received emulation enable request");
                self.notify_emulation();
            }
            FrontendRequest::Create => {
                let handle = self.add_client().await;
                self.request_dns(handle);
            }
            FrontendRequest::Activate(handle, active) => {
                if active {
                    self.activate_client(capture, emulate, handle).await;
                } else {
                    self.deactivate_client(capture, emulate, handle).await;
                }
            }
            FrontendRequest::ChangePort(port) => self.request_port_change(port),
            FrontendRequest::Delete(handle) => {
                self.remove_client(capture, emulate, handle).await;
                self.notify_frontend(FrontendEvent::Deleted(handle));
            }
            FrontendRequest::Enumerate() => self.enumerate(),
            FrontendRequest::GetState(handle) => self.broadcast_client(handle),
            FrontendRequest::UpdateFixIps(handle, fix_ips) => {
                self.update_fix_ips(handle, fix_ips);
                self.request_dns(handle);
            }
            FrontendRequest::UpdateHostname(handle, host) => self.update_hostname(handle, host),
            FrontendRequest::UpdatePort(handle, port) => self.update_port(handle, port),
            FrontendRequest::UpdatePosition(handle, pos) => {
                self.update_pos(handle, capture, emulate, pos).await;
            }
            FrontendRequest::ResolveDns(handle) => self.request_dns(handle),
        };
        false
    }
    fn enumerate(&self) {
        let clients = self
            .client_manager
            .borrow()
            .get_client_states()
            .map(|(h, (c, s))| (h, c.clone(), s.clone()))
            .collect();
        self.notify_frontend(FrontendEvent::Enumerate(clients));
    }
    async fn add_client(&self) -> ClientHandle {
        let handle = self.client_manager.borrow_mut().add_client();
        log::info!("added client {handle}");
        let (c, s) = self.client_manager.borrow().get(handle).unwrap().clone();
        self.notify_frontend(FrontendEvent::Created(handle, c, s));
        handle
    }
    async fn deactivate_client(
        &self,
        capture: &Sender<CaptureEvent>,
        emulate: &Sender<EmulationEvent>,
        handle: ClientHandle,
    ) {
        log::debug!("deactivating client {handle}");
        match self.client_manager.borrow_mut().get_mut(handle) {
            Some((_, s)) => s.active = false,
            None => return,
        };
        let _ = capture.send(CaptureEvent::Destroy(handle)).await;
        let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
        log::debug!("deactivating client {handle} done");
    }
    async fn activate_client(
        &self,
        capture: &Sender<CaptureEvent>,
        emulate: &Sender<EmulationEvent>,
        handle: ClientHandle,
    ) {
        log::debug!("activating client");
        /* deactivate potential other client at this position */
        let pos = match self.client_manager.borrow().get(handle) {
            Some((client, _)) => client.pos,
            None => return,
        };
        let other = self.client_manager.borrow_mut().find_client(pos);
        if let Some(other) = other {
            if other != handle {
                self.deactivate_client(capture, emulate, other).await;
            }
        }
        /* activate the client */
        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
            s.active = true;
        } else {
            return;
        };
        /* notify emulation, capture and frontends */
        let _ = capture.send(CaptureEvent::Create(handle, pos.into())).await;
        let _ = emulate.send(EmulationEvent::Create(handle)).await;
        log::debug!("activating client {handle} done");
    }
    async fn remove_client(
        &self,
        capture: &Sender<CaptureEvent>,
        emulate: &Sender<EmulationEvent>,
        handle: ClientHandle,
    ) {
        let Some(active) = self
            .client_manager
            .borrow_mut()
            .remove_client(handle)
            .map(|(_, s)| s.active)
        else {
            return;
        };
        if active {
            let _ = capture.send(CaptureEvent::Destroy(handle)).await;
            let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
        }
    }
    fn update_fix_ips(&self, handle: ClientHandle, fix_ips: Vec<IpAddr>) {
        if let Some((c, _)) = self.client_manager.borrow_mut().get_mut(handle) {
            c.fix_ips = fix_ips;
        };
        self.update_ips(handle);
    }
    pub(crate) fn update_dns_ips(&self, handle: ClientHandle, dns_ips: Vec<IpAddr>) {
        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
            s.dns_ips = dns_ips;
        };
        self.update_ips(handle);
    }
    fn update_ips(&self, handle: ClientHandle) {
        if let Some((c, s)) = self.client_manager.borrow_mut().get_mut(handle) {
            s.ips = c
                .fix_ips
                .iter()
                .cloned()
                .chain(s.dns_ips.iter().cloned())
                .collect::<HashSet<_>>();
        }
    }
    fn update_hostname(&self, handle: ClientHandle, hostname: Option<String>) {
        let mut client_manager = self.client_manager.borrow_mut();
        let Some((c, s)) = client_manager.get_mut(handle) else {
            return;
        };
        // hostname changed
        if c.hostname != hostname {
            c.hostname = hostname;
            s.ips = HashSet::from_iter(c.fix_ips.iter().cloned());
            s.active_addr = None;
            self.request_dns(handle);
        }
    }
    fn update_port(&self, handle: ClientHandle, port: u16) {
        let mut client_manager = self.client_manager.borrow_mut();
        let Some((c, s)) = client_manager.get_mut(handle) else {
            return;
        };
        if c.port != port {
            c.port = port;
            s.active_addr = s.active_addr.map(|a| SocketAddr::new(a.ip(), port));
        }
    }
    async fn update_pos(
        &self,
        handle: ClientHandle,
        capture: &Sender<CaptureEvent>,
        emulate: &Sender<EmulationEvent>,
        pos: Position,
    ) {
        let (changed, active) = {
            let mut client_manager = self.client_manager.borrow_mut();
            let Some((c, s)) = client_manager.get_mut(handle) else {
                return;
            };
            let changed = c.pos != pos;
            c.pos = pos;
            (changed, s.active)
        };
        // update state in event input emulator & input capture
        if changed {
            if active {
                let _ = capture.send(CaptureEvent::Destroy(handle)).await;
                let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
            }
            let _ = capture.send(CaptureEvent::Create(handle, pos.into())).await;
            let _ = emulate.send(EmulationEvent::Create(handle)).await;
        }
    }
    fn broadcast_client(&self, handle: ClientHandle) {
        let client = self.client_manager.borrow().get(handle).cloned();
        let event = if let Some((config, state)) = client {
            FrontendEvent::State(handle, config, state)
        } else {
            FrontendEvent::NoSuchClient(handle)
        };
        self.notify_frontend(event);
    }
    fn set_emulation_status(&self, status: Status) {
        self.emulation_status.replace(status);
        let status = FrontendEvent::EmulationStatus(status);
        self.notify_frontend(status);
    }
    fn set_capture_status(&self, status: Status) {
        self.capture_status.replace(status);
        let status = FrontendEvent::CaptureStatus(status);
        self.notify_frontend(status);
    }
    pub(crate) fn set_resolving(&self, handle: ClientHandle, status: bool) {
        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
            s.resolving = status;
        }
        self.client_updated(handle);
    }
    pub(crate) fn get_hostname(&self, handle: u64) -> Option<String> {
        self.client_manager
            .borrow_mut()
            .get_mut(handle)
            .and_then(|(c, _)| c.hostname.clone())
    }
 }
 async fn listen_frontend(
    request_tx: Sender<FrontendRequest>,
    #[cfg(unix)] mut stream: ReadHalf<UnixStream>,
    #[cfg(windows)] mut stream: ReadHalf<TcpStream>,
 ) {
    use std::io;
    loop {
        let request = frontend::wait_for_request(&mut stream).await;
        match request {
            Ok(request) => {
                let _ = request_tx.send(request).await;
            }
            Err(e) => {
                if let Some(e) = e.downcast_ref::<io::Error>() {
                    if e.kind() == ErrorKind::UnexpectedEof {
                        return;
                    }
                }
                log::error!("error reading frontend event: {e}");
                return;
            }
        }
    }
 }
 fn handle_frontend_stream(
    cancel: CancellationToken,
    #[cfg(unix)] stream: ReadHalf<UnixStream>,
    #[cfg(windows)] stream: ReadHalf<TcpStream>,
    request_tx: Sender<FrontendRequest>,
 ) -> JoinHandle<()> {
    tokio::task::spawn_local(async move {
        tokio::select! {
            _ = listen_frontend(request_tx, stream) => {},
            _ = cancel.cancelled() => {},
        }
    })
 }
--- a/src/server/capture_task.rs
+++ b/src/server/capture_task.rs
@@ -1,122 +1,70 @@
 use anyhow::{anyhow, Result};
 use futures::StreamExt;
 use std::{collections::HashSet, net::SocketAddr};
-use tokio::{
+use tokio::{process::Command, sync::mpsc::Sender, task::JoinHandle};
    process::Command,
    sync::mpsc::{Receiver, Sender},
    task::JoinHandle,
 };
-use input_capture::{self, CaptureError, CaptureHandle, InputCapture, InputCaptureError, Position};
+use input_capture::{self, error::CaptureCreationError, CaptureHandle, InputCapture, Position};
 use input_event::{scancode, Event, KeyboardEvent};
-use crate::{client::ClientHandle, frontend::Status, server::State};
+use crate::{client::ClientHandle, config::CaptureBackend, server::State};
 use super::Server;
 #[derive(Clone, Copy, Debug)]
-pub(crate) enum CaptureEvent {
+pub enum CaptureEvent {
    /// capture must release the mouse
    Release,
    /// add a capture client
    Create(CaptureHandle, Position),
    /// destory a capture client
    Destroy(CaptureHandle),
    /// termination signal
    Terminate,
 }
-pub(crate) fn new(
+pub fn new(
    backend: Option<CaptureBackend>,
    server: Server,
    capture_rx: Receiver<CaptureEvent>,
    udp_send: Sender<(Event, SocketAddr)>,
 ) -> JoinHandle<()> {
    let backend = server.config.capture_backend.map(|b| b.into());
    tokio::task::spawn_local(capture_task(server, backend, udp_send, capture_rx))
 }
 async fn capture_task(
    server: Server,
    backend: Option<input_capture::Backend>,
    sender_tx: Sender<(Event, SocketAddr)>,
-    mut notify_rx: Receiver<CaptureEvent>,
+    timer_tx: Sender<()>,
-) {
+    release_bind: Vec<scancode::Linux>,
-    loop {
+) -> Result<(JoinHandle<Result<()>>, Sender<CaptureEvent>), CaptureCreationError> {
-        if let Err(e) = do_capture(backend, &server, &sender_tx, &mut notify_rx).await {
+    let (tx, mut rx) = tokio::sync::mpsc::channel(32);
-            log::warn!("input capture exited: {e}");
+    let backend = backend.map(|b| b.into());
-        }
+    let task = tokio::task::spawn_local(async move {
-        server.set_capture_status(Status::Disabled);
+        let mut capture = input_capture::create(backend).await?;
-        if server.is_cancelled() {
+        let mut pressed_keys = HashSet::new();
            break;
        }
        // allow cancellation
        loop {
            tokio::select! {
-                _ = notify_rx.recv() => continue, /* need to ignore requests here! */
+                event = capture.next() => {
-                _ = server.capture_notified() => break,
+                    match event {
-                _ = server.cancelled() => return,
+                        Some(Ok(event)) => handle_capture_event(&server, &mut capture, &sender_tx, &timer_tx, event, &mut pressed_keys, &release_bind).await?,
-            }
+                        Some(Err(e)) => return Err(anyhow!("input capture: {e:?}")),
-        }
+                        None => return Err(anyhow!("input capture terminated")),
-    }
+                    }
-}
+                }
-
+                e = rx.recv() => {
-async fn do_capture(
+                    log::debug!("input capture notify rx: {e:?}");
-    backend: Option<input_capture::Backend>,
+                    match e {
-    server: &Server,
+                        Some(e) => match e {
-    sender_tx: &Sender<(Event, SocketAddr)>,
+                            CaptureEvent::Release => {
-    notify_rx: &mut Receiver<CaptureEvent>,
+                                capture.release()?;
-) -> Result<(), InputCaptureError> {
+                                server.state.replace(State::Receiving);
-    /* allow cancelling capture request */
+                            }
-    let mut capture = tokio::select! {
+                            CaptureEvent::Create(h, p) => capture.create(h, p)?,
-        r = input_capture::create(backend) => {
+                            CaptureEvent::Destroy(h) => capture.destroy(h)?,
-            r?
+                            CaptureEvent::Terminate => break,
-        },
+                        },
-        _ = server.cancelled() => return Ok(()),
+                        None => break,
-    };
+                    }
    server.set_capture_status(Status::Enabled);
    // FIXME DUPLICATES
    let clients = server
        .client_manager
        .borrow()
        .get_client_states()
        .map(|(h, s)| (h, s.clone()))
        .collect::<Vec<_>>();
    log::info!("{clients:?}");
    for (handle, (config, _state)) in clients {
        capture.create(handle, config.pos.into()).await?;
    }
    let mut pressed_keys = HashSet::new();
    loop {
        tokio::select! {
            event = capture.next() => {
                match event {
                    Some(Ok(event)) => handle_capture_event(server, &mut capture, sender_tx, event, &mut pressed_keys).await?,
                    Some(Err(e)) => return Err(e.into()),
                    None => return Ok(()),
                }
            }
            e = notify_rx.recv() => {
                log::debug!("input capture notify rx: {e:?}");
                match e {
                    Some(e) => match e {
                        CaptureEvent::Release => {
                            capture.release().await?;
                            server.state.replace(State::Receiving);
                        }
                        CaptureEvent::Create(h, p) => capture.create(h, p).await?,
                        CaptureEvent::Destroy(h) => capture.destroy(h).await?,
                    },
                    None => break,
                }
            }
            _ = server.cancelled() => break,
        }
-    }
+        anyhow::Ok(())
-    capture.terminate().await?;
+    });
-    Ok(())
+    Ok((task, tx))
 }
 fn update_pressed_keys(pressed_keys: &mut HashSet<scancode::Linux>, key: u32, state: u8) {
@@ -133,19 +81,21 @@ async fn handle_capture_event(
    server: &Server,
    capture: &mut Box<dyn InputCapture>,
    sender_tx: &Sender<(Event, SocketAddr)>,
    timer_tx: &Sender<()>,
    event: (CaptureHandle, Event),
    pressed_keys: &mut HashSet<scancode::Linux>,
-) -> Result<(), CaptureError> {
+    release_bind: &[scancode::Linux],
 ) -> Result<()> {
    let (handle, mut e) = event;
    log::trace!("({handle}) {e:?}");
    if let Event::Keyboard(KeyboardEvent::Key { key, state, .. }) = e {
        update_pressed_keys(pressed_keys, key, state);
        log::debug!("{pressed_keys:?}");
-        if server.release_bind.iter().all(|k| pressed_keys.contains(k)) {
+        if release_bind.iter().all(|k| pressed_keys.contains(k)) {
            pressed_keys.clear();
            log::info!("releasing pointer");
-            capture.release().await?;
+            capture.release()?;
            server.state.replace(State::Receiving);
            log::trace!("STATE ===> Receiving");
            // send an event to release all the modifiers
@@ -153,49 +103,44 @@ async fn handle_capture_event(
        }
    }
-    let info = {
+    let (addr, enter, start_timer) = {
        let mut enter = false;
        let mut start_timer = false;
        // get client state for handle
        let mut client_manager = server.client_manager.borrow_mut();
-        let client_state = client_manager.get_mut(handle).map(|(_, s)| s);
+        let client_state = match client_manager.get_mut(handle) {
-        if let Some(client_state) = client_state {
+            Some((_, s)) => s,
-            // if we just entered the client we want to send additional enter events until
+            None => {
-            // we get a leave event
+                // should not happen
-            if let Event::Enter() = e {
+                log::warn!("unknown client!");
-                server.state.replace(State::AwaitingLeave);
+                capture.release()?;
-                server.active_client.replace(Some(handle));
+                server.state.replace(State::Receiving);
-                log::trace!("Active client => {}", handle);
+                log::trace!("STATE ===> Receiving");
-                start_timer = true;
+                return Ok(());
                log::trace!("STATE ===> AwaitingLeave");
                enter = true;
            } else {
                // ignore any potential events in receiving mode
                if server.state.get() == State::Receiving && e != Event::Disconnect() {
                    return Ok(());
                }
            }
-            Some((client_state.active_addr, enter, start_timer))
+        };
        // if we just entered the client we want to send additional enter events until
        // we get a leave event
        if let Event::Enter() = e {
            server.state.replace(State::AwaitingLeave);
            server.active_client.replace(Some(handle));
            log::trace!("Active client => {}", handle);
            start_timer = true;
            log::trace!("STATE ===> AwaitingLeave");
            enter = true;
        } else {
-            None
+            // ignore any potential events in receiving mode
            if server.state.get() == State::Receiving && e != Event::Disconnect() {
                return Ok(());
            }
        }
    };
-    let (addr, enter, start_timer) = match info {
+        (client_state.active_addr, enter, start_timer)
        Some(i) => i,
        None => {
            // should not happen
            log::warn!("unknown client!");
            capture.release().await?;
            server.state.replace(State::Receiving);
            log::trace!("STATE ===> Receiving");
            return Ok(());
        }
    };
    if start_timer {
-        server.restart_ping_timer();
+        let _ = timer_tx.try_send(());
    }
    if enter {
        spawn_hook_command(server, handle);
--- a/src/server/emulation_task.rs
+++ b/src/server/emulation_task.rs
@@ -1,3 +1,4 @@
 use anyhow::{anyhow, Result};
 use std::net::SocketAddr;
 use tokio::{
@@ -5,130 +6,76 @@ use tokio::{
    task::JoinHandle,
 };
-use crate::{
+use crate::{client::ClientHandle, config::EmulationBackend, server::State};
-    client::{ClientHandle, ClientManager},
+use input_emulation::{
-    frontend::Status,
+    self,
-    server::State,
+    error::{EmulationCreationError, EmulationError},
    EmulationHandle, InputEmulation,
 };
 use input_emulation::{self, EmulationError, EmulationHandle, InputEmulation, InputEmulationError};
 use input_event::{Event, KeyboardEvent};
-use super::{network_task::NetworkError, CaptureEvent, Server};
+use super::{CaptureEvent, Server};
 #[derive(Clone, Debug)]
-pub(crate) enum EmulationEvent {
+pub enum EmulationEvent {
    /// create a new client
    Create(EmulationHandle),
    /// destroy a client
    Destroy(EmulationHandle),
    /// input emulation must release keys for client
    ReleaseKeys(ClientHandle),
    /// termination signal
    Terminate,
 }
-pub(crate) fn new(
+pub fn new(
    backend: Option<EmulationBackend>,
    server: Server,
-    emulation_rx: Receiver<EmulationEvent>,
+    mut udp_rx: Receiver<Result<(Event, SocketAddr)>>,
    udp_rx: Receiver<Result<(Event, SocketAddr), NetworkError>>,
    sender_tx: Sender<(Event, SocketAddr)>,
    capture_tx: Sender<CaptureEvent>,
-) -> JoinHandle<()> {
+    timer_tx: Sender<()>,
-    let emulation_task = emulation_task(server, emulation_rx, udp_rx, sender_tx, capture_tx);
+) -> Result<(JoinHandle<Result<()>>, Sender<EmulationEvent>), EmulationCreationError> {
-    tokio::task::spawn_local(emulation_task)
+    let (tx, mut rx) = tokio::sync::mpsc::channel(32);
-}
+    let emulate_task = tokio::task::spawn_local(async move {
        let backend = backend.map(|b| b.into());
        let mut emulate = input_emulation::create(backend).await?;
        let mut last_ignored = None;
 async fn emulation_task(
    server: Server,
    mut rx: Receiver<EmulationEvent>,
    mut udp_rx: Receiver<Result<(Event, SocketAddr), NetworkError>>,
    sender_tx: Sender<(Event, SocketAddr)>,
    capture_tx: Sender<CaptureEvent>,
 ) {
    loop {
        if let Err(e) = do_emulation(&server, &mut rx, &mut udp_rx, &sender_tx, &capture_tx).await {
            log::warn!("input emulation exited: {e}");
        }
        server.set_emulation_status(Status::Disabled);
        if server.is_cancelled() {
            break;
        }
        // allow cancellation
        loop {
            tokio::select! {
-                _ = rx.recv() => continue, /* need to ignore requests here! */
+                udp_event = udp_rx.recv() => {
-                _ = server.emulation_notified() => break,
+                    let udp_event = udp_event.ok_or(anyhow!("receiver closed"))??;
-                _ = server.cancelled() => return,
+                    handle_udp_rx(&server, &capture_tx, &mut emulate, &sender_tx, &mut last_ignored, udp_event, &timer_tx).await?;
-            }
+                }
-        }
+                emulate_event = rx.recv() => {
-    }
+                    match emulate_event {
-}
+                        Some(e) => match e {
-
+                            EmulationEvent::Create(h) => emulate.create(h).await,
-async fn do_emulation(
+                            EmulationEvent::Destroy(h) => emulate.destroy(h).await,
-    server: &Server,
+                            EmulationEvent::ReleaseKeys(c) => release_keys(&server, &mut emulate, c).await?,
-    rx: &mut Receiver<EmulationEvent>,
+                            EmulationEvent::Terminate => break,
-    udp_rx: &mut Receiver<Result<(Event, SocketAddr), NetworkError>>,
+                        },
-    sender_tx: &Sender<(Event, SocketAddr)>,
+                        None => break,
    capture_tx: &Sender<CaptureEvent>,
 ) -> Result<(), InputEmulationError> {
    let backend = server.config.emulation_backend.map(|b| b.into());
    log::info!("creating input emulation...");
    let mut emulation = tokio::select! {
        r = input_emulation::create(backend) => {
            r?
        }
        _ = server.cancelled() => return Ok(()),
    };
    server.set_emulation_status(Status::Enabled);
    // add clients
    for handle in server.active_clients() {
        emulation.create(handle).await;
    }
    let res = do_emulation_session(server, &mut emulation, rx, udp_rx, sender_tx, capture_tx).await;
    // release potentially still pressed keys
    release_all_keys(server, &mut emulation).await?;
    emulation.terminate().await;
    res?;
    Ok(())
 }
 async fn do_emulation_session(
    server: &Server,
    emulation: &mut Box<dyn InputEmulation>,
    rx: &mut Receiver<EmulationEvent>,
    udp_rx: &mut Receiver<Result<(Event, SocketAddr), NetworkError>>,
    sender_tx: &Sender<(Event, SocketAddr)>,
    capture_tx: &Sender<CaptureEvent>,
 ) -> Result<(), InputEmulationError> {
    let mut last_ignored = None;
    loop {
        tokio::select! {
            udp_event = udp_rx.recv() => {
                let udp_event = match udp_event.expect("channel closed") {
                    Ok(e) => e,
                    Err(e) => {
                        log::warn!("network error: {e}");
                        continue;
                    }
                };
                handle_udp_rx(server, capture_tx, emulation, sender_tx, &mut last_ignored, udp_event).await?;
            }
            emulate_event = rx.recv() => {
                match emulate_event.expect("channel closed") {
                    EmulationEvent::Create(h) => emulation.create(h).await,
                    EmulationEvent::Destroy(h) => emulation.destroy(h).await,
                    EmulationEvent::ReleaseKeys(c) => release_keys(server, emulation, c).await?,
                }
            }
            _ = server.notifies.cancel.cancelled() => break Ok(()),
        }
-    }
+
        // release potentially still pressed keys
        let clients = server
            .client_manager
            .borrow()
            .get_client_states()
            .map(|(h, _)| h)
            .collect::<Vec<_>>();
        for client in clients {
            release_keys(&server, &mut emulate, client).await?;
        }
        anyhow::Ok(())
    });
    Ok((emulate_task, tx))
 }
 async fn handle_udp_rx(
@@ -138,18 +85,42 @@ async fn handle_udp_rx(
    sender_tx: &Sender<(Event, SocketAddr)>,
    last_ignored: &mut Option<SocketAddr>,
    event: (Event, SocketAddr),
    timer_tx: &Sender<()>,
 ) -> Result<(), EmulationError> {
    let (event, addr) = event;
-    log::trace!("{:20} <-<-<-<------ {addr}", event.to_string());
+    // get handle for addr
-
+    let handle = match server.client_manager.borrow().get_client(addr) {
-    // get client handle for addr
+        Some(a) => a,
-    let Some(handle) =
+        None => {
-        activate_client_if_exists(&mut server.client_manager.borrow_mut(), addr, last_ignored)
+            if last_ignored.is_none() || last_ignored.is_some() && last_ignored.unwrap() != addr {
-    else {
+                log::warn!("ignoring events from client {addr}");
-        return Ok(());
+                last_ignored.replace(addr);
            }
            return Ok(());
        }
    };
    // next event can be logged as ignored again
    last_ignored.take();
    log::trace!("{:20} <-<-<-<------ {addr} ({handle})", event.to_string());
    {
        let mut client_manager = server.client_manager.borrow_mut();
        let client_state = match client_manager.get_mut(handle) {
            Some((_, s)) => s,
            None => {
                log::error!("unknown handle");
                return Ok(());
            }
        };
        // reset ttl for client and
        client_state.alive = true;
        // set addr as new default for this client
        client_state.active_addr = Some(addr);
    }
    match (event, addr) {
        (Event::Pong(), _) => { /* ignore pong events */ }
        (Event::Ping(), addr) => {
@@ -177,22 +148,30 @@ async fn handle_udp_rx(
                    }
                }
                State::Receiving => {
-                    let ignore_event =
+                    let mut ignore_event = false;
-                        if let Event::Keyboard(KeyboardEvent::Key { key, state, .. }) = event {
+                    if let Event::Keyboard(KeyboardEvent::Key {
-                            let (ignore_event, restart_timer) = update_client_keys(
+                        time: _,
-                                &mut server.client_manager.borrow_mut(),
+                        key,
-                                handle,
+                        state,
-                                key,
+                    }) = event
-                                state,
+                    {
-                            );
+                        let mut client_manager = server.client_manager.borrow_mut();
-                            // restart timer if necessary
+                        let client_state = if let Some((_, s)) = client_manager.get_mut(handle) {
-                            if restart_timer {
+                            s
                                server.restart_ping_timer();
                            }
                            ignore_event
                        } else {
-                            false
+                            log::error!("unknown handle");
                            return Ok(());
                        };
                        if state == 0 {
                            // ignore release event if key not pressed
                            ignore_event = !client_state.pressed_keys.remove(&key);
                        } else {
                            // ignore press event if key not released
                            ignore_event = !client_state.pressed_keys.insert(key);
                            let _ = timer_tx.try_send(());
                        }
                    }
                    // ignore double press / release events to
                    // workaround buggy rdp backend.
                    if !ignore_event {
                        // consume event
@@ -224,22 +203,6 @@ async fn handle_udp_rx(
    Ok(())
 }
 async fn release_all_keys(
    server: &Server,
    emulation: &mut Box<dyn InputEmulation>,
 ) -> Result<(), EmulationError> {
    let clients = server
        .client_manager
        .borrow()
        .get_client_states()
        .map(|(h, _)| h)
        .collect::<Vec<_>>();
    for client in clients {
        release_keys(server, emulation, client).await?;
    }
    Ok(())
 }
 async fn release_keys(
    server: &Server,
    emulate: &mut Box<dyn InputEmulation>,
@@ -274,50 +237,3 @@ async fn release_keys(
    emulate.consume(event, client).await?;
    Ok(())
 }
 fn activate_client_if_exists(
    client_manager: &mut ClientManager,
    addr: SocketAddr,
    last_ignored: &mut Option<SocketAddr>,
 ) -> Option<ClientHandle> {
    let Some(handle) = client_manager.get_client(addr) else {
        // log ignored if it is the first event from the client in a series
        if last_ignored.is_none() || last_ignored.is_some() && last_ignored.unwrap() != addr {
            log::warn!("ignoring events from client {addr}");
            last_ignored.replace(addr);
        }
        return None;
    };
    // next event can be logged as ignored again
    last_ignored.take();
    let (_, client_state) = client_manager.get_mut(handle)?;
    // reset ttl for client
    client_state.alive = true;
    // set addr as new default for this client
    client_state.active_addr = Some(addr);
    Some(handle)
 }
 fn update_client_keys(
    client_manager: &mut ClientManager,
    handle: ClientHandle,
    key: u32,
    state: u8,
 ) -> (bool, bool) {
    let Some(client_state) = client_manager.get_mut(handle).map(|(_, s)| s) else {
        return (true, false);
    };
    // ignore double press / release events
    let ignore_event = if state == 0 {
        // ignore release event if key not pressed
        !client_state.pressed_keys.remove(&key)
    } else {
        // ignore press event if key not released
        !client_state.pressed_keys.insert(key)
    };
    let restart_timer = !client_state.pressed_keys.is_empty();
    (ignore_event, restart_timer)
 }
--- a/src/server/frontend_task.rs
+++ b/src/server/frontend_task.rs
@@ -0,0 +1,350 @@
 use std::{
    collections::HashSet,
    io::ErrorKind,
    net::{IpAddr, SocketAddr},
 };
 #[cfg(unix)]
 use tokio::net::UnixStream;
 #[cfg(windows)]
 use tokio::net::TcpStream;
 use anyhow::{anyhow, Result};
 use tokio::{
    io::ReadHalf,
    sync::mpsc::{Receiver, Sender},
    task::JoinHandle,
 };
 use crate::{
    client::{ClientHandle, Position},
    frontend::{self, FrontendEvent, FrontendListener, FrontendRequest},
 };
 use super::{
    capture_task::CaptureEvent, emulation_task::EmulationEvent, resolver_task::DnsRequest, Server,
 };
 pub(crate) fn new(
    mut frontend: FrontendListener,
    mut notify_rx: Receiver<FrontendEvent>,
    server: Server,
    capture: Sender<CaptureEvent>,
    emulate: Sender<EmulationEvent>,
    resolve_ch: Sender<DnsRequest>,
    port_tx: Sender<u16>,
 ) -> (JoinHandle<Result<()>>, Sender<FrontendRequest>) {
    let (event_tx, mut event_rx) = tokio::sync::mpsc::channel(32);
    let event_tx_clone = event_tx.clone();
    let frontend_task = tokio::task::spawn_local(async move {
        loop {
            tokio::select! {
                stream = frontend.accept() => {
                    let stream = match stream {
                        Ok(s) => s,
                        Err(e) => {
                            log::warn!("error accepting frontend connection: {e}");
                            continue;
                        }
                    };
                    handle_frontend_stream(&event_tx_clone, stream).await;
                }
                event = event_rx.recv() => {
                    let frontend_event = event.ok_or(anyhow!("frontend channel closed"))?;
                    if handle_frontend_event(&server, &capture, &emulate, &resolve_ch, &mut frontend, &port_tx, frontend_event).await {
                        break;
                    }
                }
                notify = notify_rx.recv() => {
                    let notify = notify.ok_or(anyhow!("frontend notify closed"))?;
                    let _ = frontend.broadcast_event(notify).await;
                }
            }
        }
        anyhow::Ok(())
    });
    (frontend_task, event_tx)
 }
 async fn handle_frontend_stream(
    frontend_tx: &Sender<FrontendRequest>,
    #[cfg(unix)] mut stream: ReadHalf<UnixStream>,
    #[cfg(windows)] mut stream: ReadHalf<TcpStream>,
 ) {
    use std::io;
    let tx = frontend_tx.clone();
    tokio::task::spawn_local(async move {
        loop {
            let request = frontend::wait_for_request(&mut stream).await;
            match request {
                Ok(request) => {
                    let _ = tx.send(request).await;
                }
                Err(e) => {
                    if let Some(e) = e.downcast_ref::<io::Error>() {
                        if e.kind() == ErrorKind::UnexpectedEof {
                            return;
                        }
                    }
                    log::error!("error reading frontend event: {e}");
                    return;
                }
            }
        }
    });
 }
 async fn handle_frontend_event(
    server: &Server,
    capture: &Sender<CaptureEvent>,
    emulate: &Sender<EmulationEvent>,
    resolve_tx: &Sender<DnsRequest>,
    frontend: &mut FrontendListener,
    port_tx: &Sender<u16>,
    event: FrontendRequest,
 ) -> bool {
    log::debug!("frontend: {event:?}");
    match event {
        FrontendRequest::Create => {
            let handle = 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;
            } else {
                deactivate_client(server, capture, emulate, handle).await;
            }
        }
        FrontendRequest::ChangePort(port) => {
            let _ = port_tx.send(port).await;
        }
        FrontendRequest::Delete(handle) => {
            remove_client(server, capture, emulate, handle).await;
            broadcast(frontend, FrontendEvent::Deleted(handle)).await;
        }
        FrontendRequest::Enumerate() => {
            let clients = server
                .client_manager
                .borrow()
                .get_client_states()
                .map(|(h, (c, s))| (h, c.clone(), s.clone()))
                .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;
            resolve_dns(server, resolve_tx, handle).await;
        }
        FrontendRequest::UpdateHostname(handle, hostname) => {
            update_hostname(server, resolve_tx, handle, hostname).await;
            resolve_dns(server, resolve_tx, handle).await;
        }
        FrontendRequest::UpdatePort(handle, port) => {
            update_port(server, handle, port).await;
        }
        FrontendRequest::UpdatePosition(handle, pos) => {
            update_pos(server, handle, capture, emulate, pos).await;
        }
        FrontendRequest::ResolveDns(handle) => {
            resolve_dns(server, resolve_tx, 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 {
    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,
    capture: &Sender<CaptureEvent>,
    emulate: &Sender<EmulationEvent>,
    handle: ClientHandle,
 ) {
    match server.client_manager.borrow_mut().get_mut(handle) {
        Some((_, s)) => {
            s.active = false;
        }
        None => return,
    };
    let _ = capture.send(CaptureEvent::Destroy(handle)).await;
    let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
 }
 pub async fn activate_client(
    server: &Server,
    capture: &Sender<CaptureEvent>,
    emulate: &Sender<EmulationEvent>,
    handle: ClientHandle,
 ) {
    /* deactivate potential other client at this position */
    let pos = match server.client_manager.borrow().get(handle) {
        Some((client, _)) => client.pos,
        None => return,
    };
    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;
        }
    }
    /* activate the client */
    if let Some((_, s)) = server.client_manager.borrow_mut().get_mut(handle) {
        s.active = true;
    } else {
        return;
    };
    /* notify emulation, capture and frontends */
    let _ = capture.send(CaptureEvent::Create(handle, pos.into())).await;
    let _ = emulate.send(EmulationEvent::Create(handle)).await;
 }
 pub async fn remove_client(
    server: &Server,
    capture: &Sender<CaptureEvent>,
    emulate: &Sender<EmulationEvent>,
    handle: ClientHandle,
 ) {
    let Some(active) = server
        .client_manager
        .borrow_mut()
        .remove_client(handle)
        .map(|(_, s)| s.active)
    else {
        return;
    };
    if active {
        let _ = capture.send(CaptureEvent::Destroy(handle)).await;
        let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
    }
 }
 async fn update_fix_ips(server: &Server, handle: ClientHandle, fix_ips: Vec<IpAddr>) {
    let mut client_manager = server.client_manager.borrow_mut();
    let Some((c, _)) = client_manager.get_mut(handle) else {
        return;
    };
    c.fix_ips = fix_ips;
 }
 async fn update_hostname(
    server: &Server,
    resolve_tx: &Sender<DnsRequest>,
    handle: ClientHandle,
    hostname: Option<String>,
 ) {
    let hostname = {
        let mut client_manager = server.client_manager.borrow_mut();
        let Some((c, s)) = client_manager.get_mut(handle) else {
            return;
        };
        // update hostname
        if c.hostname != hostname {
            c.hostname = hostname;
            s.ips = HashSet::from_iter(c.fix_ips.iter().cloned());
            s.active_addr = None;
            c.hostname.clone()
        } else {
            None
        }
    };
    // resolve to update ips in state
    if let Some(hostname) = hostname {
        let _ = resolve_tx.send(DnsRequest { hostname, handle }).await;
    }
 }
 async fn update_port(server: &Server, handle: ClientHandle, port: u16) {
    let mut client_manager = server.client_manager.borrow_mut();
    let Some((c, s)) = client_manager.get_mut(handle) else {
        return;
    };
    if c.port != port {
        c.port = port;
        s.active_addr = s.active_addr.map(|a| SocketAddr::new(a.ip(), port));
    }
 }
 async fn update_pos(
    server: &Server,
    handle: ClientHandle,
    capture: &Sender<CaptureEvent>,
    emulate: &Sender<EmulationEvent>,
    pos: Position,
 ) {
    let (changed, active) = {
        let mut client_manager = server.client_manager.borrow_mut();
        let Some((c, s)) = client_manager.get_mut(handle) else {
            return;
        };
        let changed = c.pos != pos;
        c.pos = pos;
        (changed, s.active)
    };
    // update state in event input emulator & input capture
    if changed {
        if active {
            let _ = capture.send(CaptureEvent::Destroy(handle)).await;
            let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
        }
        let _ = capture.send(CaptureEvent::Create(handle, pos.into())).await;
        let _ = emulate.send(EmulationEvent::Create(handle)).await;
    }
 }
 async fn broadcast_client(server: &Server, frontend: &mut FrontendListener, handle: ClientHandle) {
    let client = server.client_manager.borrow().get(handle).cloned();
    if let Some((config, state)) = client {
        broadcast(frontend, FrontendEvent::State(handle, config, state)).await;
    } else {
        broadcast(frontend, FrontendEvent::NoSuchClient(handle)).await;
    }
 }
--- a/src/server/network_task.rs
+++ b/src/server/network_task.rs
@@ -1,99 +1,87 @@
-use std::{io, net::SocketAddr};
+use std::net::SocketAddr;
-use thiserror::Error;
+use anyhow::Result;
 use tokio::{
    net::UdpSocket,
    sync::mpsc::{Receiver, Sender},
    task::JoinHandle,
 };
-use input_event::{Event, ProtocolError};
+use crate::frontend::FrontendEvent;
 use input_event::Event;
 use super::Server;
-pub(crate) async fn new(
+pub async fn new(
    server: Server,
-    udp_recv_tx: Sender<Result<(Event, SocketAddr), NetworkError>>,
+    frontend_notify_tx: Sender<FrontendEvent>,
-    udp_send_rx: Receiver<(Event, SocketAddr)>,
+) -> Result<(
-) -> io::Result<JoinHandle<()>> {
+    JoinHandle<()>,
    Sender<(Event, SocketAddr)>,
    Receiver<Result<(Event, SocketAddr)>>,
    Sender<u16>,
 )> {
    // bind the udp socket
    let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), server.port.get());
    let mut socket = UdpSocket::bind(listen_addr).await?;
    let (receiver_tx, receiver_rx) = tokio::sync::mpsc::channel(32);
    let (sender_tx, mut sender_rx) = tokio::sync::mpsc::channel(32);
    let (port_tx, mut port_rx) = tokio::sync::mpsc::channel(32);
-    Ok(tokio::task::spawn_local(async move {
+    let udp_task = tokio::task::spawn_local(async move {
        let mut sender_rx = udp_send_rx;
        loop {
            let udp_receiver = udp_receiver(&socket, &udp_recv_tx);
            let udp_sender = udp_sender(&socket, &mut sender_rx);
            tokio::select! {
-                _ = udp_receiver => break, /* channel closed */
+                event = receive_event(&socket) => {
-                _ = udp_sender => break, /* channel closed */
+                    let _ = receiver_tx.send(event).await;
-                _ = server.notifies.port_changed.notified() => update_port(&server, &mut socket).await,
+                }
-                _ = server.cancelled() => break, /* cancellation requested */
+                event = sender_rx.recv() => {
                    let Some((event, addr)) = event else {
                        break;
                    };
                    if let Err(e) = send_event(&socket, event, addr) {
                        log::warn!("udp send failed: {e}");
                    };
                }
                port = port_rx.recv() => {
                    let Some(port) = port else {
                        break;
                    };
                    if socket.local_addr().unwrap().port() == port {
                        continue;
                    }
                    let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), port);
                    match UdpSocket::bind(listen_addr).await {
                        Ok(new_socket) => {
                            socket = new_socket;
                            server.port.replace(port);
                            let _ = frontend_notify_tx.send(FrontendEvent::PortChanged(port, None)).await;
                        }
                        Err(e) => {
                            log::warn!("could not change port: {e}");
                            let port = socket.local_addr().unwrap().port();
                            let _ = frontend_notify_tx.send(FrontendEvent::PortChanged(
                                    port,
                                    Some(format!("could not change port: {e}")),
                                )).await;
                        }
                    }
                }
            }
        }
-    }))
+    });
    Ok((udp_task, sender_tx, receiver_rx, port_tx))
 }
-async fn update_port(server: &Server, socket: &mut UdpSocket) {
+async fn receive_event(socket: &UdpSocket) -> Result<(Event, SocketAddr)> {
    let new_port = server.port.get();
    let current_port = socket.local_addr().expect("socket not bound").port();
    // if port is the same, we dont need to change it
    if current_port == new_port {
        return;
    }
    // bind new socket
    let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), new_port);
    let new_socket = UdpSocket::bind(listen_addr).await;
    let err = match new_socket {
        Ok(new_socket) => {
            *socket = new_socket;
            None
        }
        Err(e) => Some(e.to_string()),
    };
    // notify frontend of the actual port
    let port = socket.local_addr().expect("socket not bound").port();
    server.notify_port_changed(port, err);
 }
 async fn udp_receiver(
    socket: &UdpSocket,
    receiver_tx: &Sender<Result<(Event, SocketAddr), NetworkError>>,
 ) {
    loop {
        let event = receive_event(socket).await;
        receiver_tx.send(event).await.expect("channel closed");
    }
 }
 async fn udp_sender(socket: &UdpSocket, rx: &mut Receiver<(Event, SocketAddr)>) {
    loop {
        let (event, addr) = rx.recv().await.expect("channel closed");
        if let Err(e) = send_event(socket, event, addr) {
            log::warn!("udp send failed: {e}");
        };
    }
 }
 #[derive(Debug, Error)]
 pub(crate) enum NetworkError {
    #[error(transparent)]
    Protocol(#[from] ProtocolError),
    #[error("network error: `{0}`")]
    Io(#[from] io::Error),
 }
 async fn receive_event(socket: &UdpSocket) -> Result<(Event, SocketAddr), NetworkError> {
    let mut buf = vec![0u8; 22];
    let (_amt, src) = socket.recv_from(&mut buf).await?;
    Ok((Event::try_from(buf)?, src))
 }
-fn send_event(sock: &UdpSocket, e: Event, addr: SocketAddr) -> Result<usize, NetworkError> {
+fn send_event(sock: &UdpSocket, e: Event, addr: SocketAddr) -> Result<usize> {
    log::trace!("{:20} ------>->->-> {addr}", e.to_string());
    let data: Vec<u8> = (&e).into();
    // When udp blocks, we dont want to block the event loop.
--- a/src/server/ping_task.rs
+++ b/src/server/ping_task.rs
@@ -1,6 +1,9 @@
 use std::{net::SocketAddr, time::Duration};
-use tokio::{sync::mpsc::Sender, task::JoinHandle};
+use tokio::{
    sync::mpsc::{Receiver, Sender},
    task::JoinHandle,
 };
 use input_event::Event;
@@ -10,129 +13,119 @@ use super::{capture_task::CaptureEvent, emulation_task::EmulationEvent, Server,
 const MAX_RESPONSE_TIME: Duration = Duration::from_millis(500);
-pub(crate) fn new(
+pub fn new(
    server: Server,
    sender_ch: Sender<(Event, SocketAddr)>,
    emulate_notify: Sender<EmulationEvent>,
    capture_notify: Sender<CaptureEvent>,
    mut timer_rx: Receiver<()>,
 ) -> JoinHandle<()> {
    // timer task
-    tokio::task::spawn_local(async move {
+    let ping_task = tokio::task::spawn_local(async move {
        tokio::select! {
            _ = server.notifies.cancel.cancelled() => {}
            _ = ping_task(&server, sender_ch, emulate_notify, capture_notify) => {}
        }
    })
 }
 async fn ping_task(
    server: &Server,
    sender_ch: Sender<(Event, SocketAddr)>,
    emulate_notify: Sender<EmulationEvent>,
    capture_notify: Sender<CaptureEvent>,
 ) {
    loop {
        // wait for wake up signal
        server.ping_timer_notified().await;
        loop {
-            let receiving = server.state.get() == State::Receiving;
+            // wait for wake up signal
-            let (ping_clients, ping_addrs) = {
+            let Some(_): Option<()> = timer_rx.recv().await else {
-                let mut client_manager = server.client_manager.borrow_mut();
+                break;
            };
            loop {
                let receiving = server.state.get() == State::Receiving;
                let (ping_clients, ping_addrs) = {
                    let mut client_manager = server.client_manager.borrow_mut();
-                let ping_clients: Vec<ClientHandle> = if receiving {
+                    let ping_clients: Vec<ClientHandle> = if receiving {
-                    // if receiving we care about clients with pressed keys
+                        // if receiving we care about clients with pressed keys
-                    client_manager
+                        client_manager
-                        .get_client_states_mut()
+                            .get_client_states_mut()
-                        .filter(|(_, (_, s))| !s.pressed_keys.is_empty())
+                            .filter(|(_, (_, s))| !s.pressed_keys.is_empty())
-                        .map(|(h, _)| h)
+                            .map(|(h, _)| h)
-                        .collect()
+                            .collect()
-                } else {
+                    } else {
-                    // if sending we care about the active client
+                        // if sending we care about the active client
-                    server.active_client.get().iter().cloned().collect()
+                        server.active_client.get().iter().cloned().collect()
                    };
                    // get relevant socket addrs for clients
                    let ping_addrs: Vec<SocketAddr> = {
                        ping_clients
                            .iter()
                            .flat_map(|&h| client_manager.get(h))
                            .flat_map(|(c, s)| {
                                if s.alive && s.active_addr.is_some() {
                                    vec![s.active_addr.unwrap()]
                                } else {
                                    s.ips
                                        .iter()
                                        .cloned()
                                        .map(|ip| SocketAddr::new(ip, c.port))
                                        .collect()
                                }
                            })
                            .collect()
                    };
                    // reset alive
                    for (_, (_, s)) in client_manager.get_client_states_mut() {
                        s.alive = false;
                    }
                    (ping_clients, ping_addrs)
                };
-                // get relevant socket addrs for clients
+                if receiving && ping_clients.is_empty() {
-                let ping_addrs: Vec<SocketAddr> = {
+                    // receiving and no client has pressed keys
                    // -> no need to keep pinging
                    break;
                }
                // ping clients
                for addr in ping_addrs {
                    if sender_ch.send((Event::Ping(), addr)).await.is_err() {
                        break;
                    }
                }
                // give clients time to resond
                if receiving {
                    log::trace!("waiting {MAX_RESPONSE_TIME:?} for response from client with pressed keys ...");
                } else {
                    log::trace!(
                        "state: {:?} => waiting {MAX_RESPONSE_TIME:?} for client to respond ...",
                        server.state.get()
                    );
                }
                tokio::time::sleep(MAX_RESPONSE_TIME).await;
                // when anything is received from a client,
                // the alive flag gets set
                let unresponsive_clients: Vec<_> = {
                    let client_manager = server.client_manager.borrow();
                    ping_clients
                        .iter()
-                        .flat_map(|&h| client_manager.get(h))
+                        .filter_map(|&h| match client_manager.get(h) {
-                        .flat_map(|(c, s)| {
+                            Some((_, s)) if !s.alive => Some(h),
-                            if s.alive && s.active_addr.is_some() {
+                            _ => None,
                                vec![s.active_addr.unwrap()]
                            } else {
                                s.ips
                                    .iter()
                                    .cloned()
                                    .map(|ip| SocketAddr::new(ip, c.port))
                                    .collect()
                            }
                        })
                        .collect()
                };
-                // reset alive
+                // we may not be receiving anymore but we should respond
-                for (_, (_, s)) in client_manager.get_client_states_mut() {
+                // to the original state and not the "new" one
-                    s.alive = false;
+                if receiving {
-                }
+                    for h in unresponsive_clients {
-
+                        log::warn!("device not responding, releasing keys!");
-                (ping_clients, ping_addrs)
+                        let _ = emulate_notify.send(EmulationEvent::ReleaseKeys(h)).await;
-            };
+                    }
-
+                } else {
-            if receiving && ping_clients.is_empty() {
+                    // release pointer if the active client has not responded
-                // receiving and no client has pressed keys
+                    if !unresponsive_clients.is_empty() {
-                // -> no need to keep pinging
+                        log::warn!("client not responding, releasing pointer!");
-                break;
+                        server.state.replace(State::Receiving);
-            }
+                        let _ = capture_notify.send(CaptureEvent::Release).await;
-
+                    }
            // ping clients
            for addr in ping_addrs {
                if sender_ch.send((Event::Ping(), addr)).await.is_err() {
                    break;
                }
            }
            // give clients time to resond
            if receiving {
                log::trace!(
                    "waiting {MAX_RESPONSE_TIME:?} for response from client with pressed keys ..."
                );
            } else {
                log::trace!(
                    "state: {:?} => waiting {MAX_RESPONSE_TIME:?} for client to respond ...",
                    server.state.get()
                );
            }
            tokio::time::sleep(MAX_RESPONSE_TIME).await;
            // when anything is received from a client,
            // the alive flag gets set
            let unresponsive_clients: Vec<_> = {
                let client_manager = server.client_manager.borrow();
                ping_clients
                    .iter()
                    .filter_map(|&h| match client_manager.get(h) {
                        Some((_, s)) if !s.alive => Some(h),
                        _ => None,
                    })
                    .collect()
            };
            // we may not be receiving anymore but we should respond
            // to the original state and not the "new" one
            if receiving {
                for h in unresponsive_clients {
                    log::warn!("device not responding, releasing keys!");
                    let _ = emulate_notify.send(EmulationEvent::ReleaseKeys(h)).await;
                }
            } else {
                // release pointer if the active client has not responded
                if !unresponsive_clients.is_empty() {
                    log::warn!("client not responding, releasing pointer!");
                    server.state.replace(State::Receiving);
                    let _ = capture_notify.send(CaptureEvent::Release).await;
                }
            }
        }
-    }
+    });
    ping_task
 }
--- a/src/server/resolver_task.rs
+++ b/src/server/resolver_task.rs
@@ -0,0 +1,68 @@
 use std::collections::HashSet;
 use tokio::{sync::mpsc::Sender, task::JoinHandle};
 use crate::{client::ClientHandle, dns::DnsResolver, frontend::FrontendEvent};
 use super::Server;
 #[derive(Clone)]
 pub struct DnsRequest {
    pub hostname: String,
    pub handle: ClientHandle,
 }
 pub fn new(
    resolver: DnsResolver,
    mut server: Server,
    mut frontend: Sender<FrontendEvent>,
 ) -> (JoinHandle<()>, Sender<DnsRequest>) {
    let (dns_tx, mut dns_rx) = tokio::sync::mpsc::channel::<DnsRequest>(32);
    let resolver_task = tokio::task::spawn_local(async move {
        loop {
            let (host, handle) = match dns_rx.recv().await {
                Some(r) => (r.hostname, r.handle),
                None => break,
            };
            /* update resolving status */
            if let Some((_, s)) = server.client_manager.borrow_mut().get_mut(handle) {
                s.resolving = true;
            }
            notify_state_change(&mut frontend, &mut server, handle).await;
            let ips = match resolver.resolve(&host).await {
                Ok(ips) => ips,
                Err(e) => {
                    log::warn!("could not resolve host '{host}': {e}");
                    vec![]
                }
            };
            /* update ips and resolving state */
            if let Some((c, s)) = server.client_manager.borrow_mut().get_mut(handle) {
                let mut addrs = HashSet::from_iter(c.fix_ips.iter().cloned());
                for ip in ips {
                    addrs.insert(ip);
                }
                s.ips = addrs;
                s.resolving = false;
            }
            notify_state_change(&mut frontend, &mut server, handle).await;
        }
    });
    (resolver_task, dns_tx)
 }
 async fn notify_state_change(
    frontend: &mut Sender<FrontendEvent>,
    server: &mut Server,
    handle: ClientHandle,
 ) {
    let state = server.client_manager.borrow_mut().get_mut(handle).cloned();
    if let Some((config, state)) = state {
        let _ = frontend
            .send(FrontendEvent::State(handle, config, state))
            .await;
    }
 }
Author	SHA1	Message	Date
Ferdinand Schober	09f08f1798	fix drop impl for desktop-portal	2024-07-05 00:31:16 +02:00
Ferdinand Schober	f97621e987	adjust error handling	2024-07-04 23:44:32 +02:00
Ferdinand Schober	b3aa3f4281	remove dispatch workaround	2024-07-04 22:40:05 +02:00